ruote 0.9.20 → 2.1.1

data/test/functional/eft_11_wait.rb

@@ -0,0 +1,97 @@
+
+#
+# testing ruote
+#
+# Thu Jun 18 11:03:45 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftWaitTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_wait_for
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+        wait :for => '2s'
+        alpha
+        echo 'done.'
+      end
+    end
+
+    #noisy
+
+    ts = []
+    @engine.register_participant(:alpha) { ts << Time.now }
+
+    assert_trace pdef, 'done.'
+
+    #p [ ts[1].sec, ts[0].sec ]
+    assert [ 2, 3 ].include?((ts[1].sec - ts[0].sec) % 60)
+  end
+
+  def test_cancel_wait
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'a'
+        wait :for => '3d'
+        echo 'b'
+      end
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(4)
+
+    @engine.cancel_process(wfid)
+
+    wait_for(wfid)
+
+    assert_equal 'a', @tracer.to_s
+    assert_equal 0, @engine.storage.get_many('schedules').size
+  end
+
+  def test_wait_until
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+        wait :until => (Time.now + 2.0).to_s
+        alpha
+        echo 'done.'
+      end
+    end
+
+    #noisy
+
+    ts = []
+    @engine.register_participant(:alpha) { ts << Time.now }
+
+    assert_trace pdef, 'done.'
+
+    #p ts
+    assert ts[1] - ts[0] > 1.0, "#{ts[1] - ts[0]} should be > 1.0"
+  end
+
+  def test_wait_until_now
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'a'
+        wait Time.now
+        echo 'b'
+      end
+    end
+
+    #noisy
+
+    assert_trace pdef, %w[ a b ]
+  end
+end
+

data/test/functional/eft_12_listen.rb

@@ -0,0 +1,271 @@
+
+#
+# testing ruote
+#
+# Fri Jun 19 15:26:33 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftListenTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_listen
+
+    pdef = Ruote.process_definition do
+      concurrence do
+        sequence do
+          listen :to => '^al.*'
+          echo '1'
+        end
+        sequence do
+          alpha
+        end
+      end
+    end
+
+    #noisy
+
+    @engine.register_participant :alpha do
+      @tracer << "alpha\n"
+    end
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+
+    assert_equal %w[ 1 alpha ], @tracer.to_a.sort
+
+    assert_equal(
+      0, @engine.context.storage.get('variables', 'trackers')['trackers'].size)
+  end
+
+  def test_listen_with_child
+
+    pdef = Ruote.process_definition do
+      concurrence do
+        listen :to => '^al.*' do
+          bravo
+        end
+        sequence do
+          alpha
+          alpha
+        end
+      end
+    end
+
+    @engine.register_participant :alpha do
+      @tracer << "a\n"
+    end
+    @engine.register_participant :bravo do |workitem|
+      @tracer << "#{workitem.fei.wfid}|#{workitem.fei.sub_wfid}"
+      @tracer << "\n"
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:bravo)
+    wait_for(:bravo)
+    wait_for(2)
+
+    #p @tracer.to_s
+
+    a = @tracer.to_a
+    assert_equal 2, a.select { |e| e == 'a' }.size
+
+    a = (a - [ 'a', 'a' ]).sort
+    assert_equal 2, a.uniq.size
+
+    ps = @engine.process(wfid)
+
+    #assert_equal 3, ps.expressions.size
+    assert_equal 0, ps.errors.size
+
+    assert_equal(
+      1, @engine.context.storage.get('variables', 'trackers')['trackers'].size)
+  end
+
+  def test_upon
+
+    pdef = Ruote.process_definition do
+      concurrence do
+        sequence do
+          listen :to => '^al.*', :merge => false
+          bravo
+        end
+        sequence do
+          listen :to => '^al.*', :upon => 'reply'
+          bravo
+        end
+        sequence do
+          alpha
+        end
+      end
+    end
+
+    #noisy
+
+    @engine.register_participant :alpha do |workitem|
+      @tracer << "alpha\n"
+      workitem.fields['seen'] = 'yes'
+    end
+    @engine.register_participant :bravo do |workitem|
+      @tracer << "bravo:#{workitem.fields['seen']}\n"
+    end
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(wfid)
+
+    assert_equal %w[ alpha bravo: bravo:yes ], @tracer.to_a.sort
+  end
+
+  def test_merge_override
+
+    pdef = Ruote.process_definition do
+      set :f => 'name', :val => 'Kilroy'
+      set :f => 'other', :val => 'nothing'
+      concurrence do
+        sequence do
+          listen :to => '^al.*', :merge => 'override', :upon => 'reply'
+          bravo
+        end
+        sequence do
+          alpha
+        end
+      end
+    end
+
+    #noisy
+
+    @engine.register_participant :alpha do |wi|
+      @tracer << "alpha\n"
+      wi.fields['name'] = 'William Mandella'
+    end
+    @engine.register_participant :bravo do |wi|
+      @tracer << "name:#{wi.fields['name']} "
+      @tracer << "other:#{wi.fields['other']}\n"
+    end
+
+    assert_trace(pdef, "alpha\nname:William Mandella other:nothing")
+  end
+
+  def test_where
+
+    pdef = Ruote.process_definition do
+      concurrence do
+        listen :to => 'alpha', :where => '${f:who} == toto', :upon => 'reply' do
+          echo 'toto'
+        end
+        sequence do
+          alpha
+        end
+        sequence do
+          alpha
+        end
+      end
+    end
+
+    #noisy
+
+    count = 0
+
+    @engine.register_participant :alpha do |wi|
+      @tracer << "alpha\n"
+      wi.fields['who'] = 'toto' if count > 0
+      count = count + 1
+    end
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(wfid) # ceased
+
+    assert_equal %w[ alpha alpha toto ].join("\n"), @tracer.to_s
+    assert_equal 3, @engine.process(wfid).expressions.size
+    assert_equal 'ceased', @engine.context.logger.log.last['action']
+  end
+
+  def test_listen_cancel
+
+    pdef = Ruote.process_definition do
+      listen :to => 'alpha'
+    end
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(2)
+
+    assert_equal(
+      1, @engine.context.storage.get('variables', 'trackers')['trackers'].size)
+
+    @engine.cancel_process(wfid)
+
+    wait_for(wfid)
+
+    assert_equal(
+      0, @engine.context.storage.get('variables', 'trackers')['trackers'].size)
+  end
+
+  def test_cross
+
+    listening = Ruote.process_definition do
+      sequence do
+        listen :to => 'alpha'
+        echo 'ldone.'
+      end
+    end
+    emitting = Ruote.process_definition do
+      sequence do
+        alpha
+        echo 'edone.'
+      end
+    end
+
+    @engine.register_participant :alpha do
+      # nothing
+    end
+
+    #noisy
+
+    lwfid = @engine.launch(listening)
+    ewfid = @engine.launch(emitting)
+
+    wait_for(lwfid, ewfid)
+    wait_for(lwfid, ewfid)
+
+    #assert_equal("edone.\nldone.", @tracer.to_s)
+    assert_equal %w[ edone. ldone. ], @tracer.to_a.sort
+  end
+
+  def test_not_cross
+
+    listening = Ruote.process_definition do
+      sequence do
+        listen :to => 'alpha', :wfid => :same
+        echo 'ldone.'
+      end
+    end
+    emitting = Ruote.process_definition do
+      sequence do
+        alpha
+        echo 'edone.'
+      end
+    end
+
+    @engine.register_participant :alpha do
+      # nothing
+    end
+
+    lwfid = @engine.launch(listening)
+    ewfid = @engine.launch(emitting)
+
+    wait_for(ewfid)
+
+    assert_equal("edone.", @tracer.to_s)
+
+    ps = @engine.process(lwfid)
+    assert_equal(3, ps.expressions.size)
+  end
+end
+

data/test/functional/eft_13_iterator.rb

@@ -0,0 +1,267 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# Mon Jun 29 09:35:48 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+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(pdef, 'done.')
+  end
+
+  def test_iterator
+
+    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 '.*' do |workitem|
+      @tracer << "#{workitem.participant_name}/#{workitem.fei.expid}\n"
+    end
+
+    #noisy
+
+    assert_trace(pdef, %w[ alice/0_0_0 bob/0_0_0 charly/0_0_0 ])
+  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(pdef, %w[ alice/0_0_0 bob/0_0_0 charly/0_0_0 ])
+  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"
+
+      workitem.fields['__command__'] = [ 'break', nil ] \
+        if workitem.participant_name == 'bob'
+    end
+
+    #noisy
+
+    assert_trace(PDEF0, %w[ alice bob done. ])
+  end
+
+  def test_rewind
+
+    rewound = false
+
+    @engine.register_participant '.*' do |workitem|
+
+      @tracer << "#{workitem.participant_name}\n"
+
+      if (not rewound) and workitem.participant_name == 'bob'
+        rewound = true
+        workitem.fields['__command__'] = [ 'rewind', nil ]
+      end
+    end
+
+    #noisy
+
+    assert_trace(PDEF0, %w[ alice bob alice bob charly done. ])
+  end
+
+  def test_skip
+
+    @engine.register_participant '.*' do |workitem|
+
+      @tracer << "#{workitem.participant_name}\n"
+
+      workitem.fields['__command__'] = [ 'skip', 1 ] \
+        if workitem.participant_name == 'alice'
+    end
+
+    #noisy
+
+    assert_trace(PDEF0, %w[ alice charly done.])
+  end
+
+  def test_jump
+
+    @engine.register_participant '.*' do |workitem|
+
+      @tracer << "#{workitem.participant_name}\n"
+
+      workitem.fields['__command__'] = [ 'jump', -1 ] \
+        if workitem.participant_name == 'alice'
+    end
+
+    #noisy
+
+    assert_trace(PDEF0, %w[ alice charly done.])
+  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(pdef, %w[ alice/0_0_0_0 charly/0_0_0_0 ])
+  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(pdef, %w[ a/0_0_0 b/0_0_0 ])
+  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(pdef, %w[ a/0_1_0 b/0_1_0 ])
+  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 pdef, %w[ a:A b:B ]
+  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(pdef, %w[ alice:0/0_0_0 bob:1/0_0_0 charly:2/0_0_0 ])
+  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 pdef, %w[ 0_a 1_a ]
+  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 pdef, %w[ 1 2 ]
+  end
+end
+