message-driver 0.1.0 → 0.2.0.rc1

data/spec/integration/{amqp_integration_spec.rb → bunny/amqp_integration_spec.rb}

@@ -1,33 +1,36 @@
 require 'spec_helper'
 
 describe "AMQP Integration", :bunny, type: :integration do
-  before do
+  before(:each) do
     MessageDriver.configure BrokerConfig.config
   end
+  after(:each) do
+    MessageDriver::Broker.stop
+  end
 
   context "when a queue can't be found" do
     let(:queue_name) { "my.lost.queue" }
     it "raises a MessageDriver::QueueNotFound error" do
       expect {
         MessageDriver::Broker.dynamic_destination(queue_name, passive: true)
-      }.to raise_error(MessageDriver::QueueNotFound, /#{queue_name}/) do |err|
+      }.to raise_error(MessageDriver::QueueNotFound) do |err|
         expect(err.queue_name).to eq(queue_name)
-        expect(err.other).to be_a Bunny::NotFound
+        expect(err.nested).to be_a Bunny::NotFound
       end
     end
   end
 
   context "when a channel level exception occurs" do
-    it "raises a MessageDriver::WrappedException error" do
+    it "raises a MessageDriver::WrappedError error" do
       expect {
         MessageDriver::Broker.dynamic_destination("not.a.queue", passive: true)
-      }.to raise_error(MessageDriver::WrappedException) { |err| err.other.should be_a Bunny::ChannelLevelException }
+      }.to raise_error(MessageDriver::WrappedError) { |err| err.nested.should be_a Bunny::ChannelLevelException }
     end
 
     it "reestablishes the channel transparently" do
       expect {
         MessageDriver::Broker.dynamic_destination("not.a.queue", passive: true)
-      }.to raise_error(MessageDriver::WrappedException)
+      }.to raise_error(MessageDriver::WrappedError)
       expect {
         MessageDriver::Broker.dynamic_destination("", exclusive: true)
       }.to_not raise_error
@@ -35,10 +38,10 @@ describe "AMQP Integration", :bunny, type: :integration do
 
     context "when in a transaction" do
       it "sets the channel_context as rollback-only until the transaction is finished" do
-        MessageDriver::Broker.with_transaction do
+        MessageDriver::Client.with_message_transaction do
           expect {
             MessageDriver::Broker.dynamic_destination("not.a.queue", passive: true)
-          }.to raise_error(MessageDriver::WrappedException)
+          }.to raise_error(MessageDriver::WrappedError)
           expect {
             MessageDriver::Broker.dynamic_destination("", exclusive: true)
           }.to raise_error(MessageDriver::TransactionRollbackOnly)
@@ -50,34 +53,32 @@ describe "AMQP Integration", :bunny, type: :integration do
     end
   end
 
-  context "when the broker connection fails" do
-    after(:each) do
-      MessageDriver::Broker.stop
-    end
+  context "when the broker connection fails", pending: "these spec are busted" do
     def disrupt_connection
       #yes, this is very implementation specific
       MessageDriver::Broker.adapter.connection.instance_variable_get(:@transport).close
     end
 
-    it "raises a MessageDriver::ConnectionException" do
-      dest = MessageDriver::Broker.dynamic_destination("", exclusive: true)
+    def create_destination(queue_name)
+      MessageDriver::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::ConnectionException) do |err|
-        expect(err.other).to be_a Bunny::NetworkErrorWrapper
+      }.to raise_error(MessageDriver::ConnectionError) do |err|
+        expect(err.nested).to be_a Bunny::NetworkErrorWrapper
       end
     end
 
-    def create_destination(queue_name)
-      MessageDriver::Broker.dynamic_destination(queue_name, exclusive: true)
-    end
     it "seemlessly reconnects" do
       dest = create_destination("seemless.reconnect.queue")
       disrupt_connection
       expect {
         dest.publish("Reconnection Test 1")
-      }.to raise_error(MessageDriver::ConnectionException)
+      }.to raise_error(MessageDriver::ConnectionError)
       dest = create_destination("seemless.reconnect.queue")
       dest.publish("Reconnection Test 2")
       msg = dest.pop_message
@@ -86,21 +87,21 @@ describe "AMQP Integration", :bunny, type: :integration do
     end
 
     context "when in a transaction" do
-      it "raises a MessageDriver::ConnectionException" do
+      it "raises a MessageDriver::ConnectionError" do
         expect {
-          MessageDriver::Broker.with_transaction do
+          MessageDriver::Client.with_message_transaction do
             disrupt_connection
             MessageDriver::Broker.dynamic_destination("", exclusive: true)
           end
-        }.to raise_error(MessageDriver::ConnectionException)
+        }.to raise_error(MessageDriver::ConnectionError)
       end
 
       it "sets the channel_context as rollback-only until the transaction is finished" do
-        MessageDriver::Broker.with_transaction do
+        MessageDriver::Client.with_message_transaction do
           disrupt_connection
           expect {
             MessageDriver::Broker.dynamic_destination("", exclusive: true)
-          }.to raise_error(MessageDriver::ConnectionException)
+          }.to raise_error(MessageDriver::ConnectionError)
           expect {
             MessageDriver::Broker.dynamic_destination("", exclusive: true)
           }.to raise_error(MessageDriver::TransactionRollbackOnly)
@@ -117,7 +118,7 @@ describe "AMQP Integration", :bunny, type: :integration do
 
     it "rolls back the transaction" do
       expect {
-        MessageDriver::Broker.with_transaction do
+        MessageDriver::Client.with_message_transaction do
           destination.publish("Test Message")
           raise "unhandled error"
         end
@@ -127,14 +128,14 @@ describe "AMQP Integration", :bunny, type: :integration do
 
     it "allows the next transaction to continue" do
       expect {
-        MessageDriver::Broker.with_transaction do
+        MessageDriver::Client.with_message_transaction do
           destination.publish("Test Message 1")
           raise "unhandled error"
         end
       }.to raise_error "unhandled error"
       expect(destination.pop_message).to be_nil
 
-      MessageDriver::Broker.with_transaction do
+      MessageDriver::Client.with_message_transaction do
         destination.publish("Test Message 2")
       end
 

data/spec/integration/bunny/bunny_adapter_spec.rb

@@ -0,0 +1,339 @@
+require 'spec_helper'
+
+require 'message_driver/adapters/bunny_adapter'
+
+module MessageDriver::Adapters
+  describe BunnyAdapter, :bunny, type: :integration do
+
+    let(:valid_connection_attrs) { BrokerConfig.config }
+
+    describe "#initialize" do
+      context "differing bunny versions" do
+        shared_examples "raises an error" do
+          it "raises an error" do
+            stub_const("Bunny::VERSION", version)
+            expect {
+              described_class.new(valid_connection_attrs)
+            }.to raise_error MessageDriver::Error, "bunny 0.9.3 or later is required for the bunny adapter"
+          end
+        end
+        shared_examples "doesn't raise an error" do
+          it "doesn't raise an an error" do
+            stub_const("Bunny::VERSION", version)
+            adapter = nil
+            expect {
+              adapter = described_class.new(valid_connection_attrs)
+            }.to_not raise_error
+          end
+        end
+        %w(0.8.0 0.9.0.pre11 0.9.0.rc1 0.9.0 0.9.2).each do |v|
+          context "bunny version #{v}" do
+            let(:version) { v }
+            include_examples "raises an error"
+          end
+        end
+        %w(0.9.3 0.9.4 0.10.0 1.0.0.pre1).each do |v|
+          context "bunny version #{v}" do
+            let(:version) { v }
+            include_examples "doesn't raise an error"
+          end
+        end
+      end
+
+      it "connects to the rabbit broker" do
+        adapter = described_class.new(valid_connection_attrs)
+
+        expect(adapter.connection).to be_a Bunny::Session
+        expect(adapter.connection).to be_open
+      end
+
+      it "connects to the rabbit broker lazily" do
+        adapter = described_class.new(valid_connection_attrs)
+
+        expect(adapter.connection(false)).to_not be_open
+      end
+    end
+
+    shared_context "a connected bunny adapter" do
+      subject(:adapter) { described_class.new(valid_connection_attrs) }
+      let(:connection) { adapter.connection }
+
+      before do
+        MessageDriver::Broker.configure(adapter: adapter)
+      end
+
+      after do
+        adapter.stop
+      end
+    end
+
+    shared_context "with a queue" do
+      include_context "a connected bunny adapter"
+
+      let(:channel) { connection.create_channel }
+      let(:tmp_queue_name) { "my_temp_queue" }
+      let(:tmp_queue) { channel.queue(tmp_queue_name, exclusive: true) }
+    end
+
+    it_behaves_like "an adapter" do
+      include_context "a connected bunny adapter"
+    end
+
+    describe "#new_context" do
+      include_context "a connected bunny adapter"
+
+      it "returns a BunnyAdapter::BunnyContext" do
+        expect(subject.new_context).to be_a BunnyAdapter::BunnyContext
+      end
+    end
+
+    describe BunnyAdapter::BunnyContext do
+      include_context "a connected bunny adapter"
+      subject(:adapter_context) { adapter.new_context }
+
+      it_behaves_like "an adapter context"
+      it_behaves_like "transactions are supported"
+      it_behaves_like "client acks are supported"
+      it_behaves_like "subscriptions are supported", BunnyAdapter::Subscription
+
+      describe "#pop_message" do
+        include_context "with a queue"
+        it "needs some real tests"
+      end
+
+
+      describe "#invalidate" do
+        it "closes the channel" do
+          subject.with_channel(false) do |ch|
+            expect(ch).to be_open
+          end
+          subject.invalidate
+          expect(subject.instance_variable_get(:@channel)).to be_closed
+        end
+      end
+
+      describe "#create_destination" do
+
+        context "with defaults" do
+          context "the resulting destination" do
+            let(:dest_name) { "my_dest" }
+            subject(:result) { adapter_context.create_destination(dest_name, exclusive: true) }
+
+            it { should be_a BunnyAdapter::QueueDestination }
+          end
+        end
+
+        context "the type is queue" do
+          context "and there is no destination name given" do
+            subject(:destination) { adapter_context.create_destination("", type: :queue, exclusive: true) }
+            it { should be_a BunnyAdapter::QueueDestination }
+            its(:name) { should be_a String }
+            its(:name) { should_not be_empty }
+          end
+          context "the resulting destination" do
+            let(:dest_name) { "my_dest" }
+            subject(:destination) { adapter_context.create_destination(dest_name, type: :queue, exclusive: true) }
+            before do
+              destination
+            end
+
+            it { should be_a BunnyAdapter::QueueDestination }
+            its(:name) { should be_a String }
+            its(:name) { should eq(dest_name) }
+
+            include_examples "supports #message_count"
+
+            it "strips off the type so it isn't set on the destination" do
+              expect(subject.dest_options).to_not have_key :type
+            end
+            it "ensures the queue is declared" do
+              expect {
+                connection.with_channel do |ch|
+                  ch.queue(dest_name, passive: true)
+                end
+              }.to_not raise_error
+            end
+            context "publishing a message" do
+              let(:body) { "Testing the QueueDestination" }
+              let(:headers) { {"foo" => "bar"} }
+              let(:properties) { {persistent: false} }
+              before do
+                subject.publish(body, headers, properties)
+              end
+              it "publishes via the default exchange" do
+                msg = subject.pop_message
+                expect(msg.body).to eq(body)
+                expect(msg.headers).to eq(headers)
+                expect(msg.properties[:delivery_mode]).to eq(1)
+                expect(msg.delivery_info.exchange).to eq("")
+                expect(msg.delivery_info.routing_key).to eq(subject.name)
+              end
+            end
+            it_behaves_like "a destination"
+          end
+          context "and bindings are provided" do
+            let(:dest_name) { "binding_test_queue" }
+            let(:exchange) { adapter_context.create_destination("amq.direct", type: :exchange) }
+
+            it "raises an exception if you don't provide a source" do
+              expect {
+                adapter_context.create_destination("bad_bind_queue", type: :queue, exclusive: true, bindings: [{args: {routing_key: "test_exchange_bind"}}])
+              }.to raise_error MessageDriver::Error, /must provide a source/
+            end
+
+            it "routes message to the queue through the exchange" do
+              destination = adapter_context.create_destination(dest_name, type: :queue, exclusive: true, bindings: [{source: "amq.direct", args: {routing_key: "test_queue_bind"}}])
+              exchange.publish("test queue bindings", {}, {routing_key: "test_queue_bind"})
+              message = destination.pop_message
+              expect(message).to_not be_nil
+              expect(message.body).to eq("test queue bindings")
+            end
+          end
+
+          context "we are not yet connected to the broker and :no_declare is provided" do
+            it "doesn't cause a connection to the broker" do
+              connection.stop
+              adapter_context.create_destination("test_queue", no_declare: true, type: :queue, exclusive: true)
+              expect(adapter.connection(false)).to_not be_open
+            end
+
+            context "with a server-named queue" do
+              it "raises an error" do
+                expect {
+                  adapter_context.create_destination("", no_declare: true, type: :queue, exclusive: true)
+                }.to raise_error MessageDriver::Error, "server-named queues must be declared, but you provided :no_declare => true"
+              end
+            end
+
+            context "with bindings" do
+              it "raises an error" do
+                expect {
+                  adapter_context.create_destination("tmp_queue", no_declare: true, bindings: [{source: "amq.fanout"}], type: :queue, exclusive: true)
+                }.to raise_error MessageDriver::Error, "queues with bindings must be declared, but you provided :no_declare => true"
+              end
+            end
+          end
+        end
+
+        context "the type is exchange" do
+          context "the resulting destination" do
+            let(:dest_name) { "my_dest" }
+            subject(:destination) { adapter_context.create_destination(dest_name, type: :exchange) }
+
+            it { should be_a BunnyAdapter::ExchangeDestination }
+            include_examples "doesn't support #message_count"
+
+            it "strips off the type so it isn't set on the destination" do
+              expect(subject.dest_options).to_not have_key :type
+            end
+
+            it "raises an error when pop_message is called" do
+              expect {
+                subject.pop_message(dest_name)
+              }.to raise_error MessageDriver::Error, "You can't pop a message off an exchange"
+            end
+
+            context "publishing a message" do
+              let(:body) { "Testing the ExchangeDestination" }
+              let(:headers) { {"foo" => "bar"} }
+              let(:properties) { {persistent: false} }
+              before { connection.with_channel { |ch| ch.fanout(dest_name, auto_delete: true) } }
+              let!(:queue) do
+                q = nil
+                connection.with_channel do |ch|
+                  q = ch.queue("", exclusive: true)
+                  q.bind(dest_name)
+                end
+                q
+              end
+              before do
+                subject.publish(body, headers, properties)
+              end
+
+              it "publishes to the specified exchange" do
+                connection.with_channel do |ch|
+                  q = ch.queue(queue.name, passive: true)
+                  msg = q.pop
+                  expect(msg[2]).to eq(body)
+                  expect(msg[0].exchange).to eq(dest_name)
+                  expect(msg[1][:headers]).to eq(headers)
+                  expect(msg[1][:delivery_mode]).to eq(1)
+                end
+              end
+            end
+          end
+
+          context "declaring an exchange on the broker" do
+            let(:dest_name) { "my.cool.exchange" }
+
+            it "creates the exchange if you include 'declare' in the options" do
+              exchange = adapter_context.create_destination(dest_name, type: :exchange, declare: {type: :fanout, auto_delete: true})
+              queue = adapter_context.create_destination("", type: :queue, exclusive: true, bindings: [{source: dest_name}])
+              exchange.publish("test declaring exchange")
+              message = queue.pop_message
+              expect(message).to_not be_nil
+              expect(message.body).to eq("test declaring exchange")
+            end
+
+            it "raises an error if you don't provide a type" do
+              expect {
+                adapter_context.create_destination(dest_name, type: :exchange, declare: {auto_delete: true})
+              }.to raise_error MessageDriver::Error, /you must provide a valid exchange type/
+            end
+
+          end
+
+          context "and bindings are provided" do
+            let(:dest_name) { "binding_exchange_queue" }
+            let(:exchange) { adapter_context.create_destination("amq.direct", type: :exchange) }
+
+            it "raises an exception if you don't provide a source" do
+              expect {
+                adapter_context.create_destination("amq.fanout", type: :exchange, bindings: [{args: {routing_key: "test_exchange_bind"}}])
+              }.to raise_error MessageDriver::Error, /must provide a source/
+            end
+
+            it "routes message to the queue through the exchange" do
+              adapter_context.create_destination("amq.fanout", type: :exchange, bindings: [{source: "amq.direct", args: {routing_key: "test_exchange_bind"}}])
+              destination = adapter_context.create_destination(dest_name, type: :queue, exclusive: true, bindings: [{source: "amq.fanout"}])
+              exchange.publish("test exchange bindings", {}, {routing_key: "test_exchange_bind"})
+              message = destination.pop_message
+              expect(message).to_not be_nil
+              expect(message.body).to eq("test exchange bindings")
+            end
+          end
+
+          context "we are not yet connected to the broker" do
+            it "doesn't cause a connection to the broker" do
+              connection.stop
+              adapter_context.create_destination("amq.fanout", type: :exchange)
+              expect(adapter.connection(false)).to_not be_open
+            end
+          end
+        end
+
+        context "the type is invalid" do
+          it "raises in an error" do
+            expect {
+              adapter_context.create_destination("my_dest", type: :foo_bar)
+            }.to raise_error MessageDriver::Error, "invalid destination type #{:foo_bar}"
+          end
+        end
+      end
+
+      describe "#subscribe" do
+        context "the destination is an ExchangeDestination" do
+          let(:dest_name) { "my_dest" }
+          let(:destination) { adapter_context.create_destination(dest_name, type: :exchange) }
+          let(:consumer) { lambda do |m|; end }
+
+          it "raises an error" do
+            expect {
+              adapter_context.subscribe(destination, &consumer)
+            }.to raise_error MessageDriver::Error, /QueueDestination/
+          end
+        end
+      end
+    end
+  end
+end

data/spec/integration/in_memory/in_memory_adapter_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+require 'message_driver/adapters/in_memory_adapter'
+
+module MessageDriver::Adapters
+  describe InMemoryAdapter, :in_memory, type: :integration do
+    subject(:adapter) { described_class.new }
+
+    describe "#new_context" do
+      it "returns a InMemoryAdapter::InMemoryContext" do
+        expect(subject.new_context).to be_a InMemoryAdapter::InMemoryContext
+      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 { should be_a InMemoryAdapter::Destination }
+
+        it_behaves_like "a destination"
+        include_examples "supports #message_count"
+      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 "#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
+
+        destinations.each do |destination|
+          expect(destination.message_count).to eq(0)
+        end
+      end
+
+      it "removes any existing subscriptions" do
+        destinations = (1..3).map(&adapter.method(:create_destination))
+        consumer = lambda do |m| end
+        destinations.each do |destination|
+          destination.subscribe(&consumer)
+        end
+
+        adapter.reset_after_tests
+
+        destinations.each do |destination|
+          expect(destination.subscription).to be_nil
+        end
+
+      end
+    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) }
+
+      context "when I have a consumer on one destination" do
+        let(:consumer) { lambda do |m| 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)
+        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 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 {
+            dest1.pop_message
+          }.to change{dest2.message_count}.from(1).to(0)
+        end
+      end
+    end
+
+    describe "subscribing a consumer" do
+      let(:destination) { adapter.create_destination(:my_queue) }
+
+      let(:subscription_type) { MessageDriver::Adapters::InMemoryAdapter::Subscription }
+    end
+  end
+end