ruote 2.2.0 → 2.3.0

data/test/functional/concurrent_base.rb

@@ -5,7 +5,7 @@
 # Fri Dec  4 17:15:10 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'base.rb')
+require File.expand_path('../base', __FILE__)
 
 
 class Ruote::Worker
@@ -16,7 +16,9 @@ end
 class Ruote::Engine
 
   def peek_msg
-    @msgs = @context.storage.get_msgs if ( ! @msgs) || @msgs.size < 1
+    if ( ! @msgs) || @msgs.size < 1
+      @msgs = @context.storage.get_msgs
+    end
     @msgs.shift
   end
 
@@ -62,37 +64,38 @@ module ConcurrentBase
 
   def setup
 
-    @storage = determine_storage(
-      's_logger' => [ 'ruote/log/test_logger', 'Ruote::TestLogger' ])
+    @storage = determine_storage({})
 
-    @engine0 = Ruote::Engine.new(Ruote::Worker.new(@storage), false)
-    @engine1 = Ruote::Engine.new(Ruote::Worker.new(@storage), false)
+    @dashboard0 = Ruote::Engine.new(Ruote::Worker.new(@storage), false)
+    @dashboard1 = Ruote::Engine.new(Ruote::Worker.new(@storage), false)
       #
       # the 2 engines are set with run=false
 
     @tracer0 = Tracer.new
     @tracer1 = Tracer.new
 
-    @engine0.context.add_service('s_tracer', @tracer0, nil)
-    @engine1.context.add_service('s_tracer', @tracer1, nil)
+    @dashboard0.context.add_service('s_tracer', @tracer0, nil)
+    @dashboard1.context.add_service('s_tracer', @tracer1, nil)
+
+    @dashboard1.context.logger.color = '32' # green
 
-    @engine1.context.logger.color = '32' # green
+    noisy if ARGV.include?('-N')
   end
 
   def teardown
 
     @storage.purge!
 
-    @engine0.shutdown
-    @engine1.shutdown
+    @dashboard0.shutdown
+    @dashboard1.shutdown
   end
 
   protected
 
   def noisy
 
-    @engine0.context.logger.noisy = true
-    @engine1.context.logger.noisy = true
+    @dashboard0.noisy = true
+    @dashboard1.noisy = true
   end
 end
 

data/test/functional/ct_0_concurrence.rb

@@ -5,9 +5,7 @@
 # Wed Jul  8 15:30:55 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'concurrent_base')
-
-#require 'ruote/part/hash_participant'
+require File.expand_path('../concurrent_base', __FILE__)
 
 
 class CtConcurrenceTest < Test::Unit::TestCase
@@ -26,20 +24,18 @@ class CtConcurrenceTest < Test::Unit::TestCase
       end
     end
 
-    noisy if ARGV.include?('-N')
-
-    wfid = @engine0.launch(pdef)
+    wfid = @dashboard0.launch(pdef)
 
     replies = []
 
     while replies.size < 2
 
-      msg = @engine0.next_msg
+      msg = @dashboard0.next_msg
 
       if msg['action'] == 'reply'
         replies << msg
       else
-        @engine0.do_process(msg)
+        @dashboard0.do_process(msg)
       end
     end
 
@@ -47,12 +43,12 @@ class CtConcurrenceTest < Test::Unit::TestCase
 
     #replies.each { |r| p r }
 
-    t0 = Thread.new { @engine1.do_process(replies[0]) }
-    t1 = Thread.new { @engine0.do_process(replies[1]) }
+    t0 = Thread.new { @dashboard1.do_process(replies[0]) }
+    t1 = Thread.new { @dashboard0.do_process(replies[1]) }
     t0.join
     t1.join
 
-    msgs = @engine0.gather_msgs
+    msgs = @dashboard0.gather_msgs
 
     assert_equal 1, msgs.size, 'exactly 1 message was expected'
 

data/test/functional/ct_1_iterator.rb

@@ -5,7 +5,7 @@
 # Mon Dec  7 13:54:18 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'concurrent_base')
+require File.expand_path('../concurrent_base', __FILE__)
 
 
 class CtIteratorTest < Test::Unit::TestCase
@@ -29,35 +29,33 @@ class CtIteratorTest < Test::Unit::TestCase
       end
     end
 
-    noisy if ARGV.include?('-N')
-
-    wfid = @engine0.launch(pdef)
+    wfid = @dashboard0.launch(pdef)
 
     stop_msg = nil
 
     loop do
-      m = @engine0.next_msg
+      m = @dashboard0.next_msg
       if m['command']
         stop_msg = m
         break
       end
-      @engine0.do_process(m)
+      @dashboard0.do_process(m)
     end
 
     assert_equal 'stop', stop_msg['command'].first
     assert_equal '0_0_0', stop_msg['fei']['expid']
 
-    msg = @engine0.next_msg
+    msg = @dashboard0.next_msg
 
-    t0 = Thread.new { @engine1.do_process(stop_msg) }
-    t1 = Thread.new { @engine0.do_process(msg) }
+    t0 = Thread.new { @dashboard1.do_process(stop_msg) }
+    t1 = Thread.new { @dashboard0.do_process(msg) }
     t0.join
     t1.join
 
     loop do
-      m = @engine0.next_msg
+      m = @dashboard0.next_msg
       break if m['action'] == 'terminated'
-      @engine0.do_process(m)
+      @dashboard0.do_process(m)
     end
 
     assert_equal "1\n2", @tracer0.to_s

data/test/functional/ct_2_cancel.rb

@@ -5,7 +5,7 @@
 # Mon Dec 28 19:13:02 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'concurrent_base')
+require File.expand_path('../concurrent_base', __FILE__)
 
 
 class CtCancelTest < Test::Unit::TestCase
@@ -24,58 +24,69 @@ class CtCancelTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine0.register_participant :alpha do |workitem|
+    alpha = @dashboard0.register_participant :alpha do |workitem|
       # let reply immediately
     end
 
-    noisy if ARGV.include?('-N')
+    wfid = @dashboard0.launch(pdef)
 
-    wfid = @engine0.launch(pdef)
+    #
+    # test preparation...
 
-    @engine0.step 7
+    @dashboard0.step 6
 
     dispatched_seen = false
     reply_msg = nil
 
+    #
+    # reach the point where the reply is coming (and the dispatched msg has
+    # passed)
+
     loop do
-      m = @engine0.next_msg
+      m = @dashboard0.next_msg
       ma = m['action']
       if ma == 'dispatched'
         dispatched_seen = true
-        @engine0.do_process(m)
+        @dashboard0.do_process(m)
         break if reply_msg
       elsif ma == 'reply'
         reply_msg = m
-        break
+        break if dispatched_seen
       else
-        @engine0.do_process(m)
+        @dashboard0.do_process(m)
       end
     end
 
-    #p dispatched_seen
+    #
+    # inject the cancel message
 
-    @engine0.cancel_expression(
+    @dashboard0.cancel_expression(
       { 'engine_id' => 'engine', 'wfid' => wfid, 'expid' => '0_0' })
 
-    msgs = @engine0.gather_msgs
+    msgs = @dashboard0.gather_msgs
 
     msgs = msgs - [ reply_msg ]
 
     assert_equal 1, msgs.size
     assert_equal 'cancel', msgs.first['action']
+      #
+      # trusting is good, checking is better
+
+    #
+    # try to force a collision between the reply msg and the cancel msg
 
-    t1 = Thread.new { @engine1.do_process(msgs.first) }
-    t0 = Thread.new { @engine0.do_process(reply_msg) }
+    t1 = Thread.new { @dashboard1.do_process(msgs.first) }
+    t0 = Thread.new { @dashboard0.do_process(reply_msg) }
     t1.join
     t0.join
 
     loop do
-      m = @engine0.next_msg
-      @engine0.do_process(m)
+      m = @dashboard0.next_msg
+      @dashboard0.do_process(m)
       break if m['action'] == 'terminated'
     end
 
-    assert_nil @engine0.process(wfid)
+    assert_nil @dashboard0.process(wfid)
   end
 end
 

data/test/functional/eft_0_flow_expression.rb

@@ -0,0 +1,35 @@
+
+#
+# testing ruote
+#
+# Mon Jun 27 11:24:21 JST 2011
+#
+
+
+require File.expand_path('../base', __FILE__)
+
+
+class EftFlowExpressionTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_root_and_root_id
+
+    @dashboard.register :alpha, Ruote::NullParticipant
+
+    wfid = @dashboard.launch(Ruote.define do
+      sequence do
+        alpha
+      end
+    end)
+
+    @dashboard.wait_for(:alpha)
+
+    fexp = @dashboard.ps(wfid).expressions.last
+
+    assert_equal '0', fexp.root.fei.expid
+    assert_equal Ruote::Exp::SequenceExpression, fexp.root.class
+
+    assert_equal '0', fexp.root_id.expid
+  end
+end
+

data/test/functional/eft_10_cancel_process.rb

@@ -5,7 +5,7 @@
 # Mon Jun 15 21:18:06 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'base')
+require File.expand_path('../base', __FILE__)
 
 
 class EftCancelProcessTest < Test::Unit::TestCase

data/test/functional/eft_11_wait.rb

@@ -5,7 +5,7 @@
 # Thu Jun 18 11:03:45 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'base')
+require File.expand_path('../base', __FILE__)
 
 
 class EftWaitTest < Test::Unit::TestCase
@@ -24,18 +24,18 @@ class EftWaitTest < Test::Unit::TestCase
 
     #noisy
 
-    @engine.context.stash[:ts] = []
+    @dashboard.context.stash[:ts] = []
 
-    @engine.register_participant(:alpha) { stash[:ts] << Time.now }
+    @dashboard.register_participant(:alpha) { stash[:ts] << Time.now }
 
     assert_trace 'done.', pdef
 
     d = (
-      @engine.context.stash[:ts][1].sec - @engine.context.stash[:ts][0].sec
+      @dashboard.context.stash[:ts][1].sec - @dashboard.context.stash[:ts][0].sec
     ) % 60
 
-    deltas = [ 2, 3 ]
-    deltas << 4 if @engine.storage.class.name.match(/^Ruote::Couch::/)
+    deltas = [ 2, 3, 4 ]
+    #deltas << 4 if @dashboard.storage.class.name.match(/^Ruote::Couch::/)
 
     assert(
       deltas.include?(d),
@@ -54,23 +54,23 @@ class EftWaitTest < Test::Unit::TestCase
 
     #noisy
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
     wait_for(4)
 
-    @engine.cancel_process(wfid)
+    @dashboard.cancel_process(wfid)
 
     wait_for(wfid)
 
     assert_equal 'a', @tracer.to_s
-    assert_equal 0, @engine.storage.get_many('schedules').size
+    assert_equal 0, @dashboard.storage.get_many('schedules').size
   end
 
   def test_wait_until
 
-    @engine.context.stash[:ts] = []
+    @dashboard.context.stash[:ts] = []
 
-    @engine.register_participant(:alpha) { stash[:ts] << Time.now }
+    @dashboard.register_participant(:alpha) { stash[:ts] << Time.now }
 
     pdef = Ruote.process_definition do
       sequence do
@@ -85,8 +85,8 @@ class EftWaitTest < Test::Unit::TestCase
 
     assert_trace 'done.', pdef
 
-    ts0 = @engine.context.stash[:ts][0]
-    ts1 = @engine.context.stash[:ts][1]
+    ts0 = @dashboard.context.stash[:ts][0]
+    ts1 = @dashboard.context.stash[:ts][1]
 
     assert(ts1 - ts0 > 1.0, "#{ts1 - ts0} should be > 1.0")
   end

data/test/functional/eft_12_listen.rb

@@ -5,7 +5,7 @@
 # Fri Jun 19 15:26:33 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'base')
+require File.expand_path('../base', __FILE__)
 
 
 class EftListenTest < Test::Unit::TestCase
@@ -25,19 +25,18 @@ class EftListenTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
-    @engine.register_participant :alpha do
-      @tracer << "alpha\n"
+    @dashboard.register_participant :alpha do
+      tracer << "alpha\n"
     end
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.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)
+      0,
+      @dashboard.context.storage.get('variables', 'trackers')['trackers'].size)
   end
 
   def test_listen_with_child
@@ -54,24 +53,17 @@ class EftListenTest < Test::Unit::TestCase
       end
     end
 
-    @engine.register_participant :alpha do
-      @tracer << "a\n"
+    @dashboard.register_participant :alpha do
+      tracer << "a\n"
     end
-    @engine.register_participant :bravo do |workitem|
-      @tracer << "#{workitem.fei.wfid}|#{workitem.fei.subid}"
-      @tracer << "\n"
+    @dashboard.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)
+    wfid = @dashboard.launch(pdef)
 
-    #sleep 0.001
-    #p @tracer.to_s
+    4.times { @dashboard.wait_for('dispatched') }
 
     a = @tracer.to_a
     assert_equal 2, a.select { |e| e == 'a' }.size
@@ -79,13 +71,14 @@ class EftListenTest < Test::Unit::TestCase
     a = (a - [ 'a', 'a' ]).sort
     assert_equal 2, a.uniq.size
 
-    ps = @engine.process(wfid)
+    ps = @dashboard.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)
+      1,
+      @dashboard.context.storage.get('variables', 'trackers')['trackers'].size)
   end
 
   def test_upon
@@ -106,18 +99,16 @@ class EftListenTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
-    @engine.register_participant :alpha do |workitem|
-      @tracer << "alpha\n"
+    @dashboard.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"
+    @dashboard.register_participant :bravo do |workitem|
+      tracer << "bravo:#{workitem.fields['seen']}\n"
     end
 
-    wfid = @engine.launch(pdef)
-    @engine.wait_for(wfid)
+    wfid = @dashboard.launch(pdef)
+    @dashboard.wait_for(wfid)
 
     assert_equal %w[ alpha bravo: bravo:yes ], @tracer.to_a.sort
   end
@@ -138,15 +129,13 @@ class EftListenTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
-    @engine.register_participant :alpha do |wi|
-      @tracer << "alpha\n"
+    @dashboard.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"
+    @dashboard.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)
@@ -168,25 +157,23 @@ class EftListenTest < Test::Unit::TestCase
       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
+    @dashboard.register_participant :alpha do |wi|
+      tracer << "alpha\n"
+      wi.fields['who'] = 'toto' if context.stash[:count] > 0
+      context.stash[:count] += 1
     end
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.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_equal 3, @dashboard.process(wfid).expressions.size
 
     assert_not_nil(
-      @engine.context.logger.log.find { |l| l['action'] == 'ceased' })
+      @dashboard.context.logger.log.find { |l| l['action'] == 'ceased' })
   end
 
   def test_listen_cancel
@@ -195,19 +182,19 @@ class EftListenTest < Test::Unit::TestCase
       listen :to => 'alpha'
     end
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
     wait_for(2)
 
     assert_equal(
-      1, @engine.context.storage.get('variables', 'trackers')['trackers'].size)
+      1, @dashboard.context.storage.get('variables', 'trackers')['trackers'].size)
 
-    @engine.cancel_process(wfid)
+    @dashboard.cancel_process(wfid)
 
     wait_for(wfid)
 
     assert_equal(
-      0, @engine.context.storage.get('variables', 'trackers')['trackers'].size)
+      0, @dashboard.context.storage.get('variables', 'trackers')['trackers'].size)
   end
 
   def test_cross
@@ -225,14 +212,12 @@ class EftListenTest < Test::Unit::TestCase
       end
     end
 
-    @engine.register_participant :alpha do
+    @dashboard.register_participant :alpha do
       # nothing
     end
 
-    #noisy
-
-    lwfid = @engine.launch(listening)
-    ewfid = @engine.launch(emitting)
+    lwfid = @dashboard.launch(listening)
+    ewfid = @dashboard.launch(emitting)
 
     wait_for(lwfid, ewfid)
 
@@ -255,18 +240,18 @@ class EftListenTest < Test::Unit::TestCase
       end
     end
 
-    @engine.register_participant :alpha do
+    @dashboard.register_participant :alpha do
       # nothing
     end
 
-    lwfid = @engine.launch(listening)
-    ewfid = @engine.launch(emitting)
+    lwfid = @dashboard.launch(listening)
+    ewfid = @dashboard.launch(emitting)
 
     wait_for(ewfid)
 
     assert_equal("edone.", @tracer.to_s)
 
-    ps = @engine.process(lwfid)
+    ps = @dashboard.process(lwfid)
     assert_equal(3, ps.expressions.size)
   end
 
@@ -289,10 +274,8 @@ class EftListenTest < Test::Unit::TestCase
       echo 'edone.'
     end
 
-    #noisy
-
-    lwfid = @engine.launch(listening)
-    ewfid = @engine.launch(emitting)
+    lwfid = @dashboard.launch(listening)
+    ewfid = @dashboard.launch(emitting)
 
     wait_for(ewfid)
 
@@ -328,11 +311,161 @@ class EftListenTest < Test::Unit::TestCase
       end
     end
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
-    @engine.wait_for(wfid)
+    @dashboard.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
+
+    @dashboard.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
+
+    wfid = @dashboard.launch(pdef)
+
+    @dashboard.wait_for(wfid)
+
+    @dashboard.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
+
+    wfid = @dashboard.launch(pdef)
+    @dashboard.wait_for(wfid)
+
+    assert_equal '', @tracer.to_s
+  end
+
+  def test_listen_does_not_work_for_errors_in_other_processes
+
+    wfid0 = @dashboard.launch(Ruote.define do
+      listen :to => :errors do
+        echo 'error intercepted'
+      end
+    end)
+
+    sleep 0.700
+
+    wfid1 = @dashboard.launch(Ruote.define do
+      nemo
+    end)
+
+    @dashboard.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
+
+    wfid = @dashboard.launch(pdef)
+
+    #sleep 1.000
+    4.times { @dashboard.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
+
+    @dashboard.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
+
+    wfid = @dashboard.launch(pdef)
+
+    4.times { @dashboard.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
+
+    wfid = @dashboard.launch(pdef)
+
+    #sleep 1.000
+    4.times { @dashboard.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