ruote 2.2.0 → 2.3.0

data/test/functional/ft_37_default_history.rb

@@ -5,7 +5,7 @@
 # Mon Jan 24 11:11:43 JST 2011
 #
 
-require File.join(File.dirname(__FILE__), 'base')
+require File.expand_path('../base', __FILE__)
 
 
 class FtDefaultHistoryTest < Test::Unit::TestCase
@@ -13,25 +13,30 @@ class FtDefaultHistoryTest < Test::Unit::TestCase
 
   def test_engine_has_history
 
-    assert_not_nil @engine.context.history
-    assert_not_nil @engine.history
+    assert_not_nil @dashboard.context.history
+    assert_not_nil @dashboard.history
   end
 
   def launch_processes(clear=true)
 
-    @engine.history.clear! if clear
+    if clear
+      @dashboard.history.clear!
+      sleep 0.050
+      @dashboard.history.clear!
+    end
+
+    @dashboard.register_participant 'alpha', Ruote::NullParticipant
 
-    @engine.register_participant 'alpha', Ruote::NullParticipant
+    #puts; @dashboard.noisy = true
 
     pdef = Ruote.define do
       alpha
     end
 
-    wfids = 2.times.collect { @engine.launch(pdef) }
+    wfids = 2.times.collect { @dashboard.launch(pdef) }
 
-    @engine.wait_for(:alpha)
-    @engine.wait_for(:alpha)
-    sleep 0.700
+    @dashboard.wait_for('dispatched')
+    @dashboard.wait_for('dispatched')
 
     wfids
   end
@@ -42,33 +47,33 @@ class FtDefaultHistoryTest < Test::Unit::TestCase
 
     wfids = launch_processes
 
-    assert_equal 9, @engine.history.all.size
+    assert_equal 9, @dashboard.history.reject { |m| m['action'] == 'noop' }.size
   end
 
   def test_by_wfid
 
     wfids = launch_processes
 
-    assert_equal 4, @engine.history.by_wfid(wfids[0]).size
-    assert_not_nil @engine.history.by_wfid(wfids[0]).first['seen_at']
+    assert_equal 4, @dashboard.history.by_wfid(wfids[0]).size
+    assert_not_nil @dashboard.history.by_wfid(wfids[0]).first['seen_at']
 
-    assert_equal 4, @engine.history.by_wfid(wfids[1]).size
+    assert_equal 4, @dashboard.history.by_wfid(wfids[1]).size
   end
 
   def test_clear!
 
     launch_processes
 
-    assert_equal 9, @engine.history.all.size
+    assert_equal 9, @dashboard.history.reject { |m| m['action'] == 'noop' }.size
 
-    @engine.history.clear!
+    @dashboard.history.clear!
 
-    assert_equal 0, @engine.history.all.size
+    assert_equal 0, @dashboard.history.all.size
   end
 
   def test_default_range
 
-    range = @engine.history.range
+    range = @dashboard.history.range
 
     assert_equal Time, range[0].class
     assert_equal range[0], range[1]
@@ -80,7 +85,7 @@ class FtDefaultHistoryTest < Test::Unit::TestCase
     sleep 1
     launch_processes(false)
 
-    range = @engine.history.range
+    range = @dashboard.history.range
 
     assert_not_equal range[0], range[1]
     assert range[0] < range[1]
@@ -90,20 +95,27 @@ class FtDefaultHistoryTest < Test::Unit::TestCase
 
     launch_processes
 
-    @engine.history.all.each { |msg| msg['seen_at'] = '1970-12-25' }
+    @dashboard.history.all.each { |msg| msg['seen_at'] = '1970-12-25' }
 
     launch_processes(false)
 
-    assert_equal 18, @engine.history.all.size
-
-    assert_equal 9, @engine.history.by_date(Time.now).size
+    assert_equal(
+      18,
+      @dashboard.history.reject { |m|
+        m['action'] == 'noop'
+      }.size)
+    assert_equal(
+      9,
+      @dashboard.history.by_date(Time.now.utc).reject { |m|
+        m['action'] == 'noop'
+      }.size)
   end
 
   def test_wfids
 
     wfids = launch_processes
 
-    assert_equal wfids.sort, @engine.history.wfids
+    assert_equal wfids.sort, @dashboard.history.wfids
   end
 end
 

data/test/functional/ft_38_participant_more.rb

@@ -7,7 +7,7 @@
 # Qcon Tokyo, special day
 #
 
-require File.join(File.dirname(__FILE__), 'base')
+require File.expand_path('../base', __FILE__)
 
 require 'ruote/part/local_participant'
 
@@ -15,6 +15,42 @@ require 'ruote/part/local_participant'
 class FtParticipantMoreTest < Test::Unit::TestCase
   include FunctionalBase
 
+  #
+  # tests about reject / re_dispatch
+
+  def test_re_dispatch_count_is_initially_zero
+
+    @dashboard.register { catchall }
+
+    wfid = @dashboard.launch(Ruote.define { alpha })
+    r = @dashboard.wait_for(:alpha)
+
+    assert_equal 0, r['workitem']['re_dispatch_count']
+  end
+
+  class CountingParticipant
+    include Ruote::LocalParticipant
+    def on_workitem
+      context.tracer << "#{workitem.re_dispatch_count}\n"
+      if workitem.re_dispatch_count < 5
+        re_dispatch
+      else
+        reply
+      end
+    end
+  end
+
+  def test_re_dispatch_count_is_incremented_at_each_re_dispatch
+
+    @dashboard.register { counter CountingParticipant }
+
+    wfid = @dashboard.launch(Ruote.define { counter })
+
+    @dashboard.wait_for(wfid)
+
+    assert_equal %w[ 0 1 2 3 4 5 ], @tracer.to_a
+  end
+
   class DifficultParticipant
     include Ruote::LocalParticipant
     def initialize(opts)
@@ -38,13 +74,55 @@ class FtParticipantMoreTest < Test::Unit::TestCase
       alpha
     end
 
-    @engine.register_participant :alpha, DifficultParticipant
-
-    #noisy
+    @dashboard.register_participant :alpha, DifficultParticipant
 
     assert_trace(%w[ diff diff ], pdef)
   end
 
+  # https://groups.google.com/d/topic/openwferu-users/_k-VIQwMvXw/discussion
+  #
+  def test_re_dispatch_outside_of_participant
+
+    @dashboard.register :alpha, Ruote::StorageParticipant
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for('dispatched')
+
+    wi = @dashboard.storage_participant.first
+
+    @dashboard.storage_participant.re_dispatch(wi, :in => '100')
+
+    sleep 10
+  end
+
+  class ReluctantParticipant
+    include Ruote::LocalParticipant
+    def initialize(opts)
+    end
+    def consume(workitem)
+      context.tracer << "x\n"
+      if workitem.fields['re_dispatched'].nil?
+        workitem.fields['re_dispatched'] = true
+        re_dispatch
+      else
+        reply_to_engine(workitem)
+      end
+    end
+  end
+
+  # Reject and re_dispatch are aliases.
+  #
+  def test_participant_re_dispatch_no_params
+
+    @dashboard.register_participant :alpha, ReluctantParticipant
+
+    assert_trace(%w[ x x ], Ruote.define { alpha })
+  end
+
   class FightingParticipant
     include Ruote::LocalParticipant
     def initialize(opts)
@@ -61,15 +139,13 @@ class FtParticipantMoreTest < Test::Unit::TestCase
     end
   end
 
-  # Reject and re_dispatch are aliases.
-  #
   def test_participant_re_dispatch
 
     pdef = Ruote.process_definition do
       alpha
     end
 
-    @engine.register_participant :alpha, FightingParticipant
+    @dashboard.register_participant :alpha, FightingParticipant
 
     #noisy
 
@@ -96,8 +172,6 @@ class FtParticipantMoreTest < Test::Unit::TestCase
     end
   end
 
-  # Reject and re_dispatch are aliases.
-  #
   # re_dispatch with an :in or an :at parameter makes sure the dispatch is
   # performed once more, but a bit later (:in / :at timepoint).
   #
@@ -107,18 +181,16 @@ class FtParticipantMoreTest < Test::Unit::TestCase
       alpha
     end
 
-    @engine.register_participant :alpha, RetryParticipant
-
-    #noisy
+    @dashboard.register_participant :alpha, RetryParticipant
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
     wait_for(wfid)
 
     times = @tracer.to_s.split("\n").collect { |t| Float(t) }
     t = times.last - times.first
 
     assert t >= 1.0, "took less that 1 second"
-    assert t < 2.0, "took more than 1.99 second"
+    assert t < 2.8, "took more than 2.8 second"
   end
 
   # Making sure that when a process gets cancelled, its 'later' re-dispatches
@@ -130,19 +202,22 @@ class FtParticipantMoreTest < Test::Unit::TestCase
       alpha
     end
 
-    @engine.register_participant :alpha, RetryParticipant, 'delay' => '1m'
+    @dashboard.register_participant :alpha, RetryParticipant, 'delay' => '1m'
 
     #noisy
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
     sleep 0.7
 
-    @engine.cancel_process(wfid)
+    @dashboard.cancel_process(wfid)
     wait_for(wfid)
 
-    assert_equal 0, @engine.storage.get_many('schedules').size
+    assert_equal 0, @dashboard.storage.get_many('schedules').size
   end
 
+  #
+  # tests about stash_put and stash_get
+
   BLACKBOARD = {}
 
   class StashingParticipant
@@ -150,11 +225,12 @@ class FtParticipantMoreTest < Test::Unit::TestCase
     def initialize(opts)
     end
     def consume(workitem)
-      put(workitem.fei, 'token' => workitem.params['token'])
+      put('token0' => workitem.params['token0'])
+      put('token1', workitem.params['token1'])
     end
     def cancel(fei, flavour)
-      BLACKBOARD['token'] = get(fei, 'token')
-      BLACKBOARD['all'] = get(fei)
+      BLACKBOARD['token0'] = get('token0')
+      BLACKBOARD['all'] = get
     end
   end
 
@@ -166,28 +242,109 @@ class FtParticipantMoreTest < Test::Unit::TestCase
     BLACKBOARD.clear
 
     pdef = Ruote.process_definition do
-      alpha :token => 'of esteem'
+      alpha :token0 => 'of esteem', :token1 => 'of whatever'
     end
 
-    @engine.register_participant :alpha, StashingParticipant
+    @dashboard.register_participant :alpha, StashingParticipant
 
-    #noisy
+    #@dashboard.noisy = true
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
     wait_for(:alpha)
+    wait_for(1)
 
-    sleep 0.350 # since wait_for(:alpha) releases too early sometimes
-
-    ps = @engine.process(wfid)
+    ps = @dashboard.process(wfid)
     fexp = ps.expressions.find { |e| e.fei.expid == '0_0' }
 
-    assert_equal({ 'token' => 'of esteem' }, fexp.h.stash)
+    assert_equal(
+      { 'token0' => 'of esteem', 'token1' => 'of whatever' },
+      fexp.h.stash)
 
-    @engine.cancel_process(wfid)
+    @dashboard.cancel_process(wfid)
     wait_for(wfid)
 
-    assert_equal('of esteem', BLACKBOARD['token'])
-    assert_equal({ 'token' => 'of esteem' }, BLACKBOARD['all'])
+    assert_equal(
+      'of esteem',
+      BLACKBOARD['token0'])
+    assert_equal(
+      { 'token0' => 'of esteem', 'token1' => 'of whatever' },
+      BLACKBOARD['all'])
+  end
+
+  class Doubtful
+    include Ruote::LocalParticipant
+
+    def on_workitem
+      context.tracer << "canceled:#{is_canceled?}\n"
+      context.tracer << "gone:#{is_gone?}\n"
+      sleep 5
+      context.tracer << "cancelled:#{is_cancelled?}\n"
+      context.tracer << "gone:#{is_gone?}\n"
+    end
+
+    def on_cancel
+      # nothing
+    end
+  end
+
+  def test_is_cancelled
+
+    @dashboard.register :alpha, Doubtful
+
+    pdef = Ruote.define do
+      alpha
+    end
+
+    #@dashboard.noisy = true
+
+    wfid = @dashboard.launch(pdef)
+
+    @dashboard.wait_for(:alpha)
+    sleep 1.0 # making sure on_workitem reaches its sleep
+
+    @dashboard.cancel(@dashboard.ps(wfid).expressions.last)
+
+    @dashboard.wait_for(wfid)
+
+    sleep 10
+
+    assert_equal(
+      %w[ canceled:false gone:false cancelled:true gone:true ],
+      @tracer.to_a)
+  end
+
+  class Robust
+    include Ruote::LocalParticipant
+
+    def on_workitem
+      context.tracer << "on_workitem\n"
+      sleep 5
+      workitem.fields['toto'] = 'seen'
+      reply
+    end
+
+    def on_cancel
+      context.tracer << "on_cancel\n"
+      false
+    end
+  end
+
+  def test_on_cancel_returning_false
+
+    @dashboard.register :rob, Robust
+
+    #@dashboard.noisy = true
+
+    wfid = @dashboard.launch(Ruote.define { rob })
+
+    @dashboard.wait_for(:rob)
+
+    @dashboard.cancel(@dashboard.ps(wfid).expressions.last)
+
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 'seen', r['workitem']['fields']['toto']
+    assert_equal %w[ on_cancel on_workitem ], @tracer.to_a.sort
   end
 end
 

data/test/functional/ft_39_wait_for.rb

@@ -5,7 +5,7 @@
 # Tue Apr 20 12:32:44 JST 2010
 #
 
-require File.join(File.dirname(__FILE__), 'base')
+require File.expand_path('../base', __FILE__)
 
 require 'ruote/part/storage_participant'
 
@@ -19,17 +19,17 @@ class FtWaitForTest < Test::Unit::TestCase
       alpha
     end
 
-    sp = @engine.register_participant :alpha, Ruote::StorageParticipant
+    sp = @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
     #noisy
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
     r = wait_for(:alpha)
 
     assert_equal(
       Ruote::Workitem,
-      @engine.workitem(Ruote.sid(r['fei'])).class)
+      @dashboard.workitem(Ruote.sid(r['fei'])).class)
   end
 
   class MyParticipant
@@ -48,17 +48,17 @@ class FtWaitForTest < Test::Unit::TestCase
       alpha
     end
 
-    @engine.register_participant :alpha, MyParticipant
+    @dashboard.register_participant :alpha, MyParticipant
 
     4.times do
-      @engine.launch(pdef)
+      @dashboard.launch(pdef)
     end
 
     #noisy
 
-    @engine.wait_for(:empty)
+    @dashboard.wait_for(:empty)
 
-    assert_equal [], @engine.processes
+    assert_equal [], @dashboard.processes
   end
 
   def test_wait_for_multiple
@@ -66,18 +66,18 @@ class FtWaitForTest < Test::Unit::TestCase
     pdef0 = Ruote.process_definition { alpha }
     pdef1 = Ruote.process_definition { bravo }
 
-    @engine.register_participant :alpha, MyParticipant
+    @dashboard.register_participant :alpha, MyParticipant
 
     #noisy
 
     wfids = []
 
-    2.times { wfids << @engine.launch(pdef0) }
-    2.times { wfids << @engine.launch(pdef1) }
+    2.times { wfids << @dashboard.launch(pdef0) }
+    2.times { wfids << @dashboard.launch(pdef1) }
 
-    @engine.wait_for(*wfids)
+    @dashboard.wait_for(*wfids)
 
-    assert_equal 2, @engine.processes.size
+    assert_equal 2, @dashboard.processes.size
   end
 
   def test_wait_for_inactive
@@ -85,52 +85,52 @@ class FtWaitForTest < Test::Unit::TestCase
     pdef0 = Ruote.process_definition { alpha }
     pdef1 = Ruote.process_definition { bravo }
 
-    @engine.register_participant :alpha, MyParticipant
+    @dashboard.register_participant :alpha, MyParticipant
 
     #noisy
 
     wfids = []
 
-    2.times { @engine.launch(pdef0) }
-    2.times { wfids << @engine.launch(pdef1) }
+    2.times { @dashboard.launch(pdef0) }
+    2.times { wfids << @dashboard.launch(pdef1) }
 
-    @engine.wait_for(:inactive)
+    @dashboard.wait_for(:inactive)
 
-    assert_equal wfids.sort, @engine.processes.collect { |ps| ps.wfid }.sort
+    assert_equal wfids.sort, @dashboard.processes.collect { |ps| ps.wfid }.sort
   end
 
   def test_wait_for_multithreaded
 
     pdef = Ruote.process_definition { alpha }
 
-    sp = @engine.register_participant :alpha, Ruote::StorageParticipant
+    sp = @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
     #noisy
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
     seen = []
     threads = []
 
     threads << Thread.new do
-      @engine.wait_for(wfid)
+      @dashboard.wait_for(wfid)
       seen << 'this'
     end
     threads << Thread.new do
-      @engine.wait_for(wfid)
+      @dashboard.wait_for(wfid)
       seen << 'that'
     end
 
-    @engine.wait_for(:alpha)
+    @dashboard.wait_for(:alpha)
 
-    sp.reply(sp.first)
+    sp.proceed(sp.first)
 
     threads.each do |t|
       t.join
     end
 
     assert_equal %w[ that this ], seen.sort
-    assert_equal [], @engine.context.logger.instance_variable_get(:@waiting)
+    assert_equal [], @dashboard.context.logger.instance_variable_get(:@waiting)
   end
 end