ruote-maestrodev 2.2.1

data/test/functional/ft_47_wfid_generator.rb

@@ -0,0 +1,54 @@
+
+#
+# testing ruote
+#
+# Sat Oct 23 14:22:15 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtWfidGeneratorTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  # an old test, brought back
+  #
+  def test_generate_unique_ids
+
+    n = 147
+
+    wfids = []
+    n.times { wfids << @engine.context.wfidgen.generate }
+
+    assert_equal n, wfids.uniq.size
+  end
+
+  # making a purge! doesn't incapacitate wfid generation
+  # (had a false alert when working with @hassox)
+  #
+  def test_generate_even_after_a_purge
+
+    assert_not_nil @engine.context.wfidgen.generate
+
+    @engine.storage.purge!
+    #@engine.context.wfidgen.instance_eval { @last = nil }
+
+    assert_not_nil @engine.context.wfidgen.generate
+  end
+
+  def test_generate_after_a_put_failed
+
+    assert_not_nil @engine.context.wfidgen.generate
+
+    @engine.context.wfidgen.instance_eval do
+      if @last['_rev'].is_a?(String)
+        @last['_rev'] = '1-cc9bc774f00b65ee28a6c0e4f26474de'
+      else # integer
+        @last['_rev'] = 123456789
+      end
+    end
+
+    assert_not_nil @engine.context.wfidgen.generate
+  end
+end
+

data/test/functional/ft_48_lose.rb

@@ -0,0 +1,112 @@
+
+#
+# testing ruote
+#
+# Thu Nov 25 11:20:04 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+#require 'ruote/part/storage_participant'
+
+
+class FtLoseTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_lose_participiant
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha :lose => true
+        alpha
+      end
+    end
+
+    @engine.register_participant '.+' do |wi|
+      @tracer << wi.participant_name + "\n"
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(6)
+
+    #sleep 0.500
+
+    assert_equal 'alpha', @tracer.to_s
+
+    ps = @engine.process(wfid)
+
+    assert_equal 3, ps.expressions.size
+    assert_equal 0, ps.errors.size
+      # the sequence is stuck, the lost alpha is not replying
+  end
+
+  def test_lose_sequence
+
+    pdef = Ruote.process_definition do
+      concurrence do
+        alpha
+        sequence :lose => 'true' do
+          bravo
+        end
+      end
+    end
+
+    @engine.register_participant '.+' do |wi|
+      @tracer << wi.participant_name + "\n"
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(12)
+
+    assert_match /alpha/, @tracer.to_s
+    assert_match /bravo/, @tracer.to_s
+
+    ps = @engine.process(wfid)
+
+    assert_equal 3, ps.expressions.size
+    assert_equal 0, ps.errors.size
+      # the concurrence is stuck, the lost sequence won't reply
+  end
+
+  def test_cancel_lost_expression
+
+    pdef = Ruote.define do
+      sequence do
+        alpha
+        bravo :lose => true
+        charly
+      end
+    end
+
+    @engine.register_participant '.+' do |wi|
+      @tracer << wi.participant_name + "\n"
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(12)
+      # until bravo is reached
+
+    #sleep 0.500
+
+    assert_equal "alpha\nbravo", @tracer.to_s
+
+    bravo = @engine.process(wfid).expressions.last
+
+    @engine.cancel_expression(bravo.fei)
+
+    @engine.wait_for(wfid)
+
+    assert_equal "alpha\nbravo\ncharly", @tracer.to_s
+    assert_nil @engine.process(wfid)
+  end
+end
+

data/test/functional/ft_49_engine_on_error.rb

@@ -0,0 +1,201 @@
+
+#
+# testing ruote
+#
+# Mon Dec  6 10:02:56 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class FtEngineOnErrorTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def setup
+    super
+    @engine.context.stash[:seen] = []
+  end
+
+  def test_no_on_error
+
+    assert_nil @engine.on_error
+  end
+
+  def test_on_error
+
+    @engine.on_error = 'supervisor'
+
+    assert_equal(
+      [ 'define', {}, [ [ 'supervisor', {}, [] ] ] ],
+      @engine.on_error)
+  end
+
+  class Supervisor
+    include Ruote::LocalParticipant
+    def initialize(opts)
+      @opts = opts
+    end
+    def consume(workitem)
+      workitem.fields['flavour'] = @opts['flavour']
+      @context.stash[:seen] << workitem
+      reply(workitem)
+    end
+  end
+
+  WRONGY = Ruote.process_definition do
+    error "something went wrong"
+  end
+
+  def test_on_error_participant
+
+    @engine.register 'supervisor', Supervisor, 'flavour' => 'vanilla'
+    @engine.on_error = 'supervisor'
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(WRONGY, 'colour' => 'yellow')
+
+    @engine.wait_for(wfid)
+    @engine.wait_for(:supervisor)
+
+    sleep 0.350
+      # unfortunately waiting for a participant triggers right
+      # before the consume
+
+    assert_equal 1, @engine.context.stash[:seen].size
+    assert_equal 'yellow', @engine.context.stash[:seen].first.fields['colour']
+    assert_equal 'vanilla', @engine.context.stash[:seen].first.fields['flavour']
+    assert_not_nil @engine.context.stash[:seen].first.fei.subid
+
+    # TODO : look for error message and such
+
+    @engine.wait_for(@engine.context.stash[:seen].first.wfid)
+
+    assert_equal 1, @engine.processes.size
+  end
+
+  def test_on_error_engine_subprocess_name
+
+    @engine.variables['trigger_alarm'] = Ruote.define do
+      echo '${colour} seen'
+    end
+    @engine.on_error = 'trigger_alarm'
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(WRONGY, 'colour' => 'red')
+
+    @engine.wait_for(wfid)
+
+    sleep 0.700
+      # letting the subprocess getting triggered
+
+    assert_equal 'red seen', @tracer.to_s
+    assert_equal 1, @engine.processes.size
+  end
+
+  def test_on_error_local_subprocess_name
+
+    @engine.variables['trigger_alarm'] = Ruote.define do
+      echo '${colour} seen'
+    end
+    @engine.on_error = 'trigger_alarm'
+
+    pdef = Ruote.define do
+      error 'still wrong'
+      define 'trigger_alarm' do
+        echo 'saw ${colour}'
+      end
+    end
+
+    wfid = @engine.launch(pdef, 'colour' => 'green')
+
+    @engine.wait_for(wfid)
+
+    sleep 0.700
+      # letting the subprocess getting triggered
+
+    assert_equal 'saw green', @tracer.to_s
+    assert_equal 1, @engine.processes.size
+  end
+
+  def test_on_error_subprocess_tree
+
+    @engine.on_error = Ruote.define do
+      echo 'case ${colour}'
+    end
+
+    wfid = @engine.launch(WRONGY, 'colour' => 'blue')
+
+    @engine.wait_for(wfid)
+
+    sleep 0.700
+      # letting the subprocess getting triggered
+
+    assert_equal 'case blue', @tracer.to_s
+    assert_equal 1, @engine.processes.size
+  end
+
+  def test_on_error_workitem
+
+    @engine.register 'supervisor', Supervisor
+    @engine.on_error = 'supervisor'
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(WRONGY, 'colour' => 'crimson')
+
+    @engine.wait_for(wfid)
+    @engine.wait_for(:supervisor)
+
+    sleep 0.350
+      # unfortunately waiting for a participant triggers right
+      # before the consume
+
+    wi = @engine.context.stash[:seen].first
+
+    assert_not_nil wi.error
+  end
+
+  def test_cascade_prevention
+
+    @engine.on_error = Ruote.define { error "nada" }
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(WRONGY, 'colour' => 'purple')
+
+    @engine.wait_for(wfid)
+    @engine.wait_for(wfid)
+
+    sleep 0.700
+      # give it a bit of time, to make sure no supplementary errors crop up
+
+    assert_equal 2, @engine.process(wfid).errors.size
+  end
+
+  def test_doesnt_trigger_for_checked_error
+
+    pdef = Ruote.define do
+      nemo :on_error => 'pass'
+    end
+
+    @engine.on_error = Ruote.define do
+      echo 'seen'
+    end
+
+    wfid = @engine.launch(pdef)
+
+    #noisy
+
+    @engine.wait_for(wfid)
+
+    sleep 0.700
+      # give it a bit of time, to make sure no supplementary errors crop up
+
+    assert_equal '', @tracer.to_s
+  end
+end
+

data/test/functional/ft_4_cancel.rb

@@ -0,0 +1,132 @@
+
+#
+# testing ruote
+#
+# Wed Jun  3 08:42:07 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class FtCancelTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_cancel_process
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(:alpha)
+
+    ps = @engine.process(wfid)
+    assert_equal 1, alpha.size
+
+    assert_not_nil ps
+
+    @engine.cancel_process(wfid)
+
+    wait_for(wfid)
+    ps = @engine.process(wfid)
+
+    assert_nil ps
+    assert_equal 0, alpha.size
+
+    #puts; logger.log.each { |e| p e['action'] }; puts
+    assert_equal 1, logger.log.select { |e| e['action'] == 'cancel_process' }.size
+    assert_equal 2, logger.log.select { |e| e['action'] == 'cancel' }.size
+  end
+
+  def test_cancel_expression
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+        bravo
+      end
+    end
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+    sto = @engine.register_participant :bravo, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(:alpha)
+
+    assert_equal 1, sto.size
+
+    wi = sto.first
+
+    @engine.cancel_expression(wi.fei)
+    wait_for(:bravo)
+
+    assert_equal 1, sto.size
+    assert_equal 'bravo', sto.first.participant_name
+  end
+
+  def test_cancel__process
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    @engine.register_participant :alpha, Ruote::NullParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:alpha)
+
+    @engine.cancel(wfid)
+
+    @engine.wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+
+    assert_equal 1, logger.log.select { |e| e['action'] == 'cancel_process' }.size
+  end
+
+  def test_cancel__expression
+
+    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.cancel(r['fei']) # fei as a Hash
+
+    r = @engine.wait_for(:alpha)
+
+    @engine.cancel(Ruote.sid(r['fei'])) # fei as a String
+
+    r = @engine.wait_for(:alpha)
+
+    @engine.cancel(Ruote::Workitem.new(r['workitem'])) # fei as workitem
+
+    @engine.wait_for(wfid)
+
+    assert_equal %w[ 0 1 2 ], @tracer.to_a
+
+    assert_equal 3, logger.log.select { |e| e['action'] == 'cancel' }.size
+  end
+end
+