ruote 0.9.18

data/test/storage_test.rb

@@ -0,0 +1,44 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Mon Dec 10 18:02:59 JST 2007
+#
+
+require 'test/unit'
+
+require 'openwfe/expool/expstorage'
+
+
+class Vehicle
+end
+class Car < Vehicle
+end
+class Animal
+end
+
+class StorageTest < Test::Unit::TestCase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    def test_class_accepted
+
+        esb = Object.new
+        class << esb
+            include OpenWFE::ExpressionStorageBase
+        end
+
+        assert (esb.class_accepted?(Vehicle.new, nil, nil))
+        assert (esb.class_accepted?(Vehicle.new, [ Vehicle ], nil))
+        assert (not esb.class_accepted?(Vehicle.new, nil, [ Vehicle ]))
+
+        assert (esb.class_accepted?(Car.new, [ Vehicle ], nil))
+        assert (not esb.class_accepted?(Car.new, nil, [ Vehicle ]))
+    end
+end

data/test/test.rb

@@ -0,0 +1,3 @@
+
+require 'rake_qtest'
+

data/test/timeout_test.rb

@@ -0,0 +1,105 @@
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Sun Oct 29 15:41:44 JST 2006
+#
+
+require 'test/unit'
+
+require 'openwfe/engine/engine'
+require 'openwfe/def'
+require 'openwfe/participants/storeparticipants'
+
+require 'rutest_utils'
+
+
+class TimeoutTest < Test::Unit::TestCase
+
+    #def setup
+    #    @engine = $WORKFLOW_ENGINE_CLASS.new()
+    #end
+
+    #def teardown
+    #end
+
+    class TimeoutDefinition0 < OpenWFE::ProcessDefinition
+        sequence do
+            participant :ref => "albert", :timeout => "500"
+            _print "timedout? ${f:__timed_out__}"
+            _print "over ${f:done}"
+        end
+    end
+
+    def test_timeout_0
+
+        albert = OpenWFE::HashParticipant.new
+
+        engine = OpenWFE::Engine.new :definition_in_launchitem_allowed => true
+
+        engine.application_context["__tracer"] = Tracer.new
+
+        engine.register_participant :albert, albert
+
+        li = OpenWFE::LaunchItem.new TimeoutDefinition0
+
+        engine.launch li
+
+        sleep 2
+
+        s = engine.application_context["__tracer"].to_s
+
+        engine.stop
+
+        #puts "trace is >#{s}<"
+        #puts "albert.size is #{albert.size}"
+
+        assert_equal 0, albert.size, "wi was not removed from workitem store"
+        assert_equal "timedout? true\nover", s, "flow did not reach 'over'"
+    end
+
+    def test_timeout_1
+
+        albert = OpenWFE::HashParticipant.new
+
+        engine = OpenWFE::Engine.new :definition_in_launchitem_allowed => true
+
+        engine.application_context["__tracer"] = Tracer.new
+
+        engine.register_participant(:albert, albert)
+
+        pjc = engine.get_scheduler.pending_job_count
+        assert \
+            pjc == 0,
+            "0 pending_jobs_count is at #{pjc}, it should be at 0"
+
+        li = OpenWFE::LaunchItem.new TimeoutDefinition0
+
+        engine.launch li
+
+        sleep 0.300
+
+        wi = albert.list_workitems(nil)[0]
+        wi.done = "ok"
+        albert.proceed(wi)
+
+        sleep 0.300
+
+        s = engine.application_context["__tracer"].to_s
+
+        #puts "trace is >#{s}<"
+        #puts "albert.size is #{albert.size}"
+
+        # in this test, the participant doesn't time out
+
+        assert_equal 0, albert.size, "wi was not removed from workitem store"
+        assert_equal "timedout? \nover ok", s, "flow did not reach 'over ok'"
+
+        pjc = engine.get_scheduler.pending_job_count
+
+        assert_equal 0, pjc, "pending_jobs_count is at #{pjc}, should be at 0"
+    end
+
+end
+

data/test/util_xml_test.rb

@@ -0,0 +1,112 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Sun Apr 13 19:03:31 JST 2008
+#
+
+require 'rubygems'
+
+require 'test/unit'
+
+require 'openwfe/workitem'
+require 'openwfe/flowexpressionid'
+require 'openwfe/util/xml'
+
+require 'rutest_utils'
+
+
+class UtilXmlTest < Test::Unit::TestCase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    def test_0
+
+        li = OpenWFE::LaunchItem.new
+        li.attributes.delete "___map_type"
+        xml = OpenWFE::Xml.launchitem_to_xml li
+
+        assert_equal(
+            "<?xml version=\"1.0\" encoding=\"UTF-8\"?><launchitem><workflow_definition_url></workflow_definition_url><attributes><hash></hash></attributes></launchitem>",
+            xml)
+
+        li = OpenWFE::Xml.launchitem_from_xml xml
+
+        assert_nil(li.wfdurl)
+        assert_equal({}, li.attributes)
+    end
+
+    def test_1
+
+        li = OpenWFE::LaunchItem.new
+        li.attributes = { "a" => 1, "b" => 2, "c" => [ 1, 2, 3 ]}
+
+        xml = OpenWFE::Xml.launchitem_to_xml li
+
+        assert_equal(
+            "<?xml version=\"1.0\" encoding=\"UTF-8\"?><launchitem><workflow_definition_url></workflow_definition_url><attributes><hash><entry><string>a</string><number>1</number></entry><entry><string>b</string><number>2</number></entry><entry><string>c</string><array><number>1</number><number>2</number><number>3</number></array></entry></hash></attributes></launchitem>",
+            xml)
+        
+        li = OpenWFE::Xml.launchitem_from_xml xml
+
+        assert_equal({ "a" => 1, "b" => 2, "c" => [ 1, 2, 3 ] }, li.attributes)
+    end
+
+    def test_2
+
+        wi = OpenWFE::InFlowWorkItem.new
+        wi.fei = new_fei
+
+        xml = OpenWFE::Xml.workitem_to_xml wi
+
+        wi1 = OpenWFE::Xml.workitem_from_xml xml
+
+        assert_equal wi.fei, wi1.fei
+
+        #p wi1.fei
+    end
+
+    def test_3
+
+        li = OpenWFE::LaunchItem.new
+        li.wfdurl = "http://toto"
+        li.customer_name = "toto"
+
+        xml = OpenWFE::Xml.launchitem_to_xml li, 2
+
+        li1 = OpenWFE::Xml.launchitem_from_xml xml
+
+        assert_equal li.wfdurl, li1.wfdurl
+        assert_equal li.customer_name, li1.customer_name
+    end
+
+    def test_4
+
+        a = <<-EOS
+<array>
+    <string>alpha</string>
+    <number>2</number>
+    <number>2.3</number>
+    <false/>
+    <null/>
+</array>
+        EOS
+        a = a.strip
+
+        o = OpenWFE::Xml.from_xml a
+
+        assert_equal [ 'alpha', 2, 2.3, false, nil ], o
+
+        a1 = OpenWFE::Xml.to_xml(o, 4).strip
+
+        assert_equal a, a1
+    end
+
+end
+

data/test/wfid_test.rb

@@ -0,0 +1,175 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Sun Oct 29 16:18:25 JST 2006
+#
+
+#require "rubygems"
+#require "thread"
+#require "fastthread"
+
+require 'test/unit'
+
+require 'openwfe/utils'
+require 'openwfe/workitem'
+require 'openwfe/engine/engine'
+require 'openwfe/expool/wfidgen'
+require 'openwfe/def'
+
+
+#
+# testing otime and the scheduler (its cron aspect)
+#
+class WfidTest < Test::Unit::TestCase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    def test_wfid_0
+
+        gen = OpenWFE::DefaultWfidGenerator.new("wfidgen", nil)
+
+        thread = nil
+
+        n = 777
+        #n = 1000000
+
+        map = {}
+
+        n.times do |i|
+
+            thread = Thread.new do
+
+                wfid = gen.generate
+
+                #puts wfid
+
+                abort "\nduplicate workflow_instance_id found !!!" \
+                    if map[wfid]
+
+                map[wfid] = true
+
+                #puts wfid if i == n-1
+            end
+        end
+
+        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
+
+
+    #
+    # test FieldWfidGenerator
+
+    class MyEngine < OpenWFE::Engine
+
+        def initialize
+
+            super
+
+            self.ac[:definition_in_launchitem_allowed] = true
+        end
+
+        def build_wfid_generator
+
+            g = FieldWfidGenerator.new(
+                S_WFID_GENERATOR, @application_context, "wfid")
+        end
+    end
+
+    class MyProcDef < OpenWFE::ProcessDefinition
+        sequence do
+            # do nothing
+        end
+    end
+
+    def test_field_wfid
+
+        eng = MyEngine.new
+
+        li = OpenWFE::LaunchItem.new MyProcDef
+        li.wfid = "toto"
+        fei = eng.launch(li)
+
+        assert_equal fei.wfid, "toto"
+
+        li = OpenWFE::LaunchItem.new(MyProcDef)
+        fei = eng.launch(li)
+
+        #puts fei.wfid
+
+        assert_not_equal fei.wfid, "toto"
+
+        t = OpenWFE::KotobaWfidGenerator.to_time(fei.wfid)
+
+        assert t.is_a?(Time)
+    end
+
+end

data/test/wi_test.rb

@@ -0,0 +1,75 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+
+require 'test/unit'
+require 'openwfe/workitem'
+require 'openwfe/util/dollar'
+
+
+class WiTest < Test::Unit::TestCase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    def test_0
+
+        wi = OpenWFE::InFlowWorkItem.new
+        wi.attributes = {
+            "field0" => "value0",
+            "field1" => [ 0, 1, 2, 3, [ "a", "b", "c" ]],
+            "field2" => {
+                "a" => "AA", 
+                "b" => "BB", 
+                "c" => [ "C0", "C1", "C3" ]
+            },
+            "field3" => 3,
+            "field99" => nil
+        }
+
+        assert_equal 3, wi.lookup_attribute("field3")
+        assert_equal 1, wi.lookup_attribute("field1.1")
+        assert_equal "b", wi.lookup_attribute("field1.4.1")
+        assert_equal "C1", wi.lookup_attribute("field2.c.1")
+        assert_equal nil, wi.lookup_attribute("field4")
+        assert_equal nil, wi.lookup_attribute("field4.2")
+        assert_equal nil, wi.lookup_attribute("field99")
+        assert_equal nil, wi.lookup_attribute("field99.9")
+
+        assert_equal false, wi.has_attribute?("field4")
+        assert_equal false, wi.has_attribute?("field4.2")
+        assert_equal true, wi.has_attribute?("field99")
+        assert_equal false, wi.has_attribute?("field99.9")
+
+        text = "value is '${f:field2.c.1}'"
+        text = OpenWFE::dosub text, nil, wi
+        assert_equal "value is 'C1'", text
+
+        # setting attributes
+
+        wi.set_attribute("field2.a", 42)
+        wi.set_attribute("field99", "f99")
+
+        assert_equal 42, wi.lookup_attribute("field2.a")
+        assert_equal "f99", wi.lookup_attribute("field99")
+
+        # unsetting attributes
+
+        wi.unset_attribute "field99"
+        assert_nil wi.lookup_attribute("field99")
+
+        wi.unset_attribute "field1.4"
+        assert_equal [ 0, 1, 2, 3 ], wi.lookup_attribute("field1")
+
+        wi.unset_attribute "field2.c"
+        assert_equal({ "a" => 42, "b" => "BB" }, wi.lookup_attribute("field2"))
+    end
+
+end
+