openwferu 0.9.16 → 0.9.17

data/test/rake_qtest.rb

@@ -6,30 +6,31 @@
 # Mon Oct  9 22:19:44 JST 2006
 #
 
+require 'rubygems'
+
+
 require 'fei_test'
 require 'wfid_test'
 require 'wi_test'
 require 'lookup_att_test'
 require 'filter_test'
-require 'dollar_test'
 require 'misc_test'
+require 'condition_test'
 require 'hash_test'
-require 'lru_test'
-require 'time_test'
 require 'raw_prog_test'
 require 'file_persistence_test'
-require 'cronline_test'
-require 'safely_test'
-require 'kotoba_test'
 require 'expmap_test'
 require 'obs_test'
 require 'clone_test'
+require 'lookup_vf_test'
 require 'fe_lookup_att_test'
 
 require 'sec_test'
 require 'param_test'
 
+require 'storage_test'
 require 'file_persisted_engine_test'
+require 'filep_cancel_test'
 require 'ruby_procdef_test'
 require 'description_test'
 

data/test/raw_prog_test.rb

@@ -8,27 +8,25 @@
 #
 
 require 'test/unit'
-require 'openwfe/expressions/raw_prog'
+require 'openwfe/def'
+require 'openwfe/expool/parser'
 
 
 class RawProgTest < Test::Unit::TestCase
 
-    DEBUG = false
-
     #def setup
     #end
 
     #def teardown
     #end
 
-    XML_DEF = """
-<process-definition name='test0' revision='0'>
-  <sequence>
-    <participant ref='a'/>
-    <participant ref='b'/>
-  </sequence>
-</process-definition>""".strip
-
+    XML_DEF = 
+        "<process-definition name='test0' revision='0'>"+
+        "<sequence>"+
+        "<participant ref='a'/>"+
+        "<participant ref='b'/>"+
+        "</sequence>"+
+        "</process-definition>"
 
     #
     # TEST 0
@@ -47,24 +45,17 @@ class RawProgTest < Test::Unit::TestCase
 
     def test_prog_0
 
-        s = TestDefinition.new().make.to_s
+        s = OpenWFE::ExpressionTree.to_s(TestDefinition.new.make)
 
-        puts s if DEBUG
-
-        assert \
-            s == XML_DEF,
-            "parsing failed (0)"
+        assert_equal XML_DEF, s
     end
 
     def test_prog_0b
 
-        s = TestDefinition.do_make.to_s
-
-        puts s if DEBUG
+        #s = TestDefinition.do_make.to_s
+        s = OpenWFE::ExpressionTree.to_s(TestDefinition.do_make)
 
-        assert \
-            s == XML_DEF,
-            "parsing failed (0b)"
+        assert_equal XML_DEF, s
     end
 
 
@@ -74,7 +65,7 @@ class RawProgTest < Test::Unit::TestCase
 
     def test_prog_1
 
-        pg = OpenWFE::ProcessDefinition.new()
+        pg = OpenWFE::ProcessDefinition.new
 
         class << pg
             def my_proc
@@ -89,11 +80,7 @@ class RawProgTest < Test::Unit::TestCase
         pdef = pg.my_proc
         s = pdef.to_s
 
-        puts s if DEBUG
-
-        assert \
-            s == XML_DEF,
-            "parsing failed (1)"
+        assert XML_DEF, s
     end
 
 
@@ -114,23 +101,21 @@ class RawProgTest < Test::Unit::TestCase
         end
     end
 
-    XML_DEF2 = """
-<process-definition name='test2' revision='0'>
-  <sequence>
-    <set field='toto'>nada</set>
-    <participant ref='b'/>
-  </sequence>
-</process-definition>""".strip
+    XML_DEF2 =
+        "<process-definition name='test2' revision='0'>"+
+        "<sequence>"+
+        "<set field='toto'>"+
+        "nada"+
+        "</set>"+
+        "<participant ref='b'/>"+
+        "</sequence>"+
+        "</process-definition>"
 
     def test_prog_2
 
-        s = TestDefinition2.do_make.to_s
-
-        puts s if DEBUG
+        s = OpenWFE::ExpressionTree.to_s(TestDefinition2.do_make)
 
-        assert \
-            s == XML_DEF2,
-            "parsing failed (2)"
+        assert_equal XML_DEF2, s
 
         #puts
         #puts TestDefinition2.do_make.to_code_s
@@ -152,13 +137,13 @@ class RawProgTest < Test::Unit::TestCase
         end
     end
 
-    XML_DEF3 = """
-<process-definition name='test3' revision='0'>
-  <if>
-    <equals field-value='nada' other-value='surf'/>
-    <participant ref='b'/>
-  </if>
-</process-definition>""".strip
+    XML_DEF3 = 
+        "<process-definition name='test3' revision='0'>"+
+        "<if>"+
+        "<equals field-value='nada' other-value='surf'/>"+
+        "<participant ref='b'/>"+
+        "</if>"+
+        "</process-definition>"
 
     CODE_DEF3 = """
 process_definition :name => 'test3', :revision => '0' do
@@ -170,26 +155,18 @@ end""".strip
 
     def test_prog_3
 
-        s = TestDefinition3.do_make.to_s
-
-        puts s if DEBUG
-
-        assert \
-            s == XML_DEF3,
-            "parsing failed (3)"
+        s = OpenWFE::ExpressionTree.to_s(TestDefinition3.do_make)
 
-        #puts
-        #puts TestDefinition3.do_make.to_code_s
+        assert_equal XML_DEF3, s
 
-        assert \
-            TestDefinition3.do_make.to_code_s == CODE_DEF3,
-            "to_code_s() not working properly (3)"
+        assert_equal(
+            CODE_DEF3, 
+            OpenWFE::ExpressionTree.to_code_s(TestDefinition3.do_make))
 
-        r = OpenWFE::SimpleExpRepresentation.from_xml(s)
-        #puts r.class.name
-        #puts r.to_code_s
+        #r = OpenWFE::SimpleExpRepresentation.from_xml(s)
+        r = OpenWFE::DefParser.parse_xml s
 
-        assert_equal r.to_code_s, CODE_DEF3
+        assert_equal CODE_DEF3, OpenWFE::ExpressionTree.to_code_s(r)
     end
 
 
@@ -223,9 +200,9 @@ end""".strip
         #puts
         #puts TestDefinition4.do_make.to_code_s
 
-        assert \
-            TestDefinition4.do_make.to_code_s == CODE_DEF4,
-            "to_code_s() not working properly (4)"
+        assert_equal(
+            CODE_DEF4, 
+            OpenWFE::ExpressionTree.to_code_s(TestDefinition4.do_make))
     end
 
 
@@ -244,7 +221,7 @@ end""".strip
     end
 
     CODE_DEF4b = """
-process_definition :name => 'TestDefinition4b', :revision => '0' do
+process_definition :name => 'Test', :revision => '4b' do
     sequence do
         participant do
             'b'
@@ -260,14 +237,9 @@ end""".strip
 
     def test_prog_4b
 
-        #puts
-        #puts TestDefinition4.do_make.to_s
-        #puts
-        #puts TestDefinition4b.do_make.to_code_s
-
-        assert \
-            TestDefinition4b.do_make.to_code_s == CODE_DEF4b,
-            "to_code_s() not working properly (4b)"
+        assert_equal(
+            CODE_DEF4b, 
+            OpenWFE::ExpressionTree.to_code_s(TestDefinition4b.do_make))
     end
 
 
@@ -300,14 +272,9 @@ end""".strip
 
     def test_prog_5
 
-        #puts
-        #puts TestDefinition5.do_make.to_s
-        #puts
-        #puts TestDefinition5.do_make.to_code_s
-
-        assert \
-            TestDefinition5.do_make.to_code_s == CODE_DEF5,
-            "to_code_s() not working properly (5)"
+        assert_equal(
+            CODE_DEF5, 
+            OpenWFE::ExpressionTree.to_code_s(TestDefinition5.do_make))
     end
 
 
@@ -334,14 +301,9 @@ end""".strip
 
     def test_prog_6
 
-        #puts
-        #puts TestDefinition60.do_make.to_s
-        #puts
-        #puts TestDefinition60.do_make.to_code_s
-
-        assert \
-            TestDefinition60.do_make.to_code_s == CODE_DEF6,
-            "to_code_s() not working properly (6)"
+        assert_equal(
+            CODE_DEF6, 
+            OpenWFE::ExpressionTree.to_code_s(TestDefinition60.do_make))
     end
 
 
@@ -362,29 +324,29 @@ end""".strip
 
     A_DEF7 = [
         "process-definition",
-        {"name"=>"TestDefinitionSeven", "revision"=>"0"},
-        [
-            ["participant", {"ref"=>:toto}, []]
-        ]
+        { "name"=>"TestDefinitionSeven", "revision"=>"0" },
+        [ [ "participant", { "ref" => :toto }, [] ] ]
     ]
 
     def test_prog_7
 
-        #puts
-        #puts TestDefinition7.do_make.to_s
-        #puts
-        #puts TestDefinition7.do_make.to_code_s
-
-        assert_equal TestDefinitionSeven.do_make.to_code_s, CODE_DEF7
+        assert_equal(
+            CODE_DEF7, 
+            OpenWFE::ExpressionTree.to_code_s(TestDefinitionSeven.do_make))
 
-        assert_equal TestDefinitionSeven.do_make.to_a, A_DEF7
+        assert_equal(
+            A_DEF7, 
+            TestDefinitionSeven.do_make)
     end
 
     #
     # TEST 8
     #
 
-    def do_test(class_name, pdef)
+    def do_test (class_name, pdef)
+        #
+        # losing my time with an eval
+        #
         result = eval """
             class #{class_name} < OpenWFE::ProcessDefinition
                 def make
@@ -393,15 +355,29 @@ end""".strip
             end
             #{class_name}.do_make
         """
-        assert_equal result.attributes['name'], pdef[0]
-        assert_equal result.attributes['revision'], pdef[1]
+        assert_equal result[1]['name'], pdef[0]
+        assert_equal result[1]['revision'], pdef[1]
     end
 
     def test_process_names
-        do_test("MyProcessDefinition_10", ["MyProcess", "10"])
-        do_test("MyProcessDefinition10", ["MyProcess", "10"])
-        do_test("MyProcessDefinition1_0", ["MyProcess", "1.0"])
-        do_test("MyProcessThing_1_0", ["MyProcessThing", "1.0"])
+
+        do_test "MyProcessDefinition_10", ["MyProcess", "10"]
+        do_test "MyProcessDefinition10", ["MyProcess", "10"]
+        do_test "MyProcessDefinition1_0", ["MyProcess", "1.0"]
+        do_test "MyProcessThing_1_0", ["MyProcessThing", "1.0"]
+    end
+
+    def do_test_2 (raw_name, expected)
+
+        assert_equal(
+            expected, 
+            OpenWFE::ProcessDefinition.extract_name_and_revision(raw_name))
+    end
+
+    def test_process_names_2
+
+        do_test_2 "MyProcessDefinition_10", ["MyProcess", "10"]
+        do_test_2 "MyProcessDefinition5b", ["MyProcess", "5b"]
     end
 
 
@@ -427,17 +403,9 @@ process_definition :name => 'Test', :revision => '60' do
     end
 end""".strip
 
-    def xxxx_prog_9
-    #def test_prog_9
-
-        #puts
-        #puts TestDefinition60.do_make.to_s
-        puts
-        puts TestDefinition9.do_make.to_code_s
+    def _test_prog_9
 
-        assert \
-            TestDefinition9.do_make.to_code_s == CODE_DEF9,
-            "to_code_s() not working properly (9)"
+        assert CODE_DEF9, TestDefinition9.do_make.to_code_s
     end
 
 end

data/test/restart_cron_test.rb

@@ -6,11 +6,15 @@
 # Sun Oct 29 15:41:44 JST 2006
 #
 
+require 'rubygems'
+
 require 'test/unit'
 
+require 'fileutils'
+
 require 'openwfe/workitem'
 require 'openwfe/engine/file_persisted_engine'
-require 'openwfe/expressions/raw_prog'
+require 'openwfe/def'
 
 require 'rutest_utils'
 
@@ -23,60 +27,104 @@ class RestartCronTest < Test::Unit::TestCase
     #    @engine = $WORKFLOW_ENGINE_CLASS.new()
     #end
 
-    #def teardown
-    #end
+    def teardown
+        FileUtils.rm_rf 'work'
+    end
+
+    # test 0
 
     class RestartDefinition0 < ProcessDefinition
-        #def make
-        #    process_definition :name => "rs0", :revision => "0" do
-                cron :tab => "* * * * *", :name => "//cron" do
-                    #participant :cron_event_restart
-                    cron_event_restart
-                end
-        #    end
-        #end
+        cron :tab => "* * * * *", :name => "//mycron" do
+            cron_event_restart
+        end
     end
 
-    def test_restart_0
+    def test_0
+
+        dotest RestartDefinition0
 
-        engine = FilePersistedEngine.new
+        assert_equal(
+            1, @engine.get_expression_storage.size,
+            "\n\n" + @engine.get_expression_storage.to_s)
+    end
 
-        count = 0
+    # test 1
 
-        participant = lambda do
-            #puts "______________________ :cron_event_restart"
-            count = count + 1
+    class RestartDefinition1 < ProcessDefinition
+        concurrence do
+            cron :tab => "* * * * *", :name => "mycron" do
+                cron_event_restart
+            end
+            participant :ref => "nada"
         end
-        engine.register_participant(:cron_event_restart, &participant)
+    end
 
-        engine.launch(RestartDefinition0)
+    def test_1
 
-        sleep(60)
+        dotest RestartDefinition1
 
-        engine.stop()
+        assert_equal(
+            6, @engine.get_expression_storage.size,
+            "\n\n" + @engine.get_expression_storage.to_s)
+    end
 
-        #puts "___restarting to new engine"
+    protected
 
-        old_engine = engine
-        engine = FilePersistedEngine.new
+        def dotest (definition)
 
-        engine.register_participant(:cron_event_restart, &participant)
+            @engine = new_engine
 
-        engine.reload
-            #
-            # very important
+            feis = []
 
-        sleep(60)
+            participant = lambda do |wi|
+                feis << wi.fei.dup
+            end
+            @engine.register_participant :cron_event_restart, &participant
+            @engine.register_participant :nada, NullParticipant
 
-        engine.stop()
+            @engine.launch definition
 
-        #puts "_count : #{count}"
+            sleep 60
 
-        assert \
-            count == 2,
-            "the cron expression should have counted to 2, "+
-            "but it counted to #{count}"
-    end
+            @engine.stop
+
+            assert_equal 1, @engine.get_scheduler.cron_job_count
+            assert_equal 1, feis.size
+
+            assert_equal ".0", feis[0].wfid[-2, 2]
+
+            #puts "___restarting to new engine"
+
+            #old_engine = @engine
+            new_engine
+
+            @engine.register_participant :cron_event_restart, &participant
+            @engine.register_participant :nada, NullParticipant
+
+            @engine.reload
+                #
+                # very important
+
+            sleep 60
+
+            assert_equal(
+                1, @engine.get_scheduler.cron_job_count, "wrong cron job count")
+
+            @engine.stop
+
+            assert_equal 2, feis.size
+            assert_not_equal feis[0].wfid, feis[1].wfid
+
+            assert feis[0].wfid[-1, 1].to_i < feis[1].wfid[-1, 1].to_i
+        end
+
+        def new_engine
+
+            @engine = FilePersistedEngine.new
+            #engine = CachedFilePersistedEngine.new
+
+            #$OWFE_LOG.level = Logger::DEBUG
+        end
 
 end