ruote 2.3.0.1 → 2.3.0.2

data/test/functional/ft_12_launchitem.rb

@@ -5,6 +5,7 @@
 # Tue Jun 23 10:55:16 JST 2009
 #
 
+#require 'rufus-json/automatic'
 require File.expand_path('../base', __FILE__)
 
 
@@ -37,5 +38,19 @@ class FtLaunchitemTest < Test::Unit::TestCase
       {"a"=>0, "b"=>1, "params"=>{"ref"=>"alpha"}},
       @dashboard.context.stash[:fields])
   end
+
+  # Warning: this test requires rufus-json to have a backend ready.
+  #
+  def test_launch_and_variables_with_symbol_keys
+
+    pdef = Ruote.define do
+      echo '${f} / ${v:v}'
+    end
+
+    wfid = @dashboard.launch(pdef, { :f => 'x' }, { :v => 'y' })
+    wait_for(wfid)
+
+    assert_equal 'x / y', @tracer.to_s
+  end
 end
 

data/test/functional/ft_1_process_status.rb

@@ -82,7 +82,7 @@ class FtProcessStatusTest < Test::Unit::TestCase
     assert_equal 1, @dashboard.errors(:count => true)
   end
 
-  def test_tree
+  def test_current_tree
 
     pdef = Ruote.process_definition 'my process' do
       sequence do
@@ -91,10 +91,10 @@ class FtProcessStatusTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
+    alpha = @dashboard.register :alpha, Ruote::NullParticipant
     wfid = @dashboard.launch(pdef)
 
-    wait_for(:alpha)
+    wait_for('dispatched')
 
     ps = @dashboard.process(wfid)
 
@@ -119,19 +119,55 @@ class FtProcessStatusTest < Test::Unit::TestCase
 
     e.update_tree([ 'participant', { 'ref' => 'bravo' }, [] ])
 
+    assert_equal(
+      ["define", {"my process"=>nil}, [
+        ["sequence", {}, [
+          ["echo", {"ok"=>nil}, []],
+          ["participant", {"ref"=>"alpha"}, []]]]]],
+      ps.original_tree)
+
     assert_equal(
       ["define", {"my process"=>nil}, [
         ["sequence", {}, [
           ["echo", {"ok"=>nil}, []],
           ["participant", {"ref"=>"bravo"}, []]]]]],
       ps.current_tree)
+  end
+
+  def test_current_tree_and_re_apply
+
+    pdef = Ruote.process_definition 'my process' do
+      sequence do
+        echo 'ok'
+        participant :ref => :alpha
+      end
+    end
+
+    alpha = @dashboard.register :alpha, Ruote::NullParticipant
+    wfid = @dashboard.launch(pdef)
+
+    wait_for('dispatched')
+
+    ps = @dashboard.process(wfid)
+    exp = ps.expressions.find { |fexp| fexp.fei.expid == '0_0_1' }
+
+    @dashboard.re_apply(
+      exp,
+      :tree =>
+        [ 'sequence', {}, [ [ 'alpha', {}, [] ], [ 'alpha', {}, [] ] ] ])
+
+    wait_for('dispatched')
+
+    ps = @dashboard.process(wfid)
 
     assert_equal(
       ["define", {"my process"=>nil}, [
         ["sequence", {}, [
           ["echo", {"ok"=>nil}, []],
-          ["participant", {"ref"=>"alpha"}, []]]]]],
-      ps.original_tree)
+          ["sequence", {"_triggered"=>"on_re_apply"}, [
+            ["participant", {"ref"=>"alpha"}, []],
+            ["alpha", {}, []]]]]]]],
+      ps.current_tree)
   end
 
   def test_tree_when_define_rewrites_it
@@ -156,13 +192,15 @@ class FtProcessStatusTest < Test::Unit::TestCase
 
     assert_equal(
       ["define", {"my process"=>nil}, [
-        ["define", {"sub0"=>nil}, [["echo", {"meh"=>nil}, []]]],
+        ["define", {"sub0"=>nil}, [
+          ["echo", {"meh"=>nil}, []]]],
         ["participant", {"ref"=>"alpha"}, []]]],
       ps.current_tree)
 
     assert_equal(
       ["define", {"my process"=>nil}, [
-        ["define", {"sub0"=>nil}, [["echo", {"meh"=>nil}, []]]],
+        ["define", {"sub0"=>nil}, [
+          ["echo", {"meh"=>nil}, []]]],
         ["participant", {"ref"=>"alpha"}, []]]],
       ps.original_tree)
   end
@@ -351,11 +389,21 @@ class FtProcessStatusTest < Test::Unit::TestCase
     assert_trace %w[ a c c d ], pdef
 
     assert_equal(
-      ["define", {"name"=>"test"}, [["sequence", {}, [["alpha", {}, []], ["charly", {}, []], ["participant", {"ref"=>"charly"}, []]]], ["delta", {}, []]]],
+      ["define", {"name"=>"test"}, [
+        ["sequence", {}, [
+          ["alpha", {}, []],
+          ["charly", {}, []],
+          ["participant", {"ref"=>"charly"}, []]]],
+        ["delta", {}, []]]],
       @dashboard.context.stash[:tree0])
 
     assert_equal(
-      ["define", {"name"=>"test"}, [["sequence", {}, [["alpha", {}, []], ["charly", {}, []], ["charly", {}, []]]], ["participant", {"ref"=>"delta"}, []]]],
+      ["define", {"name"=>"test"}, [
+        ["sequence", {}, [
+          ["alpha", {}, []],
+          ["charly", {}, []],
+          ["charly", {}, []]]],
+        ["participant", {"ref"=>"delta"}, []]]],
       @dashboard.context.stash[:tree1])
   end
 
@@ -370,7 +418,7 @@ class FtProcessStatusTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
+    alpha = @dashboard.register :alpha, Ruote::StorageParticipant
 
     wfid = @dashboard.launch(pdef)
 
@@ -396,9 +444,10 @@ class FtProcessStatusTest < Test::Unit::TestCase
     assert_equal(
       ["define", {"name"=>"test"}, [
         ["define", {"sub0"=>nil}, [
-          ["participant", {"ref"=>"alpha"}, []]]],
-        ["sequence", {"on_cancel"=>"sub0", "_triggered"=>"on_cancel"}, [
-          ["alpha", {}, []]]]]],
+          ["alpha", {}, []]]],
+        ["subprocess", {"_triggered"=>"on_cancel", "ref"=>"sub0"}, [
+          ["define", {"sub0"=>nil}, [
+            ["participant", {"ref"=>"alpha"}, []]]]]]]],
       @dashboard.process(wfid).current_tree)
   end
 

data/test/functional/ft_20_storage_participant.rb

@@ -723,5 +723,30 @@ class FtStorageParticipantTest < Test::Unit::TestCase
 
     assert_equal 0, @dashboard.storage_participant.size
   end
+
+  class IuriParticipant < Ruote::StorageParticipant
+    def on_workitem
+      super
+      workitem.fields['count'] = 777
+      do_update
+    end
+  end
+
+  def test_do_update
+
+    @dashboard.register :alpha, IuriParticipant
+
+    wfid = @dashboard.launch(
+      Ruote.define do
+        alpha
+      end)
+
+    @dashboard.wait_for('dispatched')
+    sleep 0.350
+
+    wi = @dashboard.storage_participant.first
+
+    assert_equal(777, wi.fields['count'])
+  end
 end
 

data/test/functional/ft_38_participant_more.rb

@@ -4,7 +4,7 @@
 #
 # Mon Apr 19 14:38:54 JST 2010
 #
-# Qcon Tokyo, special day
+# Qcon Tokyo, special day (12/19 plus tard)
 #
 
 require File.expand_path('../base', __FILE__)

data/test/functional/ft_42_storage_copy.rb

@@ -17,8 +17,6 @@ class FtStorageCopyTest < Test::Unit::TestCase
 
     @dashboard.register_participant '.+', Ruote::StorageParticipant
 
-    #noisy
-
     wfid = @dashboard.launch(Ruote.process_definition do
       sequence do
         alpha :timeout => '2d'
@@ -43,7 +41,7 @@ class FtStorageCopyTest < Test::Unit::TestCase
 
     dash = Ruote::Dashboard.new(Ruote::Worker.new(Ruote::HashStorage.new()))
 
-    #dash.noisy = true
+    dash.noisy = ENV['NOISY'] == 'true'
 
     dash.register_participant '.+', Ruote::StorageParticipant
 

data/test/functional/ft_43_participant_on_reply.rb

@@ -128,11 +128,9 @@ class FtParticipantOnReplyTest < Test::Unit::TestCase
 
     @dashboard.register :alpha, MyOtherAwkwardParticipant
 
-    pdef = Ruote.process_definition do
-      sequence do
-        alpha
-        echo 'over.'
-      end
+    pdef = Ruote.define do
+      alpha
+      echo 'over.'
     end
 
     wfid = @dashboard.launch(pdef)
@@ -157,5 +155,65 @@ class FtParticipantOnReplyTest < Test::Unit::TestCase
 
     assert_equal 'over.', @tracer.to_s
   end
+
+  class MyFailingParticipant < Ruote::Participant
+    def on_workitem
+      raise 'flunk!'
+    end
+    def on_error
+      @context.tracer <<
+        "on_error: #{error.class}: #{error.message}: #{msg['action']}\n"
+      workitem.fields['hello'] = 'world'
+      true # returning true to signify we're dealing with the error
+    end
+  end
+
+  def test_participant_on_error
+
+    @dashboard.register :alpha, MyFailingParticipant
+
+    pdef = Ruote.define do
+      alpha
+      echo 'over.'
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+    assert_equal 'world', r['workitem']['fields']['hello']
+    assert_equal "on_error: RuntimeError: flunk!: dispatch\nover.", @tracer.to_s
+  end
+
+  class MyVeryFailingParticipant < Ruote::Participant
+    def on_workitem
+      raise 'flunkito!'
+    end
+    def on_error
+      @context.tracer << "on_error...\n"
+      workitem.fields['hello'] = 'world'
+      false # returning false to signify we're NOT dealing with the error
+    end
+  end
+
+  def test_participant_on_error_return_false
+
+    @dashboard.register :alpha, MyVeryFailingParticipant
+
+    pdef = Ruote.define do
+      alpha
+      echo 'over.'
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 'error_intercepted', r['action']
+    assert_equal 'world', r['msg']['workitem']['fields']['hello']
+    assert_equal 'on_error...', @tracer.to_s
+
+    # Error has not been dealt with within the participant implementation,
+    # it went straight to the common error handler
+  end
 end
 

data/test/functional/ft_66_flank.rb

@@ -129,5 +129,46 @@ class FtFlankTest < Test::Unit::TestCase
     assert_equal 0, @dashboard.storage.get_many('expressions').size
     assert_equal 0, @dashboard.storage.get_many('workitems').size
   end
+
+  # for https://groups.google.com/forum/?fromgroups=#!topic/openwferu-users/dZ--leQgEns
+  #
+  def test_ceasing_flank
+
+    @dashboard.register { catchall }
+
+    pdef =
+      Ruote.define do
+        sequence :tag => 'x' do
+          alice :flank => true
+          bob
+        end
+      end
+
+    wfid = @dashboard.launch(pdef)
+
+    2.times { @dashboard.wait_for('dispatched') }
+
+    alice =
+      @dashboard.storage_participant.find { |wi|
+        wi.participant_name == 'alice'
+      }
+
+    @dashboard.storage_participant.proceed(alice)
+    @dashboard.wait_for('receive')
+
+    ps = @dashboard.ps(wfid)
+
+    assert_equal %w[ 0 0_0 0_0_1 ], ps.expressions.collect { |e| e.fei.expid }
+    assert_equal 0, ps.errors.size
+
+    bob = @dashboard.storage_participant.first
+
+    @dashboard.storage_participant.proceed(bob)
+    @dashboard.wait_for('terminated')
+
+    sleep 0.350
+
+    assert_equal nil, @dashboard.ps(wfid)
+  end
 end
 

data/test/functional/ft_6_on_cancel.rb

@@ -27,8 +27,6 @@ class FtOnCancelTest < Test::Unit::TestCase
       tracer << "caught\n"
     end
 
-    #noisy
-
     wfid = @dashboard.launch(pdef)
     wait_for(:nemo)
 
@@ -48,8 +46,6 @@ class FtOnCancelTest < Test::Unit::TestCase
 
     nemo = @dashboard.register_participant :nemo, Ruote::StorageParticipant
 
-    #noisy
-
     wfid = @dashboard.launch(pdef)
     wait_for(:nemo)
 
@@ -80,8 +76,6 @@ class FtOnCancelTest < Test::Unit::TestCase
 
     alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
-    #noisy
-
     wfid = @dashboard.launch(pdef)
 
     wait_for(:alpha)
@@ -111,8 +105,6 @@ class FtOnCancelTest < Test::Unit::TestCase
     @dashboard.register_participant :alpha, Ruote::StorageParticipant
     sto = @dashboard.register_participant :bravo, Ruote::StorageParticipant
 
-    #noisy
-
     wfid = @dashboard.launch(pdef)
 
     wait_for(:alpha)
@@ -142,8 +134,6 @@ class FtOnCancelTest < Test::Unit::TestCase
     @dashboard.register_participant :alpha, Ruote::StorageParticipant
     @dashboard.register_participant :bravo, Ruote::StorageParticipant
 
-    #noisy
-
     wfid = @dashboard.launch(pdef)
 
     wait_for(:alpha)
@@ -154,13 +144,18 @@ class FtOnCancelTest < Test::Unit::TestCase
 
     assert_equal(
       ["define", {"name"=>"test"}, [
-        ["define", {"sub0"=>nil}, [["bravo", {}, []]]],
-        ["sequence", {"on_cancel"=>"sub0"}, [["alpha", {}, []]]]]],
+        ["define", {"sub0"=>nil}, [
+          ["bravo", {}, []]]],
+        ["sequence", {"on_cancel"=>"sub0"}, [
+          ["alpha", {}, []]]]]],
       @dashboard.process(wfid).original_tree)
     assert_equal(
       ["define", {"name"=>"test"}, [
-        ["define", {"sub0"=>nil}, [["participant", {"ref"=>"bravo"}, []]]],
-        ["sequence", {"on_cancel"=>"sub0", "_triggered"=>"on_cancel"}, [["alpha", {}, []]]]]],
+        ["define", {"sub0"=>nil}, [
+          ["bravo", {}, []]]],
+        ["subprocess", {"_triggered"=>"on_cancel", "ref"=>"sub0"}, [
+          ["define", {"sub0"=>nil}, [
+            ["participant", {"ref"=>"bravo"}, []]]]]]]],
       @dashboard.process(wfid).current_tree)
   end
 
@@ -178,8 +173,6 @@ class FtOnCancelTest < Test::Unit::TestCase
 
     @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
-    #@dashboard.noisy = true
-
     wfid = @dashboard.launch(pdef)
 
     wait_for(:alpha)
@@ -205,8 +198,6 @@ class FtOnCancelTest < Test::Unit::TestCase
 
     @dashboard.register :alpha, Ruote::StorageParticipant
 
-    #noisy
-
     wfid = @dashboard.launch(pdef)
 
     @dashboard.wait_for(:alpha)

data/test/functional/ft_71_retries.rb

@@ -11,13 +11,10 @@ require File.expand_path('../base', __FILE__)
 class FtRetriesTest < Test::Unit::TestCase
   include FunctionalBase
 
-  class BadParticipant
-    include Ruote::LocalParticipant
+  class BadParticipant < Ruote::Participant
     def on_workitem
       fail 'badly'
     end
-    def on_cancel
-    end
   end
 
   #
@@ -31,8 +28,6 @@ class FtRetriesTest < Test::Unit::TestCase
       alpha :on_error => '4s: retry'
     end
 
-    #@dashboard.noisy = true
-
     wfid = @dashboard.launch(pdef)
 
     @dashboard.wait_for('fail')
@@ -60,8 +55,6 @@ class FtRetriesTest < Test::Unit::TestCase
       alpha :on_error => '4x: retry'
     end
 
-    #@dashboard.noisy = true
-
     wfid = @dashboard.launch(pdef)
 
     @dashboard.wait_for('error_intercepted')
@@ -83,8 +76,6 @@ class FtRetriesTest < Test::Unit::TestCase
       echo 'over.'
     end
 
-    #@dashboard.noisy = true
-
     wfid = @dashboard.launch(pdef)
 
     @dashboard.wait_for('terminated')
@@ -112,8 +103,6 @@ class FtRetriesTest < Test::Unit::TestCase
       alpha :on_error => '1s: retry * 3'
     end
 
-    #@dashboard.noisy = true
-
     wfid = @dashboard.launch(pdef)
 
     @dashboard.wait_for('fail')
@@ -139,6 +128,30 @@ class FtRetriesTest < Test::Unit::TestCase
     assert_equal(
       '#<RuntimeError: badly>',
       @dashboard.ps(wfid).errors.first.message)
+
+    fails = @dashboard.logger.log.select { |m| m['action'] == 'fail' }
+    assert_equal 3, fails.size
+  end
+
+  #
+  # :on_error => 'retry * 2'
+  #
+  # retry twice, immediately
+
+  def test_retry_star_two
+
+    @dashboard.register_participant :alpha, BadParticipant
+
+    pdef = Ruote.process_definition do
+      alpha :on_error => 'retry * 2'
+    end
+
+    wfid = @dashboard.launch(pdef)
+
+    @dashboard.wait_for('error_intercepted')
+
+    fails = @dashboard.logger.log.select { |m| m['action'] == 'fail' }
+    assert_equal 2, fails.size
   end
 end