openwferu 0.9.1 → 0.9.2

data/test/ft_8_forget.rb

@@ -0,0 +1,46 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Mon Dec 25 14:27:48 JST 2006
+#
+
+require 'flowtestbase'
+
+
+class FlowTest8 < FlowTestBase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    def test_forget_0
+        dotest(\
+'<process-definition name="'+test_name+'''" revision="0">
+    <sequence>
+        <concurrence
+            count="1"
+        >
+            <forget>
+                <print>a</print>
+            </forget>
+            <sequence>
+                <sleep for="500" />
+                <print>b</print>
+            </sequence>
+        </concurrence>
+        <print>c</print>
+    </sequence>
+</process-definition>''', 
+"""a
+c""", 
+0.1,
+false)
+    end
+
+end
+

data/test/ft_9_cursor.rb

@@ -0,0 +1,94 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Tue Jan  2 13:14:37 JST 2007
+#
+
+require 'flowtestbase'
+
+
+class FlowTest9 < FlowTestBase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    def test_cursor_0
+        dotest(\
+'<process-definition name="'+test_name+'''" revision="0">
+    <cursor>
+        <print>a</print>
+        <print>b</print>
+    </cursor>
+</process-definition>''', 
+"""a
+b""")
+    end
+
+    def test_cursor_1
+        dotest(\
+'<process-definition name="'+test_name+'''" revision="0">
+    <cursor>
+        <print>a</print>
+        <print>b</print>
+        <cancel />
+        <print>c</print>
+    </cursor>
+</process-definition>''', 
+"""a
+b""")
+    end
+
+    def test_cursor_2
+        dotest(\
+'<process-definition name="'+test_name+'''" revision="0">
+    <cursor>
+        <print>a</print>
+        <print>b</print>
+        <skip step="2" />
+        <print>c</print>
+    </cursor>
+</process-definition>''', 
+"""a
+b""")
+    end
+
+    def test_cursor_3
+        dotest(\
+'<process-definition name="'+test_name+'''" revision="0">
+    <cursor>
+        <print>a</print>
+        <skip step="2" />
+        <print>b</print>
+        <print>c</print>
+    </cursor>
+</process-definition>''', 
+"""a
+c""")
+    end
+
+    def test_cursor_4
+        dotest(\
+'<process-definition name="'+test_name+'''" revision="0">
+    <sequence>
+        <cursor>
+            <print>a</print>
+            <set field="__cursor_command__" value="skip 2" />
+            <print>b</print>
+            <print>c</print>
+        </cursor>
+        <print>d</print>
+    </sequence>
+</process-definition>''', 
+"""a
+c
+d""")
+    end
+
+end
+

data/test/journal_persistence_test.rb

@@ -0,0 +1,147 @@
+require 'test/unit'
+#require 'yaml'
+
+require 'openwfe/flowexpressionid'
+require 'openwfe/expool/journalexpstorage'
+require 'openwfe/expressions/expressionmap'
+
+include OpenWFE
+
+
+class JournalPersistenceTest < Test::Unit::TestCase 
+    
+    #
+    # test journalling and appending to journal including:
+    # - inserting :put and :del entries in the journal 
+    # - formatting for easy reading
+    # - replay
+    #
+    def test_journalling_persistence
+        fei = new_fei()
+        feip = fei.parent_workflow_instance_id
+        
+        fes = JournalizedExpressionStorage.new("journal",nil)
+        fes.clean(feip)
+        
+        fes[fei] = SequenceExpression.new(fei, nil, nil, nil, nil)
+        fes.remove(fei, nil)
+        
+        assert fes.size(feip) == 2, "expected 2 entries in the journal"
+        
+        fes.to_human_s(feip)
+        
+        # prepare replay
+        backup_journal = fes.backup(feip)
+        fes.clean(fei)
+        assert fes.size(feip) == 0, "storage is not empty"
+        
+        # replay
+        replayer = JournalReplay.new(fes)
+        replayer.replay(backup_journal)
+        assert fes.size(feip) == 2, "2 entries have not been replayed"
+    end
+    
+    def test_journal_truncate
+        fes = JournalizedExpressionStorage.new("journal",nil)
+        fei = new_fei()
+        fei.workflow_instance_id = '789129'
+        feip = fei.parent_workflow_instance_id
+        fes.clean(feip)
+        
+        assert fes.size(feip) == 0
+        
+        fe = SequenceExpression.new(fei, nil, nil, nil, nil)
+        
+        24.times { |e|
+                time = Time.gm(2007,01,17,e,00,00,00)
+                entry = JournalEntry.new(:put, fei, fe, time)
+                fes.write_to_journal(entry)
+            }
+        assert fes.size(feip) == 24 
+        
+        # truncate by number of lines
+        assert fes.truncate!(feip, 10) == 10
+        assert fes.size(feip) == 10
+        
+        # truncate by date
+        date_limit = 5
+        assert fes.truncate!(feip, nil, Time.gm(2007,01,17,date_limit,00,00,00)) == 5
+        assert fes.size(feip) == 5
+        
+    end
+    
+    # 
+    # no persistence, just test the journal entry class with a put
+    def test_journal_entry_put
+        fei = new_fei()
+        
+        fe = SequenceExpression.new(fei, nil, nil, nil, nil)
+        journal_entry = JournalEntry.new(:put,fei,fe) 
+        
+        journal_string = journal_entry.to_s
+        journal_entry_read = JournalEntry.parse_from_string(journal_string)
+        
+        assert journal_entry_read.action == journal_entry.action 
+        assert journal_entry_read.action == :put 
+        assert journal_entry_read.fei.to_s == journal_entry.fei.to_s 
+
+        yamldump = YAML.dump(journal_entry_read.fe)
+        
+        assert journal_entry_read.fe != nil, "retrieved journal entry had a null expression"
+        assert journal_entry_read.fe.to_s == journal_entry.fe.to_s, "string comparison failed for flow expression"
+        assert yamldump.index("SequenceExpression") != nil
+    end
+    
+    # 
+    # no persistence, just test the journal entry class with a del
+    def test_journal_entry_del
+        fei = new_fei()
+        
+        fe = SequenceExpression.new(fei, nil, nil, nil, nil)
+        journal_entry = JournalEntry.new(:del,fei,fe) 
+        
+        journal_string = journal_entry.to_s
+        journal_entry_read = JournalEntry.parse_from_string(journal_string)
+       
+        assert journal_entry_read.action.to_s == journal_entry.action.to_s 
+        assert journal_entry_read.fei.to_s == journal_entry.fei.to_s 
+        assert journal_entry_read.fe == nil
+        
+    end
+    
+    #
+    # this actually test the yaml output is expanded and readable, after the journal entry has been parsed
+    def test_human_readable_journal_entry
+        fei = new_fei()
+        fe = SequenceExpression.new(fei, nil, nil, nil, nil)
+        journal_entry = JournalEntry.new(:put,fei,fe) 
+        
+        # test on a freshly made journal entry
+        assert journal_entry_assert(journal_entry)
+      
+        # test on a re-parsed journal entry
+        assert journal_entry_assert(JournalEntry.parse_from_string(journal_entry.to_s))        
+    end
+        
+    protected 
+    
+        def journal_entry_assert (journal_entry)
+            human = journal_entry.to_human_s
+            human.index("SequenceExpression") != nil
+        end
+        
+        def new_fei ()
+            fei = OpenWFE::FlowExpressionId.new()
+            fei.owfe_version = OPENWFE_VERSION
+            fei.engine_id = 'this'
+            fei.initial_engine_id = 'that'
+            fei.workflow_definition_url = 'http://test/test.xml'
+            fei.workflow_definition_name = 'test'
+            fei.workflow_definition_revision = '1.0'
+            fei.workflow_instance_id = '123456'
+            fei.expression_name = 'do-test'
+            fei.expression_id = '0.0'
+            return fei
+        end
+        
+end

data/test/misctest.rb

@@ -1,6 +1,6 @@
 
 #
-# Testing OpenWFEru
+# Testing OpenWFE
 #
 # John Mettraux at openwfe.org
 #
@@ -8,10 +8,9 @@
 #
 
 require 'test/unit'
-require 'utils'
-require 'ru/ruutils'
-require 'ru/expressionmap'
-require 'ru/fe_define'
+require 'openwfe/utils'
+require 'openwfe/expressions/fe_define'
+require 'openwfe/expressions/expressionmap'
 
 #
 # testing misc things
@@ -27,17 +26,22 @@ class MiscTest < Test::Unit::TestCase
 
     def test_starts_with
         assert \
-            OpenWFEru::starts_with("//a", "//")
+            OpenWFE::starts_with("//a", "//")
         assert \
-            (not OpenWFEru::starts_with("/a", "//"))
+            (not OpenWFE::starts_with("/a", "//"))
+    end
+
+    def test_ends_with
+        assert \
+            OpenWFE::ends_with("c'est la fin", "fin")
     end
 
     def test_expression_map
 
-        em = OpenWFEru::ExpressionMap.new('expressionmap', {})
+        em = OpenWFE::ExpressionMap.new('expressionmap', {})
 
         assert \
-            em.get_class('process-definition') == OpenWFEru::DefineExpression,
+            em.get_class('process-definition') == OpenWFE::DefineExpression,
             "class of 'process-definition' should be DefineExpression"
         assert \
             em.is_definition?('process-definition'),

data/test/rake_ptest.rb

@@ -0,0 +1,18 @@
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Mon Oct  9 22:19:44 JST 2006
+#
+
+#require 'test/unit'
+
+require 'fileutils'
+FileUtils.remove_dir "work" if File.exist? "work"
+
+require 'openwfe/engine/file_persisted_engine'
+$WORKFLOW_ENGINE_CLASS = OpenWFE::FilePersistedEngine
+
+require 'rake_qtest'
+

data/test/rake_qtest.rb

@@ -0,0 +1,43 @@
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Mon Oct  9 22:19:44 JST 2006
+#
+
+#require 'test/unit'
+
+File.delete('engine.log') \
+    if File.exist? 'engine.log'
+
+require 'feitest'
+require 'dollartest'
+require 'misctest'
+require 'timetest'
+require 'raw_prog_test'
+require 'file_persistence_test'
+
+#require 'journal_persistence_test'
+    #
+    # disabled for now, as journal persistence will undergo a redesign soon
+
+require 'ft_0'
+require 'ft_0b_sequence'
+require 'ft_0c_testname'
+require 'ft_1_unset'
+require 'ft_2_concurrence'
+require 'ft_3_equals'
+require 'ft_4_misc'
+require 'ft_6_lambda'
+require 'ft_7_lose'
+require 'ft_8_forget'
+require 'ft_9_cursor'
+require 'ft_10_loop'
+require 'ft_11_ppd'
+require 'ft_12_blockparticipant'
+require 'ft_14_subprocess'
+require 'ft_14b_subprocess'
+require 'ft_15_iterator'
+require 'ft_16_fqv'
+

data/test/{fulltest.rb → rake_test.rb}

@@ -1,5 +1,5 @@
 #
-# Testing OpenWFEru
+# Testing OpenWFE
 #
 # John Mettraux at openwfe.org
 #
@@ -8,7 +8,7 @@
 
 #require 'test/unit'
 
-require 'quicktest'
 require 'ft_5_time'
 require 'timetest'
+require 'rake_qtest'
 

data/test/raw_prog_test.rb

@@ -0,0 +1,236 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Mon Oct  9 22:19:44 JST 2006
+#
+
+require 'test/unit'
+require 'openwfe/expressions/raw_prog'
+
+
+class RawProgTest < Test::Unit::TestCase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    $EXPRESSION_NAMES = [
+        "process-definition", 
+        "sequence", 
+        "participant",
+        "set",
+        "if",
+        "equals",
+        "print"
+    ]
+
+    XML_DEF = """
+<process-definition name='test0' revision='0'>
+  <sequence>
+    <participant ref='a'/>
+    <participant ref='b'/>
+  </sequence>
+</process-definition>""".strip
+
+
+    #
+    # TEST 0
+    #
+
+    class TestDefinition < OpenWFE::ProcessDefinition
+        def make
+            process_definition :name => "test0", :revision => "0" do
+                sequence do
+                    participant :ref => "a"
+                    participant :ref => "b"
+                end
+            end
+        end
+    end
+
+    def test_prog_0
+
+        #s = TestDefinition.new($EXPRESSION_NAMES).make.to_s
+        s = TestDefinition.new().make.to_s
+
+        #puts
+        #puts s
+
+        assert \
+            s == XML_DEF,
+            "parsing failed (0)"
+    end
+
+    def test_prog_0b
+
+        #s = TestDefinition.new($EXPRESSION_NAMES).make.to_s
+        s = TestDefinition.do_make.to_s
+
+        #puts
+        #puts s
+
+        assert \
+            s == XML_DEF,
+            "parsing failed (0b)"
+    end
+
+
+    #
+    # TEST 1
+    #
+
+    def test_prog_1
+
+        #pg = OpenWFE::ProcessDefinition.new($EXPRESSION_NAMES)
+        pg = OpenWFE::ProcessDefinition.new()
+
+        class << pg
+            def my_proc
+                process_definition :name => "test0", :revision => "0" do
+                    sequence do
+                        participant :ref => "a"
+                        participant :ref => "b"
+                    end
+                end
+            end
+        end
+        pdef = pg.my_proc
+        s = pdef.to_s
+
+        #puts s
+
+        assert \
+            s == XML_DEF,
+            "parsing failed (1)"
+    end
+
+
+    #
+    # TEST 2
+    #
+
+    class TestDefinition2 < OpenWFE::ProcessDefinition
+        def make
+            process_definition :name => "test2", :revision => "0" do
+                sequence do
+                    set :field => "toto" do
+                        "nada"
+                    end
+                    participant :ref => "b"
+                end
+            end
+        end
+    end
+
+    XML_DEF2 = """
+<process-definition name='test2' revision='0'>
+  <sequence>
+    <set field='toto'>nada</set>
+    <participant ref='b'/>
+  </sequence>
+</process-definition>""".strip
+
+    def test_prog_2
+
+        s = TestDefinition2.do_make.to_s
+        #puts s
+
+        assert \
+            s == XML_DEF2,
+            "parsing failed (2)"
+
+        #puts
+        #puts TestDefinition2.do_make.to_code_s
+    end
+
+
+    #
+    # TEST 3
+    #
+
+    class TestDefinition3 < OpenWFE::ProcessDefinition
+        def make
+            process_definition :name => "test3", :revision => "0" do
+                _if do
+                    equals :field_value => "nada", :other_value => "surf"
+                    participant :ref => "b"
+                end
+            end
+        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
+
+    CODE_DEF3 = """
+process_definition :name => 'test3', :revision => '0' do
+    _if do
+        equals :field-value => 'nada', :other-value => 'surf'
+        participant :ref => 'b'
+    end
+end""".strip
+
+    def test_prog_3
+
+        s = TestDefinition3.do_make.to_s
+        #puts s
+
+        assert \
+            s == XML_DEF3,
+            "parsing failed (3)"
+
+        #puts
+        #puts TestDefinition3.do_make.to_code_s
+
+        assert \
+            TestDefinition3.do_make.to_code_s == CODE_DEF3,
+            "to_code_s() not working properly (3)"
+    end
+
+    #
+    # TEST 4
+    #
+
+    class TestDefinition4 < OpenWFE::ProcessDefinition
+        def make
+            process_definition :name => "test4", :revision => "0" do
+                sequence do
+                    3.times { participant :ref => "b" }
+                end
+            end
+        end
+    end
+
+    CODE_DEF4 = """
+process_definition :name => 'test4', :revision => '0' do
+    sequence do
+        participant :ref => 'b'
+        participant :ref => 'b'
+        participant :ref => 'b'
+    end
+end""".strip
+
+    def test_prog_4
+
+        #puts
+        #puts TestDefinition4.do_make.to_s
+        #puts
+        #puts TestDefinition4.do_make.to_code_s
+
+        assert \
+            TestDefinition4.do_make.to_code_s == CODE_DEF4,
+            "to_code_s() not working properly (4)"
+    end
+
+end
+