stomp 1.1.8 → 1.1.9

data/CHANGELOG.rdoc

@@ -1,4 +1,15 @@
-== 1.1.8 2010-16-05
+== 1.1.9 2011-15-06
+
+* Support wildcard destinations
+* Handle subscribe with string or symbol ID
+* Check for duplicate subscriptions in spec tests
+* Support AMQ and Apollo servers in uinit tests
+* Correct UTF-8 (Unicode) content-length calcualtion in Ruby 1.9
+* Send of a nil body causes exception
+* Add optional callback logging.  See the examples install directory, files logexamp.rb and slogger.rb
+* Correct date stamps in this file
+
+== 1.1.8 2011-16-03
 
 * Set KEEPALIVE on connection socket options
 * Attempt to support JRuby more robustly (poll remains broken)
@@ -9,7 +20,7 @@
 * Allow connection to hosts with a - (dash) in the host name
 * Add limit parameter to thread joins
 
-== 1.1.7 2010-09-01
+== 1.1.7 2011-09-01
 
 * Binary parse of raw STOMP frame
 * Fix broken tests on Ruby 1.9.2

data/README.rdoc

@@ -51,6 +51,7 @@ An implementation of the Stomp protocol for Ruby. See:
       :timeout => -1,
       :connect_headers => {},
       :parse_timeout => 5,
+      :logger => nil,
     }
     
     # for client
@@ -101,4 +102,6 @@ The following people have contributed to Stomp:
 * Stefan Saasen
 * Neil Wilson
 * Dinesh Majrekar
+* Kiall Mac Innes
+* Rob Skaggs
 

data/Rakefile

@@ -21,7 +21,7 @@ require "stomp/version"
 begin
   require "hanna/rdoctask"
 rescue LoadError => e
-  require "rake/rdoctask"
+  require "rdoc/task"
 end
 
 begin

data/examples/logexamp.rb

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'stomp'
+require 'logger'  # for the 'local' logger
+#
+$:.unshift(File.dirname(__FILE__))
+#
+require 'slogger'
+#
+# A STOMP client program which uses the callback logging facility.
+#
+llog =        Logger::new(STDOUT)
+llog.level =  Logger::DEBUG
+llog.debug "LE Starting"
+
+# //////////////////////////////////////////////////////////////////////////////
+mylog = Slogger::new  # The client provided STOMP callback logger
+
+# //////////////////////////////////////////////////////////////////////////////
+user =      ENV['STOMP_USER'] ? ENV['STOMP_USER'] : 'guest'
+password =  ENV['STOMP_PASSWORD'] ? ENV['STOMP_PASSWORD'] : 'guestpw'
+host =      ENV['STOMP_HOST'] ? ENV['STOMP_HOST'] : 'localhost'
+port =      ENV['STOMP_PORT'] ? ENV['STOMP_PORT'].to_i : 61613
+# //////////////////////////////////////////////////////////////////////////////
+# A hash type connect *MUST* be used to enable callback logging.
+# //////////////////////////////////////////////////////////////////////////////
+hash = { :hosts => [ 
+          {:login => user, :passcode => password, :host => 'noonehome', :port => 2525},
+          {:login => user, :passcode => password, :host => host, :port => port},
+          ],
+          :logger => mylog,	# This enables callback logging!
+          :max_reconnect_attempts => 5,
+        }
+
+# //////////////////////////////////////////////////////////////////////////////
+# For a Connection:
+conn = Stomp::Connection.new(hash)
+conn.disconnect
+# //////////////////////////////////////////////////////////////////////////////
+llog.debug "LE Connection processing complete"
+
+# //////////////////////////////////////////////////////////////////////////////
+# For a Client:
+conn = Stomp::Client.new(hash)
+conn.close
+# //////////////////////////////////////////////////////////////////////////////
+# llog.debug "LE Client processing complete"
+
+# //////////////////////////////////////////////////////////////////////////////
+llog.debug "LE Ending"
+

data/examples/slogger.rb

@@ -0,0 +1,100 @@
+=begin
+
+Example STOMP call back logger class.
+
+Optional callback methods:
+
+    on_connecting: connection starting
+    on_connected: successful connect
+    on_connectfail: unsuccessful connect (will usually be retried)
+    on_disconnect: successful disconnect
+
+    on_miscerr: on miscellaneous xmit/recv errors
+
+All methods are optional, at the user's requirements.
+
+If a method is not provided, it is not called (of course.)
+
+IMPORTANT NOTE:  call back logging methods *MUST* not raise exceptions, 
+otherwise the underlying STOMP connection will fail in mysterious ways.
+
+Callback parameters: are a copy of the @parameters instance variable for
+the Stomp::Connection.
+
+=end
+
+require 'logger'	# use the standard Ruby logger .....
+
+class Slogger
+  #
+  def initialize(init_parms = nil)
+    @log = Logger::new(STDOUT)		# User preference
+    @log.level = Logger::DEBUG		# User preference
+    @log.info("Logger initialization complete.")
+  end
+
+  # Log connecting events
+  def on_connecting(parms)
+    begin
+      @log.debug "Connecting: #{info(parms)}"
+    rescue
+      @log.debug "Connecting oops"
+    end
+  end
+
+  # Log connected events
+  def on_connected(parms)
+    begin
+      @log.debug "Connected: #{info(parms)}"
+    rescue
+      @log.debug "Connected oops"
+    end
+  end
+
+  # Log connectfail events
+  def on_connectfail(parms)
+    begin
+      @log.debug "Connect Fail #{info(parms)}"
+    rescue
+      @log.debug "Connect Fail oops"
+    end
+  end
+
+  # Log disconnect events
+  def on_disconnect(parms)
+    begin
+      @log.debug "Disconnected #{info(parms)}"
+    rescue
+      @log.debug "Disconnected oops"
+    end
+  end
+
+
+  # Log miscellaneous errors
+  def on_miscerr(parms, errstr)
+    begin
+      @log.debug "Miscellaneous Error #{info(parms)}"
+      @log.debug "Miscellaneous Error String #{errstr}"
+    rescue
+      @log.debug "Miscellaneous Error oops"
+    end
+  end
+
+  private
+
+  def info(parms)
+    #
+    # Available in the Hash:
+    # parms[:cur_host]
+    # parms[:cur_port]
+    # parms[:cur_login]
+    # parms[:cur_passcode]
+    # parms[:cur_ssl]
+    # parms[:cur_recondelay]
+    # parms[:cur_parseto]
+    # parms[:cur_conattempts]
+    #
+    "Host: #{parms[:cur_host]}, Port: #{parms[:cur_port]}, Login: Port: #{parms[:cur_login]}, Passcode: #{parms[:cur_passcode]}" 
+  end
+end # of class
+

data/lib/stomp/client.rb

@@ -1,4 +1,5 @@
 require 'thread'
+require 'digest/sha1'
 
 module Stomp
 
@@ -121,7 +122,7 @@ module Stomp
       replay_list = @replay_messages_by_txn[name]
       if replay_list
         replay_list.each do |message|
-          if listener = @listeners[message.headers['destination']]
+          if listener = find_listener(message)
             listener.call(message)
           end
         end
@@ -141,14 +142,22 @@ module Stomp
     # Accepts a transaction header ( :transaction => 'some_transaction_id' )
     def subscribe(destination, headers = {})
       raise "No listener given" unless block_given?
-      @listeners[destination] = lambda {|msg| yield msg}
+      # use subscription id to correlate messages to subscription. As described in
+      # the SUBSCRIPTION section of the protocol: http://stomp.codehaus.org/Protocol.
+      # If no subscription id is provided, generate one.
+      set_subscription_id_if_missing(destination, headers)
+      if @listeners[headers[:id]]
+        raise "attempting to subscribe to a queue with a previous subscription"
+      end
+      @listeners[headers[:id]] = lambda {|msg| yield msg}
       @connection.subscribe(destination, headers)
     end
 
     # Unsubecribe from a channel
     def unsubscribe(name, headers = {})
+      set_subscription_id_if_missing(name, headers)
       @connection.unsubscribe(name, headers)
-      @listeners[name] = nil
+      @listeners[headers[:id]] = nil
     end
 
     # Acknowledge a message, used when a subscription has specified
@@ -230,6 +239,16 @@ module Stomp
     end
 
     private
+      # Set a subscription id in the headers hash if one does not already exist.
+      # For simplicities sake, all subscriptions have a subscription ID.
+      # setting an id in the SUBSCRIPTION header is described in the stomp protocol docs:
+      # http://stomp.codehaus.org/Protocol
+      def set_subscription_id_if_missing(destination, headers)
+        headers[:id] = headers[:id] ? headers[:id] : headers['id'] 
+        if headers[:id] == nil
+          headers[:id] = Digest::SHA1.hexdigest(destination)
+        end
+      end
 
       def register_receipt_listener(listener)
         id = -1
@@ -284,6 +303,17 @@ module Stomp
         new_options
       end
       
+      def find_listener(message)
+        subscription_id = message.headers['subscription']
+        if subscription_id == nil
+          # For backward compatibility, some messages may already exist with no
+          # subscription id, in which case we can attempt to synthesize one.
+          set_subscription_id_if_missing(message.headers['destination'], message.headers)
+          subscription_id = message.headers['id']
+        end
+        @listeners[subscription_id]
+      end
+
       def start_listeners
         @listeners = {}
         @receipt_listeners = {}
@@ -293,7 +323,7 @@ module Stomp
           while true
             message = @connection.receive
             if message.command == 'MESSAGE'
-              if listener = @listeners[message.headers['destination']]
+              if listener = find_listener(message)
                 listener.call(message)
               end
             elsif message.command == 'RECEIPT'

data/lib/stomp/connection.rb

@@ -43,6 +43,7 @@ module Stomp
     #     :timeout => -1,
     #     :connect_headers => {},
     #     :parse_timeout => 5,
+    #     :logger => nil,
     #   }
     #
     #   e.g. c = Connection.new(hash)
@@ -72,6 +73,7 @@ module Stomp
         @ssl = false
         @parameters = nil
         @parse_timeout = 5		# To override, use hashed parameters
+        @logger = nil     		# To override, use hashed parameters
       end
       
       # Use Mutexes:  only one lock per each thread
@@ -94,8 +96,12 @@ module Stomp
       @reconnect_delay = @parameters[:initial_reconnect_delay]
       @connect_headers = @parameters[:connect_headers]
       @parse_timeout =  @parameters[:parse_timeout]
+      @logger =  @parameters[:logger]
       #sets the first host to connect
       change_host
+      if @logger && @logger.respond_to?(:on_connecting)            
+        @logger.on_connecting(log_params)
+      end
     end
     
     # Syntactic sugar for 'Connection.new' See 'initialize' for usage.
@@ -115,14 +121,19 @@ module Stomp
             # Open complete
             
             connect(used_socket)
-            
+            if @logger && @logger.respond_to?(:on_connected)
+              @logger.on_connected(log_params) 
+            end
             @connection_attempts = 0
           rescue
             @failure = $!
             used_socket = nil
             raise unless @reliable
-            $stderr.print "connect to #{@host} failed: #{$!} will retry(##{@connection_attempts}) in #{@reconnect_delay}\n"
-
+            if @logger && @logger.respond_to?(:on_connectfail)            
+              @logger.on_connectfail(log_params) 
+            else
+              $stderr.print "connect to #{@host} failed: #{$!} will retry(##{@connection_attempts}) in #{@reconnect_delay}\n"
+            end
             raise Stomp::Error::MaxReconnectAttempts if max_reconnect_attempts?
 
             sleep(@reconnect_delay)
@@ -310,6 +321,9 @@ module Stomp
       transmit("DISCONNECT", headers)
       headers = headers.symbolize_keys
       @disconnect_receipt = receive if headers[:receipt]
+      if @logger && @logger.respond_to?(:on_disconnect)
+        @logger.on_disconnect(log_params)
+      end
       close_socket
     end
 
@@ -332,7 +346,12 @@ module Stomp
         rescue
           @failure = $!
           raise unless @reliable
-          $stderr.print "receive failed: #{$!}"
+          errstr = "receive failed: #{$!}"
+          if @logger && @logger.respond_to?(:on_miscerr)
+            @logger.on_miscerr(log_params, errstr)
+          else
+            $stderr.print errstr
+          end
         end
       end
     end
@@ -340,7 +359,12 @@ module Stomp
     def receive
       super_result = __old_receive
       if super_result.nil? && @reliable
-        $stderr.print "connection.receive returning EOF as nil - resetting connection.\n"
+        errstr = "connection.receive returning EOF as nil - resetting connection.\n"
+        if @logger && @logger.respond_to?(:on_miscerr)
+          @logger.on_miscerr(log_params, errstr)
+        else
+          $stderr.print errstr
+        end
         @socket = nil
         super_result = __old_receive
       end
@@ -412,23 +436,37 @@ module Stomp
             used_socket = socket
             _transmit(used_socket, command, headers, body)
             return
+          rescue Stomp::Error::MaxReconnectAttempts => e
+              raise
           rescue
             @failure = $!
             raise unless @reliable
-            $stderr.print "transmit to #{@host} failed: #{$!}\n"
+            errstr = "transmit to #{@host} failed: #{$!}\n"
+            if @logger && @logger.respond_to?(:on_miscerr)
+              @logger.on_miscerr(log_params, errstr)
+            else
+              $stderr.print errstr
+            end
           end
         end
       end
 
       def _transmit(used_socket, command, headers = {}, body = '')
         @transmit_semaphore.synchronize do
+          # Handle nil body
+          body = '' if body.nil?
+          # The content-length should be expressed in bytes.
+          # Ruby 1.8: String#length => # of bytes; Ruby 1.9: String#length => # of characters
+          # With Unicode strings, # of bytes != # of characters.  So, use String#bytesize when available.
+          body_length_bytes = body.respond_to?(:bytesize) ? body.bytesize : body.length
+ 
           # ActiveMQ interprets every message as a BinaryMessage 
           # if content_length header is included. 
           # Using :suppress_content_length => true will suppress this behaviour
           # and ActiveMQ will interpret the message as a TextMessage.
           # For more information refer to http://juretta.com/log/2009/05/24/activemq-jms-stomp/
           # Lets send this header in the message, so it can maintain state when using unreceive
-          headers['content-length'] = "#{body.length}" unless headers[:suppress_content_length]
+          headers['content-length'] = "#{body_length_bytes}" unless headers[:suppress_content_length]
           
           used_socket.puts command  
           headers.each {|k,v| used_socket.puts "#{k}:#{v}" }
@@ -502,6 +540,19 @@ module Stomp
         @subscriptions.each { |k,v| _transmit(used_socket, "SUBSCRIBE", v) }
       end
 
+      def log_params
+        lparms = @parameters.clone
+        lparms[:cur_host] = @host
+        lparms[:cur_port] = @port
+        lparms[:cur_login] = @login
+        lparms[:cur_passcode] = @passcode
+        lparms[:cur_ssl] = @ssl
+        lparms[:cur_recondelay] = @reconnect_delay
+        lparms[:cur_parseto] = @parse_timeout
+        lparms[:cur_conattempts] = @connection_attempts
+        #
+        lparms
+      end
   end
 
 end

data/lib/stomp/version.rb

@@ -2,7 +2,7 @@ module Stomp
   module Version  #:nodoc: all
     MAJOR = 1
     MINOR = 1
-    PATCH = 8
+    PATCH = 9
     STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
   end
 end

data/spec/client_shared_examples.rb

@@ -49,6 +49,20 @@ shared_examples_for "standard Client" do
       }.should_not raise_error
     end
 
+    it "should raise RuntimeError on duplicate subscriptions" do
+      lambda {
+        @client.subscribe(@destination)
+        @client.subscribe(@destination)
+      }.should raise_error
+    end
+
+    it "should raise RuntimeError with duplicate id headers" do
+      lambda {
+        @client.subscribe(@destination, {'id' => 'abcdef'})
+        @client.subscribe(@destination, {'id' => 'abcdef'})
+      }.should raise_error
+    end
+
   end
 
 end

data/spec/connection_spec.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 require 'spec_helper'
 
 describe Stomp::Connection do
@@ -89,6 +90,11 @@ describe Stomp::Connection do
         @tcp_socket.should_not_receive(:puts).with("content-length:7")
         @connection.publish "/queue", "message", :suppress_content_length => true
       end
+      
+      it "should get the correct byte length when dealing with Unicode characters" do
+        @tcp_socket.should_receive(:puts).with("content-length:18")
+        @connection.publish "/queue", "сообщение"  # 'сообщение' is 'message' in Russian
+      end
     end
     
     describe "when unacknowledging a message" do
@@ -180,6 +186,15 @@ describe Stomp::Connection do
     
     end
     
+    describe "when sending a nil message body" do
+      it "should should not raise an error" do
+        @connection = Stomp::Connection.new("niluser", "nilpass", "localhost", 61613)
+        lambda {
+          @connection.publish("/queue/nilq", nil)
+        }.should_not raise_error
+     end
+    end
+
     describe "when using ssl" do
 
       # Mocking ruby's openssl extension, so we can test without requiring openssl  

data/stomp.gemspec

@@ -5,14 +5,14 @@
 
 Gem::Specification.new do |s|
   s.name = %q{stomp}
-  s.version = "1.1.8"
+  s.version = "1.1.9"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Brian McCallister", "Marius Mathiesen", "Thiago Morello", "Guy M. Allard"]
-  s.date = %q{2011-03-16}
+  s.authors = [%q{Brian McCallister}, %q{Marius Mathiesen}, %q{Thiago Morello}, %q{Guy M. Allard}]
+  s.date = %q{2011-06-16}
   s.description = %q{Ruby client for the Stomp messaging protocol}
-  s.email = ["brianm@apache.org", "marius@stones.com", "morellon@gmail.com", "allard.guy.m@gmail.com"]
-  s.executables = ["catstomp", "stompcat"]
+  s.email = [%q{brianm@apache.org}, %q{marius@stones.com}, %q{morellon@gmail.com}, %q{allard.guy.m@gmail.com}]
+  s.executables = [%q{catstomp}, %q{stompcat}]
   s.extra_rdoc_files = [
     "LICENSE",
     "README.rdoc"
@@ -25,7 +25,9 @@ Gem::Specification.new do |s|
     "bin/catstomp",
     "bin/stompcat",
     "examples/consumer.rb",
+    "examples/logexamp.rb",
     "examples/publisher.rb",
+    "examples/slogger.rb",
     "lib/stomp.rb",
     "lib/stomp/client.rb",
     "lib/stomp/connection.rb",
@@ -45,25 +47,11 @@ Gem::Specification.new do |s|
     "test/test_message.rb"
   ]
   s.homepage = %q{https://rubygems.org/gems/stomp}
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.5}
   s.summary = %q{Ruby client for the Stomp messaging protocol}
-  s.test_files = [
-    "examples/consumer.rb",
-    "examples/publisher.rb",
-    "spec/client_shared_examples.rb",
-    "spec/client_spec.rb",
-    "spec/connection_spec.rb",
-    "spec/message_spec.rb",
-    "spec/spec_helper.rb",
-    "test/test_client.rb",
-    "test/test_connection.rb",
-    "test/test_helper.rb",
-    "test/test_message.rb"
-  ]
 
   if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then

data/test/test_client.rb

@@ -151,6 +151,93 @@ class TestClient < Test::Unit::TestCase
     @client.commit 'tx2'
   end
 
+  def test_raise_on_multiple_subscriptions_to_same_destination
+    subscribe_dest = destination
+    @client.subscribe(subscribe_dest) {|m| nil }
+    assert_raise(RuntimeError) do
+      @client.subscribe(subscribe_dest) {|m| nil }
+    end
+  end
+
+  def test_raise_on_multiple_subscriptions_to_same_id
+    subscribe_dest = destination
+    @client.subscribe(subscribe_dest, {'id' => 'myid'}) {|m| nil }
+    assert_raise(RuntimeError) do
+      @client.subscribe(subscribe_dest, {'id' => 'myid'}) {|m| nil }
+    end
+  end
+
+  def test_raise_on_multiple_subscriptions_to_same_id_mixed
+    subscribe_dest = destination
+    @client.subscribe(subscribe_dest, {'id' => 'myid'}) {|m| nil }
+    assert_raise(RuntimeError) do
+      @client.subscribe(subscribe_dest, {:id => 'myid'}) {|m| nil }
+    end
+  end
+
+  def  test_asterisk_wildcard_subscribe
+    queue_base_name = destination
+    queue1 = queue_base_name + ".a"
+    queue2 = queue_base_name + ".b"
+    send_message = message_text
+    @client.publish queue1, send_message
+    @client.publish queue2, send_message
+    messages = []
+    @client.subscribe(queue_base_name + ".*", :ack => 'client') do |m|
+      messages << m
+      @client.acknowledge(m)
+    end
+    Timeout::timeout(4) do
+      sleep 0.1 while messages.size < 2
+    end
+
+    messages.each do |message|
+      assert_not_nil message
+      assert_equal send_message, message.body
+    end
+    results = [queue1, queue2].collect do |queue|
+      messages.any? do |message| 
+        message_source = message.headers['destination']
+        message_source == queue
+      end
+    end
+    assert results.all?{|a| a == true }
+
+  end unless ENV['STOMP_NOWILD']
+
+  def test_greater_than_wildcard_subscribe
+    queue_base_name = destination + "."
+    queue1 = queue_base_name + "foo.a"
+    queue2 = queue_base_name + "bar.a"
+    queue3 = queue_base_name + "foo.b"
+    send_message = message_text
+    @client.publish queue1, send_message
+    @client.publish queue2, send_message
+    @client.publish queue3, send_message
+    messages = []
+    # should subscribe to all three queues
+    @client.subscribe(queue_base_name + ">", :ack => 'client') do |m|
+      messages << m
+      @client.acknowledge(m)
+    end
+    Timeout::timeout(4) do
+      sleep 0.1 while messages.size < 3
+    end
+
+    messages.each do |message|
+      assert_not_nil message
+      assert_equal send_message, message.body
+    end
+    # make sure that the messages received came from the expected queues
+    results = [queue1, queue2, queue3].collect do |queue|
+      messages.any? do |message| 
+        message_source = message.headers['destination']
+        message_source == queue
+      end
+    end
+    assert results.all?{|a| a == true }
+  end unless ENV['STOMP_NOWILD'] || ENV['STOMP_APOLLO']
+
   def test_transaction_with_client_side_redelivery
     @client.publish destination, message_text
 
@@ -252,7 +339,7 @@ class TestClient < Test::Unit::TestCase
       @client.publish(dest, message_text)
     end
     #
-    max_sleep=5
+    max_sleep = (RUBY_VERSION =~ /1\.8\.6/) ? 30 : 5
     sleep_incr = 0.10
     total_slept = 0
     while true
@@ -272,6 +359,6 @@ class TestClient < Test::Unit::TestCase
 
     def destination
       name = caller_method_name unless name
-      "/queue/test/ruby/client/" + name
+      qname = ENV['STOMP_APOLLO'] ? "/queue/test.ruby.stomp." + name : "/queue/test/ruby/stomp/" + name
     end
 end

data/test/test_connection.rb

@@ -142,19 +142,20 @@ class TestStomp < Test::Unit::TestCase
 
   def test_thread_poll_one
     received = nil
+    max_sleep = (RUBY_VERSION =~ /1\.8\.6/) ? 5 : 1
     Thread.new(@conn) do |amq|
         while true
           received = amq.poll
           # One message is needed
           Thread.exit if received
-          sleep 0.1
+          sleep max_sleep
         end
     end
     #
     @conn.subscribe( make_destination )
     message = Time.now.to_s
     @conn.publish(make_destination, message)
-    sleep 1
+    sleep max_sleep+1
     assert_not_nil received
     assert_equal message, received.body
   end
@@ -183,7 +184,7 @@ class TestStomp < Test::Unit::TestCase
       @conn.publish(dest, msg)
     end
     #
-    max_sleep=5
+    max_sleep = (RUBY_VERSION =~ /1\.8\.6/) ? 30 : 5
     sleep_incr = 0.10
     total_slept = 0
     while true
@@ -225,7 +226,7 @@ class TestStomp < Test::Unit::TestCase
       @conn.publish(dest, msg)
     end
     #
-    max_sleep=5
+    max_sleep = (RUBY_VERSION =~ /1\.8\.6/) ? 30 : 5
     sleep_incr = 0.10
     total_slept = 0
     while true
@@ -237,10 +238,20 @@ class TestStomp < Test::Unit::TestCase
     assert_equal @max_msgs, msg_ctr
   end
 
+  def test_nil_body
+    dest = make_destination
+    assert_nothing_raised {
+      @conn.publish dest, nil
+    }
+    @conn.subscribe dest
+    msg = @conn.receive
+    assert_equal "", msg.body    
+  end
+
   private
     def make_destination
       name = caller_method_name unless name
-      "/queue/test/ruby/stomp/" + name
+      qname = ENV['STOMP_APOLLO'] ? "/queue/test.ruby.stomp." + name : "/queue/test/ruby/stomp/" + name
     end
 
     def _test_transaction

data/test/test_message.rb

@@ -112,7 +112,7 @@ class TestMessageKcode < Test::Unit::TestCase
   private
     def make_destination
       name = caller_method_name unless name
-      "/queue/test/rubyk01/stomp/" + name
+      qname = ENV['STOMP_APOLLO'] ? "/queue/test.rubyk01.stomp." + name : "/queue/test/rubyk01/stomp/" + name
     end
 end
 

metadata

@@ -1,14 +1,10 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: stomp
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 1
-  - 1
-  - 8
-  version: 1.1.8
+version: !ruby/object:Gem::Version
+  version: 1.1.9
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Brian McCallister
 - Marius Mathiesen
 - Thiago Morello
@@ -16,39 +12,33 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-03-16 00:00:00 -04:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-06-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rspec
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &18191140 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 3
-        version: "2.3"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.3'
   type: :development
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: *18191140
 description: Ruby client for the Stomp messaging protocol
-email: 
+email:
 - brianm@apache.org
 - marius@stones.com
 - morellon@gmail.com
 - allard.guy.m@gmail.com
-executables: 
+executables:
 - catstomp
 - stompcat
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - LICENSE
 - README.rdoc
-files: 
+files:
 - CHANGELOG.rdoc
 - LICENSE
 - README.rdoc
@@ -56,7 +46,9 @@ files:
 - bin/catstomp
 - bin/stompcat
 - examples/consumer.rb
+- examples/logexamp.rb
 - examples/publisher.rb
+- examples/slogger.rb
 - lib/stomp.rb
 - lib/stomp/client.rb
 - lib/stomp/connection.rb
@@ -74,47 +66,28 @@ files:
 - test/test_connection.rb
 - test/test_helper.rb
 - test/test_message.rb
-has_rdoc: true
 homepage: https://rubygems.org/gems/stomp
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
 summary: Ruby client for the Stomp messaging protocol
-test_files: 
-- examples/consumer.rb
-- examples/publisher.rb
-- spec/client_shared_examples.rb
-- spec/client_spec.rb
-- spec/connection_spec.rb
-- spec/message_spec.rb
-- spec/spec_helper.rb
-- test/test_client.rb
-- test/test_connection.rb
-- test/test_helper.rb
-- test/test_message.rb
+test_files: []