mailgun-tracking 2.0.0 → 3.0.0

data/spec/mailgun/tracking/notifier_spec.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mailgun::Tracking::Notifier do
-  subject(:notifier) { described_class.new(listener) }
-
-  let(:listener) { instance_double(Mailgun::Tracking::Listener) }
-
-  describe '#empty?' do
-    context 'when there is at least one subscriber' do
-      let(:subscriber) { instance_double(Mailgun::Tracking::Subscriber::AllMessages) }
-
-      before { allow(listener).to receive(:subscribers).and_return([subscriber]) }
-
-      it { is_expected.not_to be_empty }
-    end
-
-    context 'when there are no subscribers' do
-      before { allow(listener).to receive(:subscribers).and_return([]) }
-
-      it { is_expected.to be_empty }
-    end
-  end
-
-  describe '#subscribe' do
-    let(:callable) { proc {} }
-
-    before { allow(listener).to receive(:add_subscriber) }
-
-    it 'subscribes on event' do
-      notifier.subscribe(:delivered, callable)
-
-      expect(listener).to have_received(:add_subscriber)
-        .with(:delivered, callable)
-    end
-  end
-
-  describe '#all' do
-    let(:callable) { proc {} }
-
-    before { allow(listener).to receive(:add_subscriber) }
-
-    it 'subscribes on all events' do
-      notifier.all(callable)
-
-      expect(listener).to have_received(:add_subscriber).with(nil, callable)
-    end
-  end
-
-  describe '#broadcast' do
-    let(:payload) { Mailgun::Tracking::Payload.new(fixture('delivered.json')) }
-
-    before do
-      allow(Mailgun::Tracking::Signature).to receive(:verify!)
-      allow(listener).to receive(:broadcast)
-      notifier.broadcast(:delivered, payload)
-    end
-
-    it 'verify signature' do
-      expect(Mailgun::Tracking::Signature).to have_received(:verify!).with(payload)
-    end
-
-    it 'broadcasts an event' do
-      expect(listener).to have_received(:broadcast).with(:delivered, payload)
-    end
-  end
-end

data/spec/mailgun/tracking/payload_spec.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mailgun::Tracking::Payload do
-  subject(:payload) { described_class.new(values) }
-
-  describe '#==' do
-    let(:values) { { 'foo' => 'bar' } }
-
-    it { is_expected.to eq(described_class.new('foo' => 'bar')) }
-    it { is_expected.not_to eq(described_class.new('foo': 'rab')) }
-    it { is_expected.not_to eq('foo') }
-  end
-
-  describe '#respond_to?' do
-    let(:values) { { 'foo' => 'bar', 'boolean': true } }
-
-    it { is_expected.to respond_to(:foo) }
-    it { is_expected.to respond_to(:boolean?) }
-    it { is_expected.not_to respond_to(:foo?) }
-  end
-
-  describe '#[]' do
-    let(:values) { { 'Message-Id' => '<payload@mailgun-tracking.com>' } }
-
-    it 'returns the value object from values' do
-      expect(payload[:message_id]).to eq('<payload@mailgun-tracking.com>')
-    end
-  end
-
-  describe '#hash' do
-    let(:values) { { 'foo' => 'bar' } }
-
-    it { expect(payload.hash).to eq(described_class.new('foo' => 'bar').hash) }
-    it { expect(payload.hash).not_to eq(described_class.new('foo': 'rab').hash) }
-    it { expect(payload.hash).not_to eq('foo'.hash) }
-  end
-
-  describe '#to_hash' do
-    let(:values) do
-      {
-        'foo' => 'bar',
-        'list' => [described_class.new('foo' => 'bar')],
-        'bar' => { 'foo' => 'bar', 'bar' => described_class.new('foo' => 'bar') }
-      }
-    end
-
-    it 'recursively call to_hash on its values' do
-      expect(payload.to_hash).to eql(
-        foo: 'bar',
-        list: [{ foo: 'bar' }],
-        bar: { foo: 'bar', bar: { foo: 'bar' } }
-      )
-    end
-  end
-
-  describe '#to_s' do
-    let(:values) do
-      {
-        'foo' => 'bar',
-        'list' => [described_class.new('foo' => 'bar')],
-        'bar' => { 'foo' => 'bar', 'bar' => described_class.new('foo' => 'bar') }
-      }
-    end
-
-    it 'will call to_s for all embedded stripe objects' do
-      expect(payload.to_s).to eql(JSON.pretty_generate(
-                                    foo: 'bar',
-                                    list: [{ foo: 'bar' }],
-                                    bar: { foo: 'bar', bar: { foo: 'bar' } }
-                                  ))
-    end
-  end
-end

data/spec/mailgun/tracking/request_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mailgun::Tracking::Request do
-  subject(:request) { described_class.new(env) }
-
-  describe '#mailgun_tracking?' do
-    context 'when a request to an endpoint without a POST method' do
-      let(:env) { env_for('http://localhost:3000/mailgun', method: :get) }
-
-      it { is_expected.not_to be_mailgun_tracking }
-    end
-
-    context 'when a request to an endpoint with not acceptable content type' do
-      let(:env) do
-        env_for('http://localhost:3000/mailgun', method: :post, 'CONTENT_TYPE' => 'application/x-www-form-urlencoded')
-      end
-
-      it { is_expected.not_to be_mailgun_tracking }
-    end
-
-    context 'when the request is not to the endpoint' do
-      let(:env) do
-        env_for('http://localhost:3000/_mailgun', method: :post, 'CONTENT_TYPE' => 'application/json; charset=utf-8')
-      end
-
-      it { is_expected.not_to be_mailgun_tracking }
-    end
-
-    context 'when all the above conditions are met' do
-      let(:env) do
-        env_for('http://localhost:3000/mailgun', method: :post, 'CONTENT_TYPE' => 'application/json; charset=utf-8')
-      end
-
-      it { is_expected.to be_mailgun_tracking }
-    end
-  end
-
-  describe '#payload' do
-    let(:env) { env_for('http://localhost:3000/mailgun', method: :post, params: { 'signature' => {} }) }
-
-    it 'returns payload' do
-      expect(request.payload).to be_an_instance_of(Mailgun::Tracking::Payload)
-    end
-  end
-
-  context 'when application/json request' do
-    let(:env) { env_for('/', method: :post, input: input, 'CONTENT_TYPE' => content_type) }
-    let(:input) { 'foo=bar' }
-    let(:content_type) { 'application/json; charset=utf-8' }
-
-    it 'rewinds input' do
-      expect(request.body.read).to eq(input)
-    end
-
-    context 'when input is a hash' do
-      let(:input) { '{"qux": "bin"}' }
-
-      it 'adds a parsed hash to POST params' do
-        expect(request.params['qux']).to eq('bin')
-      end
-    end
-  end
-end

data/spec/mailgun/tracking/signature_spec.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mailgun::Tracking::Signature do
-  subject(:signature) { described_class.new(payload) }
-
-  describe '.verify!' do
-    context 'when the signature comparison is successful' do
-      let(:payload) do
-        Mailgun::Tracking::Payload.new(
-          signature: {
-            timestamp: '1499697910',
-            token: 'b5751a49a024483da8d41c3684f98b8f',
-            signature: '374e0b1a3deeb57318c783d43ff71093fbf26406a452761dab91bf346a93b49e'
-          }
-        )
-      end
-
-      it { expect(described_class.verify!(payload)).to be true }
-    end
-
-    context 'when the signature comparison is unsuccessful' do
-      let(:payload) do
-        Mailgun::Tracking::Payload.new(
-          signature: {
-            timestamp: '',
-            token: 'b5751a49a024483da8d41c3684f98b8f',
-            signature: '374e0b1a3deeb57318c783d43ff71093fbf26406a452761dab91bf346a93b49e'
-          }
-        )
-      end
-
-      it { expect { described_class.verify!(payload) }.to raise_error(Mailgun::Tracking::InvalidSignature) }
-    end
-  end
-
-  describe '#valid?' do
-    context 'when the signature comparison is successful' do
-      let(:payload) do
-        Mailgun::Tracking::Payload.new(
-          signature: {
-            timestamp: '1499697910',
-            token: 'b5751a49a024483da8d41c3684f98b8f',
-            signature: '374e0b1a3deeb57318c783d43ff71093fbf26406a452761dab91bf346a93b49e'
-          }
-        )
-      end
-
-      it { is_expected.to be_valid }
-    end
-
-    context 'when the signature comparison is unsuccessful' do
-      let(:payload) do
-        Mailgun::Tracking::Payload.new(
-          signature: {
-            timestamp: '',
-            token: 'b5751a49a024483da8d41c3684f98b8f',
-            signature: '374e0b1a3deeb57318c783d43ff71093fbf26406a452761dab91bf346a93b49e'
-          }
-        )
-      end
-
-      it { is_expected.not_to be_valid }
-    end
-  end
-end

data/spec/mailgun/tracking/subscriber/all_messages_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mailgun::Tracking::Subscriber::AllMessages do
-  subject(:subscriber) { described_class.new(callable) }
-
-  it_behaves_like 'subscriber'
-
-  describe '#subscribed_to?' do
-    let(:callable) { proc {} }
-
-    it { is_expected.to be_subscribed_to(:any_event) }
-  end
-end

data/spec/mailgun/tracking/subscriber/evented_spec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mailgun::Tracking::Subscriber::Evented do
-  subject(:subscriber) { described_class.new('delivered', callable) }
-
-  it_behaves_like 'subscriber'
-
-  describe '#subscribed_to?' do
-    let(:callable) { proc {} }
-
-    it { is_expected.to be_subscribed_to(:delivered) }
-    it { is_expected.not_to be_subscribed_to(:any_event) }
-  end
-end

data/spec/mailgun/tracking/subscriber_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mailgun::Tracking::Subscriber do
-  describe '.for' do
-    let(:callable) { proc {} }
-
-    it 'returns an instance of Mailgun::Tracking::Subscriber::AllMessages' do
-      expect(described_class.for(nil, callable)).to be_instance_of(Mailgun::Tracking::Subscriber::AllMessages)
-    end
-
-    it 'returns an instance of Mailgun::Tracking::Subscriber::Evented' do
-      expect(described_class.for('delivered', callable)).to be_instance_of(Mailgun::Tracking::Subscriber::Evented)
-    end
-  end
-end

data/spec/mailgun/tracking/util_spec.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mailgun::Tracking::Util do
-  describe '.normalize' do
-    context 'when the keys of the object are strings' do
-      let(:object) do
-        { 'a' => 1, 'b' => 2 }
-      end
-
-      it 'returns normalized object' do
-        expect(described_class.normalize(object)).to eq(a: 1, b: 2)
-      end
-    end
-
-    context 'when the object has deep string keys' do
-      let(:object) do
-        { 'a' => { 'b' => { 'c' => 3 } } }
-      end
-
-      it 'returns normalized object' do
-        expect(described_class.normalize(object)).to eq(a: { b: { c: 3 } })
-      end
-    end
-
-    context 'when the keys of the object are symbols' do
-      let(:object) do
-        { a: 1, b: 2 }
-      end
-
-      it 'returns normalized object' do
-        expect(described_class.normalize(object)).to eq(object)
-      end
-    end
-
-    context 'when an object has deep symbol keys' do
-      let(:object) do
-        { a: { b: { c: 3 } } }
-      end
-
-      it 'returns normalized object' do
-        expect(described_class.normalize(object)).to eq(object)
-      end
-    end
-
-    context 'when the keys of the object are mixed' do
-      let(:object) do
-        { :a => 1, 'b' => 2 }
-      end
-
-      it 'returns normalized object' do
-        expect(described_class.normalize(object)).to eq(a: 1, b: 2)
-      end
-    end
-
-    context 'when the keys of the object are integers' do
-      let(:object) do
-        { 0 => 1, 1 => 2 }
-      end
-
-      it 'returns normalized object' do
-        expect(described_class.normalize(object)).to eq(0 => 1, 1 => 2)
-      end
-    end
-
-    context 'when an object has deep integer keys' do
-      let(:object) do
-        { 0 => { 1 => { 2 => 3 } } }
-      end
-
-      it 'returns normalized object' do
-        expect(described_class.normalize(object)).to eq(0 => { 1 => { 2 => 3 } })
-      end
-    end
-
-    context 'when the key of the object is illegal symbol' do
-      let(:object) do
-        { [] => 3 }
-      end
-
-      it 'returns normalized object' do
-        expect(described_class.normalize(object)).to eq([] => 3)
-      end
-    end
-
-    context 'when an object has deep illegal symbol keys' do
-      let(:object) do
-        { [] => { [] => 3 } }
-      end
-
-      it 'returns normalized object' do
-        expect(described_class.normalize(object)).to eq([] => { [] => 3 })
-      end
-    end
-
-    context 'when the keys of the object are upcase strings' do
-      let(:object) do
-        { 'A' => 1, 'B' => 2 }
-      end
-
-      it 'returns normalized object' do
-        expect(described_class.normalize(object)).to eq(a: 1, b: 2)
-      end
-    end
-
-    context 'when an object has deep upcase string keys' do
-      let(:object) do
-        { 'A' => { 'B' => { 'C' => 3 } } }
-      end
-
-      it 'returns normalized object' do
-        expect(described_class.normalize(object)).to eq(a: { b: { c: 3 } })
-      end
-    end
-
-    context 'when the object value is an array of stringified hashes' do
-      let(:object) do
-        { 'a' => [{ 'b' => 2 }, { 'c' => 3 }, 4] }
-      end
-
-      it 'returns normalized object' do
-        expect(described_class.normalize(object)).to eq(a: [{ b: 2 }, { c: 3 }, 4])
-      end
-    end
-
-    context 'when the object value is an array of symbolized hashes' do
-      let(:object) do
-        { a: [{ b: 2 }, { c: 3 }, 4] }
-      end
-
-      it 'returns normalized object' do
-        expect(described_class.normalize(object)).to eq(object)
-      end
-    end
-
-    context 'when the object value is an array of mixed hashes' do
-      let(:object) do
-        { a: [{ b: 2 }, { 'c' => 3 }, 4] }
-      end
-
-      it 'returns normalized object' do
-        expect(described_class.normalize(object)).to eq(a: [{ b: 2 }, { c: 3 }, 4])
-      end
-    end
-
-    context 'when the object value is an array of upcased hashes' do
-      let(:object) do
-        { 'A' => [{ 'B' => 2 }, { 'C' => 3 }, 4] }
-      end
-
-      it 'returns normalized object' do
-        expect(described_class.normalize(object)).to eq(a: [{ b: 2 }, { c: 3 }, 4])
-      end
-    end
-  end
-end