ruote 2.1.11 → 2.2.0

data/test/functional/ft_56_filter_attribute.rb

@@ -0,0 +1,259 @@
+
+#
+# testing ruote
+#
+# Tue Feb  8 12:39:35 JST 2011
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtFilterAttributeTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class AlphaParticipant
+    include Ruote::LocalParticipant
+
+    def consume(workitem)
+
+      @context.tracer << 'fields: ' + workitem.fields.keys.sort.join(' ') + "\n"
+
+      reply_to_engine(workitem)
+    end
+  end
+
+  def test_filter_in_variable
+
+    pdef = Ruote.define do
+      set 'v:f' => {
+        :in => [ { :fields => '/^private_/', :remove => true } ],
+        :out => [ { :fields => '/^~~.private_/', :merge_to => '.' } ]
+      }
+      alpha :filter => 'f'
+      alpha
+    end
+
+    @engine.register :alpha, AlphaParticipant
+
+    #noisy
+
+    wfid = @engine.launch(
+      pdef,
+      'private_a' => 'x', 'a' => 'y')
+
+    @engine.wait_for(wfid)
+
+    assert_equal(
+      "fields: a dispatched_at params\n" +
+      "fields: a dispatched_at params private_a",
+      @tracer.to_s)
+  end
+
+  def test_filter_restore
+
+    pdef = Ruote.define do
+      set 'v:f' => {
+        :in => [],
+        :out => [
+          { :fields => '/^protected_/', :restore => true },
+          { :fields => '__result__', :del => true }
+        ]
+      }
+      sequence :filter => 'f' do
+        bravo
+        echo '${f:protected_thing}'
+      end
+    end
+
+    @engine.register :bravo do |wi|
+      wi.fields['protected_thing'] = 'stolen'
+      wi.fields['other_thing'] = 'stolen'
+    end
+
+    #noisy
+
+    wfid = @engine.launch(
+      pdef,
+      'protected_thing' => 'here', 'other_thing' => 'here')
+
+    r = @engine.wait_for(wfid)
+
+    assert_equal(
+      { 'protected_thing' => 'here', 'other_thing' => 'stolen' },
+      r['workitem']['fields'])
+  end
+
+  def test_broken_filter_apply
+
+    pdef = Ruote.define do
+      alpha :filter => 'f'
+    end
+
+    @engine.register :alpha, Ruote::NoOpParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    r = @engine.wait_for(wfid)
+
+    assert_not_nil r['error']
+    assert_equal 'ArgumentError', r['error']['class']
+  end
+
+  def test_broken_filter_reply
+
+    pdef = Ruote.define do
+      set 'v:f' => {
+        :in => [],
+        :out => 'nada'
+      }
+      alpha :filter => 'f'
+    end
+
+    @engine.register :alpha, AlphaParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    r = @engine.wait_for(wfid)
+
+    assert_not_nil r['error']
+    assert_equal 'ArgumentError', r['error']['class']
+  end
+
+  class AaFilterParticipant
+    def consume(wi)
+      (wi.fields['seen'] ||= []) << wi.fields['__filter_direction__']
+    end
+  end
+
+  def test_filter_participant__consume
+
+    pdef = Ruote.define do
+      alpha :filter => 'filter_a'
+    end
+
+    @engine.register :alpha, AlphaParticipant
+    @engine.register :filter_a, AaFilterParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    r = @engine.wait_for(wfid)
+
+    assert_nil r['workitem']['fields']['__filter_direction__']
+    assert_equal %w[ in out ], r['workitem']['fields']['seen']
+    assert_equal 'fields: dispatched_at params seen', @tracer.to_s
+  end
+
+  class BbFilterParticipant
+    def filter(fields, direction)
+      (fields['seen'] ||= []) << direction
+      fields
+    end
+  end
+
+  def test_filter_participant__filter
+
+    pdef = Ruote.define do
+      alpha :filter => 'filter_b'
+    end
+
+    @engine.register :alpha, AlphaParticipant
+    @engine.register :filter_b, BbFilterParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    r = @engine.wait_for(wfid)
+
+    assert_equal %w[ in out ], r['workitem']['fields']['seen']
+    assert_equal 'fields: dispatched_at params seen', @tracer.to_s
+  end
+
+  class CcFilterParticipant
+    def consume(wi)
+      raise 'something goes horribly wrong'
+    end
+  end
+
+  def test_filter_participant_with_error
+
+    pdef = Ruote.define do
+      alpha :filter => 'filter_c'
+    end
+
+    @engine.register :alpha, AlphaParticipant
+    @engine.register :filter_c, CcFilterParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(wfid)
+
+    assert_equal 1, @engine.ps(wfid).errors.size
+    assert_equal '', @tracer.to_s
+  end
+
+  class DdFilterParticipant
+    def consume(workitem)
+      workitem.fields[workitem.participant_name] =
+        workitem.fields['__filter_direction__']
+    end
+  end
+
+  def test_filter_participant__in_and_out
+
+    pdef = Ruote.define do
+      alpha :filter => { :in => 'f0', :out => 'f1' }
+    end
+
+    @engine.register :alpha, AlphaParticipant
+    @engine.register :f0, DdFilterParticipant
+    @engine.register :f1, DdFilterParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    r = @engine.wait_for(wfid)
+
+    assert_equal({ 'f0' => 'in', 'f1' => 'out' }, r['workitem']['fields'])
+    assert_equal('fields: dispatched_at f0 params', @tracer.to_s)
+  end
+
+#  def test_filter_record
+#
+#    pdef = Ruote.define do
+#      set 'v:f' => {
+#        :in => [ { :fields => 'x', :type => 'number' } ],
+#        :out => []
+#      }
+#      alpha :filter => 'f'
+#    end
+#
+#    @engine.register :alpha, AlphaParticipant
+#
+#    #noisy
+#
+#    wfid = @engine.launch(
+#      pdef,
+#      'x' => 'not a number')
+#
+#    @engine.wait_for(wfid)
+#
+#    assert_equal(
+#      "fields: a dispatched_at params\n" +
+#      "fields: a dispatched_at params private_a",
+#      @tracer.to_s)
+#  end
+  #
+  # in the fridge for now
+
+end
+

data/test/functional/ft_5_on_error.rb

@@ -42,10 +42,10 @@ class FtOnErrorTest < Test::Unit::TestCase
       participant :mark_finished
     end
 
-    @marks = []
+    @engine.context.stash[:marks] = []
 
     @engine.register_participant 'mark\_.+' do |workitem|
-      @marks << workitem.participant_name
+      stash[:marks] << workitem.participant_name
     end
 
     #noisy
@@ -54,7 +54,9 @@ class FtOnErrorTest < Test::Unit::TestCase
 
     wait_for(wfid)
 
-    assert_equal %w[ mark_started mark_failed mark_finished ], @marks
+    assert_equal(
+      %w[ mark_started mark_failed mark_finished ],
+      @engine.context.stash[:marks])
   end
 
   def test_on_error_unknown_participant_name_2
@@ -65,10 +67,10 @@ class FtOnErrorTest < Test::Unit::TestCase
       participant :mark_finished
     end
 
-    @marks = []
+    @engine.context.stash[:marks] = []
 
     @engine.register_participant 'mark\_.+' do |workitem|
-      @marks << workitem.participant_name
+      stash[:marks] << workitem.participant_name
     end
 
     #noisy
@@ -77,7 +79,9 @@ class FtOnErrorTest < Test::Unit::TestCase
 
     wait_for(wfid)
 
-    assert_equal %w[ mark_started mark_failed mark_finished ], @marks
+    assert_equal(
+      %w[ mark_started mark_failed mark_finished ],
+      @engine.context.stash[:marks])
   end
 
   def test_on_error_neutralization
@@ -103,6 +107,21 @@ class FtOnErrorTest < Test::Unit::TestCase
     assert_equal(1, ps.errors.size)
   end
 
+  class TroubleMaker
+    include Ruote::LocalParticipant
+    def consume(workitem)
+      hits = (workitem.fields['hits'] || 0) + 1
+      workitem.fields['hits'] = hits
+      workitem.trace << "#{hits.to_s}\n"
+      raise 'Houston, we have a problem !' if hits == 1
+      workitem.trace << 'done.'
+      reply(workitem)
+    end
+    def cancel(fei, flavour)
+      # nothing to do
+    end
+  end
+
   def test_on_error_redo
 
     pdef = Ruote.process_definition do
@@ -111,16 +130,22 @@ class FtOnErrorTest < Test::Unit::TestCase
       end
     end
 
-    hits = 0
+    #noisy
 
-    @engine.register_participant :troublemaker do
-      hits += 1
-      @tracer << "#{hits.to_s}\n"
-      raise 'Houston, we have a problem !' if hits == 1
-      @tracer << 'done.'
+    @engine.register_participant :troublemaker, TroubleMaker
+
+    assert_trace(%w[ 1 2 done. ], pdef)
+  end
+
+  def test_on_error_retry
+
+    pdef = Ruote.process_definition do
+      sequence :on_error => :retry do
+        troublemaker
+      end
     end
 
-    #noisy
+    @engine.register_participant :troublemaker, TroubleMaker
 
     assert_trace(%w[ 1 2 done. ], pdef)
   end
@@ -146,7 +171,7 @@ class FtOnErrorTest < Test::Unit::TestCase
     assert_nil @engine.process(wfid)
   end
 
-  def test_on_error_undo__pass
+  def test_on_error_undo_single_expression
 
     @engine.register_participant :nemo do |wi|
       wi.fields['fail_count'] = 1
@@ -166,6 +191,27 @@ class FtOnErrorTest < Test::Unit::TestCase
     assert_nil @engine.process(wfid)
   end
 
+  def test_on_error_pass
+
+    pdef = Ruote.process_definition do
+      sequence do
+        echo 'a'
+        sequence :on_error => :pass do
+          echo 'b'
+          nemo
+          echo 'c'
+        end
+        echo 'd'
+      end
+    end
+
+    #noisy
+
+    wfid = assert_trace(%w[ a b d ], pdef)
+
+    assert_nil @engine.process(wfid)
+  end
+
   def test_missing_handler_triggers_regular_error
 
     pdef = Ruote.process_definition :on_error => 'failpath' do
@@ -210,16 +256,17 @@ class FtOnErrorTest < Test::Unit::TestCase
       end
     end
 
-    a_count = 0
-    e_count = 0
-    @engine.register_participant(:alpha) { |wi| a_count += 1 }
-    @engine.register_participant(:emil) { |wi| e_count += 1 }
+    @engine.context.stash[:a_count] = 0
+    @engine.context.stash[:e_count] = 0
+
+    @engine.register_participant(:alpha) { |wi| stash[:a_count] += 1 }
+    @engine.register_participant(:emil) { |wi| stash[:e_count] += 1 }
 
     #noisy
 
     assert_trace 'done.', pdef
-    assert_equal 1, a_count
-    assert_equal 1, e_count
+    assert_equal 1, @engine.context.stash[:a_count]
+    assert_equal 1, @engine.context.stash[:e_count]
   end
 
   def test_participant_on_error
@@ -231,14 +278,12 @@ class FtOnErrorTest < Test::Unit::TestCase
       end
     end
 
-    workitem = nil
-
     @engine.register_participant :troublemaker do |wi|
       wi.fields['seen'] = true
       raise 'Beijing, we have a problem !'
     end
     @engine.register_participant :troublespotter do |wi|
-      workitem = wi
+      stash[:workitem] = wi
       @tracer << 'err...'
     end
 
@@ -251,21 +296,23 @@ class FtOnErrorTest < Test::Unit::TestCase
     #puts er.message
     #puts er.trace
 
+    wi = @engine.context.stash[:workitem]
+
     assert_equal 'err...', @tracer.to_s
-    assert_equal 5, workitem.error.size
-    assert_equal 'RuntimeError', workitem.error[2]
-    assert_equal 'Beijing, we have a problem !', workitem.error[3]
-    assert_equal Array, workitem.error[4].class
-    assert_equal true, workitem.fields['seen']
+    assert_equal 5, wi.error.size
+    assert_equal 'RuntimeError', wi.error['class']
+    assert_equal 'Beijing, we have a problem !', wi.error['message']
+    assert_equal Array, wi.error['trace'].class
+    assert_equal true, wi.fields['seen']
   end
 
   class Murphy
     include Ruote::LocalParticipant
 
-    def cancel (fei, flavour)
+    def cancel(fei, flavour)
       # nothing to do
     end
-    def consume (workitem)
+    def consume(workitem)
       raise "something got wrong"
     end
   end