message-driver 0.1.0 → 0.2.0.rc1

data/spec/integration/stomp/stomp_adapter_spec.rb

@@ -0,0 +1,142 @@
+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 }
+
+      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(connection_attrs)
+            }.to raise_error MessageDriver::Error, "stomp 1.2.10 or a later version of the 1.2.x series is required for the stomp adapter"
+          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(connection_attrs)
+            }.to_not raise_error
+          end
+        end
+        %w(1.1.0 1.2.9 1.3.0).each do |v|
+          context "stomp version #{v}" do
+            let(:version) { v }
+            include_examples "raises a stomp error"
+          end
+        end
+        %w(1.2.10 1.2.11).each do |v|
+          context "stomp version #{v}" do
+            let(:version) { v }
+            include_examples "doesn't raise a stomp error"
+          end
+        end
+      end
+
+      describe "the resulting config" do
+        let(:connection_attrs) { {hosts: [{host: "my_host"}]} }
+        subject(:config) { described_class.new(connection_attrs).config }
+
+        its([:connect_headers]) { should eq(:"accept-version" => "1.1,1.2") }
+        its([:hosts]) { should eq(connection_attrs[:hosts]) }
+
+        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
+
+        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") }
+
+          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") }
+          end
+        end
+      end
+    end
+
+    shared_context "a connected stomp adapter" do
+      subject(:adapter) { described_class.new(valid_connection_attrs) }
+
+      before do
+        MessageDriver::Broker.configure(adapter: adapter)
+      end
+
+      after do
+        adapter.stop
+      end
+    end
+
+    it_behaves_like "an adapter" do
+      include_context "a connected stomp adapter"
+    end
+
+    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
+      end
+    end
+
+    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"
+
+      describe "#create_destination" do
+
+        context "the resulting destination" do
+          let(:dest_name) { "/queue/stomp_destination_spec" }
+          subject(:destination) { adapter_context.create_destination(dest_name) }
+
+          it { should be_a StompAdapter::Destination }
+
+          it_behaves_like "a destination"
+          include_examples "doesn't support #message_count"
+
+          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
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -11,9 +11,12 @@ RSpec.configure do |c|
 
   c.reporter.message("Acceptance Tests running with broker config: #{BrokerConfig.config}")
 
-  c.filter_run_excluding :no_travis if ENV['TRAVIS']=='true' && ENV['ADAPTER']=='bunny'
+  c.filter_run_excluding :no_ci if ENV['CI']=='true' && ENV['ADAPTER'] && ENV['ADAPTER'].start_with?('bunny')
   if c.inclusion_filter[:all_adapters] == true
-    c.filter_run BrokerConfig.current_adapter
+    BrokerConfig.unconfigured_adapters.each do |a|
+      c.filter_run_excluding a
+    end
+    c.filter_run_including BrokerConfig.current_adapter
   else
     c.run_all_when_everything_filtered = true
   end

data/spec/support/shared/adapter_examples.rb

@@ -0,0 +1,17 @@
+shared_examples "an adapter" do
+  describe "#new_context" do
+    it "returns a MessageDriver::Adapters::ContextBase" do
+      expect(subject.new_context).to be_a MessageDriver::Adapters::ContextBase
+    end
+  end
+
+  describe "#stop" do
+    it "invalidates all the adapter contexts" do
+      ctx1 = subject.new_context
+      ctx2 = subject.new_context
+      subject.stop
+      expect(ctx1).to_not be_valid
+      expect(ctx2).to_not be_valid
+    end
+  end
+end

data/spec/support/shared/client_ack_examples.rb

@@ -0,0 +1,18 @@
+shared_examples "client acks are supported" do
+  describe "#supports_client_acks" do
+    it "returns true" do
+      expect(subject.supports_client_acks?).to eq(true)
+    end
+  end
+
+  it { should respond_to :ack_message }
+  it { should respond_to :nack_message }
+end
+
+shared_examples "client acks are not supported" do
+  describe "#supports_client_acks" do
+    it "returns false" do
+      expect(subject.supports_client_acks?).to eq(false)
+    end
+  end
+end

data/spec/support/shared/context_examples.rb

@@ -0,0 +1,14 @@
+shared_examples "an adapter context" do
+  it { should be_a MessageDriver::Adapters::ContextBase }
+
+  it "is initially valid" do
+    should be_valid
+  end
+
+  describe "#invalidate" do
+    it "causes the context to become invalid" do
+      subject.invalidate
+      expect(subject).to_not be_valid
+    end
+  end
+end

data/spec/support/shared/destination_examples.rb

@@ -9,12 +9,11 @@ shared_examples "a destination" do
     end
 
     context "the result" do
-      let!(:message) { destination.pop_message }
-      subject { message }
+      subject(:message) { destination.pop_message }
 
       it { should be_a MessageDriver::Message::Base }
       its(:body) { should eq(body) }
-      its(:headers) { should eq(headers) }
+      its(:headers) { should include(headers) }
       its(:properties) { should_not be_nil }
     end
   end
@@ -31,11 +30,11 @@ shared_examples "doesn't support #message_count" do
 end
 
 shared_examples "supports #message_count" do
-  #FIXME this example fails on travis with the bunny adapter :(
-  it "reports it's message_count", :no_travis do
+  it "reports it's message_count" do
     expect {
       destination.publish("msg1")
       destination.publish("msg2")
+      pause_if_needed
     }.to change{destination.message_count}.by(2)
   end
 end

data/spec/support/shared/subscription_examples.rb

@@ -0,0 +1,146 @@
+shared_examples "subscriptions are not supported" do
+  describe "#supports_subscriptions?" do
+    it "returns false" do
+      expect(subject.supports_subscriptions?).to eq(false)
+    end
+  end
+
+  describe "#subscribe" do
+    it "raises an error" do
+      destination = double("destination")
+      consumer = lambda do |m| end
+      expect {
+        subject.subscribe(destination, &consumer)
+      }.to raise_error "#subscribe is not supported by #{subject.adapter.class}"
+    end
+  end
+end
+
+shared_examples "subscriptions are supported" do |subscription_type|
+  describe "#supports_subscriptions?" do
+    it "returns true" do
+      expect(subject.supports_subscriptions?).to eq(true)
+    end
+  end
+
+  let(:destination) { adapter_context.create_destination("subscriptions_example_queue") }
+
+  let(:message1) { "message 1" }
+  let(:message2) { "message 2" }
+  let(:messages) { [] }
+  let(:consumer) do
+    lambda do |msg|
+      messages << msg
+    end
+  end
+
+  describe "#subscribe" do
+    before do
+      if destination.respond_to? :purge
+        destination.purge
+      end
+    end
+
+    let(:subscription) { adapter_context.subscribe(destination, &consumer) }
+    after do
+      subscription.unsubscribe
+    end
+
+    it "returns a MessageDriver::Subscription::Base" do
+      expect(subscription).to be_a MessageDriver::Subscription::Base
+    end
+
+    context "the subscription" do
+      subject { subscription }
+
+      it { should be_a MessageDriver::Subscription::Base }
+      it { should be_a subscription_type }
+      its(:adapter) { should be adapter }
+      its(:destination) { should be destination }
+      its(:consumer) { should be consumer }
+
+      describe "#unsubscribe" do
+        it "makes it so messages don't go to the consumer any more" do
+          subscription.unsubscribe
+          expect {
+            destination.publish("should not be consumed")
+          }.to_not change{messages.size}
+        end
+      end
+    end
+
+    context "when there are already messages in the destination" do
+      before do
+        destination.publish(message1)
+        destination.publish(message2)
+      end
+
+      it "plays the messages into the consumer" do
+        expect {
+          subscription
+          pause_if_needed
+        }.to change{messages.size}.from(0).to(2)
+        bodies = messages.map(&:body)
+        expect(bodies).to include(message1)
+        expect(bodies).to include(message2)
+      end
+
+      it "removes the messages from the queue" do
+        pause_if_needed
+        expect {
+          subscription
+          pause_if_needed
+        }.to change{destination.message_count}.from(2).to(0)
+      end
+    end
+
+    context "when a message is published to the destination" do
+      before do
+        subscription
+      end
+
+      it "consumers the message into the consumer instead of putting them on the queue" do
+        expect {
+          expect {
+            subject.publish(destination, message1)
+            pause_if_needed
+          }.to change{messages.length}.from(0).to(1)
+        }.to_not change{destination.message_count}
+        expect(messages[0].body).to eq(message1)
+      end
+    end
+
+    context "when the consumer raises an error" do
+      let(:error) { RuntimeError.new("oh nos!") }
+      let(:consumer) do
+        lambda do |msg|
+          raise error
+        end
+      end
+
+      before do
+        destination.publish(message1)
+        destination.publish(message2)
+      end
+
+      it "keeps processing the messages" do
+        pause_if_needed
+        expect {
+          subscription
+          pause_if_needed
+        }.to change{destination.message_count}.from(2).to(0)
+      end
+
+      context "an error_handler is provided" do
+        let(:error_handler) { double(:error_handler, call: nil) }
+        let(:subscription) { adapter_context.subscribe(destination, error_handler: error_handler, &consumer) }
+
+        it "passes the errors and the messages to the error handler" do
+          subscription
+          pause_if_needed
+          expect(error_handler).to have_received(:call).with(error, kind_of(MessageDriver::Message::Base)).at_least(2).times
+        end
+      end
+    end
+  end
+end

data/spec/support/shared/transaction_examples.rb

@@ -0,0 +1,43 @@
+shared_examples "transactions are not supported" do
+  describe "#supports_transactions?" do
+    it "returns false" do
+      expect(subject.supports_transactions?).to eq(false)
+    end
+  end
+end
+
+shared_examples "transactions are supported" do
+  describe "#supports_transactions?" do
+    it "returns true" do
+      expect(subject.supports_transactions?).to eq(true)
+    end
+  end
+
+  it { should respond_to :begin_transaction }
+  it { should respond_to :commit_transaction }
+  it { should respond_to :rollback_transaction }
+  it { should respond_to :in_transaction? }
+
+  describe "#in_transaction?" do
+    it "returns false if you aren't in a transaction" do
+      expect(subject.in_transaction?).to eq(false)
+    end
+  end
+
+  it "raises a MessageDriver::TransactionError error if you begin two transactions" do
+    subject.begin_transaction
+    expect {
+      subject.begin_transaction
+    }.to raise_error MessageDriver::TransactionError
+  end
+  it "raises a MessageDriver::TransactionError error if you commit outside of a transaction" do
+    expect {
+      subject.commit_transaction
+    }.to raise_error MessageDriver::TransactionError
+  end
+  it "raises a MessageDriver::TransactionError error if you rollback outside of a transaction" do
+    expect {
+      subject.rollback_transaction
+    }.to raise_error MessageDriver::TransactionError
+  end
+end

data/spec/support/utils.rb

@@ -0,0 +1,14 @@
+module Utils
+  def pause_if_needed(seconds=0.1)
+    seconds *= 10 if ENV['CI'] == 'true'
+    case BrokerConfig.current_adapter
+    when :in_memory
+    else
+      sleep seconds
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Utils
+end

data/spec/units/message_driver/adapters/base_spec.rb

@@ -2,43 +2,62 @@ require 'spec_helper'
 
 module MessageDriver::Adapters
   describe Base do
-    class TestAdapter < described_class
+    class TestAdapter < Base
       def initialize(configuration)
-
-      end
-    end
-    subject { TestAdapter.new({}) }
-
-    describe "#publish" do
-      it "raises an error" do
-        expect {
-          subject.publish(:destination, {foo: "bar"})
-        }.to raise_error "Must be implemented in subclass"
       end
     end
+    subject(:adapter) { TestAdapter.new({}) }
 
-    describe "#pop_message" do
+    describe "#new_context" do
       it "raises an error" do
         expect {
-          subject.pop_message(:destination)
+          subject.new_context
         }.to raise_error "Must be implemented in subclass"
       end
     end
 
     describe "#stop" do
-      it "raises an error" do
+      it "raises an error", pending: "maybe we don't want to do this" do
         expect {
           subject.stop
         }.to raise_error "Must be implemented in subclass"
       end
     end
 
-    describe "#create_destination" do
-      it "raises an error" do
-        expect {
-          subject.create_destination("foo")
-        }.to raise_error "Must be implemented in subclass"
+    describe ContextBase do
+      class TestContext < ContextBase
       end
+      subject(:adapter_context) { TestContext.new(adapter) }
+
+      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
+        it "raises an error" do
+          expect {
+            subject.create_destination("foo")
+          }.to raise_error "Must be implemented in subclass"
+        end
+      end
+
+      describe "#publish" do
+        it "raises an error" do
+          expect {
+            subject.publish(:destination, {foo: "bar"})
+          }.to raise_error "Must be implemented in subclass"
+        end
+      end
+
+      describe "#pop_message" do
+        it "raises an error" do
+          expect {
+            subject.pop_message(:destination)
+          }.to raise_error "Must be implemented in subclass"
+        end
+      end
+
     end
   end
 end

data/spec/units/message_driver/broker_spec.rb

@@ -3,12 +3,16 @@ require 'message_driver/adapters/in_memory_adapter'
 
 module MessageDriver
   describe Broker do
-    subject(:broker) { described_class.new(adapter: :in_memory) }
+    let(:options) { { adapter: :in_memory } }
+    before do
+      described_class.configure(options)
+    end
+    subject(:broker) { described_class.instance }
 
     describe ".configure" do
       it "calls new, passing in the options and saves the instance" do
         options = {foo: :bar}
-        result = stub(described_class)
+        result = double(described_class)
         described_class.should_receive(:new).with(options).and_return(result)
 
         described_class.configure(options)
@@ -17,6 +21,24 @@ module MessageDriver
       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
+      end
+
+      context "configuring the logger" do
+        let(:logger) { double(Logger).as_null_object }
+        let(:options) { { adapter: :in_memory, logger: logger } }
+
+        it "returns the provided logger" do
+          actual = subject.logger
+          expect(actual).to be logger
+        end
+      end
+    end
+
     describe "#initialize" do
       it "raises an error if you don't specify an adapter" do
         expect {
@@ -62,23 +84,60 @@ module MessageDriver
       end
     end
 
-    describe "#publish" do
-      it "needs some real tests"
+    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
+
+    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
 
       context "when the destination can't be found" do
-        it "raises an error"
+        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
-    describe "#pop_message" do
-      it "needs some real tests"
 
-      context "when the destination can't be found" do
-        it "raises an error"
+    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
 
-    describe "#destination" do
-      it "needs some real tests"
+    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
 
     describe "#dynamic_destination" do
@@ -86,13 +145,7 @@ module MessageDriver
         destination = broker.dynamic_destination("my_queue", exclusive: true)
         expect(destination).to be_a MessageDriver::Destination::Base
       end
-      it "doesn't save the destination" do
-        destination = nil
-        expect {
-          destination = broker.dynamic_destination("my_queue", exclusive: true)
-        }.to_not change{broker.destinations.size}
-        expect(broker.destinations.values).to_not include(destination)
-      end
     end
+
   end
 end