modern_times 0.2.11 → 0.3.0

data/test/jms_requestor_test.rb

@@ -7,47 +7,30 @@ require 'erb'
 # NOTE: This test requires a running ActiveMQ server
 
 module HashTest
-  module ModuleMethods
-    def create_obj(i)
-      {
-          'foo' => 1,
-          'bar' => {
-              'message' => i,
-              'dummy'   => "Message #{i}"
-          },
-          # Only YAML will maintain symbols
-          :zulu => :rugger
-      }
-    end
-
-    def parse_obj(obj)
-      obj['answer']
-    end
+  def self.create_obj(i)
+    {
+        'foo' => 1,
+        'bar' => {
+            'message' => i,
+            'dummy'   => "Message #{i}"
+        },
+        # Only YAML will maintain symbols
+        :zulu => :rugger
+    }
   end
 
-  def self.included(base)
-    base.extend(ModuleMethods)
+  def self.parse_obj(obj)
+    obj['answer']
   end
 
-  def request(obj)
+  def self.request(obj)
     {
         'answer' => obj['bar']['message']
     }
   end
 end
 
-module BSONTest
-  extend ModernTimes::MarshalStrategy::BSON
-  include HashTest
-end
-
-module JSONTest
-  extend ModernTimes::MarshalStrategy::JSON
-  include HashTest
-end
-
 module RubyTest
-  extend ModernTimes::MarshalStrategy::Ruby
 
   class MyClass
     attr_reader :i
@@ -64,14 +47,12 @@ module RubyTest
     obj.i-10
   end
 
-  def request(obj)
+  def self.request(obj)
     return MyClass.new(obj.i+10)
   end
 end
 
 module StringTest
-  extend ModernTimes::MarshalStrategy::String
-
   def self.create_obj(i)
     "Message #{i}"
   end
@@ -84,7 +65,7 @@ module StringTest
     end
   end
 
-  def request(str)
+  def self.request(str)
     if str =~ /^Message (\d+)$/
       "Returning #{$1}"
     else
@@ -94,12 +75,17 @@ module StringTest
 end
 
 class DefaultWorker
-  include ModernTimes::JMSRequestor::Worker
+  include ModernTimes::JMS::RequestWorker
+  response :marshal => :yaml, :time_to_live => 10000
+
+  def request(obj)
+    options[:tester].request(obj)
+  end
 end
 
 class SleepWorker
-  include ModernTimes::JMSRequestor::Worker
-  marshal :string
+  include ModernTimes::JMS::RequestWorker
+  response :marshal => :string, :time_to_live => 10000
 
   def request(i)
     sleep i.to_i
@@ -112,7 +98,7 @@ class JMSRequestorTest < Test::Unit::TestCase
   @@server = JMX.simple_server
   @@client = JMX.connect
 
-  context 'jms' do
+  context 'jms request' do
     setup do
       config = YAML.load(ERB.new(File.read(File.join(File.dirname(__FILE__), 'jms.yml'))).result(binding))
       ModernTimes::JMS::Connection.init(config)
@@ -121,14 +107,17 @@ class JMSRequestorTest < Test::Unit::TestCase
     teardown do
     end
 
-    #[BSONTest, JSONTest, RubyTest, StringTest].each do |marshal_module|
-    [BSONTest, JSONTest, StringTest].each do |marshal_module|
-      marshal_module.name =~ /(.*)Test/
-      marshal_type = $1
-
-      context "marshaling with #{marshal_type}" do
+    {
+      :bson   => HashTest,
+      :json   => HashTest,
+      :ruby   => RubyTest,
+      :string => StringTest,
+      :yaml   => HashTest
+    }.each do |marshal, tester|
+
+      context "marshaling with #{marshal}" do
         setup do
-          @domain = "Uniquize_#{marshal_module.name}"
+          @domain = "Uniquize_#{marshal}"
           @manager = ModernTimes::Manager.new(:domain => @domain)
         end
 
@@ -140,13 +129,12 @@ class JMSRequestorTest < Test::Unit::TestCase
         end
 
         should "reply correctly with multiple threads" do
-          DefaultWorker.send(:include, marshal_module)
-          DefaultWorker.send(:marshal, marshal_module)
-          @manager.add(DefaultWorker, 10)
+          DefaultWorker.response(:marshal => marshal, :time_to_live => 10000)
+          @manager.add(DefaultWorker, 10, :tester => tester)
 
           sleep 1
 
-          requestor = ModernTimes::JMSRequestor::Requestor.new(:queue_name => 'Default', :marshal => marshal_module)
+          publisher = ModernTimes::JMS::Publisher.new(:queue_name => 'Default', :marshal => marshal, :response => true)
           threads = []
           start = Time.now
           (0..9).each do |i|
@@ -154,10 +142,11 @@ class JMSRequestorTest < Test::Unit::TestCase
               start = i*10
               range = start..(start+9)
               range.each do |x|
-                obj = marshal_module.create_obj(x)
-                handle = requestor.request(obj, 2)
-                val = marshal_module.parse_obj(handle.read_response)
-                assert x == val, "#{i} does not equal #{val}"
+                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
@@ -172,7 +161,7 @@ class JMSRequestorTest < Test::Unit::TestCase
         @manager = ModernTimes::Manager.new(:domain => @domain)
         @manager.add(SleepWorker, 10)
         sleep 1
-        @requestor    = ModernTimes::JMSRequestor::Requestor.new(:queue_name => 'Sleep', :marshal => :string)
+        @publisher = ModernTimes::JMS::Publisher.new(:queue_name => 'Sleep', :marshal => :string, :response => true)
       end
 
       teardown do
@@ -183,21 +172,19 @@ class JMSRequestorTest < Test::Unit::TestCase
       end
 
       should "work correctly if request is complete before the timeout" do
-        [[1,0,2,0.8,1.2], [2,1,3,1.6,2.4], [1,2,3,0,8,1.2], [3,1,2,2.8,3.4]].each do |info|
+        [[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 = @requestor.request(work_sleep_time, timeout_time)
+              handle = @publisher.publish(work_sleep_time)
               sleep publish_sleep_time
               if work_sleep_time < timeout_time
-                response = handle.read_response.to_i
+                response = handle.read_response(timeout_time).to_i
                 assert work_sleep_time == response, "#{work_sleep_time} does not equal #{response}"
               else
-                e = assert_raises Timeout::Error do
-                  response = handle.read_response.to_i
-                end
+                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}"
@@ -215,7 +202,7 @@ class JMSRequestorTest < Test::Unit::TestCase
           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 < timeout_time
+          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}"
@@ -224,40 +211,28 @@ class JMSRequestorTest < Test::Unit::TestCase
       end
     end
 
-#    context 'dummy requesting' do
-#      setup do
-#        workers = [
-#          DefaultWorker,
-#          Dummy::DefaultWorker,
-#          SpecifiedQueueWorker,
-#          SpecifiedQueue2Worker,
-#          SpecifiedTopicWorker,
-#          SpecifiedTopic2Worker,
-#        ]
-#        workers.each do |worker_klass|
-#          worker_klass.send(:include, RubyTest)
-#        end
-#        ModernTimes::JMS::Publisher.setup_dummy_publishing(workers)
-#      end
-#
-#      teardown do
-#        ModernTimes::JMS::Publisher.clear_dummy_publishing
-#      end
-#
-#      should "directly call applicable workers" do
-#        publish(RubyTest, 100..199, :queue_name => 'Default')
-#        publish(RubyTest, 200..299, :queue_name => 'Dummy_Default')
-#        publish(RubyTest, 300..499, :queue_name => 'MyQueueName')
-#        publish(RubyTest, 500..599, :virtual_topic_name => 'MyTopicName')
-#
-#        # DefaultWorker should have 5 instances running with each worker handling between 10-30 messages in the range 100.199
-#        assert_worker(nil, DefaultWorker,         nil, 1, 100..199, 100, 100, 1)
-#        assert_worker(nil, Dummy::DefaultWorker,  nil, 1, 200..299, 100, 100, 1)
-#        assert_worker(nil, SpecifiedQueueWorker,  nil, 1, 300..499, 200, 200, 1)
-#        assert_worker(nil, SpecifiedQueue2Worker, nil, 1, 300..499, 200, 200, 1)
-#        assert_worker(nil, SpecifiedTopicWorker,  nil, 1, 500..599, 100, 100, 1)
-#        assert_worker(nil, SpecifiedTopic2Worker, nil, 1, 500..599, 100, 100, 1)
-#      end
-#    end
+    context 'dummy requesting' do
+      setup do
+        @tester = RubyTest
+        workers = [
+          DefaultWorker.new(:tester => @tester)
+        ]
+        ModernTimes::JMS::Publisher.setup_dummy_publishing(workers)
+      end
+
+      teardown do
+        ModernTimes::JMS::Publisher.clear_dummy_publishing
+      end
+
+      should "directly call applicable workers" do
+        x=9999
+        obj = @tester.create_obj(x)
+        publisher = ModernTimes::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

@@ -11,6 +11,7 @@ module WorkerHelper
   @@mutex   = Mutex.new
   def initialize(opts={})
     super
+    @tester = opts[:tester]
     @@mutex.synchronize do
       @@workers[self.class.name] ||= []
       @@workers[self.class.name] << self
@@ -18,6 +19,10 @@ module WorkerHelper
     @hash = Hash.new(0)
   end
 
+  def perform(obj)
+    add_message(@tester.translate(obj))
+  end
+
   def self.workers(worker_klass)
     @@workers[worker_klass.name]
   end
@@ -41,42 +46,24 @@ module WorkerHelper
 end
 
 module HashTest
-  module ModuleMethods
-    def create_obj(i)
-      {
-          'foo' => 1,
-          'bar' => {
-              'message' => i,
-              'dummy'   => "Message #{i}"
-          },
-          # Only YAML will maintain symbols
-          :zulu => :rugger
-      }
-    end
-  end
-
-  def self.included(base)
-    base.extend(ModuleMethods)
+  def self.create_obj(i)
+    {
+        'foo' => 1,
+        'bar' => {
+            'message' => i,
+            'dummy'   => "Message #{i}"
+        },
+        # Only YAML will maintain symbols
+        :zulu => :rugger
+    }
   end
 
-  def perform(obj)
-    add_message(obj['bar']['message'])
+  def self.translate(obj)
+    obj['bar']['message']
   end
 end
 
-module BSONTest
-  extend ModernTimes::MarshalStrategy::BSON
-  include HashTest
-end
-
-module JSONTest
-  extend ModernTimes::MarshalStrategy::JSON
-  include HashTest
-end
-
 module RubyTest
-  extend ModernTimes::MarshalStrategy::Ruby
-
   class MyClass
     attr_reader :i
     def initialize(i)
@@ -88,21 +75,19 @@ module RubyTest
     MyClass.new(i)
   end
 
-  def perform(obj)
-    add_message(obj.i)
+  def self.translate(obj)
+    obj.i
   end
 end
 
 module StringTest
-  extend ModernTimes::MarshalStrategy::String
-
   def self.create_obj(i)
     "Message #{i}"
   end
 
-  def perform(str)
+  def self.translate(str)
     if str =~ /^Message (\d+)$/
-      add_message($1.to_i)
+      $1.to_i
     else
       raise "Unknown message: #{str}"
     end
@@ -150,11 +135,11 @@ class JMSTest < Test::Unit::TestCase
   @@server = JMX.simple_server
   @@client = JMX.connect
 
-  def publish(marshal_module, range, options)
-    publisher = ModernTimes::JMS::Publisher.new(options.merge(:marshal => marshal_module))
-    puts "Publishing #{range} to #{publisher}"
+  def publish(marshal, tester, range, options)
+    publisher = ModernTimes::JMS::Publisher.new(options.merge(:marshal => marshal))
+    puts "Publishing #{range} to #{publisher} via #{marshal}"
     range.each do |i|
-      obj = marshal_module.create_obj(i)
+      obj = tester.create_obj(i)
       publisher.publish(obj)
     end
   end
@@ -170,6 +155,7 @@ class JMSTest < Test::Unit::TestCase
     all_messages = []
     workers.each do |worker|
       msg_count = worker.message_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
@@ -202,15 +188,17 @@ class JMSTest < Test::Unit::TestCase
     teardown do
     end
 
-    [BSONTest, JSONTest, RubyTest, StringTest].each do |marshal_module|
-    #[RubyTest].each do |marshal_module|
-    #[BSONTest, JSONTest, StringTest].each do |marshal_module|
-      marshal_module.name =~ /(.*)Test/
-      marshal_type = $1
+    {
+      :bson => HashTest,
+      :json => HashTest,
+      :ruby => RubyTest,
+      :string => StringTest,
+      :yaml => HashTest
+    }.each do |marshal, tester|
 
-      context "marshaling with #{marshal_type}" do
+      context "marshaling with #{marshal}" do
         setup do
-          @domain = "Uniquize_#{marshal_module.name}"
+          @domain = "Uniquize_#{marshal}"
           @manager = ModernTimes::Manager.new(:domain => @domain)
         end
 
@@ -223,26 +211,22 @@ class JMSTest < Test::Unit::TestCase
 
         should "operate on queues and topics" do
           WorkerHelper.reset_workers
-          [DefaultWorker, Dummy::DefaultWorker, SpecifiedQueueWorker, SpecifiedQueue2Worker, SpecifiedTopicWorker, SpecifiedTopic2Worker].each do |worker_klass|
-            worker_klass.send(:include, marshal_module)
-            worker_klass.send(:marshal, marshal_module)
-          end
-          @manager.add(DefaultWorker, 3)
-          @manager.add(DefaultWorker, 2, :name => 'DefaultClone')
-          @manager.add(Dummy::DefaultWorker, 4)
-          @manager.add(SpecifiedQueueWorker, 3)
-          @manager.add(SpecifiedQueueWorker, 2, :name => 'SpecifiedQueueClone')
-          @manager.add(SpecifiedQueue2Worker, 2)
-          @manager.add(SpecifiedTopicWorker, 3)
-          @manager.add(SpecifiedTopicWorker, 2, :name => 'SpecifiedTopicClone')
-          @manager.add(SpecifiedTopic2Worker, 2)
+          @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_module, 100..199, :queue_name => 'Default')
-          publish(marshal_module, 200..299, :queue_name => 'Dummy_Default')
-          publish(marshal_module, 300..499, :queue_name => 'MyQueueName')
-          publish(marshal_module, 500..599, :virtual_topic_name => 'MyTopicName')
+          publish(marshal, tester, 100..199, :queue_name => 'Default')
+          publish(marshal, tester, 200..299, :queue_name => 'Dummy_Default')
+          publish(marshal, tester, 300..499, :queue_name => 'MyQueueName')
+          publish(marshal, tester, 500..599, :virtual_topic_name => 'MyTopicName')
 
           # Let the workers do their thing
           sleep 5
@@ -259,18 +243,15 @@ class JMSTest < Test::Unit::TestCase
 
     context 'dummy publishing' do
       setup do
+        WorkerHelper.reset_workers
         workers = [
-          DefaultWorker,
-          Dummy::DefaultWorker,
-          SpecifiedQueueWorker,
-          SpecifiedQueue2Worker,
-          SpecifiedTopicWorker,
-          SpecifiedTopic2Worker,
+          DefaultWorker.new(:tester => RubyTest),
+          Dummy::DefaultWorker.new(:tester => RubyTest),
+          SpecifiedQueueWorker.new(:tester => RubyTest),
+          SpecifiedQueue2Worker.new(:tester => RubyTest),
+          SpecifiedTopicWorker.new(:tester => RubyTest),
+          SpecifiedTopic2Worker.new(:tester => RubyTest),
         ]
-        workers.each do |worker_klass|
-          worker_klass.send(:include, RubyTest)
-        end
-        WorkerHelper.reset_workers
         ModernTimes::JMS::Publisher.setup_dummy_publishing(workers)
       end
 
@@ -279,10 +260,10 @@ class JMSTest < Test::Unit::TestCase
       end
 
       should "directly call applicable workers" do
-        publish(RubyTest, 100..199, :queue_name => 'Default')
-        publish(RubyTest, 200..299, :queue_name => 'Dummy_Default')
-        publish(RubyTest, 300..499, :queue_name => 'MyQueueName')
-        publish(RubyTest, 500..599, :virtual_topic_name => 'MyTopicName')
+        publish(:ruby, RubyTest, 100..199, :queue_name => 'Default')
+        publish(:ruby, RubyTest, 200..299, :queue_name => 'Dummy_Default')
+        publish(:ruby, RubyTest, 300..499, :queue_name => 'MyQueueName')
+        publish(:ruby, RubyTest, 500..599, :virtual_topic_name => 'MyTopicName')
 
         # DefaultWorker should have 5 instances running with each worker handling between 10-30 messages in the range 100.199
         assert_worker(nil, DefaultWorker,         nil, 1, 100..199, 100, 100, 1)