torquebox-messaging 1.0.0.CR1-java

data/spec/backgroundable_spec.rb

@@ -0,0 +1,141 @@
+require 'torquebox/messaging/backgroundable'
+
+class MyTestModel
+  include TorqueBox::Messaging::Backgroundable
+
+  def an_async_action(arg1, arg2)
+    a_sync_action
+  end
+  always_background :an_async_action
+
+  def a_sync_action;  end
+  def foo;  end
+  def bar;  end
+  def optioned; end
+  def redefine_me; end
+end
+
+describe TorqueBox::Messaging::Backgroundable do
+  before(:all) do
+    @util = TorqueBox::Messaging::Backgroundable::Util
+  end
+  
+  describe "always_background" do
+    it "should be able to handle mutliple methods" do
+      MyTestModel.always_background :foo, :bar
+      @util.instance_methods_include?(MyTestModel, '__async_foo').should be_true
+      @util.instance_methods_include?(MyTestModel, '__async_bar').should be_true
+    end
+
+    it "should handle methods that are defined after the always_background call" do
+      MyTestModel.always_background :baz
+      @util.instance_methods_include?(MyTestModel, '__async_baz').should_not be_true
+      MyTestModel.class_eval('def baz;end')
+      @util.instance_methods_include?(MyTestModel, '__async_baz').should be_true
+    end
+
+    it "should handle methods that are redefined after the always_background call" do
+      MyTestModel.always_background :redefine_me
+      MyTestModel.class_eval('def redefine_me; :xyz; end')
+      MyTestModel.new.__sync_redefine_me.should == :xyz
+    end
+    
+    it "should work for private methods, maintaining visibility" do
+      MyTestModel.class_eval('private; def no_peeking;end')
+      MyTestModel.always_background :no_peeking
+      @util.private_instance_methods_include?(MyTestModel, 'no_peeking').should be_true
+      @util.private_instance_methods_include?(MyTestModel, '__async_no_peeking').should be_true
+      @util.private_instance_methods_include?(MyTestModel, '__sync_no_peeking').should be_true
+    end
+
+    it "should work for protected methods, maintaining visibility" do
+      MyTestModel.class_eval('protected; def some_peeking;end')
+      MyTestModel.always_background :some_peeking
+      @util.protected_instance_methods_include?(MyTestModel, 'some_peeking').should be_true
+      @util.protected_instance_methods_include?(MyTestModel, '__async_some_peeking').should be_true
+      @util.protected_instance_methods_include?(MyTestModel, '__sync_some_peeking').should be_true
+    end
+  end
+
+  describe "a method handled asynchronously" do
+    before(:each) do
+      @queue = mock('queue')
+      @queue.stub(:publish)
+      TorqueBox::Messaging::Queue.stub(:new).and_return(@queue)
+    end
+
+    it "should put a message on the queue" do
+      @queue.should_receive(:publish)
+      MyTestModel.new.an_async_action(nil, nil)
+    end
+
+    it "should include the receiver, sync method, and args" do
+      object = MyTestModel.new
+      @queue.should_receive(:publish).with({:receiver => object, :method => '__sync_an_async_action', :args => [:a, :b]}, { })
+      object.an_async_action(:a, :b) 
+    end
+    
+    it "should not call the action immediately" do
+      object = MyTestModel.new
+      object.should_not_receive(:a_sync_action)
+      object.an_async_action(nil, nil)
+    end
+
+    it "should pass through the options" do
+      MyTestModel.always_background :optioned, :priority => :low
+      @queue.should_receive(:publish).with(anything, :priority => :low)
+      MyTestModel.new.optioned
+    end
+
+  end
+
+  describe 'background' do
+    before(:each) do
+      @queue = mock('queue')
+      @queue.stub(:publish)
+      TorqueBox::Messaging::Queue.stub(:new).and_return(@queue)
+      @object = MyTestModel.new
+    end
+
+    it "should queue any method called on it" do
+      @queue.should_receive(:publish).with({:receiver => anything,
+                                           :method => :foo,
+                                             :args => anything}, { })
+      @object.background.foo 
+    end
+
+    it "should queue the receiver" do
+      @queue.should_receive(:publish).with({:receiver => @object,
+                                           :method => anything,
+                                             :args => anything}, { })
+      @object.background.foo 
+    end
+
+    it "should queue the args" do
+      @queue.should_receive(:publish).with({:receiver => anything,
+                                           :method => anything,
+                                             :args => [1,2]}, {})
+      @object.background.foo(1,2) 
+    end
+
+    it "should raise when given a block" do
+      lambda { 
+        @object.background.foo { }
+      }.should raise_error(ArgumentError)
+    end
+
+    it "should handle missing methods" do
+      @object.should_receive(:method_missing)
+      @object.background.no_method
+    end
+
+    it "should pass through any options" do
+      @queue.should_receive(:publish).with({:receiver => anything,
+                                           :method => anything,
+                                             :args => anything},
+                                           {:ttl => 1})
+      @object.background(:ttl => 1).foo
+    end
+  end
+  
+end

data/spec/client_spec.rb

@@ -0,0 +1,119 @@
+
+
+require 'torquebox-messaging-container'
+require 'torquebox-naming-container'
+require 'torquebox-container-foundation'
+
+require 'torquebox/messaging/client'
+
+describe TorqueBox::Messaging::Client do
+
+  describe "sending and receiving" do
+    before(:each) do
+      @container = TorqueBox::Container::Foundation.new
+      @container.enable( TorqueBox::Naming::NamingService ) {|config| config.export=false}
+      @container.enable( TorqueBox::Messaging::MessageBroker ) 
+      @container.start
+
+      @queues_yml = @container.deploy( File.join( File.dirname(__FILE__), 'queues.yml' ) )
+      @container.process_deployments(true)
+    end
+  
+    after(:each) do
+      @container.undeploy( @queues_yml )
+      @container.stop
+    end
+
+    it "should be able to send to a queue from two threads/two sessions" do
+  
+      received_message = nil
+
+      consumer_thread = Thread.new {
+        TorqueBox::Messaging::Client.connect() do |session|
+          received_message = session.receive( '/queues/foo' )
+          session.commit
+        end
+      }
+
+      producer_thread = Thread.new {
+        TorqueBox::Messaging::Client.connect() do |session|
+          session.publish( '/queues/foo', "howdy" )
+          session.commit
+        end
+      }
+
+      consumer_thread.join
+
+      received_message.should_not be_nil
+      received_message.should eql( "howdy" )
+    end
+
+
+    it "should be able to send to a queue from one thread/one session" do
+
+      received_message = nil
+
+      TorqueBox::Messaging::Client.connect() do |session|
+        session.publish( '/queues/foo', "howdy" )
+        session.commit
+        received_message = session.receive( '/queues/foo' )
+        session.commit
+      end
+
+      received_message.should_not be_nil
+      received_message.should eql( "howdy" )
+    end
+
+    it "should be able to send and receive a non-String message" do
+      message = {:string => "a string", :symbol => :a_symbol, :hash => {}, :array => []}
+      received_message = nil
+
+      TorqueBox::Messaging::Client.connect() do |session|
+        session.publish( '/queues/foo', message )
+        session.commit
+        received_message = session.receive( '/queues/foo' )
+        session.commit
+      end
+
+      received_message.should_not be_nil
+      received_message.should eql( message )
+    end
+
+    it "should identify a non-String message with a text property" do
+      received_message = nil
+      TorqueBox::Messaging::Client.connect() do |session|
+        session.publish( '/queues/foo', [] )
+        session.commit
+        received_message = session.receive( '/queues/foo', :decode => false )
+        session.commit
+      end
+      received_message.decode.should eql( [] )
+      received_message.get_string_property( 'torquebox_encoding' ).should eql( 'base64' )
+    end
+
+    it "should not identify a String message with a text property" do
+      received_message = nil
+      TorqueBox::Messaging::Client.connect() do |session|
+        session.publish( '/queues/foo', "foo" )
+        session.commit
+        received_message = session.receive( '/queues/foo', :decode => false )
+        session.commit
+      end
+      received_message.text.should eql( "foo" )
+      received_message.decode.should eql( "foo" )
+      received_message.get_string_property( 'torquebox_encoding' ).should be_nil
+    end
+
+    it "should timeout if asked" do
+      received_message = nil
+      TorqueBox::Messaging::Client.connect() do |session|
+        received_message = session.receive( '/queues/foo', :timeout => 1 )
+      end
+      received_message.should be_nil
+    end
+    
+  end
+
+end
+
+

data/spec/destination_spec.rb

@@ -0,0 +1,296 @@
+
+require 'torquebox-container-foundation'
+require 'torquebox-naming-container'
+require 'torquebox-messaging-container'
+require 'torquebox/messaging/destination'
+
+describe TorqueBox::Messaging::Destination do
+
+  it "should return its name for to_s" do
+    queue = TorqueBox::Messaging::Queue.new("/queues/foo")
+    queue.name.should == "/queues/foo"
+    queue.to_s.should == queue.name
+    topic = TorqueBox::Messaging::Topic.new("/topics/bar")
+    topic.name.should == "/topics/bar"
+    topic.to_s.should == topic.name
+  end
+
+  %w{ create start }.each do |method|
+
+    it "should create a queue on #{method}" do
+      server = mock("server")
+      server.should_receive(:createQueue)
+      server.should_receive(:destroyQueue).with("my_queue")
+      TorqueBox::Kernel.stub!(:lookup).with("JMSServerManager").and_yield(server)
+
+      queue = TorqueBox::Messaging::Queue.new("my_queue")
+      queue.name.should eql("my_queue")
+      queue.send method
+      queue.destroy
+    end
+
+    it "should create a topic on #{method}" do
+      server = mock("server")
+      server.should_receive(:createTopic)
+      server.should_receive(:destroyTopic).with("my_topic")
+      TorqueBox::Kernel.stub!(:lookup).with("JMSServerManager").and_yield(server)
+
+      topic = TorqueBox::Messaging::Topic.new("my_topic")
+      topic.name.should eql("my_topic")
+      topic.send method
+      topic.destroy
+    end
+
+  end
+
+  describe "publish" do
+    before(:each) do
+      @session = mock('session')
+      @session.stub(:transacted?).and_return(false)
+      TorqueBox::Messaging::Client.stub(:connect).and_yield(@session)
+      @queue = TorqueBox::Messaging::Queue.new('foo')
+    end
+
+    context "normalizing options" do
+      context "priority" do
+        {
+          :low => 1,
+          :normal => 4,
+          :high => 7,
+          :critical => 9
+        }.each do |symbol, level|
+          it "should normalize :#{symbol} to #{level}" do
+            @session.should_receive(:publish).with(anything, anything, { :priority => level })
+            @queue.publish('message', { :priority => symbol })
+          end
+        end
+
+        it "should pass through valid integer priorities" do
+          @session.should_receive(:publish).with(anything, anything, { :priority => 5 })
+          @queue.publish('message', { :priority => 5 })
+        end
+
+        it "should pass through valid integer-as-string priorities" do
+          @session.should_receive(:publish).with(anything, anything, { :priority => 5 })
+          @queue.publish('message', { :priority => "5" })
+        end
+
+        it "should raise on an invalid integer" do
+          lambda { 
+            @queue.publish('message', { :priority => -1 })
+          }.should raise_error(ArgumentError)
+        end
+      end
+
+      it "should handle persistence = true" do
+        @session.should_receive(:publish).with(anything, anything, { :delivery_mode => javax.jms::DeliveryMode.PERSISTENT })
+        @queue.publish('message', { :persistent => true })
+      end
+
+      it "should handle persistence = false" do
+        @session.should_receive(:publish).with(anything, anything, { :delivery_mode => javax.jms::DeliveryMode.NON_PERSISTENT })
+        @queue.publish('message', { :persistent => false })
+      end
+    end
+  end
+
+
+  describe "message selectors" do
+    before(:each) do
+      @container = TorqueBox::Container::Foundation.new
+      @container.enable( TorqueBox::Naming::NamingService ) {|config| config.export=false}
+      @container.enable( TorqueBox::Messaging::MessageBroker )
+      @container.start
+      @queue = TorqueBox::Messaging::Queue.new "/queues/selector_test"
+      @queue.start
+    end
+
+    after(:each) do
+      @queue.destroy
+      @container.stop
+    end
+
+    {
+      true => 'prop = true',
+      true => 'prop <> false',
+      5 => 'prop = 5',
+      5 => 'prop > 4',
+      5.5 => 'prop = 5.5',
+      5.5 => 'prop < 6',
+      'string' => "prop = 'string'"
+    }.each do |value, selector|
+      it "should be able to select with property set to #{value} using selector '#{selector}'" do
+        @queue.publish value.to_s, :properties => { :prop => value }
+        message = @queue.receive(:timeout => 1000, :selector => selector)
+        message.should == value.to_s
+      end
+    end
+    
+  end
+  
+  describe "browse" do
+    before(:each) do
+      @container = TorqueBox::Container::Foundation.new
+      @container.enable( TorqueBox::Naming::NamingService ) {|config| config.export=false}
+      @container.enable( TorqueBox::Messaging::MessageBroker )
+      @container.start
+    end
+
+    after(:each) do
+      @container.stop
+    end
+
+    it "should allow enumeration of the messages" do
+      queue = TorqueBox::Messaging::Queue.new "/queues/browseable"
+      queue.start
+      queue.publish "howdy"
+      queue.first.text.should == 'howdy'
+      queue.destroy
+    end
+
+    it "should accept a selector" do
+      queue = TorqueBox::Messaging::Queue.new "/queues/browseable", {}, :selector => 'blurple > 5'
+      queue.start
+      queue.publish "howdy", :properties => {:blurple => 5}
+      queue.publish "ahoyhoy", :properties => {:blurple => 6}
+      queue.first.text.should == 'ahoyhoy'
+      queue.detect { |m| m.text == 'howdy' }.should be_nil
+      queue.destroy
+      
+    end
+  end
+  
+  describe "sending and receiving" do
+    before(:each) do
+      @container = TorqueBox::Container::Foundation.new
+      @container.enable( TorqueBox::Naming::NamingService ) {|config| config.export=false}
+      @container.enable( TorqueBox::Messaging::MessageBroker )
+      @container.start
+    end
+
+    after(:each) do
+      @container.stop
+    end
+
+    it "should be able to publish to and receive from a queue" do
+      queue = TorqueBox::Messaging::Queue.new "/queues/foo"
+      queue.start
+
+      queue.publish "howdy"
+      message = queue.receive
+
+      queue.destroy
+      message.should eql( "howdy" )
+    end
+
+    it "should publish to multiple topic consumers" do
+      topic = TorqueBox::Messaging::Topic.new "/topics/foo"
+      topic.start
+      threads, count = [], 10
+
+      # Use a threadsafe "array"
+      msgs = java.util.Collections.synchronizedList( [] )
+
+      # Ensure all clients are blocking on the receipt of a message
+      count.times { threads << Thread.new { msgs << topic.receive } }
+      sleep(1)
+      topic.publish "howdy"
+      threads.each {|t| t.join}
+
+      topic.destroy
+      msgs.to_a.should eql( ["howdy"] * count )
+    end
+
+    context "synchronous messaging" do
+      it "should return value of block given to receive_and_publish" do
+        queue = TorqueBox::Messaging::Queue.new "/queues/publish_and_receive"
+        queue.start
+
+        response_thread = Thread.new {
+          queue.receive_and_publish( :timeout => 10000 ) { |msg| msg.upcase }
+        }
+        message = queue.publish_and_receive "ping", :timeout => 10000
+        response_thread.join
+
+        queue.destroy
+        message.should eql( "PING" )
+      end
+
+      it "should return request message if no block given" do
+        queue = TorqueBox::Messaging::Queue.new "/queues/publish_and_receive"
+        queue.start
+
+        response_thread = Thread.new {
+          queue.receive_and_publish( :timeout => 10000 )
+        }
+        message = queue.publish_and_receive "ping", :timeout => 10000
+        response_thread.join
+
+        queue.destroy
+        message.should eql( "ping" )
+      end
+
+      it "should not mess up with multiple consumers" do
+        queue = TorqueBox::Messaging::Queue.new "/queues/publish_and_receive"
+        queue.start
+
+        thread_count = 3
+        response_threads = (1..thread_count).map do
+          Thread.new {
+            queue.receive_and_publish( :timeout => 10000 ) { |msg| msg.upcase }
+          }
+        end
+
+        message = queue.publish_and_receive "ping", :timeout => 10000
+        # Send extra messages to trigger all remaining response threads
+        (thread_count - 1).times do
+          queue.publish_and_receive "ping", :timeout => 10000
+        end
+        response_threads.each { |thread| thread.join }
+
+        queue.destroy
+        message.should eql( "PING" )
+      end
+    end
+
+    context "destination not ready" do
+      it "should block on publish until queue is ready" do
+        queue = TorqueBox::Messaging::Queue.new "/queues/not_ready"
+        # Start the queue in a separate thread after a delay
+        setup_thread = Thread.new {
+          sleep( 0.2 )
+          queue.start
+        }
+        # The queue will not be ready when we call the publish method
+        queue.publish "something"
+        message = queue.receive
+
+        setup_thread.join
+        queue.destroy
+        message.should eql( "something" )
+      end
+
+      it "should block on receive until topic is ready" do
+        topic = TorqueBox::Messaging::Topic.new "/topics/not_ready"
+        # Start the topic in a separate thread after a delay
+        setup_thread = Thread.new {
+          topic.start
+        }
+        # The topic will not be ready when we call the receive method
+        message = topic.receive :timeout => 200
+
+        setup_thread.join
+        topic.destroy
+        message.should be_nil
+      end
+
+      it "should block until startup_timeout reached" do
+        queue = TorqueBox::Messaging::Queue.new "/queues/not_ready"
+        lambda {
+          queue.publish "something", :startup_timeout => 200
+        }.should raise_error(javax.naming.NameNotFoundException)
+      end
+    end
+  end
+
+end

data/spec/dispatcher-queues.yml

@@ -0,0 +1,4 @@
+
+/queues/questions:
+
+/queues/answers:

data/spec/dispatcher_not_running.rb

@@ -0,0 +1,54 @@
+#require 'spec_helper'
+
+require 'rubygems'
+require 'torquebox-naming'
+require 'torquebox-naming-container'
+require 'torquebox-messaging-container'
+require 'torquebox/messaging/message_processor'
+require 'torquebox/messaging/destination'
+
+QUEUE_QUESTIONS = TorqueBox::Messaging::Queue.new("/queues/questions")
+QUEUE_ANSWERS   = TorqueBox::Messaging::Queue.new("/queues/answers")
+
+TESTING_ON_WINDOWS = ( java.lang::System.getProperty( "os.name" ) =~ /.*windows*/i )
+
+class Upcaser < TorqueBox::Messaging::MessageProcessor
+  def on_message(body)
+    QUEUE_ANSWERS.publish( body.upcase )
+  end
+end
+
+describe "dispatcher test" do
+  before(:each) do
+    @container = TorqueBox::Container::Foundation.new
+    @container.enable( TorqueBox::Naming::NamingService ) {|config| config.export=true}
+    @container.enable( TorqueBox::Messaging::MessageBroker ) 
+    @container.start
+
+    @queues_yml = @container.deploy( File.join( File.dirname(__FILE__), 'dispatcher-queues.yml' ) )
+    @container.process_deployments(true)
+    puts "Deployed queues"
+  end
+  
+  after(:each) do
+    puts "UNDEPLOY queues"
+    @container.undeploy( @queues_yml )
+    puts "UNDEPLOYED queues"
+    puts "STOP container"
+    @container.stop
+    puts "STOPPED container"
+  end
+
+  unless TESTING_ON_WINDOWS
+    it "should associate a processor with a queue" do
+      dispatcher = TorqueBox::Messaging::Dispatcher.new( :skip_naming=>true ) do
+        map Upcaser, QUEUE_QUESTIONS
+      end
+      dispatcher.start
+      QUEUE_QUESTIONS.publish "lkjsdf"
+      QUEUE_ANSWERS.receive(:timeout => 2000).should == "LKJSDF"
+      dispatcher.stop
+    end
+  end
+
+end

data/spec/ext/java_jmx_session_spec.rb

@@ -0,0 +1,71 @@
+require 'torquebox/messaging/ext/javax_jms_session'
+
+describe javax.jms::Session do
+
+  before(:each) do
+    @session = javax.jms::Session.new
+  end
+
+  describe ".populate_message_properties" do
+    it "should do nothing if no properties are submitted" do
+      jms_message = mock('JMSMessage')
+      jms_message.should_not_receive(:setStringProperty)
+
+      @session.populate_message_properties jms_message, nil
+    end
+
+    it "should register properties with String keys" do
+      properties = {'abc' => 'def'}
+
+      jms_message = mock('JMSMessage')
+      jms_message.should_receive(:set_string_property).with('abc', 'def')
+
+      @session.populate_message_properties jms_message, properties
+    end
+
+    it "should register properties with Symbol keys" do
+      properties = {:abc => :def}
+
+      jms_message = mock('JMSMessage')
+      jms_message.should_receive(:set_string_property).with('abc', 'def')
+
+      @session.populate_message_properties jms_message, properties
+    end
+
+    it "should register true as a boolean" do
+      properties = {:abc => true}
+
+      jms_message = mock('JMSMessage')
+      jms_message.should_receive(:set_boolean_property).with('abc', true)
+
+      @session.populate_message_properties jms_message, properties
+    end
+
+    it "should register false as a boolean" do
+      properties = {:abc => false}
+
+      jms_message = mock('JMSMessage')
+      jms_message.should_receive(:set_boolean_property).with('abc', false)
+
+      @session.populate_message_properties jms_message, properties
+    end
+
+    it "should register 5 as an long" do
+      properties = {:abc => 5}
+
+      jms_message = mock('JMSMessage')
+      jms_message.should_receive(:set_long_property).with('abc', 5)
+
+      @session.populate_message_properties jms_message, properties
+    end
+
+    it "should register 5.5 as a double" do
+      properties = {:abc => 5.5}
+
+      jms_message = mock('JMSMessage')
+      jms_message.should_receive(:set_double_property).with('abc', 5.5)
+
+      @session.populate_message_properties jms_message, properties
+    end
+  end
+end

data/spec/queues.yml

@@ -0,0 +1,6 @@
+
+/queues/foo:
+  durable: false
+
+/queues/bar:
+  durable: false