message-driver 0.2.2 → 0.3.0

data/spec/units/message_driver/broker_spec.rb

@@ -3,38 +3,120 @@ require 'message_driver/adapters/in_memory_adapter'
 
 module MessageDriver
   describe Broker do
+    let(:broker_name) { described_class::DEFAULT_BROKER_NAME }
     let(:options) { { adapter: :in_memory } }
-    before do
-      described_class.configure(options)
-    end
-    subject(:broker) { described_class.instance }
 
-    describe ".configure" 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)
-        described_class.should_receive(:new).with(options).and_return(result)
+        result = double(described_class).as_null_object
+        described_class.should_receive(:new).with(described_class::DEFAULT_BROKER_NAME, options).and_return(result)
 
         described_class.configure(options)
 
-        expect(described_class.instance).to be result
+        expect(described_class.broker).to be result
+        expect(described_class.broker(described_class::DEFAULT_BROKER_NAME)).to be result
+      end
+
+      it "doesn't allow you to configure the same broker twice" do
+        described_class.configure(broker_name, options)
+        expect {
+          described_class.configure(broker_name, options)
+        }.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
+          options1 = {foo: :bar}
+          options2 = {bar: :baz}
+          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)
+
+          described_class.configure(:result1, options1)
+          described_class.configure(:result2, options2)
+
+          expect(described_class.broker(:result1)).to be(result1)
+          expect(described_class.broker(:result2)).to be(result2)
+        end
+      end
+
+      context "when you try to access a broker that isn't configured" do
+        it "should raise an error" do
+          expect {
+            described_class.broker(:not_an_adapter)
+          }.to raise_error BrokerNotConfigured
+        end
       end
     end
 
-    describe "#logger" do
-      it "returns the logger, which logs at the info level" do
-        expect(subject.logger).to be_a Logger
-        expect(subject.logger).to be_info
-        expect(subject.logger).to_not be_debug
+    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)
+
+        allow(broker1).to receive(:stop).and_call_original
+        allow(broker2).to receive(:stop).and_call_original
+
+        described_class.reset
+
+        expect(broker1).to have_received(:stop)
+        expect(broker2).to have_received(:stop)
+
+        expect {
+          described_class.broker(:broker1)
+        }.to raise_error BrokerNotConfigured
+
+        expect {
+          described_class.broker(:broker2)
+        }.to raise_error BrokerNotConfigured
       end
 
-      context "configuring the logger" do
-        let(:logger) { double(Logger).as_null_object }
-        let(:options) { { adapter: :in_memory, logger: logger } }
+      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(broker2).to receive(:stop).and_call_original
+
+          expect {
+            described_class.reset
+          }.not_to raise_error
+
+          expect(broker1).to have_received(:stop)
+          expect(broker2).to have_received(:stop)
 
-        it "returns the provided logger" do
-          actual = subject.logger
-          expect(actual).to be logger
+          expect {
+            described_class.broker(:broker1)
+          }.to raise_error BrokerNotConfigured
+
+          expect {
+            described_class.broker(:broker2)
+          }.to raise_error BrokerNotConfigured
+        end
+      end
+    end
+
+    describe ".client" do
+      let(:broker_name) { described_class::DEFAULT_BROKER_NAME }
+      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
+        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
+        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
+          expect(described_class.client(broker_name).broker_name).to eq(broker_name)
         end
       end
     end
@@ -81,128 +163,177 @@ module MessageDriver
         instance = described_class.new(adapter: adapter)
         expect(instance).not_to be_stopped
       end
-    end
 
-    describe "#stop" do
-      let(:adapter) { broker.adapter }
-      it "calls stop on the adapter" do
-        allow(adapter).to receive(:stop).and_call_original
-
-        subject.stop
+      it "has a default name of :default" do
+        adapter = :in_memory
 
-        expect(adapter).to have_received(:stop)
+        instance = described_class.new(adapter: adapter)
+        expect(instance.name).to eq(:default)
       end
 
-      it "marks the broker as stopped" do
-        expect {
-          subject.stop
-        }.to change { subject.stopped? }.from(false).to(true)
-      end
+      it "let's you override the name in the initializer" do
+        adapter = :in_memory
+        name = :my_vhost
 
-      it "invalidates the contexts" do
-        my_ctx = double("context", invalidate: nil)
-        adapter.contexts << my_ctx
-        subject.stop
-        expect(adapter.contexts).to be_empty
-        expect(my_ctx).to have_received(:invalidate)
+        instance = described_class.new(name, adapter: adapter)
+        expect(instance.name).to eq(name)
       end
     end
 
-    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
-        expect {
-          subject.restart
-        }.to change { subject.adapter }
-      end
+    context do
+      subject!(:broker) { described_class.configure(broker_name, options) }
 
-      it "stops the adapter if it hasn't already been stopped" do
-        subject.restart
-        expect(original_adapter).to have_received(:stop).once
+      describe "#stop" do
+        let(:adapter) { broker.adapter }
+        it "calls stop on the adapter" do
+          allow(adapter).to receive(:stop).and_call_original
+
+          subject.stop
+
+          expect(adapter).to have_received(:stop)
+        end
+
+        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)
+          adapter.contexts << my_ctx
+          subject.stop
+          expect(adapter.contexts).to be_empty
+          expect(my_ctx).to have_received(:invalidate)
+        end
       end
 
-      it "does not stop the adapter again if it has already been stopped" do
-        expect(subject.adapter).to be original_adapter
-        subject.stop
-        expect {
+      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
+          expect {
+            subject.restart
+          }.to change { subject.adapter }
+        end
+
+        it "stops the adapter if it hasn't already been stopped" do
           subject.restart
-        }.to change { subject.stopped? }.from(true).to(false)
-        expect(original_adapter).to have_received(:stop).once
-      end
-    end
+          expect(original_adapter).to have_received(:stop).once
+        end
 
-    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
+        it "does not stop the adapter again if it has already been stopped" do
+          expect(subject.adapter).to be original_adapter
+          subject.stop
+          expect {
+            subject.restart
+          }.to change { subject.stopped? }.from(true).to(false)
+          expect(original_adapter).to have_received(:stop).once
+        end
       end
-    end
 
-    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
+      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
-    end
 
-    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)
+      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
 
-      context "when the destination can't be found" do
-        let(:bad_dest_name) { :not_a_queue }
-        it "raises a MessageDriver:NoSuchDestinationError" do
-          expect {
-            broker.find_destination(bad_dest_name)
-          }.to raise_error(MessageDriver::NoSuchDestinationError, /#{bad_dest_name}/)
+      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
-      end
-    end
 
-    describe "#consumer" do
-      let(:consumer_double) { lambda do |m| end }
-      it "saves the provided consumer" do
-        broker.consumer(:my_consumer, &consumer_double)
-        expect(broker.consumers[:my_consumer]).to be(consumer_double)
+        context "when the destination can't be found" do
+          let(:bad_dest_name) { :not_a_queue }
+          it "raises a MessageDriver:NoSuchDestinationError" do
+            expect {
+              broker.find_destination(bad_dest_name)
+            }.to raise_error(MessageDriver::NoSuchDestinationError, /#{bad_dest_name}/)
+          end
+        end
       end
 
-      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")
+      describe "#consumer" do
+        let(:consumer_double) { lambda do |m| 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
+            expect {
+              broker.consumer(:my_consumer)
+            }.to raise_error(MessageDriver::Error, "you must provide a block")
+          end
         end
       end
-    end
 
-    describe "#find_consumer" do
-      let(:consumer_double) { lambda do |m| 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)
+      describe "#find_consumer" do
+        let(:consumer_double) { lambda do |m| 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
+            expect {
+              broker.find_consumer(bad_consumer_name)
+            }.to raise_error(MessageDriver::NoSuchConsumerError, /#{bad_consumer_name}/)
+          end
+        end
       end
 
-      context "when the consumer can't be found" do
-        let(:bad_consumer_name) { :not_a_queue }
-        it "raises a MessageDriver:NoSuchConsumerError" do
-          expect {
-            broker.find_consumer(bad_consumer_name)
-          }.to raise_error(MessageDriver::NoSuchConsumerError, /#{bad_consumer_name}/)
+      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
-    end
 
-    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
+      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
+          expect(broker.client.broker_name).to eq(broker_name)
+          expect(broker.client.broker).to be(broker)
+        end
+
+        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
+          expect(broker.client).to be described_class.client(broker.name)
+        end
+
+        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)
+            expect(broker.client).to be_kind_of MessageDriver::Client
+            expect(broker.client.broker_name).to eq(broker_name)
+            expect(broker.client.broker).to be(broker)
+          end
+        end
       end
     end
 

data/spec/units/message_driver/client_spec.rb

@@ -8,15 +8,19 @@ module MessageDriver
       include Client
     end
 
-    let(:adapter) { Adapters::InMemoryAdapter.new({}) }
+    let(:logger) { MessageDriver.logger }
+    let(:broker_name) { Broker::DEFAULT_BROKER_NAME }
+    let!(:broker) { Broker.configure(broker_name, adapter: Adapters::InMemoryAdapter, logger: logger) }
+    let(:adapter) { broker.adapter }
     let(:adapter_context) { adapter.new_context }
-    let(:logger) { double(Logger).as_null_object }
-
-    before do
-      MessageDriver.configure(adapter: adapter, logger: logger)
-    end
 
     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
         before { subject.clear_context }
 
@@ -37,7 +41,7 @@ module MessageDriver
       end
 
       context "with a given adapter_context" do
-        around do |example|
+        around(:each) do |example|
           subject.with_adapter_context(adapter_context, &example)
         end
 
@@ -66,7 +70,7 @@ module MessageDriver
         end
 
         describe "#publish" do
-          let(:destination) { Broker.destination(:my_queue, "my_queue", exclusive: true) }
+          let(:destination) { broker.destination(:my_queue, "my_queue", exclusive: true) }
           let(:body) { "my message" }
           let(:headers) { {foo: :bar} }
           let(:properties) { {bar: :baz} }
@@ -103,7 +107,7 @@ module MessageDriver
 
         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)
@@ -180,6 +184,7 @@ module MessageDriver
 
               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!")
                   expect {
                     subject.with_message_transaction do
@@ -232,6 +237,7 @@ module MessageDriver
               adapter_context.should_not have_received(:rollback_transaction)
             end
             it "logs a warning" do
+              allow(logger).to receive(:debug)
               expect { |blk|
                 subject.with_message_transaction(&blk)
               }.to yield_control
@@ -244,33 +250,15 @@ module MessageDriver
           let(:message) { double("message") }
           let(:options) { {foo: :bar} }
           before do
-            adapter_context.stub(:ack_message)
+            allow(message).to receive(:ack)
           end
-          context "when the adapter supports client acks" do
-            before do
-              adapter_context.stub(:supports_client_acks?) { true }
-            end
-            it "calls #ack_message with the message" do
-              subject.ack_message(message)
-              adapter_context.should have_received(:ack_message).with(message, {})
-            end
-            it "passes the supplied options to ack_message" do
-              subject.ack_message(message, options)
-              adapter_context.should have_received(:ack_message).with(message, options)
-            end
+          it "calls #ack on the message" do
+            subject.ack_message(message)
+            expect(message).to have_received(:ack).with({})
           end
-          context "when the adapter doesn't support client acks" do
-            before do
-              adapter_context.stub(:supports_client_acks?) { false }
-            end
-            it "doesn't call #ack_message" do
-              subject.ack_message(message)
-              adapter_context.should_not have_received(:ack_message)
-            end
-            it "logs a warning" do
-              subject.ack_message(message)
-              expect(logger).to have_received(:debug).with("this adapter does not support client acks")
-            end
+          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
 
@@ -278,43 +266,25 @@ module MessageDriver
           let(:message) { double("message") }
           let(:options) { {foo: :bar} }
           before do
-            adapter_context.stub(:nack_message)
+            allow(message).to receive(:nack)
           end
-          context "when the adapter supports client acks" do
-            before do
-              adapter_context.stub(:supports_client_acks?) { true }
-            end
-            it "calls #nack_message with the message" do
-              subject.nack_message(message)
-              adapter_context.should have_received(:nack_message).with(message, {})
-            end
-            it "passes the supplied options to nack_message" do
-              subject.nack_message(message, options)
-              adapter_context.should have_received(:nack_message).with(message, options)
-            end
+          it "calls #nack on the message" do
+            subject.nack_message(message)
+            expect(message).to have_received(:nack).with({})
           end
-          context "when the adapter doesn't support client acks" do
-            before do
-              adapter_context.stub(:supports_client_acks?) { false }
-            end
-            it "doesn't call #nack_message" do
-              subject.nack_message(message)
-              adapter_context.should_not have_received(:nack_message)
-            end
-            it "logs a warning" do
-              subject.nack_message(message)
-              expect(logger).to have_received(:debug).with("this adapter does not support client acks")
-            end
+          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(:destination) { broker.destination(:my_queue, "my_queue", exclusive: true) }
           let(:consumer_double) { lambda do |m| end }
 
           before do
             adapter_context.stub(:subscribe)
-            Broker.consumer(:my_consumer, &consumer_double)
+            broker.consumer(:my_consumer, &consumer_double)
           end
 
           it "delegates to the adapter_context" do
@@ -361,7 +331,7 @@ module MessageDriver
         end
 
         describe "#subscribe_with" do
-          let(:destination) { Broker.destination(:my_queue, "my_queue", exclusive: true) }
+          let(:destination) { broker.destination(:my_queue, "my_queue", exclusive: true) }
           let(:consumer_double) { lambda do |m| end }
 
           before do
@@ -412,5 +382,42 @@ module MessageDriver
       subject { described_class }
       it_behaves_like "a Client"
     end
+
+    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
+        expect(client).to be_a Module
+        expect(client).to be_kind_of described_class
+      end
+
+      it "knows it's broker" do
+        expect(client.broker_name).to eq(broker_name)
+        expect(client.broker).to be(broker)
+      end
+
+      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"
+      end
+
+      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")
+        allow(Broker).to receive(:client).with(:test_broker).and_return(expected)
+        expect(described_class[:test_broker]).to be expected
+      end
+    end
   end
 end