ruote 2.2.0 → 2.3.0

data/test/functional/ft_3_participant_registration.rb

@@ -5,7 +5,7 @@
 # Mon May 18 22:25:57 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'base')
+require File.expand_path('../base', __FILE__)
 
 require 'ruote'
 
@@ -15,12 +15,10 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
 
   def test_participant_register
 
-    #noisy
-
-    @engine.register_participant :alpha do |workitem|
-      @tracer << 'alpha'
+    @dashboard.register_participant :alpha do |workitem|
+      tracer << 'alpha'
     end
-    @engine.register_participant /^user_/, Ruote::NullParticipant
+    @dashboard.register_participant /^user_/, Ruote::NullParticipant
 
     wait_for(2)
 
@@ -33,57 +31,106 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
       logger.log.collect { |msg| msg['regex'] })
 
     assert_equal(
-      [ [ "^alpha$",
-          [ "Ruote::BlockParticipant",
-            { "block" => "proc { |workitem| (@tracer << \"alpha\") }" } ] ],
-        [ "^user_",
-          [ "Ruote::NullParticipant",
+      [ [ '^alpha$',
+          [ 'Ruote::BlockParticipant',
+            { 'on_workitem' => "proc do |workitem|\n      tracer << 'alpha'\n    end" } ] ],
+        [ '^user_',
+          [ 'Ruote::NullParticipant',
             {} ] ] ],
-      @engine.participant_list.collect { |pe| pe.to_a })
+      @dashboard.participant_list.collect { |pe| pe.to_a })
   end
 
   def test_participant_register_position
 
-    @engine.register_participant :ur, Ruote::StorageParticipant
+    @dashboard.register_participant :ur, Ruote::StorageParticipant
 
     assert_equal(
       %w[ ^ur$ ],
-      @engine.participant_list.collect { |pe| pe.regex.to_s })
+      @dashboard.participant_list.collect { |pe| pe.regex.to_s })
 
-    @engine.register_participant(
+    @dashboard.register_participant(
       :first, Ruote::StorageParticipant, :position => :first)
-    @engine.register_participant(
+    @dashboard.register_participant(
       :last, Ruote::StorageParticipant, :position => :last)
 
     assert_equal(
       %w[ ^first$ ^ur$ ^last$ ],
-      @engine.participant_list.collect { |pe| pe.regex.to_s })
+      @dashboard.participant_list.collect { |pe| pe.regex.to_s })
 
-    @engine.register_participant(
+    @dashboard.register_participant(
       :x, Ruote::StorageParticipant, :position => -2)
 
     assert_equal(
       %w[ ^first$ ^ur$ ^x$ ^last$ ],
-      @engine.participant_list.collect { |pe| pe.regex.to_s })
+      @dashboard.participant_list.collect { |pe| pe.regex.to_s })
+  end
+
+  def test_participant_register_before
+
+    @dashboard.register_participant :alpha, 'AlphaParticipant'
+    @dashboard.register_participant :bravo, 'BravoParticipant'
+    @dashboard.register_participant :alpha, 'AlphaPrimeParticipant', :pos => :after
+
+    assert_equal(
+      [ %w[ ^alpha$ AlphaParticipant ],
+        %w[ ^alpha$ AlphaPrimeParticipant ],
+        %w[ ^bravo$ BravoParticipant ] ],
+      @dashboard.participant_list.collect { |e| [ e.regex, e.classname ] })
+  end
+
+  def test_participant_register_after
+
+    @dashboard.register_participant :alpha, 'AlphaParticipant'
+    @dashboard.register_participant :alpha, 'AlphaPrimeParticipant', :pos => :before
+
+    assert_equal(
+      [ %w[ ^alpha$ AlphaPrimeParticipant ],
+        %w[ ^alpha$ AlphaParticipant ] ],
+      @dashboard.participant_list.collect { |e| [ e.regex, e.classname ] })
+  end
+
+  def test_participant_register_before_after_corner_cases
+
+    @dashboard.register_participant :alpha, 'KlassA', :pos => :before
+    @dashboard.register_participant :bravo, 'KlassB', :pos => :after
+
+    assert_equal(
+      [ %w[ ^alpha$ KlassA ],
+        %w[ ^bravo$ KlassB ] ],
+      @dashboard.participant_list.collect { |e| [ e.regex, e.classname ] })
+  end
+
+  def test_participant_register_over
+
+    @dashboard.register_participant :alpha, 'KlassA'
+    @dashboard.register_participant :bravo, 'KlassB'
+    @dashboard.register_participant :alpha, 'KlassAa', :pos => :over
+    @dashboard.register_participant :charly, 'KlassC', :pos => :over
+
+    assert_equal(
+      [ %w[ ^alpha$ KlassAa ],
+        %w[ ^bravo$ KlassB ],
+        %w[ ^charly$ KlassC ] ],
+      @dashboard.participant_list.collect { |e| [ e.regex, e.classname ] })
   end
 
   def test_double_registration
 
-    @engine.register_participant :alpha do |workitem|
-      @tracer << 'alpha'
+    @dashboard.register_participant :alpha do |workitem|
+      tracer << 'alpha'
     end
-    @engine.register_participant :alpha do |workitem|
-      @tracer << 'alpha'
+    @dashboard.register_participant :alpha do |workitem|
+      tracer << 'alpha'
     end
 
-    assert_equal 1, @engine.context.plist.send(:get_list)['list'].size
+    assert_equal 1, @dashboard.context.plist.send(:get_list)['list'].size
   end
 
   def test_register_and_return_something
 
-    pa = @engine.register_participant :alpha do |workitem|
+    pa = @dashboard.register_participant :alpha do |workitem|
     end
-    pb = @engine.register_participant :bravo, Ruote::StorageParticipant
+    pb = @dashboard.register_participant :bravo, Ruote::StorageParticipant
 
     assert_nil pa
     assert_equal Ruote::StorageParticipant, pb.class
@@ -91,12 +138,10 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
 
   def test_participant_unregister_by_name
 
-    #noisy
-
-    @engine.register_participant :alpha do |workitem|
+    @dashboard.register_participant :alpha do |workitem|
     end
 
-    @engine.unregister_participant(:alpha)
+    @dashboard.unregister_participant(:alpha)
 
     wait_for(2)
     Thread.pass
@@ -108,10 +153,10 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
 
   def test_participant_unregister
 
-    @engine.register_participant :alpha do |workitem|
+    @dashboard.register_participant :alpha do |workitem|
     end
 
-    @engine.unregister_participant('alpha')
+    @dashboard.unregister_participant('alpha')
 
     wait_for(2)
 
@@ -119,7 +164,7 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
     assert_equal 'participant_unregistered', msg['action']
     assert_equal '^alpha$', msg['regex']
 
-    assert_equal 0, @engine.context.plist.list.size
+    assert_equal 0, @dashboard.context.plist.list.size
   end
 
   class MyParticipant
@@ -136,25 +181,25 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
 
   def test_participant_shutdown
 
-    alpha = @engine.register :alpha, MyParticipant
+    alpha = @dashboard.register :alpha, MyParticipant
 
-    @engine.context.plist.shutdown
+    @dashboard.context.plist.shutdown
 
     assert_equal true, MyParticipant.down
   end
 
   def test_participant_list_of_names
 
-    pa = @engine.register_participant :alpha do |workitem|
+    pa = @dashboard.register_participant :alpha do |workitem|
     end
 
-    assert_equal [ '^alpha$' ], @engine.context.plist.names
+    assert_equal [ '^alpha$' ], @dashboard.context.plist.names
   end
 
   def test_register_require_path
 
-    rpath = File.join(
-      File.dirname(__FILE__), "#{Time.now.to_f}_#{$$}_required_participant")
+    rpath = File.expand_path(
+      "../#{Time.now.to_f}_#{$$}_required_participant", __FILE__)
     path = "#{rpath}.rb"
 
     File.open(path, 'wb') do |f|
@@ -172,22 +217,22 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
       })
     end
 
-    @engine.register_participant(
+    @dashboard.register_participant(
       :alfred,
       'RequiredParticipant',
       :require_path => rpath, :message => 'hello')
 
-    assert_equal [ '^alfred$' ], @engine.context.plist.names
+    assert_equal [ '^alfred$' ], @dashboard.context.plist.names
 
     # first run
 
     assert_equal(
       [ 'RequiredParticipant',
         { 'require_path' => rpath, 'message' => 'hello' } ],
-      @engine.context.plist.lookup_info('alfred', nil))
+      @dashboard.context.plist.lookup_info('alfred', nil))
 
-    wfid = @engine.launch(Ruote.define { alfred })
-    r = @engine.wait_for(wfid)
+    wfid = @dashboard.launch(Ruote.define { alfred })
+    r = @dashboard.wait_for(wfid)
 
     assert_equal 'hello', r['workitem']['fields']['message']
 
@@ -208,8 +253,8 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
       })
     end
 
-    wfid = @engine.launch(Ruote.define { alfred })
-    r = @engine.wait_for(wfid)
+    wfid = @dashboard.launch(Ruote.define { alfred })
+    r = @dashboard.wait_for(wfid)
 
     # since it's a 'require', the code isn't reloaded
 
@@ -238,22 +283,22 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
       })
     end
 
-    @engine.register_participant(
+    @dashboard.register_participant(
       :alfred,
       'LoadedParticipant',
       :load_path => path, :message => 'bondzoi')
 
-    assert_equal [ '^alfred$' ], @engine.context.plist.names
+    assert_equal [ '^alfred$' ], @dashboard.context.plist.names
 
     # first run
 
     assert_equal(
       [ 'LoadedParticipant',
         { 'load_path' => path, 'message' => 'bondzoi' } ],
-      @engine.context.plist.lookup_info('alfred', nil))
+      @dashboard.context.plist.lookup_info('alfred', nil))
 
-    wfid = @engine.launch(Ruote.define { alfred })
-    r = @engine.wait_for(wfid)
+    wfid = @dashboard.launch(Ruote.define { alfred })
+    r = @dashboard.wait_for(wfid)
 
     assert_equal 'bondzoi', r['workitem']['fields']['message']
 
@@ -274,8 +319,8 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
       })
     end
 
-    wfid = @engine.launch(Ruote.define { alfred })
-    r = @engine.wait_for(wfid)
+    wfid = @dashboard.launch(Ruote.define { alfred })
+    r = @dashboard.wait_for(wfid)
 
     # since it's a 'load', the code is reloaded
 
@@ -286,49 +331,59 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
 
   def test_participant_list
 
-    #noisy
+    @dashboard.register_participant 'alpha', Ruote::StorageParticipant
 
-    @engine.register_participant 'alpha', Ruote::StorageParticipant
+    #assert_equal(
+    #  [ '/^alpha$/ ==> Ruote::StorageParticipant {}' ],
+    #  @dashboard.participant_list.collect { |pe| pe.to_s })
 
-    assert_equal(
-      [ '/^alpha$/ ==> Ruote::StorageParticipant {}' ],
-      @engine.participant_list.collect { |pe| pe.to_s })
+    plist = @dashboard.participant_list
+
+    assert_equal 1, plist.size
+    assert_equal '^alpha$', plist.first.regex
+    assert_equal 'Ruote::StorageParticipant', plist.first.classname
 
     # launching a process with a missing participant
 
-    wfid = @engine.launch(Ruote.define { bravo })
-    @engine.wait_for(wfid)
+    wfid = @dashboard.launch(Ruote.define { bravo })
+    @dashboard.wait_for(wfid)
 
-    assert_equal 1, @engine.process(wfid).errors.size
+    assert_equal 1, @dashboard.process(wfid).errors.size
 
     # fixing the error by updating the participant list
 
-    list = @engine.participant_list
+    list = @dashboard.participant_list
     list.first.regex = '^.+$' # instead of '^alpha$'
-    @engine.participant_list = list
+    @dashboard.participant_list = list
 
     # replay at error
 
-    @engine.replay_at_error(@engine.process(wfid).errors.first)
-    @engine.wait_for(:bravo)
+    @dashboard.replay_at_error(@dashboard.process(wfid).errors.first)
+    @dashboard.wait_for(:bravo)
 
     # bravo should hold a workitem
 
-    assert_equal 1, @engine.storage_participant.size
-    assert_equal 'bravo', @engine.storage_participant.first.participant_name
+    assert_equal 1, @dashboard.storage_participant.size
+    assert_equal 'bravo', @dashboard.storage_participant.first.participant_name
   end
 
   def test_participant_list_update
 
-    @engine.register_participant 'alpha', Ruote::StorageParticipant
+    @dashboard.register_participant 'alpha', Ruote::StorageParticipant
 
-    assert_equal(
-      [ '/^alpha$/ ==> Ruote::StorageParticipant {}' ],
-      @engine.participant_list.collect { |pe| pe.to_s })
+    #assert_equal(
+    #  [ '/^alpha$/ ==> Ruote::StorageParticipant {}' ],
+    #  @dashboard.participant_list.collect { |pe| pe.to_s })
+
+    plist = @dashboard.participant_list
+
+    assert_equal 1, plist.size
+    assert_equal '^alpha$', plist.first.regex
+    assert_equal 'Ruote::StorageParticipant', plist.first.classname
 
     # 0
 
-    @engine.participant_list = [
+    @dashboard.participant_list = [
       { 'regex' => '^bravo$',
         'classname' => 'Ruote::StorageParticipant',
         'options' => {} },
@@ -337,47 +392,57 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
         'options' => {} }
     ]
 
-    assert_equal(
-      [
-        '/^bravo$/ ==> Ruote::StorageParticipant {}',
-        '/^charly$/ ==> Ruote::StorageParticipant {}'
-      ],
-      @engine.participant_list.collect { |pe| pe.to_s })
+    #assert_equal(
+    #  [
+    #    '/^bravo$/ ==> Ruote::StorageParticipant {}',
+    #    '/^charly$/ ==> Ruote::StorageParticipant {}'
+    #  ],
+    #  @dashboard.participant_list.collect { |pe| pe.to_s })
+
+    plist = @dashboard.participant_list
+
+    assert_equal 2, plist.size
+    assert_equal '^bravo$', plist.first.regex
+    assert_equal '^charly$', plist.last.regex
+    assert_equal 'Ruote::StorageParticipant', plist.first.classname
+    assert_equal 'Ruote::StorageParticipant', plist.last.classname
 
     # 1
 
-    @engine.participant_list = [
+    @dashboard.participant_list = [
       [ '^charly$', [ 'Ruote::StorageParticipant', {} ] ],
       [ '^bravo$', [ 'Ruote::StorageParticipant', {} ] ]
     ]
 
-    assert_equal(
-      [
-        '/^charly$/ ==> Ruote::StorageParticipant {}',
-        '/^bravo$/ ==> Ruote::StorageParticipant {}'
-      ],
-      @engine.participant_list.collect { |pe| pe.to_s })
+    plist = @dashboard.participant_list
+
+    assert_equal 2, plist.size
+    assert_equal '^charly$', plist.first.regex
+    assert_equal '^bravo$', plist.last.regex
+    assert_equal 'Ruote::StorageParticipant', plist.first.classname
+    assert_equal 'Ruote::StorageParticipant', plist.last.classname
 
     # 2
 
-    @engine.participant_list = [
+    @dashboard.participant_list = [
       [ '^delta$', Ruote::StorageParticipant, {} ],
       [ '^echo$', 'Ruote::StorageParticipant', {} ]
     ]
 
-    assert_equal(
-      [
-        '/^delta$/ ==> Ruote::StorageParticipant {}',
-        '/^echo$/ ==> Ruote::StorageParticipant {}'
-      ],
-      @engine.participant_list.collect { |pe| pe.to_s })
+    plist = @dashboard.participant_list
+
+    assert_equal 2, plist.size
+    assert_equal '^delta$', plist.first.regex
+    assert_equal '^echo$', plist.last.regex
+    assert_equal 'Ruote::StorageParticipant', plist.first.classname
+    assert_equal 'Ruote::StorageParticipant', plist.last.classname
   end
 
   class ParticipantCharlie; end
 
   def test_register_block
 
-    @engine.register do
+    @dashboard.register do
       alpha 'Participants::Alpha', 'flavour' => 'vanilla'
       participant 'bravo', 'Participants::Bravo', :flavour => 'peach'
       participant 'charlie', 'Participants::Charlie'
@@ -387,11 +452,11 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
       catchall 'Participants::Zebda', 'flavour' => 'coconut'
     end
 
-    assert_equal 5, @engine.participant_list.size
+    assert_equal 5, @dashboard.participant_list.size
 
     assert_equal(
       %w[ ^alpha$ ^bravo$ ^charlie$ ^david$ ^.+$ ],
-      @engine.participant_list.collect { |pe| pe.regex.to_s })
+      @dashboard.participant_list.collect { |pe| pe.regex.to_s })
 
     assert_equal(
       %w[ Participants::Alpha
@@ -399,33 +464,96 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
           Participants::Charlie
           Ruote::BlockParticipant
           Participants::Zebda ],
-      @engine.participant_list.collect { |pe| pe.classname })
+      @dashboard.participant_list.collect { |pe| pe.classname })
 
     assert_equal(
       %w[ vanilla peach nil nil coconut ],
-      @engine.participant_list.collect { |pe|
+      @dashboard.participant_list.collect { |pe|
         (pe.options['flavour'] || 'nil') rescue 'nil'
       })
   end
 
+  def test_register_block_and_block
+
+    @dashboard.register do
+      alpha do |workitem|
+        a
+      end
+      participant 'bravo' do |workitem|
+        b
+      end
+    end
+
+    assert_equal(
+      [ [ 'on_workitem' ], [ 'on_workitem' ] ],
+      @dashboard.participant_list.collect { |pe| pe.options.keys })
+  end
+
   def test_register_block_catchall_default
 
-    @engine.register do
+    @dashboard.register do
       catchall
     end
 
     assert_equal(
       %w[ Ruote::StorageParticipant ],
-      @engine.participant_list.collect { |pe| pe.classname })
+      @dashboard.participant_list.collect { |pe| pe.classname })
+  end
+
+  def test_register_block_catch_all
+
+    @dashboard.register do
+      catch_all
+    end
+
+    assert_equal(
+      %w[ Ruote::StorageParticipant ],
+      @dashboard.participant_list.collect { |pe| pe.classname })
+  end
+
+  def test_register_block_override_false
+
+    @dashboard.register do
+      alpha 'KlassA'
+      alpha 'KlassB'
+    end
+
+    plist = @dashboard.participant_list
+
+    assert_equal(%w[ ^alpha$ ^alpha$ ], plist.collect { |pe| pe.regex })
+    assert_equal(%w[ KlassA KlassB ], plist.collect { |pe| pe.classname })
+    assert_equal({}, plist.first.options)
+  end
+
+  def test_register_block_clears
+
+    @dashboard.register 'alpha', 'AlphaParticipant'
+
+    @dashboard.register do
+      bravo 'BravoParticipant'
+    end
+
+    assert_equal 1, @dashboard.participant_list.size
+  end
+
+  def test_register_block_clear_option
+
+    @dashboard.register 'alpha', 'AlphaParticipant'
+
+    @dashboard.register :clear => false do
+      bravo 'BravoParticipant'
+    end
+
+    assert_equal 2, @dashboard.participant_list.size
   end
 
   def test_argument_error_on_instantiated_participant
 
     assert_raise ArgumentError do
-      @engine.register 'alpha', Ruote::StorageParticipant.new
+      @dashboard.register 'alpha', Ruote::StorageParticipant.new
     end
     assert_raise ArgumentError do
-      @engine.register 'alpha', Ruote::StorageParticipant.new, 'hello' => 'kitty'
+      @dashboard.register 'alpha', Ruote::StorageParticipant.new, 'hello' => 'kitty'
     end
   end
 
@@ -444,19 +572,19 @@ class FtParticipantRegistrationTest < Test::Unit::TestCase
 
   def test_engine_participant
 
-    @engine.register do
+    @dashboard.register do
       alpha AaParticipant
       bravo BbParticipant
       catchall AaParticipant, :catch_all => 'oh yeah'
     end
 
-    assert_equal AaParticipant, @engine.participant('alpha').class
-    assert_equal BbParticipant, @engine.participant('bravo').class
+    assert_equal AaParticipant, @dashboard.participant('alpha').class
+    assert_equal BbParticipant, @dashboard.participant('bravo').class
 
-    assert_equal AaParticipant, @engine.participant('charly').class
-    assert_equal 'oh yeah', @engine.participant('charly').opts['catch_all']
+    assert_equal AaParticipant, @dashboard.participant('charly').class
+    assert_equal 'oh yeah', @dashboard.participant('charly').opts['catch_all']
 
-    assert_equal Ruote::Context, @engine.participant('alpha').context.class
+    assert_equal Ruote::Context, @dashboard.participant('alpha').context.class
   end
 end