ruote 2.1.10 → 2.1.11

data/test/functional/ft_14_re_apply.rb

@@ -8,6 +8,7 @@
 require File.join(File.dirname(__FILE__), 'base')
 
 require 'ruote/part/hash_participant'
+require 'ruote/part/storage_participant'
 
 
 class FtReApplyTest < Test::Unit::TestCase
@@ -219,5 +220,80 @@ class FtReApplyTest < Test::Unit::TestCase
 
     assert_equal "re_applied\ndone.", @tracer.to_s
   end
+
+  def test_new_tree_and_process_status_current_tree
+
+    @engine.register_participant '.+', Ruote::StorageParticipant
+
+    wfid = @engine.launch(Ruote.define { alpha })
+
+    @engine.wait_for(:alpha)
+
+    assert_equal(
+      [ 'define', {}, [ [ 'participant', { 'ref' => 'alpha' }, [] ] ] ],
+      @engine.process(wfid).current_tree)
+
+    fei = @engine.storage_participant.first.fei
+
+    @engine.re_apply(fei, :tree => [ 'bravo', {}, [] ])
+
+    @engine.wait_for(:bravo)
+
+    assert_equal(
+      'bravo',
+      @engine.storage_participant.first.participant_name)
+
+    assert_equal(
+      [ 'participant', { 'ref' => 'bravo', '_triggered' => 'on_re_apply' }, [] ],
+      @engine.process(wfid).expressions.last.tree)
+
+    assert_equal(
+      [ 'define', {}, [ [ 'participant', { 'ref' => 'bravo', '_triggered' => 'on_re_apply' }, [] ] ] ],
+      @engine.process(wfid).current_tree)
+  end
+
+  # Issue reported by Brett Anthoine
+  #
+  def test_re_apply_root
+
+    @engine.register_participant '.+', Ruote::StorageParticipant
+
+    wfid = @engine.launch(Ruote.define { alpha })
+
+    @engine.wait_for(:alpha)
+    at0 = @engine.storage_participant.first.dispatched_at
+
+    root = @engine.process(wfid).root_expression
+    @engine.re_apply(root.fei)
+
+    @engine.wait_for(:alpha)
+    at1 = @engine.storage_participant.first.dispatched_at
+
+    assert at1 > at0
+  end
+
+  def test_re_apply_define
+
+    @engine.register_participant '.+', Ruote::StorageParticipant
+
+    wfid = @engine.launch(Ruote.define do
+      sub0
+      define 'sub0' do
+        alpha
+      end
+    end)
+
+    @engine.wait_for(:alpha)
+    at0 = @engine.storage_participant.first.dispatched_at
+
+    exp = @engine.process(wfid).expressions[1]
+
+    @engine.re_apply(exp.fei)
+
+    @engine.wait_for(:alpha)
+    at1 = @engine.storage_participant.first.dispatched_at
+
+    assert at1 > at0
+  end
 end
 

data/test/functional/ft_1_process_status.rb

@@ -7,7 +7,7 @@
 
 require File.join(File.dirname(__FILE__), 'base')
 
-require 'ruote/part/hash_participant'
+require 'ruote/participant'
 
 
 class FtProcessStatusTest < Test::Unit::TestCase
@@ -36,29 +36,6 @@ class FtProcessStatusTest < Test::Unit::TestCase
     assert_equal(
       {"my process"=>["0", ["define", {"name"=>"my process"}, [["participant", {"ref"=>"alpha"}, []]]]]},
       ps.variables)
-
-    # checking process_status.to_h
-
-    h = ps.to_h
-    #p h
-
-    assert_equal wfid, h['wfid']
-    assert_equal 2, h['expressions'].size
-    assert_equal 'my process', h['definition_name']
-
-    assert_equal Time, Time.parse(h['launched_time']).class
-
-    assert_equal(
-      ["define", {"name"=>"my process"}, [["participant", {"ref"=>"alpha"}, []]]],
-      h['original_tree'])
-
-    assert_equal(
-      ["define", {"name"=>"my process"}, [["participant", {"ref"=>"alpha"}, []]]],
-      h['current_tree'])
-
-    assert_equal(
-      {"my process"=>["0", ["define", {"name"=>"my process"}, [["participant", {"ref"=>"alpha"}, []]]]]},
-      h['variables'])
   end
 
   def test_variables
@@ -90,19 +67,21 @@ class FtProcessStatusTest < Test::Unit::TestCase
       nada
     end
 
-    wfid = @engine.launch( pdef )
-    wait_for( wfid )
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
 
     errs = @engine.errors
 
     assert_equal 1, errs.size
 
-    assert_equal wfid, errs.first['fei']['wfid']
+    assert_equal wfid, errs.first.wfid
 
-    err = @engine.errors( wfid )
+    err = @engine.errors(wfid)
 
     assert_equal 1, err.size
-    assert_equal wfid, err.first['fei']['wfid']
+    assert_equal wfid, err.first.wfid
+
+    assert_equal 1, @engine.errors(:count => true)
   end
 
   def test_tree
@@ -496,5 +475,167 @@ digraph "process wfid wfid" {
       }.strip,
       dot)
   end
+
+  def test_last_active
+
+    pdef = Ruote.define do
+      alpha
+      bravo
+    end
+
+    @engine.register_participant '.+', Ruote::StorageParticipant
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:alpha)
+
+    t0 = Time.parse(@engine.process(wfid).last_active)
+
+    sp = @engine.storage_participant
+    sp.reply(sp.first)
+
+    @engine.wait_for(:bravo)
+
+    t1 = Time.parse(@engine.process(wfid).last_active)
+
+    assert t1 > t0
+  end
+
+  def test_position
+
+    pdef = Ruote.define do
+      alpha :task => 'clean car'
+    end
+
+    @engine.register_participant '.+', Ruote::StorageParticipant
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(:alpha)
+
+    assert_equal(
+      [ [ "0_0!!#{wfid}", 'alpha', { 'task' => 'clean car' } ] ],
+      @engine.process(wfid).position)
+
+    # #position leverages #workitems
+
+    assert_equal(
+      [ 'alpha' ],
+      @engine.process(wfid).workitems.collect { |wi| wi.participant_name })
+  end
+
+  def test_ps_with_stored_workitems
+
+    @engine.register_participant '.+', Ruote::StorageParticipant
+
+    wfid = @engine.launch(Ruote.define { alpha })
+    @engine.wait_for(:alpha)
+
+    ps = @engine.process(wfid)
+
+    assert_equal 1, ps.stored_workitems.size
+    assert_equal Ruote::Workitem, ps.stored_workitems.first.class
+  end
+
+  def test_ps_without_stored_workitems
+
+    @engine.register_participant '.+', Ruote::NullParticipant
+
+    wfid = @engine.launch(Ruote.define { alpha })
+    @engine.wait_for(:alpha)
+
+    ps = @engine.process(wfid)
+
+    assert_equal 0, ps.stored_workitems.size
+  end
+
+  def test_schedules
+
+    @engine.register_participant '.+', Ruote::NullParticipant
+
+    wfid = @engine.launch(Ruote.define { alpha :timeout => '2d' })
+    @engine.wait_for(:alpha)
+
+    assert_equal 1, @engine.schedules.size
+    assert_equal 1, @engine.schedules(:count => true)
+  end
+
+  def test_ps_and_schedules
+
+    @engine.register_participant '.+', Ruote::NullParticipant
+
+    #noisy
+
+    wfid = @engine.launch(Ruote.define { alpha :timeout => '2d' })
+    @engine.wait_for(:alpha)
+
+    ps = @engine.process(wfid)
+
+    assert_equal 1, ps.schedules.size
+    assert_equal "0_0!!#{wfid}", ps.schedules.first['target'].sid
+  end
+
+  def test_ps_pagination
+
+    n = 7
+
+    @engine.register_participant '.+', Ruote::StorageParticipant
+
+    wfids = (1..n).collect { |i|
+      @engine.launch(Ruote.define { alpha })
+    }.sort
+
+    while @engine.storage_participant.size < n; sleep 0.140; end
+
+    assert_equal wfids, @engine.process_wfids
+
+    assert_equal(
+      wfids,
+      @engine.processes.collect { |ps| ps.wfid })
+
+    assert_equal(
+      wfids[0, 3],
+      @engine.processes(:limit => 3).collect { |ps| ps.wfid })
+
+    assert_equal(
+      wfids[3, 3],
+      @engine.processes(:skip => 3, :limit => 3).collect { |ps| ps.wfid })
+
+    #puts "==="
+    #wfids.each { |wfid| puts wfid }
+    #puts "---"
+    #@engine.processes(:limit => 3, :descending => false).collect { |ps| ps.wfid }.each { |wfid| puts wfid }
+    #puts "---"
+    #@engine.processes(:limit => 3, :descending => true).collect { |ps| ps.wfid }.each { |wfid| puts wfid }
+
+    assert_equal(
+      wfids.reverse[0, 3],
+      @engine.processes(
+        :limit => 3, :descending => true
+      ).collect { |ps| ps.wfid })
+
+    assert_equal(
+      n,
+      @engine.processes(:count => true))
+  end
+
+  # Issue identified by David Goodlad :
+  #
+  # http://gist.github.com/600451
+  #
+  def test_ps_and_schedules
+
+    pdef = Ruote.define do
+      concurrence do
+        wait '4h'
+        wait '2h'
+      end
+    end
+
+    @engine.launch(pdef)
+
+    sleep 0.400
+
+    assert_equal 1, @engine.processes.size
+  end
 end
 

data/test/functional/ft_20_storage_participant.rb

@@ -180,6 +180,8 @@ class FtStorageParticipantTest < Test::Unit::TestCase
     assert_equal 2, @part.query('place' => 'heiankyou', :limit => 2).size
     assert_equal 4, @part.query('place' => 'heiankyou', :limit => 20).size
 
+    assert_equal 4, @part.query(:count => true)
+
     page0 =
       @part.query('place' => 'heiankyou', :limit => 2).collect { |wi|
         "#{wi.fei.wfid}-#{wi.participant_name}" }
@@ -309,5 +311,17 @@ class FtStorageParticipantTest < Test::Unit::TestCase
     assert_equal wi, sp[wi.fei.to_h]
     assert_equal wi, sp[wi.fei.to_storage_id]
   end
+
+  def test_engine_storage_participant
+
+    @engine.register_participant 'step_.*', Ruote::StorageParticipant
+
+    wfid = @engine.launch(Ruote.process_definition { step_one })
+
+    wait_for(:step_one)
+
+    assert_equal 1, @engine.storage_participant.size
+    assert_equal 'step_one', @engine.storage_participant.first.participant_name
+  end
 end
 

data/test/functional/ft_24_block_participants.rb

@@ -62,7 +62,7 @@ class FtBlockParticipantTest < Test::Unit::TestCase
   def test_non_jsonfiable_result
 
     return if Ruote::WIN
-      # defective 'json' lib on windows render this test useless
+      # defective 'json' lib on windows renders this test useless
 
     t = Time.now
 

data/test/functional/ft_26_participant_timeout.rb

@@ -45,5 +45,98 @@ class FtParticipantTimeoutTest < Test::Unit::TestCase
 
     assert_not_nil bravo.first.fields['__timed_out__']
   end
+
+  class MyParticipant
+    include Ruote::LocalParticipant
+    def consume (workitem)
+      # do nothing
+    end
+    def cancel (fei, flavour)
+      # do nothing
+    end
+    def timeout
+      '1s'
+    end
+    def do_not_thread
+      true
+    end
+  end
+
+  def test_participant_class_defined_timeout
+
+    pdef = Ruote.define do
+      alpha
+      echo 'done.'
+    end
+
+    @engine.register_participant :alpha, MyParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(wfid)
+
+    assert_equal 'done.', @tracer.to_s
+    assert_equal 2, logger.log.select { |e| e['flavour'] == 'timeout' }.size
+  end
+
+  def test_pdef_overriden_timeout
+
+    # process definition cancels timeout given by participant
+
+    pdef = Ruote.define do
+      alpha :timeout => ''
+      echo 'done.'
+    end
+
+    @engine.register_participant :alpha, MyParticipant
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:alpha)
+
+    sleep 0.350
+
+    assert_equal 0, @engine.storage.get_many('schedules').size
+    assert_equal '', @tracer.to_s
+  end
+
+  class MyOtherParticipant
+    include Ruote::LocalParticipant
+    def initialize (opts)
+      @opts = opts
+    end
+    def consume (workitem)
+      # do nothing
+    end
+    def cancel (fei, flavour)
+      # do nothing
+    end
+    def timeout
+      @opts['timeout']
+    end
+  end
+
+  def test_participant_option_defined_timeout
+
+    pdef = Ruote.define do
+      alpha
+      bravo
+      echo 'done.'
+    end
+
+    @engine.register_participant :alpha, MyOtherParticipant, 'timeout' => '1s'
+    @engine.register_participant :bravo, MyOtherParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:bravo)
+
+    assert_equal 0, @engine.storage.get_many('schedules').size
+      # no timeout for participant :bravo
+  end
 end
 

data/test/functional/ft_2_errors.rb

@@ -19,8 +19,6 @@ class FtErrorsTest < Test::Unit::TestCase
       nada
     end
 
-    #noisy
-
     wfid = @engine.launch(pdef)
     wait_for(wfid)
 
@@ -49,7 +47,7 @@ class FtErrorsTest < Test::Unit::TestCase
 
     ps = @engine.process(wfid)
 
-    exp = ps.expressions.find { |fe| fe.class == Ruote::Exp::RawExpression }
+    exp = ps.expressions.find { |fe| fe.class == Ruote::Exp::RefExpression }
 
     assert_not_nil exp
 
@@ -115,7 +113,7 @@ class FtErrorsTest < Test::Unit::TestCase
     ps = @engine.process(wfid)
 
     err = ps.errors.first
-    assert_equal [ 'nada', {}, [] ], err.tree
+    assert_equal [ 'nada', { 'ref' => 'nada' }, [] ], err.tree
 
     err.tree = [ 'alpha', {}, [] ]
     @engine.replay_at_error(err)
@@ -339,26 +337,35 @@ class FtErrorsTest < Test::Unit::TestCase
     assert_nil @engine.process(wfid)
   end
 
-  def test_ps_to_h
+  #def test_ps_to_h
+  #  pdef = Ruote.process_definition do
+  #    error 'nada'
+  #  end
+  #  #noisy
+  #  wfid = @engine.launch(pdef)
+  #  wait_for(wfid)
+  #  ps = @engine.process(wfid)
+  #  es = ps.to_h['errors']
+  #  e = es.first
+  #  assert_equal 1, es.size
+  #  assert_equal 'reply', e['msg']['action']
+  #  assert_equal wfid, e['msg']['fei']['wfid']
+  #  assert_equal 8, e.size
+  #end
+
+  def test_error_intercepted
 
     pdef = Ruote.process_definition do
-      error 'nada'
+      nada
     end
 
-    #noisy
-
     wfid = @engine.launch(pdef)
-    wait_for(wfid)
-
-    ps = @engine.process(wfid)
 
-    es = ps.to_h['errors']
-    e = es.first
+    r = @engine.wait_for(wfid)
 
-    assert_equal 1, es.size
-    assert_equal 'reply', e['msg']['action']
-    assert_equal wfid, e['msg']['fei']['wfid']
-    assert_equal 8, e.size
+    assert_equal 'RuntimeError', r['error_class']
+    assert_equal "unknown participant or subprocess 'nada'", r['error_message']
+    assert_equal Array, r['error_backtrace'].class
   end
 end
 

data/test/functional/ft_30_smtp_participant.rb

@@ -80,7 +80,9 @@ class NftSmtpParticipantTest < Test::Unit::TestCase
       end
     end
 
-    trapfile = Ruote::WIN ? 'ruote_mailtrap.txt' : '/tmp/ruote_mailtrap.txt'
+    trapfile = "ruote_mailtrap_#{$$}_#{Time.now.to_f}.txt"
+
+    trapfile = Ruote::WIN ? trapfile : "/tmp/#{trapfile}"
     FileUtils.rm_f(trapfile)
 
     t = Thread.new do
@@ -108,7 +110,10 @@ class NftSmtpParticipantTest < Test::Unit::TestCase
     #sleep 0.450
     wait_for(wfid)
 
-    assert_match(/want cat food/, File.read(trapfile))
+    trapped = File.read(trapfile)
+    FileUtils.rm_f(trapfile)
+
+    assert_match /want cat food/, trapped
     assert_nil @engine.process(wfid)
 
     t.kill

data/test/functional/ft_38_participant_more.rb

@@ -30,6 +30,8 @@ class FtParticipantMoreTest < Test::Unit::TestCase
     end
   end
 
+  # Reject and re_dispatch are aliases.
+  #
   def test_participant_reject
 
     pdef = Ruote.process_definition do
@@ -59,6 +61,8 @@ class FtParticipantMoreTest < Test::Unit::TestCase
     end
   end
 
+  # Reject and re_dispatch are aliases.
+  #
   def test_participant_re_dispatch
 
     pdef = Ruote.process_definition do
@@ -92,6 +96,11 @@ 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).
+  #
   def test_participant_re_dispatch_later
 
     pdef = Ruote.process_definition do
@@ -112,6 +121,9 @@ class FtParticipantMoreTest < Test::Unit::TestCase
     assert t < 2.0, "took more than 1.99 second"
   end
 
+  # Making sure that when a process gets cancelled, its 'later' re-dispatches
+  # are cancelled as well.
+  #
   def test_participant_re_dispatch_later_cancel
 
     pdef = Ruote.process_definition do
@@ -146,6 +158,9 @@ class FtParticipantMoreTest < Test::Unit::TestCase
     end
   end
 
+  # Stashing lets a stateless participant 'stash' state via put() and get()
+  # into the engine.
+  #
   def test_stash
 
     BLACKBOARD.clear

data/test/functional/ft_39_wait_for.rb

@@ -10,7 +10,7 @@ require File.join(File.dirname(__FILE__), 'base')
 require 'ruote/part/storage_participant'
 
 
-class FtEngineTest < Test::Unit::TestCase
+class FtWaitForTest < Test::Unit::TestCase
   include FunctionalBase
 
   def test_workitem
@@ -96,5 +96,38 @@ class FtEngineTest < Test::Unit::TestCase
 
     assert_equal wfids.sort, @engine.processes.collect { |ps| ps.wfid }.sort
   end
+
+  def test_wait_for_multithreaded
+
+    pdef = Ruote.process_definition { alpha }
+
+    sp = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    seen = []
+
+    Thread.new do
+      @engine.wait_for(wfid)
+      seen << 'this'
+    end
+    Thread.new do
+      @engine.wait_for(wfid)
+      seen << 'that'
+    end
+
+    @engine.wait_for(:alpha)
+
+    sp.reply(sp.first)
+
+    @engine.wait_for(wfid)
+
+    sleep 0.100
+
+    assert_equal %w[ that this ], seen.sort
+    assert_equal [], @engine.context.logger.instance_variable_get(:@waiting)
+  end
 end