rabbit_feed 0.3.1

data/spec/lib/rabbit_feed/event_definitions_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+module RabbitFeed
+  describe EventDefinitions do
+    before do
+      EventDefinitions do
+        define_event('customer_purchases_policy', version: '1.0.0') do
+          defined_as do
+            'The definition of a purchase'
+          end
+          payload_contains do
+            field('customer_id', type: 'string', definition: 'The definition of the customer id')
+            field('policy_id', type: 'string', definition: 'The definition of the policy id')
+            field('price', type: 'string', definition: 'The definition of the price')
+          end
+        end
+      end
+    end
+    subject { RabbitFeed::Producer.event_definitions['customer_purchases_policy'] }
+
+    it { should_not be_nil }
+    it { should be_valid }
+    its(:name) { should eq 'customer_purchases_policy' }
+
+    describe EventDefinitions::Event do
+      let(:name)       { 'event_name' }
+      let(:version)    { '1.0.0' }
+      let(:definition) { 'event definition' }
+      subject do
+        (EventDefinitions::Event.new name, version).tap do |event|
+          event.defined_as do
+            definition
+          end
+          event.payload_contains do
+            field 'field', { type: 'string', definition: 'field definition' }
+          end
+        end
+      end
+
+      it { should be_valid }
+      its(:fields) { should_not be_empty }
+      its(:schema) { should be_a Avro::Schema }
+      its(:payload){ should =~ [
+        {name: 'application', type: 'string', doc: 'The name of the application that created the event'},
+        {name: 'host', type: 'string', doc: 'The hostname of the server on which the event was created'},
+        {name: 'environment', type: 'string', doc: 'The environment in which the event was created'},
+        {name: 'version', type: 'string', doc: 'The version of the event'},
+        {name: 'created_at_utc', type: 'string', doc: 'The UTC time that the event was created'},
+        {name: 'field', type: 'string', doc: 'field definition'},
+        {name: 'name', type: 'string', doc: 'The name of the event'}
+        ]
+      }
+
+      context 'when the name is nil' do
+        let(:name) {}
+
+        it { should_not be_valid }
+      end
+
+      context 'when the version is nil' do
+        let(:version) {}
+
+        it { should_not be_valid }
+      end
+
+      context 'when the version is malformed' do
+        let(:version) { '1.a' }
+
+        it { should_not be_valid }
+      end
+
+      context 'when the definition is nil' do
+        let(:definition) {}
+
+        it { should_not be_valid }
+      end
+
+      context 'when the event is not a valid avro schema' do
+        before { subject.fields << (EventDefinitions::Field.new 'junk', 'junk', 'junk') }
+
+        it { should_not be_valid }
+      end
+    end
+
+    describe EventDefinitions::Field do
+      let(:name)       { 'event_name' }
+      let(:type)       { 'string' }
+      let(:definition) { 'event definition' }
+      subject{ EventDefinitions::Field.new name, type, definition }
+
+      it { should be_valid }
+      its(:schema) { should eq({ name: name, type: type, doc: definition }) }
+
+      context 'when the name is nil' do
+        let(:name) {}
+
+        it 'raises a configuration error' do
+          expect{ subject }.to raise_error ConfigurationError
+        end
+      end
+
+      context 'when the type is nil' do
+        let(:type) {}
+
+        it 'raises a configuration error' do
+          expect{ subject }.to raise_error ConfigurationError
+        end
+      end
+
+      context 'when the definition is nil' do
+        let(:definition) {}
+
+        it 'raises a configuration error' do
+          expect{ subject }.to raise_error ConfigurationError
+        end
+      end
+    end
+
+    context 'testing cumulative definitions' do
+      before do
+        EventDefinitions do
+          define_event('plumber_fixes_tap', version: '1.0.0') do
+            defined_as do
+              'What a plumber does'
+            end
+            payload_contains do
+              field('plumber_name', type: 'string', definition: 'The name of the plumber')
+            end
+          end
+        end
+      end
+
+      it 'applies event definitions in a cumulative manner' do
+        expect(RabbitFeed::Producer.event_definitions['customer_purchases_policy']).to be_present
+        expect(RabbitFeed::Producer.event_definitions['plumber_fixes_tap']).to be_present
+      end
+    end
+  end
+end

data/spec/lib/rabbit_feed/event_routing_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+module RabbitFeed
+  describe EventRouting do
+    before do
+      EventRouting do
+        accept_from('dummy_1') do
+          event('event_1') do |event|
+            event.payload
+          end
+          event('event_2') do |event|
+            event.payload
+          end
+        end
+        accept_from('dummy_2') do
+          event('event_3') do |event|
+            event.payload
+          end
+        end
+      end
+    end
+
+    it 'should create routing keys for the specified routes' do
+
+      RabbitFeed::Consumer.event_routing.accepted_routes.should =~ %w{
+        test.dummy_1.event_1
+        test.dummy_1.event_2
+        test.dummy_2.event_3
+      }
+    end
+
+    it 'routes the event to the correct action' do
+      events = [
+        double(:event, application: 'dummy_1', name: 'event_1', payload: 1),
+        double(:event, application: 'dummy_1', name: 'event_2', payload: 2),
+        double(:event, application: 'dummy_2', name: 'event_3', payload: 3),
+      ]
+      events.each do |event|
+        (RabbitFeed::Consumer.event_routing.handle_event event).should eq event.payload
+      end
+    end
+
+    it 'raises a routing error when the event cannot be routed' do
+      events = [
+        double(:event, application: 'dummy_9', name: 'event_1', payload: 1),
+        double(:event, application: 'dummy_1', name: 'event_9', payload: 3),
+      ]
+      events.each do |event|
+        expect{ RabbitFeed::Consumer.event_routing.handle_event event }.to raise_error RoutingError
+      end
+    end
+
+    describe EventRouting::Application do
+      let(:name) { 'name' }
+      subject{ EventRouting::Application.new name }
+
+      it { should be_valid }
+
+      context 'when the name is nil' do
+        let(:name) {}
+
+        it 'raises a configuration error' do
+          expect{ subject }.to raise_error ConfigurationError
+        end
+      end
+    end
+
+    describe EventRouting::Event do
+      let(:name)  { 'name' }
+      let(:block) { Proc.new{|event|} }
+      subject{ EventRouting::Event.new name, block }
+
+      it { should be_valid }
+
+      context 'when the name is nil' do
+        let(:name) {}
+
+        it 'raises a configuration error' do
+          expect{ subject }.to raise_error ConfigurationError
+        end
+      end
+
+      context 'when no action is provided' do
+        let(:block) {}
+
+        it 'raises a configuration error' do
+          expect{ subject }.to raise_error ConfigurationError
+        end
+      end
+
+      context 'when the event is not provided to the event action' do
+        let(:block) { Proc.new{} }
+
+        it 'raises a configuration error' do
+          expect{ subject }.to raise_error ConfigurationError
+        end
+      end
+    end
+
+    context 'testing cumulative routing definitions' do
+      before do
+        EventRouting do
+          accept_from('dummy_3') do
+            event('event_4') do |event|
+              event.payload
+            end
+          end
+        end
+      end
+
+      it 'applies routing definitions in a cumulative manner' do
+        RabbitFeed::Consumer.event_routing.accepted_routes.should =~ %w{
+          test.dummy_1.event_1
+          test.dummy_1.event_2
+          test.dummy_2.event_3
+          test.dummy_3.event_4
+        }
+      end
+    end
+  end
+end

data/spec/lib/rabbit_feed/event_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module RabbitFeed
+  describe Event do
+    let(:schema)  { double(:schema) }
+    let(:payload) { { 'customer_id' => '123' } }
+
+    subject { described_class.new schema, payload }
+
+    describe '.new' do
+
+      it { should be_valid }
+      its(:schema)  { should eq schema }
+      its(:payload) { should eq({ 'customer_id' => '123' }) }
+
+      context 'when schema is nil' do
+        let(:schema) {}
+
+        it 'should raise an error' do
+          expect{ subject }.to raise_error Error
+        end
+      end
+
+      context 'when payload is nil' do
+        let(:payload) {}
+
+        it 'should raise an error' do
+          expect{ subject }.to raise_error Error
+        end
+      end
+    end
+  end
+end

data/spec/lib/rabbit_feed/producer_connection_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+module RabbitFeed
+  describe ProducerConnection do
+    let(:bunny_exchange)   { double(:bunny_exchange, on_return: nil, publish: nil) }
+    let(:bunny_channel)    { double(:bunny_channel, exchange: bunny_exchange, id: 1) }
+    let(:bunny_connection) { double(:bunny_connection, start: nil, closed?: false, close: nil, create_channel: bunny_channel) }
+    before do
+      allow(Bunny).to receive(:new).and_return(bunny_connection)
+    end
+    subject do
+      described_class.new bunny_channel
+    end
+
+    describe '#new' do
+      it 'sets up returned message handling' do
+        expect(described_class).to receive(:handle_returned_message).with('return_info', 'content')
+        expect(bunny_exchange).to receive(:on_return).and_yield('return_info', 'properties', 'content')
+        subject
+      end
+
+      it 'assigns the exchange' do
+        expect(subject.exchange).to eq bunny_exchange
+      end
+    end
+
+    describe '#handle_returned_message' do
+
+      context 'when Airbrake is defined' do
+        before do
+          stub_const('Airbrake', double(:airbrake, configuration: airbrake_configuration))
+        end
+
+        context 'and the Airbrake configuration is public' do
+          let(:airbrake_configuration) { double(:airbrake_configuration, public?: true) }
+
+          it 'notifies Airbrake of the return' do
+            expect(Airbrake).to receive(:notify_or_ignore).with(an_instance_of ReturnedMessageError)
+            described_class.handle_returned_message 1, 2
+          end
+        end
+      end
+    end
+
+    describe '#connection_options' do
+
+      it 'does not use a threaded connection' do
+        expect(described_class.connection_options).to include(threaded: false)
+      end
+    end
+
+    describe '#publish' do
+      let(:message) { 'the message' }
+      let(:options) { {routing_key: 'routing_key'} }
+
+      it 'publishes the message as mandatory and persistent' do
+        expect(bunny_exchange).to receive(:publish).with(message, { persistent: true, mandatory: true, routing_key: 'routing_key' })
+        described_class.publish message, options
+      end
+
+      it 'retries on closed connections' do
+        expect(described_class).to receive(:retry_on_closed_connection).and_call_original
+        described_class.publish message, options
+      end
+
+      it 'retries on exception' do
+        expect(described_class).to receive(:retry_on_exception).twice.and_call_original
+        described_class.publish message, options
+      end
+    end
+  end
+end

data/spec/lib/rabbit_feed/producer_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module RabbitFeed
+  describe Producer do
+    describe '.publish' do
+      let(:event_name) { 'event_name' }
+      before do
+        RabbitFeed::Producer.stub!
+        EventDefinitions do
+          define_event('event_name', version: '1.0.0') do
+            defined_as do
+              'The definition of the event'
+            end
+            payload_contains do
+              field('field', type: 'string', definition: 'The definition of the field')
+            end
+          end
+        end
+      end
+      subject{ RabbitFeed::Producer.publish_event event_name, { 'field' => 'value' } }
+
+      context 'when event definitions are not set' do
+        before{ RabbitFeed::Producer.event_definitions = nil }
+
+        it 'raises an error' do
+          expect{ subject }.to raise_error Error
+        end
+      end
+
+      context 'when no event definition is found' do
+        let(:event_name) { 'different event name' }
+
+        it 'raises an error' do
+          expect{ subject }.to raise_error Error
+        end
+      end
+
+      it 'returns the event' do
+        expect(subject).to be_a Event
+      end
+
+      it 'serializes the event and provides message metadata' do
+        Timecop.freeze do
+          expect(ProducerConnection).to receive(:publish).with(
+            an_instance_of(String),
+            {
+              routing_key: 'test.rabbit_feed.event_name',
+              type:        'event_name',
+              app_id:      'rabbit_feed',
+              timestamp:   Time.now.utc.to_i,
+            })
+          subject
+        end
+      end
+    end
+  end
+end

data/spec/lib/rabbit_feed/testing_support/rspec_matchers/publish_event_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+module RabbitFeed
+  module TestingSupport
+    module RSpecMatchers
+      describe PublishEvent do
+        let(:event_name) { 'test_event' }
+        let(:event_payload) { {'field' => 'value'} }
+        before do
+          EventDefinitions do
+            define_event('test_event', version: '1.0.0') do
+              defined_as do
+                'The definition of a test event'
+              end
+              field('field', type: 'string', definition: 'field definition')
+            end
+            define_event('different name', version: '1.0.0') do
+              defined_as do
+                'The definition of a test event with a different name'
+              end
+            end
+          end
+        end
+
+        context 'when the expectation is met' do
+
+          it 'validates' do
+            expect {
+              RabbitFeed::Producer.publish_event event_name, event_payload
+            }.to publish_event(event_name, event_payload)
+          end
+
+          it 'validates the negation' do
+            expect {
+              RabbitFeed::Producer.publish_event 'different name', {}
+            }.to_not publish_event(event_name, {})
+          end
+
+          it 'traps exceptions' do
+            expect {
+              raise 'this hurts me more than it hurts you'
+            }.to_not publish_event(event_name, {})
+          end
+        end
+
+        it 'validates the event name' do
+          matcher = described_class.new(event_name, {})
+          block   = Proc.new { RabbitFeed::Producer.publish_event 'different name', {} }
+          (matcher.matches? block).should be_false
+        end
+
+        it 'validates the event payload' do
+          matcher = described_class.new(event_name, event_payload)
+          block   = Proc.new { RabbitFeed::Producer.publish_event event_name, {'field' => 'different value'} }
+          (matcher.matches? block).should be_false
+        end
+      end
+    end
+  end
+end