ruote 2.1.11 → 2.2.0

data/test/bm/launch_bench.rb

@@ -0,0 +1,37 @@
+
+# a ruote launch benchmark, as discussed with @hassox
+# http://ruote.rubyforge.org/irclogs/ruote_2010-10-20.txt
+
+puts
+puts RUBY_VERSION
+puts
+
+require 'rubygems'
+require 'benchmark'
+require 'fileutils'
+require 'ruote' # gem install ruote
+require 'ruote/storage/fs_storage'
+
+FileUtils.rm_rf('bench')
+
+engine = Ruote::Engine.new(Ruote::FsStorage.new('bench'))
+
+pdef = Ruote.process_definition do
+  alpha :task => 'walk the dog'
+  alpha :task => 'walk the dog'
+  alpha :task => 'walk the dog'
+  alpha :task => 'walk the dog'
+  alpha :task => 'walk the dog'
+  alpha :task => 'walk the dog'
+  alpha :task => 'walk the dog'
+  alpha :task => 'walk the dog'
+  alpha :task => 'walk the dog'
+  alpha :task => 'walk the dog'
+end
+
+Benchmark.benchmark(' ' * 31 + Benchmark::Tms::CAPTION, 31) do |b|
+  b.report('1000 launches') do
+    1000.times { engine.launch(pdef) }
+  end
+end
+

data/test/functional/base.rb

@@ -10,15 +10,30 @@ require 'fileutils'
 require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
 require File.join(File.dirname(__FILE__), 'storage_helper.rb')
 
-require 'ruote/engine'
-require 'ruote/worker'
-require 'ruote/parser/ruby_dsl'
+require 'ruote'
+
+
+trap 'USR2' do
+
+  require 'irb'
+  require 'irb/completion'
+
+  IRB.setup(nil)
+  ws = IRB::WorkSpace.new(binding)
+  irb = IRB::Irb.new(ws)
+  IRB::conf[:MAIN_CONTEXT] = irb.context
+  irb.eval_input
+end
+
+puts "pid #{$$}"
 
 
 module FunctionalBase
 
   def setup
 
+    p self.class if ARGV.include?('-T') or ARGV.include?('-N')
+
     #require 'ruote/util/look'
     #Ruote::Look.dump_lsof
     #Ruote::Look.dump_lsof_count
@@ -31,13 +46,21 @@ module FunctionalBase
           determine_storage(
             's_logger' => [ 'ruote/log/test_logger', 'Ruote::TestLogger' ])))
 
-    #p @engine.storage.class
+    $_test = self
+    $_engine = @engine
+      #
+      # handy when hijacking (https://github.com/ileitch/hijack)
+      # or flinging USR2 at the test process
 
     @tracer = Tracer.new
 
+    tracer = @tracer
+    @engine.context.instance_eval { @tracer = tracer }
+
     @engine.add_service('tracer', @tracer)
+    @engine.add_service('stash', {})
 
-    noisy if ARGV.include?('-n')
+    noisy if ARGV.include?('-N')
 
     #noisy # uncommented, it makes all the tests noisy
   end
@@ -49,7 +72,12 @@ module FunctionalBase
     @engine.context.storage.close if @engine.context.storage.respond_to?(:close)
   end
 
-  def assert_log_count (count, &block)
+  def stash
+
+    @engine.context.stash
+  end
+
+  def assert_log_count(count, &block)
 
     c = @engine.context.logger.log.select(&block).size
 
@@ -61,7 +89,12 @@ module FunctionalBase
   #   assert_trace(*expected_traces, pdef)
   #   assert_trace(*expected_traces, fields, pdef)
   #
-  def assert_trace (*args)
+  def assert_trace(*args)
+
+    if args.last == :clear
+      args.pop
+      @tracer.clear
+    end
 
     pdef = args.pop
     fields = args.last.is_a?(Hash) ? args.pop : {}
@@ -69,15 +102,16 @@ module FunctionalBase
 
     wfid = @engine.launch(pdef, fields)
 
-    wait_for(wfid)
-
-    #yield(@engine) if block_given?
+    r = wait_for(wfid)
 
     assert_engine_clean(wfid)
 
+    trace = r['workitem']['fields']['_trace']
+    trace = trace ? trace.join('') : @tracer.to_s
+
     if expected_traces.length > 0
-      ok, nok = expected_traces.partition { |et| @tracer.to_s == et }
-      assert_equal(nok.first, @tracer.to_s) if ok.empty?
+      ok, nok = expected_traces.partition { |et| trace == et }
+      assert_equal(nok.first, trace) if ok.empty?
     end
 
     assert(true)
@@ -93,24 +127,24 @@ module FunctionalBase
 
   protected
 
-  def noisy (on=true)
+  def noisy(on=true)
 
     puts "\nnoisy " + caller[0] if on
     @engine.context.logger.noisy = true
   end
 
-  def wait_for (*wfid_or_part)
+  def wait_for(*wfid_or_part)
 
     @engine.wait_for(*wfid_or_part)
   end
 
-  def assert_engine_clean (wfid)
+  def assert_engine_clean(wfid)
 
     assert_no_errors(wfid)
     assert_no_remaining_expressions(wfid)
   end
 
-  def assert_no_errors (wfid)
+  def assert_no_errors(wfid)
 
     errors = @engine.storage.get_many('errors', /#{wfid}$/)
 
@@ -131,7 +165,7 @@ module FunctionalBase
     flunk 'remaining process error(s)'
   end
 
-  def assert_no_remaining_expressions (wfid)
+  def assert_no_remaining_expressions(wfid)
 
     expcount = @engine.storage.get_many('expressions').size
     return if expcount == 0
@@ -169,6 +203,14 @@ module FunctionalBase
   end
 end
 
+# Re-opening workitem for a shortcut to a '_trace' field
+#
+class Ruote::Workitem
+  def trace
+    @h['fields']['_trace'] ||= []
+  end
+end
+
 class Tracer
   attr_reader :s
   def initialize
@@ -187,7 +229,7 @@ class Tracer
   def clear
     @s = ''
   end
-  def puts (s)
+  def puts(s)
     @s << "#{s}\n"
   end
 end

data/test/functional/concurrent_base.rb

@@ -20,11 +20,11 @@ class Ruote::Engine
     @msgs.shift
   end
 
-  def do_process (msg)
+  def do_process(msg)
     @context.worker.process(msg)
   end
 
-  def step (count)
+  def step(count)
     return if count == 0
     loop do
       m = next_msg

data/test/functional/ct_0_concurrence.rb

@@ -26,7 +26,7 @@ class CtConcurrenceTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
+    noisy if ARGV.include?('-N')
 
     wfid = @engine0.launch(pdef)
 

data/test/functional/ct_1_iterator.rb

@@ -29,7 +29,7 @@ class CtIteratorTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
+    noisy if ARGV.include?('-N')
 
     wfid = @engine0.launch(pdef)
 

data/test/functional/ct_2_cancel.rb

@@ -28,7 +28,7 @@ class CtCancelTest < Test::Unit::TestCase
       # let reply immediately
     end
 
-    #noisy
+    noisy if ARGV.include?('-N')
 
     wfid = @engine0.launch(pdef)
 

data/test/functional/eft_0_process_definition.rb

@@ -7,7 +7,7 @@
 
 require File.join(File.dirname(__FILE__), 'base')
 
-require 'ruote/part/hash_participant'
+require 'ruote/participant'
 
 
 class EftProcessDefinitionTest < Test::Unit::TestCase
@@ -28,7 +28,7 @@ class EftProcessDefinitionTest < Test::Unit::TestCase
       participant :ref => :alpha
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     #noisy
 

data/test/functional/eft_10_cancel_process.rb

@@ -33,7 +33,7 @@ class EftCancelProcessTest < Test::Unit::TestCase
     pdef = Ruote.process_definition do
       sequence do
         echo 'a'
-        cancel_process :unless => 'true == true'
+        terminate :unless => 'true == true'
         echo 'b'
       end
     end

data/test/functional/eft_11_wait.rb

@@ -24,17 +24,22 @@ class EftWaitTest < Test::Unit::TestCase
 
     #noisy
 
-    ts = []
-    @engine.register_participant(:alpha) { ts << Time.now }
+    @engine.context.stash[:ts] = []
+
+    @engine.register_participant(:alpha) { stash[:ts] << Time.now }
 
     assert_trace 'done.', pdef
 
-    #p [ ts[1].sec, ts[0].sec ]
-    d = (ts[1].sec - ts[0].sec) % 60
+    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(
-      [ 2, 3 ].include?(d),
-      "delta is #{d}, which isn't 2 or 3")
+      deltas.include?(d),
+      "delta is #{d}, which isn't in #{deltas.inspect}")
   end
 
   def test_cancel_wait
@@ -63,6 +68,10 @@ class EftWaitTest < Test::Unit::TestCase
 
   def test_wait_until
 
+    @engine.context.stash[:ts] = []
+
+    @engine.register_participant(:alpha) { stash[:ts] << Time.now }
+
     pdef = Ruote.process_definition do
       sequence do
         alpha
@@ -74,13 +83,12 @@ class EftWaitTest < Test::Unit::TestCase
 
     #noisy
 
-    ts = []
-    @engine.register_participant(:alpha) { ts << Time.now }
-
     assert_trace 'done.', pdef
 
-    #p ts
-    assert ts[1] - ts[0] > 1.0, "#{ts[1] - ts[0]} should be > 1.0"
+    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

data/test/functional/eft_12_listen.rb

@@ -16,7 +16,7 @@ class EftListenTest < Test::Unit::TestCase
     pdef = Ruote.process_definition do
       concurrence do
         sequence do
-          listen :to => '^al.*'
+          listen :to => '/^al.*/'
           echo '1'
         end
         sequence do
@@ -44,7 +44,7 @@ class EftListenTest < Test::Unit::TestCase
 
     pdef = Ruote.process_definition do
       concurrence do
-        listen :to => '^al.*' do
+        listen :to => /^al.*/ do
           bravo
         end
         sequence do
@@ -58,7 +58,7 @@ class EftListenTest < Test::Unit::TestCase
       @tracer << "a\n"
     end
     @engine.register_participant :bravo do |workitem|
-      @tracer << "#{workitem.fei.wfid}|#{workitem.fei.sub_wfid}"
+      @tracer << "#{workitem.fei.wfid}|#{workitem.fei.subid}"
       @tracer << "\n"
     end
 
@@ -68,10 +68,9 @@ class EftListenTest < Test::Unit::TestCase
 
     wait_for(:bravo)
     wait_for(:bravo)
-    wait_for(2)
-
-    sleep 0.001
+    wait_for(3)
 
+    #sleep 0.001
     #p @tracer.to_s
 
     a = @tracer.to_a
@@ -94,11 +93,11 @@ class EftListenTest < Test::Unit::TestCase
     pdef = Ruote.process_definition do
       concurrence do
         sequence do
-          listen :to => '^al.*', :merge => false
+          listen :to => /^al.*/, :merge => false
           bravo
         end
         sequence do
-          listen :to => '^al.*', :upon => 'reply'
+          listen :to => '/^al.*/', :upon => 'reply'
           bravo
         end
         sequence do
@@ -130,7 +129,7 @@ class EftListenTest < Test::Unit::TestCase
       set :f => 'other', :val => 'nothing'
       concurrence do
         sequence do
-          listen :to => '^al.*', :merge => 'override', :upon => 'reply'
+          listen :to => '/^al.*/', :merge => 'override', :upon => 'reply'
           bravo
         end
         sequence do
@@ -171,12 +170,12 @@ class EftListenTest < Test::Unit::TestCase
 
     #noisy
 
-    count = 0
+    stash[:count] = 0
 
     @engine.register_participant :alpha do |wi|
       @tracer << "alpha\n"
-      wi.fields['who'] = 'toto' if count > 0
-      count = count + 1
+      wi.fields['who'] = 'toto' if stash[:count] > 0
+      stash[:count] += 1
     end
 
     wfid = @engine.launch(pdef)
@@ -185,7 +184,9 @@ class EftListenTest < Test::Unit::TestCase
 
     assert_equal %w[ alpha alpha toto ].join("\n"), @tracer.to_s
     assert_equal 3, @engine.process(wfid).expressions.size
-    assert_equal 'ceased', @engine.context.logger.log.last['action']
+
+    assert_not_nil(
+      @engine.context.logger.log.find { |l| l['action'] == 'ceased' })
   end
 
   def test_listen_cancel
@@ -268,5 +269,70 @@ class EftListenTest < Test::Unit::TestCase
     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
 end