ruote 2.1.11 → 2.2.0

data/test/functional/ft_15_timeout.rb

@@ -7,8 +7,6 @@
 
 require File.join(File.dirname(__FILE__), 'base')
 
-require 'ruote/part/hash_participant'
-
 
 class FtTimeoutTest < Test::Unit::TestCase
   include FunctionalBase
@@ -22,20 +20,21 @@ class FtTimeoutTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
-    bravo = @engine.register_participant :bravo, Ruote::HashParticipant.new
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+    sto = @engine.register_participant :bravo, Ruote::StorageParticipant
 
     #noisy
 
     wfid = @engine.launch(pdef)
     wait_for(:bravo)
 
-    assert_equal 0, alpha.size
-    assert_equal 1, bravo.size
+    assert_equal 1, sto.size
+    assert_equal 'bravo', sto.first.participant_name
+
     assert_equal 2, logger.log.select { |e| e['flavour'] == 'timeout' }.size
     assert_equal 0, @engine.storage.get_many('schedules').size
 
-    assert_not_nil bravo.first.fields['__timed_out__']
+    assert_not_nil sto.first.fields['__timed_out__']
   end
 
   def test_cancel_timeout
@@ -47,22 +46,23 @@ class FtTimeoutTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
-    bravo = @engine.register_participant :bravo, Ruote::HashParticipant.new
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+    sto = @engine.register_participant :bravo, Ruote::StorageParticipant
 
     #noisy
 
     wfid = @engine.launch(pdef)
     wait_for(6)
 
-    assert_equal 1, alpha.size
+    assert_equal 1, sto.size
+    assert_equal 'alpha', sto.first.participant_name
 
-    @engine.cancel_expression(alpha.first.fei)
+    @engine.cancel_expression(sto.first.fei)
 
     wait_for(:bravo)
 
-    assert_equal 0, alpha.size
-    assert_equal 1, bravo.size
+    assert_equal 1, sto.size
+    assert_equal 'bravo', sto.first.participant_name
     assert_equal 0, @engine.storage.get_many('schedules').size
   end
 
@@ -82,7 +82,7 @@ class FtTimeoutTest < Test::Unit::TestCase
       alpha :timeout => '1.1', :on_timeout => 'redo'
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     #noisy
 
@@ -113,7 +113,7 @@ class FtTimeoutTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     #noisy
 
@@ -132,7 +132,7 @@ class FtTimeoutTest < Test::Unit::TestCase
       alpha :timeout => '1.1', :on_timeout => 'error'
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     #noisy
 
@@ -161,7 +161,7 @@ class FtTimeoutTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     wfid = @engine.launch(pdef)
     wait_for(wfid)
@@ -203,7 +203,7 @@ class FtTimeoutTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     #noisy
 

data/test/functional/ft_16_participant_params.rb

@@ -7,8 +7,6 @@
 
 require File.join(File.dirname(__FILE__), 'base')
 
-require 'ruote/part/hash_participant'
-
 
 class FtParticipantParamsTest < Test::Unit::TestCase
   include FunctionalBase
@@ -23,7 +21,7 @@ class FtParticipantParamsTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     #noisy
 

data/test/functional/ft_17_conditional.rb

@@ -45,11 +45,12 @@ class FtConditionalTest < Test::Unit::TestCase
         echo 'a', :if => '${f:d}'
         echo 'b', :if => '${f:d} == some dude'
         echo 'c', :if => "${f:d} == 'some dude'"
-        echo 'd', :if => '${f:d} is set'
+        echo 'd', :if => "${f:d} == ${'f:d}"
+        echo 'e', :if => '${f:d} is set'
       end
     end
 
-    assert_trace("some dude\na\nb\nd", pdef)
+    assert_trace("some dude\na\nc\nd\ne", pdef)
   end
 
   def test_unless
@@ -72,5 +73,27 @@ class FtConditionalTest < Test::Unit::TestCase
 
     assert_trace(%w[ other u . ], { 'f' => 'other' }, pdef)
   end
+
+  def test_and_or
+
+    pdef = Ruote.process_definition do
+
+      set 'f:t' => true
+      set 'f:f' => false
+
+      sequence do
+
+        echo '${f:t}/${f:f}'
+
+        echo 'a', :if => '${f:t}'
+        echo 'b', :if => '${f:t} or ${f:f}'
+        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})'
+      end
+    end
+
+    assert_trace(%w[ true/false a b d ], pdef)
+  end
 end
 

data/test/functional/ft_18_kill.rb

@@ -7,8 +7,6 @@
 
 require File.join(File.dirname(__FILE__), 'base')
 
-require 'ruote/part/hash_participant'
-
 
 class FtKillTest < Test::Unit::TestCase
   include FunctionalBase
@@ -19,7 +17,7 @@ class FtKillTest < Test::Unit::TestCase
       alpha
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     #noisy
 
@@ -46,8 +44,8 @@ class FtKillTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
-    catcher = @engine.register_participant :catcher, Ruote::HashParticipant.new
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+    sto = @engine.register_participant :catcher, Ruote::StorageParticipant
 
     wfid = @engine.launch(pdef)
     wait_for(:alpha)
@@ -56,8 +54,7 @@ class FtKillTest < Test::Unit::TestCase
 
     wait_for(wfid)
 
-    assert_equal 0, alpha.size
-    assert_equal 0, catcher.size
+    assert_equal 0, sto.size
   end
 
   def test_kill_expression_does_not_trigger_on_cancel
@@ -68,18 +65,74 @@ class FtKillTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
-    catcher = @engine.register_participant :catcher, Ruote::HashParticipant.new
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+    sto = @engine.register_participant :catcher, Ruote::StorageParticipant
 
     wfid = @engine.launch(pdef)
     wait_for(:alpha)
 
-    @engine.kill_expression(alpha.first.fei)
+    @engine.kill_expression(sto.first.fei)
 
     wait_for(wfid)
 
-    assert_equal 0, alpha.size
-    assert_equal 0, catcher.size
+    assert_equal 0, sto.size
+  end
+
+  def test_kill__expression
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    @engine.register_participant :alpha, Ruote::NullParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:alpha)
+
+    @engine.kill(wfid)
+
+    @engine.wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+
+    assert_equal 1, logger.log.select { |e| e['action'] == 'kill_process' }.size
+  end
+
+  def test_kill__process
+
+    pdef = Ruote.process_definition do
+      alpha
+      echo '0'
+      alpha
+      echo '1'
+      alpha
+      echo '2'
+    end
+
+    @engine.register_participant :alpha, Ruote::NullParticipant
+
+    wfid = @engine.launch(pdef)
+
+    r = @engine.wait_for(:alpha)
+
+    @engine.kill(r['fei']) # fei as a Hash
+
+    r = @engine.wait_for(:alpha)
+
+    @engine.kill(Ruote.sid(r['fei'])) # fei as a String
+
+    r = @engine.wait_for(:alpha)
+
+    @engine.kill(Ruote::Workitem.new(r['workitem'])) # fei as workitem
+
+    @engine.wait_for(wfid)
+
+    assert_equal %w[ 0 1 2 ], @tracer.to_a
+
+    assert_equal 6, logger.log.select { |e| e['flavour'] == 'kill' }.size
   end
 end
 

data/test/functional/ft_1_process_status.rb

@@ -13,7 +13,7 @@ require 'ruote/participant'
 class FtProcessStatusTest < Test::Unit::TestCase
   include FunctionalBase
 
-  def test_ps
+  def test_process
 
     pdef = Ruote.process_definition :name => 'my process' do
       participant :ref => 'alpha'
@@ -21,7 +21,7 @@ class FtProcessStatusTest < Test::Unit::TestCase
 
     #noisy
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     wfid = @engine.launch(pdef, :workitem => { 'kilroy' => 'was here' })
 
@@ -47,7 +47,7 @@ class FtProcessStatusTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
     wfid = @engine.launch(pdef, :workitem => { 'kilroy' => 'was here' })
 
     wait_for(:alpha)
@@ -93,7 +93,7 @@ class FtProcessStatusTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
     wfid = @engine.launch(pdef)
 
     wait_for(:alpha)
@@ -145,7 +145,7 @@ class FtProcessStatusTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
     wfid = @engine.launch(pdef)
 
     wait_for(:alpha)
@@ -169,41 +169,6 @@ class FtProcessStatusTest < Test::Unit::TestCase
       ps.original_tree)
   end
 
-  def test_sub_processes
-
-    pdef = Ruote.process_definition do
-      define 'sub0' do
-        alpha
-      end
-      sequence do
-        sub0
-      end
-    end
-
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
-
-    #noisy
-
-    wfid = @engine.launch(pdef)
-
-    wait_for(:alpha)
-
-    assert_equal wfid, alpha.first.fei.wfid
-    assert_not_nil alpha.first.fei.sub_wfid
-
-    ps = @engine.process(wfid)
-
-    #ps.expressions.each { |e| puts e.fei.to_s }
-
-    assert_equal 5, ps.expressions.size
-
-    wfids = ps.expressions.collect { |e|
-      [ e.fei.wfid, e.fei.sub_wfid ].join('|')
-    }.sort.uniq
-
-    assert_equal 2, wfids.size
-  end
-
   def test_all_variables
 
     pdef = Ruote.process_definition do
@@ -219,7 +184,7 @@ class FtProcessStatusTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     #noisy
 
@@ -249,7 +214,7 @@ class FtProcessStatusTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     #noisy
 
@@ -258,7 +223,7 @@ class FtProcessStatusTest < Test::Unit::TestCase
 
     ps = @engine.process(wfid)
 
-    assert_equal 2, ps.tags.size
+    assert_equal %w[ main part ], ps.tags.keys.sort
 
     assert_equal 2, ps.all_tags.size
     assert_kind_of Array, ps.all_tags['main']
@@ -278,7 +243,7 @@ class FtProcessStatusTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     #noisy
 
@@ -299,7 +264,7 @@ class FtProcessStatusTest < Test::Unit::TestCase
 
     #noisy
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     wfid0 = @engine.launch(pdef)
     wfid1 = @engine.launch(pdef)
@@ -315,6 +280,50 @@ class FtProcessStatusTest < Test::Unit::TestCase
     assert_equal 2, alpha.size
   end
 
+  def test_processes_and_leftovers
+
+    n = 3
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    n.times.collect { @engine.launch(Ruote.define { alpha }) }
+
+    while @engine.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)
+    end
+      # nuking all the expressions of a process instance
+
+    assert_equal n - 1, @engine.processes.size
+    assert_equal n,  @engine.storage_participant.size
+      # orphan workitem left in storage
+
+    assert_equal 1, @engine.leftovers.size
+  end
+
+  def test_left_overs
+
+    [
+      { '_id' => '0!f!x', 'type' => 'workitems', 'fei' => { 'wfid' => 'x' } },
+      { '_id' => '0!f!y', 'type' => 'errors', 'fei' => { 'wfid' => 'y' } },
+      { '_id' => '0!f!a', 'type' => 'workitems', 'fei' => { 'wfid' => 'a' } },
+      { '_id' => '0!f!a', 'type' => 'expressions', 'fei' => { 'wfid' => 'a' } },
+      { '_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)
+    end
+
+    assert_equal(
+      3,
+      @engine.leftovers.size)
+    assert_equal(
+      %w[ workitems errors schedules ],
+      @engine.leftovers.collect { |lo| lo['type'] })
+  end
+
   def test_tree_rewrite
 
     pdef = Ruote.process_definition :name => 'test' do
@@ -326,9 +335,6 @@ class FtProcessStatusTest < Test::Unit::TestCase
       delta
     end
 
-    tree0 = nil
-    tree1 = nil
-
     @engine.register_participant :alpha do |wi, fexp|
 
       @tracer << "a\n"
@@ -344,11 +350,11 @@ class FtProcessStatusTest < Test::Unit::TestCase
     end
     @engine.register_participant :charly do |wi, fexp|
       @tracer << "c\n"
-      tree0 = fexp.context.engine.process(fexp.fei.wfid).current_tree
+      stash[:tree0] = fexp.context.engine.process(fexp.fei.wfid).current_tree
     end
     @engine.register_participant :delta do |wi, fexp|
       @tracer << "d\n"
-      tree1 = fexp.context.engine.process(fexp.fei.wfid).current_tree
+      stash[:tree1] = fexp.context.engine.process(fexp.fei.wfid).current_tree
     end
 
     #noisy
@@ -357,11 +363,11 @@ class FtProcessStatusTest < Test::Unit::TestCase
 
     assert_equal(
       ["define", {"name"=>"test"}, [["sequence", {}, [["alpha", {}, []], ["charly", {}, []], ["participant", {"ref"=>"charly"}, []]]], ["delta", {}, []]]],
-      tree0)
+      @engine.context.stash[:tree0])
 
     assert_equal(
       ["define", {"name"=>"test"}, [["sequence", {}, [["alpha", {}, []], ["charly", {}, []], ["charly", {}, []]]], ["participant", {"ref"=>"delta"}, []]]],
-      tree1)
+      @engine.context.stash[:tree1])
   end
 
   def test_when_on_cancel_subprocess
@@ -375,7 +381,7 @@ class FtProcessStatusTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     #noisy
 
@@ -386,9 +392,10 @@ class FtProcessStatusTest < Test::Unit::TestCase
     @engine.cancel_process(wfid)
 
     wait_for(:alpha)
+    wait_for(1)
 
     assert_match wfid, alpha.first.fei.wfid
-    assert_not_nil alpha.first.fei.sub_wfid
+    assert_not_nil alpha.first.fei.subid
 
     assert_equal 0, @engine.process(wfid).errors.size
     assert_equal 4, @engine.process(wfid).expressions.size
@@ -416,7 +423,7 @@ class FtProcessStatusTest < Test::Unit::TestCase
 
     #noisy
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     wfid = @engine.launch(pdef)
 
@@ -442,7 +449,7 @@ class FtProcessStatusTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     wfid = @engine.launch(pdef)
 
@@ -454,20 +461,24 @@ class FtProcessStatusTest < Test::Unit::TestCase
     #puts ps.to_dot
 
     dot = ps.to_dot
-    dot = dot.gsub(wfid, 'wfid').strip
+
+    dot = dot.gsub(wfid, 'wfid')
+    dot = dot.gsub(/![^!]+!/, '!!')
+    dot = dot.gsub(/wfid [^ ]+ /, 'wfid ')
+    dot = dot.strip
 
     assert_equal(
       %{
-digraph "process wfid wfid" {
-"0!!wfid" [ label="wfid  0 define" ];
+digraph "process wfid {
+"0!!wfid" [ label="wfid 0 define" ];
 "0!!wfid" -> "0_0!!wfid";
-"0_0!!wfid" [ label="wfid  0_0 concurrence" ];
+"0_0!!wfid" [ label="wfid 0_0 concurrence" ];
 "0_0!!wfid" -> "0!!wfid";
 "0_0!!wfid" -> "0_0_0!!wfid";
 "0_0!!wfid" -> "0_0_1!!wfid";
-"0_0_0!!wfid" [ label="wfid  0_0_0 participant" ];
+"0_0_0!!wfid" [ label="wfid 0_0_0 participant" ];
 "0_0_0!!wfid" -> "0_0!!wfid";
-"0_0_1!!wfid" [ label="wfid  0_0_1 participant" ];
+"0_0_1!!wfid" [ label="wfid 0_0_1 participant" ];
 "0_0_1!!wfid" -> "0_0!!wfid";
 "err_0_0_1!!wfid" [ label = "error : #<ArgumentError: no participant named 'bravo'>" ];
 "err_0_0_1!!wfid" -> "0_0_1!!wfid" [ style = "dotted" ];
@@ -513,14 +524,33 @@ digraph "process wfid wfid" {
     @engine.wait_for(:alpha)
 
     assert_equal(
-      [ [ "0_0!!#{wfid}", 'alpha', { 'task' => 'clean car' } ] ],
-      @engine.process(wfid).position)
+      [ [ 'alpha', { 'task' => 'clean car' } ] ],
+      @engine.process(wfid).position.collect { |pos| pos[1..-1] })
 
     # #position leverages #workitems
 
     assert_equal(
-      [ 'alpha' ],
-      @engine.process(wfid).workitems.collect { |wi| wi.participant_name })
+      [ [ wfid, 'alpha' ] ],
+      @engine.process(wfid).workitems.collect { |wi|
+        [ wi.fei.wfid, wi.participant_name ]
+      })
+  end
+
+  def test_position_when_error
+
+    pdef = Ruote.define do
+      participant
+    end
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(wfid)
+
+    assert_equal 1, @engine.process(wfid).errors.size
+
+    assert_equal(
+      [ [ nil,
+          { 'error' => '#<ArgumentError: no participant name specified>' } ] ],
+      @engine.process(wfid).position.collect { |pos| pos[1..-1] })
   end
 
   def test_ps_with_stored_workitems
@@ -559,7 +589,7 @@ digraph "process wfid wfid" {
     assert_equal 1, @engine.schedules(:count => true)
   end
 
-  def test_ps_and_schedules
+  def test_processes_and_schedules
 
     @engine.register_participant '.+', Ruote::NullParticipant
 
@@ -571,7 +601,7 @@ digraph "process wfid wfid" {
     ps = @engine.process(wfid)
 
     assert_equal 1, ps.schedules.size
-    assert_equal "0_0!!#{wfid}", ps.schedules.first['target'].sid
+    assert_match /^0_0![a-f0-9]+!#{wfid}$/, ps.schedules.first['target'].sid
   end
 
   def test_ps_pagination
@@ -592,6 +622,12 @@ digraph "process wfid wfid" {
       wfids,
       @engine.processes.collect { |ps| ps.wfid })
 
+    assert_equal(
+      wfids,
+      @engine.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 })
@@ -631,11 +667,51 @@ digraph "process wfid wfid" {
       end
     end
 
-    @engine.launch(pdef)
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(4)
+
+    #assert_equal 1, @engine.processes.size
+    assert_equal [ wfid ], @engine.processes.collect { |ps| ps.wfid }
+  end
+
+  def test_ps
+
+    @engine.register 'alpha', Ruote::NullParticipant
+
+    wfid = nil
+
+    2.times { wfid = @engine.launch(Ruote.define { alpha }) }
+
+    @engine.wait_for(4)
+
+    assert_equal 2, @engine.ps.size
+    assert_equal wfid, @engine.ps(wfid).wfid
+  end
+
+  def test_definition_name
+
+    pdef = Ruote.process_definition :name => 'invictus' do
+      alpha
+    end
+
+    #noisy
+
+    alpha = @engine.register_participant :alpha, Ruote::NullParticipant
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    assert_equal 'invictus', @engine.process(wfid).definition_name
 
-    sleep 0.400
+    exp = @engine.process(wfid).expressions.first
+    @engine.storage.delete(exp.h)
 
-    assert_equal 1, @engine.processes.size
+    assert_nil @engine.process(wfid).definition_name
+    assert_nil @engine.process(wfid).definition_revision
   end
 end