ruote-maestrodev 2.2.1

data/test/functional/eft_19_reserve.rb

@@ -0,0 +1,136 @@
+
+#
+# testing ruote
+#
+# Fri Jul 31 21:44:04 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class EftReserveTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_reserve
+
+    pdef = Ruote.process_definition :name => 'test' do
+      concurrence do
+        reserve :mutex => 'a' do
+          alpha
+        end
+        reserve 'a' do
+          alpha
+        end
+      end
+    end
+
+    #noisy
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    assert_equal 1, alpha.size
+    assert_equal '0_0_0_0', alpha.first.fei.expid
+
+    ps = @engine.process(wfid)
+
+    assert_equal 2, ps.variables.size
+
+    assert_equal(
+      [ 'mutex', 'a' ], ps.variables['a'][0, 2])
+    assert_equal(
+      [ '0_0_0', '0_0_1' ],
+      ps.variables['a'].last.collect { |e| e['expid'] })
+
+    alpha.proceed(alpha.first)
+
+    wait_for(:alpha)
+
+    assert_equal 1, alpha.size
+    assert_equal '0_0_1_0', alpha.first.fei.expid
+
+    alpha.proceed(alpha.first)
+
+    wait_for(wfid)
+  end
+
+  def test_cancel_reserve
+
+    pdef = Ruote.process_definition :name => 'test' do
+      concurrence do
+        reserve :mutex => 'a' do
+          alpha
+        end
+        reserve 'a' do
+          alpha
+        end
+      end
+    end
+
+    #noisy
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    ps = @engine.process(wfid)
+    exp = ps.expressions.find { |e| e.fei.expid == '0_0_0' }
+
+    @engine.cancel_expression(exp.fei)
+
+    wait_for(:alpha)
+
+    #alpha.instance_variable_get(:@items).each { |i| p i }
+
+    assert_equal 1, alpha.size
+    assert_equal '0_0_1_0', alpha.first.fei.expid
+
+    alpha.proceed(alpha.first)
+
+    wait_for(wfid)
+  end
+
+  def test_reserve_but_no_name
+
+    pdef = Ruote.process_definition :name => 'test' do
+      concurrence do
+        reserve do
+          alpha
+        end
+        reserve do
+          alpha
+        end
+      end
+    end
+
+    #noisy
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    wfid = @engine.launch(pdef)
+
+    2.times do
+
+      wait_for(:alpha)
+
+      assert_equal 1, alpha.size
+
+      ps = @engine.process(wfid)
+
+      assert_equal 2, ps.variables.size
+      assert_not_nil ps.variables['reserve']
+
+      alpha.proceed(alpha.first)
+    end
+
+    wait_for(wfid)
+  end
+end
+

data/test/functional/eft_1_echo.rb

@@ -0,0 +1,68 @@
+
+#
+# testing ruote
+#
+# Sat Sep 20 23:40:10 JST 2008
+#
+
+#class String
+#  def empty?
+#    puts '=' * 80
+#    puts caller.join("\n")
+#    return (size == 0)
+#  end
+#end
+
+#require 'perftools'
+#PerfTools::CpuProfiler.start("/tmp/out.profile")
+
+#def require (o)
+#  p o
+#  Kernel.require(o)
+#end
+
+#require 'profile'
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftEchoTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_echo
+
+    pdef = Ruote.process_definition :name => 'test' do
+      echo 'a'
+    end
+
+    #noisy
+
+    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
+  #      set :v => 'toto', :value => 'otot'
+  #      echo '${toto}', :escape => 'true'
+  #      echo '${toto}', :escape => true
+  #      echo :escape => true do
+  #        '${toto}'
+  #      end
+  #    end
+  #  end
+  #  assert_trace(
+  #    pdef,
+  #    ([ '${toto}' ] * 3).join("\n"))
+  #end
+end
+

data/test/functional/eft_20_save.rb

@@ -0,0 +1,116 @@
+
+#
+# testing ruote
+#
+# Mon Aug  3 12:13:11 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class EftSaveTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_save_to_variable
+
+    pdef = Ruote.process_definition :name => 'test' do
+      save :to_variable => 'v'
+      alpha
+    end
+
+    #noisy
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    ps = @engine.process(wfid)
+
+    assert_equal Hash, ps.variables['v'].class
+  end
+
+  def test_save_to_field
+
+    pdef = Ruote.process_definition :name => 'test' do
+      set :field => 'nada', :value => 'surf'
+      save :to_f => 'f'
+      alpha
+    end
+
+    #noisy
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    assert_equal 'surf', alpha.first.fields['f']['nada']
+  end
+
+  def test_save_to_field_deep
+
+    pdef = Ruote.process_definition :name => 'test' do
+      set :field => 'nada', :value => 'surf'
+      set :field => 'h', :value => {}
+      save :to_f => 'h.wi_as_before'
+      alpha
+    end
+
+    #noisy
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    #p alpha.first.fields
+    assert_equal 'surf', alpha.first.fields['h']['wi_as_before']['nada']
+  end
+
+  # sfo -> fra
+
+  def test_save_to_f # and deep f
+
+    pdef = Ruote.process_definition do
+      set 'f:x' => 'val0'
+      set 'f:h' => {}
+      save :to => 'f:h.deep'
+      save :to => 'f:a'
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+    fields = @engine.wait_for(wfid)['workitem']['fields']
+
+    assert_equal(
+      { 'deep' => { 'x' => 'val0', 'h' => {} } },
+      fields['h'])
+    assert_equal(
+      { 'x' => 'val0', 'h' => { 'deep' => { 'x' => 'val0', 'h' => { }  } } },
+      fields['a'])
+  end
+
+  def test_save_to_v
+
+    pdef = Ruote.process_definition do
+      set 'f:x' => 'val0'
+      save :to => 'v:a'
+      set 'f:y' => '$v:a'
+    end
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+    fields = @engine.wait_for(wfid)['workitem']['fields']
+
+    assert_equal({ 'x' => 'val0' }, fields['y'])
+  end
+end
+

data/test/functional/eft_21_restore.rb

@@ -0,0 +1,61 @@
+
+#
+# testing ruote
+#
+# Tue Aug  4 08:53:33 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftRestoreTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_save_to_variable
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        set :field => 'nada', :value => 'surf'
+        save :to_variable => 'v'
+        unset :field => 'nada'
+        echo '-${f:nada}-'
+        restore :from_variable => 'v'
+        echo '-${f:nada}-'
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ -- -surf- ], pdef
+  end
+
+  def test_set_fields
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        set_fields :val => { 'a' => 'A', 'b' => 'B' }
+        echo '-${f:a}-'
+      end
+    end
+
+    #noisy
+
+    assert_trace '-A-', pdef
+  end
+
+  def test_set_fields_deep
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        set :f => 'h', :val => {}
+        set_fields :val => { 'a' => 'A', 'b' => 'B' }, :to => 'h.hh'
+        echo '-${f:h.hh.b}-'
+      end
+    end
+
+    #noisy
+
+    assert_trace '-B-', pdef
+  end
+end
+

data/test/functional/eft_22_noop.rb

@@ -0,0 +1,28 @@
+
+#
+# testing ruote
+#
+# Sun Aug 16 20:46:13 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftNoOpTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_no_operation
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        noop
+        echo 'done.'
+      end
+    end
+
+    #noisy
+
+    assert_trace('done.', pdef)
+  end
+end
+

data/test/functional/eft_23_apply.rb

@@ -0,0 +1,168 @@
+
+#
+# testing ruote
+#
+# Thu Aug 20 13:21:54 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftApplyTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_empty_apply
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        echo 'in'
+        apply
+        echo 'out.'
+      end
+    end
+
+    #noisy
+
+    assert_trace(%w[ in out. ], pdef)
+  end
+
+  def test_apply_tree
+
+    pdef = Ruote.process_definition :name => 'test' do
+      apply :tree => [ 'echo', { 'nada' => nil }, [] ]
+    end
+
+    #noisy
+
+    assert_trace('nada', pdef)
+  end
+
+  def test_apply_default_tree_variable
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        set :var => 'tree', :val => [ 'echo', { 'nada' => nil }, [] ]
+        apply
+      end
+    end
+
+    #noisy
+
+    assert_trace('nada', pdef)
+  end
+
+  def test_apply_tree_variable
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        set :var => 't', :val => [ 'echo', { 'nada' => nil }, [] ]
+        apply :tree_var => 't'
+      end
+    end
+
+    #noisy
+
+    assert_trace('nada', pdef)
+  end
+
+  def test_apply_tree_field
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        set :field => 't', :val => [ 'echo', { 'nada' => nil }, [] ]
+        #apply :tree_field => 't'
+        apply :tree_f => 't'
+      end
+    end
+
+    #noisy
+
+    assert_trace('nada', pdef)
+  end
+
+  def test_apply_attributes_as_variables
+
+    pdef = Ruote.process_definition :name => 'test' do
+      apply :tree => [ 'echo', { 'a:${v:a}' => nil }, [] ], :a => 'surf'
+    end
+
+    #noisy
+
+    assert_trace('a:surf', pdef)
+  end
+
+  def test_apply_default_with_attributes_as_variables
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        set :var => 'tree', :val => [ 'echo', { 'a:${v:a}' => nil }, [] ], :escape => true
+        apply
+        apply :a => 'surf'
+      end
+    end
+
+    #noisy
+
+    assert_trace(%w[ a: a:surf ], pdef)
+  end
+
+  def test_apply_within_subprocess
+
+    pdef = Ruote.process_definition 'test' do
+      sub0 do
+        echo 'nada'
+      end
+      define 'sub0' do
+        sequence do
+          apply
+          apply
+          apply
+        end
+      end
+    end
+
+    #noisy
+
+    assert_trace(%w[ nada ] * 3, pdef)
+  end
+
+  def test_apply_within_subprocess_2
+
+    pdef = Ruote.process_definition 'test' do
+      subprocess :ref => 'sub0' do
+        echo 'nada'
+      end
+      define 'sub0' do
+        apply
+      end
+    end
+
+    #noisy
+
+    assert_trace('nada', pdef)
+  end
+
+  def test_apply_on_error
+
+    pdef = Ruote.process_definition do
+      handle do
+        sequence do
+          echo 'in'
+          nemo
+        end
+      end
+      define 'handle' do
+        apply :on_error => 'notify'
+        echo 'over.'
+      end
+      define 'notify' do
+        echo 'error'
+      end
+    end
+
+    #noisy
+
+    assert_trace(%w[ in error over. ], pdef)
+  end
+end
+