message-driver 0.4.0 → 0.5.0

data/spec/integration/in_memory/in_memory_adapter_spec.rb

@@ -2,126 +2,129 @@ require 'spec_helper'
 
 require 'message_driver/adapters/in_memory_adapter'
 
-module MessageDriver::Adapters
-  describe InMemoryAdapter, :in_memory, type: :integration do
-    let(:broker) { double('broker') }
-    subject(:adapter) { described_class.new(broker) }
-
-    describe '#new_context' do
-      it 'returns a InMemoryAdapter::InMemoryContext' do
-        expect(subject.new_context).to be_a InMemoryAdapter::InMemoryContext
+module MessageDriver
+  module Adapters
+    RSpec.describe InMemoryAdapter, :in_memory, type: :integration do
+      let(:broker) { double(Broker) }
+      subject(:adapter) { described_class.new(broker) }
+
+      describe '#new_context' do
+        it 'returns a InMemoryAdapter::InMemoryContext' do
+          expect(subject.new_context).to be_a InMemoryAdapter::InMemoryContext
+        end
       end
-    end
-
-    it_behaves_like 'an adapter'
-
-    describe InMemoryAdapter::InMemoryContext do
-      subject(:adapter_context) { adapter.new_context }
-
-      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 supported', InMemoryAdapter::Subscription
-    end
 
-    describe '#create_destination' do
-      describe 'the resulting destination' do
-        subject(:destination) { adapter.create_destination('my_test_dest') }
+      it_behaves_like 'an adapter'
 
-        it { should be_a InMemoryAdapter::Destination }
+      describe 'InMemoryAdapter::InMemoryContext' do
+        subject(:adapter_context) { adapter.new_context }
 
-        it_behaves_like 'a destination'
-        include_examples 'supports #message_count'
+        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 supported', InMemoryAdapter::Subscription
       end
 
-      context 'when creating two destinations for the same queue' do
-        it 'creates seperate destination instances' do
-          queue_name = 'my_queue'
-          dest1 = adapter.create_destination(queue_name)
-          dest2 = adapter.create_destination(queue_name)
-          expect(dest1).to_not be(dest2)
-        end
-      end
-    end
+      describe '#create_destination' do
+        describe 'the resulting destination' do
+          subject(:destination) { adapter.create_destination('my_test_dest') }
 
-    describe '#reset_after_tests' do
-      it 'empties all the destination queues' do
-        destinations = (1..3).map(&adapter.method(:create_destination))
-        destinations.each do |destination|
-          destination.publish("There's always money in the banana stand!", {}, {})
-        end
+          it { is_expected.to be_a InMemoryAdapter::Destination }
 
-        adapter.reset_after_tests
+          it_behaves_like 'a destination'
+          include_examples 'supports #message_count'
+          include_examples 'supports #consumer_count'
+        end
 
-        destinations.each do |destination|
-          expect(destination.message_count).to eq(0)
+        context 'when creating two destinations for the same queue' do
+          it 'creates seperate destination instances' do
+            queue_name = 'my_queue'
+            dest1 = adapter.create_destination(queue_name)
+            dest2 = adapter.create_destination(queue_name)
+            expect(dest1).to_not be(dest2)
+          end
         end
       end
 
-      it 'removes any existing subscriptions' do
-        destinations = (1..3).map(&adapter.method(:create_destination))
-        consumer = lambda do |_| end
-        destinations.each do |destination|
-          destination.subscribe(&consumer)
-        end
+      describe '#reset_after_tests' do
+        it 'empties all the destination queues' do
+          destinations = (1..3).map(&adapter.method(:create_destination))
+          destinations.each do |destination|
+            destination.publish("There's always money in the banana stand!", {}, {})
+          end
 
-        adapter.reset_after_tests
+          adapter.reset_after_tests
 
-        destinations.each do |destination|
-          expect(destination.subscription).to be_nil
+          destinations.each do |destination|
+            expect(destination.message_count).to eq(0)
+          end
         end
 
-      end
-    end
+        it 'removes any existing subscriptions' do
+          destinations = (1..3).map(&adapter.method(:create_destination))
+          consumer = ->(_) {}
+          destinations.each do |destination|
+            destination.subscribe(&consumer)
+          end
 
-    describe 'accessing the same queue from two destinations' do
-      let(:queue_name) { 'my_queue' }
-      let(:dest1) { adapter.create_destination(queue_name) }
-      let(:dest2) { adapter.create_destination(queue_name) }
+          adapter.reset_after_tests
+
+          destinations.each do |destination|
+            expect(destination.subscription).to be_nil
+          end
 
-      context 'when I have a consumer on one destination' do
-        let(:consumer) { lambda do |_| end }
-        before do
-          dest1.subscribe(&consumer)
-        end
-        it 'is the same consumer on the other destination' do
-          expect(dest2.subscription.consumer).to be(consumer)
         end
       end
 
-      context 'when I publish a message to one destination' do
-        it 'changes the message_count on the other' do
-          expect {
-            dest1.publish('my test message')
-          }.to change{dest2.message_count}.from(0).to(1)
+      describe 'accessing the same queue from two destinations' do
+        let(:queue_name) { 'my_queue' }
+        let(:dest1) { adapter.create_destination(queue_name) }
+        let(:dest2) { adapter.create_destination(queue_name) }
+
+        context 'when I have a consumer on one destination' do
+          let(:consumer) { ->(_) {} }
+          before do
+            dest1.subscribe(&consumer)
+          end
+          it 'is the same consumer on the other destination' do
+            expect(dest2.subscription.consumer).to be(consumer)
+          end
         end
 
-        it 'can be popped off the other' do
-          dest1.publish('my test message')
-          msg = dest2.pop_message
-          expect(msg).to_not be_nil
-          expect(msg.body).to eq('my test message')
-        end
-      end
+        context 'when I publish a message to one destination' do
+          it 'changes the message_count on the other' do
+            expect do
+              dest1.publish('my test message')
+            end.to change { dest2.message_count }.from(0).to(1)
+          end
 
-      context 'when I pop a message off one destination' do
-        let(:message_body) { 'test popping a message' }
-        before do
-          dest2.publish(message_body)
+          it 'can be popped off the other' do
+            dest1.publish('my test message')
+            msg = dest2.pop_message
+            expect(msg).to_not be_nil
+            expect(msg.body).to eq('my test message')
+          end
         end
 
-        it 'changes the message_count on the other' do
-          expect {
-            dest1.pop_message
-          }.to change{dest2.message_count}.from(1).to(0)
+        context 'when I pop a message off one destination' do
+          let(:message_body) { 'test popping a message' }
+          before do
+            dest2.publish(message_body)
+          end
+
+          it 'changes the message_count on the other' do
+            expect do
+              dest1.pop_message
+            end.to change { dest2.message_count }.from(1).to(0)
+          end
         end
       end
-    end
 
-    describe 'subscribing a consumer' do
-      let(:destination) { adapter.create_destination(:my_queue) }
+      describe 'subscribing a consumer' do
+        let(:destination) { adapter.create_destination(:my_queue) }
 
-      let(:subscription_type) { MessageDriver::Adapters::InMemoryAdapter::Subscription }
+        let(:subscription_type) { MessageDriver::Adapters::InMemoryAdapter::Subscription }
+      end
     end
   end
 end

data/spec/integration/stomp/stomp_adapter_spec.rb

@@ -2,134 +2,167 @@ require 'spec_helper'
 
 require 'message_driver/adapters/stomp_adapter'
 
-module MessageDriver::Adapters
-  describe StompAdapter, :stomp, type: :integration do
-
-    let(:valid_connection_attrs) { BrokerConfig.config }
-
-    describe '#initialize' do
-      let(:connection_attrs) { valid_connection_attrs }
-      let(:broker) { double('broker') }
-
-      context 'differing stomp versions' do
-        shared_examples 'raises a stomp error' do
-          it 'raises an error' do
-            stub_const('Stomp::Version::STRING', version)
-            expect {
-              described_class.new(broker, connection_attrs)
-            }.to raise_error MessageDriver::Error, 'stomp 1.3.1 or a later version of the 1.3.x series is required for the stomp adapter'
+module MessageDriver
+  module Adapters
+    RSpec.describe StompAdapter, :stomp, type: :integration do
+
+      let(:valid_connection_attrs) { BrokerConfig.config }
+
+      describe '#initialize' do
+        let(:connection_attrs) { valid_connection_attrs }
+        let(:broker) { double('broker') }
+
+        context 'differing stomp versions' do
+          shared_examples 'raises a stomp error' do
+            it 'raises an error' do
+              stub_const('Stomp::Version::STRING', version)
+              expect do
+                described_class.new(broker, connection_attrs)
+              end.to raise_error MessageDriver::Error, 'stomp 1.3.1 or a later version of the 1.3.x series is required for the stomp adapter'
+            end
           end
-        end
-        shared_examples "doesn't raise a stomp error" do
-          it "doesn't raise an an error" do
-            stub_const('Stomp::Version::STRING', version)
-            adapter = nil
-            expect {
-              adapter = described_class.new(broker, connection_attrs)
-            }.to_not raise_error
+          shared_examples "doesn't raise a stomp error" do
+            it "doesn't raise an an error" do
+              stub_const('Stomp::Version::STRING', version)
+              adapter = nil
+              expect do
+                adapter = described_class.new(broker, connection_attrs)
+              end.to_not raise_error
+            end
           end
-        end
-        %w(1.1.0 1.2.9 1.3.0 1.4.0).each do |v|
-          context "stomp version #{v}" do
-            let(:version) { v }
-            include_examples 'raises a stomp error'
+          %w(1.1.0 1.2.9 1.3.0 1.4.0).each do |v|
+            context "stomp version #{v}" do
+              let(:version) { v }
+              include_examples 'raises a stomp error'
+            end
           end
-        end
-        %w(1.3.1 1.3.5).each do |v|
-          context "stomp version #{v}" do
-            let(:version) { v }
-            include_examples "doesn't raise a stomp error"
+          %w(1.3.1 1.3.5).each do |v|
+            context "stomp version #{v}" do
+              let(:version) { v }
+              include_examples "doesn't raise a stomp error"
+            end
           end
         end
-      end
 
-      describe 'the resulting config' do
-        let(:connection_attrs) { {hosts: [{host: 'my_host'}]} }
-        subject(:config) { described_class.new(broker, connection_attrs).config }
+        describe 'the resulting config' do
+          let(:connection_attrs) { { hosts: [{ host: 'my_host' }] } }
+          subject(:config) { described_class.new(broker, connection_attrs).config }
 
-        its([:connect_headers]) { should eq(:"accept-version" => '1.1,1.2') }
-        its([:hosts]) { should eq(connection_attrs[:hosts]) }
+          it 'has the expected values' do
+            is_expected.to eq(
+              connect_headers: { :"accept-version" => '1.1,1.2' },
+              hosts: connection_attrs[:hosts]
+            )
+          end
 
-        context 'when vhost is specified' do
-          let(:connection_attrs) { {hosts: [{host: 'my_host'}], vhost: 'my_vhost'} }
+          context 'when vhost is specified' do
+            let(:connection_attrs) { { hosts: [{ host: 'my_host' }], vhost: 'my_vhost' } }
 
-          it { should_not have_key(:vhost) }
-          its([:connect_headers]) { should eq(:"accept-version" => '1.1,1.2', :"host" => 'my_vhost') }
-        end
+            it 'has the vhost value in the connect headers' do
+              is_expected.not_to have_key(:vhost)
+              is_expected.to include(connect_headers: { :'accept-version' => '1.1,1.2', host: 'my_vhost' })
+            end
+          end
 
-        context 'when there are things in the connect_headers' do
-          let(:connection_attrs) { {hosts: [{host: 'my_host'}], connect_headers: {'foo' => 'bar'}} }
+          context 'when there are things in the connect_headers' do
+            let(:connection_attrs) { { hosts: [{ host: 'my_host' }], connect_headers: { 'foo' => 'bar' } } }
 
-          its([:connect_headers]) { should eq(:"accept-version" => '1.1,1.2', 'foo' => 'bar') }
+            it 'passes them through' do
+              is_expected.to include(connect_headers: { :'accept-version' => '1.1,1.2', 'foo' => 'bar' })
+            end
 
-          context 'and accept-version is one of the parameters' do
-            let(:connection_attrs) { {hosts: [{host: 'my_host'}], connect_headers: {'foo' => 'bar', :"accept-version" => 'foo!'}} }
+            context 'and accept-version is one of the parameters' do
+              let(:connection_attrs) { { hosts: [{ host: 'my_host' }], connect_headers: { 'foo' => 'bar', :"accept-version" => 'foo!' } } }
 
-            its([:connect_headers]) { should eq(:"accept-version" => '1.1,1.2', 'foo' => 'bar') }
+              it 'overrides it' do
+                is_expected.to include(connect_headers: { :'accept-version' => '1.1,1.2', 'foo' => 'bar' })
+              end
+            end
           end
         end
       end
-    end
 
-    shared_context 'a connected stomp adapter' do
-      let(:broker) { MessageDriver::Broker.configure(valid_connection_attrs) }
-      subject(:adapter) { broker.adapter }
+      shared_context 'a connected stomp adapter' do
+        let(:broker) { MessageDriver::Broker.configure(valid_connection_attrs) }
+        subject(:adapter) { broker.adapter }
 
-      after do
-        adapter.stop
+        after do
+          adapter.stop
+        end
       end
-    end
 
-    it_behaves_like 'an adapter' do
-      include_context 'a connected stomp adapter'
-    end
+      it_behaves_like 'an adapter' do
+        include_context 'a connected stomp adapter'
+      end
 
-    describe '#new_context' do
-      include_context 'a connected stomp adapter'
+      describe '#new_context' do
+        include_context 'a connected stomp adapter'
 
-      it 'returns a StompAdapter::StompContext' do
-        expect(adapter.new_context).to be_a StompAdapter::StompContext
+        it 'returns a StompAdapter::StompContext' do
+          expect(adapter.new_context).to be_a StompAdapter::StompContext
+        end
       end
-    end
 
-    describe StompAdapter::StompContext do
-      include_context 'a connected stomp adapter'
-      subject(:adapter_context) { adapter.new_context }
+      describe StompAdapter::StompContext do
+        include_context 'a connected stomp adapter'
+        subject(:adapter_context) { adapter.new_context }
+
+        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
 
-      describe '#create_destination' do
+          context 'the resulting destination' do
+            let(:dest_name) { '/queue/stomp_destination_spec' }
+            subject(:destination) { adapter_context.create_destination(dest_name) }
 
-        context 'the resulting destination' do
-          let(:dest_name) { '/queue/stomp_destination_spec' }
-          subject(:destination) { adapter_context.create_destination(dest_name) }
+            it { is_expected.to be_a StompAdapter::Destination }
 
-          it { should be_a StompAdapter::Destination }
+            it_behaves_like 'a destination'
+            include_examples "doesn't support #message_count"
+            include_examples "doesn't support #consumer_count"
 
-          it_behaves_like 'a destination'
-          include_examples "doesn't support #message_count"
+            describe '#queue_path' do
+              it 'equals name' do
+                expect(subject.queue_path).to eq(subject.name)
+              end
 
-          describe 'pop_message' do
-            context 'when there is a message on the queue' do
-              let(:body) { 'Testing stomp pop_message' }
-              before do
-                destination.publish(body)
+              context "when name does not start with '/'" do
+                let(:dest_name) { 'stomp_destination_spec' }
+                it 'prepends /queue' do
+                  expect(subject.queue_path).to eq("/queue/#{dest_name}")
+                end
               end
 
-              it 'returns the message' do
-                msg = destination.pop_message
-                expect(msg).to be_a MessageDriver::Adapters::StompAdapter::Message
-                expect(msg.body).to eq(body)
+              context "when the name does start with a '/'" do
+                let(:dest_name) { '/stomp_destination_spec' }
+                it 'equals the name' do
+                  expect(subject.queue_path).to eq(dest_name)
+                end
               end
             end
 
-            context 'when the queue is empty' do
-              it 'returns nil' do
-                msg = destination.pop_message
-                expect(msg).to be_nil
+            describe 'pop_message' do
+              context 'when there is a message on the queue' do
+                let(:body) { 'Testing stomp pop_message' }
+                before do
+                  destination.publish(body)
+                end
+
+                it 'returns the message' do
+                  msg = destination.pop_message
+                  expect(msg).to be_a MessageDriver::Adapters::StompAdapter::Message
+                  expect(msg.body).to eq(body)
+                end
+              end
+
+              context 'when the queue is empty' do
+                it 'returns nil' do
+                  msg = destination.pop_message
+                  expect(msg).to be_nil
+                end
               end
             end
           end