activemessaging 0.13.0 → 0.13.1

data/test/gateway_test.rb

@@ -1,220 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class InitializeFilter
-  
-  attr_accessor :options
-
-  def initialize(options)
-    @options = options
-  end
-  
-  def process(message, details={})
-    puts "ObjectFilter process called!"
-  end
-end
-
-class GatewayTest < Test::Unit::TestCase
-  class ClassFilter
-    def initialize
-      raise "Don't try and construct one of these please"
-    end
-    
-    class << self
-      def process(message, details={})
-        puts "ClassFilter process called!"
-      end
-    end
-  end
-
-  class ObjectFilter
-    def process(message, details={})
-      puts "ObjectFilter process called!"
-    end
-  end
-
-  class MessageManglingFilter
-    class << self
-      def process(message, details={})
-        message.body.upcase!
-        message.id.upcase!
-        message.headers['the-mangler'] = 'run'
-        message.destination.gsub! '/', '#'
-      end
-    end
-  end
-
-  class TestProcessor < ActiveMessaging::Processor
-    include ActiveMessaging::MessageSender
-    #subscribes_to :testqueue
-    def on_message(message)
-      @test_message = true
-    end
-  end
-
-  class TestRetryProcessor < ActiveMessaging::Processor
-    include ActiveMessaging::MessageSender
-    #subscribes_to :testqueue
-    def on_message(message)
-      #puts "TestRetryProcessor - about to raise exception"
-      raise ActiveMessaging::AbortMessageException.new("Cause a retry!")
-    end
-  end
-
-  class TestAdapter
-  end
-
-  def setup
-  end
-
-  def teardown
-    ActiveMessaging::Gateway.reset
-  end
-  
-  
-  def test_create_filter
-    filter_obj = ActiveMessaging::Gateway.create_filter('gateway_test/object_filter', {:direction=>:incoming, :name=>'test1'})
-    assert filter_obj
-    assert filter_obj.is_a?(GatewayTest::ObjectFilter)
-    
-    filter_obj = ActiveMessaging::Gateway.create_filter('initialize_filter', {:direction=>:incoming, :name=>'test2'})
-    assert filter_obj
-    assert filter_obj.is_a?(InitializeFilter)
-    assert_equal filter_obj.options, {:direction=>:incoming, :name=>'test2'}
-    
-    filter_obj = ActiveMessaging::Gateway.create_filter(:initialize_filter, {:direction=>:incoming, :name=>'test2'})
-    assert filter_obj
-    assert filter_obj.is_a?(InitializeFilter)
-    assert_equal filter_obj.options, {:direction=>:incoming, :name=>'test2'}
-
-    filter_obj = ActiveMessaging::Gateway.create_filter(:'gateway_test/class_filter', {:direction=>:incoming, :name=>'test2'})
-    assert filter_obj
-    assert filter_obj.is_a?(Class)
-    assert_equal filter_obj.name, "GatewayTest::ClassFilter"
-  end
-  
-  def test_register_adapter 
-    ActiveMessaging::Gateway.register_adapter :test_register_adapter, TestAdapter
-    assert_equal TestAdapter, ActiveMessaging::Gateway.adapters[:test_register_adapter]
-  end
-
-  def test_destination
-    ActiveMessaging::Gateway.destination :hello_world, '/queue/helloWorld'
-    dest = ActiveMessaging::Gateway.named_destinations[:hello_world]
-    assert_equal :hello_world, dest.name
-  end
-
-  def test_destination_duplicates
-    ActiveMessaging::Gateway.destination :hello_world, '/queue/helloWorld'
-    dest = ActiveMessaging::Gateway.named_destinations[:hello_world]
-    assert_equal :hello_world, dest.name
-
-    # make sure a dupe name causes an error
-    assert_raises RuntimeError do 
-      ActiveMessaging::Gateway.destination :hello_world, '/queue/helloWorld2'
-    end
-  end
-
-  def test_connection
-    conn = ActiveMessaging::Gateway.connection
-    assert_equal conn.class, ActiveMessaging::Adapters::Test::Connection
-  end
-
-  def test_subscribe_and_unsubscribe
-    ActiveMessaging::Gateway.destination :hello_world, '/queue/helloWorld'
-    ActiveMessaging::Gateway.subscribe_to :hello_world, TestProcessor, headers={}
-    sub = ActiveMessaging::Gateway.subscriptions.values.last
-    assert_equal :hello_world, sub.destination.name
-    assert_equal TestProcessor, sub.processor_class
-
-    ActiveMessaging::Gateway.subscribe
-    assert_not_nil ActiveMessaging::Gateway.connection.find_subscription(sub.destination.value)
-
-    ActiveMessaging::Gateway.unsubscribe
-    assert_nil ActiveMessaging::Gateway.connection.find_subscription(sub.destination.value)
-  end
-
-  def test_disconnect
-    assert_equal 0, ActiveMessaging::Gateway.connections.keys.size
-
-    conn = ActiveMessaging::Gateway.connection
-    assert_equal 1, ActiveMessaging::Gateway.connections.keys.size
-    assert_equal true, conn.connected
-
-    ActiveMessaging::Gateway.disconnect
-
-    assert_equal 0, ActiveMessaging::Gateway.connections.keys.size
-    assert_equal false, conn.connected
-  end
-
-  def test_publish
-    ActiveMessaging::Gateway.destination :hello_world, '/queue/helloWorld'
-    ActiveMessaging::Gateway.publish :hello_world, "test_publish body", self.class, headers={}, timeout=10
-    assert_not_nil ActiveMessaging::Gateway.connection.find_message('/queue/helloWorld', "test_publish body")
-    
-    assert_raise(RuntimeError) do
-      ActiveMessaging::Gateway.publish :hello_world, nil, self.class, headers={}, timeout=10
-    end
-    assert_raise(RuntimeError) do
-      ActiveMessaging::Gateway.publish :hello_world, '', self.class, headers={}, timeout=10
-    end
-  end
-
-  def test_acknowledge_message
-    ActiveMessaging::Gateway.destination :hello_world, '/queue/helloWorld'
-    ActiveMessaging::Gateway.subscribe_to :hello_world, TestProcessor, headers={}
-    sub = ActiveMessaging::Gateway.subscriptions.values.last
-    dest = ActiveMessaging::Adapters::Test::Destination.new '/queue/helloWorld'
-    msg = ActiveMessaging::Adapters::Test::Message.new("message_body", nil, {}, dest.name)
-    ActiveMessaging::Gateway.acknowledge_message sub, msg
-    assert_equal msg, ActiveMessaging::Gateway.connection.received_messages.first
-  end
-
-  def test_abort_message
-    ActiveMessaging::Gateway.destination :hello_world, '/queue/helloWorld'
-    ActiveMessaging::Gateway.subscribe_to :hello_world, TestRetryProcessor, headers={}
-    sub = ActiveMessaging::Gateway.subscriptions.values.last
-    dest = ActiveMessaging::Adapters::Test::Destination.new '/queue/helloWorld'
-    msg = ActiveMessaging::Adapters::Test::Message.new("message_body", nil, {}, dest.name)
-    ActiveMessaging::Gateway.dispatch(msg)
-    assert_equal msg, ActiveMessaging::Gateway.connection.unreceived_messages.first
-  end
-
-  def test_aborted_messages_retry_original_message
-    ActiveMessaging::Gateway.destination :hello_world, '/queue/helloWorld'
-    ActiveMessaging::Gateway.filter 'gateway_test/message_mangling_filter'
-    ActiveMessaging::Gateway.subscribe_to :hello_world, TestRetryProcessor, headers={}
-
-    message_body = "message_body"
-    message_id = "55-a-msg"
-    message_headers = { 'x-my-header' => 'value' }
-    message_destination = '/queue/helloWorld'
-    msg = ActiveMessaging::Adapters::Test::Message.new(message_body.dup, message_id.dup, message_headers.dup, message_destination.dup)
-    ActiveMessaging::Gateway.dispatch(msg)
-    assert_equal message_body, ActiveMessaging::Gateway.connection.unreceived_messages.first.body
-    assert_equal message_id, ActiveMessaging::Gateway.connection.unreceived_messages.first.id
-    assert_equal message_headers, ActiveMessaging::Gateway.connection.unreceived_messages.first.headers
-    assert_equal message_destination, ActiveMessaging::Gateway.connection.unreceived_messages.first.destination
-  end
-
-  def test_receive
-    ActiveMessaging::Gateway.destination :hello_world, '/queue/helloWorld'
-    ActiveMessaging::Gateway.publish :hello_world, "test_publish body", self.class, headers={}, timeout=10
-    msg = ActiveMessaging::Gateway.receive :hello_world, self.class, headers={}, timeout=10
-    assert_not_nil ActiveMessaging::Gateway.connection.find_message('/queue/helloWorld', "test_publish body")
-  end
-
-  # def test_reload
-  #   ActiveMessaging.reload_activemessaging
-  #   size = ActiveMessaging::Gateway.named_destinations.size
-  #   ActiveMessaging.reload_activemessaging
-  #   assert_equal size, ActiveMessaging::Gateway.named_destinations.size
-  # end
-
-  ## figure out how to test these better - start in a thread perhaps?
-  # def test_start
-  # end
-  # 
-  # def test_stop
-  # end
-
-end

data/test/jms_test.rb

@@ -1,64 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-if defined?(JRUBY_VERSION)
-
-require 'activemessaging/adapters/jms'
-
-class JmsTest < Test::Unit::TestCase
-
-  def setup
-    @test_txt = 'Yo Homie!'
-    @isolation_const = rand(99999999)
-    @connection = ActiveMessaging::Adapters::Jms::Connection.new(:url => 'vm://jms_test',
-      :login => '',
-      :passcode => '',
-      :connection_factory => 'org.apache.activemq.ActiveMQConnectionFactory')
-  end
-  
-  def test_send
-    @connection.send "/queue/TestQueue#{@isolation_const}", @test_txt, {}
-  end
-  
-  def test_receive_with_one
-    @connection.send "/queue/TestQueue#{@isolation_const}", @test_txt
-    @connection.subscribe "/queue/TestQueue#{@isolation_const}"
-    message = @connection.receive
-    assert_equal @test_txt, message.body
-  end
-  
-  def test_receive_multi
-    10.times do |i|
-      @connection.send "/queue/MultiQueue#{@isolation_const}", @test_txt
-    end
-    
-    counter=0
-    @connection.subscribe "/queue/MultiQueue#{@isolation_const}"
-    while message = @connection.receive
-      assert_equal @test_txt, message.body
-      counter += 1
-    end
-    assert_equal 10, counter
-  end
-  
-  def test_one_off_receive
-    @connection.send "/queue/OneOff#{@isolation_const}", "one off message"
-    sleep 2
-    message = @connection.receive "/queue/OneOff#{@isolation_const}"
-    assert_equal "one off message", message.body
-    assert_equal "MESSAGE", message.command
-    assert_equal "/queue/OneOff#{@isolation_const}", message.headers['destination']
-  end
-  
-  def test_unsubscribe
-    @connection.subscribe "/queue/TestSubQueue#{@isolation_const}"
-    @connection.unsubscribe "/queue/TestSubQueue#{@isolation_const}"
-    assert_nil @connection.consumers["TestSubQueue#{@isolation_const}"]
-  end
-  
-  def teardown
-    @connection.close unless @connection.nil?
-  end
-  
-end
-
-end

data/test/reliable_msg_test.rb

@@ -1,83 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-loaded = true
-begin
-  require 'reliable-msg'
-rescue Object => e
-  loaded = false
-end
-if loaded 
-
-require 'activemessaging/adapters/reliable_msg'
-
-class ReliableMsgTest < Test::Unit::TestCase
-
-  def setup
-    @qm = ReliableMsg::QueueManager.new
-    @qm.start
-    @connection = ActiveMessaging::Adapters::ReliableMsgConnection.new(:reliable=>false, :poll_interval=>2)
-    @d = "/queue/reliable.msg.test}."
-    @message = "mary had a little lamb"
-    @message2 = "whose fleece was white as snow"
-  end
-
-  def teardown
-    @connection.disconnect unless @connection.nil?
-    @qm.stop unless @qm.nil?
-  end
-  
-  def test_subscribe_and_unsubscribe
-    assert_nil @connection.subscriptions["#{@d}test_subscribe"]
-    @connection.subscribe "#{@d}test_subscribe"
-    assert_equal 1, @connection.subscriptions["#{@d}test_subscribe"].count
-    @connection.subscribe "#{@d}test_subscribe"
-    assert_equal 2, @connection.subscriptions["#{@d}test_subscribe"].count
-    @connection.unsubscribe "#{@d}test_subscribe"
-    assert_equal 1, @connection.subscriptions["#{@d}test_subscribe"].count
-    @connection.unsubscribe "#{@d}test_subscribe"
-    assert_nil @connection.subscriptions["#{@d}test_subscribe"]
-  end
-
-  def test_send_and_receive
-    @connection.subscribe "#{@d}test_send_and_receive"
-    @connection.send "#{@d}test_send_and_receive", @message 
-    message = @connection.receive
-    @connection.received message
-    assert_equal @message, message.body
-  end
-
-
-  def test_send_and_receive_multiple_subscriptions
-    @connection.subscribe "#{@d}test_send_and_receive1"
-    @connection.subscribe "#{@d}test_send_and_receive2"
-    @connection.subscribe "#{@d}test_send_and_receive3"
-
-    @connection.send "#{@d}test_send_and_receive2", "message2" 
-    message = @connection.receive
-    @connection.received message
-    assert_equal "message2", message.body
-
-    @connection.send "#{@d}test_send_and_receive3", "message3"
-    message = @connection.receive
-    @connection.received message
-    assert_equal "message3", message.body
-
-  end
-
-
-  def test_will_cause_sleep
-
-    begin
-      Timeout.timeout 10 do
-        @connection.subscribe "#{@d}test_will_cause_sleep"
-        message = @connection.receive
-        @connection.received message
-        assert false
-      end
-    rescue Timeout::Error=>toe
-      assert true
-    end
-  end
-  
-end
-
-end # if loaded

data/test/stomp_test.rb

@@ -1,168 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-require 'activemessaging/adapters/stomp'
-
-loaded = true
-begin
-  require 'stomp'
-rescue Object => e
-  loaded = false
-end
-if loaded #only run these test if stomp gem installed
-
-
-class FakeTCPSocket
-  attr_accessor :sent_messages
-  def initialize; @sent_messages=[]; end
-  def puts(s=""); @sent_messages << s; end
-  def write(s=""); self.puts s; end
-  def ready?; true; end
-end
-
-
-module Stomp
-  class Connection
-    
-    attr_accessor :subscriptions
-    
-    def socket
-      @socket = FakeTCPSocket.new if @socket.nil?
-      @socket
-    end
-    
-    def receive=(msg)
-      # stomp 1.0.5 code, now no longer works
-      # sm = Stomp::Message.new do |m|
-      #   m.command = 'MESSAGE'
-      #   m.body = msg
-      #   m.headers = {'message-id'=>'testmessage1', 'content-length'=>msg.length, 'destination'=>'destination1'}
-      # end
-      
-      sm = Stomp::Message.new("MESSAGE\ndestination:/queue/stomp/destination/1\nmessage-id: messageid1\ncontent-length:#{msg.length}\n\n#{msg}\0\n")
-      
-      sm.command = 'MESSAGE'
-      sm.headers = {'message-id'=>'testmessage1', 'content-length'=>msg.length, 'destination'=>'destination1'}
-      
-      @test_message = ActiveMessaging::Adapters::Stomp::Message.new(sm)
-    end
-    
-    def receive
-      @test_message
-    end
-  end
-end
-
-class StompTest < Test::Unit::TestCase
-
-  def setup
-    @connection = ActiveMessaging::Adapters::Stomp::Connection.new({})
-    @d = "/queue/stomp/destination/1"
-    @message = "mary had a little lamb"
-    @connection.stomp_connection.receive = @message
-  end
-
-  def sent_command
-    @connection.stomp_connection.socket.sent_messages[0]
-  end
-
-  def sent_headers
-    @connection.stomp_connection.socket.sent_messages.drop(1).take_while { |line| !line.empty? }
-  end
-
-  def sent_body
-    (@connection.stomp_connection.socket.sent_messages.drop_while {|line| !line.empty?}).drop(1).first
-  end
-
-  def test_initialize
-    i = { :retryMax => 4, 
-          :deadLetterQueue=>'/queue/dlq',
-          :login=>"",
-          :passcode=> "",
-          :host=> "localhost",
-          :port=> "61613",
-          :reliable=>FALSE,
-          :reconnectDelay=> 5,
-          :clientId=> 'cid',
-          :deadLetterQueuePrefix=>"DLQ."}
-
-    @connection = ActiveMessaging::Adapters::Stomp::Connection.new(i)
-    assert_equal 4, @connection.retryMax
-    assert_equal '/queue/dlq', @connection.deadLetterQueue
-    assert_equal "DLQ.", @connection.deadLetterQueuePrefix
-    assert_equal true, @connection.supports_dlq?
-  end
-
-  def test_disconnect
-    @connection.disconnect
-    assert_equal "DISCONNECT", sent_command
-  end
-
-  def test_subscribe
-    @connection.subscribe @d, {}
-    assert_equal "SUBSCRIBE", sent_command
-    assert sent_headers.include?("content-length:0"), "No content-length header was sent"
-    assert sent_headers.include?("destination:#{@d}"), "No destination header was sent"
-    assert_equal 1, @connection.stomp_connection.subscriptions.count
-    assert_equal({:'content-type'=>'text/plain; charset=UTF-8', :'content-length'=>'0', :destination=>@d}, @connection.stomp_connection.subscriptions[@d])
-  end
-
-  def test_unsubscribe
-    @connection.subscribe @d, {}
-    @connection.stomp_connection.socket.sent_messages = []
-    @connection.unsubscribe @d, {}
-    assert_equal "UNSUBSCRIBE", sent_command
-    assert sent_headers.include?("content-length:0"), "No content-length header was sent"
-    assert sent_headers.include?("destination:#{@d}"), "No destination header was sent"
-    assert_equal 0, @connection.stomp_connection.subscriptions.count
-  end
-  
-  def test_send
-    @connection.send(@d, @message, {})
-    assert_equal 'SEND', sent_command
-    assert sent_headers.include?("content-length:#{@message.length}"), "No content-length header was sent"
-    assert sent_headers.include?("destination:#{@d}"), "No destination header was sent"
-#    assert_equal @message, @connection.stomp_connection.socket.sent_messages[5]
-    assert_equal @message, sent_body
-  end
-
-  def test_receive
-    m = @connection.receive
-    assert_equal @message, m.body
-  end
-  
-  def test_received
-    m = @connection.receive
-    m.headers[:transaction] = 'test-transaction'
-    @connection.received m, {:ack=>'client'}
-  end
-  
-  def test_unreceive
-    @connection = ActiveMessaging::Adapters::Stomp::Connection.new({:retryMax=>4, :deadLetterQueue=>'/queue/dlq'})
-    @connection.stomp_connection.receive = @message
-    m = @connection.receive
-    m.headers["a13g-retry-count"] = 5
-    @connection.unreceive m, {:ack=>'client'}
-  end
-
-  def test_unreceive_with_dlq_prefix
-    @connection = ActiveMessaging::Adapters::Stomp::Connection.new({:retryMax=>4, :deadLetterQueuePrefix=>'DLQ.'})
-    @connection.stomp_connection.receive = @message
-    m = @connection.receive
-    m.headers["a13g-retry-count"] = 5
-    @connection.unreceive m, {:ack=>'client', :destination=>"/queue/myqueue"}
-  end
-
-  def test_add_dlq_prefix
-    @connection = ActiveMessaging::Adapters::Stomp::Connection.new({:deadLetterQueuePrefix=>'DLQ.'})
-    dlq = @connection.add_dlq_prefix("/queue/myqueue")
-    assert_equal "/queue/DLQ.myqueue", dlq
-    dlq = @connection.add_dlq_prefix("/queue/something/myqueue")
-    assert_equal "/queue/something/DLQ.myqueue", dlq
-    dlq = @connection.add_dlq_prefix("/topic/myqueue")
-    assert_equal "/topic/DLQ.myqueue", dlq
-    dlq = @connection.add_dlq_prefix("myqueue")
-    assert_equal "DLQ.myqueue", dlq
-  end
-
-end
-
-end # if loaded