modern_times 0.1.2 → 0.2.0

data/test/base_test.rb

@@ -0,0 +1,248 @@
+require 'modern_times'
+require 'shoulda'
+require 'test/unit'
+require 'fileutils'
+
+class DummyWorker
+  include ModernTimes::Base::Worker
+  attr_reader :opts, :setup_called, :count
+
+  @@mutex = Mutex.new
+
+  def self.reset
+    @@total_count = 0
+    @@workers = []
+  end
+
+  self.reset
+
+  def self.total_count
+    @@total_count
+  end
+
+  def self.workers
+    @@workers
+  end
+
+  def initialize(opts={})
+    @opts = opts
+    @count = 0
+    @@mutex.synchronize do
+      @@workers << self
+    end
+  end
+
+  # One time initialization prior to first thread
+  def setup
+    @setup_called = true
+  end
+
+  def start
+    @stopped = false
+    while !@stopped do
+      sleep 1
+      @count += 1
+      @@mutex.synchronize do
+        @@total_count += 1
+      end
+    end
+  end
+
+  def stop
+    @stopped = true
+  end
+
+  def status
+    "index=#{index}"
+  end
+end
+
+class Dummy2Worker < DummyWorker
+
+end
+
+class BaseTest < Test::Unit::TestCase
+  context 'a worker with no name specified' do
+    setup do
+      @worker = DummyWorker.new
+      @worker.index = 2
+      @worker.thread = 'dummy thread'
+      @supervisor = DummyWorker.create_supervisor('dummy_manager', {:foo => 1})
+    end
+
+    should "have default name and proper supervisor and attributes" do
+      assert_equal('Dummy', @worker.class.default_name)
+      assert_equal('Dummy', @supervisor.name)
+      assert_equal(2, @worker.index)
+      assert_equal('dummy thread', @worker.thread)
+      assert_equal(ModernTimes::Base::Supervisor, @supervisor.class)
+      assert_equal('dummy_manager', @supervisor.manager)
+    end
+  end
+
+  context 'a worker with name specified' do
+    setup do
+      @worker = DummyWorker.new(:name => 'Foo')
+      @supervisor = DummyWorker.create_supervisor('dummy_manager', {:name => 'Foo'})
+    end
+
+    should "have name specified and proper supervisor and attributes" do
+      assert_equal('Foo', @supervisor.name)
+    end
+  end
+
+  context 'a default worker' do
+    setup do
+      DummyWorker.reset
+      @start_time = Time.now
+      @manager = ModernTimes::Manager.new
+      @manager.add(DummyWorker, 2, {:foo => 42})
+      sleep 5
+      @manager.stop
+      @manager.join
+      @end_time = Time.now
+    end
+
+    should "be performing work" do
+      w = DummyWorker.workers
+      w = w.reverse if w[0].index == 1
+      assert_equal 2, w.size
+      (0..1).each do |i|
+        worker = w[i]
+        assert worker.count >= 3
+        assert worker.count <= 8
+        assert worker.index == i
+        assert worker.status == "index=#{worker.index}"
+      end
+      assert DummyWorker.total_count >= 8
+      assert DummyWorker.total_count <= 14
+      assert (@end_time-@start_time) < 14.0
+      assert w[0].setup_called
+      assert !w[1].setup_called
+    end
+  end
+
+  context 'a disallowed worker' do
+    setup do
+      DummyWorker.reset
+      @manager = ModernTimes::Manager.new(:domain => 'DisallowedWorker')
+      @manager.allowed_workers = []
+    end
+
+    should "not be allowed" do
+      e = assert_raises ModernTimes::Exception do
+        @manager.add(DummyWorker, 2, {:foo => 42})
+      end
+      assert_match %r%is not an allowed worker%, e.message
+
+      e = assert_raises ModernTimes::Exception do
+        @manager.add('FdajfsdklasdfWorker', 2, {:foo => 42})
+      end
+      assert_match %r%Invalid class%, e.message
+    end
+  end
+
+  context 'multiple workers' do
+    setup do
+      DummyWorker.reset
+      @manager = ModernTimes::Manager.new(:domain => 'AllowedWorker')
+      @manager.allowed_workers = [DummyWorker, Dummy2Worker]
+      @manager.add(DummyWorker, 2, {:foo => 42})
+      @manager.add(DummyWorker, 1, {:name => 'OtherDummy'})
+      @manager.add(Dummy2Worker, 2, {:name => 'SecondDummy'})
+      sleep 5
+      @manager.stop
+      @manager.join
+      @end_time = Time.now
+    end
+
+    should "work" do
+      w = DummyWorker.workers
+      s = @manager.supervisors
+      assert_equal 5, w.size
+      assert_equal 3, s.size
+      (0..4).each do |i|
+        worker = w[i]
+        assert worker.count >= 3
+        assert worker.count <= 8
+      end
+      assert DummyWorker.total_count >= 20
+      assert DummyWorker.total_count <= 35
+      super_names = s.map {|sup| sup.name}.sort
+      assert_equal ['Dummy', 'OtherDummy', 'SecondDummy'], super_names
+    end
+  end
+
+  context 'manager with persist_file set' do
+    setup do
+      DummyWorker.reset
+      persist_file = "/tmp/modern_times_persist_#{$$}.state"
+      @manager = ModernTimes::Manager.new(:domain => 'PersistManager', :persist_file => persist_file)
+      @manager.allowed_workers = [DummyWorker, Dummy2Worker]
+      @manager.add(DummyWorker, 2, {:foo => 42})
+      @manager.add(DummyWorker, 1, {:name => 'OtherDummy'})
+      @manager.add(Dummy2Worker, 2, {:name => 'SecondDummy'})
+      @manager.stop
+      @manager.join
+      DummyWorker.reset
+      @manager2 = ModernTimes::Manager.new(:domain => 'PersistManager2', :persist_file => persist_file)
+      sleep 5
+      @manager2.stop
+      @manager2.join
+      FileUtils.rm persist_file
+    end
+
+    should "recreate workers and supervisors correctly" do
+      w = DummyWorker.workers
+      s = @manager.supervisors
+      assert_equal 5, w.size
+      assert_equal 3, s.size
+      (0..4).each do |i|
+        worker = w[i]
+        assert worker.count >= 3
+        assert worker.count <= 8
+      end
+      assert DummyWorker.total_count >= 20
+      assert DummyWorker.total_count <= 35
+      super_names = s.map {|sup| sup.name}.sort
+      assert_equal ['Dummy', 'OtherDummy', 'SecondDummy'], super_names
+    end
+  end
+
+  context 'manager' do
+    setup do
+      DummyWorker.reset
+      persist_file = "/tmp/modern_times_persist_#{$$}.state"
+      @domain = 'JMXManagerDomain'
+      @manager = ModernTimes::Manager.new(:domain => @domain)
+      @manager.allowed_workers = [DummyWorker, Dummy2Worker]
+
+      @server = JMX.simple_server
+      @client = JMX.connect
+      @manager_mbean = @client[ModernTimes.manager_mbean_object_name(@domain)]
+    end
+
+    teardown do
+      @manager.stop
+      @manager.join
+      @server.stop
+    end
+
+    should "allow JMX to start and query workers" do
+      @manager_mbean.start_worker('DummyWorker',  2, '{"foo":42}')
+      @manager_mbean.start_worker('DummyWorker',  1, '{"name":"OtherDummy"}')
+      @manager_mbean.start_worker('Dummy2Worker', 2, '{"name":"SecondDummy"}')
+      #puts "allowed workers=#{@manager_mbean.allowed_workers[0].class.name}"
+      assert_equal ['DummyWorker', 'Dummy2Worker'], @manager_mbean.allowed_workers.to_a
+
+      dummy_bean        = @client[ModernTimes.supervisor_mbean_object_name(@domain, 'Dummy')]
+      other_dummy_bean  = @client[ModernTimes.supervisor_mbean_object_name(@domain, 'OtherDummy')]
+      second_dummy_bean = @client[ModernTimes.supervisor_mbean_object_name(@domain, 'SecondDummy')]
+      assert 2, dummy_bean.worker_count
+      assert 1, other_dummy_bean.worker_count
+      assert 2, second_dummy_bean.worker_count
+      other_dummy_bean.worker_count = 3
+      assert 3, other_dummy_bean.worker_count
+    end
+  end
+end

data/test/jms.yml

@@ -0,0 +1,8 @@
+:factory: org.apache.activemq.ActiveMQConnectionFactory
+:broker_url: tcp://localhost:61616
+:require_jars:
+  - <%= Dir.glob("#{ENV['ACTIVEMQ_HOME']}/activemq-all-*.jar")[0] %>
+  #- <%= Dir.glob("#{ENV['ACTIVEMQ_HOME']}/lib/optional/slf4j-log4j*.jar")[0] %>
+  #- <%= Dir.glob("#{ENV['ACTIVEMQ_HOME']}/lib/optional/log4j-*.jar")[0] %>
+#:username: myuser
+#:password: mypassword

data/test/jms_requestor_test.rb

@@ -0,0 +1,263 @@
+require 'modern_times'
+require 'shoulda'
+require 'test/unit'
+require 'fileutils'
+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
+  end
+
+  def self.included(base)
+    base.extend(ModuleMethods)
+  end
+
+  def 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
+    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 request(obj)
+    return MyClass.new(obj.i+10)
+  end
+end
+
+module StringTest
+  extend ModernTimes::MarshalStrategy::String
+
+  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 request(str)
+    if str =~ /^Message (\d+)$/
+      "Returning #{$1}"
+    else
+      raise "Unknown message: #{str}"
+    end
+  end
+end
+
+class DefaultWorker
+  include ModernTimes::JMSRequestor::Worker
+end
+
+class SleepWorker
+  include ModernTimes::JMSRequestor::Worker
+  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' do
+    setup do
+      config = YAML.load(ERB.new(File.read(File.join(File.dirname(__FILE__), 'jms.yml'))).result(binding))
+      ModernTimes::JMS::Connection.init(config)
+    end
+
+    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
+        setup do
+          @domain = "Uniquize_#{marshal_module.name}"
+          @manager = ModernTimes::Manager.new(:domain => @domain)
+        end
+
+        teardown do
+          if @manager
+            @manager.stop
+            @manager.join
+          end
+        end
+
+        should "reply correctly with multiple threads" do
+          DefaultWorker.send(:include, marshal_module)
+          DefaultWorker.send(:marshal, marshal_module)
+          @manager.add(DefaultWorker, 10)
+
+          sleep 1
+
+          requestor = ModernTimes::JMSRequestor::Requestor.new(:queue_name => 'Default', :marshal => marshal_module)
+          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 = 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}"
+              end
+            end
+          end
+          threads.each {|t| t.join}
+        end
+      end
+    end
+
+    context 'timed requesting' do
+      setup do
+        @domain = "TimedModernTimes"
+        @manager = ModernTimes::Manager.new(:domain => @domain)
+        @manager.add(SleepWorker, 10)
+        sleep 1
+        @requestor    = ModernTimes::JMSRequestor::Requestor.new(:queue_name => 'Sleep', :marshal => :string)
+      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.6,2.4], [1,2,3,0,8,1.2], [3,1,2,2.8,3.4]].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)
+              sleep publish_sleep_time
+              if work_sleep_time < timeout_time
+                response = handle.read_response.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
+                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[ModernTimes.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 < 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
+#        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
+  end
+end