mailgun-ruby 1.4.1 → 1.4.3

data/spec/integration/routes_spec.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'mailgun'
 
-vcr_opts = { :cassette_name => "routes", :match_requests_on => [:uri, :method, :body] }
+vcr_opts = { cassette_name: 'routes', match_requests_on: %i[uri method body] }
 
 describe 'For the Routes endpoint', order: :defined, vcr: vcr_opts do
   before(:all) do
@@ -12,79 +14,78 @@ describe 'For the Routes endpoint', order: :defined, vcr: vcr_opts do
   end
 
   it 'creates a route' do
-    result = @mg_obj.post("routes",  { priority: 10,
-                                       description: 'Integration Test Route',
-                                       expression: "match_recipient(\"#{@forward_to}\")",
-                                       action: "forward(\"#{@recipient}\")" })
+    result = @mg_obj.post('routes', { priority: 10,
+                                      description: 'Integration Test Route',
+                                      expression: "match_recipient(\"#{@forward_to}\")",
+                                      action: "forward(\"#{@recipient}\")" })
 
     result.to_h!
-    expect(result.body["message"]).to eq("Route has been created")
-    expect(result.body["route"]["description"]).to eq("Integration Test Route")
-    expect(result.body["route"]["actions"]).to include("forward(\"#{@recipient}\")")
-    expect(result.body["route"]["expression"]).to include("match_recipient(\"#{@forward_to}\")")
-    expect(result.body["route"]["priority"]).to eq(10)
+    expect(result.body['message']).to eq('Route has been created')
+    expect(result.body['route']['description']).to eq('Integration Test Route')
+    expect(result.body['route']['actions']).to include("forward(\"#{@recipient}\")")
+    expect(result.body['route']['expression']).to include("match_recipient(\"#{@forward_to}\")")
+    expect(result.body['route']['priority']).to eq(10)
   end
 
   it 'creates a route with multiple actions' do
-    result = @mg_obj.post("routes",  { priority: 10,
-                                       description: 'Integration Test Route',
-                                       expression: "match_recipient(\"#{@forward_to}\")",
-                                       action: ["forward(\"#{@recipient}\")", "stop()"] })
+    result = @mg_obj.post('routes', { priority: 10,
+                                      description: 'Integration Test Route',
+                                      expression: "match_recipient(\"#{@forward_to}\")",
+                                      action: ["forward(\"#{@recipient}\")", 'stop()'] })
 
     result.to_h!
-    expect(result.body["message"]).to eq("Route has been created")
-    expect(result.body["route"]["description"]).to eq("Integration Test Route")
-    expect(result.body["route"]["actions"].count).to eq 2
-    expect(result.body["route"]["actions"][0]).to include("forward(\"#{@recipient}\")")
-    expect(result.body["route"]["actions"][1]).to include("stop()")
-    expect(result.body["route"]["expression"]).to include("match_recipient(\"#{@forward_to}\")")
-    expect(result.body["route"]["priority"]).to eq(10)
+    expect(result.body['message']).to eq('Route has been created')
+    expect(result.body['route']['description']).to eq('Integration Test Route')
+    expect(result.body['route']['actions'].count).to eq 2
+    expect(result.body['route']['actions'][0]).to include("forward(\"#{@recipient}\")")
+    expect(result.body['route']['actions'][1]).to include('stop()')
+    expect(result.body['route']['expression']).to include("match_recipient(\"#{@forward_to}\")")
+    expect(result.body['route']['priority']).to eq(10)
   end
 
   it 'gets a list of all routes.' do
-    result = @mg_obj.get("routes", {:limit => 50})
+    result = @mg_obj.get('routes', { limit: 50 })
 
     result.to_h!
-    expect(result.body["total_count"]).to be > 0
+    expect(result.body['total_count']).to be > 0
   end
 
   it 'gets the route.' do
-    result = @mg_obj.get("routes", {:limit => 1})
+    result = @mg_obj.get('routes', { limit: 1 })
     route_id = result.to_h['items'].first['id']
 
     result = @mg_obj.get("routes/#{route_id}")
 
     result.to_h!
-    expect(result.body["route"]["description"]).to eq("Integration Test Route")
-    expect(result.body["route"]["actions"]).to include("forward(\"#{@recipient}\")")
-    expect(result.body["route"]["expression"]).to include("match_recipient(\"#{@forward_to}\")")
-    expect(result.body["route"]["priority"]).to eq(10)
+    expect(result.body['route']['description']).to eq('Integration Test Route')
+    expect(result.body['route']['actions']).to include("forward(\"#{@recipient}\")")
+    expect(result.body['route']['expression']).to include("match_recipient(\"#{@forward_to}\")")
+    expect(result.body['route']['priority']).to eq(10)
   end
 
   it 'updates the route.' do
-    result = @mg_obj.get("routes", {:limit => 1})
+    result = @mg_obj.get('routes', { limit: 1 })
     route_id = result.to_h['items'].first['id']
 
-    result = @mg_obj.put("routes/#{route_id}",  {:priority => 10,
-                                                  :description => 'Integration Test Route Update',
-                                                  :expression => "match_recipient(\"#{@forward_to}\")",
-                                                  :action => "forward(\"#{@recipient}\")"})
+    result = @mg_obj.put("routes/#{route_id}", { priority: 10,
+                                                 description: 'Integration Test Route Update',
+                                                 expression: "match_recipient(\"#{@forward_to}\")",
+                                                 action: "forward(\"#{@recipient}\")" })
 
     result.to_h!
-    expect(result.body["message"]).to eq("Route has been updated")
-    expect(result.body["description"]).to eq("Integration Test Route Update")
-    expect(result.body["actions"]).to include("forward(\"#{@recipient}\")")
-    expect(result.body["expression"]).to include("match_recipient(\"#{@forward_to}\")")
-    expect(result.body["priority"]).to eq(10)
+    expect(result.body['message']).to eq('Route has been updated')
+    expect(result.body['description']).to eq('Integration Test Route Update')
+    expect(result.body['actions']).to include("forward(\"#{@recipient}\")")
+    expect(result.body['expression']).to include("match_recipient(\"#{@forward_to}\")")
+    expect(result.body['priority']).to eq(10)
   end
 
   it 'removes a route' do
-    result = @mg_obj.get("routes", {:limit => 1})
+    result = @mg_obj.get('routes', { limit: 1 })
     route_id = result.to_h['items'].first['id']
 
     @mg_obj.delete("routes/#{route_id}")
 
     result.to_h!
   end
-
 end

data/spec/integration/stats_spec.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'mailgun'
 
-vcr_opts = { :cassette_name => "stats" }
+vcr_opts = { cassette_name: 'stats' }
 
 describe 'For the Stats endpoint', vcr: vcr_opts do
   before(:all) do
@@ -10,6 +12,6 @@ describe 'For the Stats endpoint', vcr: vcr_opts do
   end
 
   it 'get some stats.' do
-    @mg_obj.get("#{@domain}/stats", {:limit => 50, :skip => 10, :event => 'sent'})
+    @mg_obj.get("#{@domain}/stats", { limit: 50, skip: 10, event: 'sent' })
   end
 end

data/spec/integration/subaccounts_spec.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'mailgun'
 
-vcr_opts = { :cassette_name => "subaccounts" }
+vcr_opts = { cassette_name: 'subaccounts' }
 
 describe 'For the subaccounts endpoints', vcr: vcr_opts do
   let(:name) { 'test.subaccount' }
@@ -16,7 +18,8 @@ describe 'For the subaccounts endpoints', vcr: vcr_opts do
     it 'returns a list of templates' do
       result = @mg_obj.list
 
-      expect(result).to eq({"subaccounts"=>[{"id"=>"xxx", "name"=>"test-ruby-lib", "status"=>"open"}], "total"=>1})
+      expect(result).to eq({ 'subaccounts' => [{ 'id' => 'xxx', 'name' => 'test-ruby-lib', 'status' => 'open' }],
+                             'total' => 1 })
     end
   end
 
@@ -24,26 +27,23 @@ describe 'For the subaccounts endpoints', vcr: vcr_opts do
     it 'creates the subaccount' do
       result = @mg_obj.create(name)
 
-      expect(result).to eq({"subaccount"=>{"id"=>"xxx", "name"=>"test.subaccount", "status"=>"open"}})
+      expect(result).to eq({ 'subaccount' => { 'id' => 'xxx', 'name' => 'test.subaccount', 'status' => 'open' } })
     end
   end
 
-
   describe '#info' do
     it 'gets the templates info' do
       result = @mg_obj.info(subaccount_id)
 
-      expect(result).to eq({"subaccount"=>{"id"=>"xxx", "name"=>"test-ruby-lib", "status"=>"open"}})
+      expect(result).to eq({ 'subaccount' => { 'id' => 'xxx', 'name' => 'test-ruby-lib', 'status' => 'open' } })
     end
   end
 
-
-
   describe '#enable' do
     it 'enables the subaccount' do
       result = @mg_obj.enable(subaccount_id)
 
-      expect(result).to eq({"subaccount"=>{"id"=>"xxx", "name"=>"test-ruby-lib", "status"=>"open"}})
+      expect(result).to eq({ 'subaccount' => { 'id' => 'xxx', 'name' => 'test-ruby-lib', 'status' => 'open' } })
     end
   end
 
@@ -51,8 +51,7 @@ describe 'For the subaccounts endpoints', vcr: vcr_opts do
     it 'disables the subaccount' do
       result = @mg_obj.disable(subaccount_id)
 
-      expect(result).to eq({"subaccount"=>{"id"=>"xxx", "name"=>"test-ruby-lib", "status"=>"disabled"}})
+      expect(result).to eq({ 'subaccount' => { 'id' => 'xxx', 'name' => 'test-ruby-lib', 'status' => 'disabled' } })
     end
   end
-
 end

data/spec/integration/suppressions_spec.rb

@@ -1,30 +1,28 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 require 'mailgun'
 require 'mailgun/suppressions'
 
-vcr_opts = { :cassette_name => 'suppressions' }
+vcr_opts = { cassette_name: 'suppressions', match_requests_on: %i[uri method body] }
 
 describe 'For the suppressions handling class', order: :defined, vcr: vcr_opts do
-
-  before(:all) do
-    @mg_obj = Mailgun::Client.new(APIKEY)
-    @suppress = Mailgun::Suppressions.new(@mg_obj, TESTDOMAIN)
-
-    @addresses = ['test1@example.com', 'test2@example.org', 'test3@example.net', 'test4@example.info']
-  end
+  let(:mg_obj) { Mailgun::Client.new(APIKEY, APIHOST, 'v3') }
+  let(:suppress) { Mailgun::Suppressions.new(mg_obj, TESTDOMAIN) }
+  let(:addresses) { %w[test1@example.com test2@example.org test3@example.net test4@example.info] }
 
   it 'can batch-add bounces' do
     bounces = []
-    @addresses.each do |addr|
+    addresses.each do |addr|
       bounces.push({
-        :address => addr,
-        :code => 500,
-        :error => 'integration testing',
-      })
+                     address: addr,
+                     code: 500,
+                     error: 'integration testing'
+                   })
     end
 
-    response, nested = @suppress.create_bounces bounces
+    response, nested = suppress.create_bounces bounces
     response.to_h!
 
     expect(response.code).to eq(200)
@@ -35,16 +33,44 @@ describe 'For the suppressions handling class', order: :defined, vcr: vcr_opts d
   it 'raises ParameterError if no bounce[:address] is present' do
     bounces = []
     bounces.push({
-      :code => 500,
-      :error => 'integration testing',
-    })
+                   code: 500,
+                   error: 'integration testing'
+                 })
+
+    expect { suppress.create_bounces bounces }.to raise_error(Mailgun::ParameterError)
+  end
 
-    expect { @suppress.create_bounces bounces }.to raise_error(Mailgun::ParameterError)
+  it 'returns nil if no bounces passed' do
+    response = suppress.create_bounces({})
+
+    expect(response[0]).to be_nil
+  end
+
+  it 'creates a single bounce' do
+    bounce = {
+      address: 'test777@example.info',
+      code: 777,
+      error: 'integration testing123'
+    }
+
+    response = suppress.create_bounce bounce
+    response.to_h!
+
+    expect(response.code).to eq(200)
+    expect(response.body['message']).to eq('Address has been added to the bounces table')
+  end
+
+  it 'fetches a single bounce' do
+    response = suppress.get_bounce('test777@example.info')
+    response.to_h!
+
+    expect(response.code).to eq(200)
+    expect(response.body['address']).to eq('test777@example.info')
   end
 
   it 'removes a single bounce address' do
-    @addresses.each do |addr|
-      response = @suppress.delete_bounce addr
+    addresses.each do |addr|
+      response = suppress.delete_bounce addr
       response.to_h!
 
       expect(response.code).to eq(200)
@@ -52,16 +78,24 @@ describe 'For the suppressions handling class', order: :defined, vcr: vcr_opts d
     end
   end
 
+  it 'removes all bounces' do
+    response = suppress.delete_all_bounces
+    response.to_h!
+
+    expect(response.code).to eq(200)
+    expect(response.body['message']).to eq('Bounced addresses for this domain have been removed')
+  end
+
   it 'can batch-add unsubscribes with tags as string' do
     unsubscribes = []
-    @addresses.each do |addr|
+    addresses.each do |addr|
       unsubscribes.push({
-        :address => addr,
-        :tag => 'integration',
-      })
+                          address: addr,
+                          tag: '123'
+                        })
     end
 
-    response, nested = @suppress.create_unsubscribes unsubscribes
+    response, nested = suppress.create_unsubscribes unsubscribes
     response.to_h!
 
     expect(response.code).to eq(200)
@@ -71,14 +105,31 @@ describe 'For the suppressions handling class', order: :defined, vcr: vcr_opts d
 
   it 'can batch-add unsubscribes with tags as array' do
     unsubscribes = []
-    @addresses.each do |addr|
+    addresses.each do |addr|
       unsubscribes.push({
-        :address => addr,
-        :tags => ['integration'],
-      })
+                          address: addr,
+                          tags: ['integration']
+                        })
     end
 
-    response, nested = @suppress.create_unsubscribes unsubscribes
+    response, nested = suppress.create_unsubscribes unsubscribes
+    response.to_h!
+
+    expect(response.code).to eq(200)
+    expect(response.body['message']).to eq('4 addresses have been added to the unsubscribes table')
+    expect(nested.length).to eq(0)
+  end
+
+  it 'can batch-add unsubscribes with tags as digits' do
+    unsubscribes = []
+    addresses.each do |addr|
+      unsubscribes.push({
+                          address: addr,
+                          tag: 123
+                        })
+    end
+
+    response, nested = suppress.create_unsubscribes unsubscribes
     response.to_h!
 
     expect(response.code).to eq(200)
@@ -89,15 +140,21 @@ describe 'For the suppressions handling class', order: :defined, vcr: vcr_opts d
   it 'raises ParameterError if no unsubscribe[:address] is present' do
     unsubscribes = []
     unsubscribes.push({
-      :tag => 'integration',
-    })
+                        tag: 'integration'
+                      })
 
-    expect { @suppress.create_unsubscribes unsubscribes }.to raise_error(Mailgun::ParameterError)
+    expect { suppress.create_unsubscribes unsubscribes }.to raise_error(Mailgun::ParameterError)
+  end
+
+  it 'returns nil if no unsubscribes passed' do
+    response = suppress.create_unsubscribes({})
+
+    expect(response[0]).to be_nil
   end
 
   it 'removes a single unsubscribe address' do
-    @addresses.each do |addr|
-      response = @suppress.delete_unsubscribe addr
+    addresses.each do |addr|
+      response = suppress.delete_unsubscribe addr
       response.to_h!
 
       expect(response.code).to eq(200)
@@ -105,13 +162,40 @@ describe 'For the suppressions handling class', order: :defined, vcr: vcr_opts d
     end
   end
 
+  it 'creates a single unsubscribe' do
+    response = suppress.create_unsubscribe({
+                                             address: 'test777@example.com',
+                                             tags: ['integration']
+                                           })
+    response.to_h!
+
+    expect(response.code).to eq(200)
+    expect(response.body['message']).to eq('Address has been added to the unsubscribes table')
+  end
+
+  it 'returns a single unsubscribe' do
+    response = suppress.get_unsubscribe('test777@example.com')
+    response.to_h!
+
+    expect(response.code).to eq(200)
+    expect(response.body['address']).to eq('test777@example.com')
+  end
+
+  it 'returns all unsubscribers' do
+    response = suppress.list_unsubscribes
+    response.to_h!
+
+    expect(response.code).to eq(200)
+    expect(response.body['items'][0]['address']).to eq('test777@example.com')
+  end
+
   it 'can batch-add complaints' do
     complaints = []
-    @addresses.each do |addr|
-      complaints.push :address => addr
+    addresses.each do |addr|
+      complaints.push address: addr
     end
 
-    response, nested = @suppress.create_complaints complaints
+    response, nested = suppress.create_complaints complaints
     response.to_h!
 
     expect(response.code).to eq(200)
@@ -122,15 +206,45 @@ describe 'For the suppressions handling class', order: :defined, vcr: vcr_opts d
   it 'raises ParameterError if no complaint[:address] is present' do
     complaints = []
     complaints.push({
-      :tag => 'integration',
-    })
+                      tag: 'integration'
+                    })
+
+    expect { suppress.create_complaints complaints }.to raise_error(Mailgun::ParameterError)
+  end
 
-    expect { @suppress.create_complaints complaints }.to raise_error(Mailgun::ParameterError)
+  it 'returns nil if no complaints passed' do
+    response = suppress.create_complaints({})
+
+    expect(response[0]).to be_nil
+  end
+
+  it 'creates a single complaint' do
+    response = suppress.create_complaint({ address: 'test777@example.com' })
+    response.to_h!
+
+    expect(response.code).to eq(200)
+    expect(response.body['message']).to eq('Address has been added to the complaints table')
+  end
+
+  it 'returns a single complaint' do
+    response = suppress.get_complaint('test777@example.com')
+    response.to_h!
+
+    expect(response.code).to eq(200)
+    expect(response.body['address']).to eq('test777@example.com')
+  end
+
+  it 'returns all complaints' do
+    response = suppress.list_complaints
+    response.to_h!
+
+    expect(response.code).to eq(200)
+    expect(response.body['items'][0]['address']).to eq('test1@example.com')
   end
 
   it 'removes a single complaint address' do
-    @addresses.each do |addr|
-      response = @suppress.delete_complaint addr
+    addresses.each do |addr|
+      response = suppress.delete_complaint addr
       response.to_h!
 
       expect(response.code).to eq(200)
@@ -138,5 +252,69 @@ describe 'For the suppressions handling class', order: :defined, vcr: vcr_opts d
     end
   end
 
-  # TODO: Add tests for pagination support.
+  describe 'paging' do
+    before do
+      suppress.list_bounces
+    end
+
+    describe '#next' do
+      it 'returns the response' do
+        resp = suppress.next
+        expect(resp.status).to eq(200)
+        expect(JSON.parse(resp.body)).to include('items')
+      end
+    end
+
+    describe '#prev' do
+      it 'returns the response' do
+        resp = suppress.prev
+        expect(resp.status).to eq(200)
+        expect(JSON.parse(resp.body)).to include('items')
+      end
+    end
+  end
+
+  context 'with 1000 or more entries' do
+    subject(:suppressions) { Mailgun::Suppressions.new(client, domain) }
+
+    let(:large_list) { Array.new(1000) { |i| { address: "user#{i}@example.com" } } }
+    let(:client)  { double(:client) }
+    let(:domain)  { 'example.com' }
+
+    def stub_response(body = {})
+      double(:response).tap do |r|
+        allow(r).to receive_messages(to_h: body, to_h!: body, code: 200, body: body)
+      end
+    end
+
+    it 'splits bounces list and makes two POST requests' do
+      expect(client).to receive(:post)
+        .with('example.com/bounces', anything, { 'Content-Type' => 'application/json' })
+        .twice
+        .and_return(stub_response)
+
+      _resp, split = suppressions.create_bounces(large_list)
+      expect(split).not_to be_empty
+    end
+
+    it 'splits unsubscribes list and makes two POST requests' do
+      expect(client).to receive(:post)
+        .with('example.com/unsubscribes', anything, { 'Content-Type' => 'application/json' })
+        .twice
+        .and_return(stub_response)
+
+      _resp, split = suppressions.create_unsubscribes(large_list)
+      expect(split).not_to be_empty
+    end
+
+    it 'splits complaints list and makes two POST requests' do
+      expect(client).to receive(:post)
+        .with('example.com/complaints', anything, { 'Content-Type' => 'application/json' })
+        .twice
+        .and_return(stub_response)
+
+      _resp, split = suppressions.create_complaints(large_list)
+      expect(split).not_to be_empty
+    end
+  end
 end

data/spec/integration/templates_spec.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'mailgun'
 
-vcr_opts = { :cassette_name => "templates" }
+vcr_opts = { cassette_name: 'templates' }
 
 describe 'For the templates endpoints', vcr: vcr_opts do
   let(:template_name) { 'test.template' }
-  let(:domain) { "integration-test.domain.invalid" }
+  let(:domain) { 'integration-test.domain.invalid' }
   let(:tag) { 'v2' }
 
   before(:all) do
@@ -21,14 +23,14 @@ describe 'For the templates endpoints', vcr: vcr_opts do
           name: template_name,
           description: 'Test',
           template: '{{fname}} {{lname}}',
-            comment: 'test comment',
-            headers: '{"Subject": "{{subject}}"}',
-            tag: 'V1'
+          comment: 'test comment',
+          headers: '{"Subject": "{{subject}}"}',
+          tag: 'V1'
         }
       )
 
-      expect(result['template']["name"]).to eq('test.template')
-      expect(result['template']["description"]).to eq("Test")
+      expect(result['template']['name']).to eq('test.template')
+      expect(result['template']['description']).to eq('Test')
     end
   end
 
@@ -36,8 +38,8 @@ describe 'For the templates endpoints', vcr: vcr_opts do
     it 'gets the templates info' do
       result = @mg_obj.info(domain, 'test.template')
 
-      expect(result).to include("template")
-      expect(result["template"]["name"]).to eq(template_name)
+      expect(result).to include('template')
+      expect(result['template']['name']).to eq(template_name)
     end
   end
 
@@ -88,7 +90,7 @@ describe 'For the templates endpoints', vcr: vcr_opts do
         }
       )
 
-      expect(result['template']["version"]['tag']).to eq(tag)
+      expect(result['template']['version']['tag']).to eq(tag)
     end
   end
 
@@ -96,7 +98,7 @@ describe 'For the templates endpoints', vcr: vcr_opts do
     it "gets the template's version info" do
       result = @mg_obj.info_version(domain, template_name, tag)
 
-      expect(result["template"]["version"]['tag']).to eq(tag)
+      expect(result['template']['version']['tag']).to eq(tag)
     end
   end
 
@@ -121,7 +123,7 @@ describe 'For the templates endpoints', vcr: vcr_opts do
     it "returns template's versions" do
       result = @mg_obj.template_versions_list(domain, template_name)
 
-      expect(result["template"]["versions"].first).to include('tag')
+      expect(result['template']['versions'].first).to include('tag')
     end
   end