ruote 0.9.18 → 0.9.19

data/test/ft_58_ejournal.rb

@@ -19,133 +19,136 @@ require 'openwfe/expool/errorjournal'
 
 
 class FlowTest58 < Test::Unit::TestCase
-    include FlowTestBase
+  include FlowTestBase
 
-    #def teardown
-    #end
+  #def teardown
+  #end
 
-    #def setup
-    #end
+  #def setup
+  #end
 
 
-    #
-    # TEST 0
-
-    class Test0 < OpenWFE::ProcessDefinition
-        sequence do
-            participant :alpha
-            participant :nada
-            participant :bravo
-        end
+  #
+  # TEST 0
+
+  class Test0 < OpenWFE::ProcessDefinition
+    sequence do
+      participant :alpha
+      participant :nada
+      participant :bravo
     end
+  end
 
-    def test_0
+  def test_0
 
-        ejournal = @engine.get_error_journal
+    ejournal = @engine.get_error_journal
 
-        @engine.register_participant(:alpha) do |wi|
-            @tracer << "alpha\n"
-        end
+    @engine.register_participant(:alpha) do |wi|
+      @tracer << "alpha\n"
+    end
 
-        li = OpenWFE::LaunchItem.new Test0
-        fei = launch li
+    li = OpenWFE::LaunchItem.new Test0
+    fei = launch li
 
-        sleep 0.300
+    sleep 0.300
 
-        assert File.exist?("work/ejournal/#{fei.parent_wfid}.ejournal") \
-            if @engine.is_a?(OpenWFE::FilePersistedEngine)
+    assert File.exist?("work/ejournal/#{fei.parent_wfid}.ejournal") \
+      if @engine.is_a?(OpenWFE::FilePersistedEngine)
 
-        errors = ejournal.get_error_log fei
+    errors = ejournal.get_error_log fei
 
-        #require 'pp'; pp ejournal
-        #puts "/// error journal of class #{ejournal.class.name}"
+    #require 'pp'; pp ejournal
+    #puts "/// error journal of class #{ejournal.class.name}"
 
-        assert_equal 1, errors.length
+    assert_equal 1, errors.length
 
-        assert ejournal.has_errors?(fei)
-        assert ejournal.has_errors?(fei.wfid)
+    assert ejournal.has_errors?(fei)
+    assert ejournal.has_errors?(fei.wfid)
 
-        # OK, let's fix the root and replay
+    assert_equal 1, ejournal.get_error_logs.size
+    assert_equal fei.wfid, ejournal.get_error_logs.keys.first
 
-        @engine.register_participant(:nada) do |wi|
-            @tracer << "nada\n"
-        end
-        @engine.register_participant(:bravo) do |wi|
-            @tracer << "bravo\n"
-        end
+    # OK, let's fix the root and replay
 
-        # fix done
+    @engine.register_participant(:nada) do |wi|
+      @tracer << "nada\n"
+    end
+    @engine.register_participant(:bravo) do |wi|
+      @tracer << "bravo\n"
+    end
 
-        assert_equal "alpha", @tracer.to_s
+    # fix done
 
-        @engine.replay_at_error errors.first
+    assert_equal "alpha", @tracer.to_s
 
-        sleep 0.300
+    @engine.replay_at_error errors.first
 
-        assert_equal "alpha\nnada\nbravo", @tracer.to_s
+    sleep 0.300
 
-        errors = ejournal.get_error_log fei
+    assert_equal "alpha\nnada\nbravo", @tracer.to_s
 
-        assert_equal 0, errors.length
+    errors = ejournal.get_error_log fei
 
-        assert ( ! ejournal.has_errors?(fei))
-    end
+    assert_equal 0, errors.length
 
-    #
-    # TEST 1
+    assert ( ! ejournal.has_errors?(fei))
+  end
+
+  #
+  # TEST 1
 
-    # Testing that the changes to the workitem are taken into account
+  # Testing that the changes to the workitem are taken into account
 
-    class Test1 < OpenWFE::ProcessDefinition
-        sequence do
-            participant :nada
-            _print "it's ${f:weather}"
-        end
+  class Test1 < OpenWFE::ProcessDefinition
+    sequence do
+      participant :nada
+      _print "it's ${f:weather}"
     end
+  end
 
-    def test_1
+  def test_1
 
-        ejournal = @engine.get_error_journal
+    ejournal = @engine.get_error_journal
 
-        li = OpenWFE::LaunchItem.new Test1
-        li.weather = "sunny"
+    li = OpenWFE::LaunchItem.new Test1
+    li.weather = "sunny"
 
-        fei = launch li
+    fei = launch li
 
-        sleep 0.300
+    sleep 0.300
 
-        errors = ejournal.get_error_log fei
+    errors = ejournal.get_error_log fei
 
-        #require 'pp'; pp ejournal
-        #puts "/// error journal of class #{ejournal.class.name}"
+    #require 'pp'; pp ejournal
+    #puts "/// error journal of class #{ejournal.class.name}"
 
-        assert_equal 1, errors.length
+    assert_equal 1, errors.length
 
-        assert ejournal.has_errors?(fei)
-        assert ejournal.has_errors?(fei.wfid)
+    assert ejournal.has_errors?(fei)
+    assert ejournal.has_errors?(fei.wfid)
 
-        #
-        # fix
+    #
+    # fix
 
-        @engine.register_participant :nada do
-            # do nothing
-        end
+    @engine.register_participant :nada do
+      # do nothing
+    end
 
-        #
-        # replay
+    #
+    # replay
 
-        error = errors.first
+    error = errors.first
 
-        assert_equal "sunny", error.workitem.weather
+    assert_equal "sunny", error.workitem.weather
 
-        error.workitem.weather = "rainy"
+    error.workitem.weather = "rainy"
 
-        @engine.replay_at_error error
+    @engine.replay_at_error error
 
-        sleep 0.300
+    sleep 0.300
 
-        assert_trace "it's rainy"
-    end
+    assert_trace "it's rainy"
+  end
 
 end
 

data/test/ft_58b_ejournal.rb

@@ -0,0 +1,82 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Thu Jun 12 08:38:02 JST 2008
+#
+
+require 'rubygems'
+
+require 'openwfe/def'
+
+require 'flowtestbase'
+
+require 'openwfe/engine/file_persisted_engine'
+require 'openwfe/expool/errorjournal'
+
+
+
+class FlowTest58 < Test::Unit::TestCase
+  include FlowTestBase
+
+  #def teardown
+  #end
+
+  #def setup
+  #end
+
+
+  #
+  # TEST 0
+
+  class Test0 < OpenWFE::ProcessDefinition
+    sequence do
+      participant :alpha
+      participant :bravo
+    end
+  end
+
+  def test_0
+
+    ejournal = @engine.get_error_journal
+
+    @engine.register_participant(:alpha) do |wi|
+      raise "error inside of block participant"
+    end
+
+    fei = launch Test0
+
+    sleep 0.350
+
+    assert File.exist?("work/ejournal/#{fei.parent_wfid}.ejournal") \
+      if @engine.is_a?(OpenWFE::FilePersistedEngine)
+
+    errors = ejournal.get_error_log fei
+
+    assert_equal 1, errors.length
+    assert_equal "RuntimeError", errors.first.error_class
+
+    assert_equal(
+      'error inside of block participant',
+      errors.first.stacktrace.split("\n").first)
+
+    @engine.replay_at_error errors.first
+
+    sleep 0.350
+
+    errors = ejournal.get_error_log fei
+
+    assert_equal 1, errors.length
+    assert_equal "RuntimeError", errors.first.error_class
+
+    assert_equal(
+      'error inside of block participant',
+      errors.first.stacktrace.split("\n").first)
+
+    purge_engine
+  end
+
+end
+

data/test/ft_59_ps.rb

@@ -7,6 +7,8 @@
 # Sat Jul  7 22:44:00 JST 2007 (tanabata)
 #
 
+require 'rubygems'
+
 require 'openwfe/def'
 require 'openwfe/participants/storeparticipants'
 
@@ -14,137 +16,197 @@ require 'flowtestbase'
 
 
 class FlowTest59 < Test::Unit::TestCase
-    include FlowTestBase
+  include FlowTestBase
 
-    #def setup
-    #end
+  #def setup
+  #end
 
-    #def teardown
-    #end
+  #def teardown
+  #end
 
-    #
-    # TEST 0
+  #
+  # TEST 0
 
-    class Def59 < ProcessDefinition
-        concurrence do
-            store_a
-            store_b
-        end
+  class Def59 < OpenWFE::ProcessDefinition
+    concurrence do
+      store_a
+      store_b
     end
+  end
 
-    def test_0
+  def test_0
 
-        sa = @engine.register_participant("store_a", OpenWFE::HashParticipant)
-        sb = @engine.register_participant("store_b", OpenWFE::HashParticipant)
+    sa = @engine.register_participant("store_a", OpenWFE::HashParticipant)
+    sb = @engine.register_participant("store_b", OpenWFE::HashParticipant)
 
-        fei = launch Def59
+    fei = launch Def59
 
-        sleep 0.350
+    sleep 0.350
 
-        ps = @engine.process_statuses
-        #puts ps
+    ps = @engine.process_statuses
+    #puts ps
 
-        assert_equal 2, ps[fei.wfid].expressions.size
-        assert_equal 0, ps[fei.wfid].errors.size
+    assert_equal 2, ps[fei.wfid].expressions.size
+    assert_equal 0, ps[fei.wfid].errors.size
 
-        @engine.cancel_process fei
-    end
+    @engine.cancel_process fei
+  end
 
-    #
-    # TEST 0b
+  #
+  # TEST 0b
 
-    class Def59b < ProcessDefinition
-        sequence do
-            alpha
-            bravo
-        end
+  class Def59b < OpenWFE::ProcessDefinition
+    sequence do
+      alpha
+      bravo
     end
+  end
+
+  def test_0b
+
+    a = @engine.register_participant :alpha, OpenWFE::HashParticipant
+    b = @engine.register_participant :bravo, OpenWFE::HashParticipant
 
-    def test_0b
+    fei = launch Def59b
 
-        a = @engine.register_participant :alpha, OpenWFE::HashParticipant
-        b = @engine.register_participant :bravo, OpenWFE::HashParticipant
+    sleep 0.350
 
-        fei = launch Def59b
+    ps = @engine.process_statuses
+    #puts ps
 
-        sleep 0.350
+    assert_equal 1, ps[fei.wfid].expressions.size
+    assert_equal 0, ps[fei.wfid].errors.size
 
-        ps = @engine.process_statuses
-        #puts ps
+    @engine.cancel_process fei
+  end
 
-        assert_equal 1, ps[fei.wfid].expressions.size
-        assert_equal 0, ps[fei.wfid].errors.size
+  #
+  # TEST 1
 
-        @engine.cancel_process fei
+  class Def59_1 < OpenWFE::ProcessDefinition
+    sequence do
+      nada59_1
+      alpha
     end
+  end
 
-    #
-    # TEST 1
+  def test_1
 
-    class Def59_1 < ProcessDefinition
-        sequence do
-            nada59_1
-            alpha
-        end
+    alpha = @engine.register_participant :alpha do
+      # nothing
     end
 
-    def test_1
+    fei = launch Def59_1
 
-        alpha = @engine.register_participant :alpha do
-            # nothing
-        end
+    sleep 0.350
 
-        fei = launch Def59_1
+    ps = @engine.process_statuses
+    #p ps[fei.wfid].scheduled_jobs
+    #puts ps[fei.wfid].errors
 
-        sleep 0.350
+    assert_equal 1, ps[fei.wfid].expressions.size
+    assert_equal 1, ps[fei.wfid].branches
+    assert_equal 1, ps[fei.wfid].errors.size
 
-        ps = @engine.process_statuses
-        #puts ps
-        #puts ps[fei.wfid].errors
+    #puts
+    #puts ps.to_s
 
-        assert_equal 1, ps[fei.wfid].expressions.size
-        assert_equal 1, ps[fei.wfid].branches
-        assert_equal 1, ps[fei.wfid].errors.size
+    @engine.cancel_process fei.wfid
+  end
 
-        #puts
-        #puts ps.to_s
+  #
+  # TEST 2
 
-        @engine.cancel_process fei.wfid
+  class Def59c < OpenWFE::ProcessDefinition
+    sequence do
+      bravo
+      alpha
     end
+  end
+
+  def test_2
+
+    a = @engine.register_participant :alpha, OpenWFE::HashParticipant
+    b = @engine.register_participant :bravo, OpenWFE::HashParticipant
+
+    feis = []
+    feis << launch(Def59b)
+    feis << launch(Def59b)
+    feis << launch(Def59c)
 
-    #
-    # TEST 2
+    sleep 0.350
 
-    class Def59c < ProcessDefinition
-        sequence do
-            bravo
-            alpha
-        end
+    assert_equal 3, @engine.list_processes(:wfname => "Def").size
+    assert_equal 2, @engine.list_processes(:wfrevision => "59b").size
+    assert_equal 1, @engine.list_processes(:wfrevision => "59c").size
+    assert_equal 2, @engine.list_processes(:wfname => "Def", :wfrevision => "59b").size
+
+    feis.each do |fei|
+      @engine.cancel_process fei
     end
 
-    def test_2
+    sleep 0.350
+  end
 
-        a = @engine.register_participant :alpha, OpenWFE::HashParticipant
-        b = @engine.register_participant :bravo, OpenWFE::HashParticipant
+  #
+  # TEST 3
 
-        feis = []
-        feis << launch(Def59b)
-        feis << launch(Def59b)
-        feis << launch(Def59c)
+  class Def59d < OpenWFE::ProcessDefinition
+    _sleep "1h"
+  end
 
-        sleep 0.350
+  def test_3
 
-        assert_equal 3, @engine.list_processes(:wfname => "Def").size
-        assert_equal 2, @engine.list_processes(:wfrevision => "59b").size
-        assert_equal 1, @engine.list_processes(:wfrevision => "59c").size
-        assert_equal 2, @engine.list_processes(:wfname => "Def", :wfrevision => "59b").size
+    now = Time.now
 
-        feis.each do |fei|
-            @engine.cancel_process fei
-        end
+    fei = launch Def59d
 
-        sleep 0.350
-    end
+    sleep 0.350
+
+    ps = @engine.process_status fei.wfid
+
+    delta =  ps.scheduled_jobs.first.next_time - now
+    assert(delta > 3600)
+    assert(delta < 3601)
+
+    purge_engine
+  end
+
+  #
+  # TEST 4
+
+  def test_4
+
+    sa = @engine.register_participant('store_a', OpenWFE::HashParticipant)
+    sb = @engine.register_participant('store_b', OpenWFE::HashParticipant)
+
+    fei = launch Def59
+
+    sleep 0.350
+
+    ps0 = @engine.process_status fei.wfid
+    pss0 = @engine.process_statuses
+    sleep 0.020
+    ps1 = @engine.process_status fei.wfid
+    pss1 = @engine.process_statuses
+
+    assert_equal ps0.timestamp, ps1.timestamp
+    assert_equal pss0.object_id, pss1.object_id
+
+    sa.forward(sa.first_workitem)
+
+    sleep 0.350
+
+    ps2 = @engine.process_status fei.wfid
+    pss2 = @engine.process_statuses
+
+    assert_not_equal ps0.timestamp, ps2.timestamp
+    assert_not_equal pss0.object_id, pss2.object_id
+
+    @engine.cancel_process fei
+
+    sleep 0.350
+  end
 
 end