Cayo oliveira/cu 86af019hb/5 backend envio de mensagens baileys

.claude/skills/rspec-tests/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: rspec-tests
+description: Guidelines for writing RSpec tests in this Rails project. Covers test structure, conventions, anti-patterns, and project-specific tooling. Use when creating or reviewing Ruby specs.
+---
+
+# RSpec Testing Skill
+
+## Core Principles
+
+### 1. Test Each Behavior Exactly Once
+
+Every spec should verify one expected behavior. Do not write multiple specs that assert the same thing in different ways. Redundant specs slow the suite and add maintenance burden without extra confidence.
+
+### 2. Avoid `before(:each)`
+
+Prefer `let`, `let!`, `let_it_be`, `before_all`, or inline setup inside the `it` block. Only use `before(:each)` when there is truly no alternative (e.g., stateful mutation needed before every example in a tightly scoped context). When a `before` block is unavoidable, keep it as close to the examples that need it as possible.
+
+### 3. Follow Set → Action → Expect Ordering
+
+Structure every test with three clearly separated stages, each divided by a blank line:
+
+- **Set** (Setup): Build the context — `let`, `let_it_be`, `create`, variable assignment.
+- **Action**: Execute the behavior under test — call the method, make the request, trigger the job.
+- **Expect**: Assert the outcome — `expect(...)`.
+
+Only break this order when the assertion must come before the action (e.g., `expect { action }.to change(...)`).
+
+```ruby
+it 'assigns the conversation to the agent' do
+  agent = create(:user, account: account)
+
+  service.perform
+
+  expect(conversation.reload.assignee).to eq(agent)
+end
+```
+
+### 4. Never Assert on Translated Strings
+
+Translations vary by locale. Instead of matching user-facing text like `'enviado'` or `'sent'`, assert on the underlying status, enum value, or state change that produces that text.
+
+```ruby
+# Bad
+expect(message.status_text).to eq('sent')
+
+# Good
+expect(message.status).to eq('sent')
+expect(message).to be_sent
+```
+
+---
+
+## Project Conventions
+
+### Stubs and Mocks
+
+- Stub with `allow(object).to receive(:method).and_return(value)`.
+- Verify calls with `have_received(:method)` (message spies style is acceptable — `RSpec/MessageSpies` is disabled).
+- For ENV variables, use the `with_modified_env` helper instead of stubbing `ENV` directly.
+
+### Assertions
+
+- Use Shoulda matchers for model validations and associations as one-liners:
+  ```ruby
+  it { is_expected.to belong_to(:account) }
+  it { is_expected.to validate_presence_of(:name) }
+  ```
+- For HTTP responses: `expect(response).to have_http_status(:success)`.
+- For error classes in parallel/reloading environments, compare `error.class.name` (string) instead of the constant directly.
+
+### Style
+
+- **Hash syntax**: Use explicit `key: value`. Do not use Ruby 3.1 shorthand (`{key:}`).
+- **Module/class style**: Use compact definitions (`class Foo::Bar`) — never nested.
+- **Describe/context naming**: `describe '#method_name'` for instance methods, `describe '.method_name'` for class methods, `context 'when condition'` for scenarios.
+
+---
+
+## Structure Examples
+
+### Service Spec
+
+```ruby
+require 'rails_helper'
+
+RSpec.describe MyService do
+  subject(:service) { described_class.new(account: account) }
+
+  let_it_be(:account) { create(:account) }
+
+  describe '#perform' do
+    context 'when the input is valid' do
+      let(:params) { { name: 'Test' } }
+
+      it 'creates the resource' do
+        result = service.perform(params)
+
+        expect(result).to be_persisted
+        expect(result.name).to eq('Test')
+      end
+    end
+
+    context 'when the input is invalid' do
+      let(:params) { { name: '' } }
+
+      it 'raises a validation error' do
+        expect { service.perform(params) }.to raise_error(ActiveRecord::RecordInvalid)
+      end
+    end
+  end
+end
+```
+
+### Request Spec
+
+```ruby
+require 'rails_helper'
+
+RSpec.describe 'Widgets API', type: :request do
+  let_it_be(:account) { create(:account) }
+  let_it_be(:agent) { create(:user, account: account, role: :agent) }
+
+  describe 'POST /api/v1/accounts/{account.id}/widgets' do
+    context 'when authenticated' do
+      it 'creates a widget' do
+        params = { name: 'Support', website_url: 'https://example.com' }
+
+        post "/api/v1/accounts/#{account.id}/widgets",
+             headers: { api_access_token: agent.access_token.token },
+             params: params,
+             as: :json
+
+        expect(response).to have_http_status(:success)
+        expect(JSON.parse(response.body)['name']).to eq('Support')
+      end
+    end
+  end
+end
+```

app/services/whatsapp/baileys_handlers/message_receipt_update.rb

@@ -0,0 +1,40 @@
+module Whatsapp::BaileysHandlers::MessageReceiptUpdate
+  include Whatsapp::BaileysHandlers::Helpers
+
+  private
+
+  def process_message_receipt_update
+    receipts = processed_params[:data]
+    receipts.each do |receipt|
+      @message = nil
+      @raw_message = receipt
+
+      next handle_receipt_update if incoming?
+
+      # NOTE: Shared lock with Whatsapp::SendOnWhatsappService
+      # Avoids race conditions when sending messages.
+      with_baileys_channel_lock_on_outgoing_message(inbox.channel.id) { handle_receipt_update }
+    end
+  end
+
+  def handle_receipt_update
+    return unless find_message_by_source_id(raw_message_id)
+
+    new_status = receipt_status
+    return if new_status.nil?
+    return unless receipt_status_transition_allowed?(new_status)
+
+    @message.update!(status: new_status)
+  end
+
+  def receipt_status
+    'delivered' if @raw_message.dig(:receipt, :receiptTimestamp).present?
+  end
+
+  def receipt_status_transition_allowed?(new_status)
+    return false if @message.status == 'read'
+    return false if @message.status == 'delivered' && new_status == 'delivered'
+
+    true
+  end
+end

app/services/whatsapp/incoming_message_baileys_service.rb

@@ -3,6 +3,7 @@ class Whatsapp::IncomingMessageBaileysService < Whatsapp::IncomingMessageBaseSer
   include Whatsapp::BaileysHandlers::ConnectionUpdate
   include Whatsapp::BaileysHandlers::MessagesUpsert
   include Whatsapp::BaileysHandlers::MessagesUpdate
+  include Whatsapp::BaileysHandlers::MessageReceiptUpdate
   include Whatsapp::BaileysHandlers::GroupParticipantsUpdate
   include Whatsapp::BaileysHandlers::GroupsUpdate
 

app/services/whatsapp/providers/whatsapp_baileys_service.rb

@@ -161,13 +161,7 @@ def read_messages(messages, recipient_id:, **)
       "#{provider_url}/connections/#{whatsapp_channel.phone_number}/read-messages",
       headers: api_headers,
       body: {
-        keys: messages.map do |message|
-          {
-            id: message.source_id,
-            remoteJid: remote_jid,
-            fromMe: message.message_type == 'outgoing'
-          }
-        end
+        keys: messages.map { |message| message_key_for(message) }
       }.to_json
     )
 
@@ -176,7 +170,7 @@ def read_messages(messages, recipient_id:, **)
     true
   end
 
-  def unread_message(recipient_id, message) # rubocop:disable Metrics/MethodLength
+  def unread_message(recipient_id, message)
     @recipient_id = recipient_id
 
     response = HTTParty.post(
@@ -187,11 +181,7 @@ def unread_message(recipient_id, message) # rubocop:disable Metrics/MethodLength
         mod: {
           markRead: false,
           lastMessages: [{
-            key: {
-              id: message.source_id,
-              remoteJid: remote_jid,
-              fromMe: message.message_type == 'outgoing'
-            },
+            key: message_key_for(message),
             messageTimestamp: message.content_attributes[:external_created_at]
           }]
         }
@@ -210,13 +200,7 @@ def received_messages(recipient_id, messages)
       "#{provider_url}/connections/#{whatsapp_channel.phone_number}/send-receipts",
       headers: api_headers,
       body: {
-        keys: messages.map do |message|
-          {
-            id: message.source_id,
-            remoteJid: remote_jid,
-            fromMe: message.message_type == 'outgoing'
-          }
-        end
+        keys: messages.map { |message| message_key_for(message) }
       }.to_json
     )
 
@@ -275,11 +259,7 @@ def delete_message(recipient_id, message)
       headers: api_headers,
       body: {
         jid: remote_jid,
-        key: {
-          id: message.source_id,
-          remoteJid: remote_jid,
-          fromMe: message.message_type == 'outgoing'
-        }
+        key: message_key_for(message)
       }.to_json
     )
 
@@ -296,11 +276,7 @@ def edit_message(recipient_id, message, new_content)
       headers: api_headers,
       body: {
         jid: remote_jid,
-        key: {
-          id: message.source_id,
-          remoteJid: remote_jid,
-          fromMe: message.message_type == 'outgoing'
-        },
+        key: message_key_for(message),
         messageContent: { text: new_content }
       }.to_json
     )
@@ -323,10 +299,10 @@ def api_key
   def reaction_message_content
     reply_to = Message.find(@message.in_reply_to)
     {
-      react: { key: { id: reply_to.source_id,
-                      remoteJid: remote_jid,
-                      fromMe: reply_to.message_type == 'outgoing' },
-               text: @message.outgoing_content }
+      react: {
+        key: message_key_for(reply_to),
+        text: @message.outgoing_content
+      }
     }
   end
 
@@ -339,16 +315,28 @@ def reply_context
 
     {
       quotedMessage: {
-        key: {
-          id: reply_to_external_id,
-          remoteJid: remote_jid,
-          fromMe: reply_to_message.message_type == 'outgoing'
-        },
+        key: message_key_for(reply_to_message),
         message: quoted_message_content(reply_to_message)
       }
     }
   end
 
+  def message_key_for(message)
+    {
+      id: message.source_id,
+      remoteJid: remote_jid,
+      fromMe: message.message_type == 'outgoing',
+      participant: group_participant_jid(message)
+    }.compact
+  end
+
+  def group_participant_jid(message)
+    return unless remote_jid.ends_with?('@g.us')
+    return if message.message_type == 'outgoing'
+
+    message.sender&.identifier
+  end
+
   def quoted_message_content(message)
     if message.attachments.present?
       attachment = message.attachments.first

spec/services/whatsapp/incoming_message_baileys_service_spec.rb

@@ -1046,6 +1046,67 @@
         end
       end
     end
+
+    context 'when processing message-receipt.update event' do
+      let(:conversation) do
+        agent = create(:user, account: inbox.account, role: :agent)
+        contact = create(:contact, account: inbox.account)
+        contact_inbox = create(:contact_inbox, inbox: inbox, contact: contact)
+        create(:conversation, inbox: inbox, contact_inbox: contact_inbox, assignee_id: agent.id)
+      end
+      let!(:message) { create(:message, inbox: inbox, conversation: conversation, source_id: '123ABCDE1234567', status: 'sent') }
+      let(:receipt_payload) do
+        {
+          key: { remoteJid: '123456789123456789@g.us', id: '123ABCDE1234567', fromMe: true,
+                 participant: '12345678@lid' },
+          receipt: receipt_data
+        }
+      end
+      let(:receipt_data) { { userJid: '12345678@lid', receiptTimestamp: 1_772_056_268 } }
+      let(:params) do
+        {
+          webhookVerifyToken: webhook_verify_token,
+          event: 'message-receipt.update',
+          data: [receipt_payload]
+        }
+      end
+
+      it 'updates message from sent to delivered on receiptTimestamp' do
+        described_class.new(inbox: inbox, params: params).perform
+
+        expect(message.reload.status).to eq('delivered')
+      end
+
+      it 'ignores readTimestamp and does not update status' do
+        receipt_data.replace(userJid: '12345678@lid', readTimestamp: 1_772_056_497)
+
+        described_class.new(inbox: inbox, params: params).perform
+
+        expect(message.reload.status).to eq('sent')
+      end
+
+      it 'does not downgrade a delivered message on receiptTimestamp' do
+        message.update!(status: 'delivered')
+
+        described_class.new(inbox: inbox, params: params).perform
+
+        expect(message.reload.status).to eq('delivered')
+      end
+
+      it 'does not downgrade a read message on receiptTimestamp' do
+        message.update!(status: 'read')
+
+        described_class.new(inbox: inbox, params: params).perform
+
+        expect(message.reload.status).to eq('read')
+      end
+
+      it 'does not raise error when message is not found' do
+        receipt_payload[:key][:id] = 'NONEXISTENT_MSG_ID'
+
+        expect { described_class.new(inbox: inbox, params: params).perform }.not_to raise_error
+      end
+    end
   end
 
   def format_message_source_key(message_id)