spec/integration/bunny/amqp_integration_spec.rb in message-driver-0.4.0 vs spec/integration/bunny/amqp_integration_spec.rb in message-driver-0.5.0

@@ -1,134 +1,73 @@
 require 'spec_helper'
 
-describe 'AMQP Integration', :bunny, type: :integration do
+RSpec.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
-      expect {
+      expect do
         broker.dynamic_destination(queue_name, passive: true)
-      }.to raise_error(MessageDriver::QueueNotFound) do |err|
-        expect(err.queue_name).to eq(queue_name)
+      end.to raise_error(MessageDriver::QueueNotFound) do |err|
         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
-      expect {
+      expect do
         broker.dynamic_destination('not.a.queue', passive: true)
-      }.to raise_error(MessageDriver::WrappedError) { |err| err.nested.should be_a Bunny::ChannelLevelException }
+      end.to raise_error(MessageDriver::WrappedError) { |err| expect(err.nested).to be_a Bunny::ChannelLevelException }
     end
 
     it 'reestablishes the channel transparently' do
-      expect {
+      expect do
         broker.dynamic_destination('not.a.queue', passive: true)
-      }.to raise_error(MessageDriver::WrappedError)
-      expect {
+      end.to raise_error(MessageDriver::WrappedError)
+      expect do
         broker.dynamic_destination('', exclusive: true)
-      }.to_not raise_error
+      end.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
         MessageDriver::Client.with_message_transaction do
-          expect {
+          expect do
             broker.dynamic_destination('not.a.queue', passive: true)
-          }.to raise_error(MessageDriver::WrappedError)
-          expect {
+          end.to raise_error(MessageDriver::WrappedError)
+          expect do
             broker.dynamic_destination('', exclusive: true)
-          }.to raise_error(MessageDriver::TransactionRollbackOnly)
+          end.to raise_error(MessageDriver::TransactionRollbackOnly)
         end
-        expect {
+        expect do
           broker.dynamic_destination('', exclusive: true)
-        }.to_not raise_error
+        end.to_not raise_error
       end
     end
   end
 
-  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')
-      disrupt_connection
-      expect {
-        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')
-      disrupt_connection
-      expect {
-        dest.publish('Reconnection Test 1')
-      }.to raise_error(MessageDriver::ConnectionError)
-      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')
-    end
-
-    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)
-          end
-        }.to raise_error(MessageDriver::ConnectionError)
-      end
-
-      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)
-          }.to raise_error(MessageDriver::ConnectionError)
-          expect {
-            broker.dynamic_destination('', exclusive: true)
-          }.to raise_error(MessageDriver::TransactionRollbackOnly)
-        end
-        expect {
-          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) }
 
     it 'rolls back the transaction' do
-      expect {
+      expect do
         MessageDriver::Client.with_message_transaction do
           destination.publish('Test Message')
-          raise 'unhandled error'
+          fail 'unhandled error'
         end
-      }.to raise_error 'unhandled error'
+      end.to raise_error 'unhandled error'
       expect(destination.pop_message).to be_nil
     end
 
     it 'allows the next transaction to continue' do
-      expect {
+      expect do
         MessageDriver::Client.with_message_transaction do
           destination.publish('Test Message 1')
-          raise 'unhandled error'
+          fail 'unhandled error'
         end
-      }.to raise_error 'unhandled error'
+      end.to raise_error 'unhandled error'
       expect(destination.pop_message).to be_nil
 
       MessageDriver::Client.with_message_transaction do
         destination.publish('Test Message 2')
       end