mailgun-ruby 1.4.5 → 1.4.6

data/spec/unit/client_spec.rb

@@ -1,448 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'mailgun'
-require 'mailgun/exceptions/exceptions'
-
-describe Mailgun::Client do
-  # ---------------------------------------------------------------------------
-  # Shared helpers
-  # ---------------------------------------------------------------------------
-  # Build a client in test mode so no real HTTP calls are ever made.
-  subject(:client) { described_class.new(api_key, 'api.mailgun.net', 'v3', true, true) }
-
-  let(:api_key)    { 'test-api-key-abc123' }
-  let(:message_params) do
-    {
-      from: 'bob@example.com',
-      to: 'sally@example.com',
-      subject: 'Hello!',
-      text: 'Test body.'
-    }
-  end
-  let(:domain) { 'example.com' }
-
-  # Fake HTTP response double reusable across examples
-  def fake_http_response(body: '{"message":"ok"}', status: 200)
-    double('http_response', body: body, status: status)
-  end
-
-  # ---------------------------------------------------------------------------
-  # .new / #initialize
-  # ---------------------------------------------------------------------------
-  describe '#initialize' do
-    it 'instantiates without raising' do
-      expect { described_class.new(api_key) }.not_to raise_error
-    end
-
-    it 'stores the api_version' do
-      c = described_class.new(api_key, 'api.mailgun.net', 'v3')
-      expect(c.api_version).to eq('v3')
-    end
-
-    it 'defaults test_mode to false when not specified' do
-      # Pass test_mode = false explicitly to avoid picking up global config
-      c = described_class.new(api_key, 'api.mailgun.net', 'v3', true, false)
-      expect(c.test_mode?).to be(false)
-    end
-
-    it 'accepts test_mode = true' do
-      c = described_class.new(api_key, 'api.mailgun.net', nil, true, true)
-      expect(c.test_mode?).to be(true)
-    end
-
-    it 'supports EU api host' do
-      expect { described_class.new(api_key, 'api.eu.mailgun.net') }.not_to raise_error
-    end
-
-    context 'when test_mode is not passed' do
-      around do |example|
-        original = Mailgun.test_mode
-        example.run
-      ensure
-        Mailgun.test_mode = original
-      end
-
-      it 'enables test mode when Mailgun.test_mode is true' do
-        Mailgun.test_mode = true
-        expect(described_class.new(api_key).test_mode?).to be(true)
-      end
-
-      it 'disables test mode when Mailgun.test_mode is false' do
-        Mailgun.test_mode = false
-        expect(described_class.new(api_key).test_mode?).to be(false)
-      end
-
-      it 'disables test mode when Mailgun.test_mode is not set' do
-        Mailgun.test_mode = nil
-        expect(described_class.new(api_key).test_mode?).to be(false)
-      end
-    end
-  end
-
-  # ---------------------------------------------------------------------------
-  # #test_mode?
-  # ---------------------------------------------------------------------------
-  describe '#test_mode?' do
-    it 'returns true when the client is in test mode' do
-      expect(client.test_mode?).to be(true)
-    end
-
-    it 'returns false when test mode has been disabled' do
-      client.disable_test_mode!
-      expect(client.test_mode?).to be(false)
-    end
-  end
-
-  # ---------------------------------------------------------------------------
-  # #enable_test_mode!
-  # ---------------------------------------------------------------------------
-  describe '#enable_test_mode!' do
-    subject(:non_test_client) do
-      described_class.new(api_key, 'api.mailgun.net', 'v3', true, false)
-    end
-
-    it 'sets test_mode to true' do
-      non_test_client.enable_test_mode!
-      expect(non_test_client.test_mode?).to be(true)
-    end
-  end
-
-  # ---------------------------------------------------------------------------
-  # #disable_test_mode!
-  # ---------------------------------------------------------------------------
-  describe '#disable_test_mode!' do
-    it 'sets test_mode to false' do
-      client.disable_test_mode!
-      expect(client.test_mode?).to be(false)
-    end
-  end
-
-  # ---------------------------------------------------------------------------
-  # .deliveries
-  # ---------------------------------------------------------------------------
-  describe '.deliveries' do
-    before { described_class.deliveries.clear }
-
-    it 'returns an Array' do
-      expect(described_class.deliveries).to be_an(Array)
-    end
-
-    it 'accumulates messages sent in test mode' do
-      client.send_message(domain, message_params)
-      expect(described_class.deliveries).not_to be_empty
-    end
-
-    it 'stores the message data sent in test mode' do
-      client.send_message(domain, message_params)
-      expect(described_class.deliveries.last).to include(from: 'bob@example.com')
-    end
-
-    it 'accumulates multiple deliveries' do
-      2.times { client.send_message(domain, message_params) }
-      expect(described_class.deliveries.size).to eq(2)
-    end
-  end
-
-  # ---------------------------------------------------------------------------
-  # #send_message — test mode
-  # ---------------------------------------------------------------------------
-  describe '#send_message (test mode)' do
-    before { described_class.deliveries.clear }
-
-    it 'returns a Mailgun::Response' do
-      result = client.send_message(domain, message_params)
-      expect(result).to be_a(Mailgun::Response)
-    end
-
-    it 'returns a 200 status response in test mode' do
-      result = client.send_message(domain, message_params)
-      expect(result.code).to eq(200)
-    end
-
-    it 'returns a body containing the Queued message in test mode' do
-      result = client.send_message(domain, message_params)
-      body = JSON.parse(result.body)
-      expect(body['message']).to eq('Queued. Thank you.')
-    end
-
-    it 'returns a body with a unique test-mode message id' do
-      result = client.send_message(domain, message_params)
-      body = JSON.parse(result.body)
-      expect(body['id']).to match(/test-mode-mail-.+@localhost/)
-    end
-
-    it 'does not make real HTTP calls in test mode' do
-      expect(client.instance_variable_get(:@http_client)).not_to receive(:post)
-      client.send_message(domain, message_params)
-    end
-
-    it 'records a copy of message data in .deliveries' do
-      client.send_message(domain, message_params)
-      expect(described_class.deliveries.last[:subject]).to eq('Hello!')
-    end
-
-    context 'with a MessageBuilder object' do
-      it 'stores the MessageBuilder in .deliveries' do
-        mb = Mailgun::MessageBuilder.new
-        mb.set_from_address('bob@example.com')
-        mb.add_recipient(:to, 'sally@example.com')
-        mb.set_subject('Hello via builder!')
-        mb.set_text_body('Body text.')
-
-        result = client.send_message(domain, mb)
-        expect(result).to be_a(Mailgun::Response)
-        expect(described_class.deliveries.last).to be_a(Mailgun::MessageBuilder)
-      end
-
-      it 'raises a Mailgun::ParameterError when mb is empty' do
-        mb = Mailgun::MessageBuilder.new
-
-        expect { client.send_message(domain, mb) }
-          .to raise_error(Mailgun::ParameterError)
-      end
-
-      it 'raises a Mailgun::ParameterError when from is missing' do
-        mb = Mailgun::MessageBuilder.new
-        mb.add_recipient(:to, 'sally@example.com')
-
-        expect { client.send_message(domain, mb) }
-          .to raise_error(Mailgun::ParameterError)
-      end
-    end
-  end
-
-  # ---------------------------------------------------------------------------
-  # #send_message — live mode (HTTP mocked at the Faraday level)
-  # ---------------------------------------------------------------------------
-  describe '#send_message (live mode)' do
-    subject(:live_client) do
-      described_class.new(api_key, 'api.mailgun.net', 'v3', true, false)
-    end
-
-    let(:success_response) { fake_http_response }
-
-    before do
-      allow(live_client.instance_variable_get(:@http_client))
-        .to receive(:post)
-        .and_return(success_response)
-    end
-
-    it 'posts to the messages endpoint and returns a Response' do
-      result = live_client.send_message(domain, message_params)
-      expect(result).to be_a(Mailgun::Response)
-    end
-
-    it 'strips nil values from the data hash before posting' do
-      params_with_nil = message_params.merge(cc: nil)
-      http = live_client.instance_variable_get(:@http_client)
-      expect(http).to receive(:post) do |_path, data, *|
-        expect(data).not_to have_key(:cc)
-        success_response
-      end
-      live_client.send_message(domain, params_with_nil)
-    end
-
-    it 'raises CommunicationError when the underlying request fails' do
-      allow(live_client.instance_variable_get(:@http_client))
-        .to receive(:post)
-        .and_raise(StandardError, 'connection refused')
-
-      expect { live_client.send_message(domain, message_params) }
-        .to raise_error(Mailgun::CommunicationError)
-    end
-
-    context 'with a MessageBuilder object' do
-      it 'posts to the messages endpoint and returns a Response' do
-        mb = Mailgun::MessageBuilder.new
-        mb.set_from_address('bob@example.com')
-        mb.add_recipient(:to, 'sally@example.com')
-        mb.set_subject('Hello via builder!')
-        mb.set_text_body('Body text.')
-
-        result = live_client.send_message(domain, mb)
-        expect(result).to be_a(Mailgun::Response)
-      end
-    end
-  end
-
-  # ---------------------------------------------------------------------------
-  # #get
-  # ---------------------------------------------------------------------------
-  describe '#get' do
-    let(:http_response) { fake_http_response }
-
-    before do
-      allow(client.instance_variable_get(:@http_client))
-        .to receive(:get)
-        .and_return(http_response)
-    end
-
-    it 'returns a Mailgun::Response' do
-      result = client.get("#{domain}/events", { event: 'delivered' })
-      expect(result).to be_a(Mailgun::Response)
-    end
-
-    it 'passes the resource path through to the http client' do
-      http = client.instance_variable_get(:@http_client)
-      expect(http).to receive(:get).with("#{domain}/events", anything, anything)
-                                   .and_return(http_response)
-      client.get("#{domain}/events")
-    end
-
-    it 'raises CommunicationError on failure' do
-      allow(client.instance_variable_get(:@http_client))
-        .to receive(:get)
-        .and_raise(StandardError, 'timeout')
-
-      expect { client.get("#{domain}/events") }
-        .to raise_error(Mailgun::CommunicationError)
-    end
-  end
-
-  # ---------------------------------------------------------------------------
-  # #post
-  # ---------------------------------------------------------------------------
-  describe '#post' do
-    let(:http_response) { fake_http_response }
-
-    before do
-      allow(client.instance_variable_get(:@http_client))
-        .to receive(:post)
-        .and_return(http_response)
-    end
-
-    it 'returns a Mailgun::Response' do
-      result = client.post("#{domain}/messages", message_params)
-      expect(result).to be_a(Mailgun::Response)
-    end
-
-    it 'raises CommunicationError on failure' do
-      allow(client.instance_variable_get(:@http_client))
-        .to receive(:post)
-        .and_raise(StandardError, 'connection error')
-
-      expect { client.post("#{domain}/messages", message_params) }
-        .to raise_error(Mailgun::CommunicationError)
-    end
-  end
-
-  # ---------------------------------------------------------------------------
-  # #put
-  # ---------------------------------------------------------------------------
-  describe '#put' do
-    let(:http_response) { fake_http_response }
-
-    before do
-      allow(client.instance_variable_get(:@http_client))
-        .to receive(:put)
-        .and_return(http_response)
-    end
-
-    it 'returns a Mailgun::Response' do
-      result = client.put("#{domain}/routes/abc123", { description: 'updated' })
-      expect(result).to be_a(Mailgun::Response)
-    end
-
-    it 'raises CommunicationError on failure' do
-      allow(client.instance_variable_get(:@http_client))
-        .to receive(:put)
-        .and_raise(StandardError, 'connection error')
-
-      expect { client.put("#{domain}/routes/abc123", {}) }
-        .to raise_error(Mailgun::CommunicationError)
-    end
-  end
-
-  # ---------------------------------------------------------------------------
-  # #delete
-  # ---------------------------------------------------------------------------
-  describe '#delete' do
-    let(:http_response) { fake_http_response(body: '{"message":"Bounced address has been removed"}') }
-
-    before do
-      allow(client.instance_variable_get(:@http_client))
-        .to receive(:delete)
-        .and_return(http_response)
-    end
-
-    it 'returns a Mailgun::Response' do
-      result = client.delete("#{domain}/bounces/test@example.com")
-      expect(result).to be_a(Mailgun::Response)
-    end
-
-    it 'raises CommunicationError on failure' do
-      allow(client.instance_variable_get(:@http_client))
-        .to receive(:delete)
-        .and_raise(StandardError, 'connection error')
-
-      expect { client.delete("#{domain}/bounces/test@example.com") }
-        .to raise_error(Mailgun::CommunicationError)
-    end
-
-    it 'sends params in the request' do
-      result = client.delete("#{domain}/bounces/test@example.com", params: 'test')
-      expect(result).to be_a(Mailgun::Response)
-    end
-
-    it 'sends params in the request when body_params truthy' do
-      result = client.delete("#{domain}/bounces/test@example.com", params: 'test', body_params: true)
-      expect(result).to be_a(Mailgun::Response)
-    end
-  end
-
-  # ---------------------------------------------------------------------------
-  # #set_api_key
-  # ---------------------------------------------------------------------------
-  describe '#set_api_key' do
-    it 'does not raise when updating the api key' do
-      expect { client.set_api_key('new-key-xyz') }.not_to raise_error
-    end
-  end
-
-  # ---------------------------------------------------------------------------
-  # #set_subaccount / #reset_subaccount
-  # ---------------------------------------------------------------------------
-  describe '#set_subaccount' do
-    it 'adds the subaccount header to the http client' do
-      client.set_subaccount('subaccount-id-123')
-      headers = client.instance_variable_get(:@http_client).headers
-      expect(headers[Mailgun::Client::SUBACCOUNT_HEADER]).to eq('subaccount-id-123')
-    end
-  end
-
-  describe '#reset_subaccount' do
-    it 'removes the subaccount header from the http client' do
-      client.set_subaccount('subaccount-id-123')
-      client.reset_subaccount
-      headers = client.instance_variable_get(:@http_client).headers
-      expect(headers[Mailgun::Client::SUBACCOUNT_HEADER]).to be_nil
-    end
-  end
-
-  # ---------------------------------------------------------------------------
-  # #suppressions
-  # ---------------------------------------------------------------------------
-  describe '#suppressions' do
-    it 'returns a Mailgun::Suppressions instance' do
-      expect(client.suppressions(domain)).to be_a(Mailgun::Suppressions)
-    end
-
-    it 'scopes the suppressions client to the given domain' do
-      suppressions = client.suppressions(domain)
-      expect(suppressions).to be_a(Mailgun::Suppressions)
-    end
-  end
-
-  # ---------------------------------------------------------------------------
-  # Mailgun.configure integration
-  # ---------------------------------------------------------------------------
-  describe 'Mailgun.configure integration' do
-    after { Mailgun.instance_variable_set(:@configuration, nil) }
-
-    it 'picks up the api_key from Mailgun.configure' do
-      Mailgun.configure { |config| config.api_key = 'configured-key' }
-      expect { described_class.new }.not_to raise_error
-    end
-  end
-end

data/spec/unit/connection/test_client.rb

@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-require 'time'
-require 'json'
-
-module Mailgun
-  class UnitClient < Mailgun::Client
-    attr_reader :options, :block, :body, :code, :response
-
-    def initialize(endpoint, &block)
-      @block = block
-      @endpoint = endpoint
-      @body = nil
-      @code = nil
-    end
-
-    def [](endpoint, &new_block)
-      if block_given?
-        self.class.new(endpoint, &new_block)
-      elsif block
-        self.class.new(endpoint, &block)
-      else
-        self.class.new(endpoint)
-      end
-    end
-
-    def send_message(working_domain, data)
-      perform_data_validation(working_domain, data)
-      case data
-      when Hash
-        if data.key?(:message)
-          data[:message] = convert_string_to_file(data[:message]) if data[:message].is_a?(String)
-          post("#{working_domain}/messages.mime", data)
-        else
-          post("#{working_domain}/messages", data)
-        end
-      when MessageBuilder
-        post("#{working_domain}/messages", data.message)
-      else
-        raise ParameterError.new('Unknown data type for data parameter.', data)
-      end
-    end
-
-    def post(_path, _data)
-      Mailgun::Response.new(response_generator(@endpoint))
-    rescue StandardError => e
-      p e
-      raise CommunicationError.new(e), e.response if e.respond_to? :response
-
-      raise CommunicationError, e.message
-    end
-
-    def get(_path, _query_string = nil)
-      Mailgun::Response.new(response_generator(@endpoint))
-    rescue StandardError => e
-      raise CommunicationError.new(e), e.response
-    end
-
-    def put(_path, _data)
-      Mailgun::Response.new(response_generator(@endpoint))
-    rescue StandardError => e
-      raise CommunicationError.new(e), e.response
-    end
-
-    def delete(_path)
-      Mailgun::Response.new(response_generator(@endpoint))
-    rescue StandardError => e
-      raise CommunicationError.new(e), e.response
-    end
-
-    private
-
-    def perform_data_validation(working_domain, data)
-      raise ParameterError.new('Missing working domain', working_domain) unless working_domain
-      return true unless data.is_a?(Hash) && data.present?
-
-      message = data.respond_to?(:message) ? data.message : data
-
-      if message.fetch('to', []).empty? && message.fetch(:to, []).empty?
-        raise ParameterError.new(
-          'Missing `to` recipient, message should contain at least 1 recipient',
-          working_domain
-        )
-      end
-      return unless message.fetch('from', []).empty? && message.fetch(:from, []).empty?
-
-      raise ParameterError.new(
-        'Missing a `from` sender, message should contain at least 1 `from` sender',
-        working_domain
-      )
-    end
-
-    def response_generator(resource_endpoint)
-      if resource_endpoint == 'messages'
-        t = Time.now
-        id = "<#{t.to_i}.#{rand(99_999_999)}.5817@example.com>"
-        return Response.from_hash({ body: JSON.generate({ 'message' => 'Queued. Thank you.', 'id' => id }) })
-      end
-      if resource_endpoint == 'bounces'
-        return Response.from_hash(
-          { body: JSON.generate(
-            {
-              'total_count' => 1,
-              'items' =>
-                {
-                  'created_at' => 'Fri, 21 Oct 2011 11:02:55 GMT',
-                  'status' => 550,
-                  'address' => 'baz@example.com',
-                  'error' => "Message was not accepted -- invalid mailbox. \
-Local mailbox baz@example.com is unavailable: user not found"
-                }
-            }
-          ) }
-        )
-      end
-      if resource_endpoint == 'lists'
-        return Response.from_hash(
-          { body: JSON.generate(
-            {
-              'member' =>
-                {
-                  'vars' => { 'age' => 26 },
-                  'name' => 'Foo Bar',
-                  'subscribed' => false,
-                  'address' => 'bar@example.com'
-                },
-              'message' => 'Mailing list member has been updated'
-            }
-          ) }
-        )
-      end
-      if resource_endpoint == 'campaigns'
-        return Response.from_hash(
-          {
-            body: JSON.generate(
-              {
-                'message' => 'Campaign has been deleted',
-                'id' => 'ABC123'
-              }
-            )
-          }
-        )
-      end
-      return unless resource_endpoint == 'events'
-
-      Response.from_hash(
-        { body: JSON.generate(
-          { 'items' => [],
-            'paging' => {
-              'next' =>
-                "https://api.mailgun.net/v3/thisisatestdomainformailgun.com/events/W3siYiI6I\
-CIyMDE0LTA1LTA3VDAwOjQ1OjUxLjc0MDg5MiswMDowMCIsICJlIjogIjIwMTQtMDUtMDVUMDA6NDU6NTEuNzQwOTgzK\
-zAwOjAwIn0sIHsiYiI6ICIyMDE0LTA1LTA3VDAwOjQ1OjUxLjc0MDg5MiswMDowMCIsICJlIjogIjIwMTQtMDUtMDVUM\
-DA6NDU6NTEuNzQwOTgzKzAwOjAwIn0sIFsiZiJdLCBudWxsLCB7ImFjY291bnQuaWQiOiAiNGU4MjMwZjYxNDc2ZDg2N\
-zEzMDBjNDc2IiwgImRvbWFpbi5uYW1lIjogInRoaXNpc2F0ZXN0ZG9tYWluZm9ybWFpbGd1bi5jb20iLCAic2V2ZXJpd\
-HkiOiAiTk9UIGludGVybmFsIn0sIDEwMCwgbnVsbF0=",
-              'previous' =>
-                "https://api.mailgun.net/v2/thisisatestdomainformailgun.com/events/W3siYiI6IC\
-IyMDE0LTA1LTA3VDAwOjQ1OjUxLjc0MDg5MiswMDowMCIsICJlIjogIjIwMTQtMDUtMDVUMDA6NDU6NTEuNzQwOTgzKzA\
-wOjAwIn0sIHsiYiI6ICIyMDE0LTA1LTA3VDAwOjQ1OjUxLjc0MDg5MiswMDowMCIsICJlIjogIjIwMTQtMDUtMDdUMDA6\
-NDU6NTEuNzQxODkyKzAwOjAwIn0sIFsicCIsICJmIl0sIG51bGwsIHsiYWNjb3VudC5pZCI6ICI0ZTgyMzBmNjE0NzZkO\
-DY3MTMwMGM0NzYiLCAiZG9tYWluLm5hbWUiOiAidGhpc2lzYXRlc3Rkb21haW5mb3JtYWlsZ3VuLmNvbSIsICJzZXZlcm\
-l0eSI6ICJOT1QgaW50ZXJuYWwifSwgMTAwLCBudWxsXQ=="
-            } }
-        ) }
-      )
-    end
-  end
-end

data/spec/unit/events/events_spec.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe 'The method get' do
-  it 'returns a proper hash of log data.' do
-    @mg_obj = Mailgun::UnitClient.new('events')
-    events = Mailgun::Events.new(@mg_obj, 'samples.mailgun.org')
-    result = events.get
-
-    expect(result.body).to include('items')
-    expect(result.body).to include('paging')
-  end
-end
-
-describe 'Pagination' do
-  it 'returns a proper hash of log data.' do
-    @mg_obj = Mailgun::UnitClient.new('events')
-    events = Mailgun::Events.new(@mg_obj, 'samples.mailgun.org')
-    result = events.get
-
-    json = JSON.parse(result.body)
-    expect(json).to include('paging')
-    expect(json['paging']).to include('next')
-    expect(json['paging']).to include('previous')
-  end
-
-  it 'calculates proper next-page url' do
-    events = Mailgun::Events.new(@mg_obj, 'samples.mailgun.org')
-    output = events.send(
-      :extract_endpoint_from,
-      "/v3/samples.mailgun.org/events/W3siYiI6ICIyMDE3LTA1\
-LTEwVDIwOjA2OjU0LjU3NiswMDowMCIsICJlIjogIjIwMTctMDUtMDhUMj\
-A6MDY6NTQuNTc3KzAwOjAwIn0sIHsiYiI6ICIyMDE3LTA1LTEwVDIwOjA2\
-OjU0LjU3NiswMDowMCIsICJlIjogIjIwMTctMDUtMDhUMjA6MDY6NTQuNT\
-c3KzAwOjAwIn0sIFsiZiJdLCBudWxsLCBbWyJhY2NvdW50LmlkIiwgIjU4\
-MDUyMTg2NzhmYTE2MTNjNzkwYjUwZiJdLCBbImRvbWFpbi5uYW1lIiwgIn\
-NhbmRib3gyOTcwMTUyYWYzZDM0NTU5YmZjN2U3MTcwM2E2Y2YyNC5tYWls\
-Z3VuLm9yZyJdXSwgMTAwLCBudWxsXQ=="
-    )
-
-    expect(output).to eq "W3siYiI6ICIyMDE3LTA1LTEwVDIwOjA2O\
-jU0LjU3NiswMDowMCIsICJlIjogIjIwMTctMDUtMDhUMjA6MDY6NTQuNTc3\
-KzAwOjAwIn0sIHsiYiI6ICIyMDE3LTA1LTEwVDIwOjA2OjU0LjU3NiswMDo\
-wMCIsICJlIjogIjIwMTctMDUtMDhUMjA6MDY6NTQuNTc3KzAwOjAwIn0sIF\
-siZiJdLCBudWxsLCBbWyJhY2NvdW50LmlkIiwgIjU4MDUyMTg2NzhmYTE2M\
-TNjNzkwYjUwZiJdLCBbImRvbWFpbi5uYW1lIiwgInNhbmRib3gyOTcwMTUy\
-YWYzZDM0NTU5YmZjN2U3MTcwM2E2Y2YyNC5tYWlsZ3VuLm9yZyJdXSwgMTA\
-wLCBudWxsXQ=="
-  end
-end
-
-describe 'The method next' do
-  it 'returns the next series of data.' do
-    @mg_obj = Mailgun::UnitClient.new('events')
-    events = Mailgun::Events.new(@mg_obj, 'samples.mailgun.org')
-    result = events.next
-
-    expect(result.body).to include('items')
-    expect(result.body).to include('paging')
-  end
-end
-
-describe 'The method previous' do
-  it 'returns the previous series of data.' do
-    @mg_obj = Mailgun::UnitClient.new('events')
-    events = Mailgun::Events.new(@mg_obj, 'samples.mailgun.org')
-    result = events.previous
-
-    expect(result.body).to include('items')
-    expect(result.body).to include('paging')
-  end
-end
-
-describe 'The method each' do
-  it 'iterates over all event items.' do
-    @mg_obj = Mailgun::UnitClient.new('events')
-    events = Mailgun::Events.new(@mg_obj, 'samples.mailgun.org')
-    # Events from the UnitClient are actually empty.
-    count = 0
-    events.each do |_e|
-      count += 1
-    end
-
-    # Better than nothing..
-    expect(count).to eq(0)
-  end
-end