ruote-maestrodev 2.2.1

data/test/functional/ft_11_recursion.rb

@@ -0,0 +1,109 @@
+
+#
+# testing ruote
+#
+# Sat Jun 13 22:43:16 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/local_participant'
+
+
+class FtRecursionTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class CountingParticipant
+    include Ruote::LocalParticipant
+
+    def consume(workitem)
+
+      @context.stash[:wfids] ||= []
+      @context.stash[:wfids] << "#{workitem.fei.wfid}|#{workitem.fei.subid}"
+
+      workitem.fields['count'] ||= 0
+      workitem.fields['count'] = workitem.fields['count'] + 1
+
+      @context.tracer << workitem.fields['count'].to_s + "\n"
+
+      if workitem.fields['count'] > 5
+        @context.engine.cancel_process(workitem.fei.wfid)
+      else
+        reply_to_engine(workitem)
+      end
+    end
+
+    def cancel(fei, flavour)
+    end
+  end
+
+  def test_main_recursion
+
+    @engine.context.stash[:wfids] = []
+
+    pdef = Ruote.process_definition :name => 'def0' do
+      sequence do
+        alpha
+        def0
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, CountingParticipant
+
+    #noisy
+
+    assert_trace(%w[ 1 2 3 4 5 6 ], pdef)
+
+    assert_equal 6, @engine.context.stash[:wfids].uniq.size
+  end
+
+  def test_sub_recursion
+
+    @engine.context.stash[:wfids] = []
+
+    pdef = Ruote.process_definition do
+      define 'sub0' do
+        sequence do
+          alpha
+          sub0
+        end
+      end
+      sub0
+    end
+
+    alpha = @engine.register_participant :alpha, CountingParticipant
+
+    #noisy
+
+    assert_trace %w[ 1 2 3 4 5 6 ], pdef
+
+    #p alpha.wfids.uniq
+
+    assert_equal 6, @engine.context.stash[:wfids].uniq.size
+  end
+
+  def test_forgotten_main_recursion
+
+    pdef = Ruote.process_definition :name => 'def0' do
+      sequence do
+        alpha
+        forget do
+          def0
+        end
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, CountingParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    6.times { wait_for(:alpha) }
+
+    wait_for(1)
+
+    assert_equal((1..6).to_a.join("\n"), @tracer.to_s)
+  end
+end
+

data/test/functional/ft_12_launchitem.rb

@@ -0,0 +1,43 @@
+
+#
+# testing ruote
+#
+# Tue Jun 23 10:55:16 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtLaunchitemTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_launch
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    @engine.register_participant :alpha do |workitem|
+      stash[:fields] = workitem.fields
+      @tracer << 'a'
+      nil
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef, 'a' => 0, 'b' => 1)
+    wait_for(wfid)
+
+    assert_equal('a', @tracer.to_s)
+
+    @engine.context.stash[:fields].delete('__result__')
+
+    assert_not_nil(
+      @engine.context.stash[:fields].delete('dispatched_at'))
+
+    assert_equal(
+      {"a"=>0, "b"=>1, "params"=>{"ref"=>"alpha"}},
+      @engine.context.stash[:fields])
+  end
+end
+

data/test/functional/ft_13_variables.rb

@@ -0,0 +1,151 @@
+
+#
+# testing ruote
+#
+# Tue Jun 23 11:16:39 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtVariablesTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_wfid_and_expid
+
+    pdef = Ruote.process_definition do
+      echo 'at:${wfid}:${expid}'
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+
+    assert_equal "at:#{wfid}:0_0", @tracer.to_s
+  end
+
+  def test_variables_event
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set :var => 'v', :val => 'x'
+        unset :var => 'v'
+        echo 'done.'
+      end
+    end
+
+    #noisy
+
+    assert_trace('done.', pdef)
+
+    #logger.log.each { |e| p e }
+
+    assert_equal(
+      1, logger.log.select { |e| e['action'] == 'variable_set' }.size)
+    assert_equal(
+      1, logger.log.select { |e| e['action'] == 'variable_unset' }.size)
+  end
+
+  def test_process_root_variables
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set 'v:va' => 'a0'
+        set 'v:/vb' => 'b0'
+        echo '${v:va}:${v:vb}:${v:/va}:${v:/vb}'
+        sub0
+        echo '${v:va}:${v:vb}:${v:/va}:${v:/vb}'
+      end
+      define 'sub0' do
+        set 'v:va' => 'a1'
+        set 'v:/vb' => 'b1'
+        echo '${v:va}:${v:vb}:${v:/va}:${v:/vb}'
+      end
+    end
+
+    #noisy
+
+    assert_trace(%w[ a0:b0:a0:b0 a1:b1:a0:b1 a0:b1:a0:b1 ], pdef)
+  end
+
+  def test_engine_variables
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set 'v:va' => 'a0'
+        echo '${v:va}:${v://va}'
+        echo '${v:vb}:${v://vb}'
+        echo 'done.'
+      end
+    end
+
+    #noisy
+
+    @engine.variables['vb'] = 'b0'
+
+    assert_trace(%w[ a0: b0:b0 done. ], pdef)
+
+    assert_equal(
+      1, logger.log.select { |e| e['action'] == 'variable_set' }.size)
+  end
+
+  # A test about a protected method in FlowExpression, quite low level.
+  #
+  def test_lookup_var_site
+
+    pdef = Ruote.process_definition do
+      sequence do
+        sub0
+        echo 'done.'
+      end
+      define 'sub0' do
+        alpha
+      end
+    end
+
+    @engine.context.stash[:results] = []
+
+    @engine.register_participant :alpha do |workitem, fexp|
+
+      class << fexp
+        public :locate_var
+      end
+
+      stash[:results] << fexp.locate_var('//a')
+      stash[:results] << fexp.locate_var('/a').first.fei.to_storage_id
+      stash[:results] << fexp.locate_var('a').first.fei.to_storage_id
+    end
+
+    #noisy
+
+    assert_trace 'done.', pdef
+
+    assert_equal(nil, @engine.context.stash[:results][0])
+    assert_match(/^0||\d+_\d+$/, @engine.context.stash[:results][1])
+    assert_match(/^0\_0|\d+|\d+_\d+$/, @engine.context.stash[:results][2])
+  end
+
+  def test_lookup_in_var
+
+    @engine.register_participant :echo_toto do |wi, fexp|
+      @tracer << fexp.lookup_variable('toto').join
+      @tracer << "\n"
+    end
+
+    pdef = Ruote.process_definition do
+
+      set 'v:toto' => %w[ a b c ]
+      echo '${v:toto.1}'
+
+      set 'v:toto.2' => 'C'
+      echo_toto
+
+      unset 'v:toto.1'
+      echo_toto
+    end
+
+    assert_trace(%w[ b abC aC ], pdef)
+  end
+end
+

data/test/functional/ft_14_re_apply.rb

@@ -0,0 +1,324 @@
+
+#
+# testing ruote
+#
+# Thu Jun 25 13:31:26 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtReApplyTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  PDEF = Ruote.process_definition do
+    sequence do
+      alpha
+      echo 'done.'
+    end
+  end
+
+  def test_re_apply
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(PDEF)
+    wait_for(:alpha)
+
+    id0 = alpha.first.object_id
+
+    # ... flow stalled ...
+
+    ps = @engine.process(wfid)
+
+    stalled_exp = ps.expressions.find { |fexp| fexp.fei.expid == '0_0_0' }
+
+    @engine.re_apply(stalled_exp.fei)
+
+    wait_for(:alpha)
+
+    assert_equal 1, alpha.size
+    assert_not_equal id0, alpha.first.object_id
+
+    alpha.proceed(alpha.first)
+
+    wait_for(wfid)
+
+    assert_equal 'done.', @tracer.to_s
+  end
+
+  def test_cancel_and_re_apply
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(PDEF)
+    wait_for(:alpha)
+
+    id0 = alpha.first.object_id
+
+    # ... flow stalled ...
+
+    ps = @engine.process(wfid)
+
+    stalled_exp = ps.expressions.find { |fexp| fexp.fei.expid == '0_0_0' }
+
+    @engine.re_apply(stalled_exp.fei)
+
+    wait_for(:alpha)
+
+    assert_equal 1, alpha.size
+    assert_not_equal id0, alpha.first.object_id
+
+    alpha.proceed(alpha.first)
+
+    wait_for(wfid)
+
+    assert_equal 'done.', @tracer.to_s
+  end
+
+  def test_update_expression_and_re_apply
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(PDEF)
+    wait_for(:alpha)
+
+    sleep 0.350 # threaded dispatch
+
+    id0 = alpha.first.object_id
+
+    # ... flow stalled ...
+
+    ps = @engine.process(wfid)
+
+    stalled_exp = ps.expressions.find { |fexp| fexp.fei.expid == '0_0_0' }
+
+    stalled_exp.update_tree([
+      'participant', { 'ref' => 'alpha', 'activity' => 'mow lawn' }, [] ])
+    #p [ :stalled, stalled_exp.h['_rev'] ]
+    stalled_exp.persist
+
+    @engine.re_apply(stalled_exp.fei)
+
+    wait_for(:alpha)
+
+    assert_equal 'mow lawn', alpha.first.fields['params']['activity']
+
+    alpha.proceed(alpha.first)
+
+    wait_for(wfid)
+
+    assert_equal 'done.', @tracer.to_s
+  end
+
+  def test_re_apply_with_new_workitem_fields
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+        echo 'done for ${f:x}.'
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(:alpha)
+
+    id0 = alpha.first.object_id
+
+    # ... flow stalled ...
+
+    ps = @engine.process(wfid)
+
+    stalled_exp = ps.expressions.find { |fexp| fexp.fei.expid == '0_0_0' }
+
+    @engine.re_apply(stalled_exp.fei, :fields => { 'x' => 'nada' })
+
+    wait_for(:alpha)
+
+    assert_equal 1, alpha.size
+    assert_not_equal id0, alpha.first.object_id
+
+    alpha.proceed(alpha.first)
+
+    wait_for(wfid)
+
+    assert_equal 'done for nada.', @tracer.to_s
+  end
+
+  def test_re_apply_with_merged_workitem_fields
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+        echo 'done for ${f:x} and ${f:y}.'
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef, { 'y' => 'nemo' })
+    wait_for(:alpha)
+
+    id0 = alpha.first.object_id
+
+    # ... flow stalled ...
+
+    ps = @engine.process(wfid)
+
+    stalled_exp = ps.expressions.find { |fexp| fexp.fei.expid == '0_0_0' }
+
+    @engine.re_apply(stalled_exp.fei, :merge_in_fields => { 'x' => 'nada' })
+
+    wait_for(:alpha)
+
+    assert_equal 1, alpha.size
+    assert_not_equal id0, alpha.first.object_id
+
+    alpha.proceed(alpha.first)
+
+    wait_for(wfid)
+
+    assert_equal 'done for nada and nemo.', @tracer.to_s
+  end
+
+  def test_re_apply_with_new_tree
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(PDEF)
+    wait_for(:alpha)
+
+    id0 = alpha.first.object_id
+
+    # ... flow stalled ...
+
+    ps = @engine.process(wfid)
+
+    stalled_exp = ps.expressions.find { |fexp| fexp.fei.expid == '0_0_0' }
+
+    @engine.re_apply(
+      stalled_exp.fei, :tree => [ 'echo', { 're_applied' => nil }, [] ])
+
+    wait_for(wfid)
+
+    assert_equal "re_applied\ndone.", @tracer.to_s
+  end
+
+  def test_new_tree_and_process_status_current_tree
+
+    #@engine.noisy = true
+
+    @engine.register_participant '.+', Ruote::StorageParticipant
+
+    wfid = @engine.launch(Ruote.define { alpha })
+
+    @engine.wait_for(:alpha)
+
+    assert_equal(
+      [ 'define', {}, [ [ 'participant', { 'ref' => 'alpha' }, [] ] ] ],
+      @engine.process(wfid).current_tree)
+
+    fei = @engine.storage_participant.first.fei
+
+    @engine.re_apply(fei, :tree => [ 'bravo', {}, [] ])
+
+    @engine.wait_for(:bravo)
+
+    assert_equal(
+      'bravo',
+      @engine.storage_participant.first.participant_name)
+
+    assert_equal(
+      [ 'participant', { 'ref' => 'bravo', '_triggered' => 'on_re_apply' }, [] ],
+      @engine.process(wfid).expressions.last.tree)
+
+    assert_equal(
+      [ 'define', {}, [ [ 'participant', { 'ref' => 'bravo', '_triggered' => 'on_re_apply' }, [] ] ] ],
+      @engine.process(wfid).current_tree)
+  end
+
+  # Issue reported by Brett Anthoine
+  #
+  def test_re_apply_root
+
+    @engine.register_participant '.+', Ruote::StorageParticipant
+
+    wfid = @engine.launch(Ruote.define { alpha })
+
+    @engine.wait_for(:alpha)
+    at0 = @engine.storage_participant.first.dispatched_at
+
+    root = @engine.process(wfid).root_expression
+    @engine.re_apply(root.fei)
+
+    @engine.wait_for(:alpha)
+    at1 = @engine.storage_participant.first.dispatched_at
+
+    assert at1 > at0
+  end
+
+  def test_re_apply_define
+
+    @engine.register_participant '.+', Ruote::StorageParticipant
+
+    wfid = @engine.launch(Ruote.define do
+      sub0
+      define 'sub0' do
+        alpha
+      end
+    end)
+
+    @engine.wait_for(:alpha)
+    at0 = @engine.storage_participant.first.dispatched_at
+
+    exp = @engine.process(wfid).expressions[1]
+
+    @engine.re_apply(exp.fei)
+
+    @engine.wait_for(:alpha)
+    at1 = @engine.storage_participant.first.dispatched_at
+
+    assert at1 > at0
+  end
+
+  # Making sure re_apply nukes errors
+  #
+  def test_re_apply_error
+
+    #@engine.noisy = true
+
+    @engine.register_participant '.+', Ruote::StorageParticipant
+
+    wfid = @engine.launch(Ruote.define do
+      error "X"
+    end)
+
+    @engine.wait_for(wfid)
+
+    fei = @engine.ps(wfid).expressions.last.fei
+
+    @engine.re_apply(fei, :tree => [ 'alpha', {}, [] ])
+
+    @engine.wait_for(:alpha)
+
+    ps = @engine.ps(wfid)
+
+    assert_equal 0, ps.errors.size
+    assert_equal Ruote::Exp::ParticipantExpression, ps.expressions.last.class
+  end
+end
+