chatwoot/spec/builders/conversation_builder_spec.rb

require 'rails_helper'

describe ConversationBuilder do
  let(:account) { create(:account) }
  let!(:sms_channel) { create(:channel_sms, account: account) }
  let!(:api_channel) { create(:channel_api, account: account) }
  let!(:sms_inbox) { create(:inbox, channel: sms_channel, account: account) }
  let!(:api_inbox) { create(:inbox, channel: api_channel, account: account) }
  let(:contact) { create(:contact, account: account) }
  let(:contact_sms_inbox) { create(:contact_inbox, contact: contact, inbox: sms_inbox) }
  let(:contact_api_inbox) { create(:contact_inbox, contact: contact, inbox: api_inbox) }

  describe '#perform' do
    it 'creates sms conversation' do
      conversation = described_class.new(
        contact_inbox: contact_sms_inbox,
        params: {}
      ).perform

      expect(conversation.contact_inbox_id).to eq(contact_sms_inbox.id)
    end

    it 'creates api conversation' do
      conversation = described_class.new(
        contact_inbox: contact_api_inbox,
        params: {}
      ).perform

      expect(conversation.contact_inbox_id).to eq(contact_api_inbox.id)
    end

    context 'when lock_to_single_conversation is true for sms inbox' do
      before do
        sms_inbox.update!(lock_to_single_conversation: true)
      end

      it 'creates sms conversation when existing conversation is not present' do
        conversation = described_class.new(
          contact_inbox: contact_sms_inbox,
          params: {}
        ).perform

        expect(conversation.contact_inbox_id).to eq(contact_sms_inbox.id)
      end

      it 'returns last from existing sms conversations when existing conversation is not present' do
        create(:conversation, contact_inbox: contact_sms_inbox)
        existing_conversation = create(:conversation, contact_inbox: contact_sms_inbox)
        conversation = described_class.new(
          contact_inbox: contact_sms_inbox,
          params: {}
        ).perform

        expect(conversation.id).to eq(existing_conversation.id)
      end
    end

    context 'when lock_to_single_conversation is true for api inbox' do
      before do
        api_inbox.update!(lock_to_single_conversation: true)
      end

      it 'creates conversation when existing api conversation is not present' do
        conversation = described_class.new(
          contact_inbox: contact_api_inbox,
          params: {}
        ).perform

        expect(conversation.contact_inbox_id).to eq(contact_api_inbox.id)
      end

      it 'returns last from existing api conversations when existing conversation is not present' do
        create(:conversation, contact_inbox: contact_api_inbox)
        existing_conversation = create(:conversation, contact_inbox: contact_api_inbox)
        conversation = described_class.new(
          contact_inbox: contact_api_inbox,
          params: {}
        ).perform

        expect(conversation.id).to eq(existing_conversation.id)
      end
    end

    context 'when status is provided in params' do
      it 'sets the status to the provided value' do
        conversation = described_class.new(
          contact_inbox: contact_api_inbox,
          params: { status: 'open' }
        ).perform

        expect(conversation.status).to eq('open')
      end

      it 'overrides bot status when status is explicitly provided' do
        # Create a bot for the inbox
        create(:agent_bot, account: account)
        create(:agent_bot_inbox, inbox: api_inbox, account: account)

        conversation = described_class.new(
          contact_inbox: contact_api_inbox,
          params: { status: 'open' }
        ).perform

        expect(conversation.status).to eq('open')
      end

      it 'sets status to resolved when explicitly provided' do
        conversation = described_class.new(
          contact_inbox: contact_api_inbox,
          params: { status: 'resolved' }
        ).perform

        expect(conversation.status).to eq('resolved')
      end
    end

    context 'when no status is provided and bot is active' do
      it 'sets status to pending for bot conversations' do
        # Create a bot for the inbox
        create(:agent_bot, account: account)
        create(:agent_bot_inbox, inbox: api_inbox, account: account)

        conversation = described_class.new(
          contact_inbox: contact_api_inbox,
          params: {}
        ).perform

        expect(conversation.status).to eq('pending')
      end
    end

    context 'when no status is provided and no bot is active' do
      it 'uses default status from model' do
        conversation = described_class.new(
          contact_inbox: contact_api_inbox,
          params: {}
        ).perform

        expect(conversation.status).to eq('open')
      end
    end
  end
end