ruote-maestrodev 2.2.1

data/test/functional/eft_13_iterator.rb

@@ -0,0 +1,342 @@
+
+#
+# testing ruote
+#
+# Mon Jun 29 09:35:48 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class EftIteratorTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_empty_iterator
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        iterator :on_val => 'alice, bob, charly', :to_var => 'v' do
+        end
+        echo 'done.'
+      end
+    end
+
+    #noisy
+
+    assert_trace('done.', pdef)
+  end
+
+  class TraceParticipant
+    include Ruote::LocalParticipant
+    def consume(wi)
+      context.tracer << "#{wi.participant_name}/#{wi.fei.expid}\n"
+      reply(wi)
+    end
+  end
+
+  def test_on_val
+
+    pdef = Ruote.process_definition :name => 'test' do
+      iterator :on_val => 'alice, bob, charly', :to_var => 'v' do
+        participant '${v:v}'
+      end
+    end
+
+    @engine.register_participant '.*', TraceParticipant
+
+    #noisy
+
+    assert_trace(%w[ alice/0_0_0 bob/0_0_0 charly/0_0_0 ], pdef)
+  end
+
+  def test_on__list
+
+    pdef = Ruote.process_definition :name => 'test' do
+      iterator :on => 'alice, bob, charly', :to_var => 'v' do
+        participant '${v:v}'
+      end
+    end
+
+    @engine.register_participant '.*', TraceParticipant
+
+    assert_trace(%w[ alice/0_0_0 bob/0_0_0 charly/0_0_0 ], pdef)
+  end
+
+  def test_on_f
+
+    pdef = Ruote.process_definition :name => 'test' do
+      set :f => 'people', :val => %w[ alice bob charly ]
+      iterator :on_f => 'people', :to_var => 'v' do
+        participant '${v:v}'
+      end
+    end
+
+    @engine.register_participant '.*', TraceParticipant
+
+    assert_trace(%w[ alice/0_1_0 bob/0_1_0 charly/0_1_0 ], pdef)
+  end
+
+  def test_on_nested_f
+
+    pdef = Ruote.process_definition :name => 'test' do
+      set 'f:data' => {}
+      set 'f:data.people' => %w[ alice bob charly ]
+      iterator :on_f => 'data.people', :to_var => 'v' do
+        participant '${v:v}'
+      end
+    end
+
+    @engine.register_participant '.*', TraceParticipant
+
+    assert_trace(%w[ alice/0_2_0 bob/0_2_0 charly/0_2_0 ], pdef)
+  end
+
+  def test_to_f
+
+    pdef = Ruote.process_definition :name => 'test' do
+      iterator :on_val => 'alice, bob, charly', :to_field => 'f' do
+        participant '${f:f}'
+      end
+    end
+
+    @engine.register_participant '.*' do |workitem|
+      @tracer << "#{workitem.fields['f']}/#{workitem.fei.expid}\n"
+    end
+
+    #noisy
+
+    assert_trace(%w[ alice/0_0_0 bob/0_0_0 charly/0_0_0 ], pdef)
+  end
+
+  def test_to
+
+    pdef = Ruote.process_definition :name => 'test' do
+      iterator :on_val => 'a, b', :to => 'x' do
+        echo '${f:x}'
+      end
+      iterator :on_val => 'c, d', :to => 'f:y' do
+        echo '${f:y}'
+      end
+      iterator :on_val => 'e, f', :to => 'v:z' do
+        echo '${v:z}'
+      end
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(wfid)
+
+    assert_equal %w[ a b c d e f ], @tracer.to_a
+  end
+
+  PDEF0 = Ruote.process_definition :name => 'test' do
+    sequence do
+      iterator :on_val => 'alice, bob, charly', :to_var => 'v' do
+        participant '${v:v}'
+      end
+      echo 'done.'
+    end
+  end
+
+  def test_break
+
+    @engine.register_participant '.*' do |workitem|
+
+      @tracer << "#{workitem.participant_name}\n"
+
+      if workitem.participant_name == 'bob'
+        workitem.fields['__command__'] = [ 'break', nil ]
+      end
+    end
+
+    #noisy
+
+    assert_trace(%w[ alice bob done. ], PDEF0)
+  end
+
+  def test_rewind
+
+    stash[:rewound] = false
+
+    @engine.register_participant '.*' do |workitem|
+
+      @tracer << "#{workitem.participant_name}\n"
+
+      if (not stash[:rewound]) and workitem.participant_name == 'bob'
+        stash[:rewound] = true
+        workitem.fields['__command__'] = [ 'rewind', nil ]
+      end
+    end
+
+    #noisy
+
+    assert_trace(%w[ alice bob alice bob charly done. ], PDEF0)
+  end
+
+  def test_skip
+
+    @engine.register_participant '.*' do |workitem|
+
+      @tracer << "#{workitem.participant_name}\n"
+
+      if workitem.participant_name == 'alice'
+        workitem.fields['__command__'] = [ 'skip', 1 ]
+      end
+    end
+
+    #noisy
+
+    assert_trace(%w[ alice charly done.], PDEF0)
+  end
+
+  def test_jump
+
+    @engine.register_participant '.*' do |workitem|
+
+      @tracer << "#{workitem.participant_name}\n"
+
+      if workitem.participant_name == 'alice'
+        workitem.fields['__command__'] = [ 'jump', -1 ]
+      end
+    end
+
+    #noisy
+
+    assert_trace(%w[ alice charly done.], PDEF0)
+  end
+
+  def test_skip_command
+
+    pdef = Ruote.process_definition :name => 'test' do
+      iterator :on_val => 'alice, bob, charly', :to_var => 'v' do
+        sequence do
+          participant '${v:v}'
+          skip 1, :if => '${v:v} == alice'
+        end
+      end
+    end
+
+    @engine.register_participant '.*' do |workitem|
+      @tracer << "#{workitem.participant_name}/#{workitem.fei.expid}\n"
+    end
+
+    #noisy
+
+    assert_trace(%w[ alice/0_0_0_0 charly/0_0_0_0 ], pdef)
+  end
+
+  def test_break_if
+
+    pdef = Ruote.process_definition :name => 'test' do
+      iterator :on_val => 'a, b, c', :to_var => 'v', :break_if => '${v:v} == b' do
+        participant '${v:v}'
+      end
+    end
+
+    @engine.register_participant '.*' do |workitem|
+      @tracer << "#{workitem.participant_name}/#{workitem.fei.expid}\n"
+    end
+
+    #noisy
+
+    assert_trace(%w[ a/0_0_0 b/0_0_0 ], pdef)
+  end
+
+  def test_break_unless
+
+    pdef = Ruote.process_definition :name => 'test' do
+      set :var => 'v', :val => 'a'
+      iterator :on_val => 'a, b, c', :to_var => 'v', :break_unless => '${v:v} == a' do
+        participant '${v:v}'
+      end
+    end
+
+    @engine.register_participant '.*' do |workitem|
+      @tracer << "#{workitem.participant_name}/#{workitem.fei.expid}\n"
+    end
+
+    #noisy
+
+    assert_trace(%w[ a/0_1_0 b/0_1_0 ], pdef)
+  end
+
+  def test_iterator_with_hash_as_input
+
+    pdef = Ruote.process_definition :name => 'test' do
+      iterator :on_val => { 'a' => 'A', 'b' => 'B' }, :to_f => 'f' do
+        p1
+      end
+    end
+
+    @engine.register_participant :p1 do |wi|
+      @tracer << wi.fields['f'].join(':')
+      @tracer << "\n"
+    end
+
+    #noisy
+
+    assert_trace %w[ a:A b:B ], pdef
+  end
+
+  def test_implicit_i_variable
+
+    pdef = Ruote.process_definition :name => 'test' do
+      iterator :on_val => 'alice, bob, charly' do
+        participant '${v:i}:${v:ii}'
+      end
+    end
+
+    @engine.register_participant '.*' do |workitem|
+      @tracer << "#{workitem.participant_name}/#{workitem.fei.expid}\n"
+    end
+
+    #noisy
+
+    assert_trace(%w[ alice:0/0_0_0 bob:1/0_0_0 charly:2/0_0_0 ], pdef)
+  end
+
+  def test_nested_break
+
+    pdef = Ruote.process_definition :name => 'test' do
+      iterator :on => 'a, b, c', :tag => 'it' do
+        sequence do
+          echo '0_${v:i}'
+          cursor do
+            echo '1_${v:i}'
+            _break :ref => 'it'
+            echo '11_${v:i}'
+          end
+          echo '2_${v:i}'
+        end
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ 0_a 1_a ], pdef
+  end
+
+  def test_external_break
+
+    pdef = Ruote.process_definition :name => 'test' do
+      concurrence do
+        iterator :on => (1..1000).to_a, :tag => 'it' do
+          echo '${v:i}'
+        end
+        sequence do
+          sequence do
+            _break :ref => 'it'
+          end
+        end
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ 1 2 ], pdef
+  end
+end
+

data/test/functional/eft_14_cursor.rb

@@ -0,0 +1,456 @@
+
+#
+# testing ruote
+#
+# Mon Jun 29 18:34:02 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/no_op_participant'
+
+
+class EftCursorTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_empty_cursor
+
+    pdef = Ruote.process_definition :name => 'test' do
+      cursor do
+      end
+    end
+
+    #noisy
+
+    assert_trace('', pdef)
+  end
+
+  def test_cursor
+
+    pdef = Ruote.process_definition :name => 'test' do
+      cursor do
+        echo 'a'
+        echo 'b'
+      end
+    end
+
+    #noisy
+
+    assert_trace(%w[ a b ], pdef)
+  end
+
+  def test_skip
+
+    pdef = Ruote.process_definition :name => 'test' do
+      cursor do
+        echo 'a'
+        skip 1
+        echo 'b'
+        echo 'c'
+      end
+    end
+
+    #noisy
+
+    assert_trace(%w[ a c ], pdef)
+  end
+
+  def test_break
+
+    pdef = Ruote.process_definition :name => 'test' do
+      cursor do
+        echo 'a'
+        _break
+        echo 'b'
+      end
+    end
+
+    #noisy
+
+    assert_trace('a', pdef)
+  end
+
+  def test_stop
+
+    pdef = Ruote.process_definition :name => 'test' do
+      cursor do
+        echo 'a'
+        stop
+        echo 'b'
+      end
+    end
+
+    #noisy
+
+    assert_trace('a', pdef)
+  end
+
+  def test_over
+
+    pdef = Ruote.process_definition :name => 'test' do
+      cursor do
+        echo 'a'
+        over
+        echo 'b'
+      end
+    end
+
+    #noisy
+
+    assert_trace('a', pdef)
+  end
+
+  def test_jump_to_tag
+
+    pdef = Ruote.process_definition :name => 'test' do
+      cursor do
+        echo 'a'
+        jump :to => 'c'
+        echo 'b'
+        echo 'c', :tag => 'c'
+      end
+    end
+
+    #noisy
+
+    assert_trace(%w[ a c ], pdef)
+  end
+
+  def test_jump_to_variable_tag
+
+    pdef = Ruote.process_definition :name => 'test' do
+      cursor do
+        echo 'a'
+        jump :to => 'd'
+        echo 'b'
+        set :var => 'v0', :val => 'd'
+        jump :to => 'd'
+        echo 'c'
+        echo 'd', :tag => '${v:v0}'
+      end
+    end
+
+    #noisy
+
+    assert_trace(%w[ a b d ], pdef)
+  end
+
+  def test_rewind_if
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        set :f => 'counter', :val => 0
+        set :f => 'rewind', :val => false
+        cursor :rewind_if => '${f:rewind}' do
+          alpha
+        end
+      end
+    end
+
+    @engine.register_participant :alpha do |workitem|
+      workitem.fields['counter'] += 1
+      workitem.fields['rewind'] = workitem.fields['counter'] < 5
+      @tracer << "a\n"
+    end
+
+    #noisy
+
+    assert_trace(%w[ a ] * 5, pdef)
+  end
+
+  def test_jump_to
+
+    pdef = Ruote.process_definition :name => 'test' do
+      cursor do
+        author
+        reviewer
+        jump :to => 'author', :if => '${not_ok}'
+        publisher
+      end
+    end
+
+    @engine.register_participant :author do |workitem|
+      @tracer << "a\n"
+      stash[:count] ||= 0
+      stash[:count] += 1
+    end
+    @engine.register_participant :reviewer do |workitem|
+      @tracer << "r\n"
+      workitem.fields['not_ok'] = (stash[:count] < 3)
+    end
+    @engine.register_participant :publisher do |workitem|
+      @tracer << "p\n"
+    end
+
+    #noisy
+
+    assert_trace %w[ a r a r a r p ], pdef
+      # ARP nostalgy....
+  end
+
+  def test_deep_rewind
+
+    pdef = Ruote.process_definition :name => 'test' do
+      cursor do
+        sequence do
+          echo 'a'
+          rewind
+          echo 'b'
+        end
+      end
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(14)
+
+    #p @tracer.to_s
+
+    assert_equal [ 'a', 'a' ], @tracer.to_a[0..1]
+  end
+
+  def test_external_break
+
+    pdef = Ruote.process_definition :name => 'test' do
+      concurrence do
+        repeat :tag => 'cu' do
+          echo 'a'
+        end
+        sequence do
+          wait '1.1'
+          stop :ref => 'cu'
+          alpha
+        end
+      end
+    end
+
+    @engine.register_participant :alpha, Ruote::NoOpParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+    wait_for(wfid)
+
+    #p @tracer.to_s
+    assert_equal %w[ a a a ], @tracer.to_a[0, 3]
+
+    assert_nil @engine.process(wfid)
+  end
+
+  def test_nested_break
+
+    pdef = Ruote.process_definition :name => 'test' do
+      cursor :tag => 'cu' do
+        echo 'a'
+        cursor do
+          echo 'b'
+          _break :ref => 'cu'
+          echo 'c'
+        end
+        echo 'd'
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ a b ], pdef
+  end
+
+  def test_break_if
+
+    pdef = Ruote.process_definition :name => 'test' do
+      cursor :break_if => 'true' do
+        echo 'c'
+      end
+      echo 'done.'
+    end
+
+    #noisy
+
+    assert_trace 'done.', pdef
+  end
+
+  def test_over_unless
+
+    pdef = Ruote.process_definition :name => 'test' do
+      cursor :over_unless => 'false' do
+        echo 'c'
+      end
+      echo 'done.'
+    end
+
+    #noisy
+
+    assert_trace 'done.', pdef
+  end
+
+  class Alpha
+    include Ruote::LocalParticipant
+    def consume(workitem)
+      workitem.command = 'break'
+      reply_to_engine(workitem)
+    end
+    def cancel(fei, flavour)
+    end
+  end
+  class Bravo < Alpha
+    def consume(workitem)
+      workitem.command = 'skip 1'
+      reply_to_engine(workitem)
+    end
+  end
+
+  def test_cursor_and_workitem
+
+    pdef = Ruote.define do
+      cursor do
+        echo 'in'
+        bravo
+        echo 'mid'
+        alpha
+        echo 'out'
+      end
+      echo 'done.'
+    end
+
+    #noisy
+
+    @engine.register do
+      alpha EftCursorTest::Alpha
+      bravo EftCursorTest::Bravo
+    end
+
+    assert_trace "in\ndone.", pdef
+  end
+
+  def test_cursor_with_lonely_rewind
+
+    pdef = Ruote.define do
+      cursor do
+        rewind
+      end
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(9)
+
+    assert_not_nil @engine.process(wfid)
+  end
+
+  class Charly
+    include Ruote::LocalParticipant
+    def initialize(opts)
+      @opts = opts
+    end
+    def consume(workitem)
+      workitem.command = @opts['command']
+      reply_to_engine(workitem)
+    end
+    def cancel(fei, flavour)
+    end
+  end
+
+  JUMP_DEF = Ruote.process_definition do
+    cursor do
+      echo 'top'
+      charly
+      echo 'middle'
+      delta
+      echo 'bottom'
+    end
+  end
+
+  def test_workitem_command_and_jump_array
+
+    #noisy
+
+    @engine.register do
+      charly EftCursorTest::Charly, 'command' => [ 'jump', 'delta' ]
+      catchall Ruote::NoOpParticipant
+    end
+
+    assert_trace "top\nbottom", JUMP_DEF
+  end
+
+  def test_workitem_command_and_jump_string
+
+    #noisy
+
+    @engine.register do
+      charly EftCursorTest::Charly, 'command' => 'jump delta'
+      catchall Ruote::NoOpParticipant
+    end
+
+    assert_trace "top\nbottom", JUMP_DEF
+  end
+
+  def test_workitem_command_and_jump_to_string
+
+    #noisy
+
+    @engine.register do
+      charly EftCursorTest::Charly, 'command' => 'jump to delta'
+      catchall Ruote::NoOpParticipant
+    end
+
+    assert_trace "top\nbottom", JUMP_DEF
+  end
+
+  def test_reset
+
+    pdef = Ruote.define do
+      cursor do
+        alpha
+        set 'f:toto' => 'oops'
+        reset
+      end
+    end
+
+    @engine.register { catchall }
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(:alpha)
+
+    assert_nil @engine.storage_participant.first.fields['toto']
+
+    @engine.storage_participant.proceed(@engine.storage_participant.first)
+    @engine.wait_for(:alpha)
+
+    assert_nil @engine.storage_participant.first.fields['toto']
+  end
+
+  def test_reset_if
+
+    pdef = Ruote.define do
+      cursor :reset_if => '${f:reset} == true' do
+        alpha
+        set 'f:toto' => 'oops'
+        set 'f:reset' => true
+      end
+    end
+
+    @engine.register { catchall }
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(:alpha)
+
+    assert_nil @engine.storage_participant.first.fields['toto']
+
+    @engine.storage_participant.proceed(@engine.storage_participant.first)
+    @engine.wait_for(:alpha)
+
+    assert_nil @engine.storage_participant.first.fields['toto']
+  end
+end
+