qwirk 0.0.1

data/test/jms_requestor_test.rb

@@ -0,0 +1,238 @@
+require 'qwirk'
+require 'shoulda'
+require 'test/unit'
+require 'fileutils'
+require 'erb'
+
+# NOTE: This test requires a running ActiveMQ server
+
+module HashTest
+  def self.create_obj(i)
+    {
+        'foo' => 1,
+        'bar' => {
+            'message' => i,
+            'dummy'   => "Message #{i}"
+        },
+        # Only YAML will maintain symbols
+        :zulu => :rugger
+    }
+  end
+
+  def self.parse_obj(obj)
+    obj['answer']
+  end
+
+  def self.request(obj)
+    {
+        'answer' => obj['bar']['message']
+    }
+  end
+end
+
+module RubyTest
+
+  class MyClass
+    attr_reader :i
+    def initialize(i)
+      @i = i
+    end
+  end
+
+  def self.create_obj(i)
+    MyClass.new(i)
+  end
+
+  def self.parse_obj(obj)
+    obj.i-10
+  end
+
+  def self.request(obj)
+    return MyClass.new(obj.i+10)
+  end
+end
+
+module StringTest
+  def self.create_obj(i)
+    "Message #{i}"
+  end
+
+  def self.parse_obj(obj)
+    if obj =~ /^Returning (\d+)$/
+      $1.to_i
+    else
+      raise "Unknown message: #{obj}"
+    end
+  end
+
+  def self.request(str)
+    if str =~ /^Message (\d+)$/
+      "Returning #{$1}"
+    else
+      raise "Unknown message: #{str}"
+    end
+  end
+end
+
+class DefaultWorker
+  include Qwirk::QueueAdapter::JMS::RequestWorker
+  response :marshal => :yaml
+
+  def request(obj)
+    options[:tester].request(obj)
+  end
+end
+
+class SleepWorker
+  include Qwirk::QueueAdapter::JMS::RequestWorker
+  response :marshal => :string
+
+  def request(i)
+    sleep i.to_i
+    return i
+  end
+end
+
+class JMSRequestorTest < Test::Unit::TestCase
+
+  @@server = JMX.simple_server
+  @@client = JMX.connect
+
+  context 'jms request' do
+    setup do
+      config = YAML.load(ERB.new(File.read(File.join(File.dirname(__FILE__), 'jms.yml'))).result(binding))
+      Qwirk::QueueAdapter::JMS::Connection.init(config)
+    end
+
+    teardown do
+    end
+
+    {
+      :bson   => HashTest,
+      :json   => HashTest,
+      :ruby   => RubyTest,
+      :string => StringTest,
+      :yaml   => HashTest
+    }.each do |marshal, tester|
+
+      context "marshaling with #{marshal}" do
+        setup do
+          @domain = "Uniquize_#{marshal}"
+          @manager = Qwirk::Manager.new(:domain => @domain)
+        end
+
+        teardown do
+          if @manager
+            @manager.stop
+            @manager.join
+          end
+        end
+
+        should "reply correctly with multiple threads" do
+          DefaultWorker.response(:marshal => marshal, :time_to_live => 10000)
+          @manager.add(DefaultWorker, 10, :tester => tester)
+
+          sleep 1
+
+          publisher = Qwirk::QueueAdapter::JMS::Publisher.new(:queue_name => 'Default', :marshal => marshal, :response_time_to_live => 10000)
+          threads = []
+          start = Time.now
+          (0..9).each do |i|
+            threads << Thread.new(i) do |i|
+              start = i*10
+              range = start..(start+9)
+              range.each do |x|
+                obj = tester.create_obj(x)
+                handle = publisher.publish(obj)
+                reply_obj = handle.read_response(2)
+                val = tester.parse_obj(reply_obj)
+                assert x == val, "#{x} does not equal #{val}"
+              end
+            end
+          end
+          threads.each {|t| t.join}
+        end
+      end
+    end
+
+    context 'timed requesting' do
+      setup do
+        @domain = "TimedQwirk"
+        @manager = Qwirk::Manager.new(:domain => @domain)
+        @manager.add(SleepWorker, 10)
+        sleep 1
+        @producer = Qwirk::QueueAdapter::JMS::Publisher.new(:queue_name => 'Sleep', :marshal => :string, :response_time_to_live => 10000)
+      end
+
+      teardown do
+        if @manager
+          @manager.stop
+          @manager.join
+        end
+      end
+
+      should "work correctly if request is complete before the timeout" do
+        [[1,0,2,0.8,1.2], [2,1,3,1.8,2.2], [1,2,3,0.8,1.2], [3,1,2,2.8,3.2]].each do |info|
+          work_sleep_time, publish_sleep_time, timeout_time, min_time, max_time = info
+          threads      = []
+          start_time   = Time.now
+          (0..9).each do |i|
+            threads << Thread.new(i) do |i|
+              handle = @producer.publish(work_sleep_time)
+              sleep publish_sleep_time
+              if work_sleep_time < timeout_time
+                response = handle.read_response(timeout_time).to_i
+                assert work_sleep_time == response, "#{work_sleep_time} does not equal #{response}"
+              else
+                assert handle.read_response(timeout_time).nil?
+                actual_time = Time.now - start_time
+                assert timeout_time-0.1 < actual_time, "Bad timeout #{actual_time}"
+                assert timeout_time+0.3 > actual_time, "Bad timeout #{actual_time}"
+
+                # Give the requests time to complete
+                sleep work_sleep_time - timeout_time + 1
+              end
+            end
+          end
+          threads.each {|t| t.join}
+          total_time = Time.now - start_time
+          bean = @@client[Qwirk.supervisor_mbean_object_name(@domain, 'Sleep')]
+          bean_avg = bean.average_response_time
+          bean_min = bean.min_response_time
+          bean_max = bean.max_response_time
+          puts "total=#{total_time} avg=#{bean_avg} min=#{bean_min} max=#{bean_max}"
+          all_times = [bean_avg, bean_min, bean_max]
+          all_times << total_time if work_sleep_time > publish_sleep_time && work_sleep_time < timeout_time
+          all_times.each do |time_val|
+            assert min_time < time_val, "#{time_val} is not between #{min_time} and #{max_time}"
+            assert max_time > time_val, "#{time_val} is not between #{min_time} and #{max_time}"
+          end
+        end
+      end
+    end
+
+    context 'dummy requesting' do
+      setup do
+        @tester = RubyTest
+        workers = [
+          DefaultWorker.new(:tester => @tester)
+        ]
+        Qwirk::QueueAdapter::JMS::Publisher.setup_dummy_publishing(workers)
+      end
+
+      teardown do
+        Qwirk::QueueAdapter::JMS::Publisher.clear_dummy_publishing
+      end
+
+      should "directly call applicable workers" do
+        x=9999
+        obj = @tester.create_obj(x)
+        publisher = Qwirk::QueueAdapter::JMS::Publisher.new(:queue_name => 'Default', :marshal => :ruby, :response => true)
+        handle = publisher.publish(obj)
+        reply_obj = handle.read_response(2)
+        val = @tester.parse_obj(reply_obj)
+        assert x == val, "#{x} does not equal #{val}"
+      end
+    end
+  end
+end

data/test/jms_test.rb

@@ -0,0 +1,287 @@
+require 'qwirk'
+require 'shoulda'
+require 'test/unit'
+require 'fileutils'
+require 'erb'
+
+# NOTE: This test requires a running ActiveMQ server
+
+module WorkerHelper
+  @@workers = {}
+  @@mutex   = Mutex.new
+  def initialize(opts={})
+    super
+    @tester = opts[:tester]
+    @@mutex.synchronize do
+      @@workers[self.name] ||= []
+      @@workers[self.name] << self
+    end
+    @hash = Hash.new(0)
+  end
+
+  def perform(obj)
+    add_message(@tester.translate(obj))
+  end
+
+  def self.workers(names)
+    workers = []
+    names.each {|name| workers += @@workers[name]}
+    workers
+  end
+
+  def self.reset_workers
+    @@workers = {}
+  end
+
+  def add_message(i)
+    @hash[i] += 1
+  end
+
+  def call_count
+    puts "hash=#{@hash.inspect}"
+    @hash.values.reduce(:+)
+  end
+
+  def messages
+    @hash.keys
+  end
+end
+
+module HashTest
+  def self.create_obj(i)
+    {
+        'foo' => 1,
+        'bar' => {
+            'message' => i,
+            'dummy'   => "Message #{i}"
+        },
+        # Only YAML will maintain symbols
+        :zulu => :rugger
+    }
+  end
+
+  def self.translate(obj)
+    obj['bar']['message']
+  end
+end
+
+module RubyTest
+  class MyClass
+    attr_reader :i
+    def initialize(i)
+      @i = i
+    end
+  end
+
+  def self.create_obj(i)
+    MyClass.new(i)
+  end
+
+  def self.translate(obj)
+    obj.i
+  end
+end
+
+module StringTest
+  def self.create_obj(i)
+    "Message #{i}"
+  end
+
+  def self.translate(str)
+    if str =~ /^Message (\d+)$/
+      $1.to_i
+    else
+      raise "Unknown message: #{str}"
+    end
+  end
+end
+
+class DefaultWorker
+  include Qwirk::QueueAdapter::JMS::Worker
+  include WorkerHelper
+end
+
+module Dummy
+  class DefaultWorker
+    include Qwirk::QueueAdapter::JMS::Worker
+    include WorkerHelper
+  end
+end
+
+class SpecifiedQueueWorker
+  include Qwirk::QueueAdapter::JMS::Worker
+  queue 'MyQueueName'
+  include WorkerHelper
+end
+
+class SpecifiedQueue2Worker
+  include Qwirk::QueueAdapter::JMS::Worker
+  queue 'MyQueueName'
+  include WorkerHelper
+end
+
+class SpecifiedTopicWorker
+  include Qwirk::QueueAdapter::JMS::Worker
+  virtual_topic 'MyTopicName'
+  include WorkerHelper
+end
+
+class SpecifiedTopic2Worker
+  include Qwirk::QueueAdapter::JMS::Worker
+  virtual_topic 'MyTopicName'
+  include WorkerHelper
+end
+
+class JMSTest < Test::Unit::TestCase
+
+  @@server = JMX.simple_server
+  @@client = JMX.connect
+
+  def publish(marshal, tester, range, options)
+    publisher = Qwirk::QueueAdapter::JMS::Publisher.new(options.merge(:marshal => marshal))
+    puts "Publishing #{range} to #{publisher} via #{marshal}"
+    range.each do |i|
+      obj = tester.create_obj(i)
+      publisher.publish(obj)
+    end
+  end
+  
+  def assert_worker(domain, names, worker_count, range, min, max, instance_count)
+    puts "Checking #{names.inspect}"
+    names = [names] unless names.kind_of?(Array)
+    workers = WorkerHelper.workers(names)
+
+    assert_equal worker_count, workers.size
+    all_messages = []
+    workers.each do |worker|
+      msg_count = worker.call_count
+      assert msg_count
+      assert msg_count >= min, "#{msg_count} is not between #{min} and #{max}"
+      assert msg_count <= max, "#{msg_count} is not between #{min} and #{max}"
+      # Make sure no duplicate messages
+      assert msg_count == worker.messages.size, "#{msg_count} is not == #{worker.messages.size}"
+      all_messages.concat(worker.messages)
+    end
+    all_messages.sort!
+    assert_equal all_messages, (range.to_a*instance_count).sort
+
+    if domain
+      total_count = 0
+      names.each do |name|
+        bean = @@client[Qwirk.supervisor_mbean_object_name(domain, name)]
+        bean.message_counts.each do |msg_count|
+          total_count += msg_count
+          assert msg_count >= min, "#{msg_count} is not between #{min} and #{max}"
+          assert msg_count <= max, "#{msg_count} is not between #{min} and #{max}"
+        end
+      end
+      assert_equal all_messages.size, total_count
+    end
+  end
+
+  context 'jms' do
+    setup do
+      config = YAML.load(ERB.new(File.read(File.join(File.dirname(__FILE__), 'jms.yml'))).result(binding))
+      Qwirk::QueueAdapter::JMS::Connection.init(config)
+    end
+
+    teardown do
+    end
+
+    {
+      :bson => HashTest,
+      :json => HashTest,
+      :ruby => RubyTest,
+      :string => StringTest,
+      :yaml => HashTest
+    }.each do |marshal, tester|
+
+      context "marshaling with #{marshal}" do
+        setup do
+          @domain = "Uniquize_#{marshal}"
+          @manager = Qwirk::Manager.new(:domain => @domain)
+        end
+
+        teardown do
+          if @manager
+            @manager.stop
+            @manager.join
+          end
+        end
+
+        should "operate on queues and topics" do
+          WorkerHelper.reset_workers
+          @manager.add(DefaultWorker, 3, :tester => tester)
+          @manager.add(DefaultWorker, 2, :name => 'DefaultClone', :tester => tester)
+          @manager.add(Dummy::DefaultWorker, 4, :tester => tester)
+          @manager.add(SpecifiedQueueWorker, 3, :tester => tester)
+          @manager.add(SpecifiedQueueWorker, 2, :name => 'SpecifiedQueueClone', :tester => tester)
+          @manager.add(SpecifiedQueue2Worker, 2, :tester => tester)
+          @manager.add(SpecifiedTopicWorker, 3, :tester => tester)
+          @manager.add(SpecifiedTopicWorker, 2, :name => 'SpecifiedTopicClone', :tester => tester)
+          @manager.add(SpecifiedTopic2Worker, 2, :tester => tester)
+
+          sleep 1
+
+          publish(marshal, tester, 100..199, :queue_name => 'Default')
+          publish(marshal, tester, 200..299, :queue_name => 'DefaultClone')
+          publish(marshal, tester, 300..399, :queue_name => 'Dummy_Default')
+          publish(marshal, tester, 400..599, :queue_name => 'MyQueueName')
+          publish(marshal, tester, 600..699, :virtual_topic_name => 'MyTopicName')
+
+          # Let the workers do their thing
+          sleep 5
+
+          # DefaultWorker should have 5 instances running with each worker handling between 10-30 messages in the range 100.199
+          assert_worker(@domain, 'Default',                                                    3, 100..199, 30, 36, 1)
+          assert_worker(@domain, 'DefaultClone',                                               2, 200..299, 45, 55, 1)
+          assert_worker(@domain, 'Dummy_Default',                                              4, 300..399, 20, 30, 1)
+          assert_worker(@domain, ['SpecifiedQueue', 'SpecifiedQueueClone', 'SpecifiedQueue2'], 7, 400..599, 20, 40, 1)
+          assert_worker(@domain, ['SpecifiedTopic', 'SpecifiedTopicClone'],                    5, 600..699, 30, 60, 2)
+          assert_worker(@domain, 'SpecifiedTopic2',                                            2, 600..699, 35, 65, 1)
+        end
+      end
+    end
+
+    context 'dummy publishing' do
+      setup do
+        WorkerHelper.reset_workers
+        workers = [
+          DefaultWorker.new(:tester => RubyTest),
+          DefaultWorker.new(:tester => RubyTest, :name => 'DefaultClone'),
+          Dummy::DefaultWorker.new(:tester => RubyTest),
+          SpecifiedQueueWorker.new(:tester => RubyTest),
+          SpecifiedQueueWorker.new(:tester => RubyTest, :name => 'SpecifiedQueueClone'),
+          SpecifiedQueue2Worker.new(:tester => RubyTest),
+          SpecifiedTopicWorker.new(:tester => RubyTest),
+          SpecifiedTopicWorker.new(:tester => RubyTest, :name => 'SpecifiedTopicClone'),
+          SpecifiedTopic2Worker.new(:tester => RubyTest),
+        ]
+        Qwirk::QueueAdapter::JMS::Publisher.setup_dummy_publishing(workers)
+      end
+
+      teardown do
+        Qwirk::QueueAdapter::JMS::Publisher.clear_dummy_publishing
+      end
+
+      should "directly call applicable workers" do
+        publish(:ruby, RubyTest, 100..199, :queue_name => 'Default')
+        publish(:ruby, RubyTest, 200..299, :queue_name => 'DefaultClone')
+        publish(:ruby, RubyTest, 300..399, :queue_name => 'Dummy_Default')
+        publish(:ruby, RubyTest, 400..599, :queue_name => 'MyQueueName')
+        publish(:ruby, RubyTest, 600..699, :virtual_topic_name => 'MyTopicName')
+
+        # The single instance of each class will be called so everyone will have all messages.
+        assert_worker(nil, 'Default',             1, 100..199, 100, 100, 1)
+        assert_worker(nil, 'DefaultClone',        1, 200..299, 100, 100, 1)
+        assert_worker(nil, 'Dummy_Default',       1, 300..399, 100, 100, 1)
+        assert_worker(nil, 'SpecifiedQueue',      1, 400..599, 200, 200, 1)
+        assert_worker(nil, 'SpecifiedQueueClone', 1, 400..599, 200, 200, 1)
+        assert_worker(nil, 'SpecifiedQueue2',     1, 400..599, 200, 200, 1)
+        assert_worker(nil, 'SpecifiedTopic',      1, 600..699, 100, 100, 1)
+        assert_worker(nil, 'SpecifiedTopicClone', 1, 600..699, 100, 100, 1)
+        assert_worker(nil, 'SpecifiedTopic2',     1, 600..699, 100, 100, 1)
+      end
+    end
+  end
+end