ruote 2.3.0.1 → 2.3.0.2

data/test/functional/eft_16_if.rb

@@ -20,8 +20,6 @@ class EftIfTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
     assert_trace('then', pdef)
   end
 
@@ -34,8 +32,6 @@ class EftIfTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
     assert_trace('else', pdef)
   end
 
@@ -49,8 +45,6 @@ class EftIfTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
     assert_trace('done.', pdef)
   end
 
@@ -65,8 +59,6 @@ class EftIfTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
     assert_trace('done.', pdef)
   end
 
@@ -80,8 +72,6 @@ class EftIfTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
     assert_trace('then', pdef)
   end
 
@@ -95,8 +85,6 @@ class EftIfTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
     assert_trace('else', pdef)
   end
 
@@ -111,8 +99,6 @@ class EftIfTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
     assert_trace('done.', pdef)
   end
 
@@ -139,11 +125,33 @@ class EftIfTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
     assert_trace(%w[ then else else else ], pdef)
   end
 
+  # For ruote-mon and its dot/dollar escaping scheme.
+  #
+  # (Fukuoka Ruby Kaigi 01 2012/12/01)
+  #
+  def test_attribute_text_and_dots
+
+    @dashboard.context['ruby_eval_allowed'] = true
+
+    pdef = Ruote.define do
+      _if '${r:"".length == 0}' do
+      #_if :test => '${r:"".length == 0}' do
+        echo 'a'
+        echo 'b'
+      end
+      _if '${r:"".length == 1}' do
+      #_if :test => '${r:"".length == 1}' do
+        echo 'a'
+        echo 'b'
+      end
+    end
+
+    assert_trace(%w[ a b ], pdef)
+  end
+
   def test_xml_equals
 
     require_json

data/test/functional/eft_18_concurrent_iterator.rb

@@ -256,7 +256,7 @@ class EftConcurrentIteratorTest < Test::Unit::TestCase
   def test_merge_type_isolate
 
     pdef = Ruote.process_definition do
-      concurrent_iterator :on => 'a, b, c', :to_f => 'f', :merge_type => 'isolate' do
+      concurrent_iterator :on => 'a, b, c', :to_f => 'f', :mt => 'isolate' do
         echo '.'
       end
       bravo
@@ -458,6 +458,36 @@ class EftConcurrentIteratorTest < Test::Unit::TestCase
     assert_equal nil, r['workitem']['fields']['d']
   end
 
+#  #class MeasureParticipant < Ruote::Participant
+#  #  def on_workitem
+#  #    sleep(10 * rand)
+#  #    ps = @context.dashboard.ps(workitem.wfid)
+#  #    ci = ps.expressions.find { |e| e.name == 'citerator' }
+#  #    $volume = [ $volume, ci.h.inspect.length ].max
+#  #    reply
+#  #  end
+#  #end
+#
+#  def test_merge_volume_xxx
+#
+#    #@dashboard.register 'measure', MeasureParticipant
+#    @dashboard.register 'measure', Ruote::NoOpParticipant
+#
+#    n = 500
+#
+#    pdef = Ruote.define do
+#      citerator :on => (1..n).to_a do
+#      #iterator :on => (1..n).to_a do
+#        measure
+#      end
+#    end
+#
+#    wfid = @dashboard.launch(pdef)
+#    r = @dashboard.wait_for(wfid)
+#
+#    assert_equal 'terminated', r['action']
+#  end
+
   protected
 
   def register_catchall_participant

data/test/functional/eft_6_concurrence.rb

@@ -196,30 +196,32 @@ class EftConcurrenceTest < Test::Unit::TestCase
 
   # helper
   #
-  def run_concurrence(concurrence_attributes, noise)
+  def run_concurrence(concurrence_attributes)
 
-    pdef = Ruote.process_definition do
-      sequence do
-        concurrence(concurrence_attributes) do
-          alpha
-          alpha
-        end
+    reverse_reply_order = concurrence_attributes.delete(:_reverse_reply_order)
+
+    pdef = Ruote.define do
+      concurrence(concurrence_attributes) do
+        alpha
+        alpha
+        alpha
       end
       alpha
     end
 
     alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
-    noisy if noise
-
     wfid = @dashboard.launch(pdef)
 
-    wait_for(:alpha)
-    wait_for(:alpha)
+    3.times { wait_for('dispatched') }
 
-    2.times do
-      wi = alpha.first
+    wis = @dashboard.storage_participant.to_a
+    wis.reverse! if reverse_reply_order
+    wis.each do |wi|
       wi.fields['seen'] = wi.fei.expid
+      wi.fields[wi.fei.expid] = 'alpha'
+      wi.fields['a'] = [ wi.fei.expid, 'x' ]
+      wi.fields['h'] = { wi.fei.expid => 9 }
       alpha.proceed(wi)
     end
 
@@ -233,51 +235,165 @@ class EftConcurrenceTest < Test::Unit::TestCase
     wi
   end
 
-  def test_default_merge
+  #
+  # merge tests
+
+  def test_default_merge # first
 
-    wi = run_concurrence({}, false)
+    wi = run_concurrence({})
 
-    assert_equal '0_1', wi.fei.expid
-    assert_not_nil wi.fields['seen']
+    assert_equal '0_0_0', wi.fields['seen']
+  end
+
+  def test_default_merge__reverse # first
+
+    wi = run_concurrence(:_reverse_reply_order => true)
+
+    assert_equal '0_0_2', wi.fields['seen']
   end
 
   def test_merge_last
 
-    wi = run_concurrence({ :merge => :last }, false)
+    wi = run_concurrence(:merge => :last)
+
+    assert_equal '0_0_2', wi.fields['seen']
+  end
+
+  def test_merge_last__reverse
+
+    wi = run_concurrence(:merge => :last, :_reverse_reply_order => true)
+
+    assert_equal '0_0_0', wi.fields['seen']
+  end
+
+  def test_merge_highest
+
+    wi = run_concurrence(:merge => :highest)
+
+    assert_equal '0_0_0', wi.fields['seen']
+  end
+
+  def test_merge_highest__reverse
+
+    wi = run_concurrence(:merge => :highest, :_reverse_reply_order => true)
+
+    assert_equal '0_0_0', wi.fields['seen']
+  end
+
+  def test_merge_lowest
+
+    wi = run_concurrence(:merge => :lowest)
+
+    assert_equal '0_0_2', wi.fields['seen']
+  end
+
+  def test_merge_lowest__reverse
+
+    wi = run_concurrence(:merge => :lowest, :_reverse_reply_order => true)
+
+    assert_equal '0_0_2', wi.fields['seen']
+  end
+
+  #
+  # merge_type tests
+
+  #def test_merge_type_override # already tested above
+  #end
+
+  def test_merge_type_mix
+
+    wi = run_concurrence(:merge_type => :mix)
 
-    assert_equal '0_1', wi.fei.expid
-    assert_not_nil wi.fields['seen']
+    assert_equal(
+      %w[ 0_0_0 0_0_1 0_0_2 a dispatched_at h params seen ],
+      wi.fields.keys.collect { |k| k.to_s }.sort)
+
+    assert_equal('0_0_0', wi.fields['seen'])
   end
 
-  def test_concurrence_merge_type_isolate
+  def test_merge_type_isolate
 
-    wi = run_concurrence({ :merge_type => :isolate }, false)
+    wi = run_concurrence(:merge_type => :isolate)
 
     assert_equal(
-      %w[ 0 1 dispatched_at params ],
+      %w[ 0 1 2 dispatched_at params ],
       wi.fields.keys.collect { |k| k.to_s }.sort)
 
     assert_equal({ 'ref' => 'alpha' }, wi.fields['params'])
-    assert_equal(%w[ seen ], wi.fields['0'].keys)
-    assert_equal(%w[ seen ], wi.fields['1'].keys)
+    assert_equal(%w[ 0_0_0 a h seen ], wi.fields['0'].keys.sort)
+    assert_equal(%w[ 0_0_1 a h seen ], wi.fields['1'].keys.sort)
+    assert_equal(%w[ 0_0_2 a h seen ], wi.fields['2'].keys.sort)
   end
 
-  def test_concurrence_merge_type_stack
+  def test_merge_type_stack
 
-    wi = run_concurrence({ :merge_type => :stack }, false)
+    wi = run_concurrence(:merge_type => :stack)
 
     assert_equal(
       %w[ dispatched_at params stack stack_attributes ],
       wi.fields.keys.collect { |k| k.to_s }.sort)
 
     assert_equal({ 'ref' => 'alpha' }, wi.fields['params'])
-    assert_equal(%w[ seen ], wi.fields['stack'][0].keys)
-    assert_equal(%w[ seen ], wi.fields['stack'][1].keys)
+    assert_equal(%w[ 0_0_0 a h seen ], wi.fields['stack'][0].keys.sort)
+    assert_equal(%w[ 0_0_1 a h seen ], wi.fields['stack'][1].keys.sort)
+    assert_equal(%w[ 0_0_2 a h seen ], wi.fields['stack'][2].keys.sort)
+  end
+
+  def test_merge_type_union
+
+    wi = run_concurrence(:merge_type => :union)
+
+    assert_equal(
+      %w[ 0_0_0 0_0_1 0_0_2 a dispatched_at h params seen ],
+      wi.fields.keys.collect { |k| k.to_s }.sort)
+
+    assert_equal('0_0_2', wi.fields['seen'])
+    assert_equal(%w[ 0_0_0 x 0_0_1 0_0_2 ], wi.fields['a'])
+    assert_equal(%w[ 0_0_0 0_0_1 0_0_2 ], wi.fields['h'].keys.sort)
+  end
+
+  def test_merge_type_concat
+
+    wi = run_concurrence(:merge_type => :concat)
+
+    assert_equal(
+      %w[ 0_0_0 0_0_1 0_0_2 a dispatched_at h params seen ],
+      wi.fields.keys.collect { |k| k.to_s }.sort)
+
+    assert_equal('0_0_2', wi.fields['seen'])
+    assert_equal(%w[ 0_0_0 x 0_0_1 x 0_0_2 x], wi.fields['a'])
+    assert_equal(%w[ 0_0_0 0_0_1 0_0_2 ], wi.fields['h'].keys.sort)
   end
 
+  # not deep enough though
+  #
+  def test_merge_type_deep
+
+    wi = run_concurrence(:merge_type => :deep)
+
+    assert_equal(
+      %w[ 0_0_0 0_0_1 0_0_2 a dispatched_at h params seen ],
+      wi.fields.keys.collect { |k| k.to_s }.sort)
+
+    assert_equal('0_0_2', wi.fields['seen'])
+    assert_equal(%w[ 0_0_0 x 0_0_1 x 0_0_2 x ], wi.fields['a'])
+    assert_equal(%w[ 0_0_0 0_0_1 0_0_2 ], wi.fields['h'].keys.sort)
+  end
+
+  def test_merge_type_ignore
+
+    wi = run_concurrence(:merge_type => :ignore)
+
+    assert_equal(
+      %w[ dispatched_at params ], wi.fields.keys.collect { |k| k.to_s }.sort)
+  end
+
+  #
+  # count tests
+
   # helper
   #
-  def run_test_count(remaining, noise)
+  def run_test_count(remaining)
 
     pdef = Ruote.process_definition do
       concurrence :count => 1, :remaining => remaining do
@@ -288,8 +404,6 @@ class EftConcurrenceTest < Test::Unit::TestCase
 
     @dashboard.register_participant '.+', Ruote::StorageParticipant
 
-    noisy if noise
-
     wfid = @dashboard.launch(pdef)
 
     wait_for(:alpha)
@@ -303,7 +417,7 @@ class EftConcurrenceTest < Test::Unit::TestCase
 
   def test_count
 
-    wfid = run_test_count('cancel', false)
+    wfid = run_test_count('cancel')
 
     #puts
     #logger.log.each { |e| p e }
@@ -317,7 +431,7 @@ class EftConcurrenceTest < Test::Unit::TestCase
 
   def test_count_remaining_forget
 
-    wfid = run_test_count('forget', false)
+    wfid = run_test_count('forget')
 
     #assert_equal 1, logger.log.select { |e| e['action'] == 'forget' }.size
 
@@ -326,6 +440,7 @@ class EftConcurrenceTest < Test::Unit::TestCase
 
     #@dashboard.context.storage.get_many('expressions').each { |e| p e['fei'] }
     #puts @dashboard.context.storage.dump('expressions')
+    #p @dashboard.ps(wfid)
     assert_equal 2, @dashboard.context.storage.get_many('expressions').size
     assert_not_nil @dashboard.process(wfid)
 

data/test/functional/ft_10_dollar.rb

@@ -21,8 +21,6 @@ class FtDollarTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
     assert_trace 'field', pdef
   end
 
@@ -38,8 +36,6 @@ class FtDollarTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
     assert_trace(%w[ a b0 c0 d0 ], pdef)
   end
 
@@ -57,8 +53,6 @@ class FtDollarTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
     assert_trace(%w[ a:toto b:atlantic_city ], pdef)
   end
 
@@ -73,8 +67,6 @@ class FtDollarTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
     assert_trace(%w[ a btoto cAsia ], pdef)
   end
 
@@ -86,8 +78,6 @@ class FtDollarTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
     wfid = @dashboard.launch(pdef)
 
     @dashboard.wait_for(wfid)
@@ -106,8 +96,6 @@ class FtDollarTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
     @dashboard.context['ruby_eval_allowed'] = true
 
     assert_trace('>3<', pdef)
@@ -124,8 +112,6 @@ class FtDollarTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
     @dashboard.context['ruby_eval_allowed'] = true
 
     assert_trace [ 'person' ] * 3, pdef
@@ -140,8 +126,6 @@ class FtDollarTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
     @dashboard.context['ruby_eval_allowed'] = true
 
     assert_trace 'person', pdef
@@ -157,8 +141,6 @@ class FtDollarTest < Test::Unit::TestCase
       end
     end
 
-    #noisy
-
     assert_trace 'AA', pdef
   end
 
@@ -189,8 +171,6 @@ class FtDollarTest < Test::Unit::TestCase
 
     @dashboard.context['ruby_eval_allowed'] = true
 
-    #noisy
-
     assert_trace 'alpha/bravo/charly', pdef
   end
 
@@ -221,11 +201,14 @@ class FtDollarTest < Test::Unit::TestCase
       set 'f:F' => '$a'
       set 'f:G' => '$nada'
       set 'f:H' => '$a '
+      set 'f:I' => '$v:a '
+      set 'f:J' => ' $a'
+      set 'f:K' => ' $v:a'
+      set 'f:L' => '$$'
+      set 'f:M' => '$$a'
       filter :f => /^[a-c]$/, :del => true
     end
 
-    #noisy
-
     wfid = @dashboard.launch(pdef)
 
     r = @dashboard.wait_for(wfid)
@@ -235,11 +218,16 @@ class FtDollarTest < Test::Unit::TestCase
         'A' => %w[ A B C ],
         'B' => %w[ A B C ],
         'C' => %w[ venture capitalist ],
-        'D' => '$f:nada',
-        'E' => '$v:nada',
+        'D' => nil,
+        'E' => nil,
         'F' => %w[ A B C ],
-        'G' => '$nada',
-        'H' => '$a '
+        'G' => nil,
+        'H' => '$a ',
+        'I' => '$v:a ',
+        'J' => ' $a',
+        'K' => ' $v:a',
+        'L' => '$$',
+        'M' => '$$a'
       },
       r['workitem']['fields'])
   end
@@ -255,8 +243,6 @@ class FtDollarTest < Test::Unit::TestCase
       wi.fields['parameters'] = wi.fields['params']
     end
 
-    #noisy
-
     wfid = @dashboard.launch(pdef)
 
     r = @dashboard.wait_for(wfid)
@@ -304,8 +290,6 @@ class FtDollarTest < Test::Unit::TestCase
 
   def test_participant_params
 
-    #@dashboard.noisy = true
-
     @dashboard.register :toto do |workitem, fexp|
       workitem['a'] = fexp.compile_atts
       workitem['p'] = workitem.params