mailgun-ruby 1.4.1 → 1.4.3

data/spec/unit/railgun/content_type_spec.rb

@@ -1,50 +1,51 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'mailgun'
 require 'railgun'
 
 describe 'extract_body' do
-
-  let(:text_mail_option) {
+  let(:text_mail_option) do
     {
-      from:        'bob@example.com',
-      to:          'sally@example.com',
-      subject:     'RAILGUN TEST SAMPLE',
-      body:         text_content,
-      content_type: 'text/plain',
+      from: 'bob@example.com',
+      to: 'sally@example.com',
+      subject: 'RAILGUN TEST SAMPLE',
+      body: text_content,
+      content_type: 'text/plain'
     }
-  }
+  end
   let(:text_content) { '[TEST] Hello, world.' }
 
-  let(:html_mail_option) {
+  let(:html_mail_option) do
     {
-      from:        'bob@example.com',
-      to:          'sally@example.com',
-      subject:     'RAILGUN TEST SAMPLE',
-      body:         html_content,
-      content_type: 'text/html',
+      from: 'bob@example.com',
+      to: 'sally@example.com',
+      subject: 'RAILGUN TEST SAMPLE',
+      body: html_content,
+      content_type: 'text/html'
     }
-  }
+  end
   let(:html_content) { '<h3> [TEST] </h3> <br/> Hello, world!' }
 
-  let(:amp_mail_option) {
+  let(:amp_mail_option) do
     {
-      from:        'bob@example.com',
-      to:          'sally@example.com',
-      subject:     'RAILGUN TEST SAMPLE',
-      body:         amp_content,
-      content_type: 'text/x-amp-html',
+      from: 'bob@example.com',
+      to: 'sally@example.com',
+      subject: 'RAILGUN TEST SAMPLE',
+      body: amp_content,
+      content_type: 'text/x-amp-html'
     }
-  }
+  end
   let(:amp_content) { '<h3> [TEST] </h3> <br/> Hello from AMP!' }
 
   context 'with <Content-Type: text/plain>' do
     let(:sample_mail) { Mail.new(text_mail_option) }
 
-    it 'should return body text' do
+    it 'returns body text' do
       expect(Railgun.extract_body_text(sample_mail)).to eq(text_content)
     end
 
-    it 'should not return body html' do
+    it 'does not return body html' do
       expect(Railgun.extract_body_html(sample_mail)).to be_nil
     end
   end
@@ -52,11 +53,11 @@ describe 'extract_body' do
   context 'with <Content-Type: text/html>' do
     let(:sample_mail) { Mail.new(html_mail_option) }
 
-    it 'should not return body text' do
+    it 'does not return body text' do
       expect(Railgun.extract_body_text(sample_mail)).to be_nil
     end
 
-    it 'should return body html' do
+    it 'returns body html' do
       expect(Railgun.extract_body_html(sample_mail)).to eq(html_content)
     end
   end
@@ -67,21 +68,21 @@ describe 'extract_body' do
     let(:amp_mail) { Mail.new(amp_mail_option) }
 
     before do
-      @sample_mail = Mail::Part.new(content_type: "multipart/alternative")
+      @sample_mail = Mail::Part.new(content_type: 'multipart/alternative')
       @sample_mail.add_part text_mail
       @sample_mail.add_part amp_mail
       @sample_mail.add_part html_mail
     end
 
-    it 'should return body text' do
+    it 'returns body text' do
       expect(Railgun.extract_body_text(@sample_mail)).to eq(text_content)
     end
 
-    it 'should return body html' do
+    it 'returns body html' do
       expect(Railgun.extract_body_html(@sample_mail)).to eq(html_content)
     end
 
-    it 'should return AMP html' do
+    it 'returns AMP html' do
       expect(Railgun.extract_amp_html(@sample_mail)).to eq(amp_content)
     end
   end

data/spec/unit/railgun/mailer_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'logger'
 require 'spec_helper'
@@ -15,42 +17,40 @@ class UnitTestMailer < ActionMailer::Base
   def plain_message(address, subject, headers)
     headers(headers)
     mail(to: address, subject: subject) do |format|
-      format.text { render plain: "Test!" }
-      format.html { render html: "<p>Test!</p>".html_safe }
+      format.text { render plain: 'Test!' }
+      format.html { render html: '<p>Test!</p>'.html_safe }
     end
   end
 
   def message_with_attachment(address, subject)
     attachments['info.txt'] = {
-      :content => File.read('docs/railgun/Overview.md'),
-      :mime_type => 'text/plain',
+      content: File.read('docs/railgun/Overview.md'),
+      mime_type: 'text/plain'
     }
     mail(to: address, subject: subject) do |format|
-      format.text { render plain: "Test!" }
-      format.html { render html: "<p>Test!</p>".html_safe }
+      format.text { render plain: 'Test!' }
+      format.html { render html: '<p>Test!</p>'.html_safe }
     end
   end
 
   def message_with_template(address, subject, template_name)
     mail(to: address, subject: subject, template: template_name) do |format|
-      format.text { render plain: "Test!" }
+      format.text { render plain: 'Test!' }
     end
   end
 
   def message_with_domain(address, subject, domain)
     mail(to: address, subject: subject, domain: domain) do |format|
-      format.text { render plain: "Test!" }
+      format.text { render plain: 'Test!' }
     end
   end
-
 end
 
 describe 'Railgun::Mailer' do
-
   it 'has a mailgun_client property which returns a Mailgun::Client' do
     config = {
-      api_key:  {},
-      domain:   {}
+      api_key: {},
+      domain: {}
     }
     @mailer_obj = Railgun::Mailer.new(config)
 
@@ -60,18 +60,18 @@ describe 'Railgun::Mailer' do
   context 'when config does not have api_key or domain' do
     it 'raises configuration error' do
       config = {
-        api_key:  {}
+        api_key: {}
       }
 
-    expect { Railgun::Mailer.new(config) }.to raise_error(Railgun::ConfigurationError)
+      expect { Railgun::Mailer.new(config) }.to raise_error(Railgun::ConfigurationError)
     end
   end
 
   context 'when fake_message_send is present in config' do
     it 'enables test mode' do
       config = {
-        api_key:  {},
-        domain:   {},
+        api_key: {},
+        domain: {},
         fake_message_send: true
       }
       client_double = double(Mailgun::Client)
@@ -100,7 +100,7 @@ describe 'Railgun::Mailer' do
   it 'adds options to message body' do
     message = UnitTestMailer.plain_message('test@example.org', '', {})
     message.mailgun_options ||= {
-      'tracking-opens' => 'true',
+      'tracking-opens' => 'true'
     }
 
     body = Railgun.transform_for_mailgun(message)
@@ -124,14 +124,14 @@ describe 'Railgun::Mailer' do
   it 'adds variables to message body' do
     message = UnitTestMailer.plain_message('test@example.org', '', {})
     message.mailgun_variables ||= {
-      'user' => {:id => '1', :name => 'tstark'},
+      'user' => { id: '1', name: 'tstark' }
     }
 
     body = Railgun.transform_for_mailgun(message)
 
     expect(body).to include('v:user')
 
-    var_body = JSON.load(body['v:user'])
+    var_body = JSON.parse(body['v:user'])
     expect(var_body).to include('id')
     expect(var_body).to include('name')
     expect(var_body['id']).to eq('1')
@@ -141,7 +141,7 @@ describe 'Railgun::Mailer' do
   it 'adds headers to message body' do
     message = UnitTestMailer.plain_message('test@example.org', '', {})
     message.mailgun_headers ||= {
-      'x-unit-test' => 'true',
+      'x-unit-test' => 'true'
     }
 
     body = Railgun.transform_for_mailgun(message)
@@ -152,8 +152,8 @@ describe 'Railgun::Mailer' do
 
   it 'adds headers to message body from mailer' do
     message = UnitTestMailer.plain_message('test@example.org', '', {
-      'x-unit-test-2' => 'true',
-    })
+                                             'x-unit-test-2' => 'true'
+                                           })
 
     body = Railgun.transform_for_mailgun(message)
 
@@ -162,21 +162,24 @@ describe 'Railgun::Mailer' do
   end
 
   it 'properly handles headers that are passed as separate POST params' do
-    message = UnitTestMailer.plain_message('test@example.org', 'Test!', {
-      # `From`, `To`, and `Subject` are set on the envelope, so they should be ignored as headers
-      'From' => 'units@example.net',
-      'To' => 'user@example.com',
-      'Subject' => 'This should disappear',
-      # If `Bcc` or `Cc` are set as headers, they should be carried over as POST params, not headers
-      'Bcc' => ['list@example.org'],
-      'Cc' => ['admin@example.com'],
-      # This is an arbitrary header and should be carried over properly
-      'X-Source' => 'unit tests',
-    })
+    message = UnitTestMailer.plain_message(
+      'test@example.org', 'Test!',
+      {
+        # `From`, `To`, and `Subject` are set on the envelope, so they should be ignored as headers
+        'From' => 'units@example.net',
+        'To' => 'user@example.com',
+        'Subject' => 'This should disappear',
+        # If `Bcc` or `Cc` are set as headers, they should be carried over as POST params, not headers
+        'Bcc' => ['list@example.org'],
+        'Cc' => ['admin@example.com'],
+        # This is an arbitrary header and should be carried over properly
+        'X-Source' => 'unit tests'
+      }
+    )
 
     body = Railgun.transform_for_mailgun(message)
 
-    ['From', 'To', 'Subject'].each do |header|
+    %w[From To Subject].each do |header|
       expect(body).not_to include("h:#{header}")
     end
 
@@ -202,20 +205,20 @@ describe 'Railgun::Mailer' do
         }
       end
       body = Railgun.transform_for_mailgun(message)
-      expect(body["v:my-data"]).to be_kind_of(String)
-      expect(body["v:my-data"].to_s).to eq('{"key":"value"}')
+      expect(body['v:my-data']).to be_a(String)
+      expect(body['v:my-data'].to_s).to eq('{"key":"value"}')
     end
 
     it 'accepts a hash and appends as data to the message.' do
       message = UnitTestMailer.plain_message('test@example.org', '', {}).tap do |message|
         message.mailgun_variables = {
-          'my-data' => {'key' => 'value'}
+          'my-data' => { 'key' => 'value' }
         }
       end
       body = Railgun.transform_for_mailgun(message)
 
-      expect(body["v:my-data"]).to be_kind_of(String)
-      expect(body["v:my-data"].to_s).to eq('{"key":"value"}')
+      expect(body['v:my-data']).to be_a(String)
+      expect(body['v:my-data'].to_s).to eq('{"key":"value"}')
     end
 
     it 'accepts string values' do
@@ -226,8 +229,8 @@ describe 'Railgun::Mailer' do
       end
       body = Railgun.transform_for_mailgun(message)
 
-      expect(body["v:my-data"]).to be_kind_of(String)
-      expect(body["v:my-data"].to_s).to eq('String Value.')
+      expect(body['v:my-data']).to be_a(String)
+      expect(body['v:my-data'].to_s).to eq('String Value.')
     end
   end
 
@@ -251,13 +254,13 @@ describe 'Railgun::Mailer' do
 
   it 'ignores `reply-to` in headers' do
     message = UnitTestMailer.plain_message('test@example.org', '', {
-      'reply-to' => 'user@example.com',
-    })
+                                             'reply-to' => 'user@example.com'
+                                           })
     message.mailgun_headers = {
-      'Reply-To' => 'administrator@example.org',
+      'Reply-To' => 'administrator@example.org'
     }
-    message.headers({'REPLY-TO' => 'admin@example.net'})
-    message.reply_to = "dude@example.com.au"
+    message.headers({ 'REPLY-TO' => 'admin@example.net' })
+    message.reply_to = 'dude@example.com.au'
 
     body = Railgun.transform_for_mailgun(message)
     expect(body).to include('h:reply-to')
@@ -267,12 +270,12 @@ describe 'Railgun::Mailer' do
 
   it 'ignores `mime-version` in headers' do
     message = UnitTestMailer.plain_message('test@example.org', '', {
-      'mime-version' => '1.0',
-    })
+                                             'mime-version' => '1.0'
+                                           })
     message.mailgun_headers = {
-      'Mime-Version' => '1.1',
+      'Mime-Version' => '1.1'
     }
-    message.headers({'MIME-VERSION' => '1.2'})
+    message.headers({ 'MIME-VERSION' => '1.2' })
 
     body = Railgun.transform_for_mailgun(message)
     expect(body).not_to include('h:mime-version')
@@ -280,32 +283,32 @@ describe 'Railgun::Mailer' do
 
   it 'treats `headers()` names as case-insensitve' do
     message = UnitTestMailer.plain_message('test@example.org', '', {
-      'X-BIG-VALUE' => 1,
-    })
+                                             'X-BIG-VALUE' => 1
+                                           })
 
     body = Railgun.transform_for_mailgun(message)
     expect(body).to include('h:x-big-value')
-    expect(body['h:x-big-value']).to eq("1")
+    expect(body['h:x-big-value']).to eq('1')
   end
 
   it 'treats `mailgun_headers` names as case-insensitive' do
     message = UnitTestMailer.plain_message('test@example.org', '', {})
     message.mailgun_headers = {
-      'X-BIG-VALUE' => 1,
+      'X-BIG-VALUE' => 1
     }
 
     body = Railgun.transform_for_mailgun(message)
     expect(body).to include('h:x-big-value')
-    expect(body['h:x-big-value']).to eq("1")
+    expect(body['h:x-big-value']).to eq('1')
   end
 
   it 'handles multi-value, mixed case headers correctly' do
     message = UnitTestMailer.plain_message('test@example.org', '', {})
     message.headers({
-      'x-neat-header' => 'foo',
-      'X-Neat-Header' => 'bar',
-      'X-NEAT-HEADER' => 'zoop',
-    })
+                      'x-neat-header' => 'foo',
+                      'X-Neat-Header' => 'bar',
+                      'X-NEAT-HEADER' => 'zoop'
+                    })
 
     body = Railgun.transform_for_mailgun(message)
     expect(body).to include('h:x-neat-header')

data/spec/unit/response_spec.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'json'
+require 'yaml'
+require 'mailgun/response'
+require 'mailgun/exceptions/exceptions'
+
+describe Mailgun::Response do
+  subject(:response) { described_class.new(http_response) }
+
+  let(:json_body) { '{"id":"<message-id@example.com>","message":"Queued. Thank you."}' }
+  let(:status200) { 200 }
+
+  # Minimal double that mimics a RestClient::Response
+  let(:http_response) do
+    double('http_response', body: json_body, status: status200)
+  end
+
+  # ---------------------------------------------------------------------------
+  # .new
+  # ---------------------------------------------------------------------------
+  describe '#initialize' do
+    it 'sets body from the underlying response' do
+      expect(response.body).to eq(json_body)
+    end
+
+    it 'sets status from the underlying response' do
+      expect(response.status).to eq(status200)
+    end
+
+    it 'aliases code to status' do
+      expect(response.code).to eq(status200)
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # .from_hash
+  # ---------------------------------------------------------------------------
+  describe '.from_hash' do
+    subject(:from_hash_response) do
+      described_class.from_hash(body: json_body, status: status200)
+    end
+
+    it 'returns a Response instance' do
+      expect(from_hash_response).to be_a(described_class)
+    end
+
+    it 'sets body from the hash' do
+      expect(from_hash_response.body).to eq(json_body)
+    end
+
+    it 'sets status from the hash' do
+      expect(from_hash_response.status).to eq(status200)
+    end
+
+    it 'aliases code to status' do
+      expect(from_hash_response.code).to eq(status200)
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # #to_h
+  # ---------------------------------------------------------------------------
+  describe '#to_h' do
+    it 'returns a Hash' do
+      expect(response.to_h).to be_a(Hash)
+    end
+
+    it 'correctly parses the JSON body' do
+      result = response.to_h
+      expect(result['id']).to eq('<message-id@example.com>')
+      expect(result['message']).to eq('Queued. Thank you.')
+    end
+
+    it 'does not mutate the body attribute' do
+      expect { response.to_h }.not_to(change(response, :body))
+    end
+
+    context 'when the body is invalid JSON' do
+      let(:http_response) { double('http_response', body: 'not-json', status: 200) }
+
+      it 'raises a Mailgun::ParseError' do
+        expect { response.to_h }.to raise_error(Mailgun::ParseError)
+      end
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # #to_h!
+  # ---------------------------------------------------------------------------
+  describe '#to_h!' do
+    it 'returns a Hash' do
+      expect(response.to_h!).to be_a(Hash)
+    end
+
+    it 'correctly parses the JSON body' do
+      result = response.to_h!
+      expect(result['message']).to eq('Queued. Thank you.')
+    end
+
+    it 'replaces body with the parsed Hash' do
+      response.to_h!
+      expect(response.body).to be_a(Hash)
+      expect(response.body['id']).to eq('<message-id@example.com>')
+    end
+
+    context 'when the body is invalid JSON' do
+      let(:http_response) { double('http_response', body: 'not-json', status: 200) }
+
+      it 'raises a Mailgun::ParseError' do
+        expect { response.to_h! }.to raise_error(Mailgun::ParseError)
+      end
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # #to_yaml
+  # ---------------------------------------------------------------------------
+  describe '#to_yaml' do
+    it 'returns a String' do
+      expect(response.to_yaml).to be_a(String)
+    end
+
+    it 'returns valid YAML that round-trips back to the expected hash' do
+      parsed = YAML.safe_load(response.to_yaml)
+      expect(parsed['id']).to eq('<message-id@example.com>')
+      expect(parsed['message']).to eq('Queued. Thank you.')
+    end
+
+    it 'does not mutate the body attribute' do
+      expect { response.to_yaml }.not_to(change(response, :body))
+    end
+
+    context 'when the body is invalid JSON' do
+      let(:http_response) { double('http_response', body: 'not-json', status: 200) }
+
+      it 'raises a Mailgun::ParseError' do
+        expect { response.to_yaml }.to raise_error(Mailgun::ParseError)
+      end
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # #to_yaml!
+  # ---------------------------------------------------------------------------
+  describe '#to_yaml!' do
+    it 'returns a String' do
+      expect(response.to_yaml!).to be_a(String)
+    end
+
+    it 'returns valid YAML that round-trips back to the expected hash' do
+      yaml_str = response.to_yaml!
+      parsed = YAML.safe_load(yaml_str)
+      expect(parsed['message']).to eq('Queued. Thank you.')
+    end
+
+    it 'replaces body with the YAML string' do
+      response.to_yaml!
+      expect(response.body).to be_a(String)
+      expect(response.body).to include('Queued. Thank you.')
+    end
+
+    context 'when the body is invalid JSON' do
+      let(:http_response) { double('http_response', body: 'not-json', status: 200) }
+
+      it 'raises a Mailgun::ParseError' do
+        expect { response.to_yaml! }.to raise_error(Mailgun::ParseError)
+      end
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # #success?
+  # ---------------------------------------------------------------------------
+  describe '#success?' do
+    context 'with a 2xx status code' do
+      [200, 201, 204, 299].each do |code|
+        it "returns true for status #{code}" do
+          allow(http_response).to receive(:status).and_return(code)
+          expect(described_class.new(http_response).success?).to be(true)
+        end
+      end
+    end
+
+    context 'with a non-2xx status code' do
+      [400, 401, 403, 404, 422, 500, 503].each do |code|
+        it "returns false for status #{code}" do
+          allow(http_response).to receive(:status).and_return(code)
+          expect(described_class.new(http_response).success?).to be(false)
+        end
+      end
+    end
+
+    it 'returns false for status 199 (just below 2xx range)' do
+      allow(http_response).to receive(:status).and_return(199)
+      expect(described_class.new(http_response).success?).to be(false)
+    end
+
+    it 'returns false for status 300 (just above 2xx range)' do
+      allow(http_response).to receive(:status).and_return(300)
+      expect(described_class.new(http_response).success?).to be(false)
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # attr_accessor sanity checks
+  # ---------------------------------------------------------------------------
+  describe 'attribute accessors' do
+    it 'allows body to be overwritten' do
+      response.body = 'new body'
+      expect(response.body).to eq('new body')
+    end
+
+    it 'allows status to be overwritten' do
+      response.status = 404
+      expect(response.status).to eq(404)
+    end
+
+    it 'allows code to be overwritten' do
+      response.code = 500
+      expect(response.code).to eq(500)
+    end
+  end
+end

data/vcr_cassettes/For_the_suppressions_handling_class/creates_a_single_bounce.yml

@@ -0,0 +1,55 @@
+---
+http_interactions:
+- request:
+    method: post
+    uri: https://api.mailgun.net/bounces
+    body:
+      encoding: UTF-8
+      string: address=test5%40example.info&code=500&error=integration+testing
+    headers:
+      User-Agent:
+      - mailgun-sdk-ruby/1.4.2
+      Accept:
+      - "*/*"
+      Authorization:
+      - Basic XXX
+      Content-Type:
+      - application/x-www-form-urlencoded
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Access-Control-Allow-Credentials:
+      - 'true'
+      Access-Control-Allow-Origin:
+      - "*"
+      Cache-Control:
+      - no-store
+      Content-Length:
+      - '89'
+      Content-Type:
+      - application/json; charset=utf-8
+      Date:
+      - Wed, 25 Mar 2026 18:09:17 GMT
+      Strict-Transport-Security:
+      - max-age=63072000; includeSubDomains
+      X-Mailgun-Key-Id:
+      - XXX
+      X-Request-Limit:
+      - '2500'
+      X-Request-Remaining:
+      - '2498'
+      X-Request-Reset:
+      - '1774462171770'
+      X-Xss-Protection:
+      - 1; mode=block
+    body:
+      encoding: UTF-8
+      string: '{"message":"Address has been added to the bounces table","address":"test5@example.info"}
+
+        '
+  recorded_at: Wed, 25 Mar 2026 18:09:17 GMT
+recorded_with: VCR 6.4.0