jsparrow 1.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Leandro Silva (CodeZone) <leandrodoze@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,78 @@
+= jsparrow
+
+JSparrow is a JMS client based on JRuby. Previously it has been called Sparrow, but changed his name because has another project with the same name.
+
+=== Install
+
+Make gem install:
+
+  sudo gem install jsparrow -s http://gemcutter.org
+
+=== Example
+
+===== Six steps to send and receive JMS messages to/from a JMS middleware.
+
+WARNING: OpenJMS will be used as JMS middleware, but any other could be used with no problems.
+
+1) Create my_jsparrow_test.rb file and require the gems
+
+  require 'rubygems'
+  require 'jsparrow'
+
+2) Setup indispensable informations to connect your JMS middleware
+
+  JSparrow::Connection.configure do |connection|
+    connection.use_jms_client_jar '/opt/openjms/lib/openjms-0.7.7-beta-1.jar'
+
+    connection.use_jndi_properties :initial_context_factory => 'org.exolab.jms.jndi.InitialContextFactory',
+                                   :provider_url            => 'tcp://localhost:3035'
+                                 # :security_principal      => 'user',
+                                 # :security_credentials    => 'password'
+
+    connection.enable_connection_factories :queue_connection_factory => 'ConnectionFactory', 
+                                           :topic_connection_factory => 'ConnectionFactory'
+  end
+
+3) Create the client and setup a queue
+
+  jms_client = JSparrow::Connection.new_client
+  jms_client.enable_queues :my_queue => 'MyQueue'
+  
+4) After appropriate setup, start the client
+
+  jms_client.start
+
+5) OK! Now you can send and receive messages right now!
+
+  jms_client.queue_sender(:my_queue).send_text_message('jsparrow rocks!') do |msg|
+    msg.set_string_property('recipient', 'jsparrow-example')
+  end
+
+  jms_client.queue_receiver(:my_queue).receive_message(
+      :timeout  => 5000,
+      :selector => "recipient = 'jsparrow-example'"
+    ) do |msg|
+    
+    puts "is text message? #{msg.is_text_message?}"    # is text message? true
+    puts "message: #{msg.text}"                        # message: jsparrow rocks!
+  end
+
+6) After you receive your amazing messages, stop the client
+
+  jms_client.stop
+
+So, now that you did code and save it, start the OpenJMS server, create the queue (MyQueue), and run above script:
+
+  jruby my_jsparrow_test.rb
+
+jsparrow rocks! =)
+
+===== Sample code
+
+Or, if you don't want write code, only do it:
+
+  jruby sample/sample.rb
+
+== Copyright
+
+Copyright (c) 2009 Leandro Silva (CodeZone) <leandrodoze@gmail.com>. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "jsparrow"
+    gem.summary = "JSparrow is a JMS client based on JRuby"
+    gem.email = "leandrodoze@gmail.com"
+    gem.homepage = "http://github.com/leandrosilva/jsparrow"
+    gem.authors = ["Leandro Silva"]
+    gem.files =  FileList["[A-Z]*", "{lib,sample,spec}/**/*"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler -s http://gemcutter.org"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'jsparrow'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = false
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test

data/VERSION.yml

@@ -0,0 +1,5 @@
+--- 
+:patch: 0
+:major: 1
+:build: 
+:minor: 1

data/lib/connection.rb

@@ -0,0 +1,278 @@
+# Classes Java usadas nesse arquivo
+import 'java.util.Hashtable'
+import 'javax.naming.InitialContext'
+
+module JSparrow
+  module Connection
+
+    #
+    # Metodo usado para configurar a conexao com o middleware de JMS.
+    #
+    def self.configure
+      @@properties = ConnectionProperties.new
+      
+      yield @@properties
+    end
+    
+    #
+    # Metodo usado para obter a configuracao para conexao com o middleware de JMS.
+    #
+    def self.connection_properties
+      @@properties
+    end
+    
+    #
+    # Metodo usado para criar um novo Client JMS.
+    #
+    def self.new_client
+      jndi_context_builder = JNDI::ContextBuilder.new(@@properties.jms_client_jar, @@properties.jndi_properties)
+      
+      Client.new(@@properties, jndi_context_builder)
+    end
+
+    #
+    # Configuracoes necessarias para que clientes JMS se conetem
+    # ao middleware de mensageria via contexto JNDI.
+    #
+    class ConnectionProperties
+      attr_reader :jms_client_jar, :jndi_properties,
+                  :enabled_connection_factories, :enabled_queues, :enabled_topics
+      
+      def use_jms_client_jar(client_jar)
+        @jms_client_jar = client_jar
+      end
+      
+      def use_jndi_properties(jndi_properties = {})
+        @jndi_properties = jndi_properties
+      end
+      
+      def enable_connection_factories(jndi_names = {})
+        @enabled_connection_factories = jndi_names
+      end
+      
+      def enable_queues(jndi_names = {})
+        @enabled_queues = jndi_names
+      end
+      
+      def enable_topics(jndi_names = {})
+        @enabled_topics = jndi_names
+      end
+    end
+
+    #
+    # Cliente JMS que possibilita a conexao com o servidor de aplicacoes Java EE
+    # que prove o servico JMS.
+    #
+    class Client
+      def initialize(connection_properties, jndi_context_builder)
+        @connection_properties = connection_properties
+        @jndi_context_builder  = jndi_context_builder
+        
+        @jndi_name_of_enabled_connection_factories = @connection_properties.enabled_connection_factories
+        @jndi_name_of_enabled_queues               = {}
+        @jndi_name_of_enabled_topics               = {}
+
+        # Conexoes, filas, topicos, senders e receivers que serao habilitados
+        @connection_factories               = {}
+        @queues                             = {}
+        @queue_senders                      = {}
+        @queue_receivers                    = {}
+        @topics                             = {}
+        @topic_senders                      = {}
+        @topic_receivers                    = {}
+
+        # Foi startado?
+        @started = false
+      end
+      
+      def is_started?
+        @started
+      end
+      
+      def start
+        raise InvalidClientStateError.new('started', 'start') if is_started?
+        
+        begin
+          @jndi_context = @jndi_context_builder.build
+        rescue => cause
+          raise ClientInitializationError.new(@connection_properties, cause)
+        end
+        
+        @connection_factories = lookup_resource(@jndi_name_of_enabled_connection_factories)
+        @queues               = lookup_resource(@jndi_name_of_enabled_queues)
+        @topics               = lookup_resource(@jndi_name_of_enabled_topics)
+        
+        @started = true
+      end
+      
+      def is_stoped?
+        !@started
+      end
+      
+      def stop
+        raise InvalidClientStateError.new('stoped', 'stop') if is_stoped?
+        
+        @jndi_context.close
+        
+        @started = false  
+      end
+
+      def queue_connection_factory_enabled?
+        @jndi_name_of_enabled_connection_factories.include?(:queue_connection_factory)
+      end
+
+      def queue_connection_factory
+        @connection_factories[:queue_connection_factory]
+      end
+
+      def topic_connection_factory_enabled?
+        @jndi_name_of_enabled_connection_factories.include?(:topic_connection_factory)
+      end
+
+      def topic_connection_factory
+        @connection_factories[:topic_connection_factory]
+      end
+
+      def enable_queues(jndi_names = {})
+        raise InvalidClientStateError.new('started', 'enable_queues') if is_started?
+        
+        @jndi_name_of_enabled_queues = jndi_names
+      end
+      
+      def queue_enabled?(queue_name)
+        @jndi_name_of_enabled_queues.include?(queue_name)
+      end
+      
+      def queue(queue_name)
+        raise NameError, "Queue '#{queue_name}' does not exist." unless queue_enabled?(queue_name)
+        
+        @queues[queue_name]
+      end
+
+      def queue_sender(queue_name)
+        @queue_senders[queue_name] ||=
+            Messaging::Sender.new(queue_connection_factory, queue(queue_name))
+      end
+
+      def queue_receiver(queue_name)
+        @queue_receivers[queue_name] ||=
+            Messaging::Receiver.new(queue_connection_factory, queue(queue_name))
+      end
+
+      def enable_topics(jndi_names = {})
+        raise InvalidClientStateError.new('started', 'enable_topics') if is_started?
+        
+        @jndi_name_of_enabled_topics = jndi_names
+      end
+      
+      def topic_enabled?(topic_name)
+        @jndi_name_of_enabled_topics.include?(topic_name)
+      end
+      
+      def topic(topic_name)
+        raise NameError, "Topic '#{topic_name}' does not exist." unless topic_enabled?(topic_name)
+        
+        @topics[topic_name]
+      end
+
+      def topic_sender(topic_name)
+        @topic_senders[topic_name] ||=
+            Messaging::Sender.new(topic_connection_factory, topic(topic_name))
+      end
+
+      def topic_receiver(topic_name)
+        @topic_receivers[topic_name] ||=
+            Messaging::Receiver.new(topic_connection_factory, topic(topic_name))
+      end
+      
+      # -- Private methods -- #
+      private
+      
+        def lookup_resource(jndi_names = {})
+          lookuped = {}
+          
+          jndi_names.each do |key, jndi_name|
+            lookuped[key] = @jndi_context.lookup(jndi_name)
+          end
+          
+          lookuped
+        end
+    end
+    
+    class ClientInitializationError < StandardError
+      attr_reader :properties, :cause
+      
+      def initialize(properties, cause)
+        super("Could not open connection to server. Verify the properties's properties.")
+        
+        @properties = properties
+        @cause      = cause
+      end
+    end
+
+    class InvalidClientStateError < StandardError
+      attr_reader :state, :operation
+      
+      def initialize(state, operation)
+        super("Could not did #{operation} because client is #{state}.")
+        
+        @state     = state
+        @operation = operation
+      end
+    end
+  end
+  
+  module JNDI
+    
+    #
+    # Builder para construcao de contexto JNDI para conexao com o middleware
+    # de JMS.
+    #
+    class ContextBuilder
+      attr_accessor :jms_client_jar, :jndi_properties
+      
+      def initialize(jms_client_jar, jndi_properties)
+        @jms_client_jar = jms_client_jar
+        @jndi_properties   = jndi_properties
+      end
+      
+      #
+      # Constroi um contexto JNDI inicial a partir das configuracoes atuais.
+      #
+      def build
+          # Carrega a biblioteca cliente do servidor de aplicacoes
+          require @jms_client_jar
+          
+          InitialContext.new(to_jndi_environment_hashtable)
+      end
+
+      # --- Private methods --- #
+      private
+
+        #
+        # Cria um Hashtable Java contendo as configuracoes atuais.
+        #
+        def to_jndi_environment_hashtable
+          jndi_env = Hashtable.new
+        
+          jndi_env.put(
+            InitialContext::INITIAL_CONTEXT_FACTORY,
+            @jndi_properties[:initial_context_factory])
+            
+          jndi_env.put(
+            InitialContext::PROVIDER_URL,
+            @jndi_properties[:provider_url])
+            
+          jndi_env.put(
+            InitialContext::SECURITY_PRINCIPAL,
+            @jndi_properties[:security_principal]) if @jndi_properties[:security_principal]
+            
+          jndi_env.put(
+            InitialContext::SECURITY_CREDENTIALS,
+            @jndi_properties[:security_credentials]) if @jndi_properties[:security_credentials]
+        
+          jndi_env
+        end
+    end
+  end
+end

data/lib/error.rb

@@ -0,0 +1,9 @@
+module JSparrow
+  module Error
+    class AbstractMethodError < StandardError
+      def initialize(class_name, method_name)
+        super("The '#{class_name}##{method_name}' is a abstract method. Definition is a subclass responsibility.")
+      end
+    end
+  end
+end

data/lib/jms.rb

@@ -0,0 +1,14 @@
+# Libs directory definition
+JEE_LIB_DIR = File.expand_path(File.dirname(__FILE__)) + '/jms'
+
+# Befor all, the fundamental require for us
+require 'java'
+
+# Lib to JMS integration (contain the META-INF/applicationContext.xml)
+require "#{JEE_LIB_DIR}/jsparrow-essential.jar"
+
+#  Java EE
+require "#{JEE_LIB_DIR}/javaee-1.5.jar"
+
+# JMS API
+require "#{JEE_LIB_DIR}/jms.jar"

data/lib/jsparrow.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(File.expand_path(__FILE__)))
+
+# Bibliotecas necessarias usar JMS
+require 'jms.rb'
+
+# Bibliotecas do JSparrow
+require 'connection.rb'
+require 'messaging.rb'
+require 'error.rb'

data/lib/messaging.rb

@@ -0,0 +1,244 @@
+# Classes Java usadas nesse arquivo
+import 'javax.jms.Session'
+import 'javax.jms.MessageListener'
+
+module JSparrow
+  module Messaging
+
+    #
+    # Tempo padrao de timeout no recebimento de mensagens = 1 milesegundo.
+    #
+    DEFAULT_RECEIVER_TIMEOUT = 1000
+  
+    #
+    # Classe base para mensageiros, que enviam ou recebem mensagens, tanto
+    # para filas ou topicos.
+    #
+    class Base
+      def initialize(connection_factory, destination)
+        # Fabrica de conexoes JMS
+        @connection_factory = connection_factory
+
+        # Destino JMS para envio ou recebimento de mensagens
+        @destination = destination
+      end
+    end
+    
+    #
+    # Emissor de mensagens.
+    #
+    class Sender < Base
+      def send_text_message(text)
+        send_message do |session|
+          text_message = session.create_text_message(text)
+          
+          if block_given?
+            yield(text_message)
+          end
+          
+          text_message
+        end          
+      end
+      
+      def send_object_message(object)
+        send_message do |session|
+          object_message = session.create_object_message(object)
+          
+          if block_given?
+            yield(object_message)
+          end
+          
+          object_message
+        end
+      end
+      
+      def send_map_message
+        send_message do |session|
+          map_message = session.create_map_message
+          
+          if block_given?
+            yield(map_message)
+          end
+          
+          map_message
+        end
+      end
+      
+      def send_messages(&message_sender)
+        # Cria uma conexao, uma sessao e um emissor de qualquer tipo de mensagem
+        connection = @connection_factory.create_connection
+        session    = connection.create_session(true, Session::AUTO_ACKNOWLEDGE)
+        producer   = session.create_producer(@destination)
+        
+        # Passa o controle que trata a emissao de mensagens
+        message_sender.call(session, producer)
+
+        # Fecha a conexao
+        connection.close
+      end
+      
+      # --- Private methods --- #
+      private
+      
+      def send_message(&message_creator)
+        # Cria uma conexao, uma sessao e um emissor de qualquer tipo de mensagem
+        connection = @connection_factory.create_connection
+        session    = connection.create_session(true, Session::AUTO_ACKNOWLEDGE)
+        producer   = session.create_producer(@destination)
+        
+        # Obtem uma mensagem (TextMessage, ObjectMessage ou MapMessage) do criador especifico
+        message = message_creator.call(session)
+        
+        # Envia a mensagem
+        producer.send(message)
+        
+        # Commita a sessao e fecha a conexao
+        session.commit
+        connection.close
+      end
+    end
+    
+    #
+    # Receptor de mensagens.
+    #
+    class Receiver < Base    
+      def receive_message(criteria_for_receiving = {:timeout => DEFAULT_RECEIVER_TIMEOUT, :selector => ''}, &message_handler)
+        # Cria uma conexao, uma sessao e um consumidor de qualquer tipo de mensagem
+        connection = @connection_factory.create_connection
+        session    = connection.create_session(false, Session::AUTO_ACKNOWLEDGE)
+        consumer   = session.create_consumer(@destination, criteria_for_receiving[:selector])
+        
+        # Prepara a conexao para receber mensagens
+        connection.start
+        
+        # Inicia o recebimento de mensagens
+        timeout = criteria_for_receiving[:timeout] || DEFAULT_RECEIVER_TIMEOUT
+        
+        while (received_message = consumer.receive(timeout))
+          # Inclui o modulo de identificacao de mensagem, util para o message_handler
+          class << received_message
+            include MessageType
+          end
+        
+          # Delega o tratamento da mensagem para o bloco recebido
+          message_handler.call(received_message)
+        end
+        
+        # Fecha a conexao
+        connection.close
+      end
+    end
+    
+    #
+    # Ouvintes de mensagens.
+    #
+    # TODO: Completar a implementacao. Ainda nao esta legal. (Ja dei um tapinha,
+    #       acho que agora ta bem proximo do que deve ser.)
+    #
+    class Listener < Base
+      include MessageListener
+      
+      attr_reader :connection_factory_name, :destination_name, :criteria_to_receiving
+      
+      #
+      # Estes parametros serao injetados pelo listener manager de acordo com o
+      # que houver sido definido pelos metodos connection_factory_name e destination_name.
+      #
+      def initialize(connection_factory, destination)
+        super(connection_factory, destination)
+        
+        @connection_factory_name = 'undefined'
+        @destination_name        = 'undefined'
+        @criteria_to_receiving   = {}
+      end
+
+      #
+      # Nome JNDI da connection factory que ser usada para criar conexoes JMS.
+      #
+      # Invariavelmente deve ser usado pelas subclasses para informar qual devera
+      # ser a connection factory usada por esse listener.
+      #
+      def use_connection_factory(jndi_name)
+        @connection_factory_name = jndi_name
+      end
+      
+      #
+      # Nome JNDI do destino JMS que sera escutado.
+      #
+      # Invariavelmente deve ser usado pelas subclasses, para informar o nome
+      # da queue ou topico que sera escutado.
+      #
+      def listen_to_destination(jndi_name)
+        @destination_name = jndi_name
+      end
+      
+      #
+      # Criterios de selecao de mensagens, seguindo o padrao JMS.
+      #
+      # Invariavelmente as subclasses precisam usar esse metodo para definir
+      # os criterios de recebimento que este listener levara em conta.
+      #
+      def receive_only_in_criteria(criteria = {:timeout => DEFAULT_RECEIVER_TIMEOUT, :selector => ''})
+        # Valor default para timeout, caso nao tenha sido informado
+        @criteria_to_receiving[:timeout] = criteria[:timeout] || DEFAULT_RECEIVER_TIMEOUT
+      end
+
+      #
+      # Inicia a escuta de mensagens.
+      #
+      def start_listening
+        # Cria uma conexao, uma sessao e um consumidor de qualquer tipo de mensagem
+        connection = @connection_factory.create_connection
+        session    = connection.create_session(false, Session::AUTO_ACKNOWLEDGE)
+        consumer   = session.create_consumer(@destination, @criteria_for_receiving[:selector])
+        
+        # Registra-se como ouvinte
+        consumer.message_listener = self
+        
+        # Inicia a escuta de mensagens
+        connection.start
+      end
+      
+      #
+      # Faz o enriquecimento do objeto mensagem e delega para o metodo on_receive_message
+      # que, implementado pelas subclasses, efetivamente trata a mensagem.
+      #
+      # Nao deve ser re-implementado por subclasses.
+      #
+      def on_message(received_message)
+        class << received_message
+          include MessageType
+        end
+        
+        on_receive_message(received_message)
+      end
+      
+      #
+      # E executado todas as vezes que chega uma mensagem que atenda aos criterios
+      # definido para este listener (na variavel de instancia @criteria_for_receiving).
+      #
+      # Invariavelmente deve ser re-implementado nas subclasses.
+      #
+      def on_receive_message(received_message)
+        raise Error::AbstractMethodError.new('on_receive_message')
+      end
+    end
+  end
+  
+  #
+  # Identifica o tipo de uma mensagem.
+  #
+  module MessageType
+    def is_text_message?
+      respond_to? :get_text
+    end
+    
+    def is_object_message?
+      (respond_to? :get_object and !(respond_to? :get_long))
+    end
+    
+    def is_map_message?
+      respond_to? :get_long
+    end
+  end
+end

data/sample/sample.rb

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'jsparrow'
+
+JSparrow::Connection.configure do |connection|
+  connection.use_jms_client_jar '/opt/openjms/lib/openjms-0.7.7-beta-1.jar'
+
+  connection.use_jndi_properties :initial_context_factory => 'org.exolab.jms.jndi.InitialContextFactory',
+                                 :provider_url            => 'tcp://localhost:3035'
+                               # :security_principal      => 'user',
+                               # :security_credentials    => 'password'
+
+  connection.enable_connection_factories :queue_connection_factory => 'ConnectionFactory', 
+                                         :topic_connection_factory => 'ConnectionFactory'
+end
+
+jms_client = JSparrow::Connection.new_client
+jms_client.enable_queues :pardal_queue => 'PardalQueue'
+
+jms_client.start
+
+jms_client.queue_sender(:pardal_queue).send_text_message('jsparrow rocks!') do |msg|
+  msg.set_string_property('recipient', 'jsparrow-example')
+end
+
+jms_client.queue_receiver(:pardal_queue).receive_message(
+    :timeout  => 5000,
+    :selector => "recipient = 'jsparrow-example'"
+  ) do |msg|
+  
+  puts "is text message? #{msg.is_text_message?}"    # is text message? true
+  puts "message: #{msg.text}"                        # message: jsparrow rocks!
+end
+
+jms_client.stop

data/spec/connection_spec.rb

@@ -0,0 +1,120 @@
+require File.dirname(File.expand_path(__FILE__)) + '/spec_helper.rb'
+
+#
+# Cenario que testa o start e stop do cliente JMS.
+#
+describe JSparrow::Connection::Client, ', quando criado,' do
+
+  before(:all) do
+    @jms_client = create_jms_client
+  end
+  
+  it 'deveria permitir ser iniciado e parado' do
+    @jms_client.start
+    
+    @jms_client.is_started?.should be true
+    @jms_client.is_stoped?.should be false
+    
+    @jms_client.stop
+    
+    @jms_client.is_started?.should be false
+    @jms_client.is_stoped?.should be true
+  end
+end
+
+#
+# Cenario de configuracao do cliente JMS, quando sao informadas as propriedades de ambiente
+# para conexao com o servidor de aplicacoes e a inicializacao do contexto JNDI inicial,
+# onde estao criadas as connection factories, queues e topics.
+#
+# Importante: nesse momento o cliente JMS ainda nao sera iniciado, ja que nao deve haver
+#             configuracao depois inicia-lo.
+#
+describe JSparrow::Connection::Client, ', quando esta sendo configurado, mas ainda nao iniciado,' do
+
+  before(:all) do
+    @jms_client = create_jms_client
+  end
+  
+  it 'deveria ter uma connection factory especifica para queues' do
+    @jms_client.queue_connection_factory_enabled?.should be true
+  end
+  
+  it 'deveria ter uma connection factory especifica para topics' do
+    @jms_client.topic_connection_factory_enabled?.should be true
+  end
+  
+  it 'deveria permitir habilitar uma Queue especifica' do
+    @jms_client.enable_queues :pardal_queue => 'PardalQueue'
+
+    @jms_client.queue_enabled?(:pardal_queue).should eql true
+  end
+  
+  it 'deveria permitir habilitar um Topic especifico' do
+    @jms_client.enable_topics :pardal_topic => 'PardalTopic'
+
+    @jms_client.topic_enabled?(:pardal_topic).should eql true
+  end  
+end
+
+#
+# Cenario de configuracao do cliente JMS apos ter sido iniciado.
+#
+# Importante: Como o cliente JMS ja esta iniciado, deve lancar erro, nao permitindo
+#             qualquer configuracao.
+#
+describe JSparrow::Connection::Client, ', quando esta sendo configurado, apos iniciado,' do
+
+  before(:all) do
+    @jms_client = create_jms_client
+    @jms_client.start
+  end
+  
+  after(:all) do
+    @jms_client.stop
+  end
+  
+  it 'nao deveria permitir habilitar uma Queue especifica' do
+    lambda {
+        @jms_client.enable_queues(:pardal_queue => 'PardalQueue')
+      }.should raise_error JSparrow::Connection::InvalidClientStateError
+  end
+  
+  it 'nao deveria permitir habilitar um Topic especifico' do
+    lambda {
+        @jms_client.enable_topics(:pardal_topic => 'PardalTopic')
+      }.should raise_error JSparrow::Connection::InvalidClientStateError
+  end  
+end
+
+#
+# Cenario pos-configuracao do cliente JMS, quando as queues e os topicos ja devem estar
+# disponiveis, e entao e possivel obter sender/receiver para elas.
+#
+describe JSparrow::Connection::Client, ', depois de ter sido configurado,' do
+
+  before(:all) do
+    @jms_client = create_and_setup_jms_client
+    @jms_client.start
+  end
+  
+  after(:all) do
+    @jms_client.stop
+  end
+  
+  it 'deveria possibilitar obter um Sender para uma Queue especifica' do
+    @jms_client.queue_sender(:pardal_queue).should_not be nil
+  end
+  
+  it 'deveria possibilitar obter um Receiver para uma Queue especifica' do
+    @jms_client.queue_receiver(:pardal_queue).should_not be nil
+  end
+  
+  it 'deveria possibilitar obter um Sender para um Topic especifico' do
+    @jms_client.topic_sender(:pardal_topic).should_not be nil
+  end
+  
+  it 'deveria possibilitar obter um Receiver para um Topic especifico' do
+    @jms_client.topic_receiver(:pardal_topic).should_not be nil
+  end
+end

data/spec/messaging_spec.rb

@@ -0,0 +1,142 @@
+require File.dirname(File.expand_path(__FILE__)) + '/spec_helper.rb'
+
+#
+# Cenario pos-obtencao de um Sender e um Receiver, quando deve ser possivel enviar e
+# receber mensagens de tres tipos (Texto, Objeto e Mapa) de uma queue especifica,
+# individualmente ou em lote.
+#
+describe JSparrow::Messaging, ', quando tem um Sender e um Receiver para uma Queue especifica,' do
+  
+  before(:all) do
+    @jms_client = create_and_setup_jms_client
+    @jms_client.start
+    
+    @sender   = @jms_client.queue_sender(:pardal_queue)
+    @receiver = @jms_client.queue_receiver(:pardal_queue)
+  end
+  
+  after(:all) do
+    @jms_client.stop
+  end
+  
+  it 'deveria possibilitar enviar uma mensagem de texto e recebe-la' do
+    my_text = 'Mensagem de texto enviada da spec'
+    
+    @sender.send_text_message(my_text) do |msg|
+      msg.set_string_property('recipient', 'jsparrow-spec')
+    end
+    
+    received_text = nil
+    
+    @receiver.receive_message(:selector => "recipient = 'jsparrow-spec'") do |msg|
+      received_text = msg.text
+    end
+    
+    received_text.should eql my_text
+  end
+  
+  it 'deveria possibilitar enviar um objeto e recebe-lo' do
+    my_object = java.util.ArrayList.new
+    my_object << 'Obj1 enviado da spec'
+    
+    @sender.send_object_message(my_object) do |msg|
+      msg.set_string_property('recipient', 'jsparrow-spec')
+    end
+    
+    received_object = nil
+    
+    @receiver.receive_message(:selector => "recipient = 'jsparrow-spec'") do |msg|
+      received_object = msg.object
+    end
+    
+    received_object.should eql my_object
+  end
+  
+  it 'deveria possibilitar enviar uma mensagem mapa e recebe-la' do
+    my_id_long = 1234567
+    
+    @sender.send_map_message do |msg|
+      msg.set_string_property('recipient', 'jsparrow-spec')
+      msg.set_long('id', my_id_long)
+    end
+    
+    received_id_long = nil
+    
+    @receiver.receive_message(:selector => "recipient = 'jsparrow-spec'") do |msg|
+      received_id_long = msg.get_long('id')
+    end
+    
+    received_id_long.should eql my_id_long
+  end
+  
+  it 'deveria possibilitar enviar varias mensagens de qualquer tipo e recebe-las' do
+    my_text = 'Mensagem de texto enviada da spec'
+    
+    my_object = java.util.ArrayList.new
+    my_object << 'Obj1 enviado da spec'
+    
+    my_id_long = 1234567
+    
+    @sender.send_messages do |session, producer|
+      #--- TextMessage
+      text_message = session.create_text_message(my_text)
+      text_message.set_string_property('recipient', 'jsparrow-spec')
+      producer.send(text_message)
+      
+      #--- objectMessage
+      object_message = session.create_object_message(my_object)
+      object_message.set_string_property('recipient', 'jsparrow-spec')
+      producer.send(object_message)
+      
+      #--- MapMessage
+      map_message = session.create_map_message
+      map_message.set_string_property('recipient', 'jsparrow-spec')
+      map_message.set_long('id', my_id_long)
+      producer.send(map_message)
+      
+      # Commita as tres mensagens enviadas na sessao
+      session.commit
+    end
+    
+    received_text    = nil
+    received_object  = nil
+    received_id_long = nil
+    
+    @receiver.receive_message(:timeout => 1000, :selector => "recipient = 'jsparrow-spec'") do |msg|
+      if msg.is_text_message?
+        received_text = msg.text
+      end
+      
+      if msg.is_object_message?
+        received_object = msg.object
+      end
+      
+      if msg.is_map_message?
+        received_id_long = msg.get_long('id')
+      end
+    end
+    
+    received_text.should    eql my_text
+    received_object.should  eql my_object
+    received_id_long.should eql my_id_long
+  end
+end
+
+#
+# Cenario pos-configuracao do cliente JMS, quando deve ser possivel escutar mensagens
+# atraves de objetos listeners.
+#
+describe JSparrow::Messaging::Listener,
+         ', quando um Listener se registra para escutar uma Queue especifica,' do
+  
+  before(:all) do
+    @jms_client = create_jms_client
+    @jms_client.start
+  end
+  
+  after(:all) do
+    @jms_client.stop
+  end
+  
+  it 'deveria possibilitar escutar mensagens atraves de um listener'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'spec'
+
+require File.dirname(File.expand_path(__FILE__)) + '/../lib/jsparrow.rb'
+
+#
+# Modulo com metodos uteis para as specs.
+#
+module JSparrowHelperMethods
+
+  #
+  # Apenas cria, mas nao faz o setup do cliente JMS.
+  #
+  def create_jms_client
+    configure_connection
+    
+    JSparrow::Connection.new_client
+  end
+  
+  def create_and_setup_jms_client
+    configure_connection
+    
+    jms_client = JSparrow::Connection.new_client
+    jms_client.enable_queues :pardal_queue => 'PardalQueue'
+    jms_client.enable_topics :pardal_topic => 'PardalTopic'
+
+    jms_client
+  end
+  
+  # --- Private methods --- #
+  private
+    
+    def configure_connection
+      JSparrow::Connection.configure do |connection|
+        connection.use_jms_client_jar '/opt/openjms/lib/openjms-0.7.7-beta-1.jar'
+
+        connection.use_jndi_properties :initial_context_factory => 'org.exolab.jms.jndi.InitialContextFactory',
+                                       :provider_url            => 'tcp://localhost:3035'
+                                     # :security_principal      => 'user',
+                                     # :security_credentials    => 'password'
+
+        connection.enable_connection_factories :queue_connection_factory => 'ConnectionFactory', 
+                                               :topic_connection_factory => 'ConnectionFactory'
+      end
+    end
+end
+
+#
+# Enriquece a classe Spec::Example::ExampleGroup com o helper.
+#
+class Spec::Example::ExampleGroup
+  include JSparrowHelperMethods
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: jsparrow
+version: !ruby/object:Gem::Version 
+  version: 1.1.0
+platform: ruby
+authors: 
+- Leandro Silva
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-15 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: 
+email: leandrodoze@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- lib/connection.rb
+- lib/error.rb
+- lib/jms.rb
+- lib/jms/javaee-1.5.jar
+- lib/jms/jms.jar
+- lib/jms/jsparrow-essential.jar
+- lib/jsparrow.rb
+- lib/messaging.rb
+- sample/sample.rb
+- spec/connection_spec.rb
+- spec/messaging_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/leandrosilva/jsparrow
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: JSparrow is a JMS client based on JRuby
+test_files: 
+- spec/connection_spec.rb
+- spec/messaging_spec.rb
+- spec/spec_helper.rb