broker_spec.rb in message-driver-0.5.0

- old
+ new

@@ -1,36 +1,36 @@
 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)
 
         expect(described_class.broker).to be result
         expect(described_class.broker(described_class::DEFAULT_BROKER_NAME)).to be result
       end
 
       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)
           allow(described_class).to receive(:new).with(:result2, options2).and_return(result2)
 
@@ -42,13 +42,13 @@
         end
       end
 
       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
 
     describe '.reset' do
@@ -62,41 +62,41 @@
         described_class.reset
 
         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
         it 'still stops all the brokers' do
           broker1 = described_class.configure(:broker1, adapter: :in_memory)
           broker2 = described_class.configure(:broker2, adapter: :in_memory)
 
           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
 
     describe '.client' do
@@ -121,13 +121,13 @@
       end
     end
 
     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
         adapter = Adapters::InMemoryAdapter.new({})
 
@@ -150,13 +150,13 @@
       end
 
       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
         adapter = :in_memory
 
@@ -192,13 +192,13 @@
 
           expect(adapter).to have_received(:stop)
         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
           my_ctx = double('context', invalidate: nil)
           adapter.contexts << my_ctx
@@ -213,33 +213,33 @@
         before do
           allow(original_adapter).to receive(:stop).and_call_original
         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
           subject.restart
           expect(original_adapter).to have_received(:stop).once
         end
 
         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
       end
 
@@ -257,45 +257,45 @@
         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
               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)
         end
 
         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)
         end
 
         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
 
       describe '#dynamic_destination' do