torquebox-messaging 1.1.1-java → 2.0.0.beta1-java

data/lib/torquebox/messaging/text_message.rb

@@ -0,0 +1,36 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+#
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+#
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+module TorqueBox
+  module Messaging
+    class TextMessage < Message
+      ENCODING = :text
+      JMS_TYPE = :text
+
+      def encode(message)
+        @jms_message.text = message || ''
+      end
+
+      def decode
+        @jms_message.text
+      end
+
+    end
+
+    Message.register_encoding( TextMessage )
+  end
+end

data/lib/torquebox/messaging/topic.rb

@@ -0,0 +1,54 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+# 
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+# 
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+require 'torquebox/messaging/destination'
+require 'torquebox/service_registry'
+
+module TorqueBox
+  module Messaging
+    class Topic < Destination
+
+      DEFAULT_SUBSCRIBER_NAME = 'subscriber-1'
+      
+      def self.start( name, options={} )
+        jndi = options.fetch( :jndi, [].to_java(:string) )
+        TorqueBox::ServiceRegistry.lookup("jboss.messaging.default.jms.manager") do |server|
+          server.createTopic( false, name, jndi )
+        end
+        new( name )
+      end
+
+      def stop
+        TorqueBox::ServiceRegistry.lookup("jboss.messaging.default.jms.manager") do |server|
+          server.destroyTopic( name )
+        end
+      end
+
+      def unsubscribe(subscriber_name = DEFAULT_SUBSCRIBER_NAME, options = { })
+        wait_for_destination(options[:startup_timeout]) do
+          with_session do |session|
+            session.unsubscribe( subscriber_name )
+          end
+        end
+      end
+      
+      def to_s
+        "[Topic: #{super}]"
+      end
+    end
+  end
+end

data/lib/torquebox/messaging/xa_connection.rb

@@ -0,0 +1,58 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+# 
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+# 
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+module TorqueBox
+  module Messaging
+    class XaConnection
+
+      def initialize(jms_connection)
+        @jms_connection = jms_connection
+      end
+
+      def start
+        @jms_connection.start
+      end
+
+      def close
+        @jms_connection.close
+      end
+
+      def client_id
+        @jms_connection.client_id
+      end
+
+      def client_id=(client_id)
+        @jms_connection.client_id = client_id
+      end
+      
+      def with_session(&block)
+        session = self.create_session()
+        begin
+          result = block.call( session )
+        ensure
+          session.close
+        end
+        return result
+      end
+
+      def create_session()
+        XaSession.new( @jms_connection.create_xa_session() )
+      end
+
+    end
+  end
+end

data/lib/torquebox/messaging/xa_connection_factory.rb

@@ -0,0 +1,59 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+# 
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+# 
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+require 'java'
+require 'torquebox/messaging/connection'
+
+module TorqueBox
+  module Messaging
+    class XaConnectionFactory
+
+      attr_reader :internal_connection_factory
+      
+      def self.new(internal_connection_factory = nil)
+        return internal_connection_factory if internal_connection_factory.is_a?( XaConnectionFactory )
+        super
+      end
+
+      def initialize(internal_connection_factory = nil)
+        @internal_connection_factory = internal_connection_factory
+      end
+
+      def with_new_connection(client_id = nil, &block)
+        connection = create_connection
+        connection.client_id = client_id
+        connection.start
+        begin
+          result = block.call( connection )
+        ensure
+          connection.close
+        end
+        return result
+      end
+
+      def create_connection()
+        XaConnection.new( @internal_connection_factory.create_xa_connection )
+      end
+
+
+      def to_s
+        "[XaConnectionFactory: internal_connection_factory=#{internal_connection_factory}]"
+      end
+
+    end
+  end
+end

data/lib/torquebox/messaging/xa_session.rb

@@ -0,0 +1,30 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+# 
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+# 
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+module TorqueBox
+  module Messaging
+
+    class XaSession < Session
+
+      def xa_resource
+        @jms_session.xa_resource
+      end
+
+    end
+
+  end
+end

data/licenses/lgpl-2.1.txt

@@ -1,5 +1,5 @@
-		  GNU LESSER GENERAL PUBLIC LICENSE
-		       Version 2.1, February 1999
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
 
  Copyright (C) 1991, 1999 Free Software Foundation, Inc.
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
@@ -10,7 +10,7 @@
  as the successor of the GNU Library Public License, version 2, hence
  the version number 2.1.]
 
-			    Preamble
+                            Preamble
 
   The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
@@ -112,7 +112,7 @@ modification follow.  Pay close attention to the difference between a
 former contains code derived from the library, whereas the latter must
 be combined with the library in order to run.
 
-		  GNU LESSER GENERAL PUBLIC LICENSE
+                  GNU LESSER GENERAL PUBLIC LICENSE
    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 
   0. This License Agreement applies to any software library or other
@@ -146,7 +146,7 @@ such a program is covered only if its contents constitute a work based
 on the Library (independent of the use of the Library in a tool for
 writing it).  Whether that is true depends on what the Library does
 and what the program that uses the Library does.
-  
+
   1. You may copy and distribute verbatim copies of the Library's
 complete source code as you receive it, in any medium, provided that
 you conspicuously and appropriately publish on each copy an
@@ -432,7 +432,7 @@ decision will be guided by the two goals of preserving the free status
 of all derivatives of our free software and of promoting the sharing
 and reuse of software generally.
 
-			    NO WARRANTY
+                            NO WARRANTY
 
   15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
 WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
@@ -455,7 +455,7 @@ FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
 SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
 DAMAGES.
 
-		     END OF TERMS AND CONDITIONS
+                     END OF TERMS AND CONDITIONS
 
            How to Apply These Terms to Your New Libraries
 
@@ -500,5 +500,3 @@ necessary.  Here is a sample; alter the names:
   Ty Coon, President of Vice
 
 That's all there is to it!
-
-

data/spec/backgroundable_spec.rb

@@ -80,10 +80,11 @@ describe TorqueBox::Messaging::Backgroundable do
       @queue.should_receive(:publish).with({
                                              :receiver => object,
                                              :future_id => '1234',
-                                             :future_queue => "/queues/torquebox//backgroundable",
+                                             :future_queue => "/queues/torquebox//tasks/torquebox_backgroundable",
                                              :method => '__sync_an_async_action',
                                              :args => [:a, :b]
-                                           }, { })
+                                           },
+                                           anything)
       object.an_async_action(:a, :b) 
     end
     
@@ -95,7 +96,7 @@ describe TorqueBox::Messaging::Backgroundable do
 
     it "should pass through the options" do
       MyTestModel.always_background :optioned, :priority => :low
-      @queue.should_receive(:publish).with(anything, :priority => :low)
+      @queue.should_receive(:publish).with(anything, hash_including(:priority => :low))
       MyTestModel.new.optioned
     end
 
@@ -110,29 +111,18 @@ describe TorqueBox::Messaging::Backgroundable do
     end
 
     it "should queue any method called on it" do
-      @queue.should_receive(:publish).with({:receiver => anything,
-                                             :method => :foo,
-                                             :args => anything,
-                                             :future_id => anything,
-                                             :future_queue => anything}, { })
+      @queue.should_receive(:publish).with(hash_including(:method => :foo),
+                                           anything)
       @object.background.foo 
     end
 
     it "should queue the receiver" do
-      @queue.should_receive(:publish).with({:receiver => @object,
-                                             :method => anything,
-                                             :args => anything,
-                                             :future_id => anything,
-                                             :future_queue => anything}, { })
+      @queue.should_receive(:publish).with(hash_including(:receiver => @object), anything)
       @object.background.foo 
     end
 
     it "should queue the args" do
-      @queue.should_receive(:publish).with({:receiver => anything,
-                                             :method => anything,
-                                             :future_id => anything,
-                                             :future_queue => anything,
-                                             :args => [1,2]}, {})
+      @queue.should_receive(:publish).with(hash_including(:args => [1,2]), anything)
       @object.background.foo(1,2) 
     end
 
@@ -148,14 +138,17 @@ describe TorqueBox::Messaging::Backgroundable do
     end
 
     it "should pass through any options" do
-      @queue.should_receive(:publish).with({:receiver => anything,
-                                             :method => anything,
-                                             :args => anything,
-                                             :future_id => anything,
-                                             :future_queue => anything},
-                                           {:ttl => 1})
+      @queue.should_receive(:publish).with(anything,
+                                           hash_including(:ttl => 1))
       @object.background(:ttl => 1).foo
     end
+
+    it "should always use the :marshal encoding" do
+      @queue.should_receive(:publish).with(anything,
+                                           hash_including(:encoding => :marshal))
+      @object.background.foo
+    end
+
   end
   
 end

data/spec/destination_spec.rb

@@ -1,54 +1,57 @@
 
-require 'torquebox-container-foundation'
-require 'torquebox-naming-container'
-require 'torquebox-messaging-container'
-require 'torquebox/messaging/destination'
+require 'torquebox/messaging/queue'
+require 'torquebox/messaging/topic'
+require 'torquebox/service_registry'
+
+java_import org.mockito.ArgumentCaptor
+java_import org.mockito.Matchers
+java_import org.mockito.Mockito
+java_import org.hornetq.jms.server.impl.JMSServerManagerImpl
 
 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 start and stop a queue" do
+    server = Mockito.mock(JMSServerManagerImpl.java_class)
+    TorqueBox::ServiceRegistry.stub!(:lookup).with("jboss.messaging.default.jms.manager").and_yield(server)
 
-    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.start( "my_queue" )
+    queue.name.should == "my_queue"
+    queue.stop
 
-      queue = TorqueBox::Messaging::Queue.new("my_queue")
-      queue.name.should eql("my_queue")
-      queue.send method
-      queue.destroy
-    end
+    Mockito.verify(server).createQueue(Matchers.anyBoolean,
+                                       Matchers.eq("my_queue"),
+                                       Matchers.anyString,
+                                       Matchers.anyBoolean)
+    Mockito.verify(server).destroyQueue("my_queue")
+  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)
+  it "should start and stop a topic" do
+    server = Mockito.mock(JMSServerManagerImpl.java_class)
+    TorqueBox::ServiceRegistry.stub!(:lookup).with("jboss.messaging.default.jms.manager").and_yield(server)
 
-      topic = TorqueBox::Messaging::Topic.new("my_topic")
-      topic.name.should eql("my_topic")
-      topic.send method
-      topic.destroy
-    end
+    topic = TorqueBox::Messaging::Topic.start( "my_topic" )
+    topic.name.should == "my_topic"
+    topic.stop
+
+    Mockito.verify(server).createTopic(Matchers.anyBoolean,
+                                       Matchers.eq("my_topic"))
 
+    Mockito.verify(server).destroyTopic("my_topic")
   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')
+      @queue.stub(:with_session).and_yield(@session)
     end
 
     context "normalizing options" do
@@ -94,294 +97,4 @@ describe TorqueBox::Messaging::Destination do
     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.decode.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.decode.should == 'ahoyhoy'
-      queue.detect { |m| m.decode == 'howdy' }.should be_nil
-      queue.detect { |m| m.decode == 'ahoyhoy' }.should_not 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 receive a binary file correctly" do
-      queue = TorqueBox::Messaging::Queue.new "/queues/foo"
-      queue.start
-
-      data = File.open("#{File.dirname(__FILE__)}/../src/test/resources/sample.pdf", "r") { |file| file.read }
-      queue.publish data
-      message = queue.receive
-
-      queue.destroy
-      message.should eql( data )
-    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 "durable topics" do
-      describe 'receive' do
-        it "should be durable" do
-          topic = TorqueBox::Messaging::Topic.new "/topics/foo", :client_id => 'blarg'
-          topic.start
-          
-          topic.receive :durable => true, :timeout => 1
-          topic.publish 'biscuit'
-          response = topic.receive :durable => true, :timeout => 10_000
-          response.should == 'biscuit'
-          
-          topic.destroy
-        end
-        
-        it "should raise if client_id is not set" do
-          topic = TorqueBox::Messaging::Topic.new "/topics/foo"
-          topic.start
-          
-          lambda { topic.receive :durable => true, :timeout => 1 }.should raise_error(ArgumentError)
-          
-          topic.destroy
-        end
-      end
-
-      describe 'unsubscribe' do
-        it "should work" do
-          topic = TorqueBox::Messaging::Topic.new "/topics/foo", :client_id => 'blarg'
-          topic.start
-          
-          topic.receive :durable => true, :timeout => 1
-          topic.publish 'biscuit'
-          response = topic.receive :durable => true, :timeout => 10_000
-          response.should == 'biscuit'
-
-          topic.unsubscribe
-
-          topic.publish 'ham'
-          response = topic.receive :durable => true, :timeout => 10
-          response.should be_nil
-          
-          topic.publish 'gravy'
-          response = topic.receive :durable => true, :timeout => 10_000
-          response.should == 'gravy'
-          
-          topic.destroy
-
-        end
-      end
-    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 => 120_000 ) { |msg| msg.upcase }
-        }
-        message = queue.publish_and_receive "ping", :timeout => 120_000
-        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 => 120_000 )
-        }
-        message = queue.publish_and_receive "ping", :timeout => 120_000
-        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 => 120_000 ) { |msg| msg.upcase }
-          }
-        end
-
-        message = queue.publish_and_receive "ping", :timeout => 120_000
-        # Send extra messages to trigger all remaining response threads
-        (thread_count - 1).times do
-          queue.publish_and_receive "ping", :timeout => 120_000
-        end
-        response_threads.each { |thread| thread.join }
-
-        queue.destroy
-        message.should eql( "PING" )
-      end
-
-      it "should allow a selector to be passed" do
-        queue = TorqueBox::Messaging::Queue.new "/queues/publish_and_receive"
-        queue.start
-
-        response_thread = Thread.new {
-          queue.receive_and_publish( :timeout => 120_000,
-                                     :selector => "age > 60 or tan = true" )
-        }
-
-        # Publish a non-synchronous message that should not match selector
-        queue.publish( "young and tan", :properties => { :age => 25, :tan => true } )
-        # Publish a synchronous message that should not match selector
-        queue.publish_and_receive( "young",
-                                   :timeout => 25,
-                                   :properties => { :age => 25 } )
-        # Publish a synchronous message that should match selector
-        message = queue.publish_and_receive( "wrinkled",
-                                             :timeout => 120_000,
-                                             :properties => { :age => 65, :tan => true } )
-        message.should eql( "wrinkled" )
-        response_thread.join
-
-        # Drain any remaining messages off the queue
-        2.times { queue.receive(:timeout => 10) }
-
-        queue.destroy
-      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