ruote-maestrodev 2.2.1

data/test/functional/ft_25_receiver.rb

@@ -0,0 +1,207 @@
+
+#
+# testing ruote
+#
+# Wed Aug 12 23:24:16 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+
+
+class FtReceiverTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def setup
+
+    super
+
+    @pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        alpha
+        echo '.'
+      end
+    end
+
+    @engine.register_participant 'alpha', MyParticipant
+  end
+
+  class MyParticipant
+    include Ruote::LocalParticipant
+
+    def consume(workitem)
+
+      @context.stash[:wi] = workitem
+
+      # no reply to the engine
+    end
+
+    # do not let the dispatch happen in its own thread, this makes
+    # wait_for(:alpha) synchronous.
+    #
+    def do_not_thread
+
+      true
+    end
+  end
+
+  class MyReceiver < Ruote::Receiver
+    attr_reader :context
+  end
+
+  def test_my_receiver_init
+
+    cid = @engine.context.object_id
+
+    receiver = MyReceiver.new(@engine)
+    assert_equal cid, receiver.context.object_id
+    assert_not_nil receiver.context.storage
+
+    receiver = MyReceiver.new(@engine.context)
+    assert_equal cid, receiver.context.object_id
+    assert_not_nil receiver.context.storage
+
+    receiver = MyReceiver.new(@engine.worker)
+    assert_equal cid, receiver.context.object_id
+    assert_not_nil receiver.context.storage
+
+    receiver = MyReceiver.new(@engine.storage)
+    assert_equal cid, receiver.context.object_id
+    assert_not_nil receiver.context.storage
+
+    @engine.storage.instance_variable_set(:@context, nil)
+    receiver = MyReceiver.new(@engine.storage)
+    assert_not_equal cid, receiver.context.object_id
+    assert_not_nil receiver.context.storage
+  end
+
+  def test_my_receiver
+
+    receiver = MyReceiver.new(@engine.context)
+
+    #noisy
+
+    wfid = @engine.launch(@pdef)
+
+    wait_for(:alpha)
+    while @engine.context.stash[:wi].nil? do
+      Thread.pass
+    end
+
+    assert_equal 3, @engine.process(wfid).expressions.size
+
+    receiver.receive(@engine.context.stash[:wi])
+
+    wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+
+    rcv = logger.log.select { |e| e['action'] == 'receive' }.first
+    assert_equal 'FtReceiverTest::MyReceiver', rcv['receiver']
+  end
+
+  def test_engine_receive
+
+    wfid = @engine.launch(@pdef)
+
+    wait_for(:alpha)
+
+    @engine.receive(@engine.context.stash[:wi])
+
+    wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+
+    rcv = logger.log.select { |e| e['action'] == 'receive' }.first
+    assert_equal 'Ruote::Engine', rcv['receiver']
+  end
+
+  class MyOtherParticipant
+    include Ruote::LocalParticipant
+    def consume(workitem)
+      @context.receiver.pass(workitem.to_h)
+    end
+  end
+  class MyOtherReceiver < Ruote::Receiver
+    def initialize(context, opts={})
+      super(context, opts)
+      @count = 0
+    end
+    def pass(workitem)
+      if @count < 1
+        @context.error_handler.action_handle(
+          'dispatch', workitem['fei'], RuntimeError.new('something went wrong'))
+      else
+        reply(workitem)
+      end
+      @count = @count + 1
+    end
+  end
+
+  def test_receiver_triggered_dispatch_error
+
+    class << @engine.context
+      def receiver
+        @rcv ||= MyOtherReceiver.new(engine)
+      end
+    end
+
+    @engine.register_participant :alpha, MyOtherParticipant
+
+    pdef = Ruote.process_definition do
+      alpha
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+    err = ps.errors.first
+
+    assert_equal 1, ps.errors.size
+    assert_equal '#<RuntimeError: something went wrong>', err.message
+
+    @engine.replay_at_error(err)
+
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    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_rtimeout.rb

@@ -0,0 +1,179 @@
+
+#
+# testing ruote
+#
+# Sun Aug 16 14:25:35 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+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
+      sequence do
+        alpha
+        bravo
+      end
+    end
+
+    @engine.register_participant :alpha, AlphaParticipant
+    sto = @engine.register_participant :bravo, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(13)
+
+    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 sto.first.fields['__timed_out__']
+  end
+
+  class MyParticipant
+    include Ruote::LocalParticipant
+    def consume(workitem)
+      # do nothing
+    end
+    def cancel(fei, flavour)
+      # do nothing
+    end
+    def rtimeout
+      '1s'
+    end
+    def do_not_thread
+      true
+    end
+  end
+
+  def test_participant_class_defined_timeout
+
+    pdef = Ruote.define do
+      alpha
+      echo 'done.'
+    end
+
+    @engine.register_participant :alpha, MyParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(wfid)
+
+    assert_equal 'done.', @tracer.to_s
+    assert_equal 2, logger.log.select { |e| e['flavour'] == 'timeout' }.size
+  end
+
+  def test_pdef_overriden_timeout
+
+    # process definition cancels timeout given by participant
+
+    pdef = Ruote.define do
+      alpha :timeout => ''
+      echo 'done.'
+    end
+
+    @engine.register_participant :alpha, MyParticipant
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:alpha)
+
+    sleep 0.350
+
+    assert_equal 0, @engine.storage.get_many('schedules').size
+    assert_equal '', @tracer.to_s
+  end
+
+  class MyOtherParticipant
+    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)
+      @opts['timeout']
+    end
+  end
+
+  def test_participant_option_defined_timeout
+
+    pdef = Ruote.define do
+      alpha
+      bravo
+      echo 'done.'
+    end
+
+    @engine.register_participant :alpha, MyOtherParticipant, 'timeout' => '1s'
+    @engine.register_participant :bravo, MyOtherParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    @engine.wait_for(:bravo)
+
+    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_27_var_indirection.rb

@@ -0,0 +1,128 @@
+
+#
+# testing ruote
+#
+# Sun Aug 23 16:59:07 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class FtVarIndirectionTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_var_alias
+
+    pdef = Ruote.process_definition :name => 'def0' do
+      set :v => 'alpha', :val => 'bravo'
+      sequence do
+        alpha
+        bravo
+      end
+    end
+
+    alpha = @engine.register_participant :bravo do |workitem|
+      @tracer << "b:#{workitem.fields['params']['original_ref']}\n"
+    end
+
+    #noisy
+
+    assert_trace(%w[ b:alpha b: ], pdef)
+  end
+
+  def test_participant_indirection
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set 'v:v' => 'alpha'
+        #participant '${v:v}'
+        v
+      end
+    end
+
+    @engine.register_participant :alpha do |workitem|
+      @tracer << "alpha\n"
+    end
+
+    #noisy
+
+    assert_trace 'alpha', pdef
+  end
+
+  def test_subprocess_indirection
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set 'v:v' => 'sub0'
+        #subprocess '${v:v}'
+        v
+      end
+      define 'sub0' do
+        echo 'a'
+      end
+    end
+
+    #noisy
+
+    assert_trace 'a', pdef
+  end
+
+  def test_subprocess_indirection_uri
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set 'v:v' => File.join(File.dirname(__FILE__), '..', 'pdef.xml')
+        #subprocess '${v:v}'
+        v
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ a b ], pdef
+  end
+
+  def test_subprocess_uri_set_as_engine_variable
+
+    pdef = Ruote.process_definition do
+      v
+    end
+
+    #noisy
+
+    @engine.variables['v'] = File.join(File.dirname(__FILE__), '..', 'pdef.xml')
+
+    assert_trace %w[ a b ], pdef
+  end
+
+  def test_subprocess_uri_set_as_engine_variable__absolute
+
+    pdef = Ruote.process_definition do
+      v
+    end
+
+    #noisy
+
+    @engine.variables['v'] = File.expand_path(
+      File.join(File.dirname(__FILE__), '..', 'pdef.xml'))
+
+    assert_trace %w[ a b ], pdef
+  end
+
+  def test_engine_variable_for_expression_aliases
+
+    pdef = Ruote.define do
+      output "nada"
+    end
+
+    @engine.variables['output'] = 'echo'
+
+    #@engine.noisy = true
+
+    wfid = @engine.launch(pdef)
+    @engine.wait_for(wfid)
+
+    assert_equal 'nada', @tracer.to_s
+  end
+end
+