ruote-maestrodev 2.2.1

data/test/functional/eft_7_forget.rb

@@ -0,0 +1,61 @@
+
+#
+# testing ruote
+#
+# Sun Jun 14 13:33:17 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftForgetTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_basic
+
+    pdef = Ruote.process_definition do
+      sequence do
+        forget do
+          alpha
+        end
+        alpha
+      end
+    end
+
+    @engine.register_participant :alpha do
+      @tracer << "alpha\n"
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+    wait_for(:alpha)
+    wait_for(wfid)
+    wait_for(wfid)
+
+    assert_equal "alpha\nalpha", @tracer.to_s
+
+    #logger.log.each { |e| puts e['action'] }
+    assert_equal 1, logger.log.select { |e| e['action'] == 'ceased' }.size
+    assert_equal 1, logger.log.select { |e| e['action'] == 'terminated' }.size
+  end
+
+  #def test_variables
+  #  pdef = Ruote.process_definition do
+  #    set :var => 'a', :value => 0
+  #    concurrence do
+  #      set :var => 'a', :value => 1
+  #      forget do
+  #        echo '0_${v:a}'
+  #      end
+  #      echo '1_${v:a}'
+  #    end
+  #    echo '2_${v:a}'
+  #  end
+  #  noisy
+  #  assert_trace %w[ 1_1 0_0 2_1 ], pdef
+  #end
+end
+

data/test/functional/eft_8_undo.rb

@@ -0,0 +1,114 @@
+
+#
+# testing ruote
+#
+# Sun Jun 14 14:48:03 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class EftUndoTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_undo_ref
+
+    pdef = Ruote.process_definition do
+      concurrence do
+        alpha :tag => 'kilroy'
+        undo :ref => 'kilroy'
+      end
+      echo 'over'
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    assert_trace %w[ over ], pdef
+
+    assert_equal 0, alpha.size
+
+    assert_equal 1, logger.log.select { |e| e['action'] == 'entered_tag' }.size
+    assert_equal 1, logger.log.select { |e| e['action'] == 'cancel' }.size
+    assert_equal 1, logger.log.select { |e| e['action'] == 'left_tag' }.size
+  end
+
+  def test_undo
+
+    pdef = Ruote.process_definition do
+      concurrence do
+        alpha :tag => :kilroy
+        #undo :kilroy
+        cancel :kilroy
+      end
+      echo 'over'
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    assert_trace %w[ over ], pdef
+
+    assert_equal 0, alpha.size
+
+    assert_equal 1, logger.log.select { |e| e['action'] == 'entered_tag' }.size
+    assert_equal 1, logger.log.select { |e| e['action'] == 'cancel' }.size
+    assert_equal 1, logger.log.select { |e| e['action'] == 'left_tag' }.size
+  end
+
+  def test_undo_parent
+
+    pdef = Ruote.process_definition do
+      sequence :tag => :richard do
+        cancel :richard
+        echo 'out'
+      end
+      echo '.'
+    end
+
+    #noisy
+
+    assert_trace '.', pdef
+  end
+
+  def test_undo_missing_tag
+
+    pdef = Ruote.process_definition do
+      cancel :nada
+      echo '.'
+    end
+
+    assert_trace '.', pdef
+  end
+
+  def test_undo_tag_pointing_nowhere
+
+    pdef = Ruote.process_definition do
+      set 'v:nada' => []
+      cancel :nada
+      echo '.'
+    end
+
+    #@engine.noisy = true
+
+    assert_trace '.', pdef
+  end
+
+  def test_undo_tag_pointing_to_missing_fei
+
+    pdef = Ruote.process_definition do
+      set 'v:nada' => { 'wfid' => '${wfid}', 'expid' => '${expid}', 'engine_id' => '${engine_id}' }
+      cancel :nada
+      echo '.'
+    end
+
+    #@engine.noisy = true
+
+    assert_trace '.', pdef
+  end
+end
+

data/test/functional/eft_9_redo.rb

@@ -0,0 +1,138 @@
+
+#
+# testing ruote
+#
+# Mon Jun 15 12:58:12 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class EftRedoTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_redo
+
+    pdef = Ruote.process_definition do
+      sequence :tag => 'seq' do
+        alpha
+        _redo :ref => 'seq'
+      end
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(:alpha)
+
+    alpha.proceed(alpha.first)
+    wait_for(:alpha)
+
+    alpha.proceed(alpha.first)
+    wait_for(:alpha)
+
+    ps = @engine.process(wfid)
+
+    assert_equal 0, ps.errors.size
+    assert_equal 3, ps.expressions.size
+
+    assert_equal 3, logger.log.select { |e| e['action'] == 'entered_tag' }.size
+  end
+
+  def test_redo_missing_tag
+
+    pdef = Ruote.process_definition do
+      _redo :nada
+      echo '.'
+    end
+
+    assert_trace '.', pdef
+  end
+
+  def test_redo_tag_pointing_nowhere
+
+    pdef = Ruote.process_definition do
+      set 'v:nada' => []
+      _redo :nada
+      echo '.'
+    end
+
+    #@engine.noisy = true
+
+    assert_trace '.', pdef
+  end
+
+  def test_redo_tag_pointing_to_missing_fei
+
+    pdef = Ruote.process_definition do
+      set 'v:nada' => { 'wfid' => '${wfid}', 'expid' => '${expid}', 'engine_id' => '${engine_id}' }
+      _redo :nada
+      echo '.'
+    end
+
+    #@engine.noisy = true
+
+    assert_trace '.', pdef
+  end
+
+  def test_forget_and_redo
+
+    pdef = Ruote.process_definition do
+      sequence :tag => 'x' do
+        alpha :forget => true
+        _redo 'x'
+      end
+    end
+
+    #noisy
+
+    @engine.register 'alpha', Ruote::StorageParticipant
+
+    wfid = @engine.launch(pdef)
+
+    while @engine.storage_participant.size < 2
+      sleep 0.350
+    end
+
+    assert_not_nil @engine.process(wfid)
+    assert_equal [], @engine.errors
+  end
+
+  class Alpha
+    include Ruote::LocalParticipant
+    @@seen = false
+    def consume(workitem)
+      (workitem.fields['alpha'] ||= []) << 'x'
+      workitem.fields['over'] = @@seen
+      @@seen = true
+      reply_to_engine(workitem)
+    end
+  end
+
+  def test_redo__blank_workitem
+
+    @engine.register do
+      alpha Alpha
+    end
+
+    pdef = Ruote.process_definition do
+      sequence :tag => 'x' do
+        alpha
+        _redo 'x', :unless => '${over}'
+      end
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    r = @engine.wait_for(wfid)
+
+    assert_equal %w[ x ], r['workitem']['fields']['alpha']
+  end
+end
+

data/test/functional/ft_0_worker.rb

@@ -0,0 +1,65 @@
+
+#
+# testing ruote
+#
+# Fri May 15 09:51:28 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/null_participant'
+
+
+class FtWorkerTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_launch_terminate
+
+    #noisy
+
+    pdef = Ruote.process_definition do
+    end
+
+    assert_trace '', pdef
+
+    #puts; logger.log.each { |e| p e }; puts
+    assert_equal %w[ launch terminated ], logger.log.map { |e| e['action'] }
+  end
+
+  def test_stop_worker
+
+    sleep 0.010 # warm up time
+
+    assert_equal true, @engine.context.worker.running
+
+    @engine.shutdown
+
+    assert_equal false, @engine.context.worker.running
+
+    pdef = Ruote.process_definition do; end
+
+    @engine.launch(pdef)
+
+    Thread.pass
+
+    #assert_equal 1, @engine.storage.get_many('msgs').size
+      # won't work with the latest ruote-redis implementations
+
+    assert_equal 1, @engine.storage.get_msgs.size
+  end
+
+  def test_remaining_messages
+
+    @engine.register_participant :alfred, Ruote::NullParticipant
+
+    pdef = Ruote.process_definition do
+    end
+
+    assert_trace '', pdef
+
+    sleep 0.300
+
+    assert_equal [], @engine.storage.get_msgs
+  end
+end
+

data/test/functional/ft_10_dollar.rb

@@ -0,0 +1,304 @@
+
+#
+# testing ruote
+#
+# Wed Jun 10 22:57:18 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtDollarTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_default
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set :var => 'x', :val => 'variable'
+        set :field => 'x', :val => 'field'
+        echo '${x}'
+      end
+    end
+
+    #noisy
+
+    assert_trace 'field', pdef
+  end
+
+  def test_v
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'a${v:missing}'
+        set :var => 'v0', :val => '0'
+        echo 'b${v:v0}'
+        echo 'c${var:v0}'
+        echo 'd${variable:v0}'
+      end
+    end
+
+    #noisy
+
+    assert_trace(%w[ a b0 c0 d0 ], pdef)
+  end
+
+  def test_nested_v
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set(
+          :var => 'v0',
+          :val => {
+            'name' => 'toto',
+            'address' => [ 'e-street', 'atlantic_city' ] })
+        echo 'a:${v:v0.name}'
+        echo 'b:${v:v0.address.1}'
+      end
+    end
+
+    #noisy
+
+    assert_trace(%w[ a:toto b:atlantic_city ], pdef)
+  end
+
+  def test_f
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set :field => 'f', :val => { 'name' => 'toto', 'address' => %w[ KL Asia ]}
+        echo 'a${f:missing}'
+        echo 'b${f:f.name}'
+        echo 'c${f:f.address.1}'
+      end
+    end
+
+    #noisy
+
+    assert_trace(%w[ a btoto cAsia ], pdef)
+  end
+
+  def test_no_r
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo '>${r:1 + 2}<'
+      end
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(wfid)
+
+    assert_equal(
+      "#<ArgumentError: 'ruby_eval_allowed' is set to false, cannot evaluate" +
+      " >1 + 2< (http://ruote.rubyforge.org/dollar.html)>",
+      @engine.errors.first.message)
+  end
+
+  def test_r
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo '>${r:1 + 2}<'
+      end
+    end
+
+    #noisy
+
+    @engine.context['ruby_eval_allowed'] = true
+
+    assert_trace('>3<', pdef)
+  end
+
+  def test_r_and_wi
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set 'f:toto' => 'person'
+        echo "${r:wi.fields['toto']}"
+        echo "${r:workitem.fields['toto']}"
+      end
+    end
+
+    #noisy
+
+    @engine.context['ruby_eval_allowed'] = true
+
+    assert_trace "person\nperson", pdef
+  end
+
+  def test_r_and_d
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set 'f:toto' => 'person'
+        echo "${r:d('f:toto')}"
+      end
+    end
+
+    #noisy
+
+    @engine.context['ruby_eval_allowed'] = true
+
+    assert_trace 'person', pdef
+  end
+
+  def test_nested
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set 'f:a' => 'a'
+        set 'v:a' => 'AA'
+        echo '${v:${f:a}}'
+      end
+    end
+
+    #noisy
+
+    assert_trace 'AA', pdef
+  end
+
+  def test_fei_and_wfid
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo '${fei}'
+        echo '${wfid}'
+      end
+    end
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(wfid)
+
+    assert_match /^0_0_0![^!]+!#{wfid}\n#{wfid}$/, @tracer.to_s
+  end
+
+  def test_direct_access_to_fields
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set 'f:a' => [ 'alpha', 'bravo', 'charly' ]
+        echo '${r:a.join("/")}'
+      end
+    end
+
+    @engine.context['ruby_eval_allowed'] = true
+
+    #noisy
+
+    assert_trace 'alpha/bravo/charly', pdef
+  end
+
+  def test_dollar_quote
+
+    pdef = Ruote.define do
+      set 'f:a' => 'alpha'
+      set 'f:b' => 'bra vo'
+      echo '${"f:a}'
+      echo "${'f:a}"
+      echo 'ok', :if => "${'f:b} == 'bra vo'"
+    end
+
+    assert_trace %w[ "alpha" "alpha" ok ], pdef
+  end
+
+  def test_literally
+
+    pdef = Ruote.define do
+      set 'f:a' => %w[ A B C ]
+      set 'f:b' => 'a'
+      set 'v:c' => %w[ venture capitalist ]
+      set 'f:A' => '$f:a'
+      set 'f:B' => '$f:${b}'
+      set 'f:C' => '$v:c'
+      set 'f:D' => '$f:nada'
+      set 'f:E' => '$v:nada'
+      set 'f:F' => '$a'
+      set 'f:G' => '$nada'
+      set 'f:H' => '$a '
+      filter :f => /^[a-c]$/, :del => true
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    r = @engine.wait_for(wfid)
+
+    assert_equal(
+      {
+        'A' => %w[ A B C ],
+        'B' => %w[ A B C ],
+        'C' => %w[ venture capitalist ],
+        'D' => '$f:nada',
+        'E' => '$v:nada',
+        'F' => %w[ A B C ],
+        'G' => '$nada',
+        'H' => '$a '
+      },
+      r['workitem']['fields'])
+  end
+
+  def test_literally_and_participant_params
+
+    pdef = Ruote.define do
+      set 'f:a' => %w[ A B C ]
+      alpha :b => '$f:a'
+    end
+
+    @engine.register_participant :alpha do |wi|
+      wi.fields['parameters'] = wi.fields['params']
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    r = @engine.wait_for(wfid)
+
+    assert_equal(
+      { 'b' => %w[ A B C ], 'ref' => 'alpha' },
+      r['workitem']['fields']['parameters'])
+  end
+
+  # Issue pointed out by John Le.
+  #
+  def test_not_a_number
+
+    pdef = Ruote.define do
+      echo 'a0', :if => '${a}'
+      echo 'a1', :if => '${a} is set'
+      echo 'b', :if => '${b}'
+      echo 'c'
+    end
+
+    wfid = @engine.launch(
+      pdef,
+      'a' => '0a')
+
+    @engine.wait_for(wfid)
+
+    assert_equal "a0\na1\nc", @tracer.to_s
+  end
+
+  def test_literal
+
+    pdef = Ruote.define do
+      set 'f:a' => true
+      _if '$a' do
+        echo 'a0'
+      end
+      echo 'a1', :if => '$a'
+    end
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(wfid)
+
+    assert_equal "a0\na1", @tracer.to_s
+  end
+end
+