ruote-maestrodev 2.2.1

data/test/functional/ft_58_workitem.rb

@@ -0,0 +1,69 @@
+
+#
+# testing ruote
+#
+# Wed Apr  6 08:39:36 JST 2011
+#
+# Santa Barbara
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote'
+
+
+class FtWorkitemTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class TraceParticipant
+    include Ruote::LocalParticipant
+
+    def consume(wi)
+      @context.tracer << "#{wi.wf_name}/#{wi.wf_revision}\n"
+      reply_to_engine(wi)
+    end
+  end
+
+  def test_wf_info
+
+    @engine.register :alpha, TraceParticipant
+
+    #@engine.noisy = true
+
+    assert_trace(
+      'x/y',
+      Ruote.process_definition(:name => 'x', :revision => 'y') do
+        alpha
+      end,
+      :clear)
+
+    assert_trace(
+      'x/y',
+      Ruote.process_definition('x', :revision => 'y') do
+        alpha
+      end,
+      :clear)
+
+    assert_trace(
+      'x/y',
+      Ruote.process_definition('x', :rev => 'y') do
+        alpha
+      end,
+      :clear)
+
+    assert_trace(
+      'x/',
+      Ruote.process_definition('x') do
+        alpha
+      end,
+      :clear)
+
+    assert_trace(
+      '/',
+      Ruote.process_definition do
+        alpha
+      end,
+      :clear)
+  end
+end
+

data/test/functional/ft_59_pause.rb

@@ -0,0 +1,343 @@
+
+#
+# testing ruote
+#
+# Tue Apr 12 06:10:17 JST 2011
+#
+# Santa Barbara
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtPauseTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_pause_process
+
+    pdef = Ruote.process_definition do
+      alice
+    end
+
+    @engine.register do
+      catchall
+    end
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:alice)
+
+    #
+    # pause the process
+
+    @engine.pause(wfid)
+
+    sleep 0.500
+
+    ps = @engine.ps(wfid)
+
+    assert_equal %w[ paused ], ps.expressions.collect { |fexp| fexp.state }.uniq
+
+    @engine.storage_participant.proceed(@engine.storage_participant.first)
+
+    sleep 0.500
+
+    ps = @engine.ps(wfid)
+
+    exp = ps.expressions.last
+
+    assert_not_nil exp.h.paused_replies
+
+    #
+    # resume the process
+
+    @engine.resume(wfid)
+
+    @engine.wait_for(wfid)
+
+    assert_nil @engine.ps(wfid)
+  end
+
+  def test_pause_process_in_error
+
+    pdef = Ruote.process_definition do
+      nada
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(wfid)
+
+    @engine.pause(wfid)
+
+    sleep 0.500
+
+    ps = @engine.ps(wfid)
+
+    assert_equal(
+      %w[ paused failed ],
+      ps.expressions.collect { |fexp| fexp.state })
+
+    #
+    # cancel at error
+
+    @engine.cancel(ps.expressions.last.fei)
+
+    #
+    # resume the process
+
+    @engine.resume(wfid)
+
+    @engine.wait_for(wfid)
+
+    assert_nil @engine.ps(wfid)
+  end
+
+  def test_cancel_paused_branch
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alice
+      end
+      bob
+    end
+
+    @engine.register do
+      catchall
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:alice)
+
+    exp = @engine.ps(wfid).expressions.find { |e| e.name == 'sequence' }
+
+    @engine.pause(exp.fei)
+
+    sleep 0.500
+
+    assert_equal(
+      %w[ 0/ 0_0/paused 0_0_0/paused ],
+      @engine.ps(wfid).expressions.collect { |fe|
+        "#{fe.fei.expid}/#{fe.state}"
+      })
+
+    @engine.cancel(exp.fei)
+
+    @engine.wait_for(:bob)
+
+    assert_equal(
+      %w[ 0/ 0_1/ ],
+      @engine.ps(wfid).expressions.collect { |fe|
+        "#{fe.fei.expid}/#{fe.state}"
+      })
+  end
+
+  class AlphaParticipant
+    include Ruote::LocalParticipant
+    def consume(workitem)
+      @context.tracer << "dispatched:#{workitem.fei.wfid}\n"
+    end
+    def on_pause(fei)
+      @context.tracer << "pause:#{fei.wfid}\n"
+    end
+    def on_resume(fei)
+      @context.tracer << "resume:#{fei.wfid}\n"
+    end
+  end
+
+  def test_propagation_to_participant
+
+    pdef = Ruote.define do
+      alpha
+    end
+
+    @engine.register do
+      alpha AlphaParticipant
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:alpha)
+
+    @engine.pause(wfid)
+
+    sleep 0.7 # give time to the pause propagation to reach the participant
+
+    assert_equal(
+      [ "dispatched:#{wfid}", "pause:#{wfid}" ],
+      @tracer.to_a)
+
+    @engine.resume(wfid)
+
+    sleep 0.7 # give time to the resume propagation to reach the participant
+
+    assert_equal(
+      [ "dispatched:#{wfid}", "pause:#{wfid}", "resume:#{wfid}" ],
+      @tracer.to_a)
+  end
+
+  def test_propagation_to_participant_when_participant_has_already_replied
+
+    pdef = Ruote.define do
+      alpha
+    end
+
+    @engine.register do
+      alpha AlphaParticipant
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:alpha)
+
+    @engine.pause(wfid)
+
+    sleep 0.7 # give time to the pause propagation to reach the participant
+
+    wi = @engine.ps(wfid).expressions.last.h.applied_workitem
+
+    part = @engine.participant(:alpha.to_s)
+
+    part.instance_eval { reply_to_engine(Ruote::Workitem.new(wi)) }
+
+    @engine.wait_for(1)
+
+    assert_equal(
+      [ "dispatched:#{wfid}", "pause:#{wfid}" ],
+      @tracer.to_a)
+
+    @engine.resume(wfid)
+
+    sleep 0.7 # give time to the resume propagation to reach the participant
+
+    assert_equal(
+      [ "dispatched:#{wfid}", "pause:#{wfid}" ],
+      @tracer.to_a)
+        #
+        # no 'resume:xxx'
+  end
+
+  def test_breakpoint
+
+    pdef = Ruote.define do
+      sequence do
+        alpha
+      end
+    end
+
+    @engine.register do
+      catchall
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:alpha)
+
+    sequence = @engine.ps(wfid).expressions[1]
+
+    @engine.pause(sequence.fei, :breakpoint => true)
+
+    @engine.storage_participant.proceed(@engine.storage_participant.first)
+
+    sleep 0.7
+
+    assert_equal(
+      [ nil, 'paused' ],
+      @engine.ps(wfid).expressions.collect { |fexp| fexp.state })
+  end
+
+  def test_no_propagation_to_participant_when_breakpoint
+
+    pdef = Ruote.define do
+      alpha
+    end
+
+    @engine.register do
+      alpha AlphaParticipant
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:alpha)
+
+    alpha = @engine.ps(wfid).expressions.last
+
+    @engine.pause(alpha.fei, :breakpoint => true)
+
+    sleep 0.7 # give time to the pause propagation to reach the participant
+
+    assert_equal([ "dispatched:#{wfid}" ], @tracer.to_a)
+
+    @engine.resume(alpha.fei)
+
+    sleep 0.7 # give time to the resume propagation to reach the participant
+
+    assert_equal([ "dispatched:#{wfid}" ], @tracer.to_a)
+  end
+
+  def test_resume_anyway
+
+    pdef = Ruote.define do
+      concurrence do
+        alpha
+        sequence do
+          bravo
+        end
+      end
+    end
+
+    @engine.register do
+      catchall
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:alpha)
+    @engine.wait_for(:bravo)
+
+    exps = @engine.ps(wfid).expressions.select { |fexp|
+      fexp.fei.expid.match(/^0_0_[01]$/)
+    }
+
+    exps.each { |fexp| @engine.pause(fexp.fei) }
+
+    sleep 0.7
+
+    assert_equal(
+      [ nil, nil, 'paused', 'paused', 'paused' ],
+      @engine.ps(wfid).expressions.collect { |fexp| fexp.state })
+
+    @engine.resume(wfid)
+      # won't resume the process, since the root is not paused
+
+    sleep 0.4
+
+    assert_equal(
+      [ nil, nil, 'paused', 'paused', 'paused' ],
+      @engine.ps(wfid).expressions.collect { |fexp| fexp.state })
+
+    @engine.resume(wfid, :anyway => true)
+
+    sleep 0.7
+
+    assert_equal(
+      [ nil, nil, nil, nil, nil ],
+      @engine.ps(wfid).expressions.collect { |fexp| fexp.state })
+  end
+end
+

data/test/functional/ft_5_on_error.rb

@@ -0,0 +1,384 @@
+
+#
+# testing ruote
+#
+# Tue Jun  2 18:48:02 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class FtOnErrorTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_on_error
+
+    pdef = Ruote.process_definition do
+      sequence :on_error => 'catcher' do
+        nada
+      end
+    end
+
+    @engine.register_participant :catcher do
+      @tracer << "caught\n"
+    end
+
+    #noisy
+
+    assert_trace('caught', pdef)
+
+    assert_equal 1, logger.log.select { |e| e['action'] == 'fail' }.size
+  end
+
+  def test_on_error_unknown_participant_name
+
+    pdef = Ruote.process_definition :name => 'test' do
+      participant :mark_started
+      sequence :on_error => :mark_failed do
+        participant :bogus
+      end
+      participant :mark_finished
+    end
+
+    @engine.context.stash[:marks] = []
+
+    @engine.register_participant 'mark\_.+' do |workitem|
+      stash[:marks] << workitem.participant_name
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(wfid)
+
+    assert_equal(
+      %w[ mark_started mark_failed mark_finished ],
+      @engine.context.stash[:marks])
+  end
+
+  def test_on_error_unknown_participant_name_2
+
+    pdef = Ruote.process_definition :name => 'test' do
+      participant :mark_started
+      participant :bogus, :on_error => :mark_failed
+      participant :mark_finished
+    end
+
+    @engine.context.stash[:marks] = []
+
+    @engine.register_participant 'mark\_.+' do |workitem|
+      stash[:marks] << workitem.participant_name
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(wfid)
+
+    assert_equal(
+      %w[ mark_started mark_failed mark_finished ],
+      @engine.context.stash[:marks])
+  end
+
+  def test_on_error_neutralization
+
+    pdef = Ruote.process_definition do
+      sequence :on_error => 'catcher' do
+        sequence :on_error => '' do
+          nada
+        end
+      end
+    end
+
+    @engine.register_participant :catcher do
+      @tracer << "caught\n"
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+    ps = @engine.process(wfid)
+
+    assert_equal(1, ps.errors.size)
+  end
+
+  class TroubleMaker
+    include Ruote::LocalParticipant
+    def consume(workitem)
+      hits = (workitem.fields['hits'] || 0) + 1
+      workitem.fields['hits'] = hits
+      workitem.trace << "#{hits.to_s}\n"
+      raise 'Houston, we have a problem !' if hits == 1
+      workitem.trace << 'done.'
+      reply(workitem)
+    end
+    def cancel(fei, flavour)
+      # nothing to do
+    end
+  end
+
+  def test_on_error_redo
+
+    pdef = Ruote.process_definition do
+      sequence :on_error => :redo do
+        troublemaker
+      end
+    end
+
+    #noisy
+
+    @engine.register_participant :troublemaker, TroubleMaker
+
+    assert_trace(%w[ 1 2 done. ], pdef)
+  end
+
+  def test_on_error_retry
+
+    pdef = Ruote.process_definition do
+      sequence :on_error => :retry do
+        troublemaker
+      end
+    end
+
+    @engine.register_participant :troublemaker, TroubleMaker
+
+    assert_trace(%w[ 1 2 done. ], pdef)
+  end
+
+  def test_on_error_undo
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'a'
+        sequence :on_error => :undo do
+          echo 'b'
+          nemo
+          echo 'c'
+        end
+        echo 'd'
+      end
+    end
+
+    #noisy
+
+    wfid = assert_trace(%w[ a b d ], pdef)
+
+    assert_nil @engine.process(wfid)
+  end
+
+  def test_on_error_undo_single_expression
+
+    @engine.register_participant :nemo do |wi|
+      wi.fields['fail_count'] = 1
+      raise 'nemo'
+    end
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'in'
+        nemo :on_error => 'undo'
+        echo '${f:error}|${f:fail_count}'
+      end
+    end
+
+    wfid = assert_trace(%w[ in |1 ], pdef)
+
+    assert_nil @engine.process(wfid)
+  end
+
+  def test_on_error_pass
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'a'
+        sequence :on_error => :pass do
+          echo 'b'
+          nemo
+          echo 'c'
+        end
+        echo 'd'
+      end
+    end
+
+    #noisy
+
+    wfid = assert_trace(%w[ a b d ], pdef)
+
+    assert_nil @engine.process(wfid)
+  end
+
+  def test_missing_handler_triggers_regular_error
+
+    pdef = Ruote.process_definition :on_error => 'failpath' do
+      nemo
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+    ps = @engine.process(wfid)
+
+    assert_equal 1, ps.errors.size
+
+    assert_equal 1, logger.log.select { |e| e['action'] == 'error_intercepted' }.size
+  end
+
+  def test_on_error_at_process_level
+
+    pdef = Ruote.process_definition :on_error => 'failpath' do
+      nemo
+      define :failpath do
+        echo 'failed.'
+      end
+    end
+
+    #noisy
+
+    assert_trace('failed.', pdef)
+  end
+
+  def test_with_concurrence
+
+    pdef = Ruote.process_definition do
+      sequence do
+        concurrence :on_error => 'emil' do
+          alpha
+          error 'nada0'
+          error 'nada1'
+        end
+        echo 'done.'
+      end
+    end
+
+    @engine.context.stash[:a_count] = 0
+    @engine.context.stash[:e_count] = 0
+
+    @engine.register_participant(:alpha) { |wi| stash[:a_count] += 1 }
+    @engine.register_participant(:emil) { |wi| stash[:e_count] += 1 }
+
+    #noisy
+
+    assert_trace 'done.', pdef
+    assert_equal 1, @engine.context.stash[:a_count]
+    assert_equal 1, @engine.context.stash[:e_count]
+  end
+
+  def test_participant_on_error
+
+    pdef = Ruote.process_definition do
+      troublemaker :on_error => 'handle_error'
+      define 'handle_error' do
+        troublespotter
+      end
+    end
+
+    @engine.register_participant :troublemaker do |wi|
+      wi.fields['seen'] = true
+      raise 'Beijing, we have a problem !'
+    end
+    @engine.register_participant :troublespotter do |wi|
+      stash[:workitem] = wi
+      @tracer << 'err...'
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+
+    #er = @engine.process(wfid).errors.first
+    #puts er.message
+    #puts er.trace
+
+    wi = @engine.context.stash[:workitem]
+
+    assert_equal 'err...', @tracer.to_s
+    assert_equal 5, wi.error.size
+    assert_equal 'RuntimeError', wi.error['class']
+    assert_equal 'Beijing, we have a problem !', wi.error['message']
+    assert_equal Array, wi.error['trace'].class
+    assert_equal true, wi.fields['seen']
+  end
+
+  class Murphy
+    include Ruote::LocalParticipant
+
+    def cancel(fei, flavour)
+      # nothing to do
+    end
+    def consume(workitem)
+      raise "something got wrong"
+    end
+  end
+
+  def test_subprocess_on_error
+
+    pdef = Ruote.process_definition do
+      sequence :on_error => 'error_path' do
+        murphy
+      end
+      define 'error_path' do
+        catcher
+      end
+    end
+
+    @engine.register do
+      murphy FtOnErrorTest::Murphy
+      catchall
+    end
+
+    #@engine.noisy = true
+
+    @engine.launch(pdef)
+
+    @engine.wait_for(:catcher)
+  end
+
+  class RescuerOne
+    include Ruote::LocalParticipant
+    def consume(workitem)
+      @context.tracer << 'one'
+      reply_to_engine(workitem)
+    end
+    def accept?(workitem)
+      false
+    end
+  end
+  class RescuerTwo
+    include Ruote::LocalParticipant
+    def consume(workitem)
+      @context.tracer << 'two'
+      reply_to_engine(workitem)
+    end
+    #def accept?(workitem)
+    #  true
+    #end
+  end
+
+  def test_participants_and_accept
+
+    pdef = Ruote.process_definition do
+      sequence :on_error => 'rescuer' do
+        nada
+      end
+    end
+
+    @engine.register do
+      rescuer RescuerOne
+      rescuer RescuerTwo
+    end
+
+    #@engine.noisy = true
+
+    assert_trace('two', pdef)
+
+    assert_equal 1, logger.log.select { |e| e['action'] == 'fail' }.size
+  end
+end
+