cwyckoff-rosetta_queue 0.3.0 → 0.3.3

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', :on_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

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"}, :on_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}, :on_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