ruote 0.9.20 → 2.1.1

data/test/functional/ft_28_null_noop_participants.rb

@@ -0,0 +1,51 @@
+
+#
+# testing ruote
+#
+# Mon Sep 14 19:11:45 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/no_op_participant'
+require 'ruote/part/null_participant'
+
+
+class FtNullNoopParticipantsTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_null_participant
+
+    pdef = Ruote.process_definition :name => 'def0' do
+      alpha
+    end
+
+    alpha = @engine.register_participant :alpha, Ruote::NullParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(4)
+
+    ps = @engine.process(wfid)
+
+    assert_not_nil ps
+    assert_equal [], ps.errors
+  end
+
+  def test_noop_participant
+
+    pdef = Ruote.process_definition :name => 'def0' do
+      alpha
+      echo 'done.'
+    end
+
+    @engine.register_participant :alpha, Ruote::NoOpParticipant
+
+    #noisy
+
+    assert_trace pdef, "done."
+  end
+end
+

data/test/functional/ft_29_part_template.rb

@@ -0,0 +1,78 @@
+
+#
+# testing ruote
+#
+# Mon Sep 14 19:31:37 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/participant'
+require 'ruote/part/template'
+
+
+class FtPartTemplateTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  class MyParticipant
+    include Ruote::LocalParticipant
+    include Ruote::TemplateMixin
+
+    def initialize (opts={}, &block)
+
+      @block_template = block
+      @template = opts[:template]
+    end
+
+    def consume (workitem)
+
+      @context['s_tracer'] << render_template(
+        Ruote::Exp::FlowExpression.fetch(@context, workitem.fei.to_h), workitem)
+      @context['s_tracer'] << "\n"
+
+      reply_to_engine(workitem)
+    end
+
+    def cancel (fei, flavour)
+    end
+  end
+
+  def test_template
+
+    pdef = Ruote.process_definition :name => 'def0' do
+      set 'v:var0' => 'v_value'
+      set 'f:field0' => 'f_value'
+      alpha
+      echo 'done.'
+    end
+
+    #noisy
+
+    @engine.register_participant(
+      :alpha,
+      MyParticipant.new(:template => "0:${v:var0}\n1:${f:field0}"))
+
+    assert_trace pdef, %w[ 0:v_value 1:f_value done. ]
+  end
+
+  def test_block_template
+
+    pdef = Ruote.process_definition :name => 'def0' do
+      set 'v:var0' => 'v_value'
+      set 'f:field0' => 'f_value'
+      alpha
+      echo 'done.'
+    end
+
+    #noisy
+
+    @engine.register_participant(
+      :alpha,
+      MyParticipant.new {
+        "0:${v:var0}\n1:${f:field0}"
+      })
+
+    assert_trace pdef, %w[ 0:v_value 1:f_value done. ]
+  end
+end
+

data/test/functional/ft_2_errors.rb

@@ -0,0 +1,320 @@
+
+#
+# testing ruote
+#
+# Fri May 15 09:51:28 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/hash_participant'
+
+
+class FtErrorsTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_error
+
+    pdef = Ruote.process_definition do
+      nada
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    assert_equal 1, ps.errors.size
+
+    pss = @engine.processes
+
+    assert_equal 1, pss.size
+    assert_equal 1, pss.first.errors.size
+  end
+
+  # asm and jpr5 use that sometimes
+  #
+  def test_error_reapply
+
+    pdef = Ruote.process_definition do
+      nada
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    exp = ps.expressions.find { |fe| fe.class == Ruote::Exp::RawExpression }
+
+    assert_not_nil exp
+
+    @engine.register_participant :nada do |workitem|
+      @tracer << 'done.'
+    end
+
+    @engine.re_apply(exp.fei)
+    wait_for(wfid)
+
+    assert_equal 'done.', @tracer.to_s
+
+    assert_equal 0, @engine.storage.get_many('errors').size
+  end
+
+  def test_error_replay
+
+    pdef = Ruote.process_definition do
+      nada
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    err = ps.errors.first
+
+    @engine.replay_at_error(err)
+
+    wait_for(wfid)
+    ps = @engine.process(wfid)
+
+    #p ps
+
+    assert_equal 1, ps.errors.size
+      # only one error
+
+    err1 = ps.errors.first
+
+    assert_not_equal err.at, err1.at
+      # not the same error
+
+    assert_equal 1, @engine.storage.get_many('errors').size
+  end
+
+  def test_error_fix_then_replay
+
+    pdef = Ruote.process_definition do
+      nada
+    end
+
+    @engine.register_participant :alpha do
+      @tracer << "alpha\n"
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+    ps = @engine.process(wfid)
+
+    err = ps.errors.first
+    assert_equal [ 'nada', {}, [] ], err.tree
+
+    err.tree = [ 'alpha', {}, [] ]
+    @engine.replay_at_error(err)
+    wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+
+    assert_equal 'alpha', @tracer.to_s
+
+    # check if error is really gone from error journal...
+
+    assert_equal [], @engine.storage.get_many('errors')
+  end
+
+  def test_error_in_participant
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+        echo 'done.'
+      end
+    end
+
+    count = 0
+
+    @engine.register_participant :alpha do
+      count += 1
+      @tracer << "alpha\n"
+      raise "something went wrong" if count == 1
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    assert_equal 1, ps.errors.size
+
+    #p ps.expressions.size
+    #ps.expressions.each do |e|
+    #  p [ e.fei.to_s, e.class, e.state ]
+    #end
+
+    @engine.replay_at_error(ps.errors.first)
+
+    wait_for(wfid)
+
+    assert_equal %w[ alpha alpha done. ].join("\n"), @tracer.to_s
+  end
+
+  def test_error_in_do_no_thread_participant
+
+    pdef = Ruote.process_definition do
+      sequence do
+        alpha
+        echo 'done.'
+      end
+    end
+
+    count = 0
+
+    alpha = @engine.register_participant :alpha do
+      count += 1
+      @tracer << "alpha\n"
+      raise "something went wrong" if count == 1
+    end
+    alpha.do_not_thread = true
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    assert_equal 1, ps.errors.size
+
+    @engine.replay_at_error(ps.errors.first)
+
+    wait_for(wfid)
+
+    assert_equal %w[ alpha alpha done. ].join("\n"), @tracer.to_s
+  end
+
+  def test_errors_and_subprocesses
+
+    pdef = Ruote.process_definition do
+      sequence do
+        sub0
+        echo 'done.'
+      end
+      define 'sub0' do
+        alpha
+      end
+    end
+
+    count = 0
+
+    alpha = @engine.register_participant :alpha do
+      count += 1
+      @tracer << "alpha\n"
+      raise "something went wrong" if count == 1
+    end
+    alpha.do_not_thread = true
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    assert_equal 1, ps.errors.size
+
+    err = ps.errors.first
+
+    assert_equal wfid, err.fei.wfid
+    assert_not_nil err.fei.sub_wfid
+
+    @engine.replay_at_error(err)
+
+    wait_for(wfid)
+
+    assert_equal %w[ alpha alpha done. ].join("\n"), @tracer.to_s
+  end
+
+  def test_process_cancellation
+
+    pdef = Ruote.process_definition do
+      nada
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(wfid)
+
+    assert_equal 1, @engine.process(wfid).errors.size
+
+    @engine.cancel_process(wfid)
+
+    wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+    assert_equal [], @engine.storage.get_many('errors')
+  end
+
+  def test_forgotten_subprocess
+
+    pdef = Ruote.process_definition do
+      sequence do
+        sub0 :forget => true
+        echo 'done.'
+      end
+      define 'sub0' do
+        error 'broken wing'
+      end
+    end
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+    wait_for(wfid)
+
+    assert_equal 'done.', @tracer.to_s
+
+    ps = @engine.process(wfid)
+    assert_equal 3, ps.expressions.size
+    assert_equal 1, ps.errors.size
+
+    @engine.replay_at_error(ps.errors.first)
+    wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+  end
+
+  def test_ps_to_h
+
+    pdef = Ruote.process_definition do
+      error 'nada'
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    es = ps.to_h['errors']
+    e = es.first
+
+    assert_equal 1, es.size
+    assert_equal 'reply', e['msg']['action']
+    assert_equal wfid, e['msg']['fei']['wfid']
+    assert_equal 7, e.size
+  end
+end
+