ruote-maestrodev 2.2.1

data/test/functional/ft_60_code_participant.rb

@@ -0,0 +1,45 @@
+
+#
+# testing ruote
+#
+# Tue Apr 26 03:30:29 JST 2011
+#
+# between Changi and Haneda (JA622A)
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtCodeParticipantTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_workitems_dispatching_message
+
+    pdef = Ruote.process_definition do
+      set 'v:alpha' => '''
+        def consume(wi)
+          context.tracer << "#{wi.participant_name}\n"
+        end
+        def cancel(fei, flavour)
+          context.tracer << "cancelled\n"
+        end
+      '''
+      alpha
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:alpha)
+    @engine.wait_for(1)
+
+    assert_equal 'alpha', @tracer.to_s
+
+    @engine.cancel(wfid)
+    @engine.wait_for(wfid)
+
+    assert_equal "alpha\ncancelled", @tracer.to_s
+  end
+end
+

data/test/functional/ft_61_trailing_fields.rb

@@ -0,0 +1,34 @@
+
+#
+# testing ruote
+#
+# Thu Jun  9 11:37:56 JST 2011
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtTrailingFields < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_t_fields
+
+    pdef = Ruote.define do
+      alpha
+      echo 'a', :if => '${t.verbose}'
+      bravo
+      echo 'b', :if => '${t.verbose}'
+    end
+
+    @engine.register(:alpha) { |wi| wi.t['verbose'] = true }
+    @engine.register(:bravo, Ruote::NoOpParticipant)
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(wfid)
+
+    assert_equal 'a', @tracer.to_s
+  end
+end
+

data/test/functional/ft_62_exp_name_and_dollar_substitution.rb

@@ -0,0 +1,35 @@
+
+#
+# testing ruote
+#
+# Sat Jun 25 21:00:57 JST 2011
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtExpNameAndDollarSubstitution < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_t_fields
+
+    pdef = <<-EOS
+define
+  set 'v:x': alpha
+  user_${v:x}
+  user_${v:nada}
+    EOS
+
+    @engine.register /^user_/ do |wi|
+      @tracer << wi.participant_name + "\n"
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(wfid)
+
+    assert_equal %w[ user_alpha user_ ], @tracer.to_a
+  end
+end
+

data/test/functional/ft_6_on_cancel.rb

@@ -0,0 +1,221 @@
+
+#
+# testing ruote
+#
+# Wed Jun  3 21:52:09 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class FtOnCancelTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_on_cancel
+
+    pdef = Ruote.process_definition do
+      sequence :on_cancel => 'catcher' do
+        nemo
+      end
+    end
+
+    nemo = @engine.register_participant :nemo, Ruote::StorageParticipant
+
+    @engine.register_participant :catcher do
+      @tracer << "caught\n"
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(:nemo)
+
+    @engine.cancel_process(wfid)
+    wait_for(wfid)
+
+    assert_equal 'caught', @tracer.to_s
+  end
+
+  def test_on_cancel_missing_handler
+
+    pdef = Ruote.process_definition do
+      sequence :on_cancel => 'nada' do
+        nemo
+      end
+    end
+
+    nemo = @engine.register_participant :nemo, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(:nemo)
+
+    @engine.cancel_process(wfid)
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+    assert_not_nil ps
+
+    #logger.log.each { |e| puts e['action'] }
+    assert_equal(
+      1, logger.log.select { |e| e['action'] == 'error_intercepted' }.size)
+  end
+
+  def test_on_cancel_trigger_subprocess
+
+    pdef = Ruote.process_definition do
+      sequence :on_cancel => 'decommission' do
+        alpha
+      end
+      define 'decommission' do
+        sequence do
+          echo 'd0'
+          echo 'd1'
+        end
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    assert_equal '', @tracer.to_s
+
+    @engine.cancel_process(wfid)
+
+    wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+
+    assert_equal "d0\nd1", @tracer.to_s
+  end
+
+  def test_on_cancel_expression
+
+    pdef = Ruote.process_definition do
+      sequence :on_cancel => 'decom' do
+        alpha
+      end
+      define 'decom' do
+        bravo
+      end
+    end
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+    sto = @engine.register_participant :bravo, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    fei = @engine.process(wfid).expressions.find { |e|
+      e.fei.expid == '0_1'
+    }.fei
+
+    @engine.cancel_expression(fei)
+
+    wait_for(:bravo)
+
+    assert_equal 1, sto.size
+  end
+
+  def test_on_cancel_subprocess
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence :on_cancel => 'sub0' do
+        alpha
+      end
+      define 'sub0' do
+        bravo
+      end
+    end
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+    @engine.register_participant :bravo, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    @engine.cancel_process(wfid)
+
+    wait_for(:bravo)
+
+    assert_equal(
+      ["define", {"name"=>"test"}, [
+        ["define", {"sub0"=>nil}, [["bravo", {}, []]]],
+        ["sequence", {"on_cancel"=>"sub0"}, [["alpha", {}, []]]]]],
+      @engine.process(wfid).original_tree)
+    assert_equal(
+      ["define", {"name"=>"test"}, [
+        ["define", {"sub0"=>nil}, [["participant", {"ref"=>"bravo"}, []]]],
+        ["sequence", {"on_cancel"=>"sub0", "_triggered"=>"on_cancel"}, [["alpha", {}, []]]]]],
+      @engine.process(wfid).current_tree)
+  end
+
+  def test_on_cancel_participant_resume
+
+    pdef = Ruote.define do
+      sequence do
+        alpha :on_cancel => 'bail_out'
+        echo 'done.'
+      end
+      define 'bail_out' do
+        echo 'bailed'
+      end
+    end
+
+    @engine.register :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:alpha)
+
+    @engine.cancel(@engine.storage_participant.first)
+
+    @engine.wait_for(wfid)
+
+    assert_equal "bailed\ndone.", @tracer.to_s
+  end
+
+  def test_on_cancel_wait_resume
+
+    pdef = Ruote.define do
+      sequence do
+        #alpha :on_cancel => 'bail_out'
+        wait '1d', :on_cancel => 'bail_out'
+        echo 'done.'
+      end
+      define 'bail_out' do
+        echo 'bailed'
+      end
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(6)
+
+    @engine.cancel(@engine.process(wfid).expressions.last)
+
+    @engine.wait_for(wfid)
+    sleep 0.350
+
+    assert_equal "bailed\ndone.", @tracer.to_s
+  end
+end
+

data/test/functional/ft_7_tags.rb

@@ -0,0 +1,177 @@
+
+#
+# testing ruote
+#
+# Wed Jun 10 11:03:26 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class FtTagsTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_tag
+
+    pdef = Ruote.process_definition do
+      sequence :tag => 'main' do
+        alpha :tag => 'part'
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(:alpha)
+
+    ps = @engine.process(wfid)
+
+    #p ps.variables
+    #ps.expressions.each { |e| p [ e.fei, e.variables ] }
+    assert_equal '0_0', ps.variables['main']['expid']
+    assert_equal '0_0_0', ps.variables['part']['expid']
+
+    #logger.log.each { |e| puts e['action'] }
+    assert_equal 2, logger.log.select { |e| e['action'] == 'entered_tag' }.size
+
+    alpha.proceed(alpha.first)
+    wait_for(wfid)
+
+    assert_equal 2, logger.log.select { |e| e['action'] == 'left_tag' }.size
+  end
+
+  # making sure a tag is removed in case of on_cancel
+  #
+  def test_on_cancel
+
+    pdef = Ruote.process_definition do
+      sequence do
+        sequence :tag => 'a', :on_cancel => 'decom' do
+          alpha
+        end
+        alpha
+      end
+      define 'decom' do
+        alpha
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    assert_equal 1, @engine.process(wfid).tags.size
+
+    fei = @engine.process(wfid).expressions.find { |e|
+      e.fei.expid == '0_1_0'
+    }.fei
+
+    @engine.cancel_expression(fei)
+
+    wait_for(:alpha)
+
+    assert_equal 0, @engine.process(wfid).tags.size
+
+    alpha.proceed(alpha.first)
+
+    wait_for(:alpha)
+
+    assert_equal 0, @engine.process(wfid).tags.size
+  end
+
+  def test_unset_tag_when_parent_gone
+
+    pdef = Ruote.process_definition do
+      concurrence :count => 1 do
+        alpha :tag => 'main'
+        sequence do
+          bravo
+          undo :ref => 'main'
+        end
+      end
+    end
+
+    #@engine.noisy = true
+
+    @engine.register :alpha, Ruote::NullParticipant
+    @engine.register :bravo, Ruote::NoOpParticipant
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(23)
+
+    assert_nil @engine.process(wfid)
+  end
+
+  def test_tags_and_workitems
+
+    pdef = Ruote.define do
+      sequence :tag => 'first-stage' do
+        alpha
+      end
+      sequence :tag => 'second-stage' do
+        bravo
+        charly :tag => 'third-stage'
+      end
+      david
+    end
+
+    @engine.register { catchall }
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(:alpha)
+    wi = @engine.storage_participant.first
+
+    assert_equal %w[ first-stage ], wi.tags
+
+    @engine.storage_participant.proceed(wi)
+    @engine.wait_for(:bravo)
+    wi = @engine.storage_participant.first
+
+    assert_equal %w[ second-stage ], wi.tags
+
+    @engine.storage_participant.proceed(wi)
+    @engine.wait_for(:charly)
+    wi = @engine.storage_participant.first
+
+    assert_equal %w[ second-stage third-stage ], wi.tags
+
+    @engine.storage_participant.proceed(wi)
+    @engine.wait_for(:david)
+    wi = @engine.storage_participant.first
+
+    assert_equal [], wi.tags
+  end
+
+  def test_tag_and_define
+
+    pdef = Ruote.define :tag => 'nada' do
+      alpha
+    end
+
+    @engine.register 'alpha', Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(:alpha)
+
+    assert_equal 1, logger.log.select { |e| e['action'] == 'entered_tag' }.size
+
+    wi = @engine.storage_participant.first
+    @engine.storage_participant.proceed(wi)
+
+    @engine.wait_for(wfid)
+
+    assert_equal 1, logger.log.select { |e| e['action'] == 'left_tag' }.size
+  end
+end
+