message-driver 0.4.0 → 0.5.0

data/lib/message_driver/message.rb

@@ -3,16 +3,17 @@ module MessageDriver
     class Base
       include Logging
 
-      attr_reader :ctx, :body, :headers, :properties
+      attr_reader :ctx, :body, :raw_body, :headers, :properties
 
-      def initialize(ctx, body, headers, properties)
+      def initialize(ctx, body, headers, properties, raw_body = nil)
         @ctx = ctx
         @body = body
         @headers = headers
         @properties = properties
+        @raw_body = raw_body.nil? ? body : raw_body
       end
 
-      def ack(options={})
+      def ack(options = {})
         if ctx.supports_client_acks?
           ctx.ack_message(self, options)
         else
@@ -20,7 +21,7 @@ module MessageDriver
         end
       end
 
-      def nack(options={})
+      def nack(options = {})
         if ctx.supports_client_acks?
           ctx.nack_message(self, options)
         else

data/lib/message_driver/middleware.rb

@@ -0,0 +1,8 @@
+require 'message_driver/middleware/base'
+require 'message_driver/middleware/block_middleware'
+require 'message_driver/middleware/middleware_stack'
+
+module MessageDriver
+  module Middleware
+  end
+end

data/lib/message_driver/middleware/base.rb

@@ -0,0 +1,19 @@
+module MessageDriver
+  module Middleware
+    class Base
+      attr_reader :destination
+
+      def initialize(*args)
+        @destination = args.shift
+      end
+
+      def on_publish(body, headers, properties)
+        [body, headers, properties]
+      end
+
+      def on_consume(body, headers, properties)
+        [body, headers, properties]
+      end
+    end
+  end
+end

data/lib/message_driver/middleware/block_middleware.rb

@@ -0,0 +1,33 @@
+module MessageDriver
+  module Middleware
+    class BlockMiddleware < Base
+      attr_reader :on_publish_block, :on_consume_block
+
+      def initialize(destination, opts)
+        super(destination)
+        fail ArgumentError, 'you must provide at least one of :on_publish and :on_consume' \
+          unless opts.keys.any? { |k| [:on_publish, :on_consume].include? k }
+        @on_publish_block = opts[:on_publish]
+        @on_consume_block = opts[:on_consume]
+      end
+
+      def on_publish(body, headers, properties)
+        delegate_to_block(on_publish_block, body, headers, properties)
+      end
+
+      def on_consume(body, headers, properties)
+        delegate_to_block(on_consume_block, body, headers, properties)
+      end
+
+      private
+
+      def delegate_to_block(block, body, headers, properties)
+        if block.nil?
+          [body, headers, properties]
+        else
+          block.call(body, headers, properties)
+        end
+      end
+    end
+  end
+end

data/lib/message_driver/middleware/middleware_stack.rb

@@ -0,0 +1,61 @@
+module MessageDriver
+  module Middleware
+    class MiddlewareStack
+      include Enumerable
+
+      attr_reader :destination
+
+      def initialize(destination)
+        @destination = destination
+        @middlewares = []
+      end
+
+      def middlewares
+        @middlewares.dup.freeze
+      end
+
+      def append(middleware_class, *args)
+        middleware = build_middleware(middleware_class, *args)
+        @middlewares << middleware
+        middleware
+      end
+
+      def prepend(middleware_class, *args)
+        middleware = build_middleware(middleware_class, *args)
+        @middlewares.unshift middleware
+        middleware
+      end
+
+      def on_publish(body, headers, properties)
+        @middlewares.reduce([body, headers, properties]) do |args, middleware|
+          middleware.on_publish(*args)
+        end
+      end
+
+      def on_consume(body, headers, properties)
+        @middlewares.reverse.reduce([body, headers, properties]) do |args, middleware|
+          middleware.on_consume(*args)
+        end
+      end
+
+      def empty?
+        @middlewares.empty?
+      end
+
+      def each
+        @middlewares.each { |x| yield x }
+      end
+
+      private
+
+      def build_middleware(middleware_type, *args)
+        case middleware_type
+        when Hash
+          BlockMiddleware.new(destination, middleware_type)
+        else
+          middleware_type.new(destination, *args)
+        end
+      end
+    end
+  end
+end

data/lib/message_driver/subscription.rb

@@ -4,7 +4,7 @@ module MessageDriver
       include Logging
       attr_reader :adapter, :destination, :consumer, :options
 
-      def initialize(adapter, destination, consumer, options={})
+      def initialize(adapter, destination, consumer, options = {})
         @adapter = adapter
         @destination = destination
         @consumer = consumer
@@ -12,7 +12,7 @@ module MessageDriver
       end
 
       def unsubscribe
-        raise 'must be implemented in subclass'
+        fail 'must be implemented in subclass'
       end
     end
   end

data/lib/message_driver/version.rb

@@ -1,5 +1,5 @@
 module Message
   module Driver
-    VERSION = '0.4.0'
+    VERSION = '0.5.0'
   end
 end

data/message-driver.gemspec

@@ -14,15 +14,14 @@ Gem::Specification.new do |gem|
   gem.license       = 'MIT'
 
   gem.files         = `git ls-files`.split($RS)
-  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.executables   = gem.files.grep(/^bin\//).map { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(/^(test|spec|features)\//)
   gem.require_paths = %w(lib)
 
   gem.required_ruby_version = '>= 1.9.2'
 
   gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'rspec', '~> 2.14.0'
+  gem.add_development_dependency 'rspec', '~> 3.1.0'
   gem.add_development_dependency 'cucumber'
   gem.add_development_dependency 'aruba'
-  gem.add_development_dependency 'rubocop'
 end

data/spec/integration/bunny/amqp_integration_spec.rb

@@ -1,15 +1,14 @@
 require 'spec_helper'
 
-describe 'AMQP Integration', :bunny, type: :integration do
+RSpec.describe 'AMQP Integration', :bunny, type: :integration do
   let!(:broker) { MessageDriver::Broker.configure BrokerConfig.config }
 
   context "when a queue can't be found" do
     let(:queue_name) { 'my.lost.queue' }
     it 'raises a MessageDriver::QueueNotFound error' do
-      expect {
+      expect do
         broker.dynamic_destination(queue_name, passive: true)
-      }.to raise_error(MessageDriver::QueueNotFound) do |err|
-        expect(err.queue_name).to eq(queue_name)
+      end.to raise_error(MessageDriver::QueueNotFound) do |err|
         expect(err.nested).to be_a Bunny::NotFound
       end
     end
@@ -17,93 +16,33 @@ describe 'AMQP Integration', :bunny, type: :integration do
 
   context 'when a channel level exception occurs' do
     it 'raises a MessageDriver::WrappedError error' do
-      expect {
+      expect do
         broker.dynamic_destination('not.a.queue', passive: true)
-      }.to raise_error(MessageDriver::WrappedError) { |err| err.nested.should be_a Bunny::ChannelLevelException }
+      end.to raise_error(MessageDriver::WrappedError) { |err| expect(err.nested).to be_a Bunny::ChannelLevelException }
     end
 
     it 'reestablishes the channel transparently' do
-      expect {
+      expect do
         broker.dynamic_destination('not.a.queue', passive: true)
-      }.to raise_error(MessageDriver::WrappedError)
-      expect {
+      end.to raise_error(MessageDriver::WrappedError)
+      expect do
         broker.dynamic_destination('', exclusive: true)
-      }.to_not raise_error
+      end.to_not raise_error
     end
 
     context 'when in a transaction' do
       it 'sets the channel_context as rollback-only until the transaction is finished' do
         MessageDriver::Client.with_message_transaction do
-          expect {
+          expect do
             broker.dynamic_destination('not.a.queue', passive: true)
-          }.to raise_error(MessageDriver::WrappedError)
-          expect {
+          end.to raise_error(MessageDriver::WrappedError)
+          expect do
             broker.dynamic_destination('', exclusive: true)
-          }.to raise_error(MessageDriver::TransactionRollbackOnly)
+          end.to raise_error(MessageDriver::TransactionRollbackOnly)
         end
-        expect {
+        expect do
           broker.dynamic_destination('', exclusive: true)
-        }.to_not raise_error
-      end
-    end
-  end
-
-  context 'when the broker connection fails', pending: 'these spec are busted' do
-    def disrupt_connection
-      #yes, this is very implementation specific
-      broker.adapter.connection.instance_variable_get(:@transport).close
-    end
-
-    def create_destination(queue_name)
-      broker.dynamic_destination(queue_name, exclusive: true)
-    end
-
-    it 'raises a MessageDriver::ConnectionError' do
-      dest = create_destination('test_queue')
-      disrupt_connection
-      expect {
-        dest.publish('Reconnection Test')
-      }.to raise_error(MessageDriver::ConnectionError) do |err|
-        expect(err.nested).to be_a Bunny::NetworkErrorWrapper
-      end
-    end
-
-    it 'seemlessly reconnects' do
-      dest = create_destination('seemless.reconnect.queue')
-      disrupt_connection
-      expect {
-        dest.publish('Reconnection Test 1')
-      }.to raise_error(MessageDriver::ConnectionError)
-      dest = create_destination('seemless.reconnect.queue')
-      dest.publish('Reconnection Test 2')
-      msg = dest.pop_message
-      expect(msg).to_not be_nil
-      expect(msg.body).to eq('Reconnection Test 2')
-    end
-
-    context 'when in a transaction' do
-      it 'raises a MessageDriver::ConnectionError' do
-        expect {
-          MessageDriver::Client.with_message_transaction do
-            disrupt_connection
-            broker.dynamic_destination('', exclusive: true)
-          end
-        }.to raise_error(MessageDriver::ConnectionError)
-      end
-
-      it 'sets the channel_context as rollback-only until the transaction is finished' do
-        MessageDriver::Client.with_message_transaction do
-          disrupt_connection
-          expect {
-            broker.dynamic_destination('', exclusive: true)
-          }.to raise_error(MessageDriver::ConnectionError)
-          expect {
-            broker.dynamic_destination('', exclusive: true)
-          }.to raise_error(MessageDriver::TransactionRollbackOnly)
-        end
-        expect {
-          broker.dynamic_destination('', exclusive: true)
-        }.to_not raise_error
+        end.to_not raise_error
       end
     end
   end
@@ -112,22 +51,22 @@ describe 'AMQP Integration', :bunny, type: :integration do
     let(:destination) { broker.dynamic_destination('', exclusive: true) }
 
     it 'rolls back the transaction' do
-      expect {
+      expect do
         MessageDriver::Client.with_message_transaction do
           destination.publish('Test Message')
-          raise 'unhandled error'
+          fail 'unhandled error'
         end
-      }.to raise_error 'unhandled error'
+      end.to raise_error 'unhandled error'
       expect(destination.pop_message).to be_nil
     end
 
     it 'allows the next transaction to continue' do
-      expect {
+      expect do
         MessageDriver::Client.with_message_transaction do
           destination.publish('Test Message 1')
-          raise 'unhandled error'
+          fail 'unhandled error'
         end
-      }.to raise_error 'unhandled error'
+      end.to raise_error 'unhandled error'
       expect(destination.pop_message).to be_nil
 
       MessageDriver::Client.with_message_transaction do

data/spec/integration/bunny/bunny_adapter_spec.rb

@@ -2,351 +2,371 @@ require 'spec_helper'
 
 require 'message_driver/adapters/bunny_adapter'
 
-module MessageDriver::Adapters
-  describe BunnyAdapter, :bunny, type: :integration do
-
-    let(:valid_connection_attrs) { BrokerConfig.config }
-
-    describe '#initialize' do
-      context 'differing bunny versions' do
-        let(:broker) { double('broker') }
-        shared_examples 'raises an error' do
-          it 'raises an error' do
-            stub_const('Bunny::VERSION', version)
-            expect {
-              described_class.new(broker, valid_connection_attrs)
-            }.to raise_error MessageDriver::Error, 'bunny 1.2.2 or later is required for the bunny adapter'
+module MessageDriver
+  module Adapters
+    RSpec.describe BunnyAdapter, :bunny, type: :integration do
+      let(:valid_connection_attrs) { BrokerConfig.config }
+
+      describe '#initialize' do
+        context 'differing bunny versions' do
+          let(:broker) { double('broker') }
+          shared_examples 'raises an error' do
+            it 'raises an error' do
+              stub_const('Bunny::VERSION', version)
+              expect do
+                described_class.new(broker, valid_connection_attrs)
+              end.to raise_error MessageDriver::Error, 'bunny 1.2.2 or later is required for the bunny adapter'
+            end
           end
-        end
-        shared_examples "doesn't raise an error" do
-          it "doesn't raise an an error" do
-            stub_const('Bunny::VERSION', version)
-            adapter = nil
-            expect {
-              adapter = described_class.new(broker, valid_connection_attrs)
-            }.to_not raise_error
+          shared_examples "doesn't raise an error" do
+            it "doesn't raise an an error" do
+              stub_const('Bunny::VERSION', version)
+              adapter = nil
+              expect do
+                adapter = described_class.new(broker, valid_connection_attrs)
+              end.to_not raise_error
+            end
           end
-        end
-        %w(0.8.0  0.9.0 0.9.8 0.10.7 1.0.3 1.1.2 1.2.1).each do |v|
-          context "bunny version #{v}" do
-            let(:version) { v }
-            include_examples 'raises an error'
+          %w(0.8.0  0.9.0 0.9.8 0.10.7 1.0.3 1.1.2 1.2.1).each do |v|
+            context "bunny version #{v}" do
+              let(:version) { v }
+              include_examples 'raises an error'
+            end
           end
-        end
-        %w(1.2.2 1.3.2 1.4.0).each do |v|
-          context "bunny version #{v}" do
-            let(:version) { v }
-            include_examples "doesn't raise an error"
+          %w(1.2.2 1.3.2 1.4.0).each do |v|
+            context "bunny version #{v}" do
+              let(:version) { v }
+              include_examples "doesn't raise an error"
+            end
           end
         end
-      end
 
-      it 'connects to the rabbit broker' do
-        broker = double(:broker)
-        adapter = described_class.new(broker, valid_connection_attrs)
+        it 'connects to the rabbit broker' do
+          broker = double(:broker)
+          adapter = described_class.new(broker, valid_connection_attrs)
 
-        expect(adapter.connection).to be_a Bunny::Session
-        expect(adapter.connection).to be_open
-      end
+          expect(adapter.connection).to be_a Bunny::Session
+          expect(adapter.connection).to be_open
+        end
 
-      it 'connects to the rabbit broker lazily' do
-        broker = double(:broker)
-        adapter = described_class.new(broker, valid_connection_attrs)
+        it 'connects to the rabbit broker lazily' do
+          broker = double(:broker)
+          adapter = described_class.new(broker, valid_connection_attrs)
 
-        expect(adapter.connection(false)).to be_nil
+          expect(adapter.connection(false)).to be_nil
+        end
       end
-    end
 
-    shared_context 'a connected bunny adapter' do
-      let(:broker) { MessageDriver::Broker.configure(valid_connection_attrs) }
-      subject(:adapter) { broker.adapter }
-      let(:connection) { adapter.connection }
+      shared_context 'a connected bunny adapter' do
+        let(:broker) { MessageDriver::Broker.configure(valid_connection_attrs) }
+        subject(:adapter) { broker.adapter }
+        let(:connection) { adapter.connection }
 
-      after do
-        adapter.stop
+        after do
+          adapter.stop
+        end
       end
-    end
-
-    shared_context 'with a queue' do
-      include_context 'a connected bunny adapter'
-
-      let(:channel) { connection.create_channel }
-      let(:tmp_queue_name) { 'my_temp_queue' }
-      let(:tmp_queue) { channel.queue(tmp_queue_name, exclusive: true) }
-    end
-
-    it_behaves_like 'an adapter' do
-      include_context 'a connected bunny adapter'
-    end
 
-    describe '#new_context' do
-      include_context 'a connected bunny adapter'
+      shared_context 'with a queue' do
+        include_context 'a connected bunny adapter'
 
-      it 'returns a BunnyAdapter::BunnyContext' do
-        expect(subject.new_context).to be_a BunnyAdapter::BunnyContext
+        let(:channel) { connection.create_channel }
+        let(:tmp_queue_name) { 'my_temp_queue' }
+        let(:tmp_queue) { channel.queue(tmp_queue_name, exclusive: true) }
       end
-    end
 
-    describe BunnyAdapter::BunnyContext do
-      include_context 'a connected bunny adapter'
-      subject(:adapter_context) { adapter.new_context }
-      around(:each) do |ex|
-        MessageDriver::Client.with_adapter_context(adapter_context) do
-          ex.run
-        end
+      it_behaves_like 'an adapter' do
+        include_context 'a connected bunny adapter'
       end
 
-      it_behaves_like 'an adapter context'
-      it_behaves_like 'transactions are supported'
-      it_behaves_like 'client acks are supported'
-      it_behaves_like 'subscriptions are supported', BunnyAdapter::Subscription
+      describe '#new_context' do
+        include_context 'a connected bunny adapter'
 
-      describe '#pop_message' do
-        include_context 'with a queue'
-        it 'needs some real tests'
+        it 'returns a BunnyAdapter::BunnyContext' do
+          expect(subject.new_context).to be_a BunnyAdapter::BunnyContext
+        end
       end
 
-      describe '#invalidate' do
-        it 'closes the channel' do
-          subject.with_channel(false) do |ch|
-            expect(ch).to be_open
+      describe BunnyAdapter::BunnyContext do
+        include_context 'a connected bunny adapter'
+        subject(:adapter_context) { adapter.new_context }
+        around(:example) do |ex|
+          MessageDriver::Client.with_adapter_context(adapter_context) do
+            ex.run
           end
-          subject.invalidate
-          expect(subject.instance_variable_get(:@channel)).to be_closed
         end
-      end
-
-      describe '#create_destination' do
 
-        context 'with defaults' do
-          context 'the resulting destination' do
-            let(:dest_name) { 'my_dest' }
-            subject(:result) { adapter_context.create_destination(dest_name, exclusive: true) }
+        it_behaves_like 'an adapter context'
+        it_behaves_like 'transactions are supported'
+        it_behaves_like 'client acks are supported'
+        it_behaves_like 'subscriptions are supported', BunnyAdapter::Subscription
 
-            it { should be_a BunnyAdapter::QueueDestination }
-          end
+        describe '#pop_message' do
+          include_context 'with a queue'
+          it 'needs some real tests'
         end
 
-        shared_examples 'supports publisher confirmations' do
-          let(:properties) { {persistent: false, confirm: true} }
-          it 'switches the channel to confirms mode' do
-            expect(adapter_context.channel.using_publisher_confirms?).to eq(true)
-          end
-          it 'waits until the confirm comes in' do
-            expect(adapter_context.channel.unconfirmed_set).to be_empty
+        describe '#invalidate' do
+          it 'closes the channel' do
+            subject.with_channel(false) do |ch|
+              expect(ch).to be_open
+            end
+            subject.invalidate
+            expect(subject.instance_variable_get(:@channel)).to be_closed
           end
         end
 
-        context 'the type is queue' do
-          context 'and there is no destination name given' do
-            subject(:destination) { adapter_context.create_destination('', type: :queue, exclusive: true) }
-            it { should be_a BunnyAdapter::QueueDestination }
-            its(:name) { should be_a String }
-            its(:name) { should_not be_empty }
-          end
-          context 'the resulting destination' do
-            let(:dest_name) { 'my_dest' }
-            subject(:destination) { adapter_context.create_destination(dest_name, type: :queue, exclusive: true) }
-            before do
-              destination
-            end
+        describe '#create_destination' do
 
-            it { should be_a BunnyAdapter::QueueDestination }
-            its(:name) { should be_a String }
-            its(:name) { should eq(dest_name) }
+          context 'with defaults' do
+            context 'the resulting destination' do
+              let(:dest_name) { 'my_dest' }
+              subject(:result) { adapter_context.create_destination(dest_name, exclusive: true) }
 
-            include_examples 'supports #message_count'
+              it { is_expected.to be_a BunnyAdapter::QueueDestination }
+            end
+          end
 
-            it "strips off the type so it isn't set on the destination" do
-              expect(subject.dest_options).to_not have_key :type
+          shared_examples 'supports publisher confirmations' do
+            let(:properties) { { persistent: false, confirm: true } }
+            it 'switches the channel to confirms mode' do
+              expect(adapter_context.channel.using_publisher_confirms?).to eq(true)
+            end
+            it 'waits until the confirm comes in' do
+              expect(adapter_context.channel.unconfirmed_set).to be_empty
             end
-            it 'ensures the queue is declared' do
-              expect {
-                connection.with_channel do |ch|
-                  ch.queue(dest_name, passive: true)
+          end
+
+          context 'the type is queue' do
+            context 'and there is no destination name given' do
+              subject(:destination) { adapter_context.create_destination('', type: :queue, exclusive: true) }
+              it { is_expected.to be_a BunnyAdapter::QueueDestination }
+
+              describe '#name' do
+                it 'is a non-empty String' do
+                  expect(subject.name).to be_a String
+                  expect(subject.name).not_to be_empty
                 end
-              }.to_not raise_error
+              end
             end
-            context 'publishing a message' do
-              let(:body) { 'Testing the QueueDestination' }
-              let(:headers) { {'foo' => 'bar'} }
-              let(:properties) { {persistent: false} }
+
+            context 'the resulting destination' do
+              let(:dest_name) { 'my_dest' }
+              subject(:destination) { adapter_context.create_destination(dest_name, type: :queue, exclusive: true) }
               before do
-                subject.publish(body, headers, properties)
+                destination
+              end
+
+              it { is_expected.to be_a BunnyAdapter::QueueDestination }
+
+              describe '#name' do
+                it 'is the destination name' do
+                  expect(subject.name).to be_a String
+                  expect(subject.name).to eq(dest_name)
+                end
+              end
+
+              include_examples 'supports #message_count'
+              include_examples 'supports #consumer_count'
+
+              it "strips off the type so it isn't set on the destination" do
+                expect(subject.dest_options).to_not have_key :type
               end
-              it 'publishes via the default exchange' do
-                msg = subject.pop_message
-                expect(msg.body).to eq(body)
-                expect(msg.headers).to eq(headers)
-                expect(msg.properties[:delivery_mode]).to eq(1)
-                expect(msg.delivery_info.exchange).to eq('')
-                expect(msg.delivery_info.routing_key).to eq(subject.name)
+              it 'ensures the queue is declared' do
+                expect do
+                  connection.with_channel do |ch|
+                    ch.queue(dest_name, passive: true)
+                  end
+                end.to_not raise_error
               end
-              include_examples 'supports publisher confirmations'
-            end
-            it_behaves_like 'a destination'
-          end
-          context 'and bindings are provided' do
-            let(:dest_name) { 'binding_test_queue' }
-            let(:exchange) { adapter_context.create_destination('amq.direct', type: :exchange) }
-
-            it "raises an exception if you don't provide a source" do
-              expect {
-                adapter_context.create_destination('bad_bind_queue', type: :queue, exclusive: true, bindings: [{args: {routing_key: 'test_exchange_bind'}}])
-              }.to raise_error MessageDriver::Error, /must provide a source/
+              context 'publishing a message' do
+                let(:body) { 'Testing the QueueDestination' }
+                let(:headers) { { 'foo' => 'bar' } }
+                let(:properties) { { persistent: false } }
+                before do
+                  subject.publish(body, headers, properties)
+                end
+                it 'publishes via the default exchange' do
+                  msg = subject.pop_message
+                  expect(msg.body).to eq(body)
+                  expect(msg.headers).to eq(headers)
+                  expect(msg.properties[:delivery_mode]).to eq(1)
+                  expect(msg.delivery_info.exchange).to eq('')
+                  expect(msg.delivery_info.routing_key).to eq(subject.name)
+                end
+                include_examples 'supports publisher confirmations'
+              end
+              it_behaves_like 'a destination'
             end
+            context 'and bindings are provided' do
+              let(:dest_name) { 'binding_test_queue' }
+              let(:exchange) { adapter_context.create_destination('amq.direct', type: :exchange) }
+
+              it "raises an exception if you don't provide a source" do
+                expect do
+                  adapter_context.create_destination('bad_bind_queue', type: :queue, exclusive: true, bindings: [{ args: { routing_key: 'test_exchange_bind' } }])
+                end.to raise_error MessageDriver::Error, /must provide a source/
+              end
 
-            it 'routes message to the queue through the exchange' do
-              destination = adapter_context.create_destination(dest_name, type: :queue, exclusive: true, bindings: [{source: 'amq.direct', args: {routing_key: 'test_queue_bind'}}])
-              exchange.publish('test queue bindings', {}, routing_key: 'test_queue_bind')
-              message = destination.pop_message
-              expect(message).to_not be_nil
-              expect(message.body).to eq('test queue bindings')
+              it 'routes message to the queue through the exchange' do
+                destination = adapter_context.create_destination(dest_name, type: :queue,
+                                                                            exclusive: true,
+                                                                            bindings: [{
+                                                                              source: 'amq.direct',
+                                                                              args: { routing_key: 'test_queue_bind' }
+                                                                            }]
+                                                                )
+                exchange.publish('test queue bindings', {}, routing_key: 'test_queue_bind')
+                message = destination.pop_message
+                expect(message).to_not be_nil
+                expect(message.body).to eq('test queue bindings')
+              end
             end
-          end
 
-          context 'we are not yet connected to the broker and :no_declare is provided' do
-            it "doesn't cause a connection to the broker" do
-              connection.stop
-              adapter_context.create_destination('test_queue', no_declare: true, type: :queue, exclusive: true)
-              expect(adapter.connection(false)).to_not be_open
-            end
+            context 'we are not yet connected to the broker and :no_declare is provided' do
+              it "doesn't cause a connection to the broker" do
+                connection.stop
+                adapter_context.create_destination('test_queue', no_declare: true, type: :queue, exclusive: true)
+                expect(adapter.connection(false)).to_not be_open
+              end
 
-            context 'with a server-named queue' do
-              it 'raises an error' do
-                expect {
-                  adapter_context.create_destination('', no_declare: true, type: :queue, exclusive: true)
-                }.to raise_error MessageDriver::Error, 'server-named queues must be declared, but you provided :no_declare => true'
+              context 'with a server-named queue' do
+                it 'raises an error' do
+                  expect do
+                    adapter_context.create_destination('', no_declare: true, type: :queue, exclusive: true)
+                  end.to raise_error MessageDriver::Error, 'server-named queues must be declared, but you provided :no_declare => true'
+                end
               end
-            end
 
-            context 'with bindings' do
-              it 'raises an error' do
-                expect {
-                  adapter_context.create_destination('tmp_queue', no_declare: true, bindings: [{source: 'amq.fanout'}], type: :queue, exclusive: true)
-                }.to raise_error MessageDriver::Error, 'queues with bindings must be declared, but you provided :no_declare => true'
+              context 'with bindings' do
+                it 'raises an error' do
+                  expect do
+                    adapter_context.create_destination('tmp_queue', no_declare: true, bindings: [{ source: 'amq.fanout' }], type: :queue, exclusive: true)
+                  end.to raise_error MessageDriver::Error, 'queues with bindings must be declared, but you provided :no_declare => true'
+                end
               end
             end
           end
-        end
 
-        context 'the type is exchange' do
-          context 'the resulting destination' do
-            let(:dest_name) { 'my_dest' }
-            subject(:destination) { adapter_context.create_destination(dest_name, type: :exchange) }
+          context 'the type is exchange' do
+            context 'the resulting destination' do
+              let(:dest_name) { 'my_dest' }
+              subject(:destination) { adapter_context.create_destination(dest_name, type: :exchange) }
 
-            it { should be_a BunnyAdapter::ExchangeDestination }
-            include_examples "doesn't support #message_count"
+              it { is_expected.to be_a BunnyAdapter::ExchangeDestination }
+              include_examples "doesn't support #message_count"
+              include_examples "doesn't support #consumer_count"
 
-            it "strips off the type so it isn't set on the destination" do
-              expect(subject.dest_options).to_not have_key :type
-            end
+              it "strips off the type so it isn't set on the destination" do
+                expect(subject.dest_options).to_not have_key :type
+              end
 
-            it 'raises an error when pop_message is called' do
-              expect {
-                subject.pop_message(dest_name)
-              }.to raise_error MessageDriver::Error, "You can't pop a message off an exchange"
-            end
+              it 'raises an error when pop_message is called' do
+                expect do
+                  subject.pop_message(dest_name)
+                end.to raise_error MessageDriver::Error, "You can't pop a message off an exchange"
+              end
 
-            context 'publishing a message' do
-              let(:body) { 'Testing the ExchangeDestination' }
-              let(:headers) { {'foo' => 'bar'} }
-              let(:properties) { {persistent: false} }
-              before { connection.with_channel { |ch| ch.fanout(dest_name, auto_delete: true) } }
-              let!(:queue) do
-                q = nil
-                connection.with_channel do |ch|
-                  q = ch.queue('', exclusive: true)
-                  q.bind(dest_name)
+              context 'publishing a message' do
+                let(:body) { 'Testing the ExchangeDestination' }
+                let(:headers) { { 'foo' => 'bar' } }
+                let(:properties) { { persistent: false } }
+                before { connection.with_channel { |ch| ch.fanout(dest_name, auto_delete: true) } }
+                let!(:queue) do
+                  q = nil
+                  connection.with_channel do |ch|
+                    q = ch.queue('', exclusive: true)
+                    q.bind(dest_name)
+                  end
+                  q
+                end
+                before do
+                  subject.publish(body, headers, properties)
                 end
-                q
-              end
-              before do
-                subject.publish(body, headers, properties)
-              end
 
-              it 'publishes to the specified exchange' do
-                connection.with_channel do |ch|
-                  q = ch.queue(queue.name, passive: true)
-                  msg = q.pop
-                  expect(msg[2]).to eq(body)
-                  expect(msg[0].exchange).to eq(dest_name)
-                  expect(msg[1][:headers]).to eq(headers)
-                  expect(msg[1][:delivery_mode]).to eq(1)
+                it 'publishes to the specified exchange' do
+                  connection.with_channel do |ch|
+                    q = ch.queue(queue.name, passive: true)
+                    msg = q.pop
+                    expect(msg[2]).to eq(body)
+                    expect(msg[0].exchange).to eq(dest_name)
+                    expect(msg[1][:headers]).to eq(headers)
+                    expect(msg[1][:delivery_mode]).to eq(1)
+                  end
                 end
+                include_examples 'supports publisher confirmations'
               end
-              include_examples 'supports publisher confirmations'
             end
-          end
 
-          context 'declaring an exchange on the broker' do
-            let(:dest_name) { 'my.cool.exchange' }
+            context 'declaring an exchange on the broker' do
+              let(:dest_name) { 'my.cool.exchange' }
 
-            it "creates the exchange if you include 'declare' in the options" do
-              exchange = adapter_context.create_destination(dest_name, type: :exchange, declare: {type: :fanout, auto_delete: true})
-              queue = adapter_context.create_destination('', type: :queue, exclusive: true, bindings: [{source: dest_name}])
-              exchange.publish('test declaring exchange')
-              message = queue.pop_message
-              expect(message).to_not be_nil
-              expect(message.body).to eq('test declaring exchange')
-            end
+              it "creates the exchange if you include 'declare' in the options" do
+                exchange = adapter_context.create_destination(dest_name, type: :exchange, declare: { type: :fanout, auto_delete: true })
+                queue = adapter_context.create_destination('', type: :queue, exclusive: true, bindings: [{ source: dest_name }])
+                exchange.publish('test declaring exchange')
+                message = queue.pop_message
+                expect(message).to_not be_nil
+                expect(message.body).to eq('test declaring exchange')
+              end
+
+              it "raises an error if you don't provide a type" do
+                expect do
+                  adapter_context.create_destination(dest_name, type: :exchange, declare: { auto_delete: true })
+                end.to raise_error MessageDriver::Error, /you must provide a valid exchange type/
+              end
 
-            it "raises an error if you don't provide a type" do
-              expect {
-                adapter_context.create_destination(dest_name, type: :exchange, declare: {auto_delete: true})
-              }.to raise_error MessageDriver::Error, /you must provide a valid exchange type/
             end
 
-          end
+            context 'and bindings are provided' do
+              let(:dest_name) { 'binding_exchange_queue' }
+              let(:exchange) { adapter_context.create_destination('amq.direct', type: :exchange) }
 
-          context 'and bindings are provided' do
-            let(:dest_name) { 'binding_exchange_queue' }
-            let(:exchange) { adapter_context.create_destination('amq.direct', type: :exchange) }
+              it "raises an exception if you don't provide a source" do
+                expect do
+                  adapter_context.create_destination('amq.fanout', type: :exchange, bindings: [{ args: { routing_key: 'test_exchange_bind' } }])
+                end.to raise_error MessageDriver::Error, /must provide a source/
+              end
 
-            it "raises an exception if you don't provide a source" do
-              expect {
-                adapter_context.create_destination('amq.fanout', type: :exchange, bindings: [{args: {routing_key: 'test_exchange_bind'}}])
-              }.to raise_error MessageDriver::Error, /must provide a source/
+              it 'routes message to the queue through the exchange' do
+                adapter_context.create_destination('amq.fanout', type: :exchange, bindings: [{ source: 'amq.direct', args: { routing_key: 'test_exchange_bind' } }])
+                destination = adapter_context.create_destination(dest_name, type: :queue, exclusive: true, bindings: [{ source: 'amq.fanout' }])
+                exchange.publish('test exchange bindings', {}, routing_key: 'test_exchange_bind')
+                message = destination.pop_message
+                expect(message).to_not be_nil
+                expect(message.body).to eq('test exchange bindings')
+              end
             end
 
-            it 'routes message to the queue through the exchange' do
-              adapter_context.create_destination('amq.fanout', type: :exchange, bindings: [{source: 'amq.direct', args: {routing_key: 'test_exchange_bind'}}])
-              destination = adapter_context.create_destination(dest_name, type: :queue, exclusive: true, bindings: [{source: 'amq.fanout'}])
-              exchange.publish('test exchange bindings', {}, routing_key: 'test_exchange_bind')
-              message = destination.pop_message
-              expect(message).to_not be_nil
-              expect(message.body).to eq('test exchange bindings')
+            context 'we are not yet connected to the broker' do
+              it "doesn't cause a connection to the broker" do
+                connection.stop
+                adapter_context.create_destination('amq.fanout', type: :exchange)
+                expect(adapter.connection(false)).to_not be_open
+              end
             end
           end
 
-          context 'we are not yet connected to the broker' do
-            it "doesn't cause a connection to the broker" do
-              connection.stop
-              adapter_context.create_destination('amq.fanout', type: :exchange)
-              expect(adapter.connection(false)).to_not be_open
+          context 'the type is invalid' do
+            it 'raises in an error' do
+              expect do
+                adapter_context.create_destination('my_dest', type: :foo_bar)
+              end.to raise_error MessageDriver::Error, "invalid destination type #{:foo_bar}"
             end
           end
         end
 
-        context 'the type is invalid' do
-          it 'raises in an error' do
-            expect {
-              adapter_context.create_destination('my_dest', type: :foo_bar)
-            }.to raise_error MessageDriver::Error, "invalid destination type #{:foo_bar}"
-          end
-        end
-      end
-
-      describe '#subscribe' do
-        context 'the destination is an ExchangeDestination' do
-          let(:dest_name) { 'my_dest' }
-          let(:destination) { adapter_context.create_destination(dest_name, type: :exchange) }
-          let(:consumer) { lambda do |_|; end }
+        describe '#subscribe' do
+          context 'the destination is an ExchangeDestination' do
+            let(:dest_name) { 'my_dest' }
+            let(:destination) { adapter_context.create_destination(dest_name, type: :exchange) }
+            let(:consumer) { ->(_) {} }
 
-          it 'raises an error' do
-            expect {
-              adapter_context.subscribe(destination, &consumer)
-            }.to raise_error MessageDriver::Error, /QueueDestination/
+            it 'raises an error' do
+              expect do
+                adapter_context.subscribe(destination, &consumer)
+              end.to raise_error MessageDriver::Error, /QueueDestination/
+            end
           end
         end
       end