ruote 2.1.11 → 2.2.0

data/test/functional/ft_20_storage_participant.rb

@@ -189,7 +189,6 @@ class FtStorageParticipantTest < Test::Unit::TestCase
       @part.query('place' => 'heiankyou', :offset => 2, :limit => 2).collect { |wi|
         "#{wi.fei.wfid}-#{wi.participant_name}" }
 
-    #p page0, page1
     assert_equal 4, (page0 + page1).sort.uniq.size
 
     assert_equal(

data/test/functional/ft_21_forget.rb

@@ -7,7 +7,7 @@
 
 require File.join(File.dirname(__FILE__), 'base')
 
-require 'ruote/part/storage_participant'
+require 'ruote/participant'
 
 
 class FtForgetTest < Test::Unit::TestCase
@@ -68,5 +68,86 @@ class FtForgetTest < Test::Unit::TestCase
     #p ps.original_tree
     #p ps.current_tree
   end
+
+  def test_forget_true_string
+
+    pdef = Ruote.process_definition do
+      concurrence :count => 1 do
+        alpha :forget => 'true'
+        bravo
+      end
+      charly
+    end
+
+    @engine.register_participant '.+' do |wi|
+      @tracer << wi.participant_name + "\n"
+    end
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(wfid)
+    wait_for(wfid)
+
+    #assert_equal "alpha\nbravo\ncharly", @tracer.to_s
+    assert_equal %w[ alpha bravo charly ], @tracer.to_a.sort
+  end
+
+  def test_forget_and_cursor
+
+    pdef = Ruote.define do
+      cursor do
+        alpha :forget => true
+        bravo
+        rewind
+      end
+    end
+
+    @engine.register_participant 'alpha', Ruote::NullParticipant
+      # this participant never replies
+
+    @engine.register_participant 'bravo', Ruote::NoOpParticipant
+      # this one simply replies
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:bravo)
+    @engine.wait_for(:bravo)
+
+    assert_not_nil @engine.process(wfid)
+  end
+
+  # As reported by Nando Sola
+  #
+  # http://groups.google.com/group/openwferu-users/browse_thread/thread/50308e9dce8359e6
+  #
+  def test_forget_on_forget
+
+    pdef = Ruote.define do
+      concurrence do
+        listen :to => 'bravo', :upon =>'reply', :wfid => true do
+          sequence :forget => true do
+            alpha
+          end
+        end
+        bravo
+      end
+    end
+
+    @engine.register do
+      catchall Ruote::NoOpParticipant
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(wfid)
+
+    assert_equal(
+      [],
+      @engine.history.all.select { |e| e['action'] == 'error_intercepted' })
+  end
 end
 

data/test/functional/{ft_24_block_participants.rb → ft_24_block_participant.rb}

@@ -64,25 +64,56 @@ class FtBlockParticipantTest < Test::Unit::TestCase
     return if Ruote::WIN
       # defective 'json' lib on windows renders this test useless
 
-    t = Time.now
-
     @engine.register_participant :alpha do |workitem|
-      t
+      Time.now
     end
 
     #noisy
 
-    #assert_trace TEST_BLOCK, Ruote.time_to_utc_s(t)
-
-    expected = if defined?(DataMapper)
-      DataMapper::VERSION >= '1.0.0' ? t.to_s : ''
-    elsif Ruote::JAVA
-      ''
+    match = if defined?(DataMapper) && DataMapper::VERSION < '1.0.0'
+      /^$/
     else
-      t.to_s
+      /\b#{Time.now.year}\b/
     end
 
-    assert_trace expected, TEST_BLOCK
+    wfid = @engine.launch(TEST_BLOCK)
+
+    @engine.wait_for(wfid)
+
+    assert_match match, @tracer.to_s
+  end
+
+  def test_raise_security_error_before_evaluating_rogue_code
+
+    fn = "test/bad.#{Time.now.to_f}.txt"
+
+    @engine.participant_list = [
+      #[ 'alpha', [ 'Ruote::BlockParticipant', { 'block' => 'exit(3)' } ] ]
+      [ 'alpha', [ 'Ruote::BlockParticipant', { 'block' => "proc { File.open(\"#{fn}\", \"wb\") { |f| f.puts(\"bad\") } }" } ] ]
+    ]
+
+    #noisy
+
+    wfid = @engine.launch(Ruote.define { alpha })
+
+    @engine.wait_for(wfid)
+
+    assert_equal false, File.exist?(fn), 'security check not enforced'
+
+    assert_equal 1, @engine.errors(wfid).size
+    assert_match /SecurityError/, @engine.errors(wfid).first.message
+
+    FileUtils.rm(fn) rescue nil
+  end
+
+  def test_raise_security_error_upon_registering_rogue_block_participant
+
+    assert_raise Rufus::SecurityError do
+
+      @engine.register 'rogue' do |workitem|
+        workitem.content = File.read('test/nada.txt')
+      end
+    end
   end
 end
 

data/test/functional/ft_25_receiver.rb

@@ -24,17 +24,15 @@ class FtReceiverTest < Test::Unit::TestCase
       end
     end
 
-    @alpha = @engine.register_participant 'alpha', MyParticipant.new
+    @engine.register_participant 'alpha', MyParticipant
   end
 
   class MyParticipant
     include Ruote::LocalParticipant
 
-    attr_accessor :wi
+    def consume(workitem)
 
-    def consume (workitem)
-
-      @wi = workitem
+      @context.stash[:wi] = workitem
 
       # no reply to the engine
     end
@@ -87,13 +85,13 @@ class FtReceiverTest < Test::Unit::TestCase
     wfid = @engine.launch(@pdef)
 
     wait_for(:alpha)
-    while @alpha.wi.nil? do
+    while @engine.context.stash[:wi].nil? do
       Thread.pass
     end
 
     assert_equal 3, @engine.process(wfid).expressions.size
 
-    receiver.receive(@alpha.wi)
+    receiver.receive(@engine.context.stash[:wi])
 
     wait_for(wfid)
 
@@ -109,7 +107,7 @@ class FtReceiverTest < Test::Unit::TestCase
 
     wait_for(:alpha)
 
-    @engine.receive(@alpha.wi)
+    @engine.receive(@engine.context.stash[:wi])
 
     wait_for(wfid)
 
@@ -120,19 +118,17 @@ class FtReceiverTest < Test::Unit::TestCase
   end
 
   class MyOtherParticipant
-    def initialize (receiver)
-      @receiver = receiver
-    end
-    def consume (workitem)
-      @receiver.pass(workitem.to_h)
+    include Ruote::LocalParticipant
+    def consume(workitem)
+      @context.receiver.pass(workitem.to_h)
     end
   end
   class MyOtherReceiver < Ruote::Receiver
-    def initialize (context, opts={})
+    def initialize(context, opts={})
       super(context, opts)
       @count = 0
     end
-    def pass (workitem)
+    def pass(workitem)
       if @count < 1
         @context.error_handler.action_handle(
           'dispatch', workitem['fei'], RuntimeError.new('something went wrong'))
@@ -145,9 +141,13 @@ class FtReceiverTest < Test::Unit::TestCase
 
   def test_receiver_triggered_dispatch_error
 
-    receiver = MyOtherReceiver.new(@engine)
+    class << @engine.context
+      def receiver
+        @rcv ||= MyOtherReceiver.new(engine)
+      end
+    end
 
-    @engine.register_participant :alpha, MyOtherParticipant.new(receiver)
+    @engine.register_participant :alpha, MyOtherParticipant
 
     pdef = Ruote.process_definition do
       alpha
@@ -173,5 +173,35 @@ class FtReceiverTest < Test::Unit::TestCase
 
     assert_nil ps
   end
+
+  def test_receiver_fexp_and_wi
+
+    #@engine.register do
+    #  catchall Ruote::StorageParticipant
+    #end
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(Ruote.define do
+      alpha
+    end)
+
+    @engine.wait_for(:alpha)
+    @engine.wait_for(1)
+
+    wi = @engine.storage_participant.first
+
+    assert_equal wfid, wi.fei.wfid
+
+    assert_equal wfid, @engine.fexp(wi).fei.wfid
+    assert_equal wfid, @engine.fexp(wi.fei).fei.wfid
+    assert_equal wfid, @engine.fexp(wi.fei.sid).fei.wfid
+    assert_equal wfid, @engine.fexp(wi.fei.sid).h.applied_workitem['fei']['wfid']
+
+    assert_equal wfid, @engine.workitem(wi).wfid
+    assert_equal wfid, @engine.workitem(wi.fei).wfid
+    assert_equal wfid, @engine.workitem(wi.fei.sid).wfid
+  end
 end
 

data/test/functional/{ft_26_participant_timeout.rb → ft_26_participant_rtimeout.rb}

@@ -7,12 +7,18 @@
 
 require File.join(File.dirname(__FILE__), 'base')
 
-require 'ruote/part/hash_participant'
+require 'ruote/participant'
 
 
 class FtParticipantTimeoutTest < Test::Unit::TestCase
   include FunctionalBase
 
+  class AlphaParticipant < Ruote::StorageParticipant
+    def rtimeout(workitem)
+      '1s'
+    end
+  end
+
   def test_participant_defined_timeout
 
     pdef = Ruote.process_definition do
@@ -22,39 +28,33 @@ class FtParticipantTimeoutTest < Test::Unit::TestCase
       end
     end
 
-    alpha = @engine.register_participant :alpha, Ruote::HashParticipant.new
-    bravo = @engine.register_participant :bravo, Ruote::HashParticipant.new
-
-    class << alpha
-      def timeout
-        '1s'
-      end
-    end
+    @engine.register_participant :alpha, AlphaParticipant
+    sto = @engine.register_participant :bravo, Ruote::StorageParticipant
 
     #noisy
 
     wfid = @engine.launch(pdef)
     wait_for(13)
 
-    assert_equal 0, alpha.size
-    assert_equal 1, bravo.size
+    assert_equal 1, sto.size
+    assert_equal 'bravo', sto.first.participant_name
 
     #logger.log.each { |l| p l }
     assert_equal 2, logger.log.select { |e| e['flavour'] == 'timeout' }.size
     assert_equal 0, @engine.storage.get_many('schedules').size
 
-    assert_not_nil bravo.first.fields['__timed_out__']
+    assert_not_nil sto.first.fields['__timed_out__']
   end
 
   class MyParticipant
     include Ruote::LocalParticipant
-    def consume (workitem)
+    def consume(workitem)
       # do nothing
     end
-    def cancel (fei, flavour)
+    def cancel(fei, flavour)
       # do nothing
     end
-    def timeout
+    def rtimeout
       '1s'
     end
     def do_not_thread
@@ -104,16 +104,16 @@ class FtParticipantTimeoutTest < Test::Unit::TestCase
 
   class MyOtherParticipant
     include Ruote::LocalParticipant
-    def initialize (opts)
+    def initialize(opts)
       @opts = opts
     end
-    def consume (workitem)
+    def consume(workitem)
       # do nothing
     end
-    def cancel (fei, flavour)
+    def cancel(fei, flavour)
       # do nothing
     end
-    def timeout
+    def rtimeout(workitem)
       @opts['timeout']
     end
   end
@@ -138,5 +138,42 @@ class FtParticipantTimeoutTest < Test::Unit::TestCase
     assert_equal 0, @engine.storage.get_many('schedules').size
       # no timeout for participant :bravo
   end
+
+  class YetAnotherParticipant
+    include Ruote::LocalParticipant
+    def initialize(opts)
+      @opts = opts
+    end
+    def consume(workitem)
+      # do nothing
+    end
+    def cancel(fei, flavour)
+      # do nothing
+    end
+    def rtimeout(workitem)
+      "#{workitem.fields['timeout'] * 2}s"
+    end
+  end
+
+  def test_participant_rtimeout_workitem
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    @engine.register_participant :alpha, YetAnotherParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef, 'timeout' => 60)
+
+    @engine.wait_for(:alpha)
+    @engine.wait_for(1)
+
+    schedules = @engine.storage.get_many('schedules')
+
+    assert_equal 1, schedules.size
+    assert_equal '120s', schedules.first['original']
+  end
 end
 

data/test/functional/ft_29_part_template.rb

@@ -18,12 +18,12 @@ class FtPartTemplateTest < Test::Unit::TestCase
     include Ruote::LocalParticipant
     include Ruote::TemplateMixin
 
-    def initialize (opts={}, &block)
+    def initialize(opts)
 
-      @template = opts[:template]
+      @template = opts['template']
     end
 
-    def consume (workitem)
+    def consume(workitem)
 
       @context['s_tracer'] << render_template(
         @template,
@@ -34,7 +34,7 @@ class FtPartTemplateTest < Test::Unit::TestCase
       reply_to_engine(workitem)
     end
 
-    def cancel (fei, flavour)
+    def cancel(fei, flavour)
     end
   end
 
@@ -51,7 +51,8 @@ class FtPartTemplateTest < Test::Unit::TestCase
 
     @engine.register_participant(
       :alpha,
-      MyParticipant.new(:template => "0:${v:var0}\n1:${f:field0}"))
+      MyParticipant,
+      :template => "0:${v:var0}\n1:${f:field0}")
 
     assert_trace %w[ 0:v_value 1:f_value done. ], pdef
   end