ruote 0.9.20 → 2.1.1

data/test/functional/concurrent_base.rb

@@ -0,0 +1,91 @@
+
+#
+# Testing ruote
+#
+# Fri Dec  4 17:15:10 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base.rb')
+
+
+class Ruote::Worker
+
+  def step_by_one
+    msg = @storage.get_msgs.first
+    #p [ msg['action'], msg['fei'] ]
+    if msg
+      process(msg)
+    else
+      false
+    end
+  end
+
+  public :process
+
+  def step_until (&block)
+    loop do
+      msg = @storage.get_msgs.first
+      return msg if block.call(msg)
+      process(msg)
+    end
+  end
+end
+
+class Ruote::Engine
+  def step (count=1)
+    count.times { @context.worker.step_by_one }
+  end
+  def step!
+    r = @context.worker.step_by_one
+    step! if r == false
+  end
+  def walk
+    while @context.worker.step_by_one do; end
+  end
+  def do_step (msg)
+    @context.worker.process(msg)
+  end
+  def step_until (&block)
+    @context.worker.step_until(&block)
+  end
+end
+
+
+module ConcurrentBase
+
+  def setup
+
+    @storage = determine_storage(
+      's_logger' => [ 'ruote/log/test_logger', 'Ruote::TestLogger' ])
+
+    @engine0 = Ruote::Engine.new(Ruote::Worker.new(@storage), false)
+    @engine1 = Ruote::Engine.new(Ruote::Worker.new(@storage), false)
+      #
+      # the 2 engines are set with run=false
+
+    @tracer0 = Tracer.new
+    @tracer1 = Tracer.new
+
+    @engine0.context.add_service('s_tracer', @tracer0, nil)
+    @engine1.context.add_service('s_tracer', @tracer1, nil)
+
+    @engine1.context.logger.color = '32' # green
+  end
+
+  def teardown
+
+    @storage.purge!
+
+    @engine0.shutdown
+    @engine1.shutdown
+  end
+
+  protected
+
+  def noisy
+
+    @engine0.context.logger.noisy = true
+    @engine1.context.logger.noisy = true
+  end
+end
+

data/test/functional/crunner.rb

@@ -0,0 +1,26 @@
+
+pers = ARGV.find { |a| a.match(/^--/) } || ''
+
+i = 0
+
+loop do
+
+  #s = `ruby test/functional/ct_0_concurrence.rb #{pers}`
+  #s = `ruby test/functional/ct_1_iterator.rb #{pers}`
+  s = `ruby test/functional/ct_2_cancel.rb #{pers}`
+
+  if $? != 0
+    puts
+    puts s
+  else
+    if (i % 5) == 0
+      print i.to_s
+    else
+      print '.'
+    end
+    STDOUT.flush
+  end
+
+  i = i + 1
+end
+

data/test/functional/ct_0_concurrence.rb

@@ -0,0 +1,68 @@
+
+#
+# testing ruote
+#
+# Wed Jul  8 15:30:55 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'concurrent_base')
+
+#require 'ruote/part/hash_participant'
+
+
+class CtConcurrenceTest < Test::Unit::TestCase
+  include ConcurrentBase
+
+  def test_collision
+
+    pdef = Ruote.process_definition do
+      concurrence do
+        echo 'a'
+        echo 'b'
+      end
+    end
+
+    #noisy
+
+    wfid = @engine0.launch(pdef)
+    @engine0.step 4
+
+    $stderr.puts "*cough*" if @storage.get_msgs.size != 2
+
+    t0 = Thread.new { @engine1.step! }
+    t1 = Thread.new { @engine0.step! }
+    t0.join
+    t1.join
+
+    #t0 = Thread.new { @engine1.step }
+    #@engine0.step
+    #t0.join
+
+    msgs = @storage.get_msgs
+    msg = msgs.first
+
+    if msgs.size > 1 || (msg['fei'] && msg['fei']['expid'] != '0')
+
+      msgs.each do |m|
+
+        fei = m['fei'] ?
+          Ruote::FlowExpressionId.to_s_id(m['fei']) : ''
+        wi_fei = m['workitem'] ?
+          Ruote::FlowExpressionId.to_s_id(m['workitem']['fei']) : ''
+
+        p [ m['action'], fei, wi_fei ]
+      end
+    end
+
+    if msg['action'] == 'error_intercepted'
+      #p @engine0.process(wfid).errors.first
+      puts @engine0.process(wfid).errors.first.message
+      puts @engine0.process(wfid).errors.first.trace
+    end
+
+    assert_equal 1, msgs.size
+    assert_equal 'reply', msg['action']
+    assert_equal '0', msg['fei']['expid']
+  end
+end
+

data/test/functional/ct_1_iterator.rb

@@ -0,0 +1,61 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# Mon Dec  7 13:54:18 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'concurrent_base')
+
+
+class CtIteratorTest < Test::Unit::TestCase
+  include ConcurrentBase
+
+  def test_collision
+
+    pdef = Ruote.process_definition do
+      concurrence do
+        iterator :on => (1..10).to_a, :tag => 'it' do
+          echo '${v:i}'
+        end
+        sequence do
+          sequence do
+            stop :ref => 'it'
+          end
+        end
+      end
+    end
+
+    #noisy
+
+    wfid = @engine0.launch(pdef)
+
+    #@engine0.step 11
+    msg = @engine0.step_until { |msg| msg['command'] != nil }
+
+    assert_equal 'stop', msg['command'].first
+    assert_equal '0_0_0', msg['fei']['expid']
+
+    msgs = @storage.get_msgs
+
+    assert_equal 3, msgs.size
+
+    msgs = msgs - [ msg ]
+
+    assert_equal 2, msgs.size
+
+    msg1 = msgs.first
+
+    t0 = Thread.new { @engine1.do_step(msg) }
+    t1 = Thread.new { @engine0.do_step(msg1) }
+    t0.join
+    t1.join
+
+    #@engine0.step 4
+    @engine1.walk
+
+    assert_equal "1\n2", @tracer0.to_s
+    assert_equal "", @tracer1.to_s
+  end
+end
+

data/test/functional/ct_2_cancel.rb

@@ -0,0 +1,69 @@
+
+#
+# testing ruote
+#
+# Mon Dec 28 19:13:02 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'concurrent_base')
+
+
+class CtCancelTest < Test::Unit::TestCase
+  include ConcurrentBase
+
+  def test_collision
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+      end
+    end
+
+    alpha = @engine0.register_participant :alpha do |workitem|
+      # let reply immediately
+    end
+
+    #noisy
+
+    wfid = @engine0.launch(pdef)
+
+    @engine0.step 6
+
+    @engine1.cancel_expression(
+      { 'engine_id' => 'engine', 'wfid' => wfid, 'expid' => '0_0' })
+
+    msgs = nil
+    loop do
+      msgs = @storage.get_msgs
+      break if msgs.size == 2
+      #p msgs.collect { |m| m['fei']['expid'] }.uniq
+      #break if
+      #  msgs.size == 2 &&
+      #  msgs.collect { |m| m['fei']['expid'] }.uniq == %w[ 0_0 ]
+    end
+
+    #msgs.each { |m| p m }
+    #puts
+
+    t1 = Thread.new { @engine0.do_step(msgs[1]) }
+    t0 = Thread.new { @engine1.do_step(msgs[0]) }
+    t1.join
+    t0.join
+
+    #puts
+
+    @engine0.step 4
+
+    sleep 0.010
+
+    assert_equal 0, @storage.get_msgs.size
+
+    exps = @storage.get_many('expressions')
+    exps.each { |exp|
+      p [ exp['fei']['expid'], exp['original_tree'] ]
+    } if exps.size > 0
+
+    assert_equal 0, exps.size
+  end
+end
+

data/test/functional/eft_0_process_definition.rb

@@ -2,33 +2,64 @@
 #
 # Testing Ruote (OpenWFEru)
 #
-# John Mettraux at openwfe.org
-#
 # Sat Jan 24 22:40:35 JST 2009
 #
 
-require File.dirname(__FILE__) + '/base'
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/hash_participant'
 
 
 class EftProcessDefinitionTest < Test::Unit::TestCase
   include FunctionalBase
 
-  class Test0 < OpenWFE::ProcessDefinition
-  end
-  def test_empty_procdef_0
-    assert_trace(Test0, '')
+  def test_empty_procdef
+
+    assert_trace(
+      Ruote.define(:name => 'test_1') { },
+      '')
   end
 
-  def test_empty_procdef_1
-    assert_trace(OpenWFE.process_definition(:name => 'test_1') { }, '')
+  def test_sub_definition
+
+    pdef = Ruote.process_definition :name => 'main' do
+      define :name => 'sub0' do
+      end
+      participant :ref => :alpha
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::HashParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    ps = @engine.process(wfid)
+
+    assert_equal(
+      {"sub0"=> ["0_0", ["define", {"name"=>"sub0"}, []]],
+       "main"=> ["0", ["define", {"name"=>"main"}, [["define", {"name"=>"sub0"}, []], ["participant", {"ref"=>"alpha"}, []]]]]},
+      ps.variables)
   end
 
-  def test_empty_procdef_xml
-    assert_trace(%{
-<process-definition name="test">
-</process-definition>
-      },
-      '')
+  #def test_define_implicit_name
+  #  pdef = Ruote.define 'accounting_process' do
+  #  end
+  #  assert_equal 'accounting_process', pdef[1]['name']
+  #end
+
+  def test_sub_define_implicit_name
+
+    pdef = Ruote.define 'accounting_process' do
+      define 'sub0' do
+      end
+    end
+
+    assert_equal(
+      ["define", {"accounting_process"=>nil}, [["define", {"sub0"=>nil}, []]]],
+      pdef)
   end
 end
 

data/test/functional/eft_10_cancel_process.rb

@@ -0,0 +1,46 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# Mon Jun 15 21:18:06 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftCancelProcessTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_cancel_process
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'a'
+        cancel_process
+        echo 'b'
+      end
+    end
+
+    #noisy
+
+    assert_trace(pdef, 'a')
+
+    #assert_equal 3, logger.log.select { |e| e[1] == :entered_tag }.size
+  end
+
+  def test_unless
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'a'
+        cancel_process :unless => 'true == true'
+        echo 'b'
+      end
+    end
+
+    #noisy
+
+    assert_trace(pdef, "a\nb")
+  end
+end
+