mailersend-ruby 3.0.1 → 3.4.0

data/lib/mailersend/whatsapp_activities/whatsapp_activities.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Mailersend
+  # WhatsApp Activities endpoint from MailerSend API.
+  class WhatsAppActivities
+    attr_accessor :client,
+                  :whatsapp_item_id,
+                  :whatsapp_message_id,
+                  :recipient,
+                  :type,
+                  :date_from,
+                  :date_to,
+                  :page,
+                  :limit
+
+    def initialize(client = Mailersend::Client.new)
+      @client = client
+      @whatsapp_item_id = whatsapp_item_id
+      @whatsapp_message_id = whatsapp_message_id
+      @recipient = recipient
+      @type = type
+      @date_from = date_from
+      @date_to = date_to
+      @page = page
+      @limit = limit
+    end
+
+    def list(whatsapp_item_id: nil, whatsapp_message_id: nil, recipient: nil, type: nil, date_from: nil, date_to: nil,
+             page: nil, limit: nil)
+      hash = {
+        'whatsapp_item_id' => whatsapp_item_id,
+        'whatsapp_message_id' => whatsapp_message_id,
+        'recipient' => recipient,
+        'type[]' => type,
+        'date_from' => date_from,
+        'date_to' => date_to,
+        'page' => page,
+        'limit' => limit
+      }
+
+      client.http.get(URI::HTTPS.build(host: MAILERSEND_API_BASE_HOST, path: '/v1/whatsapp/activities',
+                                       query: URI.encode_www_form(hash.compact)))
+    end
+  end
+end

data/lib/mailersend/whatsapp_inbound_messages/whatsapp_inbound_messages.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Mailersend
+  # WhatsApp Inbound Messages endpoint from MailerSend API.
+  class WhatsAppInboundMessages
+    attr_accessor :client,
+                  :whatsapp_account_id,
+                  :from,
+                  :type,
+                  :date_from,
+                  :date_to,
+                  :page,
+                  :limit,
+                  :whatsapp_inbound_message_id
+
+    def initialize(client = Mailersend::Client.new)
+      @client = client
+      @whatsapp_account_id = whatsapp_account_id
+      @from = from
+      @type = type
+      @date_from = date_from
+      @date_to = date_to
+      @page = page
+      @limit = limit
+      @whatsapp_inbound_message_id = whatsapp_inbound_message_id
+    end
+
+    def list(whatsapp_account_id: nil, from: nil, type: nil, date_from: nil, date_to: nil, page: nil, limit: nil)
+      hash = {
+        'whatsapp_account_id' => whatsapp_account_id,
+        'from' => from,
+        'type[]' => type,
+        'date_from' => date_from,
+        'date_to' => date_to,
+        'page' => page,
+        'limit' => limit
+      }
+
+      client.http.get(URI::HTTPS.build(host: MAILERSEND_API_BASE_HOST, path: '/v1/whatsapp/inbound-messages',
+                                       query: URI.encode_www_form(hash.compact)))
+    end
+
+    def get(whatsapp_inbound_message_id:)
+      client.http.get("#{MAILERSEND_API_URL}/whatsapp/inbound-messages/#{whatsapp_inbound_message_id}")
+    end
+  end
+end

data/lib/mailersend/whatsapp_items/whatsapp_items.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Mailersend
+  # WhatsApp Items endpoint from MailerSend API.
+  class WhatsAppItems
+    attr_accessor :client,
+                  :recipient,
+                  :whatsapp_message_id,
+                  :status,
+                  :whatsapp_account_id,
+                  :from,
+                  :template_id,
+                  :date_from,
+                  :date_to,
+                  :page,
+                  :limit,
+                  :whatsapp_item_id
+
+    def initialize(client = Mailersend::Client.new)
+      @client = client
+      @recipient = recipient
+      @whatsapp_message_id = whatsapp_message_id
+      @status = status
+      @whatsapp_account_id = whatsapp_account_id
+      @from = from
+      @template_id = template_id
+      @date_from = date_from
+      @date_to = date_to
+      @page = page
+      @limit = limit
+      @whatsapp_item_id = whatsapp_item_id
+    end
+
+    def list(recipient: nil, whatsapp_message_id: nil, status: nil, whatsapp_account_id: nil, from: nil,
+             template_id: nil, date_from: nil, date_to: nil, page: nil, limit: nil)
+      hash = {
+        'recipient' => recipient,
+        'whatsapp_message_id' => whatsapp_message_id,
+        'status[]' => status,
+        'whatsapp_account_id' => whatsapp_account_id,
+        'from' => from,
+        'template_id' => template_id,
+        'date_from' => date_from,
+        'date_to' => date_to,
+        'page' => page,
+        'limit' => limit
+      }
+
+      client.http.get(URI::HTTPS.build(host: MAILERSEND_API_BASE_HOST, path: '/v1/whatsapp/items',
+                                       query: URI.encode_www_form(hash.compact)))
+    end
+
+    def get(whatsapp_item_id:)
+      client.http.get("#{MAILERSEND_API_URL}/whatsapp/items/#{whatsapp_item_id}")
+    end
+  end
+end

data/lib/mailersend/whatsapp_messages/whatsapp_messages.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Mailersend
+  # WhatsApp Messages endpoint from MailerSend API.
+  class WhatsAppMessages
+    attr_accessor :client,
+                  :whatsapp_account_id,
+                  :from,
+                  :template_id,
+                  :date_from,
+                  :date_to,
+                  :page,
+                  :limit,
+                  :whatsapp_message_id
+
+    def initialize(client = Mailersend::Client.new)
+      @client = client
+      @whatsapp_account_id = whatsapp_account_id
+      @from = from
+      @template_id = template_id
+      @date_from = date_from
+      @date_to = date_to
+      @page = page
+      @limit = limit
+      @whatsapp_message_id = whatsapp_message_id
+    end
+
+    def list(whatsapp_account_id: nil, from: nil, template_id: nil, date_from: nil, date_to: nil, page: nil, limit: nil)
+      hash = {
+        'whatsapp_account_id' => whatsapp_account_id,
+        'from' => from,
+        'template_id' => template_id,
+        'date_from' => date_from,
+        'date_to' => date_to,
+        'page' => page,
+        'limit' => limit
+      }
+
+      client.http.get(URI::HTTPS.build(host: MAILERSEND_API_BASE_HOST, path: '/v1/whatsapp/messages',
+                                       query: URI.encode_www_form(hash.compact)))
+    end
+
+    def get(whatsapp_message_id:)
+      client.http.get("#{MAILERSEND_API_URL}/whatsapp/messages/#{whatsapp_message_id}")
+    end
+  end
+end

data/lib/mailersend/whatsapp_recipient/whatsapp_recipient.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Mailersend
+  # WhatsApp Recipient endpoint from MailerSend API.
+  class WhatsAppRecipient
+    attr_accessor :client,
+                  :status,
+                  :phone_number,
+                  :page,
+                  :limit,
+                  :whatsapp_recipient_id
+
+    def initialize(client = Mailersend::Client.new)
+      @client = client
+      @status = status
+      @phone_number = phone_number
+      @page = page
+      @limit = limit
+      @whatsapp_recipient_id = whatsapp_recipient_id
+    end
+
+    def list(status: nil, phone_number: nil, page: nil, limit: nil)
+      hash = {
+        'status' => status,
+        'phone_number' => phone_number,
+        'page' => page,
+        'limit' => limit
+      }
+
+      client.http.get(URI::HTTPS.build(host: MAILERSEND_API_BASE_HOST, path: '/v1/whatsapp/recipients',
+                                       query: URI.encode_www_form(hash.compact)))
+    end
+
+    def get(whatsapp_recipient_id:)
+      client.http.get("#{MAILERSEND_API_URL}/whatsapp/recipients/#{whatsapp_recipient_id}")
+    end
+  end
+end

data/lib/mailersend/whatsapp_templates/whatsapp_templates.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Mailersend
+  # WhatsApp Templates endpoint from MailerSend API.
+  class WhatsAppTemplates
+    attr_accessor :client,
+                  :whatsapp_account_id,
+                  :status,
+                  :category,
+                  :language,
+                  :page,
+                  :limit,
+                  :whatsapp_template_id
+
+    def initialize(client = Mailersend::Client.new)
+      @client = client
+      @whatsapp_account_id = whatsapp_account_id
+      @status = status
+      @category = category
+      @language = language
+      @page = page
+      @limit = limit
+      @whatsapp_template_id = whatsapp_template_id
+    end
+
+    def list(whatsapp_account_id: nil, status: nil, category: nil, language: nil, page: nil, limit: nil)
+      hash = {
+        'whatsapp_account_id' => whatsapp_account_id,
+        'status' => status,
+        'category' => category,
+        'language' => language,
+        'page' => page,
+        'limit' => limit
+      }
+
+      client.http.get(URI::HTTPS.build(host: MAILERSEND_API_BASE_HOST, path: '/v1/whatsapp/templates',
+                                       query: URI.encode_www_form(hash.compact)))
+    end
+
+    def get(whatsapp_template_id:)
+      client.http.get("#{MAILERSEND_API_URL}/whatsapp/templates/#{whatsapp_template_id}")
+    end
+  end
+end

data/lib/mailersend.rb

@@ -6,15 +6,24 @@ require_relative 'mailersend/activity/activity'
 require_relative 'mailersend/api_quota/api_quota'
 require_relative 'mailersend/analytics/analytics'
 require_relative 'mailersend/bulk_email/bulk_email'
+require_relative 'mailersend/dmarc_monitoring/dmarc_monitoring'
 require_relative 'mailersend/domains/domains'
 require_relative 'mailersend/email/email'
 require_relative 'mailersend/email_verification/email_verification'
+require_relative 'mailersend/emails/emails'
 require_relative 'mailersend/inbound_routing/inbound_routing'
 require_relative 'mailersend/messages/messages'
 require_relative 'mailersend/recipients/recipients'
 require_relative 'mailersend/scheduled_messages/scheduled_messages'
 require_relative 'mailersend/sender_identity/sender_identity'
 require_relative 'mailersend/sms/sms'
+require_relative 'mailersend/whatsapp/whatsapp'
+require_relative 'mailersend/whatsapp_messages/whatsapp_messages'
+require_relative 'mailersend/whatsapp_items/whatsapp_items'
+require_relative 'mailersend/whatsapp_activities/whatsapp_activities'
+require_relative 'mailersend/whatsapp_inbound_messages/whatsapp_inbound_messages'
+require_relative 'mailersend/whatsapp_recipient/whatsapp_recipient'
+require_relative 'mailersend/whatsapp_templates/whatsapp_templates'
 require_relative 'mailersend/sms_activity/sms_activity'
 require_relative 'mailersend/sms_messages/sms_messages'
 require_relative 'mailersend/sms_number/sms_number'

data/spec/dmarc_monitoring_rspec.rb

@@ -0,0 +1,100 @@
+require 'rspec'
+require 'vcr'
+require 'json'
+
+VCR.configure do |config|
+  config.cassette_library_dir = './fixtures'
+  config.hook_into :webmock
+  config.filter_sensitive_data('<AUTH>') do |interaction|
+    interaction.request.headers['Authorization'][0]
+  end
+end
+
+RSpec.describe Mailersend::DmarcMonitoring do
+  let(:client) { Mailersend::Client.new(API_TOKEN) }
+  let(:dmarc) { Mailersend::DmarcMonitoring.new(client) }
+
+  it 'returns a list of monitors' do
+    VCR.use_cassette('dmarc_monitoring/list') do
+      response = dmarc.list
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+
+  it 'creates a monitor' do
+    VCR.use_cassette('dmarc_monitoring/create') do
+      response = dmarc.create(domain_id: 'example_domain_id')
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(201)
+      expect(parsed_response['data']).to be_a(Hash)
+    end
+  end
+
+  it 'updates a monitor' do
+    VCR.use_cassette('dmarc_monitoring/update') do
+      response = dmarc.update(monitor_id: 'example_monitor_id', wanted_dmarc_record: 'v=DMARC1; p=reject;')
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_a(Hash)
+    end
+  end
+
+  it 'deletes a monitor' do
+    VCR.use_cassette('dmarc_monitoring/delete') do
+      response = dmarc.delete(monitor_id: 'example_monitor_id')
+
+      expect(response.status).to eq(204)
+    end
+  end
+
+  it 'returns aggregated report' do
+    VCR.use_cassette('dmarc_monitoring/report') do
+      response = dmarc.report(monitor_id: 'example_monitor_id')
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+
+  it 'returns IP-specific report' do
+    VCR.use_cassette('dmarc_monitoring/report_by_ip') do
+      response = dmarc.report_by_ip(monitor_id: 'example_monitor_id', ip: '1.2.3.4')
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+
+  it 'returns report sources' do
+    VCR.use_cassette('dmarc_monitoring/report_sources') do
+      response = dmarc.report_sources(monitor_id: 'example_monitor_id')
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+
+  it 'marks an IP as favorite' do
+    VCR.use_cassette('dmarc_monitoring/add_favorite') do
+      response = dmarc.add_favorite(monitor_id: 'example_monitor_id', ip: '1.2.3.4')
+
+      expect(response.status).to eq(200)
+    end
+  end
+
+  it 'removes an IP from favorites' do
+    VCR.use_cassette('dmarc_monitoring/remove_favorite') do
+      response = dmarc.remove_favorite(monitor_id: 'example_monitor_id', ip: '1.2.3.4')
+
+      expect(response.status).to eq(200)
+    end
+  end
+end

data/spec/email_rspec.rb

@@ -26,4 +26,19 @@ RSpec.describe Mailersend::Email do
       expect(response.status).to eq(202)
     end
   end
+
+  it 'includes the language in the request body when set' do
+    # Cassette is matched on the request body, so this passes only when
+    # the serialized payload contains the language field.
+    VCR.use_cassette('email/email_send_template_language', match_requests_on: %i[method uri body]) do
+      email.from = { 'email' => 'sender@test-sdk.com', 'name' => 'Sender' }
+      email.recipients = [{ 'email' => 'test@mailerlite.com', 'name' => 'Test' }]
+      email.subject = 'Test Email'
+      email.add_template_id('123abc')
+      email.add_language('de')
+
+      response = email.send
+      expect(response.status).to eq(202)
+    end
+  end
 end

data/spec/emails_rspec.rb

@@ -0,0 +1,175 @@
+require 'rspec'
+require 'vcr'
+require 'json'
+
+VCR.configure do |config|
+  config.cassette_library_dir = './fixtures'
+  config.hook_into :webmock
+  config.filter_sensitive_data('<AUTH>') do |interaction|
+    interaction.request.headers['Authorization'][0]
+  end
+end
+
+RSpec.describe Mailersend::Emails do
+  let(:client) { Mailersend::Client.new(API_TOKEN) }
+  let(:emails) { Mailersend::Emails.new(client) }
+
+  # The three required arguments, reused by every example.
+  let(:domain_id) { 'jpzkmgq7e5vl059v' }
+  let(:date_from) { 1_756_252_800 }
+  let(:date_to) { 1_756_339_200 }
+
+  describe '#list' do
+    # VCR matches on method + URI, so the `uri:` recorded in the cassette is itself the
+    # assertion that `list` hits `v1/emails` with domain_id, date_from, date_to, limit and page.
+    it 'returns a list of emails' do
+      VCR.use_cassette('emails/emails_list_emails', match_requests_on: %i[method uri]) do
+        response = emails.list(domain_id: domain_id, date_from: date_from, date_to: date_to, page: 1, limit: 10)
+        parsed_response = JSON.parse(response.body)
+
+        expect(response.status).to eq(200)
+        expect(parsed_response['data']).to be_an(Array)
+
+        email = parsed_response['data'].first
+
+        expect(email['id']).to eq('6a8fa9b1902fab56e0ce50dd')
+        expect(email['from']).to eq('sender@example.com')
+        expect(email['to']).to eq('rcpt@example.org')
+        expect(email['status']).to eq('sent')
+        expect(email['tags']).to eq(['newsletter'])
+        expect(email['interaction']).to eq(['opened'])
+        expect(email['suppression_reason']).to be_nil
+        expect(email['headers']).to eq([{ 'name' => 'X-Custom', 'value' => 'foo' }])
+
+        # List rows never carry content — it is only returned by `single`.
+        expect(email['text']).to be_nil
+        expect(email['html']).to be_nil
+
+        expect(parsed_response['links']['first']).to eq('https://api.mailersend.com/v1/emails?page=1')
+        expect(parsed_response['links']['last']).to be_nil
+        expect(parsed_response['meta']['current_page']).to eq(1)
+        expect(parsed_response['meta']['per_page']).to eq(10)
+      end
+    end
+
+    it 'returns an empty page past the end of the result set' do
+      VCR.use_cassette('emails/emails_list_emails_empty_page', match_requests_on: %i[method uri]) do
+        response = emails.list(domain_id: domain_id, date_from: date_from, date_to: date_to, page: 2, limit: 10)
+        parsed_response = JSON.parse(response.body)
+
+        expect(response.status).to eq(200)
+        expect(parsed_response['data']).to eq([])
+        expect(parsed_response['links']['prev']).to eq('https://api.mailersend.com/v1/emails?page=1')
+        expect(parsed_response['links']['next']).to be_nil
+        expect(parsed_response['meta']['current_page']).to eq(2)
+        expect(parsed_response['meta']['from']).to be_nil
+        expect(parsed_response['meta']['to']).to be_nil
+      end
+    end
+  end
+
+  describe '#single' do
+    # The path is singular (`v1/email/{id}`) while `list` is plural (`v1/emails`); the cassette
+    # URI pins that difference.
+    it 'returns a single email with its recipient and activity' do
+      VCR.use_cassette('emails/emails_single_email', match_requests_on: %i[method uri]) do
+        response = emails.single(email_id: '6a8fa9b1902fab56e0ce50dd')
+        parsed_response = JSON.parse(response.body)
+
+        expect(response.status).to eq(200)
+        expect(parsed_response['data']).to be_a(Hash)
+        expect(parsed_response['data']['id']).to eq('6a8fa9b1902fab56e0ce50dd')
+
+        # `single` adds content, the recipient object and the activity array on top of a list row.
+        expect(parsed_response['data']['text']).to eq('Welcome aboard.')
+        expect(parsed_response['data']['html']).to eq('<p>Welcome aboard.</p>')
+        expect(parsed_response['data']['recipient']).to be_a(Hash)
+        expect(parsed_response['data']['recipient']['email']).to eq('rcpt@example.org')
+
+        activity = parsed_response['data']['activity']
+
+        expect(activity).to be_an(Array)
+        expect(activity.length).to eq(3)
+        expect(activity.first).to include('id', 'type', 'created_at')
+        expect(activity.first['type']).to eq('opened')
+        expect(activity.map { |event| event['type'] }).to eq(%w[opened delivered sent])
+      end
+    end
+  end
+
+  # These examples assert the URI the SDK builds rather than replaying a cassette, because query
+  # serialization is the contract that matters most here: the API rejects a scalar `status` or
+  # `interaction` with 422, so both must go out as repeated `status[]` / `interaction[]` params and
+  # never as a single comma-joined value.
+  describe 'query serialization' do
+    let(:http) { double('http') }
+    let(:requested_urls) { [] }
+
+    before do
+      allow(client).to receive(:http).and_return(http)
+      allow(http).to receive(:get) { |url| requested_urls << url.to_s }
+    end
+
+    it 'sends status and interaction as repeated array params' do
+      emails.list(domain_id: domain_id, date_from: date_from, date_to: date_to, limit: 10, page: 1,
+                  status: %w[sent delivered], interaction: %w[opened clicked])
+
+      expect(requested_urls.last).to eq(
+        'https://api.mailersend.com/v1/emails' \
+        '?domain_id=jpzkmgq7e5vl059v&date_from=1756252800&date_to=1756339200&limit=10&page=1' \
+        '&status%5B%5D=sent&status%5B%5D=delivered' \
+        '&interaction%5B%5D=opened&interaction%5B%5D=clicked'
+      )
+
+      # One key per value, and no comma-joined value anywhere (%2C is an encoded comma).
+      expect(requested_urls.last.scan('status%5B%5D=').length).to eq(2)
+      expect(requested_urls.last.scan('interaction%5B%5D=').length).to eq(2)
+      expect(requested_urls.last).not_to include('%2C')
+    end
+
+    it 'sends a scalar status and interaction in array form too' do
+      emails.list(domain_id: domain_id, date_from: date_from, date_to: date_to,
+                  status: 'sent', interaction: 'opened')
+
+      expect(requested_urls.last).to eq(
+        'https://api.mailersend.com/v1/emails' \
+        '?domain_id=jpzkmgq7e5vl059v&date_from=1756252800&date_to=1756339200' \
+        '&status%5B%5D=sent&interaction%5B%5D=opened'
+      )
+    end
+
+    it 'includes every optional filter when set' do
+      emails.list(domain_id: domain_id, date_from: date_from, date_to: date_to, limit: 25, page: 2,
+                  status: %w[sent], interaction: %w[opened], recipient_email: 'rcpt@example.org',
+                  message_id: '6a8fa9b1902fab56e0ce50aa', template_id: '7nxe3yjmeq28vp0k',
+                  subject: 'Welcome', tag: 'newsletter')
+
+      expect(requested_urls.last).to eq(
+        'https://api.mailersend.com/v1/emails' \
+        '?domain_id=jpzkmgq7e5vl059v&date_from=1756252800&date_to=1756339200&limit=25&page=2' \
+        '&status%5B%5D=sent&interaction%5B%5D=opened' \
+        '&recipient_email=rcpt%40example.org&message_id=6a8fa9b1902fab56e0ce50aa' \
+        '&template_id=7nxe3yjmeq28vp0k&subject=Welcome&tag=newsletter'
+      )
+    end
+
+    it 'omits every optional filter that is nil' do
+      emails.list(domain_id: domain_id, date_from: date_from, date_to: date_to)
+
+      expect(requested_urls.last).to eq(
+        'https://api.mailersend.com/v1/emails?domain_id=jpzkmgq7e5vl059v&date_from=1756252800&date_to=1756339200'
+      )
+
+      %w[limit page status interaction recipient_email message_id template_id subject tag].each do |param|
+        expect(requested_urls.last).not_to include(param)
+      end
+    end
+
+    it 'requests the singular v1/email/{id} path for a single email' do
+      emails.single(email_id: '6a8fa9b1902fab56e0ce50dd')
+
+      expect(requested_urls.last).to eq('https://api.mailersend.com/v1/email/6a8fa9b1902fab56e0ce50dd')
+      expect(requested_urls.last).not_to include('/v1/emails/')
+    end
+  end
+end

data/spec/whatsapp_activities_rspec.rb

@@ -0,0 +1,38 @@
+require 'rspec'
+require 'vcr'
+require 'json'
+
+VCR.configure do |config|
+  config.cassette_library_dir = './fixtures'
+  config.hook_into :webmock
+  config.filter_sensitive_data('<AUTH>') do |interaction|
+    interaction.request.headers['Authorization'][0]
+  end
+end
+
+RSpec.describe Mailersend::WhatsAppActivities do
+  let(:client) { Mailersend::Client.new(API_TOKEN) }
+  let(:whatsapp_activities) { Mailersend::WhatsAppActivities.new(client) }
+
+  it 'returns a list of WhatsApp activities' do
+    VCR.use_cassette('whatsapp_activities/whatsapp_activities_list', match_requests_on: %i[method host path query]) do
+      response = whatsapp_activities.list(
+        whatsapp_item_id: '67f91abe2202f3705540234a',
+        whatsapp_message_id: '67f91abd69f79df391e9d78d',
+        recipient: '48600000001',
+        type: %w[delivered read],
+        date_from: 1_791_936_000,
+        date_to: 1_792_022_400,
+        page: 1,
+        limit: 25
+      )
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_an(Array)
+      expect(parsed_response['data'].map { |activity| activity['type'] }).to eq(%w[read delivered])
+      expect(parsed_response['links']['last']).to be_nil
+      expect(parsed_response['meta']).not_to have_key('total')
+    end
+  end
+end