bmabey-rosetta_queue 0.1.3 → 0.2.0

data/spec/rosetta_queue/adapters/{amqp_spec.rb → amqp_synchronous_spec.rb}

@@ -1,14 +1,25 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 require File.dirname(__FILE__) + '/shared_adapter_behavior'
 require File.dirname(__FILE__) + '/shared_fanout_behavior'
-require 'rosetta_queue/adapters/amqp'
+
+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 filter the message and forward it to the handler" do
         when_receiving_exchange {
           ::RosettaQueue::Filters.should_receive(:process_receiving).with(@msg).and_return("Filtered Message")
@@ -18,20 +29,20 @@ module RosettaQueue::Gateway
     end
   end
 
-  describe "Amqp adapter and components" do
+  describe "AmqpSynch adapter and components" do
 
     before(:each) do
       RosettaQueue.logger.stub!(:info)
       @msg = "Hello World!"
-      @adapter = AmqpAdapter.new("foo", "bar", "localhost")
-      @handler = mock("handler", :on_message => true, :destination => :foo)
+      @adapter = AmqpSynchAdapter.new({:user => "foo", :password => "bar", :host => "localhost"})
+      @handler = mock("handler", :on_message => true, :destination => :foo, :options_hash => {:durable => true})
     end
-    
-    describe AmqpAdapter do
+
+    describe AmqpSynchAdapter do
 
       before(:each) do
-        @exchange_strategy = mock('DirectExchange', :do_single_exchange => @msg, :do_exchange => @msg, :send_message => true)
-        DirectExchange.stub!(:new).and_return(@exchange_strategy)  
+        @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"
@@ -39,232 +50,209 @@ module RosettaQueue::Gateway
       describe "#receive_once" do
 
         def do_receiving_once
-          @adapter.receive_once("/queue/foo", {:durable => false})
+          @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(:do_single_exchange).with("/queue/foo", {:durable => false})
+            @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", :on_message => true, :destination => :foo)
+          @handler = mock("handler", :on_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(:do_exchange).with("/queue/foo", @handler)
+            @exchange_strategy.should_receive(:receive).with("foo", @handler)
           }
         end
 
       end
-      
-      describe "#send_message" do    
+
+      describe "#send_message" do
 
         it "should pass message handler to exchange strategy" do
           when_publishing {
-            @exchange_strategy.should_receive(:publish_to_exchange).with('queue', 'message', 'options')
+            @exchange_strategy.should_receive(:publish).with('queue', 'message')
           }
         end
-    
+
       end
     end
 
 
-    describe DirectExchange do
-    
+    describe SynchExchange::DirectExchange do
+
       before(:each) do
-        AMQP.stub!(:connect).and_return(@conn = mock("AMQP::Client"))    
-        @queue = mock("MQ::Queue", :pop => @msg, :publish => true, :unsubscribe => true)
-        @channel = mock("MQ", :queue => @queue)
-        MQ.stub!(:new).and_return(@channel)
+        @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))
         @queue.stub!(:subscribe).and_yield(@msg)
         @handler = mock("handler", :on_message => true, :destination => :foo)
-        EM.stub!(:run).and_yield
-        EM.stub!(:stop_event_loop)
-        @strategy = DirectExchange.new('user', 'pass', 'host')
+        @exchange = SynchExchange::DirectExchange.new({:user => 'user', :password => 'pass', :host => 'host', :opts => {:vhost => "foo"}})
       end
-      
-      
+
+
       def do_receiving_exchange
-        @strategy.do_exchange("/queue/foo", @handler)
+        @exchange.receive("queue.foo", @handler)
       end
-      
+
       it_should_behave_like "an exchange"
-      
-      describe "#do_single_exchange" do
-    
+
+      describe "#receive_once" do
+
         def do_receiving_single_exchange
-          @strategy.do_single_exchange("/queue/foo", {:durable => false})
+          @exchange.receive_once("queue.foo") { |msg| }
+
         end
-    
+
         it "should return the message from the connection" do
-          @strategy.do_single_exchange("/queue/foo", {:durable => false}).should == @msg
+          @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
-    
-        # it "should stop event loop" do
-        #   pending
-        #   when_receiving_single_exchange {
-        #     EM.should_receive(:stop_event_loop)
-        #   }
-        # end
-    
+
       end
-    
-      describe "#do_exchange" do
+
+      describe "#receive" do
 
         it "should subscribe to queue" do
           when_receiving_exchange {
             @queue.should_receive(:subscribe).and_yield(@msg)
           }
-        end                
-  
-      end
-    
-    
-      describe "#publish_to_exchange" do
-        
-        before(:each) do
-          EM.stub!(:reactor_running?).and_return(true)
         end
-    
+
+      end
+
+
+      describe "#publish" do
+
         def do_publishing
-          @strategy.publish_to_exchange('/queue/foo', 'message', {:durable => false})
+          @exchange.publish('queue.foo', 'message')
         end
-    
+
         it "should instantiate queue" do
           when_publishing {
-            @channel.should_receive(:queue).and_return(@queue)
+            @conn.should_receive(:queue).and_return(@queue)
           }
         end
-        
+
         it "should publish message to queue" do
           when_publishing {
-            @channel.queue.should_receive(:publish).with('message', {:durable => false})
+            @conn.queue.should_receive(:publish).with("message", {})
           }
         end
-        
-        # it "should stop event loop" do
-        #   when_publishing {
-        #     EM.should_receive(:stop_event_loop)
-        #   }
-        # end
+
       end
-    
+
     end
-    
-    
-    describe FanoutExchange do
-    
+
+
+    describe SynchExchange::FanoutExchange do
+
       before(:each) do
-        AMQP.stub!(:connect).and_return(@conn = mock("AMQP::Client"))    
-        @queue = mock("MQ::Queue", :pop => @msg, :bind => @bound_queue = mock("MQ::Queue", :pop => @msg), :publish => true, :unbind => true)
-        @channel = mock("MQ", :queue => @queue, :fanout => 'fanout')
-        MQ.stub!(:new).and_return(@channel)
-        @bound_queue.stub!(:subscribe).and_yield(@msg)
+        @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", :on_message => true, :destination => :foo, :options => {:durable => false})
-        EM.stub!(:run).and_yield
-        EM.stub!(:stop_event_loop)
-        @strategy = FanoutExchange.new('user', 'pass', 'host')
       end
-      
+
       def do_receiving_exchange
-        @strategy.do_exchange("/topic/foo", @handler)
+        @exchange.receive("topic.foo", @handler)
       end
-      
+
       it_should_behave_like "an exchange"
-    
-      describe "#do_single_exchange" do
-    
+
+      describe "#receive_once" do
+
         def do_receiving_exchange
-          @strategy.do_single_exchange("/topic/foo")
+          @exchange.receive_once("topic.foo") { |msg| }
         end
-    
+
         it_should_behave_like "a fanout exchange adapter"
-    
+
         it "should return the message from the connection" do
-          @strategy.do_single_exchange("/topic/foo").should == @msg
+          @exchange.receive_once("topic.foo") do |msg|
+            msg.should == @msg
+          end
         end
-    
+
         it "should subscribe to queue" do
           when_receiving_exchange {
-            @bound_queue.should_receive(:pop)
+            @queue.should_receive(:pop)
           }
         end
-    
+
         it "should unbind queue from exchange" do
           pending
           when_receiving_single_exchange {
             @queue.should_receive(:unbind)
           }
         end
-    
-        it "should stop event loop" do
-          pending
-          when_receiving_single_exchange {
-            EM.should_receive(:stop_event_loop)
-          }
-        end
+
       end
-    
-      describe "#do_exchange" do                  
-    
+
+      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(:on_message).with("Hello World!")
           }
         end
-    
+
         it "should subscribe to queue" do
           when_receiving_exchange {
-            @bound_queue.should_receive(:subscribe).and_yield(@msg)
+            @queue.should_receive(:subscribe).and_yield(@msg)
           }
         end
-      
+
       end
-            
+
       # describe "#publish_to_exchange" do
-      # 
+      #
       #   def do_publishing
-      #     @strategy.publish_to_exchange('/queue/foo', 'message', {:durable => false})
+      #     @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
-    
+
     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

@@ -13,7 +13,7 @@ module RosettaQueue
         @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("user", "password", "host", "port")
+        @adapter = BeanstalkAdapter.new({:host => "host", :port => "port"})
         @adapter.stub!(:running).and_yield
       end
 

data/spec/rosetta_queue/adapters/null_spec.rb

@@ -8,7 +8,7 @@ module RosettaQueue
     describe NullAdapter do
       
       def null_adapter
-        NullAdapter.new('user', 'password', 'host', 'port')
+        NullAdapter.new({:user => 'user', :password => 'password', :host => 'host', :port => 'port'})
       end
       
       %w[disconnect receive receive_with send_message subscribe unsubscribe].each do |adapter_method|

data/spec/rosetta_queue/adapters/shared_adapter_behavior.rb

@@ -4,7 +4,7 @@ module RosettaQueue
     describe "an adapter", :shared => true do
 
       before(:each) do
-        ::RosettaQueue::Destinations.stub!(:lookup).and_return("/queue/foo")
+        ::RosettaQueue::Destinations.stub!(:lookup).and_return("foo")
       end
 
       def do_publishing
@@ -18,7 +18,7 @@ module RosettaQueue
       describe "#receive_once" do
 
         it "should return the message from the connection" do
-          @adapter.receive_once("/queue/foo", {:persistent => false}).should == @msg
+          @adapter.receive_once("foo", {:persistent => false}).should == @msg
         end
 
       end
@@ -27,7 +27,7 @@ module RosettaQueue
 
         it "should look up the destination defined on the class" do
           when_receiving_with_handler {
-            Destinations.should_receive(:lookup).with(:foo).and_return("/queue/foo")
+            Destinations.should_receive(:lookup).with(:foo).and_return("foo")
           }
         end
       
@@ -35,4 +35,4 @@ module RosettaQueue
       
     end
   end
-end
+end

data/spec/rosetta_queue/adapters/shared_fanout_behavior.rb

@@ -3,18 +3,18 @@ module RosettaQueue
 
     describe "a fanout exchange adapter", :shared => true do
 
-      it "should discover fanout name for destation" do
-        when_receiving_exchange {
-          @channel.should_receive(:fanout).with('/foo').and_return(@bound_queue)
-        }
-      end
+#       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('fanout').and_return(@bound_queue)
+          @queue.should_receive(:bind).with(@exchange).and_return(@bound_queue)
         }
       end
 
     end
   end
-end
+end

data/spec/rosetta_queue/adapters/stomp_spec.rb

@@ -13,7 +13,7 @@ module RosettaQueue
         @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", "password", "host", "port")
+        @adapter = StompAdapter.new({:user => "user", :password => "password", :host => "host", :port => "port"})
         @adapter.stub!(:running).and_yield
       end
 
@@ -56,7 +56,7 @@ module RosettaQueue
 
         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('/queue/foo', :persistent => false, :ack => "client")
+            @conn.should_receive("subscribe").with('foo', :persistent => false, :ack => "client")
           }
         end
 
@@ -89,7 +89,7 @@ module RosettaQueue
 
         it "should unsubscribe connection" do
           when_disconnecting {
-            @conn.should_receive("unsubscribe").with("/queue/foo")          
+            @conn.should_receive("unsubscribe").with("foo")
           }
         end
 

data/spec/rosetta_queue/consumer_spec.rb

@@ -47,6 +47,30 @@ module RosettaQueue
     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
@@ -72,4 +96,4 @@ module RosettaQueue
     end
 
   end
-end
+end

data/spec/spec_helper.rb

@@ -10,13 +10,15 @@ require 'rosetta_queue/adapters/null'
 require 'rosetta_queue/adapters/fake'
 require 'rosetta_queue/adapters/stomp'
 require 'rosetta_queue/adapters/amqp'
+require 'rosetta_queue/consumer_managers/base'
+require 'rosetta_queue/consumer_managers/evented'
+require 'rosetta_queue/consumer_managers/threaded'
 require 'rosetta_queue/spec_helpers'
 require 'rosetta_queue/consumer_managers/base'
 require 'rosetta_queue/consumer_managers/evented'
 require 'rosetta_queue/consumer_managers/threaded'
 require File.dirname(__FILE__) + '/rosetta_queue/shared_messaging_behavior.rb'
 
-
 class NullLogger
   def info(*args);  end
   def debug(*args); end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bmabey-rosetta_queue
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors: 
 - Ben Mabey
@@ -10,12 +10,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-14 00:00:00 -07:00
+date: 2009-07-28 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
 description: Messaging gateway API with adapters for many messaging systems available in Ruby. Messaging systems can be easily switched out with a small configuration change. Code for testing on the object and application level is also provided.
-email: ben@benmabey.com
+email: cbwyckoff@gmail.com
 executables: []
 
 extensions: []
@@ -31,16 +31,18 @@ files:
 - VERSION.yml
 - cucumber.yml
 - features/filtering.feature
-- features/messaging/point_to_point.feature
-- features/messaging/step_definitions/point_to_point_steps.rb
-- features/messaging/step_definitions/publish_subscribe_steps.rb
+- features/messaging.feature
+- features/step_definitions/common_messaging_steps.rb
 - features/step_definitions/filtering_steps.rb
-- features/support/common_messaging_steps.rb
+- features/step_definitions/point_to_point_steps.rb
+- features/step_definitions/publish_subscribe_steps.rb
 - features/support/env.rb
 - features/support/sample_consumers.rb
 - lib/rosetta_queue.rb
 - lib/rosetta_queue/adapter.rb
 - lib/rosetta_queue/adapters/amqp.rb
+- lib/rosetta_queue/adapters/amqp_evented.rb
+- lib/rosetta_queue/adapters/amqp_synch.rb
 - lib/rosetta_queue/adapters/base.rb
 - lib/rosetta_queue/adapters/beanstalk.rb
 - lib/rosetta_queue/adapters/fake.rb
@@ -63,7 +65,7 @@ files:
 - lib/rosetta_queue/spec_helpers/helpers.rb
 - lib/rosetta_queue/spec_helpers/publishing_matchers.rb
 - spec/rosetta_queue/adapter_spec.rb
-- spec/rosetta_queue/adapters/amqp_spec.rb
+- spec/rosetta_queue/adapters/amqp_synchronous_spec.rb
 - spec/rosetta_queue/adapters/beanstalk_spec.rb
 - spec/rosetta_queue/adapters/fake_spec.rb
 - spec/rosetta_queue/adapters/null_spec.rb
@@ -82,7 +84,8 @@ files:
 - spec/spec.opts
 - spec/spec_helper.rb
 has_rdoc: false
-homepage: http://github.com/bmabey/rosetta_queue
+homepage: http://github.com/cwyckoff/rosetta_queue
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --charset=UTF-8
@@ -103,13 +106,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: rosetta-queue
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Messaging gateway API with adapters for many messaging systems available in Ruby.
 test_files: 
 - spec/rosetta_queue/adapter_spec.rb
-- spec/rosetta_queue/adapters/amqp_spec.rb
+- spec/rosetta_queue/adapters/amqp_synchronous_spec.rb
 - spec/rosetta_queue/adapters/beanstalk_spec.rb
 - spec/rosetta_queue/adapters/fake_spec.rb
 - spec/rosetta_queue/adapters/null_spec.rb
@@ -126,3 +129,7 @@ test_files:
 - spec/rosetta_queue/producer_spec.rb
 - spec/rosetta_queue/shared_messaging_behavior.rb
 - spec/spec_helper.rb
+- examples/sample_amqp_consumer.rb
+- examples/sample_amqp_fanout_consumer.rb
+- examples/sample_amqp_fanout_producer.rb
+- examples/sample_amqp_producer.rb

data/features/messaging/point_to_point.feature

@@ -1,30 +0,0 @@
-Story: Point-to-Point Producing and Consuming
-
-  As a RosettaQueue user
-  I want to publish and consume point-to-point using various messaging protocols
-  So that I can reliably integrate my systems with a message broker
-
-    Scenario Outline: Point-to-Point
-      Given RosettaQueue is configured for '<Adapter>'
-      And a point-to-point destination is set
-      When a message is published to queue 'foo'
-      Then the message should be consumed
-
-  Examples:
-  | Adapter   |
-  | amqp      |
-  | stomp     |
-  | beanstalk |
-
-
-  # Scenario Outline: Publish-Subscribe
-  # Given RosettaQueue is configured for '<Adapter>'
-  # And a publish-subscribe destination is set
-  # When a message is published to topic foobar
-  # Then multiple messages should be consumed from the topic
-  #
-  # Examples:
-  # | Adapter   |
-  # | amqp    |
-  # # | stomp   |
-  # #