openwferu 0.9.1 → 0.9.2

data/test/file_persistence_test.rb

@@ -0,0 +1,93 @@
+
+require 'test/unit'
+
+require 'openwfe/expressions/expressionmap'
+require 'openwfe/expool/expstorage'
+require 'openwfe/expool/yamlexpstorage'
+require 'openwfe/flowexpressionid'
+
+include OpenWFE
+
+
+class FilePersistenceTest < Test::Unit::TestCase 
+    
+    # 
+    # test persistence using yaml
+    def test_yaml_persistence
+        fes = YamlFileExpressionStorage.new("yaml", nil)
+        test_persistence(fes)
+    end
+    
+    #
+    # test cache persistence 
+    def test_cache_persistence
+        fes = LruCachedExpressionStorage.new("lru", nil)
+        test_persistence(fes)
+    end
+    
+    #
+    # flow expression check
+    def test_flow_expression
+        fei = new_fei()
+        fes = YamlFileExpressionStorage.new("yaml", nil)
+        fe = SequenceExpression.new(fei, nil, nil, nil, nil)
+        test_persistence(fes,fe)
+    end
+    
+    #
+    # test UTF-8 data persistence
+    def test_utf8_with_file
+        workflow_definition_name = "みんなにARIGATOU★☆に関する最新の情報公開"
+        fei = new_fei(workflow_definition_name)
+        fe = SequenceExpression.new(fei, nil, nil, nil, nil)
+        fes = YamlFileExpressionStorage.new("yaml", nil)
+        
+        loaded = test_persistence(fes,fe)
+        #puts loaded.fei.workflow_definition_name
+        assert loaded.fei.workflow_definition_name == fei.workflow_definition_name
+    end
+    
+        
+    protected 
+    
+        def test_persistence (fes, fe=nil) 
+            fei = new_fei()
+            fes.remove(fei,nil) if(fes.has_key?(fei))
+            
+            raw = 
+                  if fe == nil 
+                    RawExpression.new(fei, 'parent', 'env', nil, nil) 
+                  else
+                    fe
+                  end
+            assert (not fes.has_key?(fei)), "they key is present in the file system. Maybe a previous test did not delete the "
+            
+            fes[fei]=raw
+            assert fes.has_key?(fei)
+            
+            loaded = fes[fei]
+            
+            fes.remove(fei,nil)
+            assert !(fes.has_key?(fei))
+            return loaded
+        end
+        
+        def new_fei (definition_name = nil)
+            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 = if definition_name == nil 
+                                                                          'test' 
+                                                                        else
+                                                                           definition_name
+                                                                        end
+            fei.workflow_definition_revision = '1.0'
+            fei.workflow_instance_id = '1234568'
+            fei.expression_name = 'do-test'
+            fei.expression_id = '0.0'
+            return fei
+        end
+        
+end

data/test/flowtestbase.rb

@@ -1,6 +1,5 @@
-
 #
-# Testing OpenWFEru
+# Testing OpenWFE
 #
 # John Mettraux at openwfe.org
 #
@@ -10,21 +9,40 @@
 #
 
 require 'test/unit'
-require 'workitem'
-require 'ru/engine'
-require 'ru/rudefinitions'
-require 'ru/participants'
+
+require 'openwfe/workitem'
+require 'openwfe/engine/engine'
+require 'openwfe/rudefinitions'
+require 'openwfe/participants/participants'
+
 require 'rutest_utils'
 
+include OpenWFE
+
+
+$WORKFLOW_ENGINE_CLASS = Engine \
+    if not $WORKFLOW_ENGINE_CLASS
+
+puts
+puts "testing with engine of class " + $WORKFLOW_ENGINE_CLASS.to_s
+puts
 
 class FlowTestBase < Test::Unit::TestCase
 
-    #def setup
-    #end
+    attr_reader \
+        :engine, :tracer
+
+    def setup
+
+        @engine = $WORKFLOW_ENGINE_CLASS.new()
+
+        @tracer = Tracer.new
+        @engine.application_context["__tracer"] = @tracer
+    end
 
     #def teardown
     #end
-    
+
     def default_test ()
         assert true
     end
@@ -34,37 +52,49 @@ class FlowTestBase < Test::Unit::TestCase
         def test_name
             s = caller(1)[0]
             i = s.index('`')
-            s = s[i+1..s.length-2]
+            #s = s[i+1..s.length-2]
+            s = s[i+6..s.length-2]
             return s
         end
 
-        def dotest (flowDef, expectedTrace, sleepTime=0)
+        def dotest (flowDef, expectedTrace, sleepTime=0, allowRemainingExpressions=false)
 
-            engine = OpenWFEru::Engine.new()
+            @engine.register_participant('test-.*', PrintParticipant.new())
 
-            engine.application_context["__tracer"] = Tracer.new
+            @engine.register_participant('block-participant') do |workitem|
+                @tracer << "the block participant received a workitem"
+                @tracer << "\n"
+            end
 
-            engine.register_participant('test-.*', OpenWFEru::PrintParticipant.new())
+#            @engine.register_participant(
+#                'eno', 
+#                EmailNotificationParticipant.new(
+#                    "googlemail.l.google.com",
+#                    25,
+#                    "eno@outoftheblue.co.jp",
+#                    """Subject: test 0
+#
+#0 : ${r:Time.new}
+#1 : ${f:customer_name}
+#                    """))
 
             # register unique tracing participant
 
-            li = OpenWFE::LaunchItem.new()
+            li = OpenWFE::LaunchItem.new(flowDef)
 
-            li.workflowDefinitionUrl = "field:__definition"
-
-            li.attributes['__definition'] = flowDef
-            engine.launch(li)
+            @engine.launch(li)
 
             sleep(sleepTime)
 
-            trace = engine.application_context["__tracer"].to_s
+            trace = @tracer.to_s
 
             #puts "...'#{trace}' ?= '#{expectedTrace}'"
 
-            if expectedTrace.kind_of?([].class)
-                result = true
+            if expectedTrace.kind_of? [].class
+
+                result = false
                 expectedTrace.each do |etrace|
-                    result = result and trace == etrace
+                    result = (result or (trace == etrace))
                 end
                 assert \
                     result,
@@ -72,13 +102,28 @@ class FlowTestBase < Test::Unit::TestCase
             else
                 assert \
                     trace == expectedTrace, \
-                    "flow failed : '#{trace}' != '#{expectedTrace}'"
+                    """flow failed : 
+                    
+'#{trace}'
+
+  != 
+
+'#{expectedTrace}'
+"""
             end
 
+
             exp_storage = \
-                engine.application_context[OpenWFEru::S_EXPRESSION_STORAGE]
+                engine.application_context[S_EXPRESSION_STORAGE]
+
+            if allowRemainingExpressions
+                exp_storage.purge
+                return
+            end
 
             if exp_storage.length != 1
+                puts
+                puts "    remaining expressions : #{exp_storage.length}"
                 puts
                 puts exp_storage.to_s
                 puts
@@ -86,7 +131,8 @@ class FlowTestBase < Test::Unit::TestCase
 
             assert \
                 exp_storage.length == 1,
-                "there are expressions remaining in the expression pool"
+                "there are expressions remaining in the expression pool " +
+                "(#{exp_storage.length})"
         end
 
 end

data/test/ft_0.rb

@@ -1,6 +1,6 @@
 
 #
-# Testing OpenWFEru
+# Testing OpenWFE
 #
 # John Mettraux at openwfe.org
 #
@@ -32,17 +32,6 @@ class FlowTest0 < FlowTestBase
 </process-definition>''', "test-alpha")
     end
 
-    def test_sequence
-        dotest(\
-'''<process-definition name="n" revision="0">
-    <sequence>
-        <print>a</print>
-        <print>b</print>
-    </sequence>
-</process-definition>''', '''a
-b''')
-    end
-
     def test_dollar_notation_0
         dotest(\
 '''<process-definition name="n" revision="0">
@@ -72,90 +61,5 @@ b''')
 </process-definition>''', 'X')
     end
 
-    def test_subprocess_ref_0
-        dotest(\
-'''<process-definition name="subtest0" revision="0">
-
-    <subprocess ref="sub0" />
-
-    <process-definition name="sub0">
-        <print>ok</print>
-    </process-definition>
-
-</process-definition>''', 'ok')
-    end
-
-    def test_subprocess_ref_1
-        dotest(\
-'''<process-definition name="subtest0" revision="0">
-
-    <sequence>
-        <subprocess ref="sub0" />
-        <subprocess ref="sub0" />
-    </sequence>
-
-    <process-definition name="sub0">
-        <print>ok</print>
-    </process-definition>
-
-</process-definition>''', '''ok
-ok''')
-    end
-
-    def test_subprocess_ref_2
-        dotest(\
-'''<process-definition name="subtest0" revision="0">
-
-    <sequence>
-        <sub0 />
-        <print>after</print>
-    </sequence>
-
-    <process-definition name="sub0">
-        <print>ok</print>
-    </process-definition>
-
-</process-definition>''', '''ok
-after''')
-    end
-
-    def test_subprocess_ref_3
-        dotest(\
-'''<process-definition name="subtest0" revision="0">
-
-    <sequence>
-        <set variable="v" value="out" />
-        <sub0 />
-        <print>after : ${v}</print>
-    </sequence>
-
-    <process-definition name="sub0">
-        <sequence>
-            <set variable="v" value="in" />
-            <print>ok : ${v}</print>
-        </sequence>
-    </process-definition>
-
-</process-definition>''', '''ok : in
-after : out''')
-    end
-
-    def test_subprocess_ref_4
-        dotest(\
-'''<process-definition name="subtest0" revision="0">
-
-    <sequence>
-        <subprocess ref="sub0" a="A" b="B" c="C" />
-        <sub0 a="A" b="B" c="C" />
-    </sequence>
-
-    <process-definition name="sub0">
-        <print>${a}${b}${c}</print>
-    </process-definition>
-
-</process-definition>''', '''ABC
-ABC''')
-    end
-
 end
 

data/test/ft_0b_sequence.rb

@@ -0,0 +1,33 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Mon Oct  9 22:19:44 JST 2006
+#
+
+require 'flowtestbase'
+
+
+class FlowTest0 < FlowTestBase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    def test_sequence
+        dotest(\
+'''<process-definition name="n" revision="0">
+    <sequence>
+        <print>a</print>
+        <print>b</print>
+    </sequence>
+</process-definition>''', '''a
+b''')
+    end
+
+end
+

data/test/ft_0c_testname.rb

@@ -0,0 +1,29 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Mon Dec 25 14:27:48 JST 2006
+#
+
+require 'flowtestbase'
+
+
+class TestTestName < FlowTestBase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    def test_test_name
+        dotest(\
+"""<process-definition name='#{test_name}' revision='0'>
+    <print>#{test_name}</print>
+</process-definition>""", "test_name")
+    end
+
+end
+

data/test/ft_10_loop.rb

@@ -0,0 +1,48 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Tue Jan  2 13:14:37 JST 2007
+#
+
+require 'flowtestbase'
+
+
+class FlowTest10 < FlowTestBase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    def test_loop_0
+
+        s = ""
+        0.upto(9) do |i|
+            s << i.to_s
+            s << "\n"
+        end
+        s = s.strip()
+
+        dotest(\
+'<process-definition name="'+test_name+'''" revision="0">
+    <sequence>
+        <reval>$i = 0</reval>
+        <loop>
+            <print>${r:$i}</print>
+            <reval>$i = $i + 1</reval>
+            <if>
+                <equals value="${r:$i}" other-value="10" />
+                <break/>
+            </if>
+        </loop>
+    </sequence>
+</process-definition>''', 
+        s)
+    end
+
+end
+