amqp_integration_spec.rb in message-driver-0.4.0

- old
+ new
@@ -1,142 +1,142 @@
 require 'spec_helper'
 
-describe "AMQP Integration", :bunny, type: :integration do
+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
+    let(:queue_name) { 'my.lost.queue' }
+    it 'raises a MessageDriver::QueueNotFound error' do
       expect {
         broker.dynamic_destination(queue_name, passive: true)
       }.to raise_error(MessageDriver::QueueNotFound) do |err|
         expect(err.queue_name).to eq(queue_name)
         expect(err.nested).to be_a Bunny::NotFound
       end
     end
   end
 
-  context "when a channel level exception occurs" do
-    it "raises a MessageDriver::WrappedError error" do
+  context 'when a channel level exception occurs' do
+    it 'raises a MessageDriver::WrappedError error' do
       expect {
-        broker.dynamic_destination("not.a.queue", passive: true)
+        broker.dynamic_destination('not.a.queue', passive: true)
       }.to raise_error(MessageDriver::WrappedError) { |err| err.nested.should be_a Bunny::ChannelLevelException }
     end
 
-    it "reestablishes the channel transparently" do
+    it 'reestablishes the channel transparently' do
       expect {
-        broker.dynamic_destination("not.a.queue", passive: true)
+        broker.dynamic_destination('not.a.queue', passive: true)
       }.to raise_error(MessageDriver::WrappedError)
       expect {
-        broker.dynamic_destination("", exclusive: true)
+        broker.dynamic_destination('', exclusive: true)
       }.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
+    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 {
-            broker.dynamic_destination("not.a.queue", passive: true)
+            broker.dynamic_destination('not.a.queue', passive: true)
           }.to raise_error(MessageDriver::WrappedError)
           expect {
-            broker.dynamic_destination("", exclusive: true)
+            broker.dynamic_destination('', exclusive: true)
           }.to raise_error(MessageDriver::TransactionRollbackOnly)
         end
         expect {
-          broker.dynamic_destination("", exclusive: true)
+          broker.dynamic_destination('', exclusive: true)
         }.to_not raise_error
       end
     end
   end
 
-  context "when the broker connection fails", pending: "these spec are busted" do
+  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")
+    it 'raises a MessageDriver::ConnectionError' do
+      dest = create_destination('test_queue')
       disrupt_connection
       expect {
-        dest.publish("Reconnection Test")
+        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")
+    it 'seemlessly reconnects' do
+      dest = create_destination('seemless.reconnect.queue')
       disrupt_connection
       expect {
-        dest.publish("Reconnection Test 1")
+        dest.publish('Reconnection Test 1')
       }.to raise_error(MessageDriver::ConnectionError)
-      dest = create_destination("seemless.reconnect.queue")
-      dest.publish("Reconnection Test 2")
+      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")
+      expect(msg.body).to eq('Reconnection Test 2')
     end
 
-    context "when in a transaction" do
-      it "raises a MessageDriver::ConnectionError" do
+    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)
+            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
+      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)
+            broker.dynamic_destination('', exclusive: true)
           }.to raise_error(MessageDriver::ConnectionError)
           expect {
-            broker.dynamic_destination("", exclusive: true)
+            broker.dynamic_destination('', exclusive: true)
           }.to raise_error(MessageDriver::TransactionRollbackOnly)
         end
         expect {
-          broker.dynamic_destination("", exclusive: true)
+          broker.dynamic_destination('', exclusive: true)
         }.to_not raise_error
       end
     end
   end
 
-  context "when an unhandled expection occurs in a transaction" do
-    let(:destination) { broker.dynamic_destination("", exclusive: true) }
+  context 'when an unhandled expection occurs in a transaction' do
+    let(:destination) { broker.dynamic_destination('', exclusive: true) }
 
-    it "rolls back the transaction" do
+    it 'rolls back the transaction' do
       expect {
         MessageDriver::Client.with_message_transaction do
-          destination.publish("Test Message")
-          raise "unhandled error"
+          destination.publish('Test Message')
+          raise 'unhandled error'
         end
-      }.to raise_error "unhandled error"
+      }.to raise_error 'unhandled error'
       expect(destination.pop_message).to be_nil
     end
 
-    it "allows the next transaction to continue" do
+    it 'allows the next transaction to continue' do
       expect {
         MessageDriver::Client.with_message_transaction do
-          destination.publish("Test Message 1")
-          raise "unhandled error"
+          destination.publish('Test Message 1')
+          raise 'unhandled error'
         end
-      }.to raise_error "unhandled error"
+      }.to raise_error 'unhandled error'
       expect(destination.pop_message).to be_nil
 
       MessageDriver::Client.with_message_transaction do
-        destination.publish("Test Message 2")
+        destination.publish('Test Message 2')
       end
 
       msg = destination.pop_message
       expect(msg).to_not be_nil
-      expect(msg.body).to eq("Test Message 2")
+      expect(msg.body).to eq('Test Message 2')
     end
   end
 end