mailgun-ruby 1.4.5 → 1.4.6

data/spec/unit/exceptions/exceptions_spec.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Mailgun::CommunicationError do
-  describe '.new' do
-    context "when the Response body doesn't have a `message` property" do
-      it "doesn't raise an error" do
-        expect do
-          described_class.new('Boom!', { status: 401, body: '{}' })
-        end.not_to raise_error
-      end
-
-      context 'when the Response body has an `Error` property' do
-        it 'uses the `Error` property as the API message' do
-          subject = described_class.new('Boom!', { status: 401, body: '{"Error":"unauthorized"}' })
-
-          expect(subject.message).to eq('Boom!: unauthorized')
-        end
-      end
-
-      context 'when the Response body has an `error` property' do
-        it 'uses the `Error` property as the API message' do
-          subject = described_class.new('Boom!', { status: 401, body: '{"error":"not found"}' })
-
-          expect(subject.message).to eq('Boom!: not found')
-        end
-      end
-    end
-  end
-end

data/spec/unit/helpers/api_version_checker_spec.rb

@@ -1,206 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-require 'mailgun'
-require 'mailgun/helpers/api_version_checker'
-
-describe Mailgun::ApiVersionChecker do
-  # Build a minimal host class that includes the module, with a controllable
-  # @client so we can set api_version per example.
-  subject(:instance) { host_class.new(client) }
-
-  let(:client) { double(:client) }
-
-  let(:host_class) do
-    Class.new do
-      include Mailgun::ApiVersionChecker
-
-      attr_reader :result
-
-      def initialize(client)
-        @client = client
-      end
-
-      def do_something(arg = nil)
-        @result = arg || :called
-      end
-    end
-  end
-
-  # ──────────────────────────────────────────────────────────────────────────
-  # .included / module structure
-  # ──────────────────────────────────────────────────────────────────────────
-
-  describe '.included' do
-    it 'extends the including class with ClassMethods' do
-      expect(host_class).to respond_to(:requires_api_version)
-      expect(host_class).to respond_to(:enforces_api_version)
-    end
-
-    it 'does not expose ClassMethods as instance methods' do
-      expect(instance).not_to respond_to(:requires_api_version)
-      expect(instance).not_to respond_to(:enforces_api_version)
-    end
-  end
-
-  # ──────────────────────────────────────────────────────────────────────────
-  # .requires_api_version  (warns but still calls through)
-  # ──────────────────────────────────────────────────────────────────────────
-
-  describe '.requires_api_version' do
-    before { host_class.requires_api_version('v3', :do_something) }
-
-    context 'when the client is on the expected version' do
-      before { allow(client).to receive(:api_version).and_return('v3') }
-
-      it 'does not emit a warning' do
-        expect { instance.do_something }.not_to output.to_stderr
-      end
-
-      it 'still calls the original method' do
-        instance.do_something(:payload)
-        expect(instance.result).to eq(:payload)
-      end
-
-      it 'forwards all arguments to the original method' do
-        instance.do_something(:forwarded_arg)
-        expect(instance.result).to eq(:forwarded_arg)
-      end
-    end
-
-    context 'when the client is on a different version' do
-      before { allow(client).to receive(:api_version).and_return('v4') }
-
-      it 'emits a warning to stderr' do
-        expect { instance.do_something }
-          .to output(/WARN: Client api version must be v3/).to_stderr
-      end
-
-      it 'still calls the original method despite the warning' do
-        instance.do_something(:payload)
-        expect(instance.result).to eq(:payload)
-      end
-
-      it 'warning message includes the expected version' do
-        expect { instance.do_something }
-          .to output(/v3/).to_stderr
-      end
-    end
-
-    it 'wraps multiple methods when given a list' do
-      host_class.class_eval { def do_other = @result = :other }
-      host_class.requires_api_version('v3', :do_something, :do_other)
-
-      allow(client).to receive(:api_version).and_return('v4')
-
-      expect { instance.do_something }.to output(/v3/).to_stderr
-      expect { instance.do_other }.to output(/v3/).to_stderr
-    end
-
-    it 'wraps only the listed methods, leaving others unwrapped' do
-      host_class.class_eval { def unwrapped = @result = :unwrapped }
-      host_class.requires_api_version('v3', :do_something)
-
-      allow(client).to receive(:api_version).and_return('v4')
-
-      # unwrapped should not warn
-      expect { instance.unwrapped }.not_to output.to_stderr
-    end
-  end
-
-  # ──────────────────────────────────────────────────────────────────────────
-  # .enforces_api_version  (raises on version mismatch)
-  # ──────────────────────────────────────────────────────────────────────────
-
-  describe '.enforces_api_version' do
-    before { host_class.enforces_api_version('v3', :do_something) }
-
-    context 'when the client is on the expected version' do
-      before { allow(client).to receive(:api_version).and_return('v3') }
-
-      it 'does not raise' do
-        expect { instance.do_something }.not_to raise_error
-      end
-
-      it 'calls the original method' do
-        instance.do_something(:payload)
-        expect(instance.result).to eq(:payload)
-      end
-
-      it 'forwards all arguments to the original method' do
-        instance.do_something(:forwarded_arg)
-        expect(instance.result).to eq(:forwarded_arg)
-      end
-    end
-
-    context 'when the client is on a different version' do
-      before { allow(client).to receive(:api_version).and_return('v4') }
-
-      it 'raises Mailgun::ParameterError' do
-        expect { instance.do_something }
-          .to raise_error(Mailgun::ParameterError)
-      end
-
-      it 'raises with a message including the expected version' do
-        expect { instance.do_something }
-          .to raise_error(Mailgun::ParameterError, /v3/)
-      end
-
-      it 'does not call the original method' do
-        begin
-          instance.do_something
-        rescue StandardError
-          nil
-        end
-        expect(instance.result).to be_nil
-      end
-    end
-
-    it 'wraps multiple methods when given a list' do
-      host_class.class_eval { def do_other = @result = :other }
-      host_class.enforces_api_version('v3', :do_something, :do_other)
-
-      allow(client).to receive(:api_version).and_return('v4')
-
-      expect { instance.do_something }.to raise_error(Mailgun::ParameterError)
-      expect { instance.do_other }.to raise_error(Mailgun::ParameterError)
-    end
-
-    it 'wraps only the listed methods, leaving others unwrapped' do
-      host_class.class_eval { def unwrapped = @result = :unwrapped }
-      host_class.enforces_api_version('v3', :do_something)
-
-      allow(client).to receive(:api_version).and_return('v4')
-
-      expect { instance.unwrapped }.not_to raise_error
-    end
-  end
-
-  # ──────────────────────────────────────────────────────────────────────────
-  # requires vs enforces contrast
-  # ──────────────────────────────────────────────────────────────────────────
-
-  describe 'requires_api_version vs enforces_api_version' do
-    before do
-      host_class.class_eval do
-        def soft_method = @result = :soft
-        def hard_method = @result = :hard
-      end
-      host_class.requires_api_version('v3', :soft_method)
-      host_class.enforces_api_version('v3', :hard_method)
-
-      allow(client).to receive(:api_version).and_return('v4')
-    end
-
-    it 'requires_api_version warns but does not raise' do
-      expect { instance.soft_method }.to output(/v3/).to_stderr
-      expect(instance.result).to eq(:soft)
-    end
-
-    it 'enforces_api_version raises and does not call through' do
-      expect { instance.hard_method }.to raise_error(Mailgun::ParameterError)
-      expect(instance.result).not_to eq(:hard)
-    end
-  end
-end

data/spec/unit/lists/opt_in_handler_spec.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe 'The method generate_hash' do
-  before do
-    @mailing_list = 'mylist@example.com'
-    @secret_app_id = 'mysupersecretpassword'
-    @recipient_address = 'bob@example.com'
-    @precalculated_hash =
-      "eyJoIjoiMmY3ZmY1MzFlOGJmMjA0OWNhMTI3ZmU4ZTQyNjZkOTljYzhkMTdk%0AMiIsInAiOiJleUpzSWpv\
-aWJYbHNhWE4wUUdWNFlXMXdiR1V1WTI5dElpd2lj%0AaUk2SW1KdllrQmxlR0Z0Y0d4bExtTnZcbmJTSjlcbiJ9%0A"
-  end
-
-  it 'generates a web safe hash for the recipient wishing to subscribe' do
-    my_hash = Mailgun::OptInHandler.generate_hash(@mailing_list, @secret_app_id, @recipient_address)
-
-    expect(my_hash).to eq(@precalculated_hash)
-  end
-
-  it 'generates a web safe hash for the recipient wishing to subscribe' do
-    validate_result = Mailgun::OptInHandler.validate_hash(@secret_app_id, @precalculated_hash)
-
-    expect(validate_result.length).to eq(2)
-    expect(validate_result['recipient_address']).to eq(@recipient_address)
-    expect(validate_result['mailing_list']).to eq(@mailing_list)
-  end
-end

data/spec/unit/mailgun_spec.rb

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe 'Mailgun instantiation' do
-  it 'instantiates an HttpClient object' do
-    expect { @mg_obj = Mailgun::UnitClient.new('messages') }.not_to raise_error
-  end
-end
-
-describe 'The method send_message()' do
-  before do
-    @mg_obj = Mailgun::UnitClient.new('messages')
-    @domain = 'test.com'
-    @list_address = 'mylist@test.com'
-    @member_address = 'subscribee@test.com'
-  end
-
-  it 'accepts only specific data types' do
-    @mb_obj = Mailgun::MessageBuilder.new
-    @mh_obj = {}
-
-    expect { @mg_obj.send_message('test.com', 'incorrect data') }.to raise_error Mailgun::ParameterError
-    expect { @mg_obj.send_message('test.com', @mb_obj) }.not_to raise_error
-    expect { @mg_obj.send_message('test.com', @mh_obj) }.not_to raise_error
-  end
-
-  it 'sends a message' do
-    data = { 'from' => 'joe@test.com',
-             'to' => 'bob@example.com',
-             'subject' => 'Test',
-             'text' => 'Test Data' }
-    result = @mg_obj.send_message('testdomain.com', data)
-
-    result.to_h!
-
-    expect(result.body).to include('message')
-    expect(result.body).to include('id')
-  end
-
-  it 'opens the message MIME and sends the MIME message.' do
-    data = {
-      'to' => 'joe@test.com',
-      'message' => 'Sample Data/mime.txt',
-      'from' => 'joe@test.com'
-    }
-    result = @mg_obj.send_message('testdomain.com', data)
-
-    result.to_h!
-
-    expect(result.body).to include('message')
-    expect(result.body).to include('id')
-  end
-
-  context 'when domain is missing' do
-    it 'shows failure message' do
-      expect(@mg_obj).to receive(:raise)
-      @mg_obj.send_message(nil, {})
-    end
-  end
-
-  context 'when to is missing' do
-    it 'shows failure message' do
-      data = {
-        'to' => '',
-        'message' => 'Sample Data/mime.txt',
-        'from' => 'joe@test.com'
-      }
-      expect(@mg_obj).to receive(:raise)
-      @mg_obj.send_message('testdomain.com', data)
-    end
-  end
-end
-
-describe 'The method post()' do
-  before do
-    @mg_obj = Mailgun::UnitClient.new('messages')
-    @domain = 'test.com'
-  end
-
-  it 'in this case, sends a simple message.' do
-    data = { 'from' => 'joe@test.com',
-             'to' => 'bob@example.com',
-             'subject' => 'Test',
-             'text' => 'Test Data' }
-    result = @mg_obj.post("#{@domain}/messages", data)
-
-    result.to_h!
-
-    expect(result.body).to include('message')
-    expect(result.body).to include('id')
-  end
-
-  context 'when Unknown API error is raised' do
-    before do
-      allow(Mailgun::Response).to receive(:new).and_raise(StandardError, 'message')
-      allow(JSON).to receive(:parse).and_raise('Unknown')
-    end
-
-    it 'adds Unknown API error to message' do
-      data = { 'from' => 'joe@test.com',
-               'to' => 'bob@example.com',
-               'subject' => 'Test',
-               'text' => 'Test Data' }
-      @mg_obj.post("#{@domain}/messages", data)
-    rescue Mailgun::CommunicationError => e
-      expect(e.message).to eq('message: Unknown API error')
-    else
-      raise
-    end
-  end
-end
-
-describe 'The method put()' do
-  before do
-    @mg_obj = Mailgun::UnitClient.new('lists')
-    @domain = 'test.com'
-    @list_address = 'mylist@test.com'
-    @member_address = 'subscribee@test.com'
-  end
-
-  it 'in this case, updates a member with the attributes in data.' do
-    data = { 'subscribed' => false,
-             'name' => 'Foo Bar' }
-    result = @mg_obj.put("lists/#{@list_address}/members#{@member_address}", data)
-
-    result.to_h!
-
-    expect(result.body).to include('member')
-    expect(result.body['member']).to include('vars')
-    expect(result.body['member']['vars']).to include('age')
-    expect(result.body['member']).to include('name')
-    expect(result.body['member']).to include('subscribed')
-    expect(result.body['member']).to include('address')
-    expect(result.body).to include('message')
-  end
-end
-
-describe 'The method get()' do
-  before do
-    @mg_obj = Mailgun::UnitClient.new('bounces')
-    @domain = 'test.com'
-  end
-
-  it 'in this case, obtains a list of bounces for the domain, limit of 5, skipping the first 10.' do
-    query_string = { 'skip' => '10',
-                     'limit' => '5' }
-    result = @mg_obj.get("#{@domain}/bounces", query_string)
-
-    result.to_h!
-
-    expect(result.body).to include('total_count')
-    expect(result.body).to include('items')
-  end
-end
-
-describe 'The method delete()' do
-  before do
-    @mg_obj = Mailgun::UnitClient.new('campaigns')
-    @domain = 'test.com'
-  end
-
-  it 'issues a generic delete request.' do
-    result = @mg_obj.delete("#{@domain}/campaigns/ABC123")
-
-    result.to_h!
-
-    expect(result.body).to include('message')
-    expect(result.body).to include('id')
-  end
-end

data/spec/unit/messages/batch_message_spec.rb

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe 'BatchMessage attribute readers' do
-  it 'is readable' do
-    @mb_client = Mailgun::UnitClient.new('messages')
-    @mb_obj = Mailgun::BatchMessage.new(@mb_client, 'example.com')
-
-    expect(@mb_obj).to respond_to(:message_ids)
-    expect(@mb_obj).to respond_to(:message)
-    expect(@mb_obj).to respond_to(:counters)
-    expect(@mb_obj).to respond_to(:recipient_variables)
-    expect(@mb_obj).to respond_to(:domain)
-  end
-end
-
-describe 'The instantiation of Batch Message' do
-  before do
-    @mb_client = Mailgun::UnitClient.new('messages')
-    @mb_obj = Mailgun::BatchMessage.new(@mb_client, 'example.com')
-  end
-
-  it 'contains Message, which should be of type Hash and empty' do
-    expect(@mb_obj.message).to be_a(Hash)
-    expect(@mb_obj.message.length).to eq(0)
-  end
-
-  it 'contains recipient_variables, which should be of type Hash and empty' do
-    expect(@mb_obj.recipient_variables).to be_a(Hash)
-    expect(@mb_obj.recipient_variables.length).to eq(0)
-  end
-
-  it 'contains domain, which should be of type string and contain example.com' do
-    expect(@mb_obj.domain).to be_a(String)
-    expect(@mb_obj.domain).to eq('example.com')
-  end
-
-  it 'contains message_ids, which should be of type hash and empty' do
-    expect(@mb_obj.message_ids).to be_a(Hash)
-    expect(@mb_obj.message_ids.length).to eq(0)
-  end
-
-  it 'contains counters, which should be of type hash and contain several important counters' do
-    expect(@mb_obj.counters).to be_a(Hash)
-    expect(@mb_obj.counters).to include(:recipients)
-  end
-
-  it 'contains counters, which should be of type hash and contain several important counters' do
-    expect(@mb_obj.counters).to be_a(Hash)
-
-    expect(@mb_obj.counters).to include(:recipients)
-    expect(@mb_obj.counters[:recipients]).to include(:to)
-    expect(@mb_obj.counters[:recipients]).to include(:cc)
-    expect(@mb_obj.counters[:recipients]).to include(:bcc)
-
-    expect(@mb_obj.counters).to include(:attributes)
-    expect(@mb_obj.counters[:attributes]).to include(:attachment)
-    expect(@mb_obj.counters[:attributes]).to include(:campaign_id)
-    expect(@mb_obj.counters[:attributes]).to include(:custom_option)
-    expect(@mb_obj.counters[:attributes]).to include(:tag)
-  end
-end
-
-describe 'The method add_recipient' do
-  before do
-    @mb_client = Mailgun::UnitClient.new('messages')
-    @mb_obj = Mailgun::BatchMessage.new(@mb_client, 'example.com')
-    @address1   = 'jane@example.com'
-    @variables1 = { 'first' => 'Jane', 'last' => 'Doe', 'tracking' => 'ABC123' }
-    @address2   = 'bob@example.com'
-    @variables2 = { 'first' => 'Bob', 'last' => 'Doe', 'tracking' => 'DEF123' }
-    @address3   = 'sam@example.com'
-    @variables3 = { 'first' => 'Sam', 'last' => 'Doe', 'tracking' => 'GHI123' }
-  end
-
-  context 'when from is present' do
-    before do
-      @mb_obj.from('example@email.com')
-    end
-
-    it 'adds 1,000 recipients to the message body and validates counter is incremented then reset' do
-      recipient_type = :to
-      1000.times do
-        @mb_obj.add_recipient(recipient_type, @address1, @variables1)
-      end
-
-      expect(@mb_obj.counters[:recipients][recipient_type]).to eq(1000)
-
-      @mb_obj.add_recipient(recipient_type, @address1, @variables1)
-
-      expect(@mb_obj.counters[:recipients][recipient_type]).to eq(1)
-    end
-
-    it 'adds recipients to the message, calls finalize, and cleans up' do
-      recipient_type = :to
-      1000.times do
-        @mb_obj.add_recipient(recipient_type, @address1, @variables1)
-      end
-
-      expect(@mb_obj.counters[:recipients][recipient_type]).to eq(1000)
-      @mb_obj.finalize
-
-      expect(@mb_obj.recipient_variables).to eq({})
-      expect(@mb_obj.message['recipient-variables'].length).to eq(0)
-      expect(@mb_obj.message[:to].length).to eq(0)
-      expect(@mb_obj.counters[:recipients][recipient_type]).to eq(0)
-    end
-
-    it 'adds 5,005 recipients to the message body and validates we receive message_ids back' do
-      recipient_type = :to
-      5005.times do
-        @mb_obj.add_recipient(recipient_type, @address1, @variables1)
-      end
-      @mb_obj.finalize
-
-      expect(@mb_obj.message_ids.length).to eq(6)
-    end
-
-    it 'sets recipient-variables, for batch expansion' do
-      recipient_type = :to
-      @mb_obj.add_recipient(recipient_type, @address1, @variables1)
-
-      expect(@mb_obj.recipient_variables[@address1]).to eq(@variables1)
-    end
-
-    it 'sets multiple recipient-variables, for batch expansion' do
-      recipient_type = :to
-      @mb_obj.add_recipient(recipient_type, @address1, @variables1)
-      @mb_obj.add_recipient(recipient_type, @address2, @variables2)
-      @mb_obj.add_recipient(recipient_type, @address3, @variables3)
-
-      expect(@mb_obj.recipient_variables[@address1]).to eq(@variables1)
-      expect(@mb_obj.recipient_variables[@address2]).to eq(@variables2)
-      expect(@mb_obj.recipient_variables[@address3]).to eq(@variables3)
-    end
-  end
-
-  context 'when from is empty' do
-    it 'shows error message' do
-      recipient_type = :to
-      @mb_obj.add_recipient(recipient_type, @address1, @variables1)
-      @mb_obj.add_recipient(recipient_type, @address2, @variables2)
-      expect(@mb_client).to receive(:raise)
-      @mb_obj.finalize
-    end
-  end
-end