ruote 0.9.20 → 2.1.1

data/test/functional/ft_35_add_service.rb

@@ -0,0 +1,48 @@
+
+#
+# testing ruote
+#
+# Thu Dec 24 18:05:39 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtAddServiceTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class MyService
+
+    attr_reader :context, :options
+
+    def initialize (context, options={})
+
+      @context = context
+      @options = options
+    end
+  end
+
+  def test_as_path_class
+
+    @engine.add_service('toto', 'ruote', 'FtAddServiceTest::MyService')
+
+    assert_equal MyService, @engine.context.toto.class
+  end
+
+  def test_as_instance
+
+    @engine.add_service('toto', MyService.new(nil))
+
+    assert_equal MyService, @engine.context.toto.class
+  end
+
+  def test_as_path_class_options
+
+    @engine.add_service(
+      'toto', 'ruote', 'FtAddServiceTest::MyService', 'colour' => 'blue')
+
+    assert_equal MyService, @engine.context.toto.class
+    assert_equal 'blue', @engine.context.toto.options['colour']
+  end
+end
+

data/test/functional/ft_3_participant_registration.rb

@@ -0,0 +1,107 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# Mon May 18 22:25:57 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtParticipantRegistrationTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_participant_register
+
+    #noisy
+
+    @engine.register_participant :alpha do |workitem|
+      @tracer << 'alpha'
+    end
+
+    wait_for(1)
+
+    msg = logger.log.last
+    assert_equal 'participant_registered', msg['action']
+    assert_equal 'alpha', msg['regex']
+
+    assert_equal(
+      [ 'inpa_:alpha' ],
+      @engine.context.plist.instantiated_participants.collect { |e| e.first })
+  end
+
+  def test_double_registration
+
+    @engine.register_participant :alpha do |workitem|
+      @tracer << 'alpha'
+    end
+    @engine.register_participant :alpha do |workitem|
+      @tracer << 'alpha'
+    end
+
+    assert_equal 1, @engine.context.plist.send(:get_list)['list'].size
+  end
+
+  def test_register_and_return_participant
+
+    pa = @engine.register_participant :alpha do |workitem|
+    end
+
+    assert_kind_of Ruote::BlockParticipant, pa
+  end
+
+  def test_participant_unregister_by_name
+
+    #noisy
+
+    @engine.register_participant :alpha do |workitem|
+    end
+
+    @engine.unregister_participant :alpha
+
+    wait_for(2)
+    Thread.pass
+
+    msg = logger.log.last
+    assert_equal 'participant_unregistered', msg['action']
+    assert_equal '^alpha$', msg['regex']
+
+    assert_equal 0, @engine.context.plist.instantiated_participants.size
+  end
+
+  def test_participant_unregister
+
+    pa = @engine.register_participant :alpha do |workitem|
+    end
+
+    @engine.unregister_participant pa
+
+    wait_for(2)
+
+    msg = logger.log.last
+    assert_equal 'participant_unregistered', msg['action']
+    assert_equal '^alpha$', msg['regex']
+
+    assert_equal 0, @engine.context.plist.instantiated_participants.size
+  end
+
+  class MyParticipant
+    attr_reader :down
+    def initialize
+      @down = false
+    end
+    def shutdown
+      @down = true
+    end
+  end
+
+  def test_participant_shutdown
+
+    alpha = @engine.register_participant :alpha, MyParticipant.new
+
+    @engine.context.plist.shutdown
+
+    assert_equal true, alpha.down
+  end
+end
+

data/test/functional/ft_4_cancel.rb

@@ -0,0 +1,72 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# Wed Jun  3 08:42:07 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/hash_participant'
+
+
+class FtCancelTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_cancel_process
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(:alpha)
+
+    ps = @engine.process(wfid)
+    assert_equal 1, alpha.size
+
+    assert_not_nil ps
+
+    @engine.cancel_process(wfid)
+
+    wait_for(wfid)
+    ps = @engine.process(wfid)
+
+    assert_nil ps
+    assert_equal 0, alpha.size
+
+    #puts; logger.log.each { |e| p e['action'] }; puts
+    assert_equal 1, logger.log.select { |e| e['action'] == 'cancel_process' }.size
+    assert_equal 2, logger.log.select { |e| e['action'] == 'cancel' }.size
+  end
+
+  def test_cancel_expression
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+        bravo
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    bravo = @engine.register_participant :bravo, Ruote::HashParticipant.new
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(:alpha)
+
+    wi = alpha.first
+
+    @engine.cancel_expression(wi.fei)
+    wait_for(:bravo)
+
+    assert_not_nil bravo.first
+  end
+end
+

data/test/functional/ft_5_on_error.rb

@@ -0,0 +1,155 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# Tue Jun  2 18:48:02 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtOnErrorTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_on_error
+
+    pdef = Ruote.process_definition do
+      sequence :on_error => 'catcher' do
+        nada
+      end
+    end
+
+    @engine.register_participant :catcher do
+      @tracer << "caught\n"
+    end
+
+    #noisy
+
+    assert_trace(pdef, 'caught')
+
+    assert_equal 1, logger.log.select { |e| e['action'] == 'fail' }.size
+  end
+
+  def test_on_error_neutralization
+
+    pdef = Ruote.process_definition do
+      sequence :on_error => 'catcher' do
+        sequence :on_error => '' do
+          nada
+        end
+      end
+    end
+
+    @engine.register_participant :catcher do
+      @tracer << "caught\n"
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+    ps = @engine.process(wfid)
+
+    assert_equal(1, ps.errors.size)
+  end
+
+  def test_on_error_redo
+
+    pdef = Ruote.process_definition do
+      sequence :on_error => :redo do
+        troublemaker
+      end
+    end
+
+    hits = 0
+
+    @engine.register_participant :troublemaker do
+      hits += 1
+      @tracer << "#{hits.to_s}\n"
+      raise 'Houston, we have a problem !' if hits == 1
+      @tracer << 'done.'
+    end
+
+    #noisy
+
+    assert_trace(pdef, %w[ 1 2 done. ])
+  end
+
+  def test_on_error_undo
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'a'
+        sequence :on_error => :undo do
+          echo 'b'
+          nemo
+          echo 'c'
+        end
+        echo 'd'
+      end
+    end
+
+    #noisy
+
+    wfid = assert_trace(pdef, %w[ a b d ])
+
+    assert_nil @engine.process(wfid)
+  end
+
+  def test_missing_handler_triggers_regular_error
+
+    pdef = Ruote.process_definition :on_error => 'failpath' do
+      nemo
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+    ps = @engine.process(wfid)
+
+    assert_equal 1, ps.errors.size
+
+    assert_equal 1, logger.log.select { |e| e['action'] == 'error_intercepted' }.size
+  end
+
+  def test_on_error_at_process_level
+
+    pdef = Ruote.process_definition :on_error => 'failpath' do
+      nemo
+      define :failpath do
+        echo 'failed.'
+      end
+    end
+
+    #noisy
+
+    assert_trace(pdef, 'failed.')
+  end
+
+  def test_with_concurrence
+
+    pdef = Ruote.process_definition do
+      sequence do
+        concurrence :on_error => 'emil' do
+          alpha
+          error 'nada0'
+          error 'nada1'
+        end
+        echo 'done.'
+      end
+    end
+
+    a_count = 0
+    e_count = 0
+    @engine.register_participant(:alpha) { |wi| a_count += 1 }
+    @engine.register_participant(:emil) { |wi| e_count += 1 }
+
+    #noisy
+
+    assert_trace pdef, 'done.'
+    assert_equal 1, a_count
+    assert_equal 1, e_count
+  end
+end
+

data/test/functional/ft_6_on_cancel.rb

@@ -0,0 +1,165 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# Wed Jun  3 21:52:09 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/hash_participant'
+
+
+class FtOnCancelTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_on_cancel
+
+    pdef = Ruote.process_definition do
+      sequence :on_cancel => 'catcher' do
+        nemo
+      end
+    end
+
+    nemo = @engine.register_participant :nemo, Ruote::HashParticipant
+
+    @engine.register_participant :catcher do
+      @tracer << "caught\n"
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(:nemo)
+
+    @engine.cancel_process(wfid)
+    wait_for(wfid)
+
+    assert_equal 'caught', @tracer.to_s
+  end
+
+  def test_on_cancel_missing_handler
+
+    pdef = Ruote.process_definition do
+      sequence :on_cancel => 'nada' do
+        nemo
+      end
+    end
+
+    nemo = @engine.register_participant :nemo, Ruote::HashParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(:nemo)
+
+    @engine.cancel_process(wfid)
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+    assert_not_nil ps
+
+    #logger.log.each { |e| puts e['action'] }
+    assert_equal(
+      1, logger.log.select { |e| e['action'] == 'error_intercepted' }.size)
+  end
+
+  def test_on_cancel_trigger_subprocess
+
+    pdef = Ruote.process_definition do
+      sequence :on_cancel => 'decommission' do
+        alpha
+      end
+      define 'decommission' do
+        sequence do
+          echo 'd0'
+          echo 'd1'
+        end
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::HashParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    assert_equal '', @tracer.to_s
+
+    @engine.cancel_process(wfid)
+
+    wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+
+    assert_equal "d0\nd1", @tracer.to_s
+  end
+
+  def test_on_cancel_expression
+
+    pdef = Ruote.process_definition do
+      sequence :on_cancel => 'decom' do
+        alpha
+      end
+      define 'decom' do
+        bravo
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    bravo = @engine.register_participant :bravo, Ruote::HashParticipant.new
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    fei = alpha.first.fei.dup
+    fei.h['expid'] = '0_1'
+    @engine.cancel_expression(fei)
+
+    wait_for(:bravo)
+
+    assert_equal 1, bravo.size
+  end
+
+  def test_on_cancel_subprocess
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence :on_cancel => 'sub0' do
+        alpha
+      end
+      define 'sub0' do
+        bravo
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::HashParticipant
+    bravo = @engine.register_participant :bravo, Ruote::HashParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    @engine.cancel_process(wfid)
+
+    wait_for(:bravo)
+
+    assert_equal(
+      ["define", {"name"=>"test"}, [
+        ["define", {"sub0"=>nil}, [["bravo", {}, []]]],
+        ["sequence", {"on_cancel"=>"sub0"}, [["alpha", {}, []]]]]],
+      @engine.process(wfid).original_tree)
+    assert_equal(
+      ["define", {"name"=>"test"}, [
+        ["define", {"sub0"=>nil}, [["participant", {"ref"=>"bravo"}, []]]],
+        ["sequence", {"on_cancel"=>"sub0", "_triggered"=>"on_cancel"}, [["alpha", {}, []]]]]],
+      @engine.process(wfid).current_tree)
+  end
+end
+