gz_activemessaging 0.13.1

data/lib/generators/active_messaging/processor/templates/processor_test.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'activemessaging/test_helper'
+require File.dirname(__FILE__) + '/../../app/processors/application_processor'
+
+class <%= class_name %>ProcessorTest < Test::Unit::TestCase
+  include ActiveMessaging::TestHelper
+  
+  def setup
+    load File.dirname(__FILE__) + "/../../app/processors/<%= file_name %>_processor.rb"
+    @processor = <%= class_name %>Processor.new
+  end
+  
+  def teardown
+    @processor = nil
+  end  
+
+  def test_<%= file_name %>_processor
+    @processor.on_message('Your test message here!')
+  end
+end

data/lib/tasks/start_consumers.rake

@@ -0,0 +1,8 @@
+namespace "activemessaging" do
+
+  desc 'Run all consumers'
+  task :start_consumers do
+    load File.dirname(__FILE__) + '/../poller.rb'
+  end
+  
+end

data/poller.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# Make sure stdout and stderr write out without delay for using with daemon like scripts
+STDOUT.sync = true; STDOUT.flush
+STDERR.sync = true; STDERR.flush
+
+# Load Rails
+RAILS_ROOT=File.expand_path(File.join(File.dirname(__FILE__), '..','..','..'))
+load File.join(RAILS_ROOT, 'config', 'environment.rb')
+
+# Load ActiveMessaging processors
+#ActiveMessaging::load_processors
+
+# Start it up!
+ActiveMessaging::start

data/test/all_tests.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+
+require 'test/unit'
+
+# tests
+require 'config_test'
+require 'filter_test'
+require 'tracer_test'
+require 'jms_test'
+require 'asqs_test'

data/test/app/config/broker.yml

@@ -0,0 +1,4 @@
+# Yaml config file for testing ActiveMessaging
+test:
+    adapter: test
+    reliable: false

data/test/asqs_test.rb

@@ -0,0 +1,125 @@
+require File.dirname(__FILE__) + '/test_helper'
+require 'activemessaging/adapters/asqs'
+
+class AsqsTest < Test::Unit::TestCase
+  
+  class FakeHTTPResponse
+    attr_accessor :headers, :body
+    
+    def to_hash
+      @headers
+    end
+    
+    def kind_of? kind
+      true
+    end
+  end
+  
+  ::ActiveMessaging::Adapters::AmazonSqs::Connection.class_eval do
+    attr_accessor :test_response, :test_headers
+
+    DEFAULT_RESPONSE = <<EOM 
+    <ListQueuesResponse xmlns='http://queue.amazonaws.com/doc/2007-05-01/' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:type='ListQueuesResponse'>
+    <Queues>
+    <QueueUrl>http://queue.amazonaws.com/thisisatestid1/test1</QueueUrl>
+    <QueueUrl>http://queue.amazonaws.com/thisisatestid12/test2</QueueUrl>
+    </Queues>
+    <ResponseStatus><StatusCode>Success</StatusCode><RequestId>cb919c0a-9bce-4afe-9b48-9bdf2412bb67</RequestId></ResponseStatus>
+    </ListQueuesResponse>
+EOM
+
+    def http_request h, p, r
+      raise test_response if test_response.is_a?(Exception)
+      
+      resp = FakeHTTPResponse.new
+      resp.body = @test_response || DEFAULT_RESPONSE
+      resp.headers = @test_headers || {}
+      return resp
+    end
+  end
+  
+
+  def setup
+    @connection = ActiveMessaging::Adapters::AmazonSqs::Connection.new(:reliable=>false, :access_key_id=>'access_key_id', :secret_access_key=>'secret_access_key', :reconnectDelay=>1)
+    @d = "asqs"
+    @message = "mary had a little lamb"
+  end
+
+  def teardown
+    @connection.disconnect unless @connection.nil?
+  end
+
+  def test_message_size
+    assert_equal @connection.max_message_size, 8
+
+    @connection = ActiveMessaging::Adapters::AmazonSqs::Connection.new(:reliable=>false, :access_key_id=>'access_key_id', :secret_access_key=>'secret_access_key', :max_message_size => 10)
+
+    assert_nothing_raised do
+      @connection.send @d, @message
+    end
+
+    large_message = "m" * 1024 * 9
+    assert_nothing_raised do
+      @connection.send @d, large_message
+    end
+    large_message = nil
+
+    large_message = "m" * 1024 * 11
+    assert_raise(RuntimeError) do
+      @connection.send @d, large_message
+    end
+    large_message = nil
+
+  end
+
+  def test_allow_underscore_and_dash
+    assert_nothing_raised do
+      @connection.subscribe 'name-name_dash'
+    end
+    assert_raise(RuntimeError) do
+      @connection.subscribe '!@#$%^&'
+    end
+  end
+
+  
+  def test_send_and_receive
+    @connection.subscribe @d, :visibility_timeout=>100
+    @connection.send @d, @message
+
+    @connection.test_headers = {:destination=>@d}
+    @connection.test_response = <<EOM
+    <ReceiveMessageResponse>
+      <Message>
+        <MessageId>11YEJMCHE2DM483NGN40|3H4AA8J7EJKM0DQZR7E1|PT6DRTB278S4MNY77NJ0</MessageId>
+        <ReceiptHandle>some handle value</ReceiptHandle>
+        <Body>#{@message}</Body>
+        <MD5OfBody>not really the md5</MD5OfBody>
+      </Message>
+      <ResponseStatus>
+        <StatusCode>Success</StatusCode>
+        <RequestId>b5bf2332-e983-4d3e-941a-f64c0d21f00f</RequestId>
+      </ResponseStatus>
+    </ReceiveMessageResponse>
+EOM
+
+    message = @connection.receive
+    assert_equal @message, message.body
+  end
+  
+  def test_receive_timeout
+    @connection.subscribe @d
+    @connection.send @d, @message
+
+    @connection.test_headers = {:destination=>@d}
+    @connection.test_response = TimeoutError.new('test timeout error')
+    @connection.reliable = true
+    begin
+      Timeout.timeout 2 do
+        @connection.receive
+      end
+    rescue Timeout::Error=>toe
+      assert_not_equal toe.message, 'test timeout error'
+    end
+  end
+  
+end

data/test/config_test.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class TestProcessor < ActiveMessaging::Processor
+end
+
+class ConfigTest < Test::Unit::TestCase
+
+  def setup
+    ActiveMessaging::Gateway.define do |s|
+      s.destination :hello_world, '/queue/helloWorld'
+    end
+  end
+  
+  def teardown
+    ActiveMessaging::Gateway.reset
+  end
+
+  def test_can_subscribe_to_named_queue
+    TestProcessor.subscribes_to :hello_world
+    sub = ActiveMessaging::Gateway.subscriptions.values.last
+    assert_equal :hello_world, sub.destination.name
+    assert_equal TestProcessor, sub.processor_class
+  end
+
+  def test_can_publish_to_named_queue
+    TestProcessor.publishes_to :hello_world
+    #no exception - publish just checks to see if the queue exists
+  end
+
+  def test_should_raise_error_if_subscribe_to_queue_that_does_not_exist
+    assert_raises(RuntimeError) do 
+      TestProcessor.subscribes_to :queue_that_does_not_exist
+    end
+  end
+
+  def test_should_raise_error_if_publishes_to_queue_that_does_not_exist
+    assert_raises(RuntimeError) do 
+      TestProcessor.publishes_to :queue_that_does_not_exist
+    end
+  end
+  
+end

data/test/filter_test.rb

@@ -0,0 +1,131 @@
+require File.dirname(__FILE__) + '/test_helper'
+require 'activemessaging/filter'
+
+module ActiveMessaging #:nodoc:
+  def self.reload_activemessaging
+  end
+end
+
+class FilterTest < Test::Unit::TestCase
+  
+  class MockFilter < ActiveMessaging::Filter
+    
+    @@called = {}
+    cattr_reader :called
+
+    attr_reader :options
+    
+    def initialize(options)
+      @options = options
+    end
+    
+    def process(message, details={})
+      @@called[options[:name]] = {:message=>message, :details=>details}
+    end
+    
+    class << self
+      include Test::Unit::Assertions
+
+      def reset
+        @@called = {}
+      end
+      
+      def assert_was_called(name=nil)
+        assert @@called.has_key?(name)
+      end
+
+      def assert_was_not_called(name=nil)
+        assert !@@called.has_key?(name)
+      end
+
+      def assert_routing(name, routing)
+        assert_equal routing, @@called[name][:details]
+      end
+    end
+  end
+
+  class TestProcessor < ActiveMessaging::Processor
+    include ActiveMessaging::MessageSender
+    #subscribes_to :testqueue
+    
+    @@was_called = false
+    class<<self
+      include Test::Unit::Assertions
+      
+      def assert_was_called
+        assert @@was_called
+        @@was_called = false
+      end
+    end
+    
+    def on_message(message)
+      @@was_called = true
+    end
+  end
+
+  include ActiveMessaging::TestHelper
+
+  def setup
+    ActiveMessaging::Gateway.define do |d|
+      d.destination :testqueue, '/queue/test.queue'
+      d.filter 'filter_test/mock_filter', :direction=>:bidirectional, :name=>:bidirectional
+      d.filter 'filter_test/mock_filter', :direction=>:incoming, :name=>:incoming
+      d.filter 'filter_test/mock_filter', :direction=>:outgoing, :name=>:outgoing
+
+      d.filter 'filter_test/mock_filter', :direction=>:incoming, :name=>:exclude_only, :only=>:foo
+      d.filter 'filter_test/mock_filter', :direction=>:incoming, :name=>:include_only, :only=>:testqueue
+      d.filter 'filter_test/mock_filter', :direction=>:incoming, :name=>:exclude_except, :except=>:testqueue
+      d.filter 'filter_test/mock_filter', :direction=>:incoming, :name=>:include_except, :except=>:foo
+    end
+    
+    TestProcessor.subscribes_to :testqueue
+    MockFilter.reset
+  end
+
+  def teardown
+    ActiveMessaging::Gateway.reset
+  end
+
+  def test_filters_use_include
+    ActiveMessaging::Gateway.dispatch ActiveMessaging::TestMessage.new('body', {}, '/queue/test.queue')
+    MockFilter.assert_was_called(:include_only)
+    MockFilter.assert_was_not_called(:exclude_only)
+  end
+
+  def test_filters_use_exclude
+    ActiveMessaging::Gateway.dispatch ActiveMessaging::TestMessage.new('body', {}, '/queue/test.queue')
+    MockFilter.assert_was_called(:include_except)
+    MockFilter.assert_was_not_called(:exclude_except)
+  end
+
+  def test_filters_and_processor_gets_called_on_receive
+    ActiveMessaging::Gateway.dispatch ActiveMessaging::TestMessage.new('body', {}, '/queue/test.queue')
+    MockFilter.assert_was_called(:bidirectional)
+    MockFilter.assert_was_called(:incoming)
+    MockFilter.assert_was_not_called(:outgoing)
+    TestProcessor.assert_was_called
+  end
+  
+  def test_filters_gets_called_on_publish
+    ActiveMessaging::Gateway.publish :testqueue, "blah blah"
+    MockFilter.assert_was_called(:bidirectional)
+    MockFilter.assert_was_not_called(:incoming)
+    MockFilter.assert_was_called(:outgoing)
+  end
+
+  def test_sets_routing_details_on_send
+    sender = TestProcessor.new
+    sender.publish :testqueue, "Hi there!"
+  
+    MockFilter.assert_was_called(:outgoing)
+    MockFilter.assert_routing(:outgoing, {:destination=>ActiveMessaging::Gateway.find_queue(:testqueue), :publisher=>FilterTest::TestProcessor, :direction=>:outgoing})
+  end
+  
+  def test_sets_routing_details_on_receive
+    ActiveMessaging::Gateway.dispatch ActiveMessaging::TestMessage.new('body', {}, '/queue/test.queue')
+  
+    MockFilter.assert_was_called(:incoming)
+    MockFilter.assert_routing(:incoming, {:destination=>ActiveMessaging::Gateway.find_queue(:testqueue), :receiver=>FilterTest::TestProcessor, :direction=>:incoming})
+  end
+  
+end

data/test/gateway_test.rb

@@ -0,0 +1,220 @@
+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