message-driver 0.1.0

data/lib/message_driver.rb

@@ -0,0 +1,18 @@
+require 'message_driver/version'
+
+require 'message_driver/exceptions'
+require 'message_driver/broker'
+require 'message_driver/message'
+require 'message_driver/destination'
+require 'message_driver/adapters/base'
+require 'message_driver/message_publisher'
+
+module MessageDriver
+  def self.configure(options={})
+    Broker.configure(options)
+  end
+
+  def self.stop
+    Broker.stop
+  end
+end

data/message-driver.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'message_driver/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "message-driver"
+  gem.version       = Message::Driver::VERSION
+  gem.authors       = ["Matt Campbell"]
+  gem.email         = ["matt@soupmatt.com"]
+  gem.description   = %q{Easy message queues for ruby using AMQ, STOMP and others}
+  gem.summary       = %q{Easy message queues for ruby}
+  gem.homepage      = "https://github.com/soupmatt/message_driver"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.required_ruby_version = '>= 1.9.2'
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec", "~> 2.13.0"
+  gem.add_development_dependency "cucumber"
+  gem.add_development_dependency "bunny", "~> 0.9.0.pre7"
+end

data/spec/integration/amqp_integration_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe "AMQP Integration", :bunny, type: :integration do
+  before do
+    MessageDriver.configure BrokerConfig.config
+  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|
+        expect(err.queue_name).to eq(queue_name)
+        expect(err.other).to be_a Bunny::NotFound
+      end
+    end
+  end
+
+  context "when a channel level exception occurs" do
+    it "raises a MessageDriver::WrappedException 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 }
+    end
+
+    it "reestablishes the channel transparently" do
+      expect {
+        MessageDriver::Broker.dynamic_destination("not.a.queue", passive: true)
+      }.to raise_error(MessageDriver::WrappedException)
+      expect {
+        MessageDriver::Broker.dynamic_destination("", exclusive: true)
+      }.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::Broker.with_transaction do
+          expect {
+            MessageDriver::Broker.dynamic_destination("not.a.queue", passive: true)
+          }.to raise_error(MessageDriver::WrappedException)
+          expect {
+            MessageDriver::Broker.dynamic_destination("", exclusive: true)
+          }.to raise_error(MessageDriver::TransactionRollbackOnly)
+        end
+        expect {
+          MessageDriver::Broker.dynamic_destination("", exclusive: true)
+        }.to_not raise_error
+      end
+    end
+  end
+
+  context "when the broker connection fails" do
+    after(:each) do
+      MessageDriver::Broker.stop
+    end
+    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)
+      disrupt_connection
+      expect {
+        dest.publish("Reconnection Test")
+      }.to raise_error(MessageDriver::ConnectionException) do |err|
+        expect(err.other).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)
+      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::ConnectionException" do
+        expect {
+          MessageDriver::Broker.with_transaction do
+            disrupt_connection
+            MessageDriver::Broker.dynamic_destination("", exclusive: true)
+          end
+        }.to raise_error(MessageDriver::ConnectionException)
+      end
+
+      it "sets the channel_context as rollback-only until the transaction is finished" do
+        MessageDriver::Broker.with_transaction do
+          disrupt_connection
+          expect {
+            MessageDriver::Broker.dynamic_destination("", exclusive: true)
+          }.to raise_error(MessageDriver::ConnectionException)
+          expect {
+            MessageDriver::Broker.dynamic_destination("", exclusive: true)
+          }.to raise_error(MessageDriver::TransactionRollbackOnly)
+        end
+        expect {
+          MessageDriver::Broker.dynamic_destination("", exclusive: true)
+        }.to_not raise_error
+      end
+    end
+  end
+
+  context "when an unhandled expection occurs in a transaction" do
+    let(:destination) { MessageDriver::Broker.dynamic_destination("", exclusive: true) }
+
+    it "rolls back the transaction" do
+      expect {
+        MessageDriver::Broker.with_transaction do
+          destination.publish("Test Message")
+          raise "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 {
+        MessageDriver::Broker.with_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
+        destination.publish("Test Message 2")
+      end
+
+      msg = destination.pop_message
+      expect(msg).to_not be_nil
+      expect(msg.body).to eq("Test Message 2")
+    end
+  end
+end

data/spec/integration/message_driver/adapters/bunny_adapter_spec.rb

@@ -0,0 +1,301 @@
+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::Exception, "bunny 0.9.0.pre7 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.pre6).each do |v|
+          context "bunny version #{v}" do
+            let(:version) { v }
+            include_examples "raises an error"
+          end
+        end
+        %w(0.9.0.pre7 0.9.0.rc1 0.9.0 0.9.1).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
+
+      it "forces bunny into non-threaded mode" do
+        #FIXME can be changed once ruby-amqp/bunny#112 is fixed
+        adapter = described_class.new(valid_connection_attrs)
+        expect(adapter.connection(false).threaded).to be_false
+
+        adapter = described_class.new(valid_connection_attrs.merge(threaded: true))
+        expect(adapter.connection(false).threaded).to be_false
+      end
+    end
+
+    shared_context "a connected adapter" do
+      let(:adapter) { described_class.new(valid_connection_attrs) }
+      let(:connection) { adapter.connection }
+
+      after do
+        connection.close
+      end
+    end
+
+    shared_context "with a queue" do
+      include_context "a connected adapter"
+
+      let(:channel) { connection.create_channel }
+      let(:tmp_queue_name) { "my_temp_queue" }
+      let(:tmp_queue) { channel.queue(tmp_queue_name, exclusive: true) }
+    end
+
+    describe "#pop_message" do
+      include_context "with a queue"
+      it "needs some real tests"
+    end
+
+    describe "#create_destination" do
+      include_context "a connected adapter"
+
+      context "with defaults" do
+        context "the resulting destination" do
+          let(:dest_name) { "my_dest" }
+          subject(:result) { adapter.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.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.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.create_destination("amq.direct", type: :exchange) }
+
+          it "raises an exception if you don't provide a source" do
+            expect {
+              adapter.create_destination("bad_bind_queue", type: :queue, exclusive: true, bindings: [{args: {routing_key: "test_exchange_bind"}}])
+            }.to raise_error MessageDriver::Exception, /must provide a source/
+          end
+
+          it "routes message to the queue through the exchange" do
+            destination = adapter.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.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.create_destination("", no_declare: true, type: :queue, exclusive: true)
+              }.to raise_error MessageDriver::Exception, "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.create_destination("tmp_queue", no_declare: true, bindings: [{source: "amq.fanout"}], type: :queue, exclusive: true)
+              }.to raise_error MessageDriver::Exception, "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.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::Exception, "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.create_destination(dest_name, type: :exchange, declare: {type: :fanout, auto_delete: true})
+            queue = adapter.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.create_destination(dest_name, type: :exchange, declare: {auto_delete: true})
+            }.to raise_error MessageDriver::Exception, /you must provide a valid exchange type/
+          end
+
+        end
+
+        context "and bindings are provided" do
+          let(:dest_name) { "binding_exchange_queue" }
+          let(:exchange) { adapter.create_destination("amq.direct", type: :exchange) }
+
+          it "raises an exception if you don't provide a source" do
+            expect {
+              adapter.create_destination("amq.fanout", type: :exchange, bindings: [{args: {routing_key: "test_exchange_bind"}}])
+            }.to raise_error MessageDriver::Exception, /must provide a source/
+          end
+
+          it "routes message to the queue through the exchange" do
+            adapter.create_destination("amq.fanout", type: :exchange, bindings: [{source: "amq.direct", args: {routing_key: "test_exchange_bind"}}])
+            destination = adapter.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
+          before do
+            connection.stop
+          end
+
+          it "doesn't cause a connection to the broker" do
+            adapter.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.create_destination("my_dest", type: :foo_bar)
+          }.to raise_error MessageDriver::Exception, "invalid destination type #{:foo_bar}"
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'message_driver'
+
+require File.join(File.dirname(__FILE__), '..', 'test_lib', 'broker_config')
+
+Dir["./spec/support/**/*.rb"].sort.each {|f| require f}
+
+RSpec.configure do |c|
+  c.treat_symbols_as_metadata_keys_with_true_values = true
+  c.order = 'random'
+  c.filter_run :focus
+
+  c.reporter.message("Acceptance Tests running with broker config: #{BrokerConfig.config}")
+
+  c.filter_run_excluding :no_travis if ENV['TRAVIS']=='true' && ENV['ADAPTER']=='bunny'
+  if c.inclusion_filter[:all_adapters] == true
+    c.filter_run BrokerConfig.current_adapter
+  else
+    c.run_all_when_everything_filtered = true
+  end
+end

data/spec/support/shared/destination_examples.rb

@@ -0,0 +1,41 @@
+shared_examples "a destination" do
+  describe "#pop_message" do
+    let(:body) { "The message body" }
+    let(:headers) { { "foo" => "bar", "bar" => "baz"} }
+    let(:properties) { {persistent: true, client_ack: true} }
+
+    before do
+      destination.publish(body, headers, properties)
+    end
+
+    context "the result" do
+      let!(:message) { destination.pop_message }
+      subject { message }
+
+      it { should be_a MessageDriver::Message::Base }
+      its(:body) { should eq(body) }
+      its(:headers) { should eq(headers) }
+      its(:properties) { should_not be_nil }
+    end
+  end
+end
+
+shared_examples "doesn't support #message_count" do
+  describe "#message_count" do
+    it "raises an error" do
+      expect {
+        destination.message_count
+      }.to raise_error "#message_count is not supported by #{destination.class}"
+    end
+  end
+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
+    expect {
+      destination.publish("msg1")
+      destination.publish("msg2")
+    }.to change{destination.message_count}.by(2)
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+module MessageDriver::Adapters
+  describe Base do
+    class TestAdapter < described_class
+      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
+
+    describe "#pop_message" do
+      it "raises an error" do
+        expect {
+          subject.pop_message(:destination)
+        }.to raise_error "Must be implemented in subclass"
+      end
+    end
+
+    describe "#stop" do
+      it "raises an error" 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"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+require 'message_driver/adapters/in_memory_adapter'
+
+module MessageDriver::Adapters
+  describe InMemoryAdapter do
+    let(:adapter) { described_class.new }
+
+    describe "#create_destination" do
+      describe "the resulting destination" do
+        let!(:destination) { adapter.create_destination("my_test_dest") }
+        it_behaves_like "a destination"
+
+        subject { destination }
+
+        it { should be_a InMemoryAdapter::Destination }
+
+        include_examples "supports #message_count"
+      end
+    end
+
+    describe "#reset_after_tests" do
+      #make some destinations
+      # throw some messages on it
+      # assert the messages are in the destinations
+      # empty the queues on each destination via method
+      # assert destinations are empty
+
+      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.pop_message).to be_nil
+        end
+      end
+    end
+  end
+end