ruote 2.1.9 → 2.1.10

data/test/functional/base.rb

@@ -35,6 +35,8 @@ module FunctionalBase
 
     @engine.add_service('tracer', @tracer)
 
+    noisy if ARGV.include?('-n')
+
     #noisy # uncommented, it makes all the tests noisy
   end
 
@@ -96,7 +98,7 @@ module FunctionalBase
 
   def wait_for (*wfid_or_part)
 
-    @engine.context.logger.wait_for(*wfid_or_part)
+    @engine.wait_for(*wfid_or_part)
   end
 
   def assert_engine_clean (wfid)

data/test/functional/concurrent_base.rb

@@ -10,43 +10,49 @@ require File.join(File.dirname(__FILE__), 'base.rb')
 
 class Ruote::Worker
 
-  def step_by_one
-    msg = @storage.get_msgs.first
-    #p [ msg['action'], msg['fei'] ]
-    if msg
-      process(msg)
-    else
-      false
-    end
-  end
-
   public :process
-
-  def step_until (&block)
-    loop do
-      msg = @storage.get_msgs.first
-      return msg if block.call(msg)
-      process(msg)
-    end
-  end
 end
 
 class Ruote::Engine
-  def step (count=1)
-    count.times { @context.worker.step_by_one }
+
+  def peek_msg
+    @msgs = @context.storage.get_msgs if ( ! @msgs) || @msgs.size < 1
+    @msgs.shift
   end
-  def step!
-    r = @context.worker.step_by_one
-    step! if r == false
+
+  def do_process (msg)
+    @context.worker.process(msg)
   end
-  def walk
-    while @context.worker.step_by_one do; end
+
+  def step (count)
+    return if count == 0
+    loop do
+      m = next_msg
+      next unless m
+      do_process(m)
+      break
+    end
+    step(count - 1)
   end
-  def do_step (msg)
-    @context.worker.process(msg)
+
+  def next_msg
+    loop do
+      if m = peek_msg
+        return m
+      end
+    end
   end
-  def step_until (&block)
-    @context.worker.step_until(&block)
+
+  def gather_msgs
+    (1..77).to_a.inject({}) { |h, i|
+      #(i % 10).times { Thread.pass }
+      sleep 0.001
+      m = peek_msg
+      h[m['_id']] = m if m
+      h
+    }.values.sort { |a, b|
+      a['put_at'] <=> b['put_at']
+    }
   end
 end
 

data/test/functional/crunner.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+
+TEST="test/functional/ct_0_concurrence.rb"
+if [ $1 = "1" ]; then
+  TEST="test/functional/ct_1_iterator.rb"
+fi
+if [ $1 = "2" ]; then
+  TEST="test/functional/ct_2_cancel.rb"
+fi
+
+COUNT=0
+
+while [ $? == 0 ]
+do
+  echo " *** $COUNT"
+  ((COUNT=$COUNT + 1))
+  time ruby $TEST $1 $2
+done
+

data/test/functional/ct_0_concurrence.rb

@@ -25,46 +25,33 @@ class CtConcurrenceTest < Test::Unit::TestCase
     #noisy
 
     wfid = @engine0.launch(pdef)
-    @engine0.step 4
 
-    msgs = @storage.get_msgs
-    $stderr.puts "*cough*" if msgs.size != 2
-    #msgs.each do |m|
-    #  p [ m['action'], m['fei']['expid'], m['workitem'] ]
-    #end
+    replies = []
 
-    t0 = Thread.new { @engine1.step! }
-    t1 = Thread.new { @engine0.step! }
-    t0.join
-    t1.join
+    while replies.size < 2
 
-    #t0 = Thread.new { @engine1.step }
-    #@engine0.step
-    #t0.join
+      msg = @engine0.next_msg
 
-    msgs = @storage.get_msgs
-    msg = msgs.first
+      if msg['action'] == 'reply'
+        replies << msg
+      else
+        @engine0.do_process(msg)
+      end
+    end
 
-    if msgs.size > 1 || (msg && msg['fei'] && msg['fei']['expid'] != '0')
+    replies.sort! { |a, b| a['put_at'] <=> b['put_at'] }
 
-      msgs.each do |m|
+    t0 = Thread.new { @engine1.do_process(replies[0]) }
+    t1 = Thread.new { @engine0.do_process(replies[1]) }
+    t0.join
+    t1.join
 
-        fei = m['fei'] ?
-          Ruote::FlowExpressionId.to_storage_id(m['fei']) : ''
-        wi_fei = m['workitem'] ?
-          Ruote::FlowExpressionId.to_storage_id(m['workitem']['fei']) : ''
+    msgs = @engine0.gather_msgs
 
-        p [ m['action'], fei, wi_fei ]
-      end
-    end
+    assert_equal 1, msgs.size, 'exactly 1 message was expected'
 
-    if msg['action'] == 'error_intercepted'
-      #p @engine0.process(wfid).errors.first
-      puts @engine0.process(wfid).errors.first.message
-      puts @engine0.process(wfid).errors.first.trace
-    end
+    msg = msgs.first
 
-    assert_equal 1, msgs.size
     assert_equal 'reply', msg['action']
     assert_equal '0', msg['fei']['expid']
   end

data/test/functional/ct_1_iterator.rb

@@ -30,32 +30,35 @@ class CtIteratorTest < Test::Unit::TestCase
 
     wfid = @engine0.launch(pdef)
 
-    #@engine0.step 11
-    msg = @engine0.step_until { |msg| msg['command'] != nil }
+    stop_msg = nil
 
-    assert_equal 'stop', msg['command'].first
-    assert_equal '0_0_0', msg['fei']['expid']
-
-    msgs = @storage.get_msgs
-
-    assert_equal 3, msgs.size
-
-    msgs = msgs - [ msg ]
+    loop do
+      m = @engine0.next_msg
+      if m['command']
+        stop_msg = m
+        break
+      end
+      @engine0.do_process(m)
+    end
 
-    assert_equal 2, msgs.size
+    assert_equal 'stop', stop_msg['command'].first
+    assert_equal '0_0_0', stop_msg['fei']['expid']
 
-    msg1 = msgs.first
+    msg = @engine0.next_msg
 
-    t0 = Thread.new { @engine1.do_step(msg) }
-    t1 = Thread.new { @engine0.do_step(msg1) }
+    t0 = Thread.new { @engine1.do_process(stop_msg) }
+    t1 = Thread.new { @engine0.do_process(msg) }
     t0.join
     t1.join
 
-    #@engine0.step 4
-    @engine1.walk
+    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
+    assert_equal '', @tracer1.to_s
   end
 end
 

data/test/functional/ct_2_cancel.rb

@@ -27,43 +27,50 @@ class CtCancelTest < Test::Unit::TestCase
 
     wfid = @engine0.launch(pdef)
 
-    @engine0.step 6
+    @engine0.step 7
 
-    @engine1.cancel_expression(
-      { 'engine_id' => 'engine', 'wfid' => wfid, 'expid' => '0_0' })
+    dispatched_seen = false
+    reply_msg = nil
 
-    msgs = nil
     loop do
-      msgs = @storage.get_msgs
-      break if msgs.size == 2
-      #p msgs.collect { |m| m['fei']['expid'] }.uniq
-      #break if
-      #  msgs.size == 2 &&
-      #  msgs.collect { |m| m['fei']['expid'] }.uniq == %w[ 0_0 ]
+      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
 
-    #msgs.each { |m| p m }
-    #puts
+    #p dispatched_seen
 
-    t1 = Thread.new { @engine1.do_step(msgs[1]) }
-    t0 = Thread.new { @engine0.do_step(msgs[0]) }
-    t1.join
-    t0.join
+    @engine0.cancel_expression(
+      { 'engine_id' => 'engine', 'wfid' => wfid, 'expid' => '0_0' })
 
-    #puts
+    msgs = @engine0.gather_msgs
 
-    @engine0.step 4
+    msgs = msgs - [ reply_msg ]
 
-    sleep 0.010
+    assert_equal 1, msgs.size
+    assert_equal 'cancel', msgs.first['action']
 
-    assert_equal 0, @storage.get_msgs.size
+    t1 = Thread.new { @engine1.do_process(msgs.first) }
+    t0 = Thread.new { @engine0.do_process(reply_msg) }
+    t1.join
+    t0.join
 
-    exps = @storage.get_many('expressions')
-    exps.each { |exp|
-      p [ exp['fei']['expid'], exp['original_tree'] ]
-    } if exps.size > 0
+    loop do
+      m = @engine0.next_msg
+      @engine0.do_process(m)
+      break if m['action'] == 'terminated'
+    end
 
-    assert_equal 0, exps.size
+    assert_nil @engine0.process(wfid)
   end
 end
 

data/test/functional/eft_12_listen.rb

@@ -70,6 +70,8 @@ class EftListenTest < Test::Unit::TestCase
     wait_for(:bravo)
     wait_for(2)
 
+    sleep 0.001
+
     #p @tracer.to_s
 
     a = @tracer.to_a
@@ -231,7 +233,6 @@ class EftListenTest < Test::Unit::TestCase
     lwfid = @engine.launch(listening)
     ewfid = @engine.launch(emitting)
 
-    wait_for(lwfid, ewfid)
     wait_for(lwfid, ewfid)
 
     #assert_equal("edone.\nldone.", @tracer.to_s)

data/test/functional/eft_23_apply.rb

@@ -141,5 +141,28 @@ class EftApplyTest < Test::Unit::TestCase
 
     assert_trace('nada', pdef)
   end
+
+  def test_apply_on_error
+
+    pdef = Ruote.process_definition do
+      handle do
+        sequence do
+          echo 'in'
+          nemo
+        end
+      end
+      define 'handle' do
+        apply :on_error => 'notify'
+        echo 'over.'
+      end
+      define 'notify' do
+        echo 'error'
+      end
+    end
+
+    #noisy
+
+    assert_trace(%w[ in error over. ], pdef)
+  end
 end
 

data/test/functional/eft_3_participant.rb

@@ -28,6 +28,7 @@ class EftParticipantTest < Test::Unit::TestCase
     assert_trace 'alpha', pdef
 
     assert_log_count(1) { |e| e['action'] == 'dispatch' }
+    assert_log_count(1) { |e| e['action'] == 'dispatched' }
     assert_log_count(1) { |e| e['action'] == 'receive' }
   end
 
@@ -118,5 +119,31 @@ class EftParticipantTest < Test::Unit::TestCase
       { "commander of the left guard"=>nil, "if"=>"true", "ref"=>"notify" },
       atts)
   end
+
+  def test_dispatched
+
+    part = @engine.register_participant :alpha do
+      sleep 1
+    end
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    ps = @engine.process(wfid)
+
+    fexp = ps.expressions.find { |fe|
+      fe.class == Ruote::Exp::ParticipantExpression
+    }
+
+    assert_equal nil, fexp.dispatched
+      # not yet 'dispatched'
+  end
 end
 

data/test/functional/ft_11_recursion.rb

@@ -105,7 +105,7 @@ class FtRecursionTest < Test::Unit::TestCase
 
     6.times { wait_for(:alpha) }
 
-    Thread.pass
+    wait_for(1)
 
     assert_equal((1..6).to_a.join("\n"), @tracer.to_s)
   end

data/test/functional/ft_13_variables.rb

@@ -127,5 +127,27 @@ class FtVariablesTest < Test::Unit::TestCase
     assert_match(/^0||\d+_\d+$/, results[1])
     assert_match(/^0\_0|\d+|\d+_\d+$/, results[2])
   end
+
+  def test_lookup_in_var
+
+    @engine.register_participant :echo_toto do |wi, fexp|
+      @tracer << fexp.lookup_variable('toto').join
+      @tracer << "\n"
+    end
+
+    pdef = Ruote.process_definition do
+
+      set 'v:toto' => %w[ a b c ]
+      echo '${v:toto.1}'
+
+      set 'v:toto.2' => 'C'
+      echo_toto
+
+      unset 'v:toto.1'
+      echo_toto
+    end
+
+    assert_trace(%w[ b abC aC ], pdef)
+  end
 end
 

data/test/functional/ft_14_re_apply.rb

@@ -91,6 +91,8 @@ class FtReApplyTest < Test::Unit::TestCase
     wfid = @engine.launch(PDEF)
     wait_for(:alpha)
 
+    sleep 0.350 # threaded dispatch
+
     id0 = alpha.first.object_id
 
     # ... flow stalled ...
@@ -101,6 +103,7 @@ class FtReApplyTest < Test::Unit::TestCase
 
     stalled_exp.update_tree([
       'participant', { 'ref' => 'alpha', 'activity' => 'mow lawn' }, [] ])
+    #p [ :stalled, stalled_exp.h['_rev'] ]
     stalled_exp.persist
 
     @engine.re_apply(stalled_exp.fei)