broker_spec.rb in message-driver-0.4.0

- old
+ new

@@ -4,12 +4,12 @@
 module MessageDriver
   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
+    describe '.configure and .broker' do
+      it 'calls new, passing in the options and saves the instance' do
         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)
 
         described_class.configure(options)
@@ -20,19 +20,19 @@
 
       it "doesn't allow you to configure the same broker twice" do
         described_class.configure(broker_name, options)
         expect {
           described_class.configure(broker_name, options)
-        }.to raise_error MessageDriver::BrokerAlreadyConfigured, match("default")
+        }.to raise_error MessageDriver::BrokerAlreadyConfigured, match('default')
       end
 
-      context "when configurating multiple brokers" do
-        it "allows you to fetch each configured broker through .broker" do
+      context 'when configurating multiple brokers' do
+        it 'allows you to fetch each configured broker through .broker' do
           options1 = {foo: :bar}
           options2 = {bar: :baz}
-          result1 = double("result1").as_null_object
-          result2 = double("result2").as_null_object
+          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)
 
           described_class.configure(:result1, options1)
           described_class.configure(:result2, options2)
@@ -41,20 +41,20 @@
           expect(described_class.broker(:result2)).to be(result2)
         end
       end
 
       context "when you try to access a broker that isn't configured" do
-        it "should raise an error" do
+        it 'should raise an error' do
           expect {
             described_class.broker(:not_an_adapter)
           }.to raise_error BrokerNotConfigured
         end
       end
     end
 
-    describe ".reset" do
-      it "stops and removes all the brokers" do
+    describe '.reset' do
+      it 'stops and removes 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_call_original
         allow(broker2).to receive(:stop).and_call_original
@@ -71,16 +71,16 @@
         expect {
           described_class.broker(:broker2)
         }.to raise_error BrokerNotConfigured
       end
 
-      context "when one of the brokers raises and error" do
-        it "still stops all the brokers" do
+      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(broker1).to receive(:stop).and_raise 'error stopping broker1!'
           allow(broker2).to receive(:stop).and_call_original
 
           expect {
             described_class.reset
           }.not_to raise_error
@@ -97,54 +97,54 @@
           }.to raise_error BrokerNotConfigured
         end
       end
     end
 
-    describe ".client" do
+    describe '.client' do
       let(:broker_name) { described_class::DEFAULT_BROKER_NAME }
-      it "returns a module that extends MessageDriver::Client for the specified broker" do
+      it 'returns a module that extends MessageDriver::Client for the specified broker' do
         expect(described_class.client(broker_name)).to be_kind_of MessageDriver::Client
         expect(described_class.client(broker_name).broker_name).to eq(broker_name)
       end
 
-      it "caches the modules" do
+      it 'caches the modules' do
         first = described_class.client(broker_name)
         second = described_class.client(broker_name)
         expect(second).to be first
       end
 
-      context "when the broker has a non-default name" do
+      context 'when the broker has a non-default name' do
         let(:broker_name) { :my_cool_broker }
         it "returns a module that extends MessageDriver::Client that knows it's broker" do
           expect(described_class.client(broker_name)).to be_kind_of MessageDriver::Client
           expect(described_class.client(broker_name).broker_name).to eq(broker_name)
         end
       end
     end
 
-    describe "#initialize" do
+    describe '#initialize' do
       it "raises an error if you don't specify an adapter" do
         expect {
           described_class.new({})
         }.to raise_error(/must specify an adapter/)
       end
 
-      it "if you provide an adapter instance, it uses that one" do
+      it 'if you provide an adapter instance, it uses that one' do
         adapter = Adapters::InMemoryAdapter.new({})
 
         instance = described_class.new(adapter: adapter)
         expect(instance.adapter).to be adapter
       end
 
-      it "if you provide an adapter class, it will instansiate it" do
+      it 'if you provide an adapter class, it will instansiate it' do
         adapter = Adapters::InMemoryAdapter
 
         instance = described_class.new(adapter: adapter)
         expect(instance.adapter).to be_a adapter
       end
 
-      it "if you provide a symbol, it will try to look up the adapter class" do
+      it 'if you provide a symbol, it will try to look up the adapter class' do
         adapter = :in_memory
 
         instance = described_class.new(adapter: adapter)
         expect(instance.adapter).to be_a Adapters::InMemoryAdapter
       end
@@ -155,18 +155,18 @@
         expect {
           described_class.new(adapter: adapter)
         }.to raise_error(/adapter must be a MessageDriver::Adapters::Base/)
       end
 
-      it "starts off with the adapter not stopped" do
+      it 'starts off with the adapter not stopped' do
         adapter = :in_memory
 
         instance = described_class.new(adapter: adapter)
         expect(instance).not_to be_stopped
       end
 
-      it "has a default name of :default" do
+      it 'has a default name of :default' do
         adapter = :in_memory
 
         instance = described_class.new(adapter: adapter)
         expect(instance.name).to eq(:default)
       end
@@ -178,155 +178,154 @@
         instance = described_class.new(name, adapter: adapter)
         expect(instance.name).to eq(name)
       end
     end
 
-
     context do
       subject!(:broker) { described_class.configure(broker_name, options) }
 
-      describe "#stop" do
+      describe '#stop' do
         let(:adapter) { broker.adapter }
-        it "calls stop on the adapter" do
+        it 'calls stop on the adapter' do
           allow(adapter).to receive(:stop).and_call_original
 
           subject.stop
 
           expect(adapter).to have_received(:stop)
         end
 
-        it "marks the broker as stopped" do
+        it 'marks the broker as stopped' do
           expect {
             subject.stop
           }.to change { subject.stopped? }.from(false).to(true)
         end
 
-        it "invalidates the contexts" do
-          my_ctx = double("context", invalidate: nil)
+        it 'invalidates the contexts' do
+          my_ctx = double('context', invalidate: nil)
           adapter.contexts << my_ctx
           subject.stop
           expect(adapter.contexts).to be_empty
           expect(my_ctx).to have_received(:invalidate)
         end
       end
 
-      describe "#restart" do
+      describe '#restart' do
         let!(:original_adapter) { subject.adapter }
         before do
           allow(original_adapter).to receive(:stop).and_call_original
         end
 
-        it "reconfigures the adapter" do
+        it 'reconfigures the adapter' do
           expect {
             subject.restart
           }.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
+        it 'does not stop the adapter again if it has already been stopped' do
           expect(subject.adapter).to be original_adapter
           subject.stop
           expect {
             subject.restart
           }.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
+      describe '#configuration' do
+        it 'returns the configuration hash you passed to .configure' do
           config = {adapter: :in_memory, foo: :bar, baz: :boz}
           instance = described_class.new(config)
           expect(instance.configuration).to be config
         end
       end
 
-      describe "#destination" do
-        it "returns the destination" do
-          destination = broker.destination(:my_queue, "my_queue", exclusive: true)
+      describe '#destination' do
+        it 'returns the destination' do
+          destination = broker.destination(:my_queue, 'my_queue', exclusive: true)
           expect(destination).to be_a MessageDriver::Destination::Base
         end
       end
 
-      describe "#find_destination" do
-        it "finds the previously defined destination" do
-          my_destination = broker.destination(:my_queue, "my_queue", exclusive: true)
+      describe '#find_destination' do
+        it 'finds the previously defined destination' do
+          my_destination = broker.destination(:my_queue, 'my_queue', exclusive: true)
           expect(broker.find_destination(:my_queue)).to be(my_destination)
         end
 
         context "when the destination can't be found" do
           let(:bad_dest_name) { :not_a_queue }
-          it "raises a MessageDriver:NoSuchDestinationError" do
+          it 'raises a MessageDriver:NoSuchDestinationError' do
             expect {
               broker.find_destination(bad_dest_name)
             }.to raise_error(MessageDriver::NoSuchDestinationError, /#{bad_dest_name}/)
           end
         end
       end
 
-      describe "#consumer" do
-        let(:consumer_double) { lambda do |m| end }
-        it "saves the provided consumer" do
+      describe '#consumer' do
+        let(:consumer_double) { lambda do |_| end }
+        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
+        context 'when no consumer is provided' do
+          it 'raises an error' do
             expect {
               broker.consumer(:my_consumer)
-            }.to raise_error(MessageDriver::Error, "you must provide a block")
+            }.to raise_error(MessageDriver::Error, 'you must provide a block')
           end
         end
       end
 
-      describe "#find_consumer" do
-        let(:consumer_double) { lambda do |m| end }
-        it "finds the previously defined consumer" do
+      describe '#find_consumer' do
+        let(:consumer_double) { lambda do |_| end }
+        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
+          it 'raises a MessageDriver:NoSuchConsumerError' do
             expect {
               broker.find_consumer(bad_consumer_name)
             }.to raise_error(MessageDriver::NoSuchConsumerError, /#{bad_consumer_name}/)
           end
         end
       end
 
-      describe "#dynamic_destination" do
-        it "returns the destination" do
-          destination = broker.dynamic_destination("my_queue", exclusive: true)
+      describe '#dynamic_destination' do
+        it 'returns the destination' do
+          destination = broker.dynamic_destination('my_queue', exclusive: true)
           expect(destination).to be_a MessageDriver::Destination::Base
         end
       end
 
-      describe "#client" do
+      describe '#client' do
         let(:broker_name) { described_class::DEFAULT_BROKER_NAME }
         it "returns a module that extends MessageDriver::Client that knows it's broker" do
           expect(broker.client).to be_kind_of MessageDriver::Client
           expect(broker.client.broker_name).to eq(broker_name)
           expect(broker.client.broker).to be(broker)
         end
 
-        it "caches the modules" do
+        it 'caches the modules' do
           first = broker.client
           second = broker.client
           expect(second).to be first
         end
 
-        it "returns the same module as .client" do
+        it 'returns the same module as .client' do
           expect(broker.client).to be described_class.client(broker.name)
         end
 
-        context "when the broker has a non-default name" do
+        context 'when the broker has a non-default name' do
           let(:broker_name) { :my_cool_broker }
           it "returns a module that extends MessageDriver::Client that knows it's broker" do
             expect(broker.name).to eq(broker_name)
             expect(broker.client).to be_kind_of MessageDriver::Client
             expect(broker.client.broker_name).to eq(broker_name)