message-driver 0.4.0 → 0.5.0

data/spec/units/message_driver/destination_spec.rb

@@ -1,19 +1,24 @@
 require 'spec_helper'
 
-module MessageDriver::Destination
-  describe Base do
-    subject(:destination) { Base.new(nil, nil, nil, nil) }
+module MessageDriver
+  module Destination
+    RSpec.describe Base do
+      subject(:destination) { Base.new(nil, nil, nil, nil) }
 
-    it 'needs some real tests'
+      describe '#middlware' do
+        it { expect(subject.middleware).to be_a Middleware::MiddlewareStack }
+      end
 
-    include_examples "doesn't support #message_count"
+      include_examples "doesn't support #message_count"
+      include_examples "doesn't support #consumer_count"
 
-    describe '#subscribe' do
-      it 'raises an error' do
-        expect {
-          consumer = lambda do |_| end
-          destination.subscribe(&consumer)
-        }.to raise_error "#subscribe is not supported by #{destination.class}"
+      describe '#subscribe' do
+        it 'raises an error' do
+          expect do
+            consumer = ->(_) {}
+            destination.subscribe(&consumer)
+          end.to raise_error "#subscribe is not supported by #{destination.class}"
+        end
       end
     end
   end

data/spec/units/message_driver/message_spec.rb

@@ -1,90 +1,116 @@
 require 'spec_helper'
 
-module MessageDriver::Message
-  describe Base do
-    describe '#initialize' do
-      let(:body) { 'The message body' }
-      let(:headers) { { foo: :bar, bar: :baz} }
-      let(:properties) { {persistent: true, client_ack: true} }
-      let(:ctx) { double('adapter_context') }
+module MessageDriver
+  module Message
+    RSpec.describe Base do
+      describe '#initialize' do
+        let(:body) { 'The message body' }
+        let(:headers) { { foo: :bar, bar: :baz } }
+        let(:properties) { { persistent: true, client_ack: true } }
+        let(:ctx) { double('adapter_context') }
 
-      context 'sets the body, header and properites on initialization' do
-        subject { described_class.new(ctx, body, headers, properties) }
+        context 'sets the body, header and properites on initialization' do
+          subject { described_class.new(ctx, body, headers, properties) }
 
-        its(:ctx) { should be(ctx) }
-        its(:body) { should eq(body) }
-        its(:headers) { should eq(headers) }
-        its(:properties) { should eq(properties) }
-      end
-    end
+          describe '#ctx' do
+            it { expect(subject.ctx).to be(ctx) }
+          end
 
-    let(:logger) { MessageDriver.logger }
-    let(:ctx) { double('adapter_context') }
-    let(:options) { double('options') }
-    subject(:message) { described_class.new(ctx, 'body', {}, {}) }
+          describe '#body' do
+            it { expect(subject.body).to eq(body) }
+          end
 
-    describe '#ack' do
-      before do
-        allow(ctx).to receive(:ack_message)
-      end
-      context 'when the adapter supports client acks' do
-        before do
-          allow(ctx).to receive(:supports_client_acks?) { true }
-        end
-        it 'calls #ack_message with the message' do
-          subject.ack
-          expect(ctx).to have_received(:ack_message).with(subject, {})
-        end
-        it 'passes the supplied options to ack_message' do
-          subject.ack(options)
-          expect(ctx).to have_received(:ack_message).with(subject, options)
-        end
-      end
-      context "when the adapter doesn't support client acks" do
-        before do
-          allow(ctx).to receive(:supports_client_acks?) { false }
-        end
-        it "doesn't call #ack_message" do
-          subject.ack
-          expect(ctx).not_to have_received(:ack_message)
-        end
-        it 'logs a warning' do
-          allow(logger).to receive(:debug)
-          subject.ack
-          expect(logger).to have_received(:debug).with('this adapter does not support client acks')
+          describe '#headers' do
+            it { expect(subject.headers).to eq(headers) }
+          end
+
+          describe '#properties' do
+            it { expect(subject.properties).to eq(properties) }
+          end
+
+          describe '#raw_body' do
+            it 'defaults to the body' do
+              expect(subject.raw_body).to eq(subject.body)
+            end
+
+            it 'can be provided in the constructor' do
+              msg = described_class.new(ctx, body, headers, properties, 'my_raw_body')
+
+              expect(msg.raw_body).to eq('my_raw_body')
+              expect(msg.body).to eq(body)
+            end
+          end
         end
       end
-    end
 
-    describe '#nack' do
-      before do
-        allow(ctx).to receive(:nack_message)
-      end
-      context 'when the adapter supports client nacks' do
+      let(:logger) { MessageDriver.logger }
+      let(:ctx) { double('adapter_context') }
+      let(:options) { double('options') }
+      subject(:message) { described_class.new(ctx, 'body', {}, {}) }
+
+      describe '#ack' do
         before do
-          allow(ctx).to receive(:supports_client_acks?) { true }
+          allow(ctx).to receive(:ack_message)
         end
-        it 'calls #nack_message with the message' do
-          subject.nack
-          expect(ctx).to have_received(:nack_message).with(subject, {})
+        context 'when the adapter supports client acks' do
+          before do
+            allow(ctx).to receive(:supports_client_acks?) { true }
+          end
+          it 'calls #ack_message with the message' do
+            subject.ack
+            expect(ctx).to have_received(:ack_message).with(subject, {})
+          end
+          it 'passes the supplied options to ack_message' do
+            subject.ack(options)
+            expect(ctx).to have_received(:ack_message).with(subject, options)
+          end
         end
-        it 'passes the supplied options to nack_message' do
-          subject.nack(options)
-          expect(ctx).to have_received(:nack_message).with(subject, options)
+        context "when the adapter doesn't support client acks" do
+          before do
+            allow(ctx).to receive(:supports_client_acks?) { false }
+          end
+          it "doesn't call #ack_message" do
+            subject.ack
+            expect(ctx).not_to have_received(:ack_message)
+          end
+          it 'logs a warning' do
+            allow(logger).to receive(:debug)
+            subject.ack
+            expect(logger).to have_received(:debug).with('this adapter does not support client acks')
+          end
         end
       end
-      context "when the adapter doesn't support client nacks" do
+
+      describe '#nack' do
         before do
-          allow(ctx).to receive(:supports_client_acks?) { false }
+          allow(ctx).to receive(:nack_message)
         end
-        it "doesn't call #nack_message" do
-          subject.nack
-          expect(ctx).not_to have_received(:nack_message)
+        context 'when the adapter supports client nacks' do
+          before do
+            allow(ctx).to receive(:supports_client_acks?) { true }
+          end
+          it 'calls #nack_message with the message' do
+            subject.nack
+            expect(ctx).to have_received(:nack_message).with(subject, {})
+          end
+          it 'passes the supplied options to nack_message' do
+            subject.nack(options)
+            expect(ctx).to have_received(:nack_message).with(subject, options)
+          end
         end
-        it 'logs a warning' do
-          allow(logger).to receive(:debug)
-          subject.nack
-          expect(logger).to have_received(:debug).with('this adapter does not support client acks')
+        context "when the adapter doesn't support client nacks" do
+          before do
+            allow(ctx).to receive(:supports_client_acks?) { false }
+          end
+          it "doesn't call #nack_message" do
+            subject.nack
+            expect(ctx).not_to have_received(:nack_message)
+          end
+          it 'logs a warning' do
+            allow(logger).to receive(:debug)
+            subject.nack
+            expect(logger).to have_received(:debug).with('this adapter does not support client acks')
+          end
         end
       end
     end

data/spec/units/message_driver/middleware/base_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module MessageDriver
+  module Middleware
+    RSpec.describe Base do
+      let(:destination) { double(Destination) }
+      subject(:middleware_base) { described_class.new(destination) }
+
+      let(:body) { double('body') }
+      let(:headers) { double('headers') }
+      let(:properties) { double('properties') }
+
+      describe '#destination' do
+        it { expect(subject.destination).to be destination }
+      end
+
+      describe '#on_publish' do
+        it 'just returns the input values' do
+          expect(subject.on_publish(body, headers, properties)).to eq [body, headers, properties]
+        end
+      end
+
+      describe '#on_consume' do
+        it 'just returns the input values' do
+          expect(subject.on_consume(body, headers, properties)).to eq [body, headers, properties]
+        end
+      end
+    end
+  end
+end

data/spec/units/message_driver/middleware/block_middleware_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+module MessageDriver
+  module Middleware
+    RSpec.describe BlockMiddleware do
+      let(:destination) { double(Destination) }
+      let(:a_block) { ->(b, h, p) { [b, h, p] } }
+      describe '#initialize' do
+        it 'requires you provide either an on_publish, or on_consume block' do
+          expect do
+            BlockMiddleware.new(destination, {})
+          end.to raise_error(ArgumentError)
+          expect do
+            BlockMiddleware.new(destination, foo: a_block)
+          end.to raise_error(ArgumentError)
+          expect do
+            BlockMiddleware.new(destination, on_publish: a_block)
+          end.not_to raise_error
+          expect do
+            BlockMiddleware.new(destination, on_consume: a_block)
+          end.not_to raise_error
+          expect do
+            BlockMiddleware.new(destination, on_consume: a_block, on_publish: a_block)
+          end.not_to raise_error
+        end
+
+        it 'saves the provided blocks' do
+          middleware = BlockMiddleware.new(destination, on_publish: a_block)
+          expect(middleware.on_publish_block).to be(a_block)
+          expect(middleware.on_consume_block).to be_nil
+
+          middleware = BlockMiddleware.new(destination, on_consume: a_block)
+          expect(middleware.on_publish_block).to be_nil
+          expect(middleware.on_consume_block).to be(a_block)
+
+          middleware = BlockMiddleware.new(destination, on_publish: a_block, on_consume: a_block)
+          expect(middleware.on_publish_block).to be(a_block)
+          expect(middleware.on_consume_block).to be(a_block)
+        end
+      end
+
+      shared_context 'a message processor' do |op|
+        let(:a_block) { double('a_block') }
+        let(:subject) { described_class.new(destination, op => a_block) }
+
+        let(:body) { double('body') }
+        let(:headers) { double('headers') }
+        let(:properties) { double('properties') }
+
+        let(:result_body) { double('result_body') }
+        let(:result_headers) { double('result_headers') }
+        let(:result_properties) { double('result_properties') }
+
+        before do
+          allow(a_block).to receive(:call).and_return([result_body, result_headers, result_properties]) unless a_block.nil?
+        end
+
+        it 'delegates to the provided block and returns it\'s result' do
+          result = subject.public_send(op, body, headers, properties)
+          expect(a_block).to have_received(:call).with(body, headers, properties)
+          expect(result).to eq([result_body, result_headers, result_properties])
+        end
+
+        context "when :#{op} was not provided" do
+          let(:a_block) { nil }
+          it 'just returns the original inputs' do
+            result = subject.public_send(op, body, headers, properties)
+            expect(result).to eq([body, headers, properties])
+          end
+        end
+      end
+
+      describe '#on_publish' do
+        it_behaves_like 'a message processor', :on_publish
+      end
+
+      describe '#on_consume' do
+        it_behaves_like 'a message processor', :on_consume
+      end
+    end
+  end
+end

data/spec/units/message_driver/middleware/middleware_stack_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+
+module MessageDriver
+  module Middleware
+    RSpec.describe MiddlewareStack do
+      class Top < Base; end
+      class Middle < Base; end
+      class Bottom < Base; end
+
+      let(:top) { Top.new(destination) }
+      let(:middle) { Middle.new(destination) }
+      let(:bottom) { Bottom.new(destination) }
+
+      before do
+        allow(Top).to receive(:new).with(destination).and_return(top)
+        allow(Middle).to receive(:new).with(destination).and_return(middle)
+        allow(Bottom).to receive(:new).with(destination).and_return(bottom)
+      end
+
+      def load_middleware_doubles
+        subject.append Middle
+        subject.prepend Bottom
+        subject.append Top
+      end
+
+      let(:destination) { double(Destination) }
+      subject(:middleware_stack) { described_class.new(destination) }
+
+      it { is_expected.to be_an Enumerable }
+
+      describe '#destination' do
+        it { expect(subject.destination).to be destination }
+      end
+
+      describe '#middlewares' do
+        it 'is initially empty' do
+          expect(subject.middlewares).to be_an Array
+          expect(subject.middlewares).to be_empty
+        end
+
+        it 'returns the list of middlewares' do
+          load_middleware_doubles
+          expect(subject.middlewares).to eq [bottom, middle, top]
+        end
+
+        it 'ensures the returned list of middlewares is frozen' do
+          expect(subject.middlewares).to be_frozen
+        end
+      end
+
+      shared_examples 'a middleware builder' do |op|
+        it 'instantiates the middleware and passes the destination to it' do
+          allow(Top).to receive(:new).and_call_original
+          subject.public_send op, Top
+          middleware = subject.middlewares.first
+          expect(middleware).to be_an_instance_of Top
+          expect(middleware.destination).to be destination
+        end
+
+        it 'returns the instantiated middleware' do
+          expect(subject.public_send(op, Top)).to be top
+        end
+
+        context 'with a parameterizable middleware' do
+          class Paramed < Base
+            attr_reader :foo, :bar
+            def initialize(destination, foo, bar)
+              super(destination)
+              @foo = foo
+              @bar = bar
+            end
+          end
+
+          it 'passes the extra values to the middleware initializer' do
+            subject.public_send(op, Paramed, 27, 'a parameter value')
+            middleware = subject.middlewares.first
+            expect(middleware).to be_an_instance_of Paramed
+            expect(middleware.foo).to eq(27)
+            expect(middleware.bar).to eq('a parameter value')
+          end
+        end
+
+        context 'with a hash of blocks' do
+          let(:on_publish) { ->(b, h, p) { [b, h, p] } }
+          let(:on_consume) { ->(b, h, p) { [b, h, p] } }
+          before do
+            expect(on_publish).not_to eq(on_consume)
+            expect(on_publish).not_to be(on_consume)
+          end
+          it 'builds a BlockMiddleware with the provied on_publish and on_consume blocks' do
+            subject.public_send(op, on_publish: on_publish, on_consume: on_consume)
+            middleware = subject.middlewares.first
+            expect(middleware).to be_an_instance_of BlockMiddleware
+            expect(middleware.on_publish_block).to be on_publish
+            expect(middleware.on_consume_block).to be on_consume
+          end
+        end
+      end
+
+      describe '#append' do
+        it 'adds middlewares to the top of the middleware stack' do
+          subject.append Bottom
+          subject.append Middle
+          subject.append Top
+          expect(subject.middlewares).to eq [bottom, middle, top]
+        end
+
+        it_behaves_like 'a middleware builder', :append
+      end
+
+      describe '#prepend' do
+        it 'adds middlewares to the bottom of the middleware stack' do
+          subject.prepend Top
+          subject.prepend Middle
+          subject.prepend Bottom
+          expect(subject.middlewares).to eq [bottom, middle, top]
+        end
+
+        it_behaves_like 'a middleware builder', :prepend
+      end
+
+      describe '#on_publish' do
+        it 'passes the message data to each middleware\'s #on_publish message, bottom to top' do
+          load_middleware_doubles
+          expect(subject.middlewares).to eq [bottom, middle, top]
+
+          allow(bottom).to receive(:on_publish).and_call_original
+          allow(middle).to receive(:on_publish).and_call_original
+          allow(top).to receive(:on_publish).and_call_original
+
+          body = double('body')
+          headers = double('headers')
+          properties = double('properties')
+
+          expect(subject.on_publish(body, headers, properties)).to eq [body, headers, properties]
+
+          expect(bottom).to have_received(:on_publish).ordered
+          expect(middle).to have_received(:on_publish).ordered
+          expect(top).to have_received(:on_publish).ordered
+        end
+      end
+
+      describe '#on_consume' do
+        it 'passes the message data to each middleware\'s #on_consume message, top to bottom' do
+          load_middleware_doubles
+          expect(subject.middlewares).to eq [bottom, middle, top]
+
+          allow(bottom).to receive(:on_consume).and_call_original
+          allow(middle).to receive(:on_consume).and_call_original
+          allow(top).to receive(:on_consume).and_call_original
+
+          body = double('body')
+          headers = double('headers')
+          properties = double('properties')
+
+          expect(subject.on_consume(body, headers, properties)).to eq [body, headers, properties]
+
+          expect(top).to have_received(:on_consume).ordered
+          expect(middle).to have_received(:on_consume).ordered
+          expect(bottom).to have_received(:on_consume).ordered
+        end
+      end
+    end
+  end
+end