message-driver 0.4.0 → 0.5.0

data/spec/units/message_driver/broker_spec.rb

@@ -2,15 +2,15 @@ require 'spec_helper'
 require 'message_driver/adapters/in_memory_adapter'
 
 module MessageDriver
-  describe Broker do
+  RSpec.describe Broker do
     let(:broker_name) { described_class::DEFAULT_BROKER_NAME }
     let(:options) { { adapter: :in_memory } }
 
     describe '.configure and .broker' do
       it 'calls new, passing in the options and saves the instance' do
-        options = {foo: :bar}
+        options = { foo: :bar }
         result = double(described_class).as_null_object
-        described_class.should_receive(:new).with(described_class::DEFAULT_BROKER_NAME, options).and_return(result)
+        expect(described_class).to receive(:new).with(described_class::DEFAULT_BROKER_NAME, options).and_return(result)
 
         described_class.configure(options)
 
@@ -20,15 +20,15 @@ module MessageDriver
 
       it "doesn't allow you to configure the same broker twice" do
         described_class.configure(broker_name, options)
-        expect {
+        expect do
           described_class.configure(broker_name, options)
-        }.to raise_error MessageDriver::BrokerAlreadyConfigured, match('default')
+        end.to raise_error MessageDriver::BrokerAlreadyConfigured, /default/
       end
 
       context 'when configurating multiple brokers' do
         it 'allows you to fetch each configured broker through .broker' do
-          options1 = {foo: :bar}
-          options2 = {bar: :baz}
+          options1 = { foo: :bar }
+          options2 = { bar: :baz }
           result1 = double('result1').as_null_object
           result2 = double('result2').as_null_object
           allow(described_class).to receive(:new).with(:result1, options1).and_return(result1)
@@ -44,9 +44,9 @@ module MessageDriver
 
       context "when you try to access a broker that isn't configured" do
         it 'should raise an error' do
-          expect {
+          expect do
             described_class.broker(:not_an_adapter)
-          }.to raise_error BrokerNotConfigured
+          end.to raise_error BrokerNotConfigured
         end
       end
     end
@@ -64,13 +64,13 @@ module MessageDriver
         expect(broker1).to have_received(:stop)
         expect(broker2).to have_received(:stop)
 
-        expect {
+        expect do
           described_class.broker(:broker1)
-        }.to raise_error BrokerNotConfigured
+        end.to raise_error BrokerNotConfigured
 
-        expect {
+        expect do
           described_class.broker(:broker2)
-        }.to raise_error BrokerNotConfigured
+        end.to raise_error BrokerNotConfigured
       end
 
       context 'when one of the brokers raises and error' do
@@ -81,20 +81,20 @@ module MessageDriver
           allow(broker1).to receive(:stop).and_raise 'error stopping broker1!'
           allow(broker2).to receive(:stop).and_call_original
 
-          expect {
+          expect do
             described_class.reset
-          }.not_to raise_error
+          end.not_to raise_error
 
           expect(broker1).to have_received(:stop)
           expect(broker2).to have_received(:stop)
 
-          expect {
+          expect do
             described_class.broker(:broker1)
-          }.to raise_error BrokerNotConfigured
+          end.to raise_error BrokerNotConfigured
 
-          expect {
+          expect do
             described_class.broker(:broker2)
-          }.to raise_error BrokerNotConfigured
+          end.to raise_error BrokerNotConfigured
         end
       end
     end
@@ -123,9 +123,9 @@ module MessageDriver
 
     describe '#initialize' do
       it "raises an error if you don't specify an adapter" do
-        expect {
+        expect do
           described_class.new({})
-        }.to raise_error(/must specify an adapter/)
+        end.to raise_error(/must specify an adapter/)
       end
 
       it 'if you provide an adapter instance, it uses that one' do
@@ -152,9 +152,9 @@ module MessageDriver
       it "raises and error if you don't provide a MessageDriver::Adapters::Base" do
         adapter = Hash.new
 
-        expect {
+        expect do
           described_class.new(adapter: adapter)
-        }.to raise_error(/adapter must be a MessageDriver::Adapters::Base/)
+        end.to raise_error(/adapter must be a MessageDriver::Adapters::Base/)
       end
 
       it 'starts off with the adapter not stopped' do
@@ -194,9 +194,9 @@ module MessageDriver
         end
 
         it 'marks the broker as stopped' do
-          expect {
+          expect do
             subject.stop
-          }.to change { subject.stopped? }.from(false).to(true)
+          end.to change { subject.stopped? }.from(false).to(true)
         end
 
         it 'invalidates the contexts' do
@@ -215,9 +215,9 @@ module MessageDriver
         end
 
         it 'reconfigures the adapter' do
-          expect {
+          expect do
             subject.restart
-          }.to change { subject.adapter }
+          end.to change { subject.adapter }
         end
 
         it "stops the adapter if it hasn't already been stopped" do
@@ -228,16 +228,16 @@ module MessageDriver
         it 'does not stop the adapter again if it has already been stopped' do
           expect(subject.adapter).to be original_adapter
           subject.stop
-          expect {
+          expect do
             subject.restart
-          }.to change { subject.stopped? }.from(true).to(false)
+          end.to change { subject.stopped? }.from(true).to(false)
           expect(original_adapter).to have_received(:stop).once
         end
       end
 
       describe '#configuration' do
         it 'returns the configuration hash you passed to .configure' do
-          config = {adapter: :in_memory, foo: :bar, baz: :boz}
+          config = { adapter: :in_memory, foo: :bar, baz: :boz }
           instance = described_class.new(config)
           expect(instance.configuration).to be config
         end
@@ -259,15 +259,15 @@ module MessageDriver
         context "when the destination can't be found" do
           let(:bad_dest_name) { :not_a_queue }
           it 'raises a MessageDriver:NoSuchDestinationError' do
-            expect {
+            expect do
               broker.find_destination(bad_dest_name)
-            }.to raise_error(MessageDriver::NoSuchDestinationError, /#{bad_dest_name}/)
+            end.to raise_error(MessageDriver::NoSuchDestinationError, /#{bad_dest_name}/)
           end
         end
       end
 
       describe '#consumer' do
-        let(:consumer_double) { lambda do |_| end }
+        let(:consumer_double) { ->(_) {} }
         it 'saves the provided consumer' do
           broker.consumer(:my_consumer, &consumer_double)
           expect(broker.consumers[:my_consumer]).to be(consumer_double)
@@ -275,15 +275,15 @@ module MessageDriver
 
         context 'when no consumer is provided' do
           it 'raises an error' do
-            expect {
+            expect do
               broker.consumer(:my_consumer)
-            }.to raise_error(MessageDriver::Error, 'you must provide a block')
+            end.to raise_error(MessageDriver::Error, 'you must provide a block')
           end
         end
       end
 
       describe '#find_consumer' do
-        let(:consumer_double) { lambda do |_| end }
+        let(:consumer_double) { ->(_) {} }
         it 'finds the previously defined consumer' do
           my_consumer = broker.consumer(:my_consumer, &consumer_double)
           expect(broker.find_consumer(:my_consumer)).to be(my_consumer)
@@ -292,9 +292,9 @@ module MessageDriver
         context "when the consumer can't be found" do
           let(:bad_consumer_name) { :not_a_queue }
           it 'raises a MessageDriver:NoSuchConsumerError' do
-            expect {
+            expect do
               broker.find_consumer(bad_consumer_name)
-            }.to raise_error(MessageDriver::NoSuchConsumerError, /#{bad_consumer_name}/)
+            end.to raise_error(MessageDriver::NoSuchConsumerError, /#{bad_consumer_name}/)
           end
         end
       end

data/spec/units/message_driver/client_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 require 'message_driver/adapters/in_memory_adapter'
 
 module MessageDriver
-  describe Client do
+  RSpec.describe Client do
     class TestPublisher
       include Client
     end
@@ -41,66 +41,66 @@ module MessageDriver
       end
 
       context 'with a given adapter_context' do
-        around(:each) do |example|
+        around(:example) do |example|
           subject.with_adapter_context(adapter_context, &example)
         end
 
         describe '#dynamic_destination' do
           let(:dest_name) { 'my_new_queue' }
-          let(:dest_options) { {type: 2} }
-          let(:message_props) { {expires: 'soon'} }
+          let(:dest_options) { { type: 2 } }
+          let(:message_props) { { expires: 'soon' } }
           let(:created_dest) { double('created destination') }
           before do
-            adapter_context.stub(:create_destination) { created_dest }
+            allow(adapter_context).to receive(:create_destination) { created_dest }
           end
 
           it 'delegates to the adapter_context' do
             result = subject.dynamic_destination(dest_name, dest_options, message_props)
             expect(result).to be(created_dest)
 
-            adapter_context.should have_received(:create_destination).with(dest_name, dest_options, message_props)
+            expect(adapter_context).to have_received(:create_destination).with(dest_name, dest_options, message_props)
           end
 
           it 'only requires destination name' do
             result = subject.dynamic_destination(dest_name)
             expect(result).to be(created_dest)
 
-            adapter_context.should have_received(:create_destination).with(dest_name, {}, {})
+            expect(adapter_context).to have_received(:create_destination).with(dest_name, {}, {})
           end
         end
 
         describe '#publish' do
           let(:destination) { broker.destination(:my_queue, 'my_queue', exclusive: true) }
           let(:body) { 'my message' }
-          let(:headers) { {foo: :bar} }
-          let(:properties) { {bar: :baz} }
+          let(:headers) { { foo: :bar } }
+          let(:properties) { { bar: :baz } }
           before do
-            adapter_context.stub(:publish)
+            allow(destination).to receive(:publish)
           end
 
-          it 'delegates to the adapter_context' do
+          it 'delegates to the destination' do
             subject.publish(destination, body, headers, properties)
-            adapter_context.should have_received(:publish).with(destination, body, headers, properties)
+            expect(destination).to have_received(:publish).with(body, headers, properties)
           end
 
-          it 'only requires destination and body' do
+          it 'only requires the body' do
             subject.publish(destination, body)
-            adapter_context.should have_received(:publish).with(destination, body, {}, {})
+            expect(destination).to have_received(:publish).with(body, {}, {})
           end
 
           it 'looks up the destination if necessary' do
             destination
             subject.publish(:my_queue, body, headers, properties)
-            adapter_context.should have_received(:publish).with(destination, body, headers, properties)
+            expect(destination).to have_received(:publish).with(body, headers, properties)
           end
 
           context "when the destination can't be found" do
             let(:bad_dest_name) { :not_a_queue }
             it 'raises a MessageDriver:NoSuchDestinationError' do
-              expect {
+              expect do
                 subject.publish(bad_dest_name, body, headers, properties)
-              }.to raise_error(MessageDriver::NoSuchDestinationError, /#{bad_dest_name}/)
-              adapter_context.should_not have_received(:publish)
+              end.to raise_error(MessageDriver::NoSuchDestinationError, /#{bad_dest_name}/)
+              expect(destination).not_to have_received(:publish)
             end
           end
         end
@@ -108,34 +108,34 @@ module MessageDriver
         describe '#pop_message' do
           let(:expected) { double(MessageDriver::Message) }
           let(:destination) { broker.destination(:my_queue, 'my_queue', exclusive: true) }
-          let(:options) { {foo: :bar} }
+          let(:options) { { foo: :bar } }
           before do
-            adapter_context.stub(:pop_message)
+            allow(destination).to receive(:pop_message)
           end
 
           it 'delegates to the adapter_context' do
             subject.pop_message(destination, options)
-            adapter_context.should have_received(:pop_message).with(destination, options)
+            expect(destination).to have_received(:pop_message).with(options)
           end
 
           it 'looks up the destination if necessary' do
             destination
             subject.pop_message(:my_queue, options)
-            adapter_context.should have_received(:pop_message).with(destination, options)
+            expect(destination).to have_received(:pop_message).with(options)
           end
 
           context "when the destination can't be found" do
             let(:bad_dest_name) { :not_a_queue }
             it 'raises a MessageDriver:NoSuchDestinationError' do
-              expect {
+              expect do
                 subject.pop_message(bad_dest_name, options)
-              }.to raise_error(MessageDriver::NoSuchDestinationError, /#{bad_dest_name}/)
-              adapter_context.should_not have_received(:pop_message)
+              end.to raise_error(MessageDriver::NoSuchDestinationError, /#{bad_dest_name}/)
+              expect(destination).not_to have_received(:pop_message)
             end
           end
 
-          it 'requires the destination and returns the message' do
-            adapter_context.should_receive(:pop_message).with(destination, {}).and_return(expected)
+          it 'requires just the destination and returns the message' do
+            expect(destination).to receive(:pop_message).with({}).and_return(expected)
 
             actual = subject.pop_message(destination)
 
@@ -143,7 +143,7 @@ module MessageDriver
           end
 
           it 'passes the options through and returns the message' do
-            adapter_context.should_receive(:pop_message).with(destination, options).and_return(expected)
+            expect(destination).to receive(:pop_message).with(options).and_return(expected)
 
             actual = subject.pop_message(destination, options)
 
@@ -153,44 +153,44 @@ module MessageDriver
 
         describe '#with_message_transaction' do
           before do
-            adapter_context.stub(:begin_transaction)
-            adapter_context.stub(:commit_transaction)
-            adapter_context.stub(:rollback_transaction)
+            allow(adapter_context).to receive(:begin_transaction)
+            allow(adapter_context).to receive(:commit_transaction)
+            allow(adapter_context).to receive(:rollback_transaction)
           end
 
           context 'when the adapter supports transactions' do
             before do
-              adapter_context.stub(:supports_transactions?) { true }
+              allow(adapter_context).to receive(:supports_transactions?) { true }
             end
             it 'delegates to the adapter context' do
-              expect { |blk|
+              expect do |blk|
                 subject.with_message_transaction(&blk)
-              }.to yield_control
-              adapter_context.should have_received(:begin_transaction)
-              adapter_context.should have_received(:commit_transaction)
+              end.to yield_control
+              expect(adapter_context).to have_received(:begin_transaction)
+              expect(adapter_context).to have_received(:commit_transaction)
             end
 
             context 'when the block raises an error' do
               it 'calls rollback instead of commit and raises the error' do
-                expect {
+                expect do
                   subject.with_message_transaction do
-                    raise 'having a tough time'
+                    fail 'having a tough time'
                   end
-                }.to raise_error 'having a tough time'
-                adapter_context.should have_received(:begin_transaction)
-                adapter_context.should_not have_received(:commit_transaction)
-                adapter_context.should have_received(:rollback_transaction)
+                end.to raise_error 'having a tough time'
+                expect(adapter_context).to have_received(:begin_transaction)
+                expect(adapter_context).not_to have_received(:commit_transaction)
+                expect(adapter_context).to have_received(:rollback_transaction)
               end
 
               context 'and the the rollback raises an error' do
                 it 'logs the error from the rollback and raises the original error' do
                   allow(logger).to receive(:error)
-                  adapter_context.stub(:rollback_transaction).and_raise('rollback failed!')
-                  expect {
+                  allow(adapter_context).to receive(:rollback_transaction).and_raise('rollback failed!')
+                  expect do
                     subject.with_message_transaction do
-                      raise 'having a tough time'
+                      fail 'having a tough time'
                     end
-                  }.to raise_error 'having a tough time'
+                  end.to raise_error 'having a tough time'
                   expect(logger).to have_received(:error).with(match('rollback failed!'))
                 end
               end
@@ -198,27 +198,27 @@ module MessageDriver
 
             context 'when the transactions are nested' do
               it 'only starts and commits once' do
-                expect { |blk|
+                expect do |blk|
                   subject.with_message_transaction do
                     subject.with_message_transaction(&blk)
                   end
-                }.to yield_control
-                adapter_context.should have_received(:begin_transaction).once
-                adapter_context.should have_received(:commit_transaction).once
+                end.to yield_control
+                expect(adapter_context).to have_received(:begin_transaction).once
+                expect(adapter_context).to have_received(:commit_transaction).once
               end
 
               context 'when the block raises an error' do
                 it 'calls rollback instead of commit and raises the error' do
-                  expect {
+                  expect do
                     subject.with_message_transaction do
                       subject.with_message_transaction do
-                        raise 'having a tough time'
+                        fail 'having a tough time'
                       end
                     end
-                  }.to raise_error 'having a tough time'
-                  adapter_context.should have_received(:begin_transaction).once
-                  adapter_context.should_not have_received(:commit_transaction)
-                  adapter_context.should have_received(:rollback_transaction).once
+                  end.to raise_error 'having a tough time'
+                  expect(adapter_context).to have_received(:begin_transaction).once
+                  expect(adapter_context).not_to have_received(:commit_transaction)
+                  expect(adapter_context).to have_received(:rollback_transaction).once
                 end
               end
             end
@@ -226,21 +226,21 @@ module MessageDriver
 
           context "when the adapter doesn't support transactions" do
             before do
-              adapter_context.stub(:supports_transactions?) { false }
+              allow(adapter_context).to receive(:supports_transactions?) { false }
             end
             it "run the block on it's own" do
-              expect { |blk|
+              expect do |blk|
                 subject.with_message_transaction(&blk)
-              }.to yield_control
-              adapter_context.should_not have_received(:begin_transaction)
-              adapter_context.should_not have_received(:commit_transaction)
-              adapter_context.should_not have_received(:rollback_transaction)
+              end.to yield_control
+              expect(adapter_context).not_to have_received(:begin_transaction)
+              expect(adapter_context).not_to have_received(:commit_transaction)
+              expect(adapter_context).not_to have_received(:rollback_transaction)
             end
             it 'logs a warning' do
               allow(logger).to receive(:debug)
-              expect { |blk|
+              expect do |blk|
                 subject.with_message_transaction(&blk)
-              }.to yield_control
+              end.to yield_control
               expect(logger).to have_received(:debug).with('this adapter does not support transactions')
             end
           end
@@ -248,7 +248,7 @@ module MessageDriver
 
         describe '#ack_message' do
           let(:message) { double('message') }
-          let(:options) { {foo: :bar} }
+          let(:options) { { foo: :bar } }
           before do
             allow(message).to receive(:ack)
           end
@@ -264,7 +264,7 @@ module MessageDriver
 
         describe '#nack_message' do
           let(:message) { double('message') }
-          let(:options) { {foo: :bar} }
+          let(:options) { { foo: :bar } }
           before do
             allow(message).to receive(:nack)
           end
@@ -280,30 +280,30 @@ module MessageDriver
 
         describe '#subscribe' do
           let(:destination) { broker.destination(:my_queue, 'my_queue', exclusive: true) }
-          let(:consumer_double) { lambda do |_| end }
+          let(:consumer_double) { ->(_) {} }
 
           before do
-            adapter_context.stub(:subscribe)
+            allow(adapter_context).to receive(:subscribe)
             broker.consumer(:my_consumer, &consumer_double)
           end
 
           it 'delegates to the adapter_context' do
-            adapter_context.should_receive(:subscribe).with(destination, {}) do |&blk|
+            expect(adapter_context).to receive(:subscribe).with(destination, {}) do |&blk|
               expect(blk).to be(consumer_double)
             end
             subject.subscribe(destination, :my_consumer)
           end
 
           it 'passes the options through' do
-            options = {foo: :bar}
-            adapter_context.should_receive(:subscribe).with(destination, options) do |&blk|
+            options = { foo: :bar }
+            expect(adapter_context).to receive(:subscribe).with(destination, options) do |&blk|
               expect(blk).to be(consumer_double)
             end
             subject.subscribe(destination, :my_consumer, options)
           end
 
           it 'looks up the destination' do
-            adapter_context.should_receive(:subscribe).with(destination, {}) do |&blk|
+            expect(adapter_context).to receive(:subscribe).with(destination, {}) do |&blk|
               expect(blk).to be(consumer_double)
             end
             subject.subscribe(:my_queue, :my_consumer)
@@ -312,49 +312,49 @@ module MessageDriver
           context "when the destination can't be found" do
             let(:bad_dest_name) { :not_a_queue }
             it 'raises a MessageDriver:NoSuchDestinationError' do
-              expect {
+              expect do
                 subject.subscribe(bad_dest_name, :my_consumer)
-              }.to raise_error(MessageDriver::NoSuchDestinationError, /#{bad_dest_name}/)
-              adapter_context.should_not have_received(:subscribe)
+              end.to raise_error(MessageDriver::NoSuchDestinationError, /#{bad_dest_name}/)
+              expect(adapter_context).not_to have_received(:subscribe)
             end
           end
 
           context "when the consumer can't be found" do
             let(:bad_consumer_name) { :not_a_consumer }
             it 'raises a MessageDriver:NoSuchConsumerError' do
-              expect {
+              expect do
                 subject.subscribe(destination, bad_consumer_name)
-              }.to raise_error(MessageDriver::NoSuchConsumerError, /#{bad_consumer_name}/)
-              adapter_context.should_not have_received(:subscribe)
+              end.to raise_error(MessageDriver::NoSuchConsumerError, /#{bad_consumer_name}/)
+              expect(adapter_context).not_to have_received(:subscribe)
             end
           end
         end
 
         describe '#subscribe_with' do
           let(:destination) { broker.destination(:my_queue, 'my_queue', exclusive: true) }
-          let(:consumer_double) { lambda do |_| end }
+          let(:consumer_double) { ->(_) {} }
 
           before do
-            adapter_context.stub(:subscribe)
+            allow(adapter_context).to receive(:subscribe)
           end
 
           it 'delegates to the adapter_context' do
-            adapter_context.should_receive(:subscribe).with(destination, {}) do |&blk|
+            expect(adapter_context).to receive(:subscribe).with(destination, {}) do |&blk|
               expect(blk).to be(consumer_double)
             end
             subject.subscribe_with(destination, &consumer_double)
           end
 
           it 'passes the options through' do
-            options = {foo: :bar}
-            adapter_context.should_receive(:subscribe).with(destination, options) do |&blk|
+            options = { foo: :bar }
+            expect(adapter_context).to receive(:subscribe).with(destination, options) do |&blk|
               expect(blk).to be(consumer_double)
             end
             subject.subscribe_with(destination, options, &consumer_double)
           end
 
           it 'looks up the destination' do
-            adapter_context.should_receive(:subscribe).with(destination, {}) do |&blk|
+            expect(adapter_context).to receive(:subscribe).with(destination, {}) do |&blk|
               expect(blk).to be(consumer_double)
             end
             subject.subscribe_with(:my_queue, &consumer_double)
@@ -363,10 +363,10 @@ module MessageDriver
           context "when the destination can't be found" do
             let(:bad_dest_name) { :not_a_queue }
             it 'raises a MessageDriver:NoSuchDestinationError' do
-              expect {
+              expect do
                 subject.subscribe_with(bad_dest_name, &consumer_double)
-              }.to raise_error(MessageDriver::NoSuchDestinationError, /#{bad_dest_name}/)
-              adapter_context.should_not have_received(:subscribe)
+              end.to raise_error(MessageDriver::NoSuchDestinationError, /#{bad_dest_name}/)
+              expect(adapter_context).not_to have_received(:subscribe)
             end
           end
         end