ruote 2.2.0 → 2.3.0

data/test/functional/eft_4_set.rb

@@ -5,7 +5,7 @@
 # Wed May 20 09:23:01 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'base')
+require File.expand_path('../base', __FILE__)
 
 
 class EftSetTest < Test::Unit::TestCase
@@ -129,10 +129,10 @@ class EftSetTest < Test::Unit::TestCase
       alpha
     end
 
-    @engine.register_participant :alpha do |workitem|
+    @dashboard.register_participant :alpha do |workitem|
       workitem.fields.delete('params')
       workitem.fields.delete('dispatched_at')
-      @tracer << workitem.fields.inspect
+      tracer << workitem.fields.inspect
     end
 
     assert_trace '{"f"=>nil}', pdef
@@ -164,9 +164,8 @@ class EftSetTest < Test::Unit::TestCase
       end
     end
 
-    @engine.register_participant :alpha do |workitem|
-      @tracer << workitem.fields['f']
-      @tracer << "\n"
+    @dashboard.register_participant :alpha do |workitem|
+      tracer << workitem.fields['f'] + "\n"
     end
 
     #noisy
@@ -219,12 +218,12 @@ class EftSetTest < Test::Unit::TestCase
 
     #noisy
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
     wait_for(wfid)
 
-    assert_nil @engine.process(wfid)
-    assert_nil @engine.variables['v']
+    assert_nil @dashboard.process(wfid)
+    assert_nil @dashboard.variables['v']
   end
 
   # 'rset' is an alias for 'set'.
@@ -233,13 +232,113 @@ class EftSetTest < Test::Unit::TestCase
   #
   def test_rset
 
-    wfid = @engine.launch(Ruote.define do
+    wfid = @dashboard.launch(Ruote.define do
       rset 'developer' => 'Rebo'
     end)
 
-    r = @engine.wait_for(wfid)
+    r = @dashboard.wait_for(wfid)
 
     assert_equal 'Rebo', r['workitem']['fields']['developer']
   end
+
+  def test_unset_field
+
+    pdef = Ruote.define do
+
+      set 'f:alpha' => 'alice'
+      set 'f:bravo' => 'bob'
+      set 'f:charly' => 'charles'
+      set 'f:__timed_out__' => %w[ seriously ]
+      set 'f:delta' => { 'echo' => 'e', 'foxtrott' => 'f' }
+
+      unset 'f:alpha'
+      unset :f => 'bravo'
+      unset :field => 'charly'
+      unset :field => '__timed_out__'
+      unset 'f:delta.echo'
+    end
+
+    wfid = @dashboard.launch(pdef)
+
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal(
+      { '__result__' => 'e', 'delta' => { 'foxtrott' => 'f' } },
+      r['workitem']['fields'])
+  end
+
+  class VarPeek
+    include Ruote::LocalParticipant
+    def consume
+      context.tracer << fexp.compile_variables.inspect
+      reply
+    end
+  end
+
+  def test_unset_var
+
+    pdef = Ruote.define do
+      set 'v:v0' => 'nada'
+      set 'v:v1' => 'nada'
+      unset 'v:v0'
+      unset :v => 'v1'
+      peek
+    end
+
+    @dashboard.register :peek, VarPeek
+
+    #@dashboard.noisy = true
+
+    wfid = @dashboard.launch(pdef)
+
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal '{}', @tracer.to_s
+  end
+
+  def test_set_sets_return_field
+
+    pdef = Ruote.define do
+      set 'v:v0' => 'nada'
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 'nada', r['workitem']['fields']['__result__']
+  end
+
+  def test_set_picks_latest
+
+    pdef = Ruote.define do
+      set 'f0' do
+        set 'v:v0' => '1'
+        set 'v:v1' => '2'
+        set 'f1' => '${v:v0}${v:v1}'
+      end
+      echo '${f0}/${v:v0}'
+    end
+
+    #@dashboard.noisy = true
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal '12', r['workitem']['fields']['f0']
+    assert_equal '12/', @tracer.to_s
+  end
+
+  def test_set_if
+
+    pdef = Ruote.define do
+      set 'f:x' => '${v:v_r}', :if => '${v:v_r}'
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal('terminated', r['action'])
+    assert_equal({}, r['workitem']['fields'])
+  end
 end
 

data/test/functional/eft_5_subprocess.rb

@@ -5,7 +5,7 @@
 # Wed May 20 17:08:17 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'base')
+require File.expand_path('../base', __FILE__)
 
 
 class EftSubprocessTest < Test::Unit::TestCase
@@ -96,7 +96,7 @@ class EftSubprocessTest < Test::Unit::TestCase
       end
     end
 
-    @engine.register_participant :alpha do |workitem, fexp|
+    @dashboard.register_participant :alpha do |workitem, fexp|
       stash[:tree] = fexp.lookup_variable('tree')
     end
 
@@ -134,13 +134,14 @@ class EftSubprocessTest < Test::Unit::TestCase
 
     #noisy
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
     wait_for(wfid)
 
     assert_equal(
       "#<RuntimeError: no subprocess named 'nada' found>",
-      @engine.process(wfid).errors.first.message)
+      #"#<RuntimeError: unknown participant or subprocess 'nada'>",
+      @dashboard.process(wfid).errors.first.message)
   end
 
   def test_subprocess_in_engine_variable
@@ -152,11 +153,32 @@ class EftSubprocessTest < Test::Unit::TestCase
       end
     end
 
-    @engine.variables['sub0'] = Ruote.process_definition do
+    @dashboard.variables['sub0'] = Ruote.process_definition do
       echo 'in sub0'
     end
 
     assert_trace "in sub0\ndone.", pdef
   end
+
+  def test_atts_to_fields
+
+    pdef = Ruote.define do
+      set 'address' => { 'city' => 'boston' }
+      subprocess(
+        'sub0',
+        'f:a' => 'fa',
+        'field:b' => 'mi',
+        'var:c' => 'sol',
+        'f:address.city' => 'nyc')
+      define 'sub0' do
+        echo '${a} ${b} ${v:c} ${address.city}'
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+    @dashboard.wait_for(wfid)
+
+    assert_equal 'fa mi sol nyc', @tracer.to_s
+  end
 end
 

data/test/functional/eft_6_concurrence.rb

@@ -5,9 +5,7 @@
 # Thu Jun 11 15:24:47 JST 2009
 #
 
-require File.join(File.dirname(__FILE__), 'base')
-
-#require 'ruote/part/hash_participant'
+require File.expand_path('../base', __FILE__)
 
 
 class EftConcurrenceTest < Test::Unit::TestCase
@@ -22,15 +20,40 @@ class EftConcurrenceTest < Test::Unit::TestCase
       end
     end
 
-    @engine.register_participant :alpha do
-      @tracer << "alpha\n"
+    @dashboard.register_participant :alpha do
+      tracer << "alpha\n"
     end
 
-    #noisy
-
     assert_trace %w[ alpha alpha ], pdef
   end
 
+  def test_empty
+
+    pdef = Ruote.process_definition do
+      concurrence do
+      end
+      echo 'done.'
+    end
+
+    assert_trace %w[ done. ], pdef
+  end
+
+  def test_accidental_empty
+
+    @dashboard.register_participant :nada do
+      tracer << "nada\n"
+    end
+
+    pdef = Ruote.process_definition do
+      concurrence do
+        nada :if => false
+      end
+      echo 'done.'
+    end
+
+    assert_trace %w[ done. ], pdef
+  end
+
   def test_over_if
 
     pdef = Ruote.process_definition do
@@ -42,35 +65,88 @@ class EftConcurrenceTest < Test::Unit::TestCase
       bravo
     end
 
-    @engine.context.instance_eval do
-      @count = 0
-    end
-      # since block participants are evaluated in the context context
+    stash[:count] = 0
 
-    alpha = @engine.register_participant :alpha, 'do_not_thread' => true do |wi|
-      wi.fields['seen'] = 'indeed' if @count == 1
-      @tracer << "alpha\n"
-      @count = @count + 1
+    alpha = @dashboard.register :alpha, 'do_not_thread' => true do |wi|
+      wi.fields['seen'] = 'indeed' if stash[:count] == 1
+      tracer << "alpha\n"
+      stash[:count] += 1
       nil
     end
 
-    @engine.register_participant :bravo do |workitem|
+    @dashboard.register_participant :bravo do |workitem|
       stash[:fields] = workitem.fields
       nil
     end
 
-    #noisy
-
     assert_trace(%w[ alpha ] * 3, pdef)
 
     #assert_equal(
     #  {'1'=>{"seen"=>"indeed"}, '0'=>{}, "params"=>{"ref"=>"bravo"}},
     #  fields)
 
-    params = @engine.context.stash[:fields].delete('params')
+    params = @dashboard.context.stash[:fields].delete('params')
 
     assert_equal({ 'ref' => 'bravo' }, params)
-    assert_match /seen/, @engine.context.stash[:fields].inspect
+    assert_match /seen/, @dashboard.context.stash[:fields].inspect
+  end
+
+  def test_over_if__remaining_cancel
+
+    @dashboard.register 'alpha', Ruote::StorageParticipant
+
+    pdef = Ruote.define do
+      concurrence :over_if => '${seen}' do
+        alpha
+        alpha
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+
+    @dashboard.wait_for('dispatched')
+
+    wi = @dashboard.storage_participant.first
+
+    wi.fields['seen'] = true
+    @dashboard.storage_participant.proceed(wi)
+
+    @dashboard.wait_for('dispatch_cancel')
+    sleep 0.350
+
+    assert_equal 0, @dashboard.storage_participant.size
+  end
+
+  def test_over_if__post
+
+    @dashboard.register :alpha do |workitem|
+      tracer << "alpha\n"
+      workitem.fields['ok'] = 'yes'
+    end
+    @dashboard.register :bravo do |workitem|
+      sleep 0.5
+      tracer << "bravo\n"
+    end
+    @dashboard.register :zulu do |workitem|
+      tracer << "zulu\n"
+    end
+
+    pdef = Ruote.define do
+      set 'f:ok' => 'no'
+      concurrence :over_if => '${f:ok} == yes' do
+      #concurrence :over_if => '${f:ok} == yes', :merge_type => 'mix' do
+        alpha
+        bravo :if => 'false'
+      end
+      zulu :if => '${f:ok} == yes'
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+    assert_equal 'yes', r['workitem']['fields']['ok']
+    assert_equal %w[ alpha zulu ], @tracer.to_a
   end
 
   def test_over_unless
@@ -85,28 +161,23 @@ class EftConcurrenceTest < Test::Unit::TestCase
       echo 'done.'
     end
 
-    @engine.context.instance_eval do
-      @count = 0
-    end
-      # since block participants are evaluated in the context context
+    stash[:count] = 0
 
-    alpha = @engine.register_participant :alpha, 'do_not_thread' => true do |wi|
-      if @count > 1
+    alpha = @dashboard.register :alpha, 'do_not_thread' => true do |wi|
+      if stash[:count] > 1
         wi.fields['ok'] = false
       else
-        @tracer << "a\n"
-        @count = @count + 1
+        tracer << "a\n"
+        stash[:count] += 1
       end
     end
 
     fields = nil
 
-    @engine.register_participant :bravo do |workitem|
+    @dashboard.register_participant :bravo do |workitem|
       fields = workitem.fields
     end
 
-    #noisy
-
     assert_trace(%w[ a a done. ], pdef)
   end
 
@@ -120,8 +191,6 @@ class EftConcurrenceTest < Test::Unit::TestCase
       echo 'done.'
     end
 
-    #noisy
-
     assert_trace %w[ a b done. ], %w[ b a done. ], pdef
   end
 
@@ -139,11 +208,11 @@ class EftConcurrenceTest < Test::Unit::TestCase
       alpha
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+    alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
     noisy if noise
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
     wait_for(:alpha)
     wait_for(:alpha)
@@ -151,14 +220,14 @@ class EftConcurrenceTest < Test::Unit::TestCase
     2.times do
       wi = alpha.first
       wi.fields['seen'] = wi.fei.expid
-      alpha.reply(wi)
+      alpha.proceed(wi)
     end
 
     wait_for(:alpha)
 
     wi = alpha.first
 
-    ps = @engine.process(wi.fei.wfid)
+    ps = @dashboard.process(wi.fei.wfid)
     assert_equal %w[ 0 0_1 ], ps.expressions.collect { |e| e.fei.expid }.sort
 
     wi
@@ -217,15 +286,15 @@ class EftConcurrenceTest < Test::Unit::TestCase
       end
     end
 
-    @engine.register_participant '.+', Ruote::StorageParticipant
+    @dashboard.register_participant '.+', Ruote::StorageParticipant
 
     noisy if noise
 
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
     wait_for(:alpha)
 
-    @engine.storage_participant.reply(@engine.storage_participant.first)
+    @dashboard.storage_participant.proceed(@dashboard.storage_participant.first)
 
     wait_for(wfid)
 
@@ -234,8 +303,6 @@ class EftConcurrenceTest < Test::Unit::TestCase
 
   def test_count
 
-    #noisy
-
     wfid = run_test_count('cancel', false)
 
     #puts
@@ -245,31 +312,47 @@ class EftConcurrenceTest < Test::Unit::TestCase
 
     sleep 0.350 # since now dispatch_cancel occurs asynchronously...
 
-    assert_equal 0, @engine.storage_participant.size
+    assert_equal 0, @dashboard.storage_participant.size
   end
 
   def test_count_remaining_forget
 
-    #noisy
-
     wfid = run_test_count('forget', false)
 
     #assert_equal 1, logger.log.select { |e| e['action'] == 'forget' }.size
 
-    assert_equal 1, @engine.storage_participant.size
-    assert_equal 'bravo', @engine.storage_participant.first.participant_name
+    assert_equal 1, @dashboard.storage_participant.size
+    assert_equal 'bravo', @dashboard.storage_participant.first.participant_name
 
-    #@engine.context.storage.get_many('expressions').each { |e| p e['fei'] }
-    #puts @engine.context.storage.dump('expressions')
-    assert_equal 2, @engine.context.storage.get_many('expressions').size
-    assert_not_nil @engine.process(wfid)
+    #@dashboard.context.storage.get_many('expressions').each { |e| p e['fei'] }
+    #puts @dashboard.context.storage.dump('expressions')
+    assert_equal 2, @dashboard.context.storage.get_many('expressions').size
+    assert_not_nil @dashboard.process(wfid)
 
-    @engine.storage_participant.reply(@engine.storage_participant.first)
+    @dashboard.storage_participant.proceed(@dashboard.storage_participant.first)
 
     wait_for(wfid)
 
-    @engine.context.storage.get_many('expressions').each { |e| p e['fei'] }
-    assert_equal 0, @engine.context.storage.get_many('expressions').size
+    @dashboard.context.storage.get_many('expressions').each { |e| p e['fei'] }
+    assert_equal 0, @dashboard.context.storage.get_many('expressions').size
+  end
+
+  def test_count_negative
+
+    pdef = Ruote.define do
+      concurrence :mt => 'mix', :c => -1 do # all but 1
+        set 'a' => 1
+        set 'b' => 2
+        set 'c' => 3
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 1, r['workitem']['fields']['a']
+    assert_equal 2, r['workitem']['fields']['b']
+    assert_equal nil, r['workitem']['fields']['c']
   end
 
   def test_cancel
@@ -281,24 +364,180 @@ class EftConcurrenceTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
+    alpha = @dashboard.register_participant :alpha, Ruote::StorageParticipant
 
-    #noisy
-
-    wfid = @engine.launch(pdef)
+    wfid = @dashboard.launch(pdef)
 
     wait_for(:alpha)
     wait_for(:alpha)
 
     assert_equal 2, alpha.size
 
-    @engine.cancel_process(wfid)
+    @dashboard.cancel_process(wfid)
 
     wait_for(wfid)
 
-    ps = @engine.process(wfid)
+    ps = @dashboard.process(wfid)
 
     assert_nil ps
   end
+
+  #
+  # 'wait_for' tests
+
+  # 'wait_for => 1' is equivalent to 'count => 1'
+  #
+  def test_wait_for_int
+
+    pdef = Ruote.define do
+      concurrence :wait_for => 1 do
+        sequence do
+          stall
+          echo 'alpha'
+        end
+        echo 'bravo'
+      end
+      echo 'over.'
+    end
+
+    wfid = @dashboard.launch(pdef)
+
+    @dashboard.wait_for(wfid)
+
+    assert_equal %w[ bravo over. ], @tracer.to_a
+  end
+
+  def test_wait_for_zero
+
+    pdef = Ruote.define do
+      concurrence :wait_for => 0, :remaining => :forget do
+        sequence do
+          wait '5s'
+          echo 'alpha'
+        end
+      end
+      echo 'over.'
+    end
+
+    wfid = @dashboard.launch(pdef)
+
+    @dashboard.wait_for(wfid)
+
+    assert_equal %w[ over. ], @tracer.to_a
+  end
+
+  def test_wait_for_tags
+
+    pdef = Ruote.define do
+      concurrence :wait_for => 'azuma, bashamichi', :merge_type => 'concat' do
+        sequence :tag => 'azuma' do
+          set 'seen' => [ 'azuma' ]
+        end
+        sequence :tag => 'bashamichi' do
+          set 'seen' => [ 'bashamichi' ]
+        end
+        sequence :tag => 'katou' do
+          set 'seen' => [ 'katou' ]
+        end
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal %w[ azuma bashamichi ], r['workitem']['fields']['seen'].sort
+  end
+
+  def test_wait_for_tags_array
+
+    pdef = Ruote.define do
+      concurrence :wait_for => %w[ azuma bashamichi ], :mt => 'concat' do
+        sequence :tag => 'azuma' do
+          set 'seen' => [ 'azuma' ]
+        end
+        sequence :tag => 'bashamichi' do
+          set 'seen' => [ 'bashamichi' ]
+        end
+        sequence :tag => 'katou' do
+          set 'seen' => [ 'katou' ]
+          wait '5s'
+        end
+      end
+    end
+
+    wfid = @dashboard.launch(pdef)
+
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal %w[ azuma bashamichi ], r['workitem']['fields']['seen'].sort
+  end
+
+  def test_wait_for_one_tag
+
+    @dashboard.register do
+      administrator do |workitem|
+        tracer << "administrator\n"
+        sleep 0.7
+      end
+      evaluator Ruote::NullParticipant
+      #evaluator Ruote::NoOpParticipant
+    end
+
+    pdef = Ruote.process_definition do
+     concurrence :wait_for => 'first' do
+       sequence :tag => 'first' do
+         administrator
+       end
+       sequence :tag => 'second' do
+         evaluator
+       end
+     end
+     echo 'done.'
+    end
+
+    wfid = @dashboard.launch(pdef)
+
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+    assert_equal "administrator\ndone.", @tracer.to_s
+  end
+
+  def test_wait_for_unknown_tag
+
+    pdef = Ruote.define do
+      concurrence :wait_for => 'nada' do
+        echo 'a'
+        echo 'b'
+      end
+      echo 'c'
+    end
+
+    wfid = @dashboard.launch(pdef)
+    r = @dashboard.wait_for(wfid)
+
+    assert_equal 'ceased', r['action']
+    assert_equal %w[ a b ], @tracer.to_a.sort
+  end
+
+  def test_remaining_wait
+
+    pdef = Ruote.define do
+      concurrence :count => 1, :rem => 'wait', :mt => 'mix' do
+        set 'a' => true
+        sequence do
+          set 'b' => true
+          stall
+        end
+      end
+    end
+
+    wfid = @dashboard.launch(pdef); r = @dashboard.wait_for(wfid)
+
+    assert_equal(
+      { 'a' => true, 'b' => true, '__result__' => true },
+      r['workitem']['fields'])
+  end
 end