ruote-maestrodev 2.2.1

data/test/functional/ft_15_timeout.rb

@@ -0,0 +1,226 @@
+
+#
+# testing ruote
+#
+# Sun Jun 28 16:45:57 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtTimeoutTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_timeout
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha :timeout => '1.1'
+        bravo
+      end
+    end
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+    sto = @engine.register_participant :bravo, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(:bravo)
+
+    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_equal wfid, sto.first.fields['__timed_out__'][0]['wfid']
+    assert_equal '0_0_0', sto.first.fields['__timed_out__'][0]['expid']
+    assert_equal 'participant', sto.first.fields['__timed_out__'][2]
+
+    assert_equal(
+      { 'timeout' => '1.1', 'ref' => 'alpha' },
+      sto.first.fields['__timed_out__'][3])
+  end
+
+  def test_cancel_timeout
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha :timeout => '1.1'
+        bravo
+      end
+    end
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+    sto = @engine.register_participant :bravo, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(6)
+
+    assert_equal 1, sto.size
+    assert_equal 'alpha', sto.first.participant_name
+
+    @engine.cancel_expression(sto.first.fei)
+
+    wait_for(:bravo)
+
+    assert_equal 1, sto.size
+    assert_equal 'bravo', sto.first.participant_name
+    assert_equal 0, @engine.storage.get_many('schedules').size
+  end
+
+  def test_on_timeout_redo
+
+    # with ruote-couch the 'cancel-process' operation gets overriden by
+    # the timeout cancel...
+    #
+    # 0 20 ca * 20100320-bipopimita {}
+    # 1 20   ca * 20100320-bipopimita  0 {"flavour"=>nil}
+    # 2 20     ca * 20100320-bipopimita  0_0 {"flavour"=>"timeout"}
+    # 3 20     ca * 20100320-bipopimita  0_0 {"flavour"=>nil, :pi=>"0!!20100320-bipopimita"}
+    #
+    # hence the multiple cancel at the end of the test
+
+    pdef = Ruote.process_definition do
+      alpha :timeout => '1.1', :on_timeout => 'redo'
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(8)
+
+    #logger.log.each { |e| p e['flavour'] }
+    assert logger.log.select { |e| e['flavour'] == 'timeout' }.size >= 2
+
+    3.times do
+      Thread.pass
+      @engine.cancel_process(wfid)
+    end
+
+    wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+  end
+
+  def test_on_timeout_cancel_nested
+
+    pdef = Ruote.process_definition do
+      sequence :timeout => '1.1', :on_timeout => 'timedout' do
+        alpha
+      end
+      define 'timedout' do
+        echo 'timed out'
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+    assert_equal 'timed out', @tracer.to_s
+    assert_equal 0, @engine.context.storage.get_many('expressions').size
+    assert_equal 0, alpha.size
+  end
+
+  def test_on_timeout_error
+
+    pdef = Ruote.process_definition do
+      alpha :timeout => '1.1', :on_timeout => 'error'
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    assert_equal 1, ps.errors.size
+
+    err = ps.errors.first
+    err.tree = [ 'alpha', {}, [] ]
+
+    @engine.replay_at_error(err)
+    wait_for(:alpha)
+
+    assert_equal 1, alpha.size
+    assert_not_nil alpha.first.fields['__timed_out__']
+  end
+
+  def test_deep_on_timeout_error
+
+    pdef = Ruote.process_definition do
+      sequence :timeout => '1.1', :on_timeout => 'error' do
+        alpha
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    assert_equal 1, ps.errors.size
+    assert_equal 0, alpha.size
+    assert_equal 2, ps.expressions.size
+  end
+
+  def test_timeout_then_error
+
+    pdef = Ruote.process_definition do
+      sequence :timeout => '1.3' do
+        toto
+      end
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(4)
+
+    ps = @engine.process(wfid)
+
+    assert_equal 1, ps.errors.size
+    assert_equal 0, @engine.storage.get_many('schedules').size
+  end
+
+  def test_timeout_at
+
+    t = (Time.now + 2).to_s
+
+    pdef = Ruote.process_definition do
+      sequence :timeout => t do
+        alpha
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    #wait_for(9)
+    wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+    assert_equal 0, alpha.size
+    assert_equal 0, @engine.storage.get_many('schedules').size
+  end
+end
+

data/test/functional/ft_16_participant_params.rb

@@ -0,0 +1,98 @@
+
+#
+# testing ruote
+#
+# Wed Jul  1 09:51:30 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtParticipantParamsTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_params
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+        alpha :activity => 'buy groceries'
+        alpha
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+    assert_equal({ 'ref' => 'alpha' }, alpha.first.fields['params'])
+    alpha.proceed(alpha.first)
+
+    wait_for(:alpha)
+    assert_equal('buy groceries', alpha.first.fields['params']['activity'])
+    alpha.proceed(alpha.first)
+
+    wait_for(:alpha)
+    assert_equal({ 'ref' => 'alpha' }, alpha.first.fields['params'])
+    alpha.proceed(alpha.first)
+
+    wait_for(wfid)
+  end
+
+  def test_attribute_text_param
+
+    pdef = Ruote.process_definition do
+      alpha 'nemo', :action => 'nada'
+      bravo
+    end
+
+    @engine.register { catchall }
+
+    #@engine.noisy = true
+
+    @engine.launch(pdef)
+
+    @engine.wait_for(:alpha)
+    workitem = @engine.storage_participant.first
+
+    assert_equal(
+      { 'nemo' => nil, 'action' => 'nada', 'ref' => 'alpha' }, workitem.params)
+    assert_equal(
+      'nemo', workitem.param_text)
+
+    @engine.storage_participant.proceed(workitem)
+
+    @engine.wait_for(:bravo)
+    workitem = @engine.storage_participant.first
+
+    assert_equal(
+      nil, workitem.param_text)
+  end
+
+  def test_param_or_field
+
+    pdef = Ruote.process_definition do
+      alpha
+      alpha :theme => :wagner
+    end
+
+    @engine.register :alpha do |workitem|
+      context.tracer << "pof_theme:#{workitem.param_or_field(:theme)}\n"
+      context.tracer << "fop_theme:#{workitem.field_or_param(:theme)}\n"
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef, 'theme' => 'mozart')
+    @engine.wait_for(wfid)
+
+    assert_equal %w[
+       pof_theme:mozart fop_theme:mozart
+       pof_theme:wagner fop_theme:mozart
+    ], @tracer.to_a
+  end
+end
+

data/test/functional/ft_17_conditional.rb

@@ -0,0 +1,102 @@
+
+#
+# testing ruote
+#
+# Fri Jul  3 19:46:22 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtConditionalTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_string_equality
+
+    pdef = Ruote.process_definition :name => 'test' do
+
+      set :f => 'd', :val => '2'
+
+      sequence do
+
+        echo '${f:d}'
+
+        echo 'a', :if => '${f:d}'
+        echo 'b', :if => '${f:d} == 2'
+        echo 'c', :if => "${f:d} == '2'"
+        echo 'd', :if => '${f:d} is set'
+        echo 'e', :if => '${f:e} is set'
+      end
+    end
+
+    assert_trace(%w[ 2 a b d ], pdef)
+  end
+
+  def test_string_equality_when_space
+
+    pdef = Ruote.process_definition :name => 'test' do
+
+      set :f => 'd', :val => 'some dude'
+
+      sequence do
+
+        echo '${f:d}'
+
+        echo 'a', :if => '${f:d}'
+        echo 'b', :if => '${f:d} == some dude'
+        echo 'c', :if => "${f:d} == 'some dude'"
+        echo 'd', :if => "${f:d} == ${'f:d}"
+        echo 'e', :if => '${f:d} is set'
+      end
+    end
+
+    assert_trace("some dude\na\nc\nd\ne", pdef)
+  end
+
+  def test_unless
+
+    pdef = Ruote.process_definition :name => 'test' do
+
+      echo '${f:f}'
+      echo 'u', :unless => '${f:f} == 2000'
+      echo 'i', :if => '${f:f} == 2000'
+      echo '.'
+    end
+
+    assert_trace(%w[ 2000 i . ], { 'f' => 2000 }, pdef)
+
+    @tracer.clear
+
+    assert_trace(%w[ 2000 i . ], { 'f' => '2000' }, pdef)
+
+    @tracer.clear
+
+    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
+      set 'f:name' => 'n'
+      set 'f:city' => 'c'
+
+      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})'
+        echo 'f', :if => '${name} == n and ${city} == c'
+      end
+    end
+
+    assert_trace(%w[ true/false a b d f ], pdef)
+  end
+end
+

data/test/functional/ft_18_kill.rb

@@ -0,0 +1,138 @@
+
+#
+# testing ruote
+#
+# Sun Jul  5 22:56:06 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtKillTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_kill_process
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(:alpha)
+
+    @engine.kill_process(wfid)
+
+    wait_for(wfid)
+    ps = @engine.process(wfid)
+
+    assert_nil ps
+    assert_equal 0, alpha.size
+
+    assert_equal(
+      1, logger.log.select { |e| e['action'] == 'kill_process' }.size)
+  end
+
+  def test_kill_does_not_trigger_on_cancel
+
+    pdef = Ruote.process_definition do
+      sequence :on_cancel => 'catcher' do
+        alpha
+      end
+    end
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+    sto = @engine.register_participant :catcher, Ruote::StorageParticipant
+
+    wfid = @engine.launch(pdef)
+    wait_for(:alpha)
+
+    @engine.kill_process(wfid)
+
+    wait_for(wfid)
+
+    assert_equal 0, sto.size
+  end
+
+  def test_kill_expression_does_not_trigger_on_cancel
+
+    pdef = Ruote.process_definition do
+      sequence :on_cancel => 'catcher' do
+        alpha
+      end
+    end
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+    sto = @engine.register_participant :catcher, Ruote::StorageParticipant
+
+    wfid = @engine.launch(pdef)
+    wait_for(:alpha)
+
+    @engine.kill_expression(sto.first.fei)
+
+    wait_for(wfid)
+
+    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
+