ruote 2.1.9 → 2.1.10

data/test/functional/ft_38_participant_more.rb

@@ -0,0 +1,178 @@
+
+#
+# testing ruote
+#
+# Mon Apr 19 14:38:54 JST 2010
+#
+# Qcon Tokyo, special day
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/local_participant'
+
+
+class FtParticipantMoreTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class DifficultParticipant
+    include Ruote::LocalParticipant
+    def initialize (opts)
+    end
+    def consume (workitem)
+      context.tracer << "diff\n"
+      if workitem.fields['rejected'].nil?
+        workitem.fields['rejected'] = true
+        reject(workitem)
+      else
+        reply_to_engine(workitem)
+      end
+    end
+  end
+
+  def test_participant_reject
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    @engine.register_participant :alpha, DifficultParticipant
+
+    #noisy
+
+    assert_trace(%w[ diff diff ], pdef)
+  end
+
+  class FightingParticipant
+    include Ruote::LocalParticipant
+    def initialize (opts)
+    end
+    def consume (workitem)
+      try = workitem.fields['try'] || 0
+      context.tracer << "try#{try}\n"
+      workitem.fields['try'] = try + 1
+      if (try == 0)
+        re_dispatch(workitem)
+      else
+        reply(workitem)
+      end
+    end
+  end
+
+  def test_participant_re_dispatch
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    @engine.register_participant :alpha, FightingParticipant
+
+    #noisy
+
+    assert_trace(%w[ try0 try1 ], pdef)
+  end
+
+  class RetryParticipant
+    include Ruote::LocalParticipant
+    def initialize (opts)
+      @opts = opts
+    end
+    def consume (workitem)
+      try = workitem.fields['try'] || 0
+      context.tracer << "#{Time.now.to_f}\n"
+      workitem.fields['try'] = try + 1
+      if (try == 0)
+        re_dispatch(workitem, :in => @opts['delay'] || '1s')
+      else
+        reply(workitem)
+      end
+    end
+    def cancel (fei, flavour)
+      unschedule_re_dispatch(fei)
+    end
+  end
+
+  def test_participant_re_dispatch_later
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    @engine.register_participant :alpha, RetryParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+
+    times = @tracer.to_s.split("\n").collect { |t| Float(t) }
+    t = times.last - times.first
+
+    assert t >= 1.0, "took less that 1 second"
+    assert t < 2.0, "took more than 1.99 second"
+  end
+
+  def test_participant_re_dispatch_later_cancel
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    @engine.register_participant :alpha, RetryParticipant, 'delay' => '1m'
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    sleep 0.7
+
+    @engine.cancel_process(wfid)
+    wait_for(wfid)
+
+    assert_equal 0, @engine.storage.get_many('schedules').size
+  end
+
+  BLACKBOARD = {}
+
+  class StashingParticipant
+    include Ruote::LocalParticipant
+    def initialize (opts)
+    end
+    def consume (workitem)
+      put(workitem.fei, 'token' => workitem.params['token'])
+    end
+    def cancel (fei, flavour)
+      BLACKBOARD['token'] = get(fei, 'token')
+      BLACKBOARD['all'] = get(fei)
+    end
+  end
+
+  def test_stash
+
+    BLACKBOARD.clear
+
+    pdef = Ruote.process_definition do
+      alpha :token => 'of esteem'
+    end
+
+    @engine.register_participant :alpha, StashingParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(:alpha)
+
+    sleep 0.350 # since wait_for(:alpha) releases too early sometimes
+
+    ps = @engine.process(wfid)
+    fexp = ps.expressions.find { |e| e.fei.expid == '0_0' }
+
+    assert_equal({ 'token' => 'of esteem' }, fexp.h.stash)
+
+    @engine.cancel_process(wfid)
+    wait_for(wfid)
+
+    assert_equal('of esteem', BLACKBOARD['token'])
+    assert_equal({ 'token' => 'of esteem' }, BLACKBOARD['all'])
+  end
+end
+

data/test/functional/ft_39_wait_for.rb

@@ -0,0 +1,100 @@
+
+#
+# testing ruote
+#
+# Tue Apr 20 12:32:44 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/storage_participant'
+
+
+class FtEngineTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_workitem
+
+    pdef = Ruote.process_definition :name => 'my process' do
+      alpha
+    end
+
+    sp = @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    assert_equal Ruote::Workitem, @engine.workitem("0_0!!#{wfid}").class
+  end
+
+  class MyParticipant
+    include Ruote::LocalParticipant
+    def initialize (opts)
+    end
+    def consume (workitem)
+      sleep rand * 2
+      reply_to_engine(workitem)
+    end
+  end
+
+  def test_wait_for_empty
+
+    pdef = Ruote.process_definition :name => 'my process' do
+      alpha
+    end
+
+    @engine.register_participant :alpha, MyParticipant
+
+    4.times do
+      @engine.launch(pdef)
+    end
+
+    #noisy
+
+    @engine.wait_for(:empty)
+
+    assert_equal [], @engine.processes
+  end
+
+  def test_wait_for_multiple
+
+    pdef0 = Ruote.process_definition { alpha }
+    pdef1 = Ruote.process_definition { bravo }
+
+    @engine.register_participant :alpha, MyParticipant
+
+    #noisy
+
+    wfids = []
+
+    2.times { wfids << @engine.launch(pdef0) }
+    2.times { wfids << @engine.launch(pdef1) }
+
+    @engine.wait_for(*wfids)
+
+    assert_equal 2, @engine.processes.size
+  end
+
+  def test_wait_for_inactive
+
+    pdef0 = Ruote.process_definition { alpha }
+    pdef1 = Ruote.process_definition { bravo }
+
+    @engine.register_participant :alpha, MyParticipant
+
+    #noisy
+
+    wfids = []
+
+    2.times { @engine.launch(pdef0) }
+    2.times { wfids << @engine.launch(pdef1) }
+
+    @engine.wait_for(:inactive)
+
+    assert_equal wfids.sort, @engine.processes.collect { |ps| ps.wfid }.sort
+  end
+end
+

data/test/functional/ft_40_participant_on_reply.rb

@@ -0,0 +1,87 @@
+
+#
+# testing ruote
+#
+# Thu Apr 22 14:41:38 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/local_participant'
+
+
+class FtParticipantOnReplyTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class MyParticipant
+    include Ruote::LocalParticipant
+    def initialize (opts)
+    end
+    def consume (workitem)
+      reply(workitem)
+    end
+    def on_reply (workitem)
+      workitem.fields['message'] = 'hello'
+    end
+  end
+
+  def test_participant_on_reply
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+        echo '${f:message}'
+      end
+    end
+
+    @engine.register_participant :alpha, MyParticipant
+
+    #noisy
+
+    assert_trace('hello', pdef)
+  end
+
+  class AwkwardParticipant
+    include Ruote::LocalParticipant
+    def initialize (opts)
+    end
+    def consume (workitem)
+      reply(workitem)
+    end
+    def on_reply (workitem)
+      return if workitem.fields['pass']
+      raise "something went wrong"
+    end
+  end
+
+  def test_participant_on_reply_error
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+        echo 'over.'
+      end
+    end
+
+    @engine.register_participant :alpha, AwkwardParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    assert_equal 1, ps.errors.size
+
+    err = ps.errors.first
+    err.fields['pass'] = true
+    @engine.replay_at_error(err)
+
+    wait_for(wfid)
+
+    assert_equal 'over.', @tracer.to_s
+  end
+end
+

data/test/functional/ft_41_participants.rb

@@ -0,0 +1,65 @@
+
+#
+# testing ruote
+#
+# Mon Jun 14 12:02:53 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/local_participant'
+
+
+class FtMiscParticipantTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class MyParticipant
+    include Ruote::LocalParticipant
+    def consume (workitem)
+      workitem.fields['seen'] = true
+      reply_to_engine(workitem)
+    end
+  end
+
+  class MyMessageParticipant
+    include Ruote::LocalParticipant
+    def initialize (opts)
+      @opts = opts
+    end
+    def consume (workitem)
+      workitem.fields['message'] = @opts['message']
+      reply_to_engine(workitem)
+    end
+  end
+
+  def test_participant_without_initialize
+
+    @engine.register_participant :alpha, MyParticipant
+
+    #noisy
+
+    wfid = @engine.launch(Ruote.process_definition do
+      alpha
+    end)
+
+    r = wait_for(wfid)
+
+    assert_equal true, r['workitem']['fields']['seen']
+  end
+
+  def test_participant_with_initialize
+
+    @engine.register_participant :bravo, MyMessageParticipant, 'message' => 'hi'
+
+    #noisy
+
+    wfid = @engine.launch(Ruote.process_definition do
+      bravo
+    end)
+
+    r = wait_for(wfid)
+
+    assert_equal 'hi', r['workitem']['fields']['message']
+  end
+end
+

data/test/functional/ft_42_storage_copy.rb

@@ -0,0 +1,67 @@
+
+#
+# testing ruote
+#
+# Tue Jun 15 09:07:58 JST 2010
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/storage_participant'
+
+
+class FtStorageCopyTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_copy_to_hash_storage
+
+    @engine.register_participant '.+', Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(Ruote.process_definition do
+      sequence do
+        alpha :timeout => '2d'
+      end
+    end)
+
+    wait_for(:alpha)
+
+    target = Ruote::HashStorage.new
+    source = @engine.context.storage
+
+    #count = source.copy_to(target, :verbose => true)
+    count = source.copy_to(target)
+
+    assert_equal 8, count
+    assert_equal source.ids('expressions'), target.ids('expressions')
+  end
+
+  def test_copy_from_hash_storage
+
+    engine = Ruote::Engine.new(Ruote::Worker.new(Ruote::HashStorage.new()))
+
+    engine.register_participant '.+', Ruote::StorageParticipant
+
+    #engine.context.logger.noisy = true
+
+    wfid = engine.launch(Ruote.process_definition do
+      sequence do
+        alpha :timeout => '2d'
+      end
+    end)
+
+    engine.wait_for(:alpha)
+
+    source = engine.context.storage
+    target = @engine.context.storage
+
+    #count = source.copy_to(target, :verbose => true)
+    count = source.copy_to(target)
+
+    assert_equal 8, count
+    assert_equal source.ids('expressions'), target.ids('expressions')
+    assert_not_nil @engine.process(wfid)
+  end
+end
+