ruote 2.1.11 → 2.2.0

data/test/functional/eft_35_filter.rb

@@ -0,0 +1,269 @@
+
+#
+# testing ruote
+#
+# Mon Jan 31 14:45:09 JST 2011
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftFilterTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def assert_terminates(pdef, fields, result=nil)
+
+    wfid = @engine.launch(pdef, fields)
+    r = @engine.wait_for(wfid)
+
+    assert_equal 'terminated', r['action']
+    assert_equal(result, r['workitem']['fields']) if result
+  end
+
+  def assert_does_not_validate(pdef, fields={})
+
+    wfid = @engine.launch(pdef, fields)
+    r = @engine.wait_for(wfid)
+
+    assert_equal 'error_intercepted', r['action']
+    assert_match /ValidationError/, @engine.errors.first.message
+  end
+
+  #
+  # the tests
+
+  def test_filter_single_rule_validation
+
+    pdef = Ruote.process_definition do
+      filter 'x', :type => 'string'
+    end
+
+    assert_terminates(pdef, 'x' => 'nada')
+  end
+
+  def test_filter_single_rule_validation_failure
+
+    pdef = Ruote.process_definition do
+      filter 'x', :type => 'string'
+    end
+
+    assert_does_not_validate(pdef, 'x' => 2)
+  end
+
+  def test_filter_single_rule_transformation
+
+    pdef = Ruote.process_definition do
+      filter 'x', :or => 'crimea'
+    end
+
+    assert_terminates(pdef, {}, { 'x' => 'crimea' })
+  end
+
+  def test_filter_single_rule_in
+
+    pdef = Ruote.process_definition do
+      filter 'colour', :in => %w[ red green blue ]
+    end
+
+    assert_terminates(pdef, 'colour' => 'green')
+  end
+
+  PDEF1 = Ruote.process_definition do
+    filter :in => [
+      { :field => 'x', :type => 'string' },
+      { :field => 'y', :type => 'number' }
+    ]
+  end
+
+  def test_filter_multiple_rules_validation
+
+    assert_terminates(PDEF1, 'x' => 's', 'y' => 2)
+  end
+
+  def test_filter_multiple_rules_validation_failure
+
+    assert_does_not_validate(PDEF1, 'x' => 's', 'y' => 's')
+  end
+
+  def test_filter_multiple_rules_transformation
+
+    pdef = Ruote.process_definition do
+      filter :in => [
+        { :field => 'x', :or => 'alpha' },
+        { :field => 'y', :or => 'bravo' }
+      ]
+    end
+
+    assert_terminates(pdef, {}, { 'x' => 'alpha', 'y' => 'bravo' })
+  end
+
+  def test_filter_in_variable
+
+    pdef = Ruote.process_definition do
+      set 'v:toto' => [
+        { :field => 'a', :set => 'A' },
+        { :field => 'b', :or => 'B' },
+      ]
+      filter 'v:toto'
+    end
+
+    assert_terminates(pdef, {}, { 'a' => 'A', 'b' => 'B' })
+  end
+
+  def test_in_filter_in_variable
+
+    # compatibility with the :filter attribute
+
+    pdef = Ruote.process_definition do
+      set 'v:toto' => { :in => [
+        { :field => 'a', :set => 'A' },
+        { :field => 'b', :or => 'B' },
+      ] }
+      filter 'v:toto'
+    end
+
+    assert_terminates(pdef, {}, { 'a' => 'A', 'b' => 'B' })
+  end
+
+  def test_filter_in_field
+
+    pdef = Ruote.process_definition do
+      set 'f:toto' => [
+        { :field => 'a', :set => 'A' },
+        { :field => 'b', :or => 'B' },
+      ]
+      filter 'f:toto'
+      unset 'f:toto'
+    end
+
+    assert_terminates(pdef, {}, { 'a' => 'A', 'b' => 'B' })
+  end
+
+  def test_in_filter_in_field
+
+    pdef = Ruote.process_definition do
+      set 'f:toto' => { :in => [
+        { :field => 'a', :set => 'A' },
+        { :field => 'b', :or => 'B' },
+      ] }
+      filter 'f:toto'
+      unset 'f:toto'
+    end
+
+    assert_terminates(pdef, {}, { 'a' => 'A', 'b' => 'B' })
+  end
+
+  def test_tilde
+
+    # the ~ points to the hash as it was right before the filtering began
+
+    pdef = Ruote.process_definition do
+      filter :in => [
+        { :field => 'x', :set => 'X' },
+        { :field => 'x', :copy_from => '~.x' },
+      ]
+    end
+
+    assert_terminates(pdef, { 'x' => 1 }, { 'x' => 1 })
+  end
+
+  def test_double_tilde
+
+    # the ~~ points to the workitem fields as they are in the parent expression
+
+    pdef = Ruote.process_definition do
+      filter 'x', :set => 'X'
+      filter 'x', :copy_from => '~~.x'
+    end
+
+    assert_terminates(pdef, { 'x' => 1 }, { 'x' => 1 })
+  end
+
+  def test_record
+
+    pdef = Ruote.process_definition do
+      filter 'x', :type => 'string', :record => true
+    end
+
+    assert_terminates(
+      pdef,
+      { 'x' => 1 },
+      { '__validation_errors__' => [
+          [ { 'type' => 'string', 'field' => 'x' }, 'x', 1 ]
+        ],
+        'x' => 1
+      })
+  end
+
+  def test_record__complex
+
+    pdef = Ruote.process_definition do
+      filter :in => [
+        { :field => 'x', :type => 'string', :record => true },
+        { :field => 'y', :type => 'number' }
+      ]
+    end
+
+    assert_terminates(
+      pdef,
+      { 'x' => 1 },
+      { '__validation_errors__' => [
+          [ { 'type' => 'string', 'field' => 'x' }, 'x', 1 ],
+          [ { 'type' => 'number', 'field' => 'y' }, 'y', nil ]
+        ],
+        'x' => 1
+      })
+  end
+
+  def test_record_in_designated_field
+
+    pdef = Ruote.process_definition do
+      filter 'x', :type => 'string', :record => 'verrors'
+    end
+
+    assert_terminates(
+      pdef,
+      { 'x' => 1 },
+      { 'verrors' => [
+          [ { 'type' => 'string', 'field' => 'x' }, 'x', 1 ]
+        ],
+        'x' => 1
+      })
+  end
+
+  def test_record_accumulates
+
+    pdef = Ruote.process_definition do
+      filter 'x', :type => 'string', :record => true
+      filter 'y', :type => 'number', :record => true
+    end
+
+    assert_terminates(
+      pdef,
+      { 'x' => 1 },
+      { '__validation_errors__' => [
+          [ { 'type' => 'string', 'field' => 'x' }, 'x', 1 ],
+          [ { 'type' => 'number', 'field' => 'y' }, 'y', nil ]
+        ],
+        'x' => 1
+      })
+  end
+
+  def test_record_flushes_and_accumulates
+
+    pdef = Ruote.process_definition do
+      filter 'x', :type => 'string', :record => true
+      filter 'y', :type => 'number', :record => true, :flush => true
+    end
+
+    assert_terminates(
+      pdef,
+      { 'x' => 1 },
+      { '__validation_errors__' => [
+          [ { 'type' => 'number', 'field' => 'y' }, 'y', nil ]
+        ],
+        'x' => 1
+      })
+  end
+end
+

data/test/functional/eft_3_participant.rb

@@ -68,7 +68,7 @@ class EftParticipantTest < Test::Unit::TestCase
       delta :tag => 'whatever'
     end
 
-    delta = @engine.register_participant :delta, Ruote::HashParticipant.new
+    delta = @engine.register_participant :delta, Ruote::StorageParticipant
 
     @engine.launch(pdef)
     wait_for(:delta)
@@ -88,7 +88,7 @@ class EftParticipantTest < Test::Unit::TestCase
 
     %w[ eecho fox gamma ].each do |pname|
       @engine.register_participant pname do |workitem|
-        @tracer << "#{pname}\n"
+        @tracer << "#{workitem.participant_name}\n"
       end
     end
 
@@ -104,11 +104,9 @@ class EftParticipantTest < Test::Unit::TestCase
       echo 'done.'
     end
 
-    atts = nil
-
     @engine.register_participant :notify do |wi, fe|
       #p fe.attribute_text
-      atts = fe.attributes
+      stash[:atts] = fe.attributes
     end
 
     #noisy
@@ -117,7 +115,7 @@ class EftParticipantTest < Test::Unit::TestCase
 
     assert_equal(
       { "commander of the left guard"=>nil, "if"=>"true", "ref"=>"notify" },
-      atts)
+      stash[:atts])
   end
 
   def test_dispatched

data/test/functional/eft_4_set.rb

@@ -223,9 +223,23 @@ class EftSetTest < Test::Unit::TestCase
 
     wait_for(wfid)
 
-    ps = @engine.process(wfid)
+    assert_nil @engine.process(wfid)
+    assert_nil @engine.variables['v']
+  end
+
+  # 'rset' is an alias for 'set'.
+  #
+  # motivation at http://groups.google.com/group/openwferu-users/browse_thread/thread/9ac606e30ada686e
+  #
+  def test_rset
+
+    wfid = @engine.launch(Ruote.define do
+      rset 'developer' => 'Rebo'
+    end)
+
+    r = @engine.wait_for(wfid)
 
-    assert_equal 1, ps.errors.size
+    assert_equal 'Rebo', r['workitem']['fields']['developer']
   end
 end
 

data/test/functional/eft_5_subprocess.rb

@@ -96,17 +96,15 @@ class EftSubprocessTest < Test::Unit::TestCase
       end
     end
 
-    tree = nil
-
     @engine.register_participant :alpha do |workitem, fexp|
-      tree = fexp.lookup_variable('tree')
+      stash[:tree] = fexp.lookup_variable('tree')
     end
 
     #noisy
 
     assert_trace '', pdef
 
-    assert_equal ["noop", {}, []], tree
+    assert_equal ["noop", {}, []], stash[:tree]
   end
 
   def test_subprocess_uri

data/test/functional/eft_6_concurrence.rb

@@ -7,7 +7,7 @@
 
 require File.join(File.dirname(__FILE__), 'base')
 
-require 'ruote/part/hash_participant'
+#require 'ruote/part/hash_participant'
 
 
 class EftConcurrenceTest < Test::Unit::TestCase
@@ -42,20 +42,20 @@ class EftConcurrenceTest < Test::Unit::TestCase
       bravo
     end
 
-    count = 0
+    @engine.context.instance_eval do
+      @count = 0
+    end
+      # since block participants are evaluated in the context context
 
-    alpha = @engine.register_participant :alpha do |workitem|
-      workitem.fields['seen'] = 'indeed' if count == 1
+    alpha = @engine.register_participant :alpha, 'do_not_thread' => true do |wi|
+      wi.fields['seen'] = 'indeed' if @count == 1
       @tracer << "alpha\n"
-      count = count + 1
+      @count = @count + 1
       nil
     end
-    alpha.do_not_thread = true
-
-    fields = nil
 
     @engine.register_participant :bravo do |workitem|
-      fields = workitem.fields
+      stash[:fields] = workitem.fields
       nil
     end
 
@@ -67,10 +67,10 @@ class EftConcurrenceTest < Test::Unit::TestCase
     #  {'1'=>{"seen"=>"indeed"}, '0'=>{}, "params"=>{"ref"=>"bravo"}},
     #  fields)
 
-    params = fields.delete('params')
+    params = @engine.context.stash[:fields].delete('params')
 
     assert_equal({ 'ref' => 'bravo' }, params)
-    assert_match /seen/, fields.inspect
+    assert_match /seen/, @engine.context.stash[:fields].inspect
   end
 
   def test_over_unless
@@ -85,17 +85,19 @@ class EftConcurrenceTest < Test::Unit::TestCase
       echo 'done.'
     end
 
-    count = 0
+    @engine.context.instance_eval do
+      @count = 0
+    end
+      # since block participants are evaluated in the context context
 
-    alpha = @engine.register_participant :alpha do |workitem|
-      if count > 1
-        workitem.fields['ok'] = false
+    alpha = @engine.register_participant :alpha, 'do_not_thread' => true do |wi|
+      if @count > 1
+        wi.fields['ok'] = false
       else
         @tracer << "a\n"
-        count = count + 1
+        @count = @count + 1
       end
     end
-    alpha.do_not_thread = true
 
     fields = nil
 
@@ -125,7 +127,7 @@ class EftConcurrenceTest < Test::Unit::TestCase
 
   # helper
   #
-  def run_concurrence (concurrence_attributes, noise)
+  def run_concurrence(concurrence_attributes, noise)
 
     pdef = Ruote.process_definition do
       sequence do
@@ -137,7 +139,7 @@ class EftConcurrenceTest < Test::Unit::TestCase
       alpha
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     noisy if noise
 
@@ -206,7 +208,7 @@ class EftConcurrenceTest < Test::Unit::TestCase
 
   # helper
   #
-  def run_test_count (remaining, noise)
+  def run_test_count(remaining, noise)
 
     pdef = Ruote.process_definition do
       concurrence :count => 1, :remaining => remaining do
@@ -215,8 +217,7 @@ class EftConcurrenceTest < Test::Unit::TestCase
       end
     end
 
-    @alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
-    @bravo = @engine.register_participant :bravo, Ruote::HashParticipant.new
+    @engine.register_participant '.+', Ruote::StorageParticipant
 
     noisy if noise
 
@@ -224,7 +225,7 @@ class EftConcurrenceTest < Test::Unit::TestCase
 
     wait_for(:alpha)
 
-    @alpha.reply(@alpha.first)
+    @engine.storage_participant.reply(@engine.storage_participant.first)
 
     wait_for(wfid)
 
@@ -244,8 +245,7 @@ class EftConcurrenceTest < Test::Unit::TestCase
 
     sleep 0.350 # since now dispatch_cancel occurs asynchronously...
 
-    assert_equal 0, @alpha.size
-    assert_equal 0, @bravo.size
+    assert_equal 0, @engine.storage_participant.size
   end
 
   def test_count_remaining_forget
@@ -256,15 +256,15 @@ class EftConcurrenceTest < Test::Unit::TestCase
 
     #assert_equal 1, logger.log.select { |e| e['action'] == 'forget' }.size
 
-    assert_equal 0, @alpha.size
-    assert_equal 1, @bravo.size
+    assert_equal 1, @engine.storage_participant.size
+    assert_equal 'bravo', @engine.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)
 
-    @bravo.reply(@bravo.first)
+    @engine.storage_participant.reply(@engine.storage_participant.first)
 
     wait_for(wfid)
 
@@ -281,7 +281,7 @@ class EftConcurrenceTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
+    alpha = @engine.register_participant :alpha, Ruote::StorageParticipant
 
     #noisy