Merge branch 'assignment_v2/migrations' into wip/assignment-import

spec/services/twilio/incoming_message_service_spec.rb

@@ -327,6 +327,81 @@ describe Twilio::IncomingMessageService do
         contact = twilio_channel.inbox.contacts.find_by(phone_number: '+1234567890')
         expect(contact.name).to eq('1234567890')
       end
+
+      it 'updates existing contact name when current name matches phone number' do
+        # Create contact with phone number as name
+        existing_contact = create(:contact,
+                                  account: twilio_channel.inbox.account,
+                                  name: '+1234567890',
+                                  phone_number: '+1234567890')
+        create(:contact_inbox,
+               contact: existing_contact,
+               inbox: twilio_channel.inbox,
+               source_id: '+1234567890')
+
+        params = {
+          SmsSid: 'SMxx',
+          From: '+1234567890',
+          AccountSid: 'ACxxx',
+          MessagingServiceSid: twilio_channel.messaging_service_sid,
+          Body: 'Hello',
+          ProfileName: 'Jane Smith'
+        }
+
+        described_class.new(params: params).perform
+        existing_contact.reload
+        expect(existing_contact.name).to eq('Jane Smith')
+      end
+
+      it 'does not update contact name when current name is different from phone number' do
+        # Create contact with human name
+        existing_contact = create(:contact,
+                                  account: twilio_channel.inbox.account,
+                                  name: 'John Doe',
+                                  phone_number: '+1234567890')
+        create(:contact_inbox,
+               contact: existing_contact,
+               inbox: twilio_channel.inbox,
+               source_id: '+1234567890')
+
+        params = {
+          SmsSid: 'SMxx',
+          From: '+1234567890',
+          AccountSid: 'ACxxx',
+          MessagingServiceSid: twilio_channel.messaging_service_sid,
+          Body: 'Hello',
+          ProfileName: 'Jane Smith'
+        }
+
+        described_class.new(params: params).perform
+        existing_contact.reload
+        expect(existing_contact.name).to eq('John Doe') # Should not change
+      end
+
+      it 'updates contact name when current name matches formatted phone number' do
+        # Create contact with formatted phone number as name
+        existing_contact = create(:contact,
+                                  account: twilio_channel.inbox.account,
+                                  name: '1234567890',
+                                  phone_number: '+1234567890')
+        create(:contact_inbox,
+               contact: existing_contact,
+               inbox: twilio_channel.inbox,
+               source_id: '+1234567890')
+
+        params = {
+          SmsSid: 'SMxx',
+          From: '+1234567890',
+          AccountSid: 'ACxxx',
+          MessagingServiceSid: twilio_channel.messaging_service_sid,
+          Body: 'Hello',
+          ProfileName: 'Alice Johnson'
+        }
+
+        described_class.new(params: params).perform
+        existing_contact.reload
+        expect(existing_contact.name).to eq('Alice Johnson')
+      end
     end
   end
 end

spec/services/whatsapp/embedded_signup_service_spec.rb

@@ -2,17 +2,18 @@ require 'rails_helper'
 
 describe Whatsapp::EmbeddedSignupService do
   let(:account) { create(:account) }
-  let(:code) { 'test_authorization_code' }
-  let(:business_id) { 'test_business_id' }
-  let(:waba_id) { 'test_waba_id' }
-  let(:phone_number_id) { 'test_phone_number_id' }
+  let(:params) do
+    {
+      code: 'test_authorization_code',
+      business_id: 'test_business_id',
+      waba_id: 'test_waba_id',
+      phone_number_id: 'test_phone_number_id'
+    }
+  end
   let(:service) do
     described_class.new(
       account: account,
-      code: code,
-      business_id: business_id,
-      waba_id: waba_id,
-      phone_number_id: phone_number_id
+      params: params
     )
   end
 
@@ -20,37 +21,40 @@ describe Whatsapp::EmbeddedSignupService do
     let(:access_token) { 'test_access_token' }
     let(:phone_info) do
       {
-        phone_number_id: phone_number_id,
+        phone_number_id: params[:phone_number_id],
         phone_number: '+1234567890',
         verified: true,
         business_name: 'Test Business'
       }
     end
     let(:channel) { instance_double(Channel::Whatsapp) }
-
-    let(:token_exchange_service) { instance_double(Whatsapp::TokenExchangeService) }
-    let(:phone_info_service) { instance_double(Whatsapp::PhoneInfoService) }
-    let(:token_validation_service) { instance_double(Whatsapp::TokenValidationService) }
-    let(:channel_creation_service) { instance_double(Whatsapp::ChannelCreationService) }
+    let(:service_doubles) do
+      {
+        token_exchange: instance_double(Whatsapp::TokenExchangeService),
+        phone_info: instance_double(Whatsapp::PhoneInfoService),
+        token_validation: instance_double(Whatsapp::TokenValidationService),
+        channel_creation: instance_double(Whatsapp::ChannelCreationService)
+      }
+    end
 
     before do
       allow(GlobalConfig).to receive(:clear_cache)
 
-      allow(Whatsapp::TokenExchangeService).to receive(:new).with(code).and_return(token_exchange_service)
-      allow(token_exchange_service).to receive(:perform).and_return(access_token)
+      allow(Whatsapp::TokenExchangeService).to receive(:new).with(params[:code]).and_return(service_doubles[:token_exchange])
+      allow(service_doubles[:token_exchange]).to receive(:perform).and_return(access_token)
 
       allow(Whatsapp::PhoneInfoService).to receive(:new)
-        .with(waba_id, phone_number_id, access_token).and_return(phone_info_service)
-      allow(phone_info_service).to receive(:perform).and_return(phone_info)
+        .with(params[:waba_id], params[:phone_number_id], access_token).and_return(service_doubles[:phone_info])
+      allow(service_doubles[:phone_info]).to receive(:perform).and_return(phone_info)
 
       allow(Whatsapp::TokenValidationService).to receive(:new)
-        .with(access_token, waba_id).and_return(token_validation_service)
-      allow(token_validation_service).to receive(:perform)
+        .with(access_token, params[:waba_id]).and_return(service_doubles[:token_validation])
+      allow(service_doubles[:token_validation]).to receive(:perform)
 
       allow(Whatsapp::ChannelCreationService).to receive(:new)
-        .with(account, { waba_id: waba_id, business_name: 'Test Business' }, phone_info, access_token)
-        .and_return(channel_creation_service)
-      allow(channel_creation_service).to receive(:perform).and_return(channel)
+        .with(account, { waba_id: params[:waba_id], business_name: 'Test Business' }, phone_info, access_token)
+        .and_return(service_doubles[:channel_creation])
+      allow(service_doubles[:channel_creation]).to receive(:perform).and_return(channel)
 
       # Webhook setup is now handled in the channel after_create callback
       # So we stub it at the model level
@@ -60,10 +64,10 @@ describe Whatsapp::EmbeddedSignupService do
     end
 
     it 'orchestrates all services in the correct order' do
-      expect(token_exchange_service).to receive(:perform).ordered
-      expect(phone_info_service).to receive(:perform).ordered
-      expect(token_validation_service).to receive(:perform).ordered
-      expect(channel_creation_service).to receive(:perform).ordered
+      expect(service_doubles[:token_exchange]).to receive(:perform).ordered
+      expect(service_doubles[:phone_info]).to receive(:perform).ordered
+      expect(service_doubles[:token_validation]).to receive(:perform).ordered
+      expect(service_doubles[:channel_creation]).to receive(:perform).ordered
 
       result = service.perform
       expect(result).to eq(channel)
@@ -73,10 +77,7 @@ describe Whatsapp::EmbeddedSignupService do
       it 'raises error when code is blank' do
         service = described_class.new(
           account: account,
-          code: '',
-          business_id: business_id,
-          waba_id: waba_id,
-          phone_number_id: phone_number_id
+          params: params.merge(code: '')
         )
         expect { service.perform }.to raise_error(ArgumentError, /Required parameters are missing: code/)
       end
@@ -84,10 +85,7 @@ describe Whatsapp::EmbeddedSignupService do
       it 'raises error when business_id is blank' do
         service = described_class.new(
           account: account,
-          code: code,
-          business_id: '',
-          waba_id: waba_id,
-          phone_number_id: phone_number_id
+          params: params.merge(business_id: '')
         )
         expect { service.perform }.to raise_error(ArgumentError, /Required parameters are missing: business_id/)
       end
@@ -95,10 +93,7 @@ describe Whatsapp::EmbeddedSignupService do
       it 'raises error when waba_id is blank' do
         service = described_class.new(
           account: account,
-          code: code,
-          business_id: business_id,
-          waba_id: '',
-          phone_number_id: phone_number_id
+          params: params.merge(waba_id: '')
         )
         expect { service.perform }.to raise_error(ArgumentError, /Required parameters are missing: waba_id/)
       end
@@ -106,10 +101,7 @@ describe Whatsapp::EmbeddedSignupService do
       it 'raises error when multiple parameters are blank' do
         service = described_class.new(
           account: account,
-          code: '',
-          business_id: '',
-          waba_id: waba_id,
-          phone_number_id: phone_number_id
+          params: params.merge(code: '', business_id: '')
         )
         expect { service.perform }.to raise_error(ArgumentError, /Required parameters are missing: code, business_id/)
       end
@@ -117,11 +109,44 @@ describe Whatsapp::EmbeddedSignupService do
 
     context 'when any service fails' do
       it 'logs and re-raises the error' do
-        allow(token_exchange_service).to receive(:perform).and_raise('Token error')
+        allow(service_doubles[:token_exchange]).to receive(:perform).and_raise('Token error')
 
         expect(Rails.logger).to receive(:error).with('[WHATSAPP] Embedded signup failed: Token error')
         expect { service.perform }.to raise_error('Token error')
       end
     end
+
+    context 'when inbox_id is provided (reauthorization flow)' do
+      let(:inbox_id) { 123 }
+      let(:reauth_service) { instance_double(Whatsapp::ReauthorizationService) }
+      let(:service_with_inbox) do
+        described_class.new(
+          account: account,
+          params: params,
+          inbox_id: inbox_id
+        )
+      end
+
+      before do
+        allow(Whatsapp::ReauthorizationService).to receive(:new).with(
+          account: account,
+          inbox_id: inbox_id,
+          phone_number_id: params[:phone_number_id],
+          business_id: params[:business_id]
+        ).and_return(reauth_service)
+        allow(reauth_service).to receive(:perform).with(access_token, phone_info).and_return(channel)
+      end
+
+      it 'uses ReauthorizationService instead of ChannelCreationService' do
+        expect(service_doubles[:token_exchange]).to receive(:perform).ordered
+        expect(service_doubles[:phone_info]).to receive(:perform).ordered
+        expect(service_doubles[:token_validation]).to receive(:perform).ordered
+        expect(reauth_service).to receive(:perform).with(access_token, phone_info).ordered
+        expect(service_doubles[:channel_creation]).not_to receive(:perform)
+
+        result = service_with_inbox.perform
+        expect(result).to eq(channel)
+      end
+    end
   end
 end

spec/services/whatsapp/webhook_setup_service_spec.rb

@@ -24,25 +24,19 @@ describe Whatsapp::WebhookSetupService do
   end
 
   describe '#perform' do
-    context 'when all operations succeed' do
+    context 'when phone number is NOT verified (should register)' do
       before do
+        allow(api_client).to receive(:phone_number_verified?).with('123456789').and_return(false)
         allow(SecureRandom).to receive(:random_number).with(900_000).and_return(123_456)
         allow(api_client).to receive(:register_phone_number).with('123456789', 223_456)
         allow(api_client).to receive(:subscribe_waba_webhook)
-          .with(waba_id, anything, 'test_verify_token')
-          .and_return({ 'success' => true })
+          .with(waba_id, anything, 'test_verify_token').and_return({ 'success' => true })
         allow(channel).to receive(:save!)
       end
 
-      it 'registers the phone number' do
+      it 'registers the phone number and sets up webhook' do
         with_modified_env FRONTEND_URL: 'https://app.chatwoot.com' do
           expect(api_client).to receive(:register_phone_number).with('123456789', 223_456)
-          service.perform
-        end
-      end
-
-      it 'sets up webhook subscription' do
-        with_modified_env FRONTEND_URL: 'https://app.chatwoot.com' do
           expect(api_client).to receive(:subscribe_waba_webhook)
             .with(waba_id, 'https://app.chatwoot.com/webhooks/whatsapp/+1234567890', 'test_verify_token')
           service.perform
@@ -50,33 +44,71 @@ describe Whatsapp::WebhookSetupService do
       end
     end
 
-    context 'when phone registration fails' do
+    context 'when phone number IS verified (should NOT register)' do
       before do
-        allow(SecureRandom).to receive(:random_number).with(900_000).and_return(123_456)
-        allow(api_client).to receive(:register_phone_number)
-          .and_raise('Registration failed')
+        allow(api_client).to receive(:phone_number_verified?).with('123456789').and_return(true)
         allow(api_client).to receive(:subscribe_waba_webhook)
-          .and_return({ 'success' => true })
+          .with(waba_id, anything, 'test_verify_token').and_return({ 'success' => true })
       end
 
-      it 'continues with webhook setup' do
+      it 'does NOT register phone, but sets up webhook' do
         with_modified_env FRONTEND_URL: 'https://app.chatwoot.com' do
+          expect(api_client).not_to receive(:register_phone_number)
+          expect(api_client).to receive(:subscribe_waba_webhook)
+            .with(waba_id, 'https://app.chatwoot.com/webhooks/whatsapp/+1234567890', 'test_verify_token')
+          service.perform
+        end
+      end
+    end
+
+    context 'when phone_number_verified? raises error' do
+      before do
+        allow(api_client).to receive(:phone_number_verified?).with('123456789').and_raise('API down')
+        allow(SecureRandom).to receive(:random_number).with(900_000).and_return(123_456)
+        allow(api_client).to receive(:register_phone_number)
+        allow(api_client).to receive(:subscribe_waba_webhook).and_return({ 'success' => true })
+        allow(channel).to receive(:save!)
+      end
+
+      it 'tries to register phone and proceeds with webhook setup' do
+        with_modified_env FRONTEND_URL: 'https://app.chatwoot.com' do
+          expect(api_client).to receive(:register_phone_number)
           expect(api_client).to receive(:subscribe_waba_webhook)
           expect { service.perform }.not_to raise_error
         end
       end
     end
 
-    context 'when webhook setup fails' do
+    context 'when phone registration fails (not blocking)' do
       before do
+        allow(api_client).to receive(:phone_number_verified?).with('123456789').and_return(false)
+        allow(SecureRandom).to receive(:random_number).with(900_000).and_return(123_456)
+        allow(api_client).to receive(:register_phone_number).and_raise('Registration failed')
+        allow(api_client).to receive(:subscribe_waba_webhook).and_return({ 'success' => true })
+        allow(channel).to receive(:save!)
+      end
+
+      it 'continues with webhook setup even if registration fails' do
+        with_modified_env FRONTEND_URL: 'https://app.chatwoot.com' do
+          expect(api_client).to receive(:register_phone_number)
+          expect(api_client).to receive(:subscribe_waba_webhook)
+          expect { service.perform }.not_to raise_error
+        end
+      end
+    end
+
+    context 'when webhook setup fails (should raise)' do
+      before do
+        allow(api_client).to receive(:phone_number_verified?).with('123456789').and_return(false)
         allow(SecureRandom).to receive(:random_number).with(900_000).and_return(123_456)
         allow(api_client).to receive(:register_phone_number)
-        allow(api_client).to receive(:subscribe_waba_webhook)
-          .and_raise('Webhook failed')
+        allow(api_client).to receive(:subscribe_waba_webhook).and_raise('Webhook failed')
       end
 
       it 'raises an error' do
         with_modified_env FRONTEND_URL: 'https://app.chatwoot.com' do
+          expect(api_client).to receive(:register_phone_number)
+          expect(api_client).to receive(:subscribe_waba_webhook)
           expect { service.perform }.to raise_error(/Webhook setup failed/)
         end
       end
@@ -84,24 +116,25 @@ describe Whatsapp::WebhookSetupService do
 
     context 'when required parameters are missing' do
       it 'raises error when channel is nil' do
-        service = described_class.new(nil, waba_id, access_token)
-        expect { service.perform }.to raise_error(ArgumentError, 'Channel is required')
+        service_invalid = described_class.new(nil, waba_id, access_token)
+        expect { service_invalid.perform }.to raise_error(ArgumentError, 'Channel is required')
       end
 
       it 'raises error when waba_id is blank' do
-        service = described_class.new(channel, '', access_token)
-        expect { service.perform }.to raise_error(ArgumentError, 'WABA ID is required')
+        service_invalid = described_class.new(channel, '', access_token)
+        expect { service_invalid.perform }.to raise_error(ArgumentError, 'WABA ID is required')
       end
 
       it 'raises error when access_token is blank' do
-        service = described_class.new(channel, waba_id, '')
-        expect { service.perform }.to raise_error(ArgumentError, 'Access token is required')
+        service_invalid = described_class.new(channel, waba_id, '')
+        expect { service_invalid.perform }.to raise_error(ArgumentError, 'Access token is required')
       end
     end
 
     context 'when PIN already exists' do
       before do
         channel.provider_config['verification_pin'] = 123_456
+        allow(api_client).to receive(:phone_number_verified?).with('123456789').and_return(false)
         allow(api_client).to receive(:register_phone_number)
         allow(api_client).to receive(:subscribe_waba_webhook).and_return({ 'success' => true })
         allow(channel).to receive(:save!)

spec/services/whatsapp/webhook_teardown_service_spec.rb

@@ -7,6 +7,9 @@ RSpec.describe Whatsapp::WebhookTeardownService do
 
     context 'when channel is whatsapp_cloud with embedded_signup' do
       before do
+        # Stub webhook setup to prevent HTTP calls during channel update
+        allow(channel).to receive(:setup_webhooks).and_return(true)
+
         channel.update!(
           provider: 'whatsapp_cloud',
           provider_config: {