ruote 2.2.0 → 2.3.0

data/test/functional/ft_16_participant_params.rb

@@ -5,7 +5,7 @@
 # Wed Jul  1 09:51:30 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'base')
+require File.expand_path('../base', __FILE__)
 
 
 class FtParticipantParamsTest < Test::Unit::TestCase
@@ -21,25 +21,78 @@ class FtParticipantParamsTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+    alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
     #noisy
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
     wait_for(:alpha)
     assert_equal({ 'ref' => 'alpha' }, alpha.first.fields['params'])
-    alpha.reply(alpha.first)
+    alpha.proceed(alpha.first)
 
     wait_for(:alpha)
     assert_equal('buy groceries', alpha.first.fields['params']['activity'])
-    alpha.reply(alpha.first)
+    alpha.proceed(alpha.first)
 
     wait_for(:alpha)
     assert_equal({ 'ref' => 'alpha' }, alpha.first.fields['params'])
-    alpha.reply(alpha.first)
+    alpha.proceed(alpha.first)
 
     wait_for(wfid)
   end
+
+  def test_attribute_text_param
+
+    pdef = Ruote.process_definition do
+      alpha 'nemo', :action => 'nada'
+      bravo
+    end
+
+    @dashboard.register { catchall }
+
+    #@dashboard.noisy = true
+
+    @dashboard.launch(pdef)
+
+    @dashboard.wait_for(:alpha)
+    workitem = @dashboard.storage_participant.first
+
+    assert_equal(
+      { 'nemo' => nil, 'action' => 'nada', 'ref' => 'alpha' }, workitem.params)
+    assert_equal(
+      'nemo', workitem.param_text)
+
+    @dashboard.storage_participant.proceed(workitem)
+
+    @dashboard.wait_for(:bravo)
+    workitem = @dashboard.storage_participant.first
+
+    assert_equal(
+      nil, workitem.param_text)
+  end
+
+  def test_param_or_field
+
+    pdef = Ruote.process_definition do
+      alpha
+      alpha :theme => :wagner
+    end
+
+    @dashboard.register :alpha do |workitem|
+      context.tracer << "pof_theme:#{workitem.param_or_field(:theme)}\n"
+      context.tracer << "fop_theme:#{workitem.field_or_param(:theme)}\n"
+    end
+
+    #@dashboard.noisy = true
+
+    wfid = @dashboard.launch(pdef, 'theme' => 'mozart')
+    @dashboard.wait_for(wfid)
+
+    assert_equal %w[
+       pof_theme:mozart fop_theme:mozart
+       pof_theme:wagner fop_theme:mozart
+    ], @tracer.to_a
+  end
 end
 

data/test/functional/ft_17_conditional.rb

@@ -5,7 +5,7 @@
 # Fri Jul  3 19:46:22 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'base')
+require File.expand_path('../base', __FILE__)
 
 
 class FtConditionalTest < Test::Unit::TestCase
@@ -80,6 +80,8 @@ class FtConditionalTest < Test::Unit::TestCase
 
       set 'f:t' => true
       set 'f:f' => false
+      set 'f:name' => 'n'
+      set 'f:city' => 'c'
 
       sequence do
 
@@ -90,10 +92,74 @@ class FtConditionalTest < Test::Unit::TestCase
         echo 'c', :if => '${f:t} and ${f:f}'
         echo 'd', :if => '${f:t} and (${f:t} or ${f:f})'
         echo 'e', :if => '${f:t} and (${f:t} and ${f:f})'
+        echo 'f', :if => '${name} == n and ${city} == c'
       end
     end
 
-    assert_trace(%w[ true/false a b d ], pdef)
+    assert_trace(%w[ true/false a b d f ], pdef)
+  end
+
+  def test_if_booleans
+
+    pdef = Ruote.define do
+
+      echo 'a', :if => true
+      echo '.'
+      echo 'b', :if => 'true'
+      echo '.'
+      echo 'c', :if => false
+      echo '.'
+      echo 'd', :if => 'false'
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+    assert_equal 'a.b..', @tracer.to_a.join
+  end
+
+  def test_unless_booleans
+
+    pdef = Ruote.define do
+
+      echo 'a', :unless => true
+      echo '.'
+      echo 'b', :unless => 'true'
+      echo '.'
+      echo 'c', :unless => false
+      echo '.'
+      echo 'd', :unless => 'false'
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+    assert_equal '..c.d', @tracer.to_a.join
+  end
+
+  def test_with_numbers
+
+    pdef = Ruote.define do
+
+      set 'commission' => 2.310000
+      set 'scommission' => '2.310000'
+
+      echo 'a', :if => '${f:commission} > 0'
+      echo '.'
+      echo 'b', :unless => '${f:commission} > 0'
+      echo '.'
+      echo 'c', :if => '${f:scommission} > 0'
+      echo '.'
+      echo 'c', :unless => '${f:scommission} > 0'
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+    assert_equal 'a..c.', @tracer.to_a.join
   end
 end
 

data/test/functional/ft_18_kill.rb

@@ -5,7 +5,7 @@
 # Sun Jul  5 22:56:06 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'base')
+require File.expand_path('../base', __FILE__)
 
 
 class FtKillTest < Test::Unit::TestCase
@@ -17,23 +17,36 @@ class FtKillTest < Test::Unit::TestCase
       alpha
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+    alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
     #noisy
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
     wait_for(:alpha)
 
-    @engine.kill_process(wfid)
+    @dashboard.kill_process(wfid)
 
     wait_for(wfid)
-    ps = @engine.process(wfid)
+    ps = @dashboard.process(wfid)
 
     assert_nil ps
     assert_equal 0, alpha.size
 
     assert_equal(
-      1, logger.log.select { |e| e['action'] == 'kill_process' }.size)
+      1,
+      logger.log.select { |e|
+        e['action'] == 'cancel_process' &&
+        e['flavour'] == 'kill'
+      }.size)
+  end
+
+  def test_kill_process_with_source
+
+    @dashboard.kill('20111121-nada', :source => 'y')
+
+    @dashboard.wait_for(1)
+
+    assert_equal 'y', @dashboard.context.logger.log.first['source']
   end
 
   def test_kill_does_not_trigger_on_cancel
@@ -44,13 +57,13 @@ class FtKillTest < Test::Unit::TestCase
       end
     end
 
-    @engine.register_participant :alpha, Ruote::StorageParticipant
-    sto = @engine.register_participant :catcher, Ruote::StorageParticipant
+    @dashboard.register_participant :alpha, Ruote::StorageParticipant
+    sto = @dashboard.register_participant :catcher, Ruote::StorageParticipant
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
     wait_for(:alpha)
 
-    @engine.kill_process(wfid)
+    @dashboard.kill_process(wfid)
 
     wait_for(wfid)
 
@@ -65,13 +78,13 @@ class FtKillTest < Test::Unit::TestCase
       end
     end
 
-    @engine.register_participant :alpha, Ruote::StorageParticipant
-    sto = @engine.register_participant :catcher, Ruote::StorageParticipant
+    @dashboard.register_participant :alpha, Ruote::StorageParticipant
+    sto = @dashboard.register_participant :catcher, Ruote::StorageParticipant
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
     wait_for(:alpha)
 
-    @engine.kill_expression(sto.first.fei)
+    @dashboard.kill_expression(sto.first.fei)
 
     wait_for(wfid)
 
@@ -84,21 +97,26 @@ class FtKillTest < Test::Unit::TestCase
       alpha
     end
 
-    @engine.register_participant :alpha, Ruote::NullParticipant
+    @dashboard.register_participant :alpha, Ruote::NullParticipant
 
     #noisy
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
-    @engine.wait_for(:alpha)
+    @dashboard.wait_for(:alpha)
 
-    @engine.kill(wfid)
+    @dashboard.kill(wfid)
 
-    @engine.wait_for(wfid)
+    @dashboard.wait_for(wfid)
 
-    assert_nil @engine.process(wfid)
+    assert_nil @dashboard.process(wfid)
 
-    assert_equal 1, logger.log.select { |e| e['action'] == 'kill_process' }.size
+    assert_equal(
+      1,
+      logger.log.select { |e|
+        e['action'] == 'cancel_process' &&
+        e['flavour'] == 'kill'
+      }.size)
   end
 
   def test_kill__process
@@ -112,23 +130,23 @@ class FtKillTest < Test::Unit::TestCase
       echo '2'
     end
 
-    @engine.register_participant :alpha, Ruote::NullParticipant
+    @dashboard.register_participant :alpha, Ruote::NullParticipant
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
-    r = @engine.wait_for(:alpha)
+    r = @dashboard.wait_for(:alpha)
 
-    @engine.kill(r['fei']) # fei as a Hash
+    @dashboard.kill(r['fei']) # fei as a Hash
 
-    r = @engine.wait_for(:alpha)
+    r = @dashboard.wait_for(:alpha)
 
-    @engine.kill(Ruote.sid(r['fei'])) # fei as a String
+    @dashboard.kill(Ruote.sid(r['fei'])) # fei as a String
 
-    r = @engine.wait_for(:alpha)
+    r = @dashboard.wait_for(:alpha)
 
-    @engine.kill(Ruote::Workitem.new(r['workitem'])) # fei as workitem
+    @dashboard.kill(Ruote::Workitem.new(r['workitem'])) # fei as workitem
 
-    @engine.wait_for(wfid)
+    @dashboard.wait_for(wfid)
 
     assert_equal %w[ 0 1 2 ], @tracer.to_a
 

data/test/functional/ft_19_participant_code.rb

@@ -0,0 +1,67 @@
+
+#
+# testing ruote
+#
+# Fri Apr 22 15:44:38 JST 2011
+#
+# Singapore
+#
+
+require File.expand_path('../base', __FILE__)
+
+
+class FtParticipantCodeTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_block_participant
+
+    @dashboard.context['participant_in_variable_enabled'] = true
+
+    pdef = Ruote.process_definition :name => 'def0' do
+
+      set 'v:alpha' => {
+        'on_workitem' => lambda { |wi|
+          wi.fields['alpha'] = wi.participant_name
+          wi.fields['x'] = 0
+        }
+      }
+
+      alpha
+    end
+
+    wfid = @dashboard.launch(pdef)
+
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal(
+      { 'alpha' => 'alpha', 'x' => 0, '__result__' => 0 },
+      r['workitem']['fields'])
+  end
+
+  def test_code_participant
+
+    @dashboard.context['participant_in_variable_enabled'] = true
+
+    pdef = Ruote.process_definition do
+
+      set 'v:alpha' => %{
+        def consume(workitem)
+          workitem.fields['x'] = 0
+          workitem.fields['alpha'] = workitem.participant_name
+          reply_to_engine(workitem)
+        end
+      }
+
+      alpha
+    end
+
+    wfid = @dashboard.launch(pdef)
+
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal(
+      { 'x' => 0, 'alpha' => 'alpha' },
+      r['workitem']['fields'])
+  end
+end
+

data/test/functional/ft_1_process_status.rb

@@ -5,7 +5,7 @@
 # Fri May 15 09:51:28 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'base')
+require File.expand_path('../base', __FILE__)
 
 require 'ruote/participant'
 
@@ -19,15 +19,13 @@ class FtProcessStatusTest < Test::Unit::TestCase
       participant :ref => 'alpha'
     end
 
-    #noisy
+    alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
-    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
-
-    wfid = @engine.launch(pdef, :workitem => { 'kilroy' => 'was here' })
+    wfid = @dashboard.launch(pdef, :workitem => { 'kilroy' => 'was here' })
 
     wait_for(:alpha)
 
-    ps = @engine.process(wfid)
+    ps = @dashboard.process(wfid)
 
     assert_equal 'my process', ps.definition_name
     assert_equal nil, ps.definition_revision
@@ -47,12 +45,12 @@ class FtProcessStatusTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
-    wfid = @engine.launch(pdef, :workitem => { 'kilroy' => 'was here' })
+    alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
+    wfid = @dashboard.launch(pdef, :workitem => { 'kilroy' => 'was here' })
 
     wait_for(:alpha)
 
-    ps = @engine.process(wfid)
+    ps = @dashboard.process(wfid)
 
     assert_equal 'my process', ps.definition_name
 
@@ -67,21 +65,21 @@ class FtProcessStatusTest < Test::Unit::TestCase
       nada
     end
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
     wait_for(wfid)
 
-    errs = @engine.errors
+    errs = @dashboard.errors
 
     assert_equal 1, errs.size
 
     assert_equal wfid, errs.first.wfid
 
-    err = @engine.errors(wfid)
+    err = @dashboard.errors(wfid)
 
     assert_equal 1, err.size
     assert_equal wfid, err.first.wfid
 
-    assert_equal 1, @engine.errors(:count => true)
+    assert_equal 1, @dashboard.errors(:count => true)
   end
 
   def test_tree
@@ -93,12 +91,12 @@ class FtProcessStatusTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
-    wfid = @engine.launch(pdef)
+    alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
+    wfid = @dashboard.launch(pdef)
 
     wait_for(:alpha)
 
-    ps = @engine.process(wfid)
+    ps = @dashboard.process(wfid)
 
     assert_equal(
       ["define", {"my process"=>nil}, [
@@ -145,12 +143,12 @@ class FtProcessStatusTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
-    wfid = @engine.launch(pdef)
+    alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
+    wfid = @dashboard.launch(pdef)
 
     wait_for(:alpha)
 
-    ps = @engine.process(wfid)
+    ps = @dashboard.process(wfid)
 
     assert_equal(
       {"my process"=>["0", ["define", {"my process"=>nil}, [["define", {"sub0"=>nil}, [["echo", {"meh"=>nil}, []]]], ["participant", {"ref"=>"alpha"}, []]]]], "sub0"=>["0_0", ["define", {"sub0"=>nil}, [["echo", {"meh"=>nil}, []]]]]},
@@ -184,15 +182,13 @@ class FtProcessStatusTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
-
-    #noisy
+    alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
     wait_for(:alpha)
 
-    ps = @engine.process(wfid)
+    ps = @dashboard.process(wfid)
 
     assert_equal(0, ps.variables['v0'])
     assert_equal(nil, ps.variables['v1'])
@@ -214,18 +210,17 @@ class FtProcessStatusTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
-
-    #noisy
+    alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
     wait_for(:alpha)
 
-    ps = @engine.process(wfid)
+    ps = @dashboard.process(wfid)
 
-    assert_equal %w[ main part ], ps.tags.keys.sort
+    assert_equal %w[ main main/part part ], ps.tags.keys.sort
+    assert_equal %w[ main main/part part ], ps.all_tags.keys.sort
 
-    assert_equal 2, ps.all_tags.size
+    assert_equal 3, ps.all_tags.size
     assert_kind_of Array, ps.all_tags['main']
     assert_equal 1, ps.all_tags['main'].size
   end
@@ -243,16 +238,14 @@ class FtProcessStatusTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+    alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
-    #noisy
-
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
     wait_for(:alpha)
 
-    ps = @engine.process(wfid)
+    ps = @dashboard.process(wfid)
 
-    assert_equal 1, ps.tags.size
+    assert_equal 2, ps.tags.size
     assert_equal 2, ps.all_tags['tag0'].size
   end
 
@@ -262,17 +255,15 @@ class FtProcessStatusTest < Test::Unit::TestCase
       participant :ref => 'alpha'
     end
 
-    #noisy
-
-    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+    alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
-    wfid0 = @engine.launch(pdef)
-    wfid1 = @engine.launch(pdef)
+    wfid0 = @dashboard.launch(pdef)
+    wfid1 = @dashboard.launch(pdef)
 
     wait_for(:alpha)
     wait_for(:alpha)
 
-    ps = @engine.processes
+    ps = @dashboard.processes
 
     assert_equal 2, ps.size
     assert_equal [ wfid0, wfid1 ].sort, ps.collect { |e| e.wfid }.sort
@@ -284,23 +275,23 @@ class FtProcessStatusTest < Test::Unit::TestCase
 
     n = 3
 
-    @engine.register_participant :alpha, Ruote::StorageParticipant
+    @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
-    n.times.collect { @engine.launch(Ruote.define { alpha }) }
+    n.times.collect { @dashboard.launch(Ruote.define { alpha }) }
 
-    while @engine.storage_participant.size < n; sleep 0.100; end
+    while @dashboard.storage_participant.size < n; sleep 0.100; end
     sleep 0.100
 
-    @engine.ps(@engine.storage_participant.first.wfid).expressions.each do |exp|
-      @engine.storage.delete(exp.h)
+    @dashboard.ps(@dashboard.storage_participant.first.wfid).expressions.each do |exp|
+      @dashboard.storage.delete(exp.h)
     end
       # nuking all the expressions of a process instance
 
-    assert_equal n - 1, @engine.processes.size
-    assert_equal n,  @engine.storage_participant.size
+    assert_equal n - 1, @dashboard.processes.size
+    assert_equal n,  @dashboard.storage_participant.size
       # orphan workitem left in storage
 
-    assert_equal 1, @engine.leftovers.size
+    assert_equal 1, @dashboard.leftovers.size
   end
 
   def test_left_overs
@@ -313,15 +304,15 @@ class FtProcessStatusTest < Test::Unit::TestCase
       { '_id' => '0!f!z', 'type' => 'schedules', 'fei' => { 'wfid' => 'z' },
         'at' => Ruote.time_to_utc_s(Time.now + 24 * 3600) }
     ].each do |doc|
-      @engine.storage.put(doc)
+      @dashboard.storage.put(doc)
     end
 
     assert_equal(
       3,
-      @engine.leftovers.size)
+      @dashboard.leftovers.size)
     assert_equal(
       %w[ workitems errors schedules ],
-      @engine.leftovers.collect { |lo| lo['type'] })
+      @dashboard.leftovers.collect { |lo| lo['type'] })
   end
 
   def test_tree_rewrite
@@ -335,9 +326,9 @@ class FtProcessStatusTest < Test::Unit::TestCase
       delta
     end
 
-    @engine.register_participant :alpha do |wi, fexp|
+    @dashboard.register_participant :alpha do |wi, fexp|
 
-      @tracer << "a\n"
+      tracer << "a\n"
 
       parent = fexp.parent
       parent.update_tree
@@ -345,29 +336,27 @@ class FtProcessStatusTest < Test::Unit::TestCase
       parent.persist
     end
 
-    @engine.register_participant :bravo do |wi, fexp|
-      @tracer << "b\n"
+    @dashboard.register_participant :bravo do |wi, fexp|
+      tracer << "b\n"
     end
-    @engine.register_participant :charly do |wi, fexp|
-      @tracer << "c\n"
+    @dashboard.register_participant :charly do |wi, fexp|
+      tracer << "c\n"
       stash[:tree0] = fexp.context.engine.process(fexp.fei.wfid).current_tree
     end
-    @engine.register_participant :delta do |wi, fexp|
-      @tracer << "d\n"
+    @dashboard.register_participant :delta do |wi, fexp|
+      tracer << "d\n"
       stash[:tree1] = fexp.context.engine.process(fexp.fei.wfid).current_tree
     end
 
-    #noisy
-
     assert_trace %w[ a c c d ], pdef
 
     assert_equal(
       ["define", {"name"=>"test"}, [["sequence", {}, [["alpha", {}, []], ["charly", {}, []], ["participant", {"ref"=>"charly"}, []]]], ["delta", {}, []]]],
-      @engine.context.stash[:tree0])
+      @dashboard.context.stash[:tree0])
 
     assert_equal(
       ["define", {"name"=>"test"}, [["sequence", {}, [["alpha", {}, []], ["charly", {}, []], ["charly", {}, []]]], ["participant", {"ref"=>"delta"}, []]]],
-      @engine.context.stash[:tree1])
+      @dashboard.context.stash[:tree1])
   end
 
   def test_when_on_cancel_subprocess
@@ -381,15 +370,13 @@ class FtProcessStatusTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
-
-    #noisy
+    alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
     wait_for(:alpha)
 
-    @engine.cancel_process(wfid)
+    @dashboard.cancel_process(wfid)
 
     wait_for(:alpha)
     wait_for(1)
@@ -397,14 +384,14 @@ class FtProcessStatusTest < Test::Unit::TestCase
     assert_match wfid, alpha.first.fei.wfid
     assert_not_nil alpha.first.fei.subid
 
-    assert_equal 0, @engine.process(wfid).errors.size
-    assert_equal 4, @engine.process(wfid).expressions.size
+    assert_equal 0, @dashboard.process(wfid).errors.size
+    assert_equal 4, @dashboard.process(wfid).expressions.size
 
     assert_equal(
       ["define", {"name"=>"test"}, [
         ["define", {"sub0"=>nil}, [["alpha", {}, []]]],
         ["sequence", {"on_cancel"=>"sub0"}, [["alpha", {}, []]]]]],
-      @engine.process(wfid).original_tree)
+      @dashboard.process(wfid).original_tree)
 
     assert_equal(
       ["define", {"name"=>"test"}, [
@@ -412,7 +399,7 @@ class FtProcessStatusTest < Test::Unit::TestCase
           ["participant", {"ref"=>"alpha"}, []]]],
         ["sequence", {"on_cancel"=>"sub0", "_triggered"=>"on_cancel"}, [
           ["alpha", {}, []]]]]],
-      @engine.process(wfid).current_tree)
+      @dashboard.process(wfid).current_tree)
   end
 
   def test_fexp_to_h
@@ -421,15 +408,13 @@ class FtProcessStatusTest < Test::Unit::TestCase
       participant :ref => 'alpha'
     end
 
-    #noisy
+    alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
-    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
-
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
     wait_for(:alpha)
 
-    ps = @engine.process(wfid)
+    ps = @dashboard.process(wfid)
 
     h = ps.expressions.find { |hf|
       hf.is_a?(Ruote::Exp::ParticipantExpression)
@@ -449,13 +434,13 @@ class FtProcessStatusTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+    alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
     wait_for(:alpha)
 
-    ps = @engine.process(wfid)
+    ps = @dashboard.process(wfid)
 
     #puts
     #puts ps.to_dot
@@ -494,20 +479,20 @@ digraph "process wfid {
       bravo
     end
 
-    @engine.register_participant '.+', Ruote::StorageParticipant
+    @dashboard.register_participant '.+', Ruote::StorageParticipant
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
-    @engine.wait_for(:alpha)
+    @dashboard.wait_for(:alpha)
 
-    t0 = Time.parse(@engine.process(wfid).last_active)
+    t0 = Time.parse(@dashboard.process(wfid).last_active)
 
-    sp = @engine.storage_participant
-    sp.reply(sp.first)
+    sp = @dashboard.storage_participant
+    sp.proceed(sp.first)
 
-    @engine.wait_for(:bravo)
+    @dashboard.wait_for(:bravo)
 
-    t1 = Time.parse(@engine.process(wfid).last_active)
+    t1 = Time.parse(@dashboard.process(wfid).last_active)
 
     assert t1 > t0
   end
@@ -518,20 +503,20 @@ digraph "process wfid {
       alpha :task => 'clean car'
     end
 
-    @engine.register_participant '.+', Ruote::StorageParticipant
+    @dashboard.register_participant '.+', Ruote::StorageParticipant
 
-    wfid = @engine.launch(pdef)
-    @engine.wait_for(:alpha)
+    wfid = @dashboard.launch(pdef)
+    @dashboard.wait_for(:alpha)
 
     assert_equal(
       [ [ 'alpha', { 'task' => 'clean car' } ] ],
-      @engine.process(wfid).position.collect { |pos| pos[1..-1] })
+      @dashboard.process(wfid).position.collect { |pos| pos[1..-1] })
 
     # #position leverages #workitems
 
     assert_equal(
       [ [ wfid, 'alpha' ] ],
-      @engine.process(wfid).workitems.collect { |wi|
+      @dashboard.process(wfid).workitems.collect { |wi|
         [ wi.fei.wfid, wi.participant_name ]
       })
   end
@@ -542,25 +527,25 @@ digraph "process wfid {
       participant
     end
 
-    wfid = @engine.launch(pdef)
-    @engine.wait_for(wfid)
+    wfid = @dashboard.launch(pdef)
+    @dashboard.wait_for(wfid)
 
-    assert_equal 1, @engine.process(wfid).errors.size
+    assert_equal 1, @dashboard.process(wfid).errors.size
 
     assert_equal(
       [ [ nil,
           { 'error' => '#<ArgumentError: no participant name specified>' } ] ],
-      @engine.process(wfid).position.collect { |pos| pos[1..-1] })
+      @dashboard.process(wfid).position.collect { |pos| pos[1..-1] })
   end
 
   def test_ps_with_stored_workitems
 
-    @engine.register_participant '.+', Ruote::StorageParticipant
+    @dashboard.register_participant '.+', Ruote::StorageParticipant
 
-    wfid = @engine.launch(Ruote.define { alpha })
-    @engine.wait_for(:alpha)
+    wfid = @dashboard.launch(Ruote.define { alpha })
+    @dashboard.wait_for(:alpha)
 
-    ps = @engine.process(wfid)
+    ps = @dashboard.process(wfid)
 
     assert_equal 1, ps.stored_workitems.size
     assert_equal Ruote::Workitem, ps.stored_workitems.first.class
@@ -568,37 +553,35 @@ digraph "process wfid {
 
   def test_ps_without_stored_workitems
 
-    @engine.register_participant '.+', Ruote::NullParticipant
+    @dashboard.register_participant '.+', Ruote::NullParticipant
 
-    wfid = @engine.launch(Ruote.define { alpha })
-    @engine.wait_for(:alpha)
+    wfid = @dashboard.launch(Ruote.define { alpha })
+    @dashboard.wait_for(:alpha)
 
-    ps = @engine.process(wfid)
+    ps = @dashboard.process(wfid)
 
     assert_equal 0, ps.stored_workitems.size
   end
 
   def test_schedules
 
-    @engine.register_participant '.+', Ruote::NullParticipant
+    @dashboard.register_participant '.+', Ruote::NullParticipant
 
-    wfid = @engine.launch(Ruote.define { alpha :timeout => '2d' })
-    @engine.wait_for(:alpha)
+    wfid = @dashboard.launch(Ruote.define { alpha :timeout => '2d' })
+    @dashboard.wait_for(:alpha)
 
-    assert_equal 1, @engine.schedules.size
-    assert_equal 1, @engine.schedules(:count => true)
+    assert_equal 1, @dashboard.schedules.size
+    assert_equal 1, @dashboard.schedules(:count => true)
   end
 
   def test_processes_and_schedules
 
-    @engine.register_participant '.+', Ruote::NullParticipant
-
-    #noisy
+    @dashboard.register_participant '.+', Ruote::NullParticipant
 
-    wfid = @engine.launch(Ruote.define { alpha :timeout => '2d' })
-    @engine.wait_for(:alpha)
+    wfid = @dashboard.launch(Ruote.define { alpha :timeout => '2d' })
+    @dashboard.wait_for(:alpha)
 
-    ps = @engine.process(wfid)
+    ps = @dashboard.process(wfid)
 
     assert_equal 1, ps.schedules.size
     assert_match /^0_0![a-f0-9]+!#{wfid}$/, ps.schedules.first['target'].sid
@@ -608,50 +591,50 @@ digraph "process wfid {
 
     n = 7
 
-    @engine.register_participant '.+', Ruote::StorageParticipant
+    @dashboard.register_participant '.+', Ruote::StorageParticipant
 
     wfids = (1..n).collect { |i|
-      @engine.launch(Ruote.define { alpha })
+      @dashboard.launch(Ruote.define { alpha })
     }.sort
 
-    while @engine.storage_participant.size < n; sleep 0.140; end
+    while @dashboard.storage_participant.size < n; sleep 0.140; end
 
-    assert_equal wfids, @engine.process_wfids
+    assert_equal wfids, @dashboard.process_wfids
 
     assert_equal(
       wfids,
-      @engine.processes.collect { |ps| ps.wfid })
+      @dashboard.processes.collect { |ps| ps.wfid })
 
     assert_equal(
       wfids,
-      @engine.processes(:test => :garbage).collect { |ps| ps.wfid })
+      @dashboard.processes(:test => :garbage).collect { |ps| ps.wfid })
         # prompted by
         # http://groups.google.com/group/openwferu-users/browse_thread/thread/ee493bdf8d8cdb37
 
     assert_equal(
       wfids[0, 3],
-      @engine.processes(:limit => 3).collect { |ps| ps.wfid })
+      @dashboard.processes(:limit => 3).collect { |ps| ps.wfid })
 
     assert_equal(
       wfids[3, 3],
-      @engine.processes(:skip => 3, :limit => 3).collect { |ps| ps.wfid })
+      @dashboard.processes(:skip => 3, :limit => 3).collect { |ps| ps.wfid })
 
     #puts "==="
     #wfids.each { |wfid| puts wfid }
     #puts "---"
-    #@engine.processes(:limit => 3, :descending => false).collect { |ps| ps.wfid }.each { |wfid| puts wfid }
+    #@dashboard.processes(:limit => 3, :descending => false).collect { |ps| ps.wfid }.each { |wfid| puts wfid }
     #puts "---"
-    #@engine.processes(:limit => 3, :descending => true).collect { |ps| ps.wfid }.each { |wfid| puts wfid }
+    #@dashboard.processes(:limit => 3, :descending => true).collect { |ps| ps.wfid }.each { |wfid| puts wfid }
 
     assert_equal(
       wfids.reverse[0, 3],
-      @engine.processes(
+      @dashboard.processes(
         :limit => 3, :descending => true
       ).collect { |ps| ps.wfid })
 
     assert_equal(
       n,
-      @engine.processes(:count => true))
+      @dashboard.processes(:count => true))
   end
 
   # Issue identified by David Goodlad :
@@ -667,28 +650,26 @@ digraph "process wfid {
       end
     end
 
-    #noisy
+    wfid = @dashboard.launch(pdef)
 
-    wfid = @engine.launch(pdef)
+    @dashboard.wait_for(4)
 
-    @engine.wait_for(4)
-
-    #assert_equal 1, @engine.processes.size
-    assert_equal [ wfid ], @engine.processes.collect { |ps| ps.wfid }
+    #assert_equal 1, @dashboard.processes.size
+    assert_equal [ wfid ], @dashboard.processes.collect { |ps| ps.wfid }
   end
 
   def test_ps
 
-    @engine.register 'alpha', Ruote::NullParticipant
+    @dashboard.register 'alpha', Ruote::NullParticipant
 
     wfid = nil
 
-    2.times { wfid = @engine.launch(Ruote.define { alpha }) }
+    2.times { wfid = @dashboard.launch(Ruote.define { alpha }) }
 
-    @engine.wait_for(4)
+    @dashboard.wait_for(4)
 
-    assert_equal 2, @engine.ps.size
-    assert_equal wfid, @engine.ps(wfid).wfid
+    assert_equal 2, @dashboard.ps.size
+    assert_equal wfid, @dashboard.ps(wfid).wfid
   end
 
   def test_definition_name
@@ -697,21 +678,112 @@ digraph "process wfid {
       alpha
     end
 
-    #noisy
+    alpha = @dashboard.register_participant :alpha, Ruote::NullParticipant
+
+    wfid = @dashboard.launch(pdef)
+
+    wait_for(:alpha)
+
+    assert_equal 'invictus', @dashboard.process(wfid).definition_name
+
+    exp = @dashboard.process(wfid).expressions.first
+    @dashboard.storage.delete(exp.h)
+
+    assert_nil @dashboard.process(wfid).definition_name
+    assert_nil @dashboard.process(wfid).definition_revision
+  end
+
+  def test_leaves
+
+    pdef = Ruote.define do
+      concurrence do
+        alpha
+        wait '1w'
+      end
+    end
+
+    @dashboard.register_participant :alpha, Ruote::NullParticipant
+
+    wfid = @dashboard.launch(pdef)
+
+    wait_for(:alpha)
+    wait_for(1)
+
+    leaves = @dashboard.process(wfid).leaves
+
+    assert_equal(
+      [ "0_0_0:Ruote::Exp::ParticipantExpression:",
+        "0_0_1:Ruote::Exp::WaitExpression:" ],
+      leaves.collect { |fexp|
+        [ fexp.fei.expid,
+          fexp.class.to_s,
+          fexp.error ? fexp.error.message : '' ].join(':')
+      })
+  end
+
+  def test_leaves_when_errors
+
+    pdef = Ruote.define do
+      concurrence do
+        wait '1w'
+        participant
+        alpha
+      end
+    end
+
+    @dashboard.register_participant :alpha, Ruote::NullParticipant
 
-    alpha = @engine.register_participant :alpha, Ruote::NullParticipant
+    wfid = @dashboard.launch(pdef)
+
+    wait_for(:alpha)
+    wait_for(1)
+
+    leaves = @dashboard.process(wfid).leaves
+
+    assert_equal(
+      [ "0_0_0:Ruote::Exp::WaitExpression:",
+        "0_0_1:Ruote::Exp::ParticipantExpression:#<ArgumentError: no participant name specified>",
+        "0_0_2:Ruote::Exp::ParticipantExpression:" ],
+      leaves.collect { |fexp|
+        [ fexp.fei.expid,
+          fexp.class.to_s,
+          fexp.error ? fexp.error.message : '' ].join(':')
+      })
+  end
 
-    wfid = @engine.launch(pdef)
+  def test_root_workitem
+
+    pdef = Ruote.define do
+      alpha
+    end
+
+    @dashboard.register_participant :alpha, Ruote::NullParticipant
+
+    wfid = @dashboard.launch(pdef, 'small' => 'town')
 
     wait_for(:alpha)
 
-    assert_equal 'invictus', @engine.process(wfid).definition_name
+    wi = @dashboard.process(wfid).root_workitem
+
+    assert_equal 'town', wi.fields['small']
+  end
+
+  def test_to_h
+
+    @dashboard.register_participant :alpha, Ruote::StorageParticipant
+
+    pdef = Ruote.define do
+      concurrence do
+        alpha
+        wait '1d'
+        nada
+      end
+    end
 
-    exp = @engine.process(wfid).expressions.first
-    @engine.storage.delete(exp.h)
+    wfid = @dashboard.launch(pdef)
+    @dashboard.wait_for(7)
 
-    assert_nil @engine.process(wfid).definition_name
-    assert_nil @engine.process(wfid).definition_revision
+    assert_equal Hash, @dashboard.ps(wfid).to_h.class
   end
 end