jruby-jms 0.10.0 → 0.10.1

data/HISTORY.md

@@ -1,3 +1,11 @@
+## 0.10.1 (2011-02-21)
+
+* Fix persistence typo and add message test cases
+
+## 0.10.0 (2011-02-10)
+
+* Refactoring interface
+
 ## 0.9.0 (2011-01-23)
 
 * Revised API with cleaner interface
@@ -10,4 +18,4 @@
 ## 2008, 2009, 2010
 
 * Previously known as jms4jruby
-* Running in production at an enterprise processing a million messages a day
+* Running in production at an enterprise processing a million messages a day

data/Rakefile

@@ -9,7 +9,7 @@ desc "Build gem"
 task :gem  do |t|
   gemspec = Gem::Specification.new do |s|
     s.name = 'jruby-jms'
-    s.version = '0.10.0'
+    s.version = '0.10.1'
     s.author = 'Reid Morrison'
     s.email = 'rubywmq@gmail.com'
     s.homepage = 'https://github.com/reidmorrison/jruby-jms'

data/examples/consumer.rb

@@ -17,7 +17,7 @@ config = YAML.load_file(File.join(File.dirname(__FILE__), 'jms.yml'))[jms_provid
 raise "JMS Provider option:#{jms_provider} not found in jms.yml file" unless config
 
 JMS::Connection.session(config) do |session|
-  session.consume(:q_name => 'ExampleQueue', :timeout=>1000) do |message|
+  session.consume(:queue_name => 'ExampleQueue', :timeout=>1000) do |message|
     p message
   end
 end

data/examples/performance/consumer.rb

@@ -17,7 +17,7 @@ config = YAML.load_file(File.join(File.dirname(__FILE__), '..', 'jms.yml'))[jms_
 raise "JMS Provider option:#{jms_provider} not found in jms.yml file" unless config
 
 JMS::Connection.session(config) do |session|
-  session.consumer(:q_name => 'ExampleQueue') do |consumer|
+  session.consumer(:queue_name => 'ExampleQueue') do |consumer|
     stats = consumer.each(:statistics => true) do |message|
       puts "=================================="
       p message

data/examples/performance/producer.rb

@@ -20,7 +20,7 @@ raise "JMS Provider option:#{jms_provider} not found in jms.yml file" unless con
 JMS::Connection.session(config) do |session|
   start_time = Time.now
   
-  session.producer(:q_name => 'ExampleQueue') do |producer|
+  session.producer(:queue_name => 'ExampleQueue') do |producer|
     count.times do |i| 
       producer.send(session.message("Hello Producer #{i}"))
     end

data/examples/producer.rb

@@ -17,7 +17,7 @@ config = YAML.load_file(File.join(File.dirname(__FILE__), 'jms.yml'))[jms_provid
 raise "JMS Provider option:#{jms_provider} not found in jms.yml file" unless config
 
 JMS::Connection.session(config) do |session|
-  session.producer(:q_name => 'ExampleQueue') do |producer|
+  session.producer(:queue_name => 'ExampleQueue') do |producer|
     producer.send(session.message("Hello World"))
   end
 end

data/lib/jms/connection.rb

@@ -40,7 +40,7 @@ module JMS
   #    :transport_type => com.ibm.mq.jms.JMSC::MQJMS_TP_CLIENT_MQ_TCPIP,
   #    :username => 'mqm'
   #  ) do |session|
-  #    session.consumer(:q_name=>'TEST', :mode=>:input) do |consumer|
+  #    session.consumer(:queue_name=>'TEST', :mode=>:input) do |consumer|
   #      if message = consumer.receive_no_wait
   #        puts "Data Received: #{message.data}"
   #      else
@@ -59,9 +59,9 @@ module JMS
     # call the supplied code block, then close the connection upon completion
     #
     # Returns the result of the supplied block
-    def self.start(parms = {}, &proc)
+    def self.start(params = {}, &proc)
       raise "Missing mandatory Block when calling JMS::Connection.start" unless proc
-      connection = Connection.new(parms)
+      connection = Connection.new(params)
       connection.start
       begin
         proc.call(connection)
@@ -77,9 +77,9 @@ module JMS
     # Useful when only a single session is required in the current thread
     #
     # Note: It is important that each thread have its own session to support transactions
-    def self.session(parms = {}, &proc)
-      self.start(parms) do |connection|
-        connection.session(parms, &proc)
+    def self.session(params = {}, &proc)
+      self.start(params) do |connection|
+        connection.session(params, &proc)
       end
     end
 
@@ -287,9 +287,9 @@ module JMS
     #  :options => any of the javax.jms.Session constants
     #      Default: javax.jms.Session::AUTO_ACKNOWLEDGE
     #
-    def session(parms={}, &proc)
+    def session(params={}, &proc)
       raise "Missing mandatory Block when calling JMS::Connection#session" unless proc
-      session = self.create_session(parms)
+      session = self.create_session(params)
       begin
         proc.call(session)
       ensure
@@ -328,9 +328,9 @@ module JMS
     #        session is transacted.
     #     Default: javax.jms.Session::AUTO_ACKNOWLEDGE
     #
-    def create_session(parms={})
-      transacted = parms[:transacted] || false
-      options = parms[:options] || javax.jms.Session::AUTO_ACKNOWLEDGE
+    def create_session(params={})
+      transacted = params[:transacted] || false
+      options = params[:options] || javax.jms.Session::AUTO_ACKNOWLEDGE
       @jms_connection.create_session(transacted, options)
     end
 
@@ -425,13 +425,13 @@ module JMS
     #                    Default: 1
     #
     # Consumer Parameters:
-    #   :q_name     => String: Name of the Queue to return
+    #   :queue_name     => String: Name of the Queue to return
     #                  Symbol: :temporary => Create temporary queue
     #                  Mandatory unless :topic_name is supplied
     #     Or,
     #   :topic_name => String: Name of the Topic to write to or subscribe to
     #                  Symbol: :temporary => Create temporary topic
-    #                  Mandatory unless :q_name is supplied
+    #                  Mandatory unless :queue_name is supplied
     #     Or,
     #   :destination=> Explicit javaxJms::Destination to use
     #
@@ -461,15 +461,15 @@ module JMS
     # Note: Also supply connection::on_exception so that connection failures can be handled
     #
     #
-    def on_message(parms, &proc)
+    def on_message(params, &proc)
       raise "JMS::Connection must be connected prior to calling JMS::Connection::on_message" unless @sessions && @consumers
 
-      consumer_count = parms[:session_count] || 1
+      consumer_count = params[:session_count] || 1
       consumer_count.times do
-        session = self.create_session(parms)
-        consumer = session.consumer(parms)
+        session = self.create_session(params)
+        consumer = session.consumer(params)
         if session.transacted?
-          consumer.on_message(parms) do |message|
+          consumer.on_message(params) do |message|
             begin
               proc.call(message) ? session.commit : session.rollback
             rescue => exc
@@ -478,7 +478,7 @@ module JMS
             end
           end
         else
-          consumer.on_message(parms, &proc)
+          consumer.on_message(params, &proc)
         end
         @consumers << consumer
         @sessions << session

data/lib/jms/javax_jms_message.rb

@@ -57,15 +57,15 @@ module javax.jms::Message
   # Header Fields - Attributes of the message
   
   # Return the JMS Delivery Mode as a symbol
-  #   :peristent
-  #   :non_peristent
+  #   :persistent
+  #   :non_persistent
   #   other: Value from javax.jms.DeliveryMode
   def jms_delivery_mode
     case getJMSDeliveryMode
     when javax.jms.DeliveryMode::PERSISTENT
-      :peristent
+      :persistent
     when javax.jms.DeliveryMode::NON_PERSISTENT
-      :non_peristent
+      :non_persistent
     else
       getJMSDeliveryMode
     end
@@ -73,14 +73,14 @@ module javax.jms::Message
   
   # Set the JMS Delivery Mode
   # Valid values for mode
-  #   :peristent
-  #   :non_peristent
+  #   :persistent
+  #   :non_persistent
   #   other: Any constant from javax.jms.DeliveryMode
   def jms_delivery_mode=(mode)
     val = case mode
-    when :peristent
+    when :persistent
       javax.jms.DeliveryMode::PERSISTENT
-    when :non_peristent
+    when :non_persistent
       javax.jms.DeliveryMode::NON_PERSISTENT
     else
       mode

data/lib/jms/javax_jms_message_consumer.rb

@@ -24,8 +24,8 @@ module javax.jms::MessageConsumer
   #         Note: Messages may still be on the queue, but the broker has not supplied any messages
   #                   in the time interval specified
   #    Default: 0
-  def get(parms={})
-    timeout = parms[:timeout] || 0
+  def get(params={})
+    timeout = params[:timeout] || 0
     if timeout == -1
       self.receive
     elsif timeout == 0
@@ -54,19 +54,19 @@ module javax.jms::MessageConsumer
   #              with :statistics => true
   #
   #              The statistics gathered are returned when :statistics => true and :async => false
-  def each(parms={}, &proc)
+  def each(params={}, &proc)
     raise "Destination::each requires a code block to be executed for each message received" unless proc
 
     message_count = nil
     start_time = nil
 
-    if parms[:statistics]
+    if params[:statistics]
       message_count = 0
       start_time = Time.now
     end
 
     # Receive messages according to timeout
-    while message = self.get(parms) do
+    while message = self.get(params) do
       proc.call(message)
       message_count += 1 if message_count
     end
@@ -97,10 +97,10 @@ module javax.jms::MessageConsumer
   #
   #              The statistics gathered are returned when :statistics => true and :async => false
   #
-  def on_message(parms={}, &proc)
+  def on_message(params={}, &proc)
     raise "MessageConsumer::on_message requires a code block to be executed for each message received" unless proc
 
-    @listener = JMS::MessageListener.new(parms,&proc)
+    @listener = JMS::MessageListener.new(params,&proc)
     self.setMessageListener @listener
   end
 

data/lib/jms/javax_jms_queue_browser.rb

@@ -16,7 +16,7 @@
 
 module javax.jms::QueueBrowser
   # For each message on the queue call the supplied Proc
-  def each(parms={}, &proc)
+  def each(params={}, &proc)
     raise "javax.jms.QueueBrowser::each requires a code block to be executed for each message received" unless proc
 
     e = self.getEnumeration

data/lib/jms/javax_jms_session.rb

@@ -161,19 +161,19 @@ module javax.jms::Session
   #     Or,
   #   :topic_name => String: Name of the Topic to write to or subscribe to
   #                  Symbol: :temporary => Create temporary topic
-  #                  Mandatory unless :q_name is supplied
+  #                  Mandatory unless :queue_name is supplied
   #     Or,
   #   :destination=> Explicit javaxJms::Destination to use
   #
   # Returns the result of the supplied block
-  def create_destination(parms)
+  def create_destination(params)
     # Allow a Java JMS destination object to be passed in 
-    return parms[:destination] if parms[:destination] && parms[:destination].java_kind_of?(javax.jms::Destination)
+    return params[:destination] if params[:destination] && params[:destination].java_kind_of?(javax.jms::Destination)
     
-    # :q_name is deprecated
-    queue_name = parms[:queue_name] || parms[:q_name]
-    topic_name = parms[:topic_name]
-    raise "Missing mandatory parameter :q_name or :topic_name to Session::producer, Session::consumer, or Session::browser" unless queue_name || topic_name
+    # :queue_name is deprecated
+    queue_name = params[:queue_name] || params[:queue_name]
+    topic_name = params[:topic_name]
+    raise "Missing mandatory parameter :queue_name or :topic_name to Session::producer, Session::consumer, or Session::browser" unless queue_name || topic_name
 
     if queue_name
       queue_name == :temporary ? create_temporary_queue : create_queue(queue_name)
@@ -208,16 +208,16 @@ module javax.jms::Session
   #     Or,
   #   :topic_name => String: Name of the Topic to write to or subscribe to
   #                  Symbol: :temporary => Create temporary topic
-  #                  Mandatory unless :q_name is supplied
+  #                  Mandatory unless :queue_name is supplied
   #     Or,
   #   :destination=> Explicit javaxJms::Destination to use
   #
   # Returns the result of the supplied block
-  def destination(parms={}, &block)
+  def destination(params={}, &block)
     raise "Missing mandatory Block when calling JMS::Session#destination" unless block
     dest = nil
     begin
-      dest = create_destination(parms)
+      dest = create_destination(params)
       block.call(dest)
     ensure
       # Delete Temporary Queue / Topic
@@ -283,17 +283,17 @@ module javax.jms::Session
   # Call the Proc if supplied, then automatically close the producer
   #
   # Parameters:
-  #   :q_name     => String: Name of the Queue to return
+  #   :queue_name     => String: Name of the Queue to return
   #                  Symbol: :temporary => Create temporary queue
   #                  Mandatory unless :topic_name is supplied
   #     Or,
   #   :topic_name => String: Name of the Topic to write to or subscribe to
   #                  Symbol: :temporary => Create temporary topic
-  #                  Mandatory unless :q_name is supplied
+  #                  Mandatory unless :queue_name is supplied
   #     Or,
   #   :destination=> Explicit javax.jms::Destination to use
-  def producer(parms, &proc)
-    destination = create_destination(parms)
+  def producer(params, &proc)
+    destination = create_destination(params)
     # Call original java method with this destination
     #p = java_send :create_producer, [javax.jms::Destination], destination
     p = create_producer(destination)
@@ -314,13 +314,13 @@ module javax.jms::Session
   # Call the Proc if supplied, then automatically close the consumer
   #
   # Parameters:
-  #   :q_name     => String: Name of the Queue to return
+  #   :queue_name     => String: Name of the Queue to return
   #                  Symbol: :temporary => Create temporary queue
   #                  Mandatory unless :topic_name is supplied
   #     Or,
   #   :topic_name => String: Name of the Topic to write to or subscribe to
   #                  Symbol: :temporary => Create temporary topic
-  #                  Mandatory unless :q_name is supplied
+  #                  Mandatory unless :queue_name is supplied
   #     Or,
   #   :destination=> Explicit javaxJms::Destination to use
   #
@@ -329,13 +329,13 @@ module javax.jms::Session
   #   :no_local   => Determine whether messages published by its own connection
   #                  should be delivered to it
   #                  Default: false
-  def consumer(parms, &proc)
-    destination = create_destination(parms)
+  def consumer(params, &proc)
+    destination = create_destination(params)
     c = nil
-    if parms[:no_local]
-      c = create_consumer(destination, parms[:selector] || '', parms[:no_local])
-    elsif parms[:selector]
-      c = create_consumer(destination, parms[:selector])
+    if params[:no_local]
+      c = create_consumer(destination, params[:selector] || '', params[:no_local])
+    elsif params[:selector]
+      c = create_consumer(destination, params[:selector])
     else
       c = create_consumer(destination)
     end
@@ -355,13 +355,13 @@ module javax.jms::Session
   # A consumer can read messages from the queue or topic
   #
   # Parameters:
-  #   :q_name     => String: Name of the Queue to return
+  #   :queue_name     => String: Name of the Queue to return
   #                  Symbol: :temporary => Create temporary queue
   #                  Mandatory unless :topic_name is supplied
   #     Or,
   #   :topic_name => String: Name of the Topic to write to or subscribe to
   #                  Symbol: :temporary => Create temporary topic
-  #                  Mandatory unless :q_name is supplied
+  #                  Mandatory unless :queue_name is supplied
   #     Or,
   #   :destination=> Explicit javaxJms::Destination to use
   #
@@ -379,10 +379,10 @@ module javax.jms::Session
   #                     in the time interval specified
   #      Default: 0
   #
-  def consume(parms, &proc)
-    c = self.consumer(parms)
+  def consume(params, &proc)
+    c = self.consumer(params)
     begin
-      c.each(parms, &proc)
+      c.each(params, &proc)
     ensure
       c.close
     end
@@ -395,7 +395,7 @@ module javax.jms::Session
   # Call the Proc if supplied, then automatically close the consumer
   #
   # Parameters:
-  #   :q_name     => String: Name of the Queue to return
+  #   :queue_name     => String: Name of the Queue to return
   #                  Symbol: :temporary => Create temporary queue
   #                  Mandatory unless :topic_name is supplied
   #     Or,
@@ -403,13 +403,13 @@ module javax.jms::Session
   #
   #   :selector   => Filter which messages should be returned from the queue
   #                  Default: All messages
-  def browser(parms, &proc)
+  def browser(params, &proc)
     raise "Session::browser requires a code block to be executed" unless proc
 
-    destination = create_destination(parms)
+    destination = create_destination(params)
     b = nil
-    if parms[:selector]
-      b = create_browser(destination, parms[:selector])
+    if params[:selector]
+      b = create_browser(destination, params[:selector])
     else
       b = create_browser(destination)
     end
@@ -428,7 +428,7 @@ module javax.jms::Session
   # Browse the specified queue, calling the Proc supplied for each message found
   #
   # Parameters:
-  #   :q_name     => String: Name of the Queue to return
+  #   :queue_name     => String: Name of the Queue to return
   #                  Symbol: :temporary => Create temporary queue
   #                  Mandatory unless :topic_name is supplied
   #     Or,
@@ -436,19 +436,19 @@ module javax.jms::Session
   #
   #   :selector   => Filter which messages should be returned from the queue
   #                  Default: All messages
-  def browse(parms={}, &proc)
-    self.browser(parms) {|b| b.each(parms, &proc)}
+  def browse(params={}, &proc)
+    self.browser(params) {|b| b.each(params, &proc)}
   end
 end
 
 # Workaround for IBM MQ JMS implementation that implements an undocumented consume method
 if defined? com.ibm.mq.jms::MQSession
   class com.ibm.mq.jms::MQSession
-    def consume(parms, &proc)
+    def consume(params, &proc)
       result = nil
-      c = self.consumer(parms)
+      c = self.consumer(params)
       begin
-        result = c.each(parms, &proc)
+        result = c.each(params, &proc)
       ensure
         c.close
       end

data/lib/jms/logging.rb

@@ -2,8 +2,10 @@
 module JMS
   
   # Returns the logger being used by jruby-jms
+  # Unless previously set, it will try to use the Rails logger and if it
+  # is not present, it will return a new Ruby logger
   def self.logger
-    @logger ||= (rails_logger || default_logger)
+    @logger ||= (self.rails_logger || self.ruby_logger)
   end
 
   # Replace the logger for jruby-jms
@@ -11,19 +13,22 @@ module JMS
     @logger = logger
   end
 
+  # Use the ruby logger, but add needed trace level logging which will result
+  # in debug log entries
+  def self.ruby_logger(level=nil, target=STDOUT)
+    require 'logger'
+
+    l = ::Logger.new(target)
+    l.instance_eval "alias :trace :debug"
+    l.instance_eval "alias :trace? :debug?"
+    l.level = level || ::Logger::INFO
+    l
+  end
+
   private
   def self.rails_logger
     (defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger) ||
       (defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER.respond_to?(:debug) && RAILS_DEFAULT_LOGGER)
   end
 
-  # By default we use the standard Ruby Logger
-  def self.default_logger
-    require 'logger'
-    require 'jms/logger'
-    l = Logger.new(STDOUT)
-    l.level = Logger::INFO
-    l
-  end
-
 end

data/lib/jms/message_listener.rb

@@ -32,10 +32,10 @@ module JMS
     #              is called again with :statistics => true
     #
     #              The statistics gathered are returned when :statistics => true and :async => false
-    def initialize(parms={}, &proc)
+    def initialize(params={}, &proc)
       @proc = proc
 
-      if parms[:statistics]
+      if params[:statistics]
         @message_count = 0
         @start_time = Time.now
       end

data/test/connection_test.rb

@@ -86,7 +86,7 @@ class JMSTest < Test::Unit::TestCase
       assert_nil connection.close
     end
 
-    should 'Create a session from the connection with parms' do
+    should 'Create a session from the connection with params' do
       connection = JMS::Connection.new(@config)
       
       session_parms = { 
@@ -105,7 +105,7 @@ class JMSTest < Test::Unit::TestCase
       assert_nil connection.close
     end
 
-    should 'Create a session from the connection with block and parms' do
+    should 'Create a session from the connection with block and params' do
       JMS::Connection.start(@config) do |connection|
       
         session_parms = { 
@@ -122,7 +122,7 @@ class JMSTest < Test::Unit::TestCase
       end
     end
 
-    should 'Create a session from the connection with block and parms opposite test' do
+    should 'Create a session from the connection with block and params opposite test' do
       JMS::Connection.start(@config) do |connection|
       
         session_parms = { 
@@ -143,7 +143,7 @@ class JMSTest < Test::Unit::TestCase
       should 'start an on_message handler' do
         JMS::Connection.start(@config) do |connection|
           value = nil
-          connection.on_message(:transacted => true, :q_name => :temporary) do |message|
+          connection.on_message(:transacted => true, :queue_name => :temporary) do |message|
             value = "received"
           end
         end

data/test/message_test.rb

@@ -0,0 +1,131 @@
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'jms'
+require 'yaml'
+
+class JMSTest < Test::Unit::TestCase
+  context 'JMS Session' do
+    # Load configuration from jms.yml
+    setup do
+      # To change the JMS provider, edit jms.yml and change :default
+      
+      # Load Connection parameters from configuration file
+      cfg = YAML.load_file(File.join(File.dirname(__FILE__), 'jms.yml'))
+      jms_provider = cfg['default']
+      @config = cfg[jms_provider]
+      raise "JMS Provider option:#{jms_provider} not found in jms.yml file" unless @config
+      @queue_name = @config[:queue_name] || raise("Mandatory :queue_name missing from jms.yml")
+      @topic_name = @config[:topic_name] || raise("Mandatory :topic_name missing from jms.yml")
+    end
+    
+    should 'produce and consume messages to/from a temporary queue' do
+      JMS::Connection.session(@config) do |session|
+        assert_not_nil session
+        data = nil
+        session.producer(:queue_name => :temporary) do |producer|
+          # Send Message
+          producer.send(session.message('Hello World'))
+          
+          # Consume Message
+          session.consume(:destination => producer.destination) do |message|
+            assert_equal message.java_kind_of?(javax.jms::TextMessage), true
+            data = message.data
+          end
+        end
+        assert_equal data, 'Hello World'
+      end
+    end
+
+    should 'produce, browse and consume messages to/from a queue' do
+      JMS::Connection.session(@config) do |session|
+        assert_not_nil session
+        data = nil
+        browse_data = nil
+        session.producer(:queue_name => @queue_name) do |producer|
+          # Send Message
+          producer.send(session.message('Hello World'))
+          
+          # Browse Message
+          session.browse(:queue_name => @queue_name) do |message|
+            assert_equal message.java_kind_of?(javax.jms::TextMessage), true
+            browse_data = message.data
+          end
+          
+          # Consume Message
+          session.consume(:queue_name => @queue_name) do |message|
+            assert_equal message.java_kind_of?(javax.jms::TextMessage), true
+            data = message.data
+          end
+        end
+        assert_equal 'Hello World', data
+        assert_equal 'Hello World', browse_data
+      end
+    end
+
+    should 'support setting persistence using symbols and the java constants' do
+      JMS::Connection.session(@config) do |session|
+        message = session.message('Hello World')
+        assert_equal message.jms_delivery_mode, :non_persistent
+        message.jms_delivery_mode = :non_persistent
+        assert_equal message.jms_delivery_mode, :non_persistent
+        message.jms_delivery_mode = :persistent
+        assert_equal message.jms_delivery_mode, :persistent
+      end
+    end  
+      
+    should 'produce and consume non-persistent messages' do
+      JMS::Connection.session(@config) do |session|
+        assert_not_nil session
+        data = nil
+        session.producer(:queue_name => :temporary) do |producer|
+          message = session.message('Hello World')
+          message.jms_delivery_mode = :non_persistent
+          assert_equal :non_persistent, message.jms_delivery_mode
+          assert_equal false, message.persistent?
+          
+          # Send Message
+          producer.send(message)
+          
+          # Consume Message
+          session.consume(:destination => producer.destination) do |message|
+            assert_equal message.java_kind_of?(javax.jms::TextMessage), true
+            data = message.data
+            #assert_equal :non_persistent, message.jms_delivery_mode
+            #assert_equal false, message.persistent?
+          end
+        end
+        assert_equal data, 'Hello World'
+      end
+    end
+
+    should 'produce and consume persistent messages' do
+      JMS::Connection.session(@config) do |session|
+        assert_not_nil session
+        data = nil
+        session.producer(:queue_name => :temporary) do |producer|
+          message = session.message('Hello World')
+          message.jms_delivery_mode = :persistent
+          assert_equal :persistent, message.jms_delivery_mode
+          assert_equal true, message.persistent?
+          
+          # Send Message
+          producer.send(message)
+          
+          # Consume Message
+          session.consume(:destination => producer.destination) do |message|
+            assert_equal message.java_kind_of?(javax.jms::TextMessage), true
+            data = message.data
+            assert_equal :persistent, message.jms_delivery_mode
+            assert_equal true, message.persistent?
+          end
+        end
+        assert_equal data, 'Hello World'
+      end
+    end
+
+  end
+end

data/test/session_test.rb

@@ -136,49 +136,5 @@ class JMSTest < Test::Unit::TestCase
       end
     end
     
-    should 'produce and consume messages to/from a temporary queue' do
-      JMS::Connection.session(@config) do |session|
-        assert_not_nil session
-        data = nil
-        session.producer(:queue_name => :temporary) do |producer|
-          # Send Message
-          producer.send(session.message('Hello World'))
-          
-          # Consume Message
-          session.consume(:destination => producer.destination) do |message|
-            assert_equal message.java_kind_of?(javax.jms::TextMessage), true
-            data = message.data
-          end
-        end
-        assert_equal data, 'Hello World'
-      end
-    end
-
-    should 'produce, browse and consume messages to/from a queue' do
-      JMS::Connection.session(@config) do |session|
-        assert_not_nil session
-        data = nil
-        browse_data = nil
-        session.producer(:queue_name => @queue_name) do |producer|
-          # Send Message
-          producer.send(session.message('Hello World'))
-          
-          # Browse Message
-          session.browse(:queue_name => @queue_name) do |message|
-            assert_equal message.java_kind_of?(javax.jms::TextMessage), true
-            browse_data = message.data
-          end
-          
-          # Consume Message
-          session.consume(:queue_name => @queue_name) do |message|
-            assert_equal message.java_kind_of?(javax.jms::TextMessage), true
-            data = message.data
-          end
-        end
-        assert_equal data, 'Hello World'
-        assert_equal browse_data, 'Hello World'
-      end
-    end
-
   end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
     - 0
     - 10
-    - 0
-  version: 0.10.0
+    - 1
+  version: 0.10.1
 platform: ruby
 authors: 
   - Reid Morrison
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-10 00:00:00 -05:00
+date: 2011-02-21 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -45,11 +45,11 @@ files:
   - lib/jms/javax_jms_queue_browser.rb
   - lib/jms/javax_jms_session.rb
   - lib/jms/javax_jms_text_message.rb
-  - lib/jms/logger.rb
   - lib/jms/logging.rb
   - lib/jms/message_listener.rb
   - test/connection_test.rb
   - test/jms.yml
+  - test/message_test.rb
   - test/session_test.rb
 has_rdoc: true
 homepage: https://github.com/reidmorrison/jruby-jms

data/lib/jms/logger.rb

@@ -1,4 +0,0 @@
-# Add trace method to Ruby Logger class
-class Logger
-  alias :trace :debug
-end