mailersend-ruby 3.1.0 → 3.4.0

data/flake.nix

@@ -0,0 +1,25 @@
+{
+  description = "MailerSend Ruby SDK environment";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+  };
+
+  outputs = { self, nixpkgs }:
+    let
+      systems = [ "aarch64-darwin" "x86_64-darwin" "aarch64-linux" "x86_64-linux" ];
+      forEachSystem = f:
+        nixpkgs.lib.genAttrs systems (system: f system nixpkgs.legacyPackages.${system});
+    in
+    {
+      devShells = forEachSystem (system: pkgs: {
+        default = pkgs.mkShell {
+          packages = with pkgs; [
+            lefthook
+            gitleaks
+            git-secrets
+          ];
+        };
+      });
+    };
+}

data/lefthook.yml

@@ -0,0 +1,14 @@
+---
+pre-commit:
+  commands:
+    gitleaks:
+      run: gitleaks git --pre-commit --redact --staged --verbose --no-banner
+      fail_text: Staged changes contain a secret. Remove it; never commit and revert.
+    secrets:
+      run: |
+        git secrets --list | grep -q 'mssp' || {
+          git secrets --register-aws
+          git secrets --add 'mlsn\.[A-Za-z0-9._-]+'
+          git secrets --add 'mssp\.[A-Za-z0-9._-]+'
+        }
+        git secrets --scan {staged_files}

data/lib/mailersend/email/email.rb

@@ -16,6 +16,7 @@ module Mailersend
                   :reply_to,
                   :attachments,
                   :template_id,
+                  :language,
                   :tags,
                   :variables,
                   :personalization,
@@ -40,6 +41,7 @@ module Mailersend
       @headers = {}
       @list_unsubscribe = nil
       @send_at = send_at
+      @language = nil
     end
 
     def add_recipients(recipients)
@@ -86,6 +88,13 @@ module Mailersend
       @template_id = template_id
     end
 
+    # Language code (e.g. 'de', 'fr', 'pt-BR'). Only meaningful when a
+    # template_id is set; ignored for raw html/text sends. Max length 10.
+    # Supported: de, en, es, fr, it, lt, nl, pl, pt-BR
+    def add_language(language)
+      @language = language
+    end
+
     def add_tags(tags)
       @tags << tags
     end
@@ -131,6 +140,7 @@ module Mailersend
         'variables' => @variables,
         'personalization' => @personalization,
         'template_id' => @template_id,
+        'language' => @language,
         'attachments' => @attachments,
         'headers' => @headers,
         'list_unsubscribe' => @list_unsubscribe,

data/lib/mailersend/emails/emails.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Mailersend
+  # Emails endpoint from MailerSend API.
+  class Emails
+    attr_accessor :client,
+                  :domain_id,
+                  :date_from,
+                  :date_to,
+                  :limit,
+                  :page,
+                  :email_id
+
+    def initialize(client = Mailersend::Client.new)
+      @client = client
+    end
+
+    def list(domain_id:, date_from:, date_to:, limit: nil, page: nil, status: nil, interaction: nil,
+             recipient_email: nil, message_id: nil, template_id: nil, subject: nil, tag: nil)
+      hash = {
+        'domain_id' => domain_id,
+        'date_from' => date_from,
+        'date_to' => date_to,
+        'limit' => limit,
+        'page' => page,
+        # The API rejects a scalar status/interaction with 422, so they are always sent in array form.
+        'status[]' => status,
+        'interaction[]' => interaction,
+        'recipient_email' => recipient_email,
+        'message_id' => message_id,
+        'template_id' => template_id,
+        'subject' => subject,
+        'tag' => tag
+      }
+
+      client.http.get(URI::HTTPS.build(host: MAILERSEND_API_BASE_HOST, path: '/v1/emails',
+                                       query: URI.encode_www_form(hash.compact)))
+    end
+
+    def single(email_id:)
+      client.http.get("#{MAILERSEND_API_URL}/email/#{email_id}")
+    end
+  end
+end

data/lib/mailersend/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mailersend
-  VERSION = '3.1.0'
+  VERSION = '3.4.0'
 end

data/lib/mailersend/whatsapp/whatsapp.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Mailersend
+  # Send a WhatsApp message through MailerSend API
+  class WhatsApp
+    attr_accessor :client,
+                  :from,
+                  :to,
+                  :template_id,
+                  :personalization
+
+    def initialize(client = Mailersend::Client.new)
+      @client = client
+      @from = ''
+      @to = []
+      @template_id = ''
+      @personalization = []
+    end
+
+    def add_from(from)
+      @from = from
+    end
+
+    def add_to(to)
+      @to << to
+    end
+
+    def add_template_id(template_id)
+      @template_id = template_id
+    end
+
+    def add_personalization(personalization)
+      @personalization << personalization
+    end
+
+    def send
+      message = {
+        'from' => @from,
+        'to' => @to,
+        'template_id' => @template_id,
+        'personalization' => @personalization
+      }
+
+      client.http.post("#{MAILERSEND_API_URL}/whatsapp/send", json: message.delete_if { |_, value| value.to_s.strip == '' || value == [] || value == {} })
+    end
+  end
+end

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

@@ -10,12 +10,20 @@ 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/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