ruote-maestrodev 2.2.1

data/test/functional/ft_37_default_history.rb

@@ -0,0 +1,109 @@
+
+#
+# testing ruote
+#
+# Mon Jan 24 11:11:43 JST 2011
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtDefaultHistoryTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_engine_has_history
+
+    assert_not_nil @engine.context.history
+    assert_not_nil @engine.history
+  end
+
+  def launch_processes(clear=true)
+
+    @engine.history.clear! if clear
+
+    @engine.register_participant 'alpha', Ruote::NullParticipant
+
+    pdef = Ruote.define do
+      alpha
+    end
+
+    wfids = 2.times.collect { @engine.launch(pdef) }
+
+    @engine.wait_for(:alpha)
+    @engine.wait_for(:alpha)
+    sleep 0.700
+
+    wfids
+  end
+
+  def test_all
+
+    #noisy
+
+    wfids = launch_processes
+
+    assert_equal 11, @engine.history.all.size
+  end
+
+  def test_by_wfid
+
+    wfids = launch_processes
+
+    assert_equal 4, @engine.history.by_wfid(wfids[0]).size
+    assert_not_nil @engine.history.by_wfid(wfids[0]).first['seen_at']
+
+    assert_equal 4, @engine.history.by_wfid(wfids[1]).size
+  end
+
+  def test_clear!
+
+    launch_processes
+
+    assert_equal 11, @engine.history.all.size
+
+    @engine.history.clear!
+
+    assert_equal 0, @engine.history.all.size
+  end
+
+  def test_default_range
+
+    range = @engine.history.range
+
+    assert_equal Time, range[0].class
+    assert_equal range[0], range[1]
+  end
+
+  def test_range
+
+    launch_processes
+    sleep 1
+    launch_processes(false)
+
+    range = @engine.history.range
+
+    assert_not_equal range[0], range[1]
+    assert range[0] < range[1]
+  end
+
+  def test_by_date
+
+    launch_processes
+
+    @engine.history.all.each { |msg| msg['seen_at'] = '1970-12-25' }
+
+    launch_processes(false)
+
+    assert_equal 22, @engine.history.all.size
+
+    assert_equal 11, @engine.history.by_date(Time.now).size
+  end
+
+  def test_wfids
+
+    wfids = launch_processes
+
+    assert_equal wfids.sort, @engine.history.wfids
+  end
+end
+

data/test/functional/ft_38_participant_more.rb

@@ -0,0 +1,193 @@
+
+#
+# testing ruote
+#
+# Mon Apr 19 14:38:54 JST 2010
+#
+# Qcon Tokyo, special day
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/local_participant'
+
+
+class FtParticipantMoreTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class DifficultParticipant
+    include Ruote::LocalParticipant
+    def initialize(opts)
+    end
+    def consume(workitem)
+      context.tracer << "diff\n"
+      if workitem.fields['rejected'].nil?
+        workitem.fields['rejected'] = true
+        reject(workitem)
+      else
+        reply_to_engine(workitem)
+      end
+    end
+  end
+
+  # Reject and re_dispatch are aliases.
+  #
+  def test_participant_reject
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    @engine.register_participant :alpha, DifficultParticipant
+
+    #noisy
+
+    assert_trace(%w[ diff diff ], pdef)
+  end
+
+  class FightingParticipant
+    include Ruote::LocalParticipant
+    def initialize(opts)
+    end
+    def consume(workitem)
+      try = workitem.fields['try'] || 0
+      context.tracer << "try#{try}\n"
+      workitem.fields['try'] = try + 1
+      if (try == 0)
+        re_dispatch(workitem)
+      else
+        reply(workitem)
+      end
+    end
+  end
+
+  # Reject and re_dispatch are aliases.
+  #
+  def test_participant_re_dispatch
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    @engine.register_participant :alpha, FightingParticipant
+
+    #noisy
+
+    assert_trace(%w[ try0 try1 ], pdef)
+  end
+
+  class RetryParticipant
+    include Ruote::LocalParticipant
+    def initialize(opts)
+      @opts = opts
+    end
+    def consume(workitem)
+      try = workitem.fields['try'] || 0
+      context.tracer << "#{Time.now.to_f}\n"
+      workitem.fields['try'] = try + 1
+      if (try == 0)
+        re_dispatch(workitem, :in => @opts['delay'] || '1s')
+      else
+        reply(workitem)
+      end
+    end
+    def cancel(fei, flavour)
+      unschedule_re_dispatch(fei)
+    end
+  end
+
+  # Reject and re_dispatch are aliases.
+  #
+  # re_dispatch with an :in or an :at parameter makes sure the dispatch is
+  # performed once more, but a bit later (:in / :at timepoint).
+  #
+  def test_participant_re_dispatch_later
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    @engine.register_participant :alpha, RetryParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+
+    times = @tracer.to_s.split("\n").collect { |t| Float(t) }
+    t = times.last - times.first
+
+    assert t >= 1.0, "took less that 1 second"
+    assert t < 2.0, "took more than 1.99 second"
+  end
+
+  # Making sure that when a process gets cancelled, its 'later' re-dispatches
+  # are cancelled as well.
+  #
+  def test_participant_re_dispatch_later_cancel
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    @engine.register_participant :alpha, RetryParticipant, 'delay' => '1m'
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    sleep 0.7
+
+    @engine.cancel_process(wfid)
+    wait_for(wfid)
+
+    assert_equal 0, @engine.storage.get_many('schedules').size
+  end
+
+  BLACKBOARD = {}
+
+  class StashingParticipant
+    include Ruote::LocalParticipant
+    def initialize(opts)
+    end
+    def consume(workitem)
+      put(workitem.fei, 'token' => workitem.params['token'])
+    end
+    def cancel(fei, flavour)
+      BLACKBOARD['token'] = get(fei, 'token')
+      BLACKBOARD['all'] = get(fei)
+    end
+  end
+
+  # Stashing lets a stateless participant 'stash' state via put() and get()
+  # into the engine.
+  #
+  def test_stash
+
+    BLACKBOARD.clear
+
+    pdef = Ruote.process_definition do
+      alpha :token => 'of esteem'
+    end
+
+    @engine.register_participant :alpha, StashingParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(:alpha)
+
+    sleep 0.350 # since wait_for(:alpha) releases too early sometimes
+
+    ps = @engine.process(wfid)
+    fexp = ps.expressions.find { |e| e.fei.expid == '0_0' }
+
+    assert_equal({ 'token' => 'of esteem' }, fexp.h.stash)
+
+    @engine.cancel_process(wfid)
+    wait_for(wfid)
+
+    assert_equal('of esteem', BLACKBOARD['token'])
+    assert_equal({ 'token' => 'of esteem' }, BLACKBOARD['all'])
+  end
+end
+

data/test/functional/ft_39_wait_for.rb

@@ -0,0 +1,136 @@
+
+#
+# testing ruote
+#
+# Tue Apr 20 12:32:44 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/storage_participant'
+
+
+class FtWaitForTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_workitem
+
+    pdef = Ruote.process_definition :name => 'my process' do
+      alpha
+    end
+
+    sp = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    r = wait_for(:alpha)
+
+    assert_equal(
+      Ruote::Workitem,
+      @engine.workitem(Ruote.sid(r['fei'])).class)
+  end
+
+  class MyParticipant
+    include Ruote::LocalParticipant
+    def initialize(opts)
+    end
+    def consume(workitem)
+      sleep rand * 2
+      reply_to_engine(workitem)
+    end
+  end
+
+  def test_wait_for_empty
+
+    pdef = Ruote.process_definition :name => 'my process' do
+      alpha
+    end
+
+    @engine.register_participant :alpha, MyParticipant
+
+    4.times do
+      @engine.launch(pdef)
+    end
+
+    #noisy
+
+    @engine.wait_for(:empty)
+
+    assert_equal [], @engine.processes
+  end
+
+  def test_wait_for_multiple
+
+    pdef0 = Ruote.process_definition { alpha }
+    pdef1 = Ruote.process_definition { bravo }
+
+    @engine.register_participant :alpha, MyParticipant
+
+    #noisy
+
+    wfids = []
+
+    2.times { wfids << @engine.launch(pdef0) }
+    2.times { wfids << @engine.launch(pdef1) }
+
+    @engine.wait_for(*wfids)
+
+    assert_equal 2, @engine.processes.size
+  end
+
+  def test_wait_for_inactive
+
+    pdef0 = Ruote.process_definition { alpha }
+    pdef1 = Ruote.process_definition { bravo }
+
+    @engine.register_participant :alpha, MyParticipant
+
+    #noisy
+
+    wfids = []
+
+    2.times { @engine.launch(pdef0) }
+    2.times { wfids << @engine.launch(pdef1) }
+
+    @engine.wait_for(:inactive)
+
+    assert_equal wfids.sort, @engine.processes.collect { |ps| ps.wfid }.sort
+  end
+
+  def test_wait_for_multithreaded
+
+    pdef = Ruote.process_definition { alpha }
+
+    sp = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    seen = []
+    threads = []
+
+    threads << Thread.new do
+      @engine.wait_for(wfid)
+      seen << 'this'
+    end
+    threads << Thread.new do
+      @engine.wait_for(wfid)
+      seen << 'that'
+    end
+
+    @engine.wait_for(:alpha)
+
+    sp.proceed(sp.first)
+
+    threads.each do |t|
+      t.join
+    end
+
+    assert_equal %w[ that this ], seen.sort
+    assert_equal [], @engine.context.logger.instance_variable_get(:@waiting)
+  end
+end
+

data/test/functional/ft_3_participant_registration.rb

@@ -0,0 +1,574 @@
+
+#
+# testing ruote
+#
+# Mon May 18 22:25:57 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote'
+
+
+class FtParticipantRegistrationTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_participant_register
+
+    #noisy
+
+    @engine.register_participant :alpha do |workitem|
+      @tracer << 'alpha'
+    end
+    @engine.register_participant /^user_/, Ruote::NullParticipant
+
+    wait_for(2)
+
+    assert_equal(
+      'participant_registered',
+      logger.log[0]['action'])
+
+    assert_equal(
+      %w[ alpha /^user_/ ],
+      logger.log.collect { |msg| msg['regex'] })
+
+    assert_equal(
+      [ [ '^alpha$',
+          [ 'Ruote::BlockParticipant',
+            { 'on_workitem' => "proc do |workitem|\n      @tracer << 'alpha'\n    end" } ] ],
+        [ '^user_',
+          [ 'Ruote::NullParticipant',
+            {} ] ] ],
+      @engine.participant_list.collect { |pe| pe.to_a })
+  end
+
+  def test_participant_register_position
+
+    @engine.register_participant :ur, Ruote::StorageParticipant
+
+    assert_equal(
+      %w[ ^ur$ ],
+      @engine.participant_list.collect { |pe| pe.regex.to_s })
+
+    @engine.register_participant(
+      :first, Ruote::StorageParticipant, :position => :first)
+    @engine.register_participant(
+      :last, Ruote::StorageParticipant, :position => :last)
+
+    assert_equal(
+      %w[ ^first$ ^ur$ ^last$ ],
+      @engine.participant_list.collect { |pe| pe.regex.to_s })
+
+    @engine.register_participant(
+      :x, Ruote::StorageParticipant, :position => -2)
+
+    assert_equal(
+      %w[ ^first$ ^ur$ ^x$ ^last$ ],
+      @engine.participant_list.collect { |pe| pe.regex.to_s })
+  end
+
+  def test_participant_register_before
+
+    @engine.register_participant :alpha, 'AlphaParticipant'
+    @engine.register_participant :bravo, 'BravoParticipant'
+    @engine.register_participant :alpha, 'AlphaPrimeParticipant', :pos => :after
+
+    assert_equal(
+      [ %w[ ^alpha$ AlphaParticipant ],
+        %w[ ^alpha$ AlphaPrimeParticipant ],
+        %w[ ^bravo$ BravoParticipant ] ],
+      @engine.participant_list.collect { |e| [ e.regex, e.classname ] })
+  end
+
+  def test_participant_register_after
+
+    @engine.register_participant :alpha, 'AlphaParticipant'
+    @engine.register_participant :alpha, 'AlphaPrimeParticipant', :pos => :before
+
+    assert_equal(
+      [ %w[ ^alpha$ AlphaPrimeParticipant ],
+        %w[ ^alpha$ AlphaParticipant ] ],
+      @engine.participant_list.collect { |e| [ e.regex, e.classname ] })
+  end
+
+  def test_participant_register_before_after_corner_cases
+
+    @engine.register_participant :alpha, 'KlassA', :pos => :before
+    @engine.register_participant :bravo, 'KlassB', :pos => :after
+
+    assert_equal(
+      [ %w[ ^alpha$ KlassA ],
+        %w[ ^bravo$ KlassB ] ],
+      @engine.participant_list.collect { |e| [ e.regex, e.classname ] })
+  end
+
+  def test_participant_register_over
+
+    @engine.register_participant :alpha, 'KlassA'
+    @engine.register_participant :bravo, 'KlassB'
+    @engine.register_participant :alpha, 'KlassAa', :pos => :over
+    @engine.register_participant :charly, 'KlassC', :pos => :over
+
+    assert_equal(
+      [ %w[ ^alpha$ KlassAa ],
+        %w[ ^bravo$ KlassB ],
+        %w[ ^charly$ KlassC ] ],
+      @engine.participant_list.collect { |e| [ e.regex, e.classname ] })
+  end
+
+  def test_double_registration
+
+    @engine.register_participant :alpha do |workitem|
+      @tracer << 'alpha'
+    end
+    @engine.register_participant :alpha do |workitem|
+      @tracer << 'alpha'
+    end
+
+    assert_equal 1, @engine.context.plist.send(:get_list)['list'].size
+  end
+
+  def test_register_and_return_something
+
+    pa = @engine.register_participant :alpha do |workitem|
+    end
+    pb = @engine.register_participant :bravo, Ruote::StorageParticipant
+
+    assert_nil pa
+    assert_equal Ruote::StorageParticipant, pb.class
+  end
+
+  def test_participant_unregister_by_name
+
+    #noisy
+
+    @engine.register_participant :alpha do |workitem|
+    end
+
+    @engine.unregister_participant(:alpha)
+
+    wait_for(2)
+    Thread.pass
+
+    msg = logger.log.last
+    assert_equal 'participant_unregistered', msg['action']
+    assert_equal '^alpha$', msg['regex']
+  end
+
+  def test_participant_unregister
+
+    @engine.register_participant :alpha do |workitem|
+    end
+
+    @engine.unregister_participant('alpha')
+
+    wait_for(2)
+
+    msg = logger.log.last
+    assert_equal 'participant_unregistered', msg['action']
+    assert_equal '^alpha$', msg['regex']
+
+    assert_equal 0, @engine.context.plist.list.size
+  end
+
+  class MyParticipant
+    @@down = false
+    def self.down
+      @@down
+    end
+    def initialize
+    end
+    def shutdown
+      @@down = true
+    end
+  end
+
+  def test_participant_shutdown
+
+    alpha = @engine.register :alpha, MyParticipant
+
+    @engine.context.plist.shutdown
+
+    assert_equal true, MyParticipant.down
+  end
+
+  def test_participant_list_of_names
+
+    pa = @engine.register_participant :alpha do |workitem|
+    end
+
+    assert_equal [ '^alpha$' ], @engine.context.plist.names
+  end
+
+  def test_register_require_path
+
+    rpath = File.join(
+      File.dirname(__FILE__), "#{Time.now.to_f}_#{$$}_required_participant")
+    path = "#{rpath}.rb"
+
+    File.open(path, 'wb') do |f|
+      f.write(%{
+        class RequiredParticipant
+          include Ruote::LocalParticipant
+          def initialize(opts)
+            @opts = opts
+          end
+          def consume(workitem)
+            workitem.fields['message'] = @opts['message']
+            reply(workitem)
+          end
+        end
+      })
+    end
+
+    @engine.register_participant(
+      :alfred,
+      'RequiredParticipant',
+      :require_path => rpath, :message => 'hello')
+
+    assert_equal [ '^alfred$' ], @engine.context.plist.names
+
+    # first run
+
+    assert_equal(
+      [ 'RequiredParticipant',
+        { 'require_path' => rpath, 'message' => 'hello' } ],
+      @engine.context.plist.lookup_info('alfred', nil))
+
+    wfid = @engine.launch(Ruote.define { alfred })
+    r = @engine.wait_for(wfid)
+
+    assert_equal 'hello', r['workitem']['fields']['message']
+
+    # second run
+
+    File.open(path, 'wb') do |f|
+      f.write(%{
+        class RequiredParticipant
+          include Ruote::LocalParticipant
+          def initialize(opts)
+            @opts = opts
+          end
+          def consume(workitem)
+            workitem.fields['message'] = 'second run'
+            reply(workitem)
+          end
+        end
+      })
+    end
+
+    wfid = @engine.launch(Ruote.define { alfred })
+    r = @engine.wait_for(wfid)
+
+    # since it's a 'require', the code isn't reloaded
+
+    assert_equal 'hello', r['workitem']['fields']['message']
+
+    FileUtils.rm(path)
+  end
+
+  def test_reqister_load_path
+
+    path = File.join(
+      File.dirname(__FILE__), "#{Time.now.to_f}_#{$$}_loaded_participant.rb")
+
+    File.open(path, 'wb') do |f|
+      f.write(%{
+        class LoadedParticipant
+          include Ruote::LocalParticipant
+          def initialize(opts)
+            @opts = opts
+          end
+          def consume(workitem)
+            workitem.fields['message'] = @opts['message']
+            reply(workitem)
+          end
+        end
+      })
+    end
+
+    @engine.register_participant(
+      :alfred,
+      'LoadedParticipant',
+      :load_path => path, :message => 'bondzoi')
+
+    assert_equal [ '^alfred$' ], @engine.context.plist.names
+
+    # first run
+
+    assert_equal(
+      [ 'LoadedParticipant',
+        { 'load_path' => path, 'message' => 'bondzoi' } ],
+      @engine.context.plist.lookup_info('alfred', nil))
+
+    wfid = @engine.launch(Ruote.define { alfred })
+    r = @engine.wait_for(wfid)
+
+    assert_equal 'bondzoi', r['workitem']['fields']['message']
+
+    # second run
+
+    File.open(path, 'wb') do |f|
+      f.write(%{
+        class LoadedParticipant
+          include Ruote::LocalParticipant
+          def initialize(opts)
+            @opts = opts
+          end
+          def consume(workitem)
+            workitem.fields['message'] = 'second run'
+            reply(workitem)
+          end
+        end
+      })
+    end
+
+    wfid = @engine.launch(Ruote.define { alfred })
+    r = @engine.wait_for(wfid)
+
+    # since it's a 'load', the code is reloaded
+
+    assert_equal 'second run', r['workitem']['fields']['message']
+
+    FileUtils.rm(path)
+  end
+
+  def test_participant_list
+
+    #noisy
+
+    @engine.register_participant 'alpha', Ruote::StorageParticipant
+
+    assert_equal(
+      [ '/^alpha$/ ==> Ruote::StorageParticipant {}' ],
+      @engine.participant_list.collect { |pe| pe.to_s })
+
+    # launching a process with a missing participant
+
+    wfid = @engine.launch(Ruote.define { bravo })
+    @engine.wait_for(wfid)
+
+    assert_equal 1, @engine.process(wfid).errors.size
+
+    # fixing the error by updating the participant list
+
+    list = @engine.participant_list
+    list.first.regex = '^.+$' # instead of '^alpha$'
+    @engine.participant_list = list
+
+    # replay at error
+
+    @engine.replay_at_error(@engine.process(wfid).errors.first)
+    @engine.wait_for(:bravo)
+
+    # bravo should hold a workitem
+
+    assert_equal 1, @engine.storage_participant.size
+    assert_equal 'bravo', @engine.storage_participant.first.participant_name
+  end
+
+  def test_participant_list_update
+
+    @engine.register_participant 'alpha', Ruote::StorageParticipant
+
+    assert_equal(
+      [ '/^alpha$/ ==> Ruote::StorageParticipant {}' ],
+      @engine.participant_list.collect { |pe| pe.to_s })
+
+    # 0
+
+    @engine.participant_list = [
+      { 'regex' => '^bravo$',
+        'classname' => 'Ruote::StorageParticipant',
+        'options' => {} },
+      { 'regex' => '^charly$',
+        'classname' => 'Ruote::StorageParticipant',
+        'options' => {} }
+    ]
+
+    assert_equal(
+      [
+        '/^bravo$/ ==> Ruote::StorageParticipant {}',
+        '/^charly$/ ==> Ruote::StorageParticipant {}'
+      ],
+      @engine.participant_list.collect { |pe| pe.to_s })
+
+    # 1
+
+    @engine.participant_list = [
+      [ '^charly$', [ 'Ruote::StorageParticipant', {} ] ],
+      [ '^bravo$', [ 'Ruote::StorageParticipant', {} ] ]
+    ]
+
+    assert_equal(
+      [
+        '/^charly$/ ==> Ruote::StorageParticipant {}',
+        '/^bravo$/ ==> Ruote::StorageParticipant {}'
+      ],
+      @engine.participant_list.collect { |pe| pe.to_s })
+
+    # 2
+
+    @engine.participant_list = [
+      [ '^delta$', Ruote::StorageParticipant, {} ],
+      [ '^echo$', 'Ruote::StorageParticipant', {} ]
+    ]
+
+    assert_equal(
+      [
+        '/^delta$/ ==> Ruote::StorageParticipant {}',
+        '/^echo$/ ==> Ruote::StorageParticipant {}'
+      ],
+      @engine.participant_list.collect { |pe| pe.to_s })
+  end
+
+  class ParticipantCharlie; end
+
+  def test_register_block
+
+    @engine.register do
+      alpha 'Participants::Alpha', 'flavour' => 'vanilla'
+      participant 'bravo', 'Participants::Bravo', :flavour => 'peach'
+      participant 'charlie', 'Participants::Charlie'
+      participant 'david' do |wi|
+        p wi
+      end
+      catchall 'Participants::Zebda', 'flavour' => 'coconut'
+    end
+
+    assert_equal 5, @engine.participant_list.size
+
+    assert_equal(
+      %w[ ^alpha$ ^bravo$ ^charlie$ ^david$ ^.+$ ],
+      @engine.participant_list.collect { |pe| pe.regex.to_s })
+
+    assert_equal(
+      %w[ Participants::Alpha
+          Participants::Bravo
+          Participants::Charlie
+          Ruote::BlockParticipant
+          Participants::Zebda ],
+      @engine.participant_list.collect { |pe| pe.classname })
+
+    assert_equal(
+      %w[ vanilla peach nil nil coconut ],
+      @engine.participant_list.collect { |pe|
+        (pe.options['flavour'] || 'nil') rescue 'nil'
+      })
+  end
+
+  def test_register_block_and_block
+
+    @engine.register do
+      alpha do |workitem|
+        a
+      end
+      participant 'bravo' do |workitem|
+        b
+      end
+    end
+
+    assert_equal(
+      [ [ 'on_workitem' ], [ 'on_workitem' ] ],
+      @engine.participant_list.collect { |pe| pe.options.keys })
+  end
+
+  def test_register_block_catchall_default
+
+    @engine.register do
+      catchall
+    end
+
+    assert_equal(
+      %w[ Ruote::StorageParticipant ],
+      @engine.participant_list.collect { |pe| pe.classname })
+  end
+
+  def test_register_block_catch_all
+
+    @engine.register do
+      catch_all
+    end
+
+    assert_equal(
+      %w[ Ruote::StorageParticipant ],
+      @engine.participant_list.collect { |pe| pe.classname })
+  end
+
+  def test_register_block_override_false
+
+    @engine.register do
+      alpha 'KlassA'
+      alpha 'KlassB'
+    end
+
+    plist = @engine.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
+
+    @engine.register 'alpha', 'AlphaParticipant'
+
+    @engine.register do
+      bravo 'BravoParticipant'
+    end
+
+    assert_equal 1, @engine.participant_list.size
+  end
+
+  def test_register_block_clear_option
+
+    @engine.register 'alpha', 'AlphaParticipant'
+
+    @engine.register :clear => false do
+      bravo 'BravoParticipant'
+    end
+
+    assert_equal 2, @engine.participant_list.size
+  end
+
+  def test_argument_error_on_instantiated_participant
+
+    assert_raise ArgumentError do
+      @engine.register 'alpha', Ruote::StorageParticipant.new
+    end
+    assert_raise ArgumentError do
+      @engine.register 'alpha', Ruote::StorageParticipant.new, 'hello' => 'kitty'
+    end
+  end
+
+  class AaParticipant
+    include Ruote::LocalParticipant
+    attr_reader :opts
+    def initialize(opts)
+      @opts = opts
+    end
+  end
+  class BbParticipant < AaParticipant
+    def accept?(workitem)
+      false
+    end
+  end
+
+  def test_engine_participant
+
+    @engine.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, @engine.participant('charly').class
+    assert_equal 'oh yeah', @engine.participant('charly').opts['catch_all']
+
+    assert_equal Ruote::Context, @engine.participant('alpha').context.class
+  end
+end
+