rosetta_queue 0.4.0

data/spec/rosetta_queue/adapters/null_spec.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'rosetta_queue/adapters/null'
+
+module RosettaQueue
+  module Gateway
+
+
+    describe NullAdapter do
+
+      def null_adapter
+        NullAdapter.new({:user => 'user', :password => 'password', :host => 'host', :port => 'port'})
+      end
+
+      %w[disconnect receive receive_with send_message subscribe unsubscribe].each do |adapter_method|
+        it "should respond to ##{adapter_method}" do
+          null_adapter.should respond_to(adapter_method)
+        end
+      end
+
+      it "should raise an error when #receive is called" do
+        running { null_adapter.receive }.should raise_error
+      end
+
+      it "should raise an error when #receive_with is called" do
+        running { null_adapter.receive_with('consumer') }.should raise_error
+      end
+
+    end
+
+  end
+end

data/spec/rosetta_queue/adapters/shared_adapter_behavior.rb

@@ -0,0 +1,38 @@
+module RosettaQueue
+  module Gateway
+
+    describe "an adapter", :shared => true do
+
+      before(:each) do
+        ::RosettaQueue::Destinations.stub!(:lookup).and_return("foo")
+      end
+
+      def do_publishing
+        @adapter.send_message('queue', 'message', 'options')
+      end
+
+      def do_receiving_with_handler
+        @adapter.receive_with(@handler)
+      end
+
+      describe "#receive_once" do
+
+        it "should return the message from the connection" do
+          @adapter.receive_once("foo", {:persistent => false}).should == @msg
+        end
+
+      end
+
+      describe "#receive_with" do
+
+        it "should look up the destination defined on the class" do
+          when_receiving_with_handler {
+            Destinations.should_receive(:lookup).with(:foo).and_return("foo")
+          }
+        end
+
+      end
+
+    end
+  end
+end

data/spec/rosetta_queue/adapters/shared_fanout_behavior.rb

@@ -0,0 +1,20 @@
+module RosettaQueue
+  module Gateway
+
+    describe "a fanout exchange adapter", :shared => true do
+
+#       it "should discover fanout name for destation" do
+#         when_receiving_exchange {
+#           @channel.should_receive(:fanout).with(@exchange).and_return(@bound_queue)
+#         }
+#       end
+
+      it "should bind to fanout exchange" do
+        when_receiving_exchange {
+          @queue.should_receive(:bind).with(@exchange).and_return(@bound_queue)
+        }
+      end
+
+    end
+  end
+end

data/spec/rosetta_queue/adapters/stomp_spec.rb

@@ -0,0 +1,126 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/shared_adapter_behavior'
+require 'rosetta_queue/adapters/stomp'
+
+module RosettaQueue
+  module Gateway
+
+    describe StompAdapter do
+
+      before(:each) do
+        @msg = "Hello World!"
+        @handler = mock('handler', :destination => :foo, :options_hash => {:persistent => false, :ack => "client"}, :handle_message => "")
+        @msg_obj = mock("message", :body => @msg, :headers => {"message-id" => 2})
+        @conn = mock("Stomp::Connection", :ack => true, :send => true, :subscribe => true, :receive => @msg_obj, :unsubscribe => true, :disconnect => true)
+        ::Stomp::Connection.stub!(:open).and_return(@conn)
+        @adapter = StompAdapter.new({:user => "user", :password => "password", :host => "host", :port => "port"})
+        @adapter.stub!(:running).and_yield
+      end
+
+      it_should_behave_like "an adapter"
+
+      describe "#send_message" do
+        it "should delegate to the connection" do
+          # need this hack since the stomp client overrides #send
+          def @conn.send(*args)
+            @args = args
+          end
+          def @conn.sent_args ; @args  end
+
+          after_publishing {
+            @conn.sent_args.should == ['queue', 'message', 'options']
+          }
+        end
+      end
+
+      describe "#receive_once" do
+
+        def do_receiving_once
+          @adapter.receive_once("/queue/foo", {:persistent => false})
+        end
+
+        it "should subscribe to queue" do
+          when_receiving_once {
+            @conn.should_receive("subscribe").with("/queue/foo", {:persistent => false})
+          }
+        end
+
+        it "should unsubscribe from queue" do
+          when_receiving_once {
+            @conn.should_receive("unsubscribe").with("/queue/foo")
+          }
+        end
+      end
+
+      describe "#receive_with" do
+
+        it "should subscribe to queue defined by the class with the options defined on the class" do
+          when_receiving_with_handler {
+            @conn.should_receive("subscribe").with('foo', :persistent => false, :ack => "client")
+          }
+        end
+
+        it "should acknowledge client" do
+          when_receiving_with_handler {
+            @conn.should_receive(:ack)
+          }
+        end
+
+        describe "no ack" do
+
+          before(:each) do
+            @handler = mock('handler', :destination => :foo, :options_hash => {:persistent => false}, :handle_message => "")
+          end
+
+          it "should not acknowledge client" do
+            when_receiving_with_handler {
+              @conn.should_not_receive(:ack)
+            }
+          end
+
+        end
+      end
+
+      describe "disconnect" do
+
+        def do_disconnecting
+          @adapter.disconnect(@handler)
+        end
+
+        it "should unsubscribe connection" do
+          when_disconnecting {
+            @conn.should_receive("unsubscribe").with("foo")
+          }
+        end
+
+        it "should disconnect connection" do
+          when_disconnecting {
+            @conn.should_receive("disconnect")
+          }
+        end
+
+      end
+
+      describe StompAdapterProxy do
+
+        before(:each) do
+          @adapter = mock("StompAdapter", :ack => nil)
+          @proxy = StompAdapterProxy.new(@adapter, "foo")
+        end
+
+        context "#ack" do
+
+          it "should delegate to AMQP queue object" do
+            # expect
+            @adapter.should_receive(:ack).with("foo")
+
+            # when
+            @proxy.ack
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/spec/rosetta_queue/consumer_managers/evented_spec.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/shared_manager_behavior'
+
+module RosettaQueue
+
+  describe EventedManager do
+
+    before(:each) do
+      Stomp::Connection.stub!(:open).and_return(nil)
+      @consumer = mock("test_consumer_1", :receive => true,
+                                          :connection => mock("AmqpAdapter", :subscribe => true, :unsubscribe => nil, :disconnect => nil),
+                                          :unsubscribe => true, :disconnect => true)
+      Consumer.stub!(:new).and_return(@consumer)
+      @manager = EventedManager.new
+      @manager.add(@message_handler = mock("message_handler", :destination => "/queue/foo", :option_hash => {}))
+    end
+
+    it_should_behave_like "a consumer manager"
+
+    describe "running" do
+
+      before(:each) do
+        EM.stub!(:run).and_yield
+      end
+
+      describe "starting" do
+
+        def do_process
+          @manager.start
+        end
+
+        it "should start consumers" do
+          during_process {
+            @manager.consumers.each_value { |cons| cons.should_receive(:receive) }
+          }
+        end
+
+      end
+
+      describe "stopping" do
+
+        def do_process
+          @manager.stop
+        end
+
+        it "should stop consumers" do
+          during_process {
+            EM.should_receive(:stop)
+          }
+        end
+
+      end
+
+    end
+  end
+end

data/spec/rosetta_queue/consumer_managers/shared_manager_behavior.rb

@@ -0,0 +1,26 @@
+module RosettaQueue
+
+  describe "a consumer manager", :shared => true do
+
+    def do_process
+      @manager.start
+    end
+
+    describe ".add" do
+
+      def do_process
+        @manager.add(@message_handler)
+      end
+
+      it "should load message_handler into consumer" do
+        during_process { Consumer.should_receive(:new).with(@message_handler) }
+      end
+
+      it "should allow user to add new consumers" do
+        @manager.consumers.size.should == 1
+      end
+
+    end
+
+  end
+end

data/spec/rosetta_queue/consumer_managers/threaded_spec.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/shared_manager_behavior'
+
+module RosettaQueue
+  describe ThreadedManager do
+
+    before(:each) do
+      @mutex = mock("Mutex")
+      @mutex.stub!(:synchronize).and_yield
+      Mutex.stub!(:new).and_return(@mutex)
+      Stomp::Connection.stub!(:open).and_return(nil)
+      @consumer = mock("test_consumer_1", :receive => true, :connection => mock("StompAdapter", :subscribe => true, :unsubscribe => nil, :disconnect => nil),
+                                          :unsubscribe => true, :disconnect => true)
+      Consumer.stub!(:new).and_return(@consumer)
+      @manager = ThreadedManager.new
+      @manager.add(@message_handler = mock("message_handler", :destination => "/queue/foo", :option_hash => {}))
+    end
+
+    it_should_behave_like "a consumer manager"
+
+    describe "threading" do
+
+      before do
+        @manager.stub!(:join_threads)
+        @manager.stub!(:monitor_threads)
+        # we stub brackets because we check a Thread variable
+        @thread = mock(Thread, :kill => nil, :alive? => true, :[] => false)
+        Thread.stub!(:new).and_return(@thread)
+      end
+
+      it "should load subscriptions into threads on start" do
+        during_process {Thread.should_receive(:new).with(:"spec/mocks/mock", @consumer).and_return(@thread)}
+      end
+
+      describe "shutting down" do
+
+        def do_process
+          @manager.start
+          @manager.stop
+        end
+
+        it "should shut threaded subscriptions down on stop" do
+          during_process do
+            @consumer.should_receive(:disconnect)
+            @thread.should_receive(:kill)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rosetta_queue/consumer_spec.rb

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module RosettaQueue
+  describe Consumer do
+
+    class TestConsumer
+      include MessageHandler
+
+      subscribes_to :test_queue
+      options :persistent => false, :ack => "client"
+
+      def on_message(msg)
+
+      end
+    end
+
+    before(:each) do
+      @message  = mock("message", "headers" => "foo", "body" => "message body")
+      @adapter  = mock("adpater", :subscribe => true, :unsubscribe => true, :disconnect => true, :receive_with => TestConsumer.new,
+                                  :receive_once => @message.body, :ack => true)
+      Adapter.stub!(:instance).and_return(@adapter)
+      Destinations.stub!(:lookup).and_return("/queue/foo")
+    end
+
+    it_should_behave_like "a messaging gateway object"
+
+    attr_reader :adapter
+    def gateway
+      @gateway ||= Consumer.new(TestConsumer.new)
+    end
+
+    describe "#receive" do
+      before(:each) do
+        @consumer = Consumer.new( @message_handler = TestConsumer.new)
+      end
+
+      def when_receiving
+        yield if block_given?
+        @consumer.receive
+      end
+
+      it "should pass message handler onto the adpater with #receive" do
+        when_receiving {
+          @adapter.should_receive("receive_with").with(@message_handler)
+        }
+      end
+    end
+
+
+    describe ".delete" do
+
+      before(:each) do
+        @adapter.stub!(:delete)
+        Destinations.stub!(:lookup).and_return("/queue/foo")
+      end
+
+      it "should look up the destination" do
+        # expect
+        Destinations.should_receive(:lookup).with(:test_queue_passed_in).and_return("/queue/foo")
+
+        # when
+        Consumer.delete(:test_queue_passed_in)
+      end
+
+      it "should delegate to the adapter" do
+        # expect
+        @adapter.should_receive(:delete).with("/queue/foo", {})
+
+        # when
+        Consumer.delete(:test_queue_passed_in)
+      end
+    end
+
+    describe ".receive" do
+
+      def when_receiving
+        yield if block_given?
+        Consumer.receive(:test_queue_passed_in, {:persistent => false})
+      end
+
+      it "should look up the destination" do
+        when_receiving {
+          Destinations.should_receive(:lookup).with(:test_queue_passed_in).and_return("/queue/foo")
+        }
+      end
+
+      it "should pass destination and options to adapter" do
+        when_receiving {
+          @adapter.should_receive(:receive_once).with("/queue/foo", {:persistent => false}).and_return(@message)
+        }
+      end
+
+      it "should return the body of the message received" do
+        Consumer.receive(:test_queue, {:persistent => false}).should == @message.body
+      end
+    end
+
+  end
+end