openwferu 0.9.6 → 0.9.7

data/test/raw_prog_test.rb

@@ -13,6 +13,8 @@ require 'openwfe/expressions/raw_prog'
 
 class RawProgTest < Test::Unit::TestCase
 
+    DEBUG = false
+
     #def setup
     #end
 
@@ -47,8 +49,7 @@ class RawProgTest < Test::Unit::TestCase
 
         s = TestDefinition.new().make.to_s
 
-        #puts
-        #puts s
+        puts s if DEBUG
 
         assert \
             s == XML_DEF,
@@ -59,8 +60,7 @@ class RawProgTest < Test::Unit::TestCase
 
         s = TestDefinition.do_make.to_s
 
-        #puts
-        #puts s
+        puts s if DEBUG
 
         assert \
             s == XML_DEF,
@@ -89,7 +89,7 @@ class RawProgTest < Test::Unit::TestCase
         pdef = pg.my_proc
         s = pdef.to_s
 
-        #puts s
+        puts s if DEBUG
 
         assert \
             s == XML_DEF,
@@ -125,7 +125,8 @@ class RawProgTest < Test::Unit::TestCase
     def test_prog_2
 
         s = TestDefinition2.do_make.to_s
-        #puts s
+
+        puts s if DEBUG
 
         assert \
             s == XML_DEF2,
@@ -170,7 +171,8 @@ end""".strip
     def test_prog_3
 
         s = TestDefinition3.do_make.to_s
-        #puts s
+
+        puts s if DEBUG
 
         assert \
             s == XML_DEF3,

data/test/restart_cron_test.rb

@@ -17,7 +17,7 @@ require 'rutest_utils'
 include OpenWFE
 
 
-class RestartTest < Test::Unit::TestCase
+class RestartCronTest < Test::Unit::TestCase
 
     #def setup
     #    @engine = $WORKFLOW_ENGINE_CLASS.new()
@@ -30,7 +30,7 @@ class RestartTest < Test::Unit::TestCase
         def make
             process_definition :name => "rs0", :revision => "0" do
                 cron :tab => "* * * * *", :name => "//cron" do
-                    participant :cron_event
+                    participant :cron_event_restart
                 end
             end
         end
@@ -43,11 +43,11 @@ class RestartTest < Test::Unit::TestCase
         count = 0
 
         participant = lambda do
-            #puts "______________________ :cron_event"
+            #puts "______________________ :cron_event_restart"
             count = count + 1
         end
 
-        engine.register_participant(:cron_event, &participant)
+        engine.register_participant(:cron_event_restart, &participant)
 
         engine.launch(RestartDefinition0)
 
@@ -60,7 +60,11 @@ class RestartTest < Test::Unit::TestCase
         old_engine = engine
         engine = FilePersistedEngine.new
 
-        engine.register_participant(:cron_event, &participant)
+        engine.register_participant(:cron_event_restart, &participant)
+
+        engine.reload
+            #
+            # very important
 
         sleep(60)
 

data/test/restart_sleep_test.rb

@@ -0,0 +1,104 @@
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Sun Oct 29 15:41:44 JST 2006
+#
+# somewhere between Philippina and the Japan
+#
+
+require 'test/unit'
+
+require 'openwfe/workitem'
+require 'openwfe/engine/file_persisted_engine'
+require 'openwfe/expressions/raw_prog'
+
+require 'rutest_utils'
+
+include OpenWFE
+
+
+class RestartSleepTest < Test::Unit::TestCase
+
+    #def setup
+    #    @engine = $WORKFLOW_ENGINE_CLASS.new()
+    #end
+
+    #def teardown
+    #end
+
+    class RestartDefinition0 < ProcessDefinition
+        def make
+            process_definition :name => "rs0", :revision => "0" do
+                sequence do
+                    _sleep :for => "10s"
+                    _print "after"
+                end
+            end
+        end
+    end
+
+    def test_restart_0
+
+        dotest FilePersistedEngine
+    end
+
+    def test_restart_1
+
+        dotest CachedFilePersistedEngine
+    end
+
+    protected
+
+        def dotest (engine_class)
+
+            #require 'fileutils'
+            #FileUtils.remove_dir "work" if File.exist? "work"
+
+            engine = new_engine(engine_class)
+
+            li = LaunchItem.new(RestartDefinition0)
+
+            engine.launch(li)
+
+            sleep(1)
+
+            engine.stop()
+
+            $OWFE_LOG.warn "stopped the engine"
+
+            old_engine = engine
+            engine = new_engine(engine_class)
+
+            $OWFE_LOG.warn "started the new engine"
+
+            sleep(11)
+            #sleep(21)
+
+            s_old = old_engine.application_context["__tracer"].to_s
+            s_now = engine.application_context["__tracer"].to_s
+
+            #puts "__ s_old >>>#{s_old}<<<"
+            #puts "__ s_now >>>#{s_now}<<<"
+
+            assert \
+                (s_old == "" and s_now == "after"), 
+                "old : '#{s_old}'  /  new : '#{s_now}'  BAD for #{engine_class}"
+        end
+
+        def new_engine (engine_class)
+
+            engine = engine_class.new()
+
+            tracer = Tracer.new
+            engine.application_context["__tracer"] = tracer
+
+            #engine.reschedule
+            engine.reload
+
+            engine
+        end
+
+end
+

data/test/restart_tests.rb

@@ -0,0 +1,15 @@
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Wed Mar 14 15:40:33 JST 2007
+# a clear view on the Fuji this morning
+#
+
+# just the restart tests
+
+require 'restart_sleep_test'
+require 'restart_cron_test'
+require 'restart_when_test'
+

data/test/restart_when_test.rb

@@ -0,0 +1,105 @@
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Sun Oct 29 15:41:44 JST 2006
+#
+# somewhere between Philippina and the Japan
+#
+
+require 'test/unit'
+
+require 'openwfe/workitem'
+require 'openwfe/engine/file_persisted_engine'
+require 'openwfe/expressions/raw_prog'
+
+require 'rutest_utils'
+
+include OpenWFE
+
+
+class RestartWhenTest < Test::Unit::TestCase
+
+    #def setup
+    #    @engine = $WORKFLOW_ENGINE_CLASS.new()
+    #end
+
+    #def teardown
+    #end
+
+    class RestartWhenDefinition0 < ProcessDefinition
+        def make
+            concurrence do
+                _when :test => "${v:done} == true", :frequency => "1s" do
+                #_when :test => "${v:done} == true" do
+                    _print "when triggered"
+                end
+                sequence do
+                    _sleep "2s"
+                    _set :variable => "done", :value => "true"
+                    _print "done"
+                end
+            end
+        end
+    end
+
+    def test_restart_0
+        dotest FilePersistedEngine
+    end
+
+    def test_restart_1
+        dotest CachedFilePersistedEngine
+    end
+
+    protected
+
+        def dotest (engine_class)
+
+            engine = new_engine(engine_class)
+
+            li = LaunchItem.new(RestartWhenDefinition0)
+
+            engine.launch(li)
+
+            sleep(1)
+
+            engine.stop()
+
+            $OWFE_LOG.warn "stopped the engine"
+
+            old_engine = engine
+            engine = new_engine(engine_class)
+
+            $OWFE_LOG.warn "started the new engine"
+
+            sleep(3)
+
+            s_old = old_engine.application_context["__tracer"].to_s
+            s_now = engine.application_context["__tracer"].to_s
+
+            #uts "__ s_old >>>#{s_old}<<<"
+            #uts "__ s_now >>>#{s_now}<<<"
+
+            assert \
+                (s_old == "" and s_now == "done\nwhen triggered"), 
+                "old : '#{s_old}'  /  new : '#{s_now}'  BAD for #{engine_class}"
+
+            engine.stop
+        end
+
+        def new_engine (engine_class)
+
+            engine = engine_class.new()
+
+            tracer = Tracer.new
+            engine.application_context["__tracer"] = tracer
+
+            #engine.reschedule
+            engine.reload
+
+            engine
+        end
+
+end
+

data/test/scheduler_test.rb

@@ -144,13 +144,13 @@ class SchedulerTest < Test::Unit::TestCase
 
         es = EverySchedulable.new
 
-        scheduler.schedule_every("500", es, nil)
+        job_id = scheduler.schedule_every("500", es, nil)
         
         sleep(3.2)
 
         assert_equal es.count, 6
 
-        scheduler.unschedule(es.job_id)
+        scheduler.unschedule(job_id)
 
         sleep(1)
 

data/test/sec_test.rb

@@ -0,0 +1,163 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Tue Jan  2 13:14:37 JST 2007
+#
+
+require 'test/unit'
+
+require 'openwfe/workitem'
+require 'openwfe/engine/engine'
+
+
+class SecTest < Test::Unit::TestCase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    #def xxxx_sec_0
+    def test_sec_0
+
+        engine = OpenWFE::Engine.new
+
+        engine.ac[:ruby_eval_allowed] = true
+
+        def0 = \
+'''<process-definition name="" revision="0">
+    <sequence>
+        <!--
+        <reval>puts "ok"</reval>
+        <reval>self.ac[:ruby_eval_allowed] = false</reval>
+        <reval>puts self.ac[:ruby_eval_allowed]</reval>
+        <reval>puts "ok after"</reval>
+        -->
+        <reval>File.open("nada.txt") do |f| f.write("nada"); end</reval>
+    </sequence>
+</process-definition>''' 
+
+        e = dotest(engine, def0)
+
+        assert_not_nil e
+        assert_equal e.to_s, "Insecure operation - initialize"
+
+        def1 = \
+'''<process-definition name="" revision="0">
+    <sequence>
+        <reval>
+            class Object
+                def my_name
+                    "toto"
+                end
+            end
+            "stringobject".my_name
+        </reval>
+    </sequence>
+</process-definition>''' 
+
+        e = dotest(engine, def1)
+
+        assert_not_nil e
+
+        assert_equal \
+            e.to_s, "undefined method `my_name' for \"stringobject\":String"
+
+        def2 = \
+'''<process-definition name="" revision="0">
+    <sequence>
+        <reval>
+            <![CDATA[
+            class << self.ac["engine"]
+                def is_secure?
+                    true
+                end
+            end
+            self.ac["engine"].is_secure?
+            ]]>
+        </reval>
+    </sequence>
+</process-definition>''' 
+
+        e = dotest(engine, def2)
+
+        assert_nil e
+            #
+            # I don't like that
+
+        def3 = \
+'''<process-definition name="" revision="0">
+    <sequence>
+        <reval>self.ac[:ruby_eval_allowed] = false</reval>
+        <reval>puts self.ac[:ruby_eval_allowed]</reval>
+    </sequence>
+</process-definition>''' 
+
+        e = dotest(engine, def3)
+
+        #puts e
+
+        assert_not_nil e
+
+        assert_equal \
+            e.to_s, "evaluation of ruby code is not allowed"
+
+        engine.stop
+    end
+
+    def test_sec_1
+
+        value = nil
+
+        engine = OpenWFE::Engine.new
+
+        engine.register_participant(:toto) do |workitem|
+            value = "#{workitem.attributes.size}_#{workitem.f}"
+        end
+
+        def0 = \
+'''<process-definition name="" revision="0">
+    <sequence>
+        <set field="f" value="${ruby:5*7}" />
+        <toto/>
+    </sequence>
+</process-definition>''' 
+
+        engine.launch(OpenWFE::LaunchItem.new(def0))
+
+        assert_equal value, "3_"
+
+        engine.ac[:ruby_eval_allowed] = true
+
+        engine.launch(OpenWFE::LaunchItem.new(def0))
+
+        assert_equal value, "3_35"
+
+        engine.stop
+    end
+
+    protected
+
+        def dotest (engine, def_or_li)
+            li = if def_or_li.is_a?(OpenWFE::LaunchItem)
+                def_or_li
+            else
+                OpenWFE::LaunchItem.new(def_or_li)
+            end
+            
+            e = nil
+
+            begin
+                engine.launch(li)
+            rescue Exception => e
+            end
+
+            e
+        end
+
+end
+

data/test/wfid_test.rb

@@ -14,7 +14,7 @@
 require 'test/unit'
 
 require 'openwfe/utils'
-require 'openwfe/expool/expressionpool'
+require 'openwfe/expool/wfidgen'
 
 
 #
@@ -30,25 +30,20 @@ class WfidTest < Test::Unit::TestCase
 
     def test_wfid_0
 
-        expool = OpenWFE::ExpressionPool.new("expool", nil)
+        gen = OpenWFE::DefaultWfidGenerator.new("wfidgen", nil)
 
-        class << expool
-            public :new_workflow_instance_id
-        end
+        thread = nil
 
-        n = 21
+        n = 777
+        #n = 1000000
 
         map = {}
 
         n.times do |i|
 
-            Thread.new do
+            thread = Thread.new do
 
-                #begin
-                wfid = expool.new_workflow_instance_id()
-                #rescue Exception => e
-                #    OpenWFE::die(e.to_s)
-                #end
+                wfid = gen.generate
 
                 #puts wfid
 
@@ -56,13 +51,74 @@ class WfidTest < Test::Unit::TestCase
                     if map[wfid]
 
                 map[wfid] = true
+
+                #puts wfid if i == n-1
             end
         end
 
-        sleep(2)
+        thread.join
+
+        sleep(0.1)
         #puts
+        
+        assert_equal map.size, n
 
         assert true
     end
 
+    def test_wfid_1
+
+        gen = OpenWFE::DefaultWfidGenerator.new("wfidgen", nil)
+
+        a = %w{ 1 2 3 4 5 }
+        s = a.join
+
+        #a2 = gen.split_wfid(s)
+        a2 = OpenWFE::split_wfid(s)
+
+        assert_equal a, a2
+    end
+
+    def test_wfid_2
+
+        gen = OpenWFE::UuidWfidGenerator.new("wfidgen", nil)
+
+        id = gen.generate
+
+        #puts id
+
+        #assert_equal gen.split_wfid(id).join, id[0, 8]
+        assert_equal OpenWFE::split_wfid(id).join, id[0, 8]
+    end
+
+    def test_kotoba_wfid
+
+        gen = OpenWFE::KotobaWfidGenerator.new("wfidgen", nil)
+
+        t = Time.now.gmtime
+        kid = gen.generate
+
+        #puts "now : #{t}"
+        #puts "kid : #{kid}"
+
+        t2 = OpenWFE::KotobaWfidGenerator.to_time(kid)
+
+        #puts "t2  : #{t2}"
+
+        assert_equal t.to_s, t2.to_s
+
+        #t = Time.utc(2007, 03, 20, 23, 59, 59)
+        #kid = OpenWFE::KotobaWfidGenerator.from_time(t)
+        #puts t
+        #puts kid
+        #kid = "20070320-nayozumuja"
+        #puts OpenWFE::KotobaWfidGenerator.to_time(kid)
+        #kid = "20070320-nayozumuje"
+        #puts OpenWFE::KotobaWfidGenerator.to_time(kid)
+        #kid = "20070320-nayozunuje"
+        #puts OpenWFE::KotobaWfidGenerator.to_time(kid)
+        #kid = "20070320-nazazunuje"
+        #puts OpenWFE::KotobaWfidGenerator.to_time(kid)
+    end
+
 end