ruote 2.1.11 → 2.2.0

data/test/functional/ft_50_engine_config.rb

@@ -0,0 +1,22 @@
+
+#
+# testing ruote
+#
+# Mon Dec  6 10:40:29 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtEngineConfigTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_engine_config
+
+    @engine.configure('a', 'b')
+
+    assert_equal 'b', @engine.configuration('a')
+    assert_equal 'b', @engine.storage.get_configuration('engine')['a']
+  end
+end
+

data/test/functional/ft_51_misc.rb

@@ -0,0 +1,67 @@
+
+#
+# testing ruote
+#
+# Thu Dec  9 16:39:54 JST 2010
+#
+
+require 'stringio'
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtMiscTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_noisy
+
+    result = String.new
+    out = StringIO.new(result, 'w+')
+
+    prev = $stdout
+    $stdout = out
+
+    @engine.noisy = true
+
+    wfid = @engine.launch(Ruote.define do
+      echo 'nada'
+    end)
+
+    @engine.wait_for(wfid)
+
+    out.close
+    $stdout = prev
+
+    assert_not_nil result
+  end
+
+  class NoCancel
+    def consume(workitem)
+      # do nothing
+    end
+    # no cancel method implementation
+  end
+
+  def test_participant_missing_cancel_method
+
+    pdef = Ruote.define do
+      participant 'no_cancel'
+    end
+
+    @engine.register 'no_cancel', NoCancel
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:no_cancel)
+
+    @engine.cancel(wfid)
+
+    @engine.wait_for(wfid)
+
+    assert_match(
+      /undefined method `cancel' for/,
+      @engine.ps(wfid).errors.first.message)
+  end
+end
+

data/test/functional/ft_52_case.rb

@@ -0,0 +1,134 @@
+
+#
+# testing ruote
+#
+# Fri Dec 24 14:53:30 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+#
+# Tests about replacement for case x when 'y' and switch(x) constructs.
+#
+class FtCaseTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  # The alternatives are bound at the process level
+  #
+  def test_open_lambda
+
+    pdef = Ruote.define do
+
+      define 'a' do
+        set 'f:result' => 'a'
+      end
+      define 'b' do
+        set 'f:result' => 'b'
+      end
+
+      subprocess '${the_case}'
+    end
+
+    wfid = @engine.launch(pdef, 'the_case' => 'a')
+    r = @engine.wait_for(wfid)
+    assert_equal 'a', r['workitem']['fields']['result']
+
+    wfid = @engine.launch(pdef, 'the_case' => 'b')
+    r = @engine.wait_for(wfid)
+    assert_equal 'b', r['workitem']['fields']['result']
+  end
+
+  # The alternatives are bound inside of the case subprocess (definition)
+  #
+  def test_nested_lambda
+
+    pdef = Ruote.define do
+
+      define 'case' do
+        define 'a' do
+          set 'f:result' => 'a'
+        end
+        define 'b' do
+          set 'f:result' => 'b'
+        end
+        subprocess '${the_case}'
+      end
+
+      subprocess 'case'
+    end
+
+    wfid = @engine.launch(pdef, 'the_case' => 'a')
+    r = @engine.wait_for(wfid)
+    assert_equal 'a', r['workitem']['fields']['result']
+
+    wfid = @engine.launch(pdef, 'the_case' => 'b')
+    r = @engine.wait_for(wfid)
+    assert_equal 'b', r['workitem']['fields']['result']
+  end
+
+  # /!\
+  #
+  # Works as well, but the cases are bound in the global/process scope
+  #
+  def test_local_lambda
+
+    pdef = Ruote.define do
+
+      sequence do
+        define 'a' do
+          set 'f:result' => 'a'
+        end
+        define 'b' do
+          set 'f:result' => 'b'
+        end
+        subprocess '${the_case}'
+      end
+
+      subprocess 'a' # /!\
+    end
+
+    wfid = @engine.launch(pdef, 'the_case' => 'a')
+    r = @engine.wait_for(wfid)
+    assert_equal 'a', r['workitem']['fields']['result']
+
+    wfid = @engine.launch(pdef, 'the_case' => 'b')
+    r = @engine.wait_for(wfid)
+    assert_equal 'a', r['workitem']['fields']['result']
+  end
+
+  # Works as well, but the cases are bound in the global/process scope
+  #
+  def test_let_lambda
+
+    pdef = Ruote.define do
+
+      define 'a' do
+        echo 'global_a'
+      end
+
+      let do
+        define 'a' do
+          echo 'a'
+        end
+        define 'b' do
+          echo 'b'
+        end
+        subprocess '${the_case}'
+      end
+
+      subprocess 'a'
+    end
+
+    wfid = @engine.launch(pdef, 'the_case' => 'a')
+    @engine.wait_for(wfid)
+    assert_equal %w[ a global_a ], @tracer.to_a
+
+    @tracer.clear
+
+    wfid = @engine.launch(pdef, 'the_case' => 'b')
+    @engine.wait_for(wfid)
+    assert_equal %w[ b global_a ], @tracer.to_a
+  end
+end
+

data/test/functional/ft_53_engine_on_terminate.rb

@@ -0,0 +1,95 @@
+
+#
+# testing ruote
+#
+# Thu Jan  6 21:49:01 JST 2011
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+#require 'ruote/participant'
+
+
+class FtEngineOnTerminateTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_no_on_terminate
+
+    assert_nil @engine.on_terminate
+  end
+
+  def test_on_terminate
+
+    @engine.on_terminate = 'supervisor'
+
+    assert_equal(
+      [ 'define', {}, [ [ 'supervisor', {}, [] ] ] ],
+      @engine.on_terminate)
+  end
+
+  def test_on_terminate_tree
+
+    @engine.on_terminate = Ruote.define do
+      echo '${__terminate__.wfid} terminated'
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(Ruote.define do
+      echo 'main'
+    end)
+
+    @engine.wait_for(wfid)
+    sleep 1
+
+    assert_equal [ 'main', "#{wfid} terminated" ], @tracer.to_a
+  end
+
+  # on_terminate processes are not triggered for on_error processes.
+  #
+  def test_no_on_terminate_when_on_error
+
+    @engine.on_error = Ruote.define do
+      echo 'on_error'
+    end
+    @engine.on_terminate = Ruote.define do
+      echo 'on_terminate'
+    end
+
+    #noisy
+
+    wfid = @engine.launch(Ruote.define do
+      echo 'main'
+      error 'in main'
+    end)
+
+    @engine.wait_for(wfid)
+    sleep 1
+
+    assert_equal [ 'main', 'on_error' ], @tracer.to_a
+  end
+
+  # on_error processes are triggered for on_terminate processes as well.
+  #
+  def test_on_error_when_on_terminate
+
+    @engine.on_error = Ruote.define do
+      echo 'on_error'
+    end
+    @engine.on_terminate = Ruote.define do
+      error 'in on_terminate'
+    end
+
+    #noisy
+
+    wfid = @engine.launch(Ruote.define do
+      echo 'main'
+    end)
+
+    @engine.wait_for(wfid)
+    sleep 1
+
+    assert_equal [ 'main', 'on_error' ], @tracer.to_a
+  end
+end
+

data/test/functional/ft_54_patterns.rb

@@ -0,0 +1,104 @@
+
+#
+# testing ruote
+#
+# Fri Jan  7 15:13:28 JST 2011
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+#require 'ruote/participant'
+
+
+class FtPatternsTest < Test::Unit::TestCase
+  include FunctionalBase
+
+
+  # A task is only enabled when the process instance (of which it is part) is
+  # in a specific state (typically a parallel branch). The state is assumed to
+  # be a specific execution point (also known as a milestone) in the process
+  # model. When this execution point is reached the nominated task can be
+  # enabled. If the process instance has progressed beyond this state, then the
+  # task cannot be enabled now or at any future time (i.e. the deadline has
+  # expired). Note that the execution does not influence the state itself, i.e.
+  # unlike normal control-flow dependencies it is a test rather than a trigger.
+
+  #MILESTONE = Ruote.define do
+  #
+  #  concurrence :count => 1 do
+  #
+  #    sequence do
+  #      participant 'a'
+  #      participant 'b', :tag => 'milestone'
+  #      participant 'c'
+  #    end
+  #
+  #    listen :to => 'milestone', :upon => 'entering', :wfid => true do
+  #      concurrence :count => 1 do
+  #        listen :to => 'milestone', :upon => 'leaving', :wfid => true
+  #        participant 'd'
+  #      end
+  #    end
+  #  end
+  #end
+    # this works, but, if the participant d implementation is 'fast', the
+    # milestone could be left before the inner listen is reached.
+    # This listen could thus listen for an event that already occurred and
+    # thus be locked...
+    #
+    # the revised version makes sure the milestone is listened to (bot#
+    # entering and leaving) before participant b is reached.
+
+  MILESTONE = Ruote.define do
+
+    concurrence do
+
+      sequence do
+        participant 'a'
+        participant 'b', :tag => 'milestone'
+        participant 'c'
+      end
+
+      concurrence :count => 1 do
+        sequence do
+          listen :to => 'milestone', :upon => 'entering', :wfid => true
+          participant 'd'
+        end
+        listen :to => 'milestone', :upon => 'leaving', :wfid => true
+      end
+    end
+  end
+
+  def test_18_milestone
+
+    @engine.register do
+      catchall Ruote::StorageParticipant
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(MILESTONE)
+
+    @engine.wait_for(:a)
+
+    assert_equal({}, @engine.ps(wfid).tags)
+
+    @engine.storage_participant.reply(@engine.storage_participant.first)
+
+    @engine.wait_for(:d)
+
+    assert_equal %w[ milestone ], @engine.ps(wfid).tags.collect { |t| t.first }
+    assert_equal %w[ b d ], @engine.ps(wfid).position.collect { |pos| pos[1] }
+
+    wi = @engine.storage_participant.by_participant('b').first
+    @engine.storage_participant.reply(wi)
+
+    @engine.wait_for(:c)
+
+    sleep 0.7 # give some time for the task d to get removed
+
+    assert_equal({}, @engine.ps(wfid).tags)
+    assert_equal %w[ c ], @engine.ps(wfid).position.collect { |pos| pos[1] }
+  end
+end
+

data/test/functional/{ft_37_engine_participant.rb → ft_55_engine_participant.rb}

@@ -11,8 +11,7 @@ require File.join(File.dirname(__FILE__), 'base')
 
 require 'ruote'
 require 'ruote/storage/fs_storage'
-require 'ruote/part/hash_participant'
-require 'ruote/part/engine_participant'
+require 'ruote/participant'
 
 
 class FtEngineParticipantTest < Test::Unit::TestCase
@@ -155,14 +154,14 @@ class FtEngineParticipantTest < Test::Unit::TestCase
 
     #noisy
 
-    alpha = @engine1.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine1.register_participant :alpha, Ruote::StorageParticipant
 
     wfid = @engine0.launch(pdef)
 
     @engine1.wait_for(:alpha)
 
     assert_equal 1, alpha.size
-    assert_not_nil alpha.first.fei.sub_wfid
+    assert_not_nil alpha.first.fei.subid
 
     @engine0.cancel_process(wfid)
     @engine0.wait_for(wfid)
@@ -236,7 +235,7 @@ class FtEngineParticipantTest < Test::Unit::TestCase
       end
     end
 
-    bravo = @engine1.register_participant :bravo, Ruote::HashParticipant.new
+    bravo = @engine1.register_participant :bravo, Ruote::StorageParticipant
 
     #noisy