ruote 0.9.20 → 2.1.1

data/test/functional/ft_7_tags.rb

@@ -0,0 +1,88 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# Wed Jun 10 11:03:26 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/hash_participant'
+
+
+class FtTagsTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_tag
+
+    pdef = Ruote.process_definition do
+      sequence :tag => 'main' do
+        alpha :tag => 'part'
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(:alpha)
+
+    ps = @engine.process(wfid)
+
+    #p ps.variables
+    #ps.expressions.each { |e| p [ e.fei, e.variables ] }
+    assert_equal '0_0', ps.variables['main']['expid']
+    assert_equal '0_0_0', ps.variables['part']['expid']
+
+    #logger.log.each { |e| puts e['action'] }
+    assert_equal 2, logger.log.select { |e| e['action'] == 'entered_tag' }.size
+
+    alpha.reply(alpha.first)
+    wait_for(wfid)
+
+    assert_equal 2, logger.log.select { |e| e['action'] == 'left_tag' }.size
+  end
+
+  # making sure a tag is removed in case of on_cancel
+  #
+  def test_on_cancel
+
+    pdef = Ruote.process_definition do
+      sequence do
+        sequence :tag => 'a', :on_cancel => 'decom' do
+          alpha
+        end
+        alpha
+      end
+      define 'decom' do
+        alpha
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    assert_equal 1, @engine.process(wfid).tags.size
+
+    fei = alpha.first.fei.dup
+    fei.h['expid'] = '0_1_0'
+    @engine.cancel_expression(fei)
+
+    wait_for(:alpha)
+
+    assert_equal 0, @engine.process(wfid).tags.size
+
+    alpha.reply(alpha.first)
+
+    wait_for(:alpha)
+
+    assert_equal 0, @engine.process(wfid).tags.size
+  end
+end
+

data/test/functional/ft_8_participant_consumption.rb

@@ -0,0 +1,75 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# Wed Jun 10 11:03:26 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtParticipantConsumptionTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_workitems_dispatching_message
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+      end
+    end
+
+    @engine.register_participant :alpha do |workitem|
+      @tracer << "#{workitem.participant_name}\n"
+    end
+
+    #noisy
+
+    assert_trace(pdef, 'alpha')
+
+    Thread.pass
+      # making sure the reply to the participant expression is intercepted
+      # as well
+
+    assert_equal(
+      2, logger.log.select { |e| e['participant_name'] == 'alpha' }.size)
+  end
+
+  def test_missing_participant_name
+
+    pdef = Ruote.process_definition do
+      sequence do
+        participant
+      end
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    assert_equal(
+      1, ps.errors.size)
+    assert_equal(
+      '#<ArgumentError: no participant name specified>', ps.errors[0].message)
+  end
+
+  def test_dot_star
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+      end
+    end
+
+    @engine.register_participant '.*' do |workitem|
+      @tracer << "#{workitem.participant_name} #{workitem.fei.expid}\n"
+    end
+
+    assert_trace(pdef, 'alpha 0_0_0')
+  end
+end
+

data/test/functional/ft_9_subprocesses.rb

@@ -0,0 +1,145 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# Wed Jun 10 17:41:23 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/hash_participant'
+
+
+class FtSubprocessesTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_subprocess_tree_lookup
+
+    pdef = Ruote.process_definition do
+      define 'sub0' do
+        bravo
+        echo 'result : ${v:nada}'
+      end
+      sequence do
+        bravo
+        sub0
+      end
+    end
+
+    bravo = @engine.register_participant :bravo, Ruote::HashParticipant.new
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(:bravo)
+
+    fexp = Ruote::Exp::FlowExpression.fetch(
+      @engine.context, bravo.first.fei.to_h)
+
+    assert_equal(
+      [ '0_0',
+        ['define', {'sub0'=>nil}, [['bravo', {}, []], ['echo', {'result : ${v:nada}'=>nil}, []]]] ],
+      fexp.lookup_variable('sub0'))
+
+    bravo.reply(bravo.first)
+    wait_for(:bravo)
+
+    fexp = Ruote::Exp::FlowExpression.fetch(
+      @engine.context, bravo.first.fei.to_h)
+
+    assert_equal(
+      ['define', {'sub0'=>nil}, [['bravo', {}, []], ['echo', {'result : ${v:nada}'=>nil}, []]]],
+      fexp.parent.tree)
+
+    #logger.log.each { |e| puts e['action'] }
+    assert_equal 2, logger.log.select { |e| e['action'] == 'launch' }.size
+  end
+
+  def test_next_sub_wfid
+
+    pdef = Ruote.process_definition do
+      sequence do
+        sub0 :forget => true
+        sub0 :forget => true
+      end
+      define 'sub0' do
+        sub1 :forget => true
+      end
+      define 'sub1' do
+        alpha
+      end
+    end
+
+    wfids = []
+
+    @engine.register_participant :alpha do |workitem|
+      wfids << workitem.fei.sub_wfid
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+    wait_for(:alpha)
+    wait_for(1)
+
+    assert_equal 2, wfids.sort.uniq.size
+  end
+
+  def test_cancel_and_subprocess
+
+    pdef = Ruote.process_definition do
+      sequence do
+        sub0
+      end
+      define 'sub0' do
+        alpha
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    assert_equal 1, alpha.size
+
+    @engine.cancel_process(wfid)
+
+    wait_for(wfid)
+
+    assert_equal 0, alpha.size
+  end
+
+  def test_cancel_and_engine_variable_subprocess
+
+    pdef = Ruote.process_definition do
+      sequence do
+        sub0
+      end
+    end
+
+    @engine.variables['sub0'] = Ruote.process_definition do
+      alpha
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    assert_equal 1, alpha.size
+
+    @engine.cancel_process(wfid)
+
+    wait_for(wfid)
+
+    assert_equal 0, alpha.size
+  end
+end
+

data/test/functional/restart_base.rb

@@ -1,43 +1,34 @@
 
 #
-# Testing Ruote (OpenWFEru)
+# testing ruote
 #
-# John Mettraux at openwfe.org
+# Wed Jul  1 23:27:49 JST 2009
 #
-# Wed Feb  4 10:16:34 JST 2009
-#
-
-require 'openwfe/engine'
-
-$in_memory_engine = false
 
 module RestartBase
 
-  def in_memory_engine
-
-    return true if $in_memory_engine
-    return false unless @engine.class == OpenWFE::Engine
+  def setup
+    @tracer = Tracer.new
+  end
 
-    $in_memory_engine = true
+  def teardown
+    @engine.shutdown
+    @storage.purge!
+  end
 
-    puts
-    puts "  skipping restart (rft_) tests : in-memory engine"
-    puts
+  protected
 
-    true
-  end
+  def start_new_engine
 
-  def restart_engine
+    @storage = determine_storage(
+      's_logger' => [ 'ruote/log/test_logger', 'Ruote::TestLogger' ],
+      :persistent => true)
 
-    ac = {
-      '__tracer' => @tracer,
-      :persist_as_yaml => @engine.ac[:persist_as_yaml],
-      :no_expstorage_cache => @engine.ac[:no_expstorage_cache]
-    }
+    @engine = Ruote::Engine.new(Ruote::Worker.new(@storage))
 
-    @engine = @engine.class.new(ac)
+    #@tracer.clear
 
-    @engine.reload # very important
+    @engine.add_service('tracer', @tracer)
   end
 end
 

data/test/functional/rt_0_wait.rb

@@ -0,0 +1,55 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# Wed Jul  1 23:22:26 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+require File.join(File.dirname(__FILE__), 'restart_base')
+
+
+class RtWaitTest < Test::Unit::TestCase
+  include FunctionalBase
+  include RestartBase
+
+  def test_wait_and_restart
+
+    start_new_engine
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        echo 'in'
+        wait '3d'
+        echo 'out.'
+      end
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(5)
+
+    assert_equal 1, @engine.processes.size
+    assert_equal 1, @engine.storage.get_many('schedules').size
+
+    @engine.shutdown
+
+    # restart...
+
+    start_new_engine
+
+    #noisy
+
+    assert_equal 1, @engine.processes.size
+    assert_equal 1, @engine.storage.get_many('schedules').size
+
+    @engine.cancel_process(wfid)
+
+    wait_for(wfid)
+
+    assert_equal 0, @engine.processes.size
+  end
+end
+

data/test/functional/rt_1_listen.rb

@@ -0,0 +1,56 @@
+
+#
+# testing ruote
+#
+# Thu Jul  2 12:51:54 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+require File.join(File.dirname(__FILE__), 'restart_base')
+
+
+require 'ruote/part/hash_participant'
+
+
+class RtListenTest < Test::Unit::TestCase
+  include FunctionalBase
+  include RestartBase
+
+  def test_listen_and_restart
+
+    start_new_engine
+
+    pdef = Ruote.process_definition do
+      concurrence do
+        sequence do
+          listen :to => '^al.*', :upon => 'reply'
+          echo 'done.'
+        end
+        alpha
+      end
+    end
+
+    #puts; noisy
+
+    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    assert_equal '', @tracer.to_s
+
+    @engine.shutdown
+
+    start_new_engine
+
+    #puts; noisy
+
+    @engine.reply(alpha.first)
+
+    wait_for(wfid)
+
+    assert_equal 'done.', @tracer.to_s
+  end
+end
+