rosetta_queue 0.4.0

data/spec/rosetta_queue/adapter_spec.rb

@@ -0,0 +1,101 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module RosettaQueue
+
+  describe Adapter do
+
+    before(:each) do
+      @stomp_adapter = mock("Gateway::StompAdapter")
+      Adapter.reset
+    end
+
+    describe ".reset" do
+      it "should clear all definitions" do
+        Adapter.define { |a| a.type = "null"  }
+        Adapter.instance.should be_instance_of(RosettaQueue::Gateway::NullAdapter)
+        Adapter.reset
+        running { Adapter.instance }.should raise_error(AdapterException)
+      end
+    end
+
+    describe ".type=" do
+
+      it "should raise error when adapter does not exist" do
+        running {
+          Adapter.define do |a|
+            a.type = "foo"
+          end
+          }.should raise_error(AdapterException)
+      end
+
+    end
+
+    describe "adapter not type set" do
+      it "should raise an error when .instance is called" do
+        # given
+        Adapter.define { |a|  }
+        # then & when
+        running { Adapter.instance }.should raise_error(AdapterException)
+      end
+    end
+
+    describe "adapter type set" do
+
+      before(:each) do
+        Adapter.define { |a| a.type = "null" }
+      end
+
+      it "should return adapter instance" do
+        Adapter.instance.class.should == RosettaQueue::Gateway::NullAdapter
+      end
+
+    end
+
+    describe "adapter instantiation" do
+
+      before(:each) do
+        Adapter.define do |a|
+          a.user = "foo"
+          a.password = "bar"
+          a.host = "localhost"
+          a.port = "9000"
+          a.type = "fake"
+        end
+      end
+
+      def do_process
+        Adapter.instance
+      end
+
+      it "should set opts as an empty has unless variable is set" do
+        during_process {
+          RosettaQueue::Gateway::FakeAdapter.should_receive(:new).with({:user => "foo", :password => "bar", :host => "localhost", :port => "9000", :opts => {}})
+        }
+      end
+
+      describe "when setting options" do
+        before(:each) do
+          Adapter.define { |a| a.options = {:vhost => "baz"} }
+        end
+
+        it "should map adapter_settings to a hash" do
+          during_process {
+            RosettaQueue::Gateway::FakeAdapter.should_receive(:new).with({:user => "foo", :password => "bar", :host => "localhost", :port => "9000", :opts => {:vhost => "baz"}})
+          }
+        end
+      end
+
+      describe "setting options incorrectly (options should always be set as a Hash)" do
+
+        before(:each) do
+          Adapter.define { |a| a.options = "baz" }
+        end
+
+        it "should raise an adapter exception" do
+          running { Adapter.instance }.should raise_error("Adapter options should be a hash")
+        end
+      end
+
+    end
+  end
+end

data/spec/rosetta_queue/adapters/amqp_synchronous_spec.rb

@@ -0,0 +1,277 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/shared_adapter_behavior'
+require File.dirname(__FILE__) + '/shared_fanout_behavior'
+
+begin
+  require 'rosetta_queue/adapters/amqp_synch'
+rescue LoadError => ex
+  if ex.message =~ /bunny/i
+    warn "--WARNING-- Skipping all of tha AmqpSynchAdapter code examples since bunny is not present. Install bunny if you need to be testing this adapter!"
+  else
+    raise ex
+  end
+end
+
+if defined? Bunny
+
+module RosettaQueue::Gateway
+
+  describe "an exchange", :shared => true do
+
+    describe "#do_exchange" do
+
+      it "should delegate message handling to the message handler" do
+        when_receiving_exchange {
+          @handler.should_receive(:handle_message).with("Hello World!")
+        }
+      end
+    end
+  end
+
+  describe "AmqpSynch adapter and components" do
+
+    before(:each) do
+      RosettaQueue.logger.stub!(:info)
+      @msg = "Hello World!"
+      @adapter = AmqpSynchAdapter.new({:user => "foo", :password => "bar", :host => "localhost"})
+      @handler = mock("handler", :handle_message => true, :destination => :foo, :options_hash => {:durable => true})
+    end
+
+    describe AmqpSynchAdapter do
+
+      before(:each) do
+        @exchange_strategy = mock('DirectExchange', :receive_once => @msg, :receive => @msg, :send_message => true)
+        SynchExchange::DirectExchange.stub!(:new).and_return(@exchange_strategy)
+      end
+
+      it_should_behave_like "an adapter"
+
+      describe "#receive_once" do
+
+        def do_receiving_once
+          @adapter.receive_once("queue.foo", {:durable => false})
+        end
+
+        it "should pass destination and options to exchange strategy" do
+          when_receiving_once {
+            @exchange_strategy.should_receive(:receive_once).with("queue.foo")
+          }
+        end
+
+      end
+
+      describe "#receive_with" do
+
+        def do_receiving_with_handler
+          @adapter.receive_with(@handler)
+        end
+
+        before(:each) do
+          @handler = mock("handler", :handle_message => true, :destination => :foo, :options_hash => {:durable => true })
+        end
+
+        it "should pass message handler to exchange strategy" do
+          when_receiving_with_handler {
+            @exchange_strategy.should_receive(:receive).with("foo", @handler)
+          }
+        end
+
+      end
+
+      describe "#send_message" do
+
+        it "should pass message handler to exchange strategy" do
+          when_publishing {
+            @exchange_strategy.should_receive(:publish).with('queue', 'message')
+          }
+        end
+
+      end
+    end
+
+
+    describe SynchExchange::DirectExchange do
+
+      before(:each) do
+        @queue = mock("Bunny::Queue", :pop => @msg, :publish => true, :unsubscribe => true)
+        Bunny.stub!(:new).and_return(@conn = mock("Bunny::Client", :queue => @queue, :exchange => @exchange, :status => :connected, :stop => nil))
+        @queue.stub!(:subscribe).and_yield(@msg)
+        @handler = mock("handler", :handle_message => true, :destination => :foo)
+        @exchange = SynchExchange::DirectExchange.new({:user => 'user', :password => 'pass', :host => 'host', :opts => {:vhost => "foo"}})
+      end
+
+
+      def do_receiving_exchange
+        @exchange.receive("queue.foo", @handler)
+      end
+
+      it_should_behave_like "an exchange"
+
+      describe "#receive_once" do
+
+        def do_receiving_single_exchange
+          @exchange.receive_once("queue.foo") { |msg| }
+
+        end
+
+        it "should return the message from the connection" do
+          @exchange.receive_once("queue.foo") do |msg|
+              msg.should == @msg
+          end
+        end
+
+        it "should subscribe to queue" do
+          when_receiving_single_exchange {
+            @queue.should_receive(:pop)
+          }
+        end
+
+      end
+
+      describe "#receive" do
+
+        it "should subscribe to queue" do
+          when_receiving_exchange {
+            @queue.should_receive(:subscribe).and_yield(@msg)
+          }
+        end
+
+      end
+
+
+      describe "#publish" do
+
+        def do_publishing
+          @exchange.publish('queue.foo', 'message')
+        end
+
+        it "should instantiate queue" do
+          when_publishing {
+            @conn.should_receive(:queue).and_return(@queue)
+          }
+        end
+
+        it "should publish message to queue" do
+          when_publishing {
+            @conn.queue.should_receive(:publish).with("message", {})
+          }
+        end
+
+      end
+
+    end
+
+
+    describe SynchExchange::FanoutExchange do
+
+      before(:each) do
+        @exchange = SynchExchange::FanoutExchange.new({:user => 'user', :password => 'pass', :host => 'host', :opts => {:vhost => 'foo'}})
+        @queue = mock("Bunny::Queue", :pop => @msg, :bind => @bound_queue = mock("Bunny::Queue", :pop => @msg), :publish => true, :unbind => true)
+        Bunny.stub!(:new).and_return(@conn = mock("Bunny::Client", :queue => @queue, :exchange => @exchange, :status => :connected))
+        @queue.stub!(:subscribe).and_yield(@msg)
+        @handler = mock("handler", :handle_message => true, :destination => :foo, :options => {:durable => false})
+      end
+
+      def do_receiving_exchange
+        @exchange.receive("topic.foo", @handler)
+      end
+
+      it_should_behave_like "an exchange"
+
+      describe "#receive_once" do
+
+        def do_receiving_exchange
+          @exchange.receive_once("topic.foo") { |msg| }
+        end
+
+        it_should_behave_like "a fanout exchange adapter"
+
+        it "should return the message from the connection" do
+          @exchange.receive_once("topic.foo") do |msg|
+            msg.should == @msg
+          end
+        end
+
+        it "should subscribe to queue" do
+          when_receiving_exchange {
+            @queue.should_receive(:pop)
+          }
+        end
+
+        it "should unbind queue from exchange" do
+          pending
+          when_receiving_single_exchange {
+            @queue.should_receive(:unbind)
+          }
+        end
+
+      end
+
+      describe "#receive" do
+
+        it_should_behave_like "a fanout exchange adapter"
+
+        it "should forward the message body onto the handler" do
+          when_receiving_exchange {
+            @handler.should_receive(:handle_message).with("Hello World!")
+          }
+        end
+
+        it "should subscribe to queue" do
+          when_receiving_exchange {
+            @queue.should_receive(:subscribe).and_yield(@msg)
+          }
+        end
+
+      end
+
+      # describe "#publish_to_exchange" do
+      #
+      #   def do_publishing
+      #     @exchange.publish_to_exchange('/queue/foo', 'message', {:durable => false})
+      #   end
+      #
+      #   it "should instantiate queue" do
+      #     when_publishing {
+      #       @channel.should_receive(:queue).and_return(@queue)
+      #     }
+      #   end
+      #
+      #   it "should publish message to queue" do
+      #     when_publishing {
+      #       @channel.queue.should_receive(:publish).with('message')
+      #     }
+      #   end
+      #
+      #   it "should stop event loop" do
+      #     when_publishing {
+      #       EM.should_receive(:stop_event_loop)
+      #     }
+      #   end
+      # end
+
+#       describe SynchExchange::AmqpAdapterProxy do
+
+#         before(:each) do
+#           @queue = mock("Queue", :ack => nil)
+#           @proxy = SynchExchange::AmqpAdapterProxy.new(@queue)
+#         end
+
+#         context "#ack" do
+
+#           it "should delegate to AMQP queue object" do
+#             # expect
+#             @queue.should_receive(:ack)
+
+#             # when
+#             @proxy.ack
+#           end
+
+#         end
+#       end
+
+    end
+  end
+end
+
+end # for Guard up top to prevent this spec from running if Bunny not loaded from amqp_synch

data/spec/rosetta_queue/adapters/beanstalk_spec.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/shared_adapter_behavior'
+require 'rosetta_queue/adapters/beanstalk'
+
+module RosettaQueue
+  module Gateway
+
+    describe BeanstalkAdapter do
+
+      before(:each) do
+        @msg = "Hello World!"
+        @handler = mock('handler', :handle_message => "", :destination => :foo)
+        @msg_obj = mock("message", :body => @msg, :delete => true)
+        @conn = mock("Beanstalk::Pool", :put => true, :reserve => @msg_obj)
+        ::Beanstalk::Pool.stub!(:new).and_return(@conn)
+        @adapter = BeanstalkAdapter.new({:host => "host", :port => "port"})
+        @adapter.stub!(:running).and_yield
+      end
+
+      it_should_behave_like "an adapter"
+
+      describe "#receive_once" do
+        def do_receiving_once
+          @adapter.receive_once
+        end
+
+        it "should delete messages once received" do
+          when_receiving_once {
+            @msg_obj.should_receive(:delete)
+          }
+        end
+      end
+
+      describe "#receive" do
+        def do_receiving
+          @adapter.receive
+        end
+
+        it "should delete message during receive" do
+          when_receiving {
+            @msg_obj.should_receive(:delete)
+          }
+        end
+      end
+    end
+  end
+end

data/spec/rosetta_queue/adapters/fake_spec.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'rosetta_queue/adapters/fake'
+
+module RosettaQueue
+  module Gateway
+
+    describe FakeAdapter do
+
+      describe "#queues" do
+        it "should return all the queues that messages were delivered to" do
+          # given
+          adapter = FakeAdapter.new
+          adapter.send_message('queue 1', 'message 1', 'headers 1')
+          adapter.send_message('queue 2', 'message 2', 'headers 2')
+          # then
+          adapter.queues.should == ['queue 1', 'queue 2']
+        end
+      end
+
+      describe "#messages_sent_to" do
+
+        it "should return the message bodies that were delivered to the specified queue" do
+          # given
+          adapter = FakeAdapter.new
+          adapter.send_message('queue 1', 'message 1', 'headers 1')
+          adapter.send_message('queue 2', 'message 2', 'headers 2')
+          adapter.send_message('queue 1', 'message 3', 'headers 3')
+          # when
+          results = adapter.messages_sent_to('queue 1')
+          # then
+          results.should == ['message 1', 'message 3']
+        end
+
+        it "should return the bodies of the messages after they have been filtered" do
+          # given
+          adapter = FakeAdapter.new
+          # expect
+          ::RosettaQueue::Filters.should_receive(:process_receiving).with('message').and_return("Filtered Message")
+          # when
+          adapter.send_message('queue', 'message', 'headers')
+          # then
+          adapter.messages_sent_to('queue').should == ['Filtered Message']
+        end
+
+        it "should return all the message's bodies when nil is passed in at the queue" do
+          # given
+          adapter = FakeAdapter.new
+          adapter.send_message('queue 1', 'message 1', 'headers 1')
+          adapter.send_message('queue 2', 'message 2', 'headers 2')
+          # when
+          results = adapter.messages_sent_to(nil)
+          # then
+          results.should == ['message 1', 'message 2']
+        end
+
+        it "should return an empty array when no messages have been delivered" do
+          # given
+          adapter = FakeAdapter.new
+          adapter.send_message('queue 1', 'message 1', 'headers 1')
+          # when
+          results = adapter.messages_sent_to('queue 2')
+          # then
+          results.should == []
+        end
+
+      end
+
+    end
+
+  end
+
+end