message-driver 0.3.0 → 0.4.0

data/spec/support/shared/transaction_examples.rb

@@ -1,14 +1,14 @@
-shared_examples "transactions are not supported" do
-  describe "#supports_transactions?" do
-    it "returns false" do
+shared_examples 'transactions are not supported' do
+  describe '#supports_transactions?' do
+    it 'returns false' do
       expect(subject.supports_transactions?).to eq(false)
     end
   end
 end
 
-shared_examples "transactions are supported" do
-  describe "#supports_transactions?" do
-    it "returns true" do
+shared_examples 'transactions are supported' do
+  describe '#supports_transactions?' do
+    it 'returns true' do
       expect(subject.supports_transactions?).to eq(true)
     end
   end
@@ -18,24 +18,24 @@ shared_examples "transactions are supported" do
   it { should respond_to :rollback_transaction }
   it { should respond_to :in_transaction? }
 
-  describe "#in_transaction?" do
+  describe '#in_transaction?' do
     it "returns false if you aren't in a transaction" do
       expect(subject.in_transaction?).to eq(false)
     end
   end
 
-  it "raises a MessageDriver::TransactionError error if you begin two transactions" do
+  it 'raises a MessageDriver::TransactionError error if you begin two transactions' do
     subject.begin_transaction
     expect {
       subject.begin_transaction
     }.to raise_error MessageDriver::TransactionError
   end
-  it "raises a MessageDriver::TransactionError error if you commit outside of a transaction" do
+  it 'raises a MessageDriver::TransactionError error if you commit outside of a transaction' do
     expect {
       subject.commit_transaction
     }.to raise_error MessageDriver::TransactionError
   end
-  it "raises a MessageDriver::TransactionError error if you rollback outside of a transaction" do
+  it 'raises a MessageDriver::TransactionError error if you rollback outside of a transaction' do
     expect {
       subject.rollback_transaction
     }.to raise_error MessageDriver::TransactionError

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

@@ -3,16 +3,16 @@ require 'spec_helper'
 module MessageDriver::Adapters
   describe Base do
     class TestAdapter < Base
-      def initialize(configuration)
+      def initialize(_configuration)
       end
     end
     subject(:adapter) { TestAdapter.new({}) }
 
-    describe "#new_context" do
-      it "raises an error" do
+    describe '#new_context' do
+      it 'raises an error' do
         expect {
           subject.new_context
-        }.to raise_error "Must be implemented in subclass"
+        }.to raise_error 'Must be implemented in subclass'
       end
     end
 
@@ -21,32 +21,32 @@ module MessageDriver::Adapters
       end
       subject(:adapter_context) { TestContext.new(adapter) }
 
-      it_behaves_like "an adapter context"
-      it_behaves_like "transactions are not supported"
-      it_behaves_like "client acks are not supported"
-      it_behaves_like "subscriptions are not supported"
+      it_behaves_like 'an adapter context'
+      it_behaves_like 'transactions are not supported'
+      it_behaves_like 'client acks are not supported'
+      it_behaves_like 'subscriptions are not supported'
 
-      describe "#create_destination" do
-        it "raises an error" do
+      describe '#create_destination' do
+        it 'raises an error' do
           expect {
-            subject.create_destination("foo")
-          }.to raise_error "Must be implemented in subclass"
+            subject.create_destination('foo')
+          }.to raise_error 'Must be implemented in subclass'
         end
       end
 
-      describe "#publish" do
-        it "raises an error" do
+      describe '#publish' do
+        it 'raises an error' do
           expect {
-            subject.publish(:destination, {foo: "bar"})
-          }.to raise_error "Must be implemented in subclass"
+            subject.publish(:destination, foo: 'bar')
+          }.to raise_error 'Must be implemented in subclass'
         end
       end
 
-      describe "#pop_message" do
-        it "raises an error" do
+      describe '#pop_message' do
+        it 'raises an error' do
           expect {
             subject.pop_message(:destination)
-          }.to raise_error "Must be implemented in subclass"
+          }.to raise_error 'Must be implemented in subclass'
         end
       end
 

data/spec/units/message_driver/broker_spec.rb

@@ -6,8 +6,8 @@ module MessageDriver
     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)
@@ -22,15 +22,15 @@ module MessageDriver
         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)
 
@@ -43,7 +43,7 @@ module MessageDriver
       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
@@ -51,8 +51,8 @@ module MessageDriver
       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)
 
@@ -73,12 +73,12 @@ module MessageDriver
         }.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 {
@@ -99,20 +99,20 @@ module MessageDriver
       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
@@ -121,28 +121,28 @@ module MessageDriver
       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)
@@ -157,14 +157,14 @@ module MessageDriver
         }.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)
@@ -180,13 +180,12 @@ module MessageDriver
       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
@@ -194,14 +193,14 @@ module MessageDriver
           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
@@ -209,13 +208,13 @@ module MessageDriver
         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 }
@@ -226,7 +225,7 @@ module MessageDriver
           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 {
@@ -236,30 +235,30 @@ module MessageDriver
         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}/)
@@ -267,32 +266,32 @@ module MessageDriver
         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}/)
@@ -300,14 +299,14 @@ module MessageDriver
         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
@@ -315,17 +314,17 @@ module MessageDriver
           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)

data/spec/units/message_driver/client_spec.rb

@@ -14,54 +14,54 @@ module MessageDriver
     let(:adapter) { broker.adapter }
     let(:adapter_context) { adapter.new_context }
 
-    shared_examples "a Client" do
-      describe "#broker" do
-        it "returns the broker_name" do
+    shared_examples 'a Client' do
+      describe '#broker' do
+        it 'returns the broker_name' do
           expect(subject.broker_name).to eq(broker_name)
         end
       end
 
-      describe "#current_adapter_context" do
+      describe '#current_adapter_context' do
         before { subject.clear_context }
 
-        it "returns an adapter_context" do
+        it 'returns an adapter_context' do
           expect(subject.current_adapter_context).to be_a Adapters::ContextBase
         end
 
-        it "returns the same adapter context on the second call" do
+        it 'returns the same adapter context on the second call' do
           ctx = subject.current_adapter_context
           expect(subject.current_adapter_context).to be ctx
         end
 
-        context "when called with false" do
+        context 'when called with false' do
           it "doesn't initialize the adapter context if there isn't one" do
             expect(subject.current_adapter_context(false)).to be_nil
           end
         end
       end
 
-      context "with a given adapter_context" do
+      context 'with a given adapter_context' do
         around(:each) do |example|
           subject.with_adapter_context(adapter_context, &example)
         end
 
-        describe "#dynamic_destination" do
-          let(:dest_name) { "my_new_queue" }
+        describe '#dynamic_destination' do
+          let(:dest_name) { 'my_new_queue' }
           let(:dest_options) { {type: 2} }
-          let(:message_props) { {expires: "soon"} }
-          let(:created_dest) { double("created destination") }
+          let(:message_props) { {expires: 'soon'} }
+          let(:created_dest) { double('created destination') }
           before do
             adapter_context.stub(:create_destination) { created_dest }
           end
 
-          it "delegates to the adapter_context" do
+          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)
           end
 
-          it "only requires destination name" do
+          it 'only requires destination name' do
             result = subject.dynamic_destination(dest_name)
             expect(result).to be(created_dest)
 
@@ -69,26 +69,26 @@ module MessageDriver
           end
         end
 
-        describe "#publish" do
-          let(:destination) { broker.destination(:my_queue, "my_queue", exclusive: true) }
-          let(:body) { "my message" }
+        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} }
           before do
             adapter_context.stub(:publish)
           end
 
-          it "delegates to the adapter_context" do
+          it 'delegates to the adapter_context' do
             subject.publish(destination, body, headers, properties)
             adapter_context.should have_received(:publish).with(destination, body, headers, properties)
           end
 
-          it "only requires destination and body" do
+          it 'only requires destination and body' do
             subject.publish(destination, body)
             adapter_context.should have_received(:publish).with(destination, body, {}, {})
           end
 
-          it "looks up the destination if necessary" do
+          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)
@@ -96,7 +96,7 @@ module MessageDriver
 
           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 {
                 subject.publish(bad_dest_name, body, headers, properties)
               }.to raise_error(MessageDriver::NoSuchDestinationError, /#{bad_dest_name}/)
@@ -105,20 +105,20 @@ module MessageDriver
           end
         end
 
-        describe "#pop_message" do
+        describe '#pop_message' do
           let(:expected) { double(MessageDriver::Message) }
-          let(:destination) { broker.destination(:my_queue, "my_queue", exclusive: true) }
+          let(:destination) { broker.destination(:my_queue, 'my_queue', exclusive: true) }
           let(:options) { {foo: :bar} }
           before do
             adapter_context.stub(:pop_message)
           end
 
-          it "delegates to the adapter_context" do
+          it 'delegates to the adapter_context' do
             subject.pop_message(destination, options)
             adapter_context.should have_received(:pop_message).with(destination, options)
           end
 
-          it "looks up the destination if necessary" do
+          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)
@@ -126,7 +126,7 @@ module MessageDriver
 
           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 {
                 subject.pop_message(bad_dest_name, options)
               }.to raise_error(MessageDriver::NoSuchDestinationError, /#{bad_dest_name}/)
@@ -134,7 +134,7 @@ module MessageDriver
             end
           end
 
-          it "requires the destination and returns the message" do
+          it 'requires the destination and returns the message' do
             adapter_context.should_receive(:pop_message).with(destination, {}).and_return(expected)
 
             actual = subject.pop_message(destination)
@@ -142,7 +142,7 @@ module MessageDriver
             expect(actual).to be expected
           end
 
-          it "passes the options through and returns the message" do
+          it 'passes the options through and returns the message' do
             adapter_context.should_receive(:pop_message).with(destination, options).and_return(expected)
 
             actual = subject.pop_message(destination, options)
@@ -151,18 +151,18 @@ module MessageDriver
           end
         end
 
-        describe "#with_message_transaction" do
+        describe '#with_message_transaction' do
           before do
             adapter_context.stub(:begin_transaction)
             adapter_context.stub(:commit_transaction)
             adapter_context.stub(:rollback_transaction)
           end
 
-          context "when the adapter supports transactions" do
+          context 'when the adapter supports transactions' do
             before do
               adapter_context.stub(:supports_transactions?) { true }
             end
-            it "delegates to the adapter context" do
+            it 'delegates to the adapter context' do
               expect { |blk|
                 subject.with_message_transaction(&blk)
               }.to yield_control
@@ -170,34 +170,34 @@ module MessageDriver
               adapter_context.should have_received(:commit_transaction)
             end
 
-            context "when the block raises an error" do
-              it "calls rollback instead of commit and raises the error" do
+            context 'when the block raises an error' do
+              it 'calls rollback instead of commit and raises the error' do
                 expect {
                   subject.with_message_transaction do
-                    raise "having a tough time"
+                    raise 'having a tough time'
                   end
-                }.to raise_error "having a tough time"
+                }.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
 
-              context "and the the rollback raises an error" do
-                it "logs the error from the rollback and raises the original error" do
+              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!")
+                  adapter_context.stub(:rollback_transaction).and_raise('rollback failed!')
                   expect {
                     subject.with_message_transaction do
-                      raise "having a tough time"
+                      raise 'having a tough time'
                     end
-                  }.to raise_error "having a tough time"
-                  expect(logger).to have_received(:error).with(match("rollback failed!"))
+                  }.to raise_error 'having a tough time'
+                  expect(logger).to have_received(:error).with(match('rollback failed!'))
                 end
               end
             end
 
-            context "when the transactions are nested" do
-              it "only starts and commits once" do
+            context 'when the transactions are nested' do
+              it 'only starts and commits once' do
                 expect { |blk|
                   subject.with_message_transaction do
                     subject.with_message_transaction(&blk)
@@ -207,15 +207,15 @@ module MessageDriver
                 adapter_context.should 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
+              context 'when the block raises an error' do
+                it 'calls rollback instead of commit and raises the error' do
                   expect {
                     subject.with_message_transaction do
                       subject.with_message_transaction do
-                        raise "having a tough time"
+                        raise 'having a tough time'
                       end
                     end
-                  }.to raise_error "having a tough time"
+                  }.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
@@ -236,65 +236,65 @@ module MessageDriver
               adapter_context.should_not have_received(:commit_transaction)
               adapter_context.should_not have_received(:rollback_transaction)
             end
-            it "logs a warning" do
+            it 'logs a warning' do
               allow(logger).to receive(:debug)
               expect { |blk|
                 subject.with_message_transaction(&blk)
               }.to yield_control
-              expect(logger).to have_received(:debug).with("this adapter does not support transactions")
+              expect(logger).to have_received(:debug).with('this adapter does not support transactions')
             end
           end
         end
 
-        describe "#ack_message" do
-          let(:message) { double("message") }
+        describe '#ack_message' do
+          let(:message) { double('message') }
           let(:options) { {foo: :bar} }
           before do
             allow(message).to receive(:ack)
           end
-          it "calls #ack on the message" do
+          it 'calls #ack on the message' do
             subject.ack_message(message)
             expect(message).to have_received(:ack).with({})
           end
-          it "calls #ack on the message and passes the supplied options" do
+          it 'calls #ack on the message and passes the supplied options' do
             subject.ack_message(message, options)
             expect(message).to have_received(:ack).with(options)
           end
         end
 
-        describe "#nack_message" do
-          let(:message) { double("message") }
+        describe '#nack_message' do
+          let(:message) { double('message') }
           let(:options) { {foo: :bar} }
           before do
             allow(message).to receive(:nack)
           end
-          it "calls #nack on the message" do
+          it 'calls #nack on the message' do
             subject.nack_message(message)
             expect(message).to have_received(:nack).with({})
           end
-          it "calls #nack on the message and passes the supplied options" do
+          it 'calls #nack on the message and passes the supplied options' do
             subject.nack_message(message, options)
             expect(message).to have_received(:nack).with(options)
           end
         end
 
-        describe "#subscribe" do
-          let(:destination) { broker.destination(:my_queue, "my_queue", exclusive: true) }
-          let(:consumer_double) { lambda do |m| end }
+        describe '#subscribe' do
+          let(:destination) { broker.destination(:my_queue, 'my_queue', exclusive: true) }
+          let(:consumer_double) { lambda do |_| end }
 
           before do
             adapter_context.stub(:subscribe)
             broker.consumer(:my_consumer, &consumer_double)
           end
 
-          it "delegates to the adapter_context" do
+          it 'delegates to the adapter_context' do
             adapter_context.should_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
+          it 'passes the options through' do
             options = {foo: :bar}
             adapter_context.should_receive(:subscribe).with(destination, options) do |&blk|
               expect(blk).to be(consumer_double)
@@ -302,7 +302,7 @@ module MessageDriver
             subject.subscribe(destination, :my_consumer, options)
           end
 
-          it "looks up the destination" do
+          it 'looks up the destination' do
             adapter_context.should_receive(:subscribe).with(destination, {}) do |&blk|
               expect(blk).to be(consumer_double)
             end
@@ -311,7 +311,7 @@ module MessageDriver
 
           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 {
                 subject.subscribe(bad_dest_name, :my_consumer)
               }.to raise_error(MessageDriver::NoSuchDestinationError, /#{bad_dest_name}/)
@@ -321,7 +321,7 @@ module MessageDriver
 
           context "when the consumer can't be found" do
             let(:bad_consumer_name) { :not_a_consumer }
-            it "raises a MessageDriver:NoSuchConsumerError" do
+            it 'raises a MessageDriver:NoSuchConsumerError' do
               expect {
                 subject.subscribe(destination, bad_consumer_name)
               }.to raise_error(MessageDriver::NoSuchConsumerError, /#{bad_consumer_name}/)
@@ -330,22 +330,22 @@ module MessageDriver
           end
         end
 
-        describe "#subscribe_with" do
-          let(:destination) { broker.destination(:my_queue, "my_queue", exclusive: true) }
-          let(:consumer_double) { lambda do |m| end }
+        describe '#subscribe_with' do
+          let(:destination) { broker.destination(:my_queue, 'my_queue', exclusive: true) }
+          let(:consumer_double) { lambda do |_| end }
 
           before do
             adapter_context.stub(:subscribe)
           end
 
-          it "delegates to the adapter_context" do
+          it 'delegates to the adapter_context' do
             adapter_context.should_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
+          it 'passes the options through' do
             options = {foo: :bar}
             adapter_context.should_receive(:subscribe).with(destination, options) do |&blk|
               expect(blk).to be(consumer_double)
@@ -353,7 +353,7 @@ module MessageDriver
             subject.subscribe_with(destination, options, &consumer_double)
           end
 
-          it "looks up the destination" do
+          it 'looks up the destination' do
             adapter_context.should_receive(:subscribe).with(destination, {}) do |&blk|
               expect(blk).to be(consumer_double)
             end
@@ -362,7 +362,7 @@ module MessageDriver
 
           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 {
                 subject.subscribe_with(bad_dest_name, &consumer_double)
               }.to raise_error(MessageDriver::NoSuchDestinationError, /#{bad_dest_name}/)
@@ -373,17 +373,17 @@ module MessageDriver
       end
     end
 
-    context "when used as an included module" do
+    context 'when used as an included module' do
       subject { TestPublisher.new }
-      it_behaves_like "a Client"
+      it_behaves_like 'a Client'
     end
 
-    context "when the module is used directly" do
+    context 'when the module is used directly' do
       subject { described_class }
-      it_behaves_like "a Client"
+      it_behaves_like 'a Client'
     end
 
-    describe ".for_broker" do
+    describe '.for_broker' do
       let(:broker_name) { :my_cool_broker }
       let(:client) { described_class.for_broker(broker_name) }
       it "produces a module that extends #{described_class.name}" do
@@ -396,25 +396,25 @@ module MessageDriver
         expect(client.broker).to be(broker)
       end
 
-      context "when the resulting module is used as an included module" do
+      context 'when the resulting module is used as an included module' do
         subject! do
           clz = Class.new
           clz.send :include, client
           clz.new
         end
-        it_behaves_like "a Client"
+        it_behaves_like 'a Client'
       end
 
-      context "when the resulting module is used directly" do
-        it_behaves_like "a Client" do
+      context 'when the resulting module is used directly' do
+        it_behaves_like 'a Client' do
           subject! { client }
         end
       end
     end
 
-    describe ".[]" do
-      it "grabs the client for the given broker" do
-        expected = double("client")
+    describe '.[]' do
+      it 'grabs the client for the given broker' do
+        expected = double('client')
         allow(Broker).to receive(:client).with(:test_broker).and_return(expected)
         expect(described_class[:test_broker]).to be expected
       end