ruote 2.2.0 → 2.3.0

data/test/functional/eft_39_stall.rb

@@ -0,0 +1,35 @@
+
+#
+# testing ruote
+#
+# Wed Aug 17 08:29:13 JST 2011
+#
+# Santa Barbara
+#
+
+require File.expand_path('../base', __FILE__)
+
+
+class EftStallTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_no_operation
+
+    pdef = Ruote.define do
+      stall
+    end
+
+    #@dashboard.noisy = true
+
+    wfid = @dashboard.launch(pdef)
+
+    sleep 0.750
+
+    ps = @dashboard.ps(wfid)
+
+    assert_equal 0, ps.errors.size
+    assert_equal 2, ps.expressions.size
+    assert_equal 'stall', ps.expressions.last.name
+  end
+end
+

data/test/functional/eft_3_participant.rb

@@ -5,7 +5,7 @@
 # Wed May 13 11:14:08 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'base')
+require File.expand_path('../base', __FILE__)
 
 require 'ruote/participant'
 
@@ -15,21 +15,26 @@ class EftParticipantTest < Test::Unit::TestCase
 
   def test_participant
 
+    @dashboard.register_participant :alpha do |workitem|
+      context.tracer << 'alpha'
+    end
+
     pdef = Ruote.process_definition do
       participant :ref => 'alpha'
     end
 
-    @engine.register_participant :alpha do |workitem|
-      @tracer << 'alpha'
-    end
+    #@dashboard.noisy = true
 
-    #noisy
+    wfid = @dashboard.launch(pdef)
+    @dashboard.wait_for(wfid)
 
-    assert_trace 'alpha', pdef
+    sleep 0.300
+      # give a chance to the 'dispatched' message for reaching us
 
+    assert_equal 'alpha', @tracer.to_s
     assert_log_count(1) { |e| e['action'] == 'dispatch' }
-    assert_log_count(1) { |e| e['action'] == 'dispatched' }
     assert_log_count(1) { |e| e['action'] == 'receive' }
+    assert_log_count(1) { |e| e['action'] == 'dispatched' }
   end
 
   def test_participant_att_text
@@ -38,8 +43,8 @@ class EftParticipantTest < Test::Unit::TestCase
       participant :bravo
     end
 
-    @engine.register_participant :bravo do |workitem|
-      @tracer << 'bravo'
+    @dashboard.register_participant :bravo do |workitem|
+      tracer << 'bravo'
     end
 
     #noisy
@@ -53,8 +58,8 @@ class EftParticipantTest < Test::Unit::TestCase
       charly
     end
 
-    @engine.register_participant :charly do |workitem|
-      @tracer << 'charly'
+    @dashboard.register_participant :charly do |workitem|
+      tracer << 'charly'
     end
 
     #noisy
@@ -68,14 +73,14 @@ class EftParticipantTest < Test::Unit::TestCase
       delta :tag => 'whatever'
     end
 
-    delta = @engine.register_participant :delta, Ruote::StorageParticipant
+    delta = @dashboard.register_participant :delta, Ruote::StorageParticipant
 
-    @engine.launch(pdef)
+    @dashboard.launch(pdef)
     wait_for(:delta)
 
     assert_equal(
       ['participant', {'tag'=>'whatever', 'ref'=>'delta'}, []],
-      Ruote::Exp::FlowExpression.fetch(@engine.context, delta.first.h.fei).tree)
+      Ruote::Exp::FlowExpression.fetch(@dashboard.context, delta.first.h.fei).tree)
   end
 
   def test_participant_if
@@ -87,8 +92,8 @@ class EftParticipantTest < Test::Unit::TestCase
     end
 
     %w[ eecho fox gamma ].each do |pname|
-      @engine.register_participant pname do |workitem|
-        @tracer << "#{workitem.participant_name}\n"
+      @dashboard.register_participant pname do |workitem|
+        tracer << "#{workitem.participant_name}\n"
       end
     end
 
@@ -104,7 +109,7 @@ class EftParticipantTest < Test::Unit::TestCase
       echo 'done.'
     end
 
-    @engine.register_participant :notify do |wi, fe|
+    @dashboard.register_participant :notify do |wi, fe|
       #p fe.attribute_text
       stash[:atts] = fe.attributes
     end
@@ -120,7 +125,28 @@ class EftParticipantTest < Test::Unit::TestCase
 
   def test_dispatched
 
-    @engine.register_participant :hotel do
+    @dashboard.register 'toto', Ruote::StorageParticipant
+
+    pdef = Ruote.process_definition do
+      toto
+    end
+
+    wfid = @dashboard.launch(pdef)
+
+    r = @dashboard.wait_for('dispatched')
+    sleep 0.700
+
+    fexp = @dashboard.ps(wfid).expressions.last
+
+    assert_equal true, fexp.dispatched
+    assert r.has_key?('fei')
+    assert r.has_key?('workitem')
+    assert r.has_key?('participant_name')
+  end
+
+  def test_not_dispatched
+
+    @dashboard.register_participant :hotel do
       sleep 5
     end
 
@@ -128,15 +154,13 @@ class EftParticipantTest < Test::Unit::TestCase
       hotel
     end
 
-    #noisy
-
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
     #wait_for(:hotel)
     sleep 0.777
     sleep 1 # just for ruote-couch :-(
 
-    ps = @engine.process(wfid)
+    ps = @dashboard.process(wfid)
 
     fexp = ps.expressions.find { |fe|
       fe.class == Ruote::Exp::ParticipantExpression
@@ -145,5 +169,36 @@ class EftParticipantTest < Test::Unit::TestCase
     assert_equal nil, fexp.dispatched
       # not yet 'dispatched'
   end
+
+  def test_tree
+
+    require_json
+    Rufus::Json.detect_backend
+
+    @dashboard.register_participant :alice do |workitem|
+      tracer << Rufus::Json.encode(workitem.params['__children__'])
+    end
+
+    pdef = Ruote.define do
+      alice do
+        on_error /500/ => 'this_or_${that}'
+        whatever 'list' => '$f:list'
+      end
+    end
+
+    #@dashboard.noisy = true
+
+    wfid = @dashboard.launch(
+      pdef,
+      'that' => 'those',
+      'list' => [ 1, 'two of ${that}', 3 ])
+
+    @dashboard.wait_for(wfid)
+
+    assert_equal(
+      [ [ 'on_error', { '/500/' => 'this_or_those' }, [] ],
+        [ 'whatever', { 'list' => [ 1, 'two of ${that}', 3 ] }, [] ] ],
+      Rufus::Json.decode(@tracer.to_s))
+  end
 end
 

data/test/functional/eft_40_await.rb

@@ -0,0 +1,297 @@
+
+#
+# testing ruote
+#
+# Sat Jan  7 15:23:56 JST 2012
+#
+
+require File.expand_path('../base', __FILE__)
+
+
+class EftAwaitTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_await_tag
+
+    pdef = Ruote.process_definition do
+      concurrence :wait_for => 4 do
+        sequence do
+          await :left_tag => 'alpha'
+          echo 'a0'
+        end
+        sequence do
+          await :entered_tag => 'alpha'
+          echo 'a1'
+        end
+        sequence do
+          await :entered_tag => /pha$/
+          echo 'a2'
+        end
+        sequence do
+          await :tags => 'alpha'
+          echo 'a3'
+        end
+        sequence do
+          await :entered_tag => /pha./
+          echo 'a9'
+        end
+        sequence do
+          noop # skip a beat
+          sequence :tag => 'alpha' do
+            echo 'alpha'
+          end
+        end
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal %w[ a0 a1 a2 a3 alpha ], @tracer.to_a.sort
+
+    assert @tracer.to_a.index('a1') < @tracer.to_a.index('a0')
+  end
+
+  def test_await_participant
+
+    @dashboard.register 'a' do
+      tracer << "a\n"
+    end
+
+    pdef = Ruote.process_definition do
+      concurrence do
+        sequence do
+          await :reached_participant => 'a'
+          echo 'b'
+        end
+        sequence do
+          await :left_participant => 'a'
+          echo 'c'
+        end
+        sequence do
+          noop # skip a beat
+          participant 'a'
+        end
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 3, @tracer.to_a.size
+    assert_equal 3, @tracer.to_a.uniq.size
+    assert_equal 'c', @tracer.to_a.last
+  end
+
+  def test_tag_or_tag
+
+    pdef = Ruote.process_definition do
+      concurrence do
+        sequence do
+          await :left_tag => 'a, b'
+          echo 'ab'
+        end
+        sequence do
+          await :left_tag => %w[ c d ]
+          echo 'cd'
+        end
+        sequence do
+          noop # skip a beat
+          concurrence do
+            echo 'a', :tag => 'a'
+            echo 'c', :tag => 'c'
+          end
+        end
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal %w[ a ab c cd ], @tracer.to_a.sort
+  end
+
+  def test_absolute_tag
+
+    pdef = Ruote.define do
+      concurrence do
+        sequence do
+          await :tags => 'a/b'
+          echo 'a/b'
+        end
+        sequence :tag => 'a' do
+          noop
+          sequence :tag => 'b' do
+            echo 'b'
+          end
+        end
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal %w[ a/b b ], @tracer.to_a.sort
+  end
+
+  def test_error
+
+    pdef = Ruote.process_definition do
+      concurrence :wait_for => 4 do
+        sequence do
+          await :error => /na(d|f)a/
+          echo 'e0'
+        end
+        sequence do
+          await :error => 'nada'
+          echo 'e1'
+        end
+        sequence do
+          await :error => 'Ruote::ForcedError, ArgumentError'
+          echo 'e2'
+        end
+        sequence do
+          await 'error'
+          echo 'e3'
+        end
+        sequence do
+          noop # skip a beat
+          error 'nada'
+        end
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for('terminated')
+
+    assert_equal %w[ e0 e1 e2 e3 ], @tracer.to_a.sort
+  end
+
+  def test_where
+
+    @dashboard.register 'a' do |workitem|
+      workitem['task'] = workitem.params['task']
+    end
+
+    pdef = Ruote.define do
+      concurrence :wait_for => 1 do
+        await :left_participant => 'a', :where => "${task} == 'sing'" do
+          echo 'sing-a'
+        end
+        await :left_participant => 'a' do
+          echo 'any-a'
+        end
+        concurrence do
+          participant 'a', :task => 'talk'
+          participant 'a', :task => 'sing'
+        end
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for('terminated')
+
+    assert_equal %w[ any-a any-a sing-a ], @tracer.to_a.sort
+  end
+
+  def test_implicit_sequence
+
+    @dashboard.register 'a' do |workitem|
+    end
+
+    pdef = Ruote.define do
+      concurrence :wait_for => 1 do
+        await :left_participant => 'a' do
+          echo 'a0'
+          echo 'a1'
+        end
+        sequence do
+          participant 'a'
+          noop; noop; noop # give time to concurrent branch to reach a1
+        end
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for('terminated')
+
+    assert_equal %w[ a0 a1 ], @tracer.to_a.sort
+  end
+
+  def test_other_process
+
+    wfid = @dashboard.launch(Ruote.define do
+      await :tags => 'a'
+      echo 'local' # shouldn't happen
+    end)
+    @dashboard.launch(Ruote.define do
+      await :tags => 'a', :global => true
+      echo 'global'
+    end)
+    @dashboard.launch(Ruote.define do
+      noop; noop # making sure the 'awaits' are in place
+      noop :tag => 'a'
+    end)
+
+    @dashboard.wait_for('terminated')
+    @dashboard.wait_for('terminated')
+
+    assert_equal %w[ global ], @tracer.to_a.sort
+    assert_not_nil @dashboard.ps(wfid)
+  end
+
+  def test_merge
+
+    # override / ignore / incoming / awaiting
+
+    pdef = Ruote.define do
+
+      set 'customer' => 'bamboku'
+      set 'city' => 'kyouto'
+
+      concurrence do
+
+        sequence do
+          await :in_tag => 'alpha'
+          echo 'a:${customer}/${city}/${region}'
+        end
+        sequence do
+          await :in_tag => 'alpha', :merge => 'override'
+          echo 'b:${customer}/${city}/${region}'
+        end
+        sequence do
+          await :in_tag => 'alpha', :merge => 'ignore'
+          echo 'c:${customer}/${city}/${region}'
+        end
+        sequence do
+          await :in_tag => 'alpha', :merge => 'incoming'
+          echo 'd:${customer}/${city}/${region}'
+        end
+        sequence do
+          await :in_tag => 'alpha', :merge => 'awaiting'
+          echo 'e:${customer}/${city}/${region}'
+        end
+
+        sequence do
+          4.times { noop } # making sure the 'awaits' are in place
+          set 'customer' => 'antoku'
+          unset 'city'
+          set 'region' => 'fukuhara'
+          noop :tag => 'alpha'
+        end
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal %w[
+      a:antoku//fukuhara
+      b:antoku//fukuhara
+      c:bamboku/kyouto/
+      d:antoku/kyouto/fukuhara
+      e:bamboku/kyouto/fukuhara
+    ], @tracer.to_a.sort
+  end
+end
+