ruote-maestrodev 2.2.1

data/test/functional/ct_1_iterator.rb

@@ -0,0 +1,67 @@
+
+#
+# testing ruote
+#
+# Mon Dec  7 13:54:18 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'concurrent_base')
+
+
+class CtIteratorTest < Test::Unit::TestCase
+  include ConcurrentBase
+
+  # Test proper handling of collisions between an iterator and another worker
+  # passing a stop command.
+  #
+  def test_collision
+
+    pdef = Ruote.process_definition do
+      concurrence do
+        iterator :on => (1..10).to_a, :tag => 'it' do
+          echo '${v:i}'
+        end
+        sequence do
+          sequence do
+            stop :ref => 'it'
+          end
+        end
+      end
+    end
+
+    noisy if ARGV.include?('-N')
+
+    wfid = @engine0.launch(pdef)
+
+    stop_msg = nil
+
+    loop do
+      m = @engine0.next_msg
+      if m['command']
+        stop_msg = m
+        break
+      end
+      @engine0.do_process(m)
+    end
+
+    assert_equal 'stop', stop_msg['command'].first
+    assert_equal '0_0_0', stop_msg['fei']['expid']
+
+    msg = @engine0.next_msg
+
+    t0 = Thread.new { @engine1.do_process(stop_msg) }
+    t1 = Thread.new { @engine0.do_process(msg) }
+    t0.join
+    t1.join
+
+    loop do
+      m = @engine0.next_msg
+      break if m['action'] == 'terminated'
+      @engine0.do_process(m)
+    end
+
+    assert_equal "1\n2", @tracer0.to_s
+    assert_equal '', @tracer1.to_s
+  end
+end
+

data/test/functional/ct_2_cancel.rb

@@ -0,0 +1,81 @@
+
+#
+# testing ruote
+#
+# Mon Dec 28 19:13:02 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'concurrent_base')
+
+
+class CtCancelTest < Test::Unit::TestCase
+  include ConcurrentBase
+
+  # A collision between a reply and a cancel
+  #
+  # The first one to occur should neutralize the other (and the flow should
+  # not stall).
+  #
+  def test_collision
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+      end
+    end
+
+    alpha = @engine0.register_participant :alpha do |workitem|
+      # let reply immediately
+    end
+
+    noisy if ARGV.include?('-N')
+
+    wfid = @engine0.launch(pdef)
+
+    @engine0.step 7
+
+    dispatched_seen = false
+    reply_msg = nil
+
+    loop do
+      m = @engine0.next_msg
+      ma = m['action']
+      if ma == 'dispatched'
+        dispatched_seen = true
+        @engine0.do_process(m)
+        break if reply_msg
+      elsif ma == 'reply'
+        reply_msg = m
+        break
+      else
+        @engine0.do_process(m)
+      end
+    end
+
+    #p dispatched_seen
+
+    @engine0.cancel_expression(
+      { 'engine_id' => 'engine', 'wfid' => wfid, 'expid' => '0_0' })
+
+    msgs = @engine0.gather_msgs
+
+    msgs = msgs - [ reply_msg ]
+
+    assert_equal 1, msgs.size
+    assert_equal 'cancel', msgs.first['action']
+
+    t1 = Thread.new { @engine1.do_process(msgs.first) }
+    t0 = Thread.new { @engine0.do_process(reply_msg) }
+    t1.join
+    t0.join
+
+    loop do
+      m = @engine0.next_msg
+      @engine0.do_process(m)
+      break if m['action'] == 'terminated'
+    end
+
+    assert_nil @engine0.process(wfid)
+  end
+end
+

data/test/functional/eft_0_process_definition.rb

@@ -0,0 +1,65 @@
+
+#
+# testing ruote
+#
+# Sat Jan 24 22:40:35 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class EftProcessDefinitionTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_empty_procdef
+
+    assert_trace(
+      '',
+      Ruote.define(:name => 'test_1') { })
+  end
+
+  def test_sub_definition
+
+    pdef = Ruote.process_definition :name => 'main' do
+      define :name => 'sub0' do
+      end
+      participant :ref => :alpha
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    ps = @engine.process(wfid)
+
+    assert_equal(
+      {"sub0"=> ["0_0", ["define", {"name"=>"sub0"}, []]],
+       "main"=> ["0", ["define", {"name"=>"main"}, [["define", {"name"=>"sub0"}, []], ["participant", {"ref"=>"alpha"}, []]]]]},
+      ps.variables)
+  end
+
+  #def test_define_implicit_name
+  #  pdef = Ruote.define 'accounting_process' do
+  #  end
+  #  assert_equal 'accounting_process', pdef[1]['name']
+  #end
+
+  def test_sub_define_implicit_name
+
+    pdef = Ruote.define 'accounting_process' do
+      define 'sub0' do
+      end
+    end
+
+    assert_equal(
+      ["define", {"accounting_process"=>nil}, [["define", {"sub0"=>nil}, []]]],
+      pdef)
+  end
+end
+

data/test/functional/eft_10_cancel_process.rb

@@ -0,0 +1,46 @@
+
+#
+# testing ruote
+#
+# Mon Jun 15 21:18:06 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftCancelProcessTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_cancel_process
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'a'
+        cancel_process
+        echo 'b'
+      end
+    end
+
+    #noisy
+
+    assert_trace('a', pdef)
+
+    #assert_equal 3, logger.log.select { |e| e[1] == :entered_tag }.size
+  end
+
+  def test_unless
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'a'
+        terminate :unless => 'true == true'
+        echo 'b'
+      end
+    end
+
+    #noisy
+
+    assert_trace("a\nb", pdef)
+  end
+end
+

data/test/functional/eft_11_wait.rb

@@ -0,0 +1,109 @@
+
+#
+# testing ruote
+#
+# Thu Jun 18 11:03:45 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftWaitTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_wait_for
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+        wait :for => '2s'
+        alpha
+        echo 'done.'
+      end
+    end
+
+    #noisy
+
+    @engine.context.stash[:ts] = []
+
+    @engine.register_participant(:alpha) { stash[:ts] << Time.now }
+
+    assert_trace 'done.', pdef
+
+    d = (
+      @engine.context.stash[:ts][1].sec - @engine.context.stash[:ts][0].sec
+    ) % 60
+
+    deltas = [ 2, 3 ]
+    deltas << 4 if @engine.storage.class.name.match(/^Ruote::Couch::/)
+
+    assert(
+      deltas.include?(d),
+      "delta is #{d}, which isn't in #{deltas.inspect}")
+  end
+
+  def test_cancel_wait
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'a'
+        wait :for => '3d'
+        echo 'b'
+      end
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(4)
+
+    @engine.cancel_process(wfid)
+
+    wait_for(wfid)
+
+    assert_equal 'a', @tracer.to_s
+    assert_equal 0, @engine.storage.get_many('schedules').size
+  end
+
+  def test_wait_until
+
+    @engine.context.stash[:ts] = []
+
+    @engine.register_participant(:alpha) { stash[:ts] << Time.now }
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+        wait :until => (Time.now + 2.0).to_s
+        alpha
+        echo 'done.'
+      end
+    end
+
+    #noisy
+
+    assert_trace 'done.', pdef
+
+    ts0 = @engine.context.stash[:ts][0]
+    ts1 = @engine.context.stash[:ts][1]
+
+    assert(ts1 - ts0 > 1.0, "#{ts1 - ts0} should be > 1.0")
+  end
+
+  def test_wait_until_now
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'a'
+        wait Time.now
+        echo 'b'
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ a b ], pdef
+  end
+end
+

data/test/functional/eft_12_listen.rb

@@ -0,0 +1,500 @@
+
+#
+# testing ruote
+#
+# Fri Jun 19 15:26:33 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftListenTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_listen
+
+    pdef = Ruote.process_definition do
+      concurrence do
+        sequence do
+          listen :to => '/^al.*/'
+          echo '1'
+        end
+        sequence do
+          alpha
+        end
+      end
+    end
+
+    #noisy
+
+    @engine.register_participant :alpha do
+      @tracer << "alpha\n"
+    end
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+
+    assert_equal %w[ 1 alpha ], @tracer.to_a.sort
+
+    assert_equal(
+      0, @engine.context.storage.get('variables', 'trackers')['trackers'].size)
+  end
+
+  def test_listen_with_child
+
+    pdef = Ruote.process_definition do
+      concurrence do
+        listen :to => /^al.*/ do
+          bravo
+        end
+        sequence do
+          alpha
+          alpha
+        end
+      end
+    end
+
+    @engine.register_participant :alpha do
+      @tracer << "a\n"
+    end
+    @engine.register_participant :bravo do |workitem|
+      @tracer << "#{workitem.fei.wfid}|#{workitem.fei.subid}"
+      @tracer << "\n"
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:bravo)
+    wait_for(:bravo)
+    wait_for(3)
+
+    #sleep 0.001
+    #p @tracer.to_s
+
+    a = @tracer.to_a
+    assert_equal 2, a.select { |e| e == 'a' }.size
+
+    a = (a - [ 'a', 'a' ]).sort
+    assert_equal 2, a.uniq.size
+
+    ps = @engine.process(wfid)
+
+    #assert_equal 3, ps.expressions.size
+    assert_equal 0, ps.errors.size
+
+    assert_equal(
+      1, @engine.context.storage.get('variables', 'trackers')['trackers'].size)
+  end
+
+  def test_upon
+
+    pdef = Ruote.process_definition do
+      concurrence do
+        sequence do
+          listen :to => /^al.*/, :merge => false
+          bravo
+        end
+        sequence do
+          listen :to => '/^al.*/', :upon => 'reply'
+          bravo
+        end
+        sequence do
+          alpha
+        end
+      end
+    end
+
+    #noisy
+
+    @engine.register_participant :alpha do |workitem|
+      @tracer << "alpha\n"
+      workitem.fields['seen'] = 'yes'
+    end
+    @engine.register_participant :bravo do |workitem|
+      @tracer << "bravo:#{workitem.fields['seen']}\n"
+    end
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(wfid)
+
+    assert_equal %w[ alpha bravo: bravo:yes ], @tracer.to_a.sort
+  end
+
+  def test_merge_override
+
+    pdef = Ruote.process_definition do
+      set :f => 'name', :val => 'Kilroy'
+      set :f => 'other', :val => 'nothing'
+      concurrence do
+        sequence do
+          listen :to => '/^al.*/', :merge => 'override', :upon => 'reply'
+          bravo
+        end
+        sequence do
+          alpha
+        end
+      end
+    end
+
+    #noisy
+
+    @engine.register_participant :alpha do |wi|
+      @tracer << "alpha\n"
+      wi.fields['name'] = 'William Mandella'
+    end
+    @engine.register_participant :bravo do |wi|
+      @tracer << "name:#{wi.fields['name']} "
+      @tracer << "other:#{wi.fields['other']}\n"
+    end
+
+    assert_trace("alpha\nname:William Mandella other:nothing", pdef)
+  end
+
+  def test_where
+
+    pdef = Ruote.process_definition do
+      concurrence do
+        listen :to => 'alpha', :where => '${f:who} == toto', :upon => 'reply' do
+          echo 'toto'
+        end
+        sequence do
+          alpha
+        end
+        sequence do
+          alpha
+        end
+      end
+    end
+
+    #noisy
+
+    stash[:count] = 0
+
+    @engine.register_participant :alpha do |wi|
+      @tracer << "alpha\n"
+      wi.fields['who'] = 'toto' if stash[:count] > 0
+      stash[:count] += 1
+    end
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(wfid) # ceased
+
+    assert_equal %w[ alpha alpha toto ].join("\n"), @tracer.to_s
+    assert_equal 3, @engine.process(wfid).expressions.size
+
+    assert_not_nil(
+      @engine.context.logger.log.find { |l| l['action'] == 'ceased' })
+  end
+
+  def test_listen_cancel
+
+    pdef = Ruote.process_definition do
+      listen :to => 'alpha'
+    end
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(2)
+
+    assert_equal(
+      1, @engine.context.storage.get('variables', 'trackers')['trackers'].size)
+
+    @engine.cancel_process(wfid)
+
+    wait_for(wfid)
+
+    assert_equal(
+      0, @engine.context.storage.get('variables', 'trackers')['trackers'].size)
+  end
+
+  def test_cross
+
+    listening = Ruote.process_definition do
+      sequence do
+        listen :to => 'alpha'
+        echo 'ldone.'
+      end
+    end
+    emitting = Ruote.process_definition do
+      sequence do
+        alpha
+        echo 'edone.'
+      end
+    end
+
+    @engine.register_participant :alpha do
+      # nothing
+    end
+
+    #noisy
+
+    lwfid = @engine.launch(listening)
+    ewfid = @engine.launch(emitting)
+
+    wait_for(lwfid, ewfid)
+
+    #assert_equal("edone.\nldone.", @tracer.to_s)
+    assert_equal %w[ edone. ldone. ], @tracer.to_a.sort
+  end
+
+  def test_not_cross
+
+    listening = Ruote.process_definition do
+      sequence do
+        listen :to => 'alpha', :wfid => :same
+        echo 'ldone.'
+      end
+    end
+    emitting = Ruote.process_definition do
+      sequence do
+        alpha
+        echo 'edone.'
+      end
+    end
+
+    @engine.register_participant :alpha do
+      # nothing
+    end
+
+    lwfid = @engine.launch(listening)
+    ewfid = @engine.launch(emitting)
+
+    wait_for(ewfid)
+
+    assert_equal("edone.", @tracer.to_s)
+
+    ps = @engine.process(lwfid)
+    assert_equal(3, ps.expressions.size)
+  end
+
+  def test_listen_to_tag
+
+    listening = Ruote.process_definition do
+      concurrence do
+        listen :to => :first_phase, :upon => :leaving do
+          echo 'left'
+        end
+        listen :to => :first_phase, :upon => :entering do
+          echo 'entered'
+        end
+      end
+    end
+    emitting = Ruote.process_definition do
+      sequence :tag => :first_phase do
+        echo 'in'
+      end
+      echo 'edone.'
+    end
+
+    #noisy
+
+    lwfid = @engine.launch(listening)
+    ewfid = @engine.launch(emitting)
+
+    wait_for(ewfid)
+
+    assert_equal(%w[ in entered edone. left ], @tracer.to_a)
+  end
+
+  def test_listen_and_doesnt_match
+
+    pdef = Ruote.define do
+      concurrence :count => 1 do
+        listen :to => 'stone', :upon => 'entering' do
+          echo 'stone'
+        end
+        sequence :tag => 'milestone' do
+          echo 'milestone'
+        end
+      end
+    end
+
+    assert_trace "milestone", pdef
+  end
+
+  def test_listen_and_do_match
+
+    pdef = Ruote.define do
+      concurrence :count => 1 do
+        listen :to => /stone/, :upon => 'entering' do
+          echo 'stone'
+        end
+        sequence :tag => 'milestone' do
+          echo 'milestone'
+        end
+      end
+    end
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(wfid)
+
+    assert_equal %w[ milestone stone ], @tracer.to_a
+  end
+
+  # somewhere between Haneda and Changi (Thu Apr 21 00:56:19 JST 2011)
+
+  def test_listen_to_errors
+
+    @engine.context['ruby_eval_allowed'] = true
+
+    pdef = Ruote.define do
+      concurrence :count => 1 do
+        listen :to => :errors do
+          echo 'error:${f:__error__.message}'
+        end
+        sequence do
+          nemo
+        end
+      end
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(wfid)
+
+    @engine.wait_for(3)
+      # give it some time (steps) to launch the listen block
+
+    assert_equal "error:unknown participant or subprocess 'nemo'", @tracer.to_s
+  end
+
+  def test_listen_and_caught_errors
+
+    pdef = Ruote.define do
+      concurrence :count => 1 do
+        listen :to => :errors do
+          echo 'error intercepted'
+        end
+        sequence :on_error => :pass do
+          nemo
+        end
+      end
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(wfid)
+
+    assert_equal '', @tracer.to_s
+  end
+
+  def test_listen_does_not_work_for_errors_in_other_processes
+
+    #@engine.noisy = true
+
+    wfid0 = @engine.launch(Ruote.define do
+      listen :to => :errors do
+        echo 'error intercepted'
+      end
+    end)
+
+    sleep 0.700
+
+    wfid1 = @engine.launch(Ruote.define do
+      nemo
+    end)
+
+    @engine.wait_for(wfid1)
+
+    sleep 0.350
+      # just to be sure the 'listen' doesn't trigger
+
+    assert_equal '', @tracer.to_s
+  end
+
+  def test_listen_error_class
+
+    pdef = Ruote.define do
+      concurrence do
+        listen :to => :errors, :class => 'RuntimeError' do
+          echo 'runtime error'
+        end
+        listen :to => :errors, :class => 'ArgumentError' do
+          echo 'argument error'
+        end
+        sequence do
+          nemo
+        end
+        sequence do
+          echo '${r:nada}'
+        end
+      end
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    #sleep 1.000
+    4.times { @engine.wait_for(wfid) } # error, error, ceased, ceased
+
+    assert_equal(
+      true,
+      [ "runtime error\nargument error",
+        "argument error\nruntime error" ].include?(@tracer.to_s))
+  end
+
+  def test_listen_error_message
+
+    @engine.context['ruby_eval_allowed'] = true
+
+    pdef = Ruote.define do
+      concurrence do
+        listen :to => :errors, :msg => /nemo/ do
+          echo 'nemo error ${__error__.fei.expid}'
+        end
+        listen :to => :errors, :msg => 'nada' do
+          echo 'nada error ${__error__.fei.expid}'
+        end
+        sequence do
+          nemo
+        end
+        sequence do
+          error 'nada'
+        end
+      end
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    4.times { @engine.wait_for(wfid) } # error, error, ceased, ceased
+
+    assert_equal "nemo error 0_0_2_0\nnada error 0_0_3_0", @tracer.to_s
+  end
+
+  def test_listen_error_classes
+
+    pdef = Ruote.define do
+      concurrence do
+        listen :to => :errors, :class => 'RuntimeError, ArgumentError' do
+          echo 'that error ${__error__.fei.expid}'
+        end
+        sequence do
+          nemo
+        end
+        sequence do
+          echo '${r:nada}'
+        end
+      end
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    #sleep 1.000
+    4.times { @engine.wait_for(wfid) } # error, error, ceased, ceased
+
+    assert_equal "that error 0_0_1_0\nthat error 0_0_2_0", @tracer.to_s
+  end
+end
+