ruote 2.1.11 → 2.2.0

data/test/functional/eft_1_echo.rb

@@ -40,6 +40,15 @@ class EftEchoTest < Test::Unit::TestCase
     assert_trace('a', pdef)
   end
 
+  def test_echo_text
+
+    pdef = Ruote.define do
+      echo :text => 'a'
+    end
+
+    assert_trace('a', pdef)
+  end
+
   #def test_print_escape
   #  pdef = OpenWFE.process_definition :name => 'test' do
   #    sequence do

data/test/functional/eft_20_save.rb

@@ -7,7 +7,7 @@
 
 require File.join(File.dirname(__FILE__), 'base')
 
-require 'ruote/part/hash_participant'
+require 'ruote/participant'
 
 
 class EftSaveTest < Test::Unit::TestCase
@@ -22,7 +22,7 @@ class EftSaveTest < Test::Unit::TestCase
 
     #noisy
 
-    @engine.register_participant :alpha, Ruote::HashParticipant.new
+    @engine.register_participant :alpha, Ruote::StorageParticipant
 
     wfid = @engine.launch(pdef)
 
@@ -43,7 +43,7 @@ class EftSaveTest < Test::Unit::TestCase
 
     #noisy
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     wfid = @engine.launch(pdef)
 
@@ -63,7 +63,7 @@ class EftSaveTest < Test::Unit::TestCase
 
     #noisy
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     wfid = @engine.launch(pdef)
 

data/test/functional/{eft_28_when.rb → eft_28_once.rb}

@@ -9,16 +9,18 @@
 
 require File.join(File.dirname(__FILE__), 'base')
 
+require 'ruote/participant'
 
-class EftWhenTest < Test::Unit::TestCase
+
+class EftOnceTest < Test::Unit::TestCase
   include FunctionalBase
 
-  def test_when
+  def test_once
 
     pdef = Ruote.process_definition do
       echo 'in'
       concurrence do
-        _when '${v:ok}', :freq => '1s' do
+        once '${v:ok}', :freq => '1s' do
           echo 'done.'
         end
         sequence do
@@ -36,13 +38,13 @@ class EftWhenTest < Test::Unit::TestCase
     assert_equal 0, @engine.storage.get_many('schedules').size
   end
 
-  def test_when_blocking
+  def test_once_blocking
 
     pdef = Ruote.process_definition do
       echo 'in'
       concurrence do
         sequence do
-          _when '${v:ok}', :freq => '1s'
+          once '${v:ok}', :freq => '1s'
           echo 'done.'
         end
         sequence do
@@ -63,7 +65,7 @@ class EftWhenTest < Test::Unit::TestCase
   def test_cancel
 
     pdef = Ruote.process_definition do
-      _when '${v:ok}', :freq => '10d'
+      once '${v:ok}', :freq => '10d'
       echo 'done.'
     end
 
@@ -83,7 +85,31 @@ class EftWhenTest < Test::Unit::TestCase
     assert_equal 0, @engine.storage.get_many('schedules').size
   end
 
-  def test_when_cron
+  def test_cancel_once_child_is_active
+
+    pdef = Ruote.process_definition do
+      as_soon_as 'true', :freq => '10d' do
+        alpha
+      end
+    end
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:alpha)
+
+    @engine.cancel(wfid)
+
+    @engine.wait_for(wfid)
+
+    assert_equal 0, @engine.storage_participant.size
+    assert_equal 0, @engine.storage.get_many('schedules').size
+  end
+
+  def test_once_cron
 
     pdef = Ruote.process_definition do
       echo 'in'

data/test/functional/eft_30_ref.rb

@@ -16,7 +16,7 @@ class EftRefTest < Test::Unit::TestCase
   class AlphaParticipant
     include Ruote::LocalParticipant
 
-    def consume (workitem)
+    def consume(workitem)
       @context.tracer << workitem.fei.expid
       @context.tracer << "\n"
       reply(workitem)
@@ -125,7 +125,7 @@ class EftRefTest < Test::Unit::TestCase
       define 'sub0' do
         alpha
       end
-      sub0 :timeout => '2d'
+      ref 'sub0', :timeout => '2d'
     end
 
     wfid = @engine.launch(pdef)
@@ -136,5 +136,20 @@ class EftRefTest < Test::Unit::TestCase
     assert_equal 1, scheds.size
     assert_equal '0_1', scheds.first['target'].expid
   end
+
+  def test_missing_ref_and_undo
+
+    pdef = Ruote.process_definition do
+      ref 'nemo', :on_error => 'undo'
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+  end
 end
 

data/test/functional/eft_31_registerp.rb

@@ -0,0 +1,130 @@
+
+#
+# testing ruote
+#
+# Wed Oct 13 21:22:41 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class EftRegisterpTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_register_forbidden
+
+    pdef = Ruote.define do
+      registerp 'alpha', :class => 'C', :opt0 => 'val0'
+    end
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(wfid)
+
+    err = @engine.errors.first
+
+    assert_equal(
+      "#<ArgumentError: 'registerp_allowed' is set to false, " +
+      "cannot [un]register participants from process definitions>",
+      err.message)
+  end
+
+  def test_register_from_attributes
+
+    #@engine.noisy = true
+
+    @engine.context['registerp_allowed'] = true
+
+    pdef = Ruote.define do
+      registerp 'alpha', :class => 'C', :opt0 => 'val_a'
+      registerp /bravo/, :class => 'C', :opt0 => 'val_b'
+      registerp :regex => /charly/, :class => 'C', :opt0 => 'val_c'
+      registerp :regex => 'delta', :class => 'C', :opt0 => 'val_d'
+    end
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(wfid)
+
+    assert_equal(
+      [
+        [ '^alpha$', [ 'C', { 'opt0' => 'val_a' } ] ],
+        [ 'bravo', [ 'C', { 'opt0' => 'val_b' } ] ],
+        [ 'charly', [ 'C', { 'opt0' => 'val_c' } ] ],
+        [ 'delta', [ 'C', { 'opt0' => 'val_d' } ] ]
+      ],
+      @engine.participant_list.collect { |e| e.to_a })
+  end
+
+  def test_register_from_workitem
+
+    #@engine.noisy = true
+
+    @engine.context['registerp_allowed'] = true
+
+    pdef = Ruote.define do
+      registerp :participants => 'participants'
+      registerp :participant => 'participant'
+    end
+
+    wfid = @engine.launch(pdef,
+      'participants' => [
+        [ 'alpha', 'C', { 'opt0' => 'val_a' } ],
+        [ '/bravo/', 'C', { 'opt0' => 'val_b' } ]
+      ],
+      'participant' => [ '/charly/', 'C', { 'opt0' => 'val_c' } ])
+
+    @engine.wait_for(wfid)
+
+    assert_equal(
+      [
+        [ '^alpha$', [ 'C', { 'opt0' => 'val_a' } ] ],
+        [ 'bravo', [ 'C', { 'opt0' => 'val_b' } ] ],
+        [ 'charly', [ 'C', { 'opt0' => 'val_c' } ] ]
+      ],
+      @engine.participant_list.collect { |e| e.to_a })
+  end
+
+  def test_register_with_position
+
+    #@engine.noisy = true
+
+    @engine.context['registerp_allowed'] = true
+
+    pdef = Ruote.define do
+      registerp 'alpha', :class => 'C', :opt0 => 'val_a'
+      registerp /bravo/, :class => 'C', :opt0 => 'val_b', :position => 0
+    end
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(wfid)
+
+    assert_equal(
+      [
+        [ 'bravo', [ 'C', { 'opt0' => 'val_b', 'position' => 0 } ] ],
+        [ '^alpha$', [ 'C', { 'opt0' => 'val_a' } ] ]
+      ],
+      @engine.participant_list.collect { |e| e.to_a })
+  end
+
+  def test_unregister
+
+    #@engine.noisy = true
+
+    @engine.context['registerp_allowed'] = true
+
+    pdef = Ruote.define do
+      registerp 'alpha', :class => 'C', :opt0 => 'val_a'
+      unregisterp 'alpha'
+    end
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(wfid)
+
+    assert_equal(
+      [],
+      @engine.participant_list.collect { |e| e.to_a })
+  end
+end
+

data/test/functional/eft_32_lose.rb

@@ -0,0 +1,93 @@
+
+#
+# testing ruote
+#
+# Thu Nov 25 10:05:28 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class EftLoseTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_lose_alone
+
+    pdef = Ruote.process_definition do
+      lose
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(2)
+      # wait until the process reaches the 'lose' expression
+
+    sleep 0.500
+
+    ps = @engine.process(wfid)
+
+    assert_equal 0, ps.errors.size
+    assert_equal 2, ps.expressions.size
+
+    # the process is just stuck at the 'lose' expression
+  end
+
+  def test_losing_child
+
+    pdef = Ruote.process_definition do
+      lose do
+        alpha
+      end
+      charly
+    end
+
+    @engine.register_participant '.+' do |wi|
+      @tracer << wi.participant_name
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(7)
+      # wait until 'alpha' replies to its parent 'lose'
+
+    sleep 0.500
+
+    assert_equal 'alpha', @tracer.to_s
+  end
+
+  def test_cancelling_lose
+
+    pdef = Ruote.process_definition do
+      lose do
+        alpha
+      end
+    end
+
+    @engine.register_participant '.+', Ruote::StorageParticipant
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(6)
+      # wait until 'alpha' replies to its parent 'lose'
+
+    sleep 0.500
+
+    assert_equal 1, @engine.storage_participant.size
+
+    @engine.cancel_process(wfid)
+
+    sleep 0.500
+
+    assert_equal 0, @engine.storage_participant.size
+    assert_nil @engine.process(wfid)
+  end
+end
+

data/test/functional/eft_33_let.rb

@@ -0,0 +1,31 @@
+
+#
+# testing ruote
+#
+# Fri Dec 24 15:35:17 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftLetTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_let
+
+    pdef = Ruote.process_definition do
+      set 'v:var' => 'val'
+      echo "out:${v:var}"
+      let do
+        set 'v:var' => 'val1'
+        echo "in:${v:var}"
+      end
+      echo "out:${v:var}"
+    end
+
+    #noisy
+
+    assert_trace %w[ out:val in:val1 out:val ], pdef
+  end
+end
+

data/test/functional/eft_34_given.rb

@@ -0,0 +1,123 @@
+
+#
+# testing ruote
+#
+# Sat Dec 25 12:21:00 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftGivenTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_given_that
+
+    pdef = Ruote.process_definition do
+      given do
+        that "${state} == ready" do
+          echo "a"
+        end
+        that "${location} == nichoume" do
+          echo "b"
+        end
+        # anything that follows is "else"
+        echo "c"
+        echo "d"
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ c d ], pdef, :clear
+    assert_trace %w[ a ], { 'state' => 'ready' }, pdef, :clear
+    assert_trace %w[ b ], { 'location' => 'nichoume' }, pdef, :clear
+    assert_trace %w[ a ], { 'state' => 'ready', 'location' => 'nichoume' }, pdef, :clear
+  end
+
+  def test_given_x_of
+
+    pdef = Ruote.process_definition do
+      given "${status}" do
+        of "ready" do
+          echo "a"
+        end
+        of "dead" do
+          echo "b"
+        end
+        echo "c"
+        echo "d"
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ c d ], pdef, :clear
+    assert_trace %w[ a ], { 'status' => 'ready' }, pdef, :clear
+    assert_trace %w[ b ], { 'status' => 'dead' }, pdef, :clear
+  end
+
+  def test_given_x_of_and_that
+
+    pdef = Ruote.process_definition do
+      given "${status}" do
+        that "${location} == higashiyama" do
+          echo "a"
+        end
+        of "ready" do
+          echo "b"
+        end
+        of "dead" do
+          echo "c"
+        end
+        echo "d"
+      end
+    end
+
+    assert_trace %w[ d ], {}, pdef, :clear
+    assert_trace %w[ b ], { 'status' => 'ready' }, pdef, :clear
+    assert_trace %w[ a ], { 'status' => 'dead', 'location' => 'higashiyama' }, pdef, :clear
+  end
+
+  def test_attributes
+
+    pdef = Ruote.process_definition do
+      given :t => "${status}" do
+        that :t => "${location} == higashiyama" do
+          echo "a"
+        end
+        of :t => "ready" do
+          echo "b"
+        end
+        of "dead" do
+          echo "c"
+        end
+        echo "d"
+      end
+    end
+
+    assert_trace %w[ d ], {}, pdef, :clear
+    assert_trace %w[ b ], { 'status' => 'ready' }, pdef, :clear
+    assert_trace %w[ a ], { 'status' => 'dead', 'location' => 'higashiyama' }, pdef, :clear
+  end
+
+  def test_match
+
+    pdef = Ruote.define do
+      given "${status}" do
+        of "/^a/" do
+          echo 'a'
+        end
+        of /^b/ do
+          echo 'b'
+        end
+        echo 'z'
+      end
+    end
+
+    assert_trace %w[ z ], {}, pdef, :clear
+    assert_trace %w[ a ], { 'status' => 'alpha' }, pdef, :clear
+    assert_trace %w[ b ], { 'status' => 'bravo' }, pdef, :clear
+  end
+end
+