Initial commit: Add logistics and order_detail message types

- Add Logistics component with progress tracking
- Add OrderDetail component for order information
- Support data-driven steps and actions
- Add blue color scale to widget SCSS
- Fix node overflow and progress bar rendering issues
- Add English translations for dashboard components

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

spec/services/whatsapp/providers/whatsapp_cloud_service_spec.rb

@@ -0,0 +1,403 @@
+require 'rails_helper'
+
+describe Whatsapp::Providers::WhatsappCloudService do
+  subject(:service) { described_class.new(whatsapp_channel: whatsapp_channel) }
+
+  let(:conversation) { create(:conversation, inbox: whatsapp_channel.inbox) }
+  let(:whatsapp_channel) { create(:channel_whatsapp, provider: 'whatsapp_cloud', validate_provider_config: false, sync_templates: false) }
+
+  let(:message) do
+    create(:message, conversation: conversation, message_type: :outgoing, content: 'test', inbox: whatsapp_channel.inbox, source_id: 'external_id')
+  end
+
+  let(:message_with_reply) do
+    create(:message, conversation: conversation, message_type: :outgoing, content: 'reply', inbox: whatsapp_channel.inbox,
+                     content_attributes: { in_reply_to: message.id })
+  end
+
+  let(:response_headers) { { 'Content-Type' => 'application/json' } }
+  let(:whatsapp_response) { { messages: [{ id: 'message_id' }] } }
+
+  before do
+    stub_request(:get, 'https://graph.facebook.com/v14.0/123456789/message_templates?access_token=test_key')
+  end
+
+  describe '#send_message' do
+    context 'when called' do
+      it 'calls message endpoints for normal messages' do
+        stub_request(:post, 'https://graph.facebook.com/v13.0/123456789/messages')
+          .with(
+            body: {
+              messaging_product: 'whatsapp',
+              context: nil,
+              to: '+123456789',
+              text: { body: message.content },
+              type: 'text'
+            }.to_json
+          )
+          .to_return(status: 200, body: whatsapp_response.to_json, headers: response_headers)
+        expect(service.send_message('+123456789', message)).to eq 'message_id'
+      end
+
+      it 'calls message endpoints for a reply to messages' do
+        stub_request(:post, 'https://graph.facebook.com/v13.0/123456789/messages')
+          .with(
+            body: {
+              messaging_product: 'whatsapp',
+              context: {
+                message_id: message.source_id
+              },
+              to: '+123456789',
+              text: { body: message_with_reply.content },
+              type: 'text'
+            }.to_json
+          )
+          .to_return(status: 200, body: whatsapp_response.to_json, headers: response_headers)
+        expect(service.send_message('+123456789', message_with_reply)).to eq 'message_id'
+      end
+
+      it 'calls message endpoints for image attachment message messages' do
+        attachment = message.attachments.new(account_id: message.account_id, file_type: :image)
+        attachment.file.attach(io: Rails.root.join('spec/assets/avatar.png').open, filename: 'avatar.png', content_type: 'image/png')
+
+        stub_request(:post, 'https://graph.facebook.com/v13.0/123456789/messages')
+          .with(
+            body: hash_including({
+                                   messaging_product: 'whatsapp',
+                                   to: '+123456789',
+                                   type: 'image',
+                                   image: WebMock::API.hash_including({ caption: message.content, link: anything })
+                                 })
+          )
+          .to_return(status: 200, body: whatsapp_response.to_json, headers: response_headers)
+        expect(service.send_message('+123456789', message)).to eq 'message_id'
+      end
+
+      it 'calls message endpoints for document attachment message messages' do
+        attachment = message.attachments.new(account_id: message.account_id, file_type: :file)
+        attachment.file.attach(io: Rails.root.join('spec/assets/sample.pdf').open, filename: 'sample.pdf', content_type: 'application/pdf')
+
+        # ref: https://github.com/bblimke/webmock/issues/900
+        # reason for Webmock::API.hash_including
+        stub_request(:post, 'https://graph.facebook.com/v13.0/123456789/messages')
+          .with(
+            body: hash_including({
+                                   messaging_product: 'whatsapp',
+                                   to: '+123456789',
+                                   type: 'document',
+                                   document: WebMock::API.hash_including({ filename: 'sample.pdf', caption: message.content, link: anything })
+                                 })
+          )
+          .to_return(status: 200, body: whatsapp_response.to_json, headers: response_headers)
+        expect(service.send_message('+123456789', message)).to eq 'message_id'
+      end
+    end
+  end
+
+  describe '#send_interactive message' do
+    context 'when called' do
+      it 'calls message endpoints with button payload when number of items is less than or equal to 3' do
+        message = create(:message, message_type: :outgoing, content: 'test',
+                                   inbox: whatsapp_channel.inbox, content_type: 'input_select',
+                                   content_attributes: {
+                                     items: [
+                                       { title: 'Burito', value: 'Burito' },
+                                       { title: 'Pasta', value: 'Pasta' },
+                                       { title: 'Sushi', value: 'Sushi' }
+                                     ]
+                                   })
+        stub_request(:post, 'https://graph.facebook.com/v13.0/123456789/messages')
+          .with(
+            body: {
+              messaging_product: 'whatsapp', to: '+123456789',
+              interactive: {
+                type: 'button',
+                body: {
+                  text: 'test'
+                },
+                action: '{"buttons":[{"type":"reply","reply":{"id":"Burito","title":"Burito"}},{"type":"reply",' \
+                        '"reply":{"id":"Pasta","title":"Pasta"}},{"type":"reply","reply":{"id":"Sushi","title":"Sushi"}}]}'
+              }, type: 'interactive'
+            }.to_json
+          ).to_return(status: 200, body: whatsapp_response.to_json, headers: response_headers)
+        expect(service.send_message('+123456789', message)).to eq 'message_id'
+      end
+
+      it 'calls message endpoints with list payload when number of items is greater than 3' do
+        items = %w[Burito Pasta Sushi Salad].map { |i| { title: i, value: i } }
+        message = create(:message, message_type: :outgoing, content: 'test', inbox: whatsapp_channel.inbox,
+                                   content_type: 'input_select', content_attributes: { items: items })
+
+        expected_action = {
+          button: I18n.t('conversations.messages.whatsapp.list_button_label'),
+          sections: [{ rows: %w[Burito Pasta Sushi Salad].map { |i| { id: i, title: i } } }]
+        }.to_json
+
+        stub_request(:post, 'https://graph.facebook.com/v13.0/123456789/messages')
+          .with(
+            body: {
+              messaging_product: 'whatsapp', to: '+123456789',
+              interactive: {
+                type: 'list',
+                body: {
+                  text: 'test'
+                },
+                action: expected_action
+              },
+              type: 'interactive'
+            }.to_json
+          ).to_return(status: 200, body: whatsapp_response.to_json, headers: response_headers)
+        expect(service.send_message('+123456789', message)).to eq 'message_id'
+      end
+    end
+  end
+
+  describe '#send_template' do
+    let(:template_info) do
+      {
+        name: 'test_template',
+        namespace: 'test_namespace',
+        lang_code: 'en_US',
+        parameters: [{ type: 'text', text: 'test' }]
+      }
+    end
+
+    let(:template_body) do
+      {
+        messaging_product: 'whatsapp',
+        recipient_type: 'individual', # Added recipient_type field
+        to: '+123456789',
+        type: 'template',
+        template: {
+          name: template_info[:name],
+          language: {
+            policy: 'deterministic',
+            code: template_info[:lang_code]
+          },
+          components: template_info[:parameters] # Changed to use parameters directly (enhanced format)
+        }
+      }
+    end
+
+    context 'when called' do
+      it 'calls message endpoints with template params for template messages' do
+        stub_request(:post, 'https://graph.facebook.com/v13.0/123456789/messages')
+          .with(
+            body: template_body.to_json
+          )
+          .to_return(status: 200, body: whatsapp_response.to_json, headers: response_headers)
+
+        expect(service.send_template('+123456789', template_info, message)).to eq('message_id')
+      end
+    end
+  end
+
+  describe '#sync_templates' do
+    context 'when called' do
+      it 'updated the message templates' do
+        stub_request(:get, 'https://graph.facebook.com/v14.0/123456789/message_templates?access_token=test_key')
+          .to_return(
+            { status: 200, headers: response_headers,
+              body: { data: [
+                { id: '123456789', name: 'test_template' }
+              ], paging: { next: 'https://graph.facebook.com/v14.0/123456789/message_templates?access_token=test_key' } }.to_json },
+            { status: 200, headers: response_headers,
+              body: { data: [
+                { id: '123456789', name: 'next_template' }
+              ], paging: { next: 'https://graph.facebook.com/v14.0/123456789/message_templates?access_token=test_key' } }.to_json },
+            { status: 200, headers: response_headers,
+              body: { data: [
+                { id: '123456789', name: 'last_template' }
+              ], paging: { prev: 'https://graph.facebook.com/v14.0/123456789/message_templates?access_token=test_key' } }.to_json }
+          )
+
+        timstamp = whatsapp_channel.reload.message_templates_last_updated
+        expect(subject.sync_templates).to be(true)
+        expect(whatsapp_channel.reload.message_templates.first).to eq({ id: '123456789', name: 'test_template' }.stringify_keys)
+        expect(whatsapp_channel.reload.message_templates.second).to eq({ id: '123456789', name: 'next_template' }.stringify_keys)
+        expect(whatsapp_channel.reload.message_templates.last).to eq({ id: '123456789', name: 'last_template' }.stringify_keys)
+        expect(whatsapp_channel.reload.message_templates_last_updated).not_to eq(timstamp)
+      end
+
+      it 'updates message_templates_last_updated even when template request fails' do
+        stub_request(:get, 'https://graph.facebook.com/v14.0/123456789/message_templates?access_token=test_key')
+          .to_return(status: 401)
+
+        timstamp = whatsapp_channel.reload.message_templates_last_updated
+        subject.sync_templates
+        expect(whatsapp_channel.reload.message_templates_last_updated).not_to eq(timstamp)
+      end
+    end
+  end
+
+  describe '#validate_provider_config' do
+    context 'when called' do
+      it 'returns true if valid' do
+        stub_request(:get, 'https://graph.facebook.com/v14.0/123456789/message_templates?access_token=test_key')
+        expect(subject.validate_provider_config?).to be(true)
+        expect(whatsapp_channel.errors.present?).to be(false)
+      end
+
+      it 'returns false if invalid' do
+        stub_request(:get, 'https://graph.facebook.com/v14.0/123456789/message_templates?access_token=test_key').to_return(status: 401)
+        expect(subject.validate_provider_config?).to be(false)
+      end
+    end
+  end
+
+  describe 'Ability to configure Base URL' do
+    context 'when environment variable WHATSAPP_CLOUD_BASE_URL is not set' do
+      it 'uses the default base url' do
+        expect(subject.send(:api_base_path)).to eq('https://graph.facebook.com')
+      end
+    end
+
+    context 'when environment variable WHATSAPP_CLOUD_BASE_URL is set' do
+      it 'uses the base url from the environment variable' do
+        with_modified_env WHATSAPP_CLOUD_BASE_URL: 'http://test.com' do
+          expect(subject.send(:api_base_path)).to eq('http://test.com')
+        end
+      end
+    end
+  end
+
+  describe '#handle_error' do
+    let(:error_message) { 'Invalid message format' }
+    let(:error_response) do
+      {
+        'error' => {
+          'message' => error_message,
+          'code' => 100
+        }
+      }
+    end
+
+    let(:error_response_object) do
+      instance_double(
+        HTTParty::Response,
+        body: error_response.to_json,
+        parsed_response: error_response
+      )
+    end
+
+    before do
+      allow(Rails.logger).to receive(:error)
+    end
+
+    context 'when there is a message' do
+      it 'logs error and updates message status' do
+        service.instance_variable_set(:@message, message)
+        service.send(:handle_error, error_response_object, message)
+
+        expect(message.reload.status).to eq('failed')
+        expect(message.reload.external_error).to eq(error_message)
+      end
+    end
+
+    context 'when error message is blank' do
+      let(:error_response_object) do
+        instance_double(
+          HTTParty::Response,
+          body: '{}',
+          parsed_response: {}
+        )
+      end
+
+      it 'logs error but does not update message' do
+        service.instance_variable_set(:@message, message)
+        service.send(:handle_error, error_response_object, message)
+
+        expect(message.reload.status).not_to eq('failed')
+        expect(message.reload.external_error).to be_nil
+      end
+    end
+  end
+
+  describe 'CSAT template methods' do
+    let(:mock_csat_template_service) { instance_double(Whatsapp::CsatTemplateService) }
+    let(:expected_template_name) { "customer_satisfaction_survey_#{whatsapp_channel.inbox.id}" }
+    let(:template_config) do
+      {
+        name: expected_template_name,
+        language: 'en',
+        category: 'UTILITY'
+      }
+    end
+
+    before do
+      allow(Whatsapp::CsatTemplateService).to receive(:new)
+        .with(whatsapp_channel)
+        .and_return(mock_csat_template_service)
+    end
+
+    describe '#create_csat_template' do
+      it 'delegates to csat_template_service with correct config' do
+        allow(mock_csat_template_service).to receive(:create_template)
+          .with(template_config)
+          .and_return({ success: true, template_id: '123' })
+
+        result = service.create_csat_template(template_config)
+
+        expect(mock_csat_template_service).to have_received(:create_template).with(template_config)
+        expect(result).to eq({ success: true, template_id: '123' })
+      end
+    end
+
+    describe '#delete_csat_template' do
+      it 'delegates to csat_template_service with default template name' do
+        allow(mock_csat_template_service).to receive(:delete_template)
+          .with(expected_template_name)
+          .and_return({ success: true })
+
+        result = service.delete_csat_template
+
+        expect(mock_csat_template_service).to have_received(:delete_template).with(expected_template_name)
+        expect(result).to eq({ success: true })
+      end
+
+      it 'delegates to csat_template_service with custom template name' do
+        custom_template_name = 'custom_csat_template'
+        allow(mock_csat_template_service).to receive(:delete_template)
+          .with(custom_template_name)
+          .and_return({ success: true })
+
+        result = service.delete_csat_template(custom_template_name)
+
+        expect(mock_csat_template_service).to have_received(:delete_template).with(custom_template_name)
+        expect(result).to eq({ success: true })
+      end
+    end
+
+    describe '#get_template_status' do
+      it 'delegates to csat_template_service with template name' do
+        template_name = 'customer_survey_template'
+        expected_response = { success: true, template: { status: 'APPROVED' } }
+        allow(mock_csat_template_service).to receive(:get_template_status)
+          .with(template_name)
+          .and_return(expected_response)
+
+        result = service.get_template_status(template_name)
+
+        expect(mock_csat_template_service).to have_received(:get_template_status).with(template_name)
+        expect(result).to eq(expected_response)
+      end
+    end
+
+    describe 'csat_template_service memoization' do
+      it 'creates and memoizes the csat_template_service instance' do
+        allow(Whatsapp::CsatTemplateService).to receive(:new)
+          .with(whatsapp_channel)
+          .and_return(mock_csat_template_service)
+        allow(mock_csat_template_service).to receive(:get_template_status)
+          .and_return({ success: true })
+
+        # Call multiple methods that use the service
+        service.get_template_status('test1')
+        service.get_template_status('test2')
+
+        # Verify the service was only instantiated once
+        expect(Whatsapp::CsatTemplateService).to have_received(:new).once
+      end
+    end
+  end
+end