ruote 0.9.18

data/test/param_test.rb

@@ -0,0 +1,290 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Tue Jan  2 13:14:37 JST 2007
+#
+
+require 'flowtestbase'
+require 'openwfe/def'
+require 'openwfe/workitem'
+require 'openwfe/exceptions'
+
+
+class ParameterTest < Test::Unit::TestCase
+    include FlowTestBase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    #
+    # test 0
+
+    def test_param_0
+
+        definition = '''
+<process-definition name="reqtest" revision="0">
+    <parameter field="address"/>
+    <print>${f:address}</print>
+</process-definition>'''.strip
+
+        li = OpenWFE::LaunchItem.new(definition)
+
+        e = nil
+        
+        begin
+            @engine.launch li
+        rescue Exception => e
+            #puts e
+            #puts OpenWFE::exception_to_s(e)
+        end
+
+        assert_equal "field 'address' is missing", e.to_s
+
+        # second round
+
+        li = OpenWFE::LaunchItem.new(definition)
+        li.address = "rose garden 4"
+
+        #require 'pp' ; pp li
+
+        fei = nil
+        e = nil
+        
+        begin
+            fei = @engine.launch(li)
+        rescue Exception => e
+            #puts e
+            #puts OpenWFE::exception_to_s(e)
+        end
+
+        assert_nil e
+
+        sleep 0.350
+            # let the flow terminate on its own
+    end
+
+
+    #
+    # test 1
+
+    class TestParam1 < OpenWFE::ProcessDefinition
+        
+        param :field => "customer"
+        param :field => "address"
+
+        _print "#{f:customer},  #{f:address}"
+    end
+
+    def test_param_1
+
+        li = OpenWFE::LaunchItem.new(TestParam1)
+
+        e = nil
+        
+        begin
+            @engine.launch(li)
+        rescue Exception => e
+            #puts e
+            #puts OpenWFE::exception_to_s(e)
+        end
+
+        assert_equal "field 'customer' is missing", e.to_s
+
+        li = OpenWFE::LaunchItem.new(TestParam1)
+        li.customer = "bauhaus"
+        li.address = "rose garden 4"
+
+        e = nil
+        
+        begin
+            @engine.launch(li)
+        rescue Exception => e
+            #puts e
+            #puts OpenWFE::exception_to_s(e)
+        end
+
+        assert_nil e
+    end
+
+
+    #
+    # test 2
+
+    class TestParam2 < OpenWFE::ProcessDefinition
+        
+        param :field => "address", :default => "(unknown address)"
+
+        sequence do
+            #pp_workitem
+            _print "${f:address}"
+        end
+    end
+
+    def test_param_2
+
+        li = OpenWFE::LaunchItem.new(TestParam2)
+
+        e = nil
+
+        begin
+            @engine.launch(li)
+        rescue Exception => e
+            #puts e
+            #puts OpenWFE::exception_to_s(e)
+        end
+
+        sleep 0.350
+
+        assert_nil e
+        assert_equal "(unknown address)", @tracer.to_s
+    end
+
+
+    #
+    # test 3
+
+    class TestParam3 < OpenWFE::ProcessDefinition
+        
+        param :field => :address, :type => :string
+
+        sequence do
+            #pp_workitem
+            _print "${f:address}"
+        end
+    end
+
+    def test_param_3
+
+        li = OpenWFE::LaunchItem.new(TestParam3)
+        li.address = 3
+
+        e = nil
+
+        begin
+            @engine.launch(li)
+        rescue Exception => e
+            #puts e
+            #puts OpenWFE::exception_to_s(e)
+        end
+
+        sleep 0.350
+
+        # well, I should maybe refactor the test into a method
+
+        assert_nil e
+        assert_equal "3", @tracer.to_s
+    end
+
+
+    #
+    # test 4
+
+    class TestParam4 < OpenWFE::ProcessDefinition
+        
+        param :field => :zip, :type => :integer
+
+        _print "${f:zip}"
+    end
+
+    def test_param_4
+
+        li = OpenWFE::LaunchItem.new(TestParam4)
+        li.zip = "Colorado"
+
+        e = nil
+
+        begin
+            @engine.launch(li)
+        rescue Exception => e
+            #puts e
+            #puts OpenWFE::exception_to_s(e)
+        end
+
+        assert_not_nil e
+        assert_equal 'invalid value for Integer: "Colorado"', e.to_s
+    end
+
+
+    #
+    # test 5
+
+    def test_param_5
+
+        definition = '''
+<process-definition name="paramtest" revision="5">
+    <parameter field="phone" match="^[0-9]{3}-[0-9]{3}-[0-9]{4}$" />
+    <print>${field:phone}</print>
+</process-definition>'''.strip
+
+        li = OpenWFE::LaunchItem.new(definition)
+
+        e = nil
+        
+        begin
+            @engine.launch(li)
+        rescue Exception => e
+            #puts e
+            #puts OpenWFE::exception_to_s(e)
+        end
+
+        assert_equal "field 'phone' is missing", e.to_s
+        assert_equal OpenWFE::ParameterException, e.class
+
+        # second round
+
+        li = OpenWFE::LaunchItem.new(definition)
+        li.phone = "4444-333-4444"
+
+        #require 'pp' ; pp li
+
+        e = nil
+        
+        begin
+            @engine.launch(li)
+        rescue Exception => e
+            #puts e
+            #puts OpenWFE::exception_to_s(e)
+        end
+
+        assert_not_nil e
+        assert_equal "value of field 'phone' doesn't match", e.to_s
+    end
+
+
+    #
+    # test 6
+
+    class TestParam6 < OpenWFE::ProcessDefinition
+        
+        param :field => "customer_type", :default => "2", :type => "int"
+
+        _print "#{f:customer},  #{f:address}"
+    end
+
+    def test_param_1
+
+        li = OpenWFE::LaunchItem.new(TestParam6)
+
+        e = nil
+        begin
+            @engine.pre_launch_check(li)
+        rescue Exception => e
+            #puts e
+            #puts OpenWFE::exception_to_s(e)
+        end
+
+        #require 'pp'; pp li
+
+        assert_nil e
+        assert li.customer_type
+        assert li.customer_type == 2
+    end
+
+end
+

data/test/participant_test.rb

@@ -0,0 +1,101 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Sun Oct 29 16:18:25 JST 2006
+#
+
+require 'rubygems'
+
+require 'test/unit'
+
+require 'openwfe/engine/engine'
+require 'openwfe/participants/participants'
+
+#
+# testing misc things
+#
+
+class ParticipantTest < Test::Unit::TestCase
+
+    def setup
+        @engine = OpenWFE::Engine.new
+    end
+
+    def teardown
+        @engine.stop
+    end
+
+    def test_lookup_participant
+
+        @engine.register_participant :toto, OpenWFE::NullParticipant
+
+        p = @engine.get_participant "toto"
+        assert_kind_of OpenWFE::NullParticipant, p
+
+        p = @engine.get_participant :toto
+        assert_kind_of OpenWFE::NullParticipant, p
+
+        assert_equal 1, @engine.get_participant_map.size
+    end
+
+    def test_unregister_participant
+
+        assert ( ! @engine.unregister_participant(:nada))
+
+        @engine.register_participant :toto, OpenWFE::NullParticipant
+
+        assert_equal 1, @engine.get_participant_map.size
+
+        assert @engine.unregister_participant(:toto)
+
+        assert_equal 0, @engine.get_participant_map.size
+
+        @engine.register_participant "user_.*", OpenWFE::NullParticipant
+
+        assert_equal 1, @engine.get_participant_map.size
+
+        assert @engine.unregister_participant("user_.*")
+
+        assert_equal 0, @engine.get_participant_map.size
+    end
+
+    def test_order
+
+        s = ""
+
+        @engine.register_participant "a.*", :astar
+        @engine.register_participant "alpha", :alpha
+
+        assert_equal :astar, @engine.get_participant("alpha")
+
+        clean_participants
+
+        @engine.register_participant "alpha", :alpha
+        @engine.register_participant "a.*", :astar
+
+        assert_equal :alpha, @engine.get_participant("alpha")
+
+        clean_participants
+
+        @engine.register_participant "a.*", :astar
+
+        assert_equal :astar, @engine.get_participant("alpha")
+
+        @engine.register_participant "alpha", { :participant => :alpha, :position => :first }
+
+        assert_equal :alpha, @engine.get_participant("alpha")
+        assert_equal :astar, @engine.get_participant("abricot")
+    end
+
+    protected
+
+        def clean_participants
+
+            @engine.get_participant_map.instance_variable_set(
+                :@participants, [])
+        end
+
+end

data/test/pending.rb

@@ -0,0 +1,23 @@
+
+#
+# a method for checking the number of pending jobs left in the engine
+#
+
+module PendingJobsMixin
+
+    def assert_no_jobs_left
+
+        #cname = @engine.class.name
+        #min_jobs = if cname == 'OpenWFE::CachedFilePersistedEngine'
+        #    1
+        #elsif cname == 'OpenWFE::Extras::CachedDbPersistedEngine'
+        #    1
+        #else
+        #    0
+        #end
+        #assert_equal min_jobs, @engine.get_scheduler.pending_job_count
+
+        assert_equal 0, @engine.get_scheduler.at_job_count
+    end
+end
+

data/test/ps_representation.rb

@@ -0,0 +1,133 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Tue Apr  8 18:33:11 JST 2008
+#
+
+require 'rubygems'
+
+require 'test/unit'
+
+require 'openwfe/engine'
+
+
+class PsRepresentationTest < Test::Unit::TestCase
+
+    def setup
+
+        @engine = OpenWFE::Engine.new :definition_in_launchitem_allowed => true
+    end
+
+    def teardown
+
+        @engine.stop if @engine
+    end
+
+    #
+    # TEST 0
+
+    class Test0 < OpenWFE::ProcessDefinition
+        sequence do
+            alpha
+            bravo
+        end
+    end
+
+    def test_0
+
+        @engine.register_participant "alpha", OpenWFE::NullParticipant
+
+        fei = @engine.launch Test0
+
+        sleep 0.350
+
+        ps = @engine.process_stack fei, true
+
+        #p ps.representation
+
+        assert_equal(
+            ["process-definition", {"name"=>"Test", "revision"=>"0"}, [["sequence", {}, [["alpha", {"ref"=>"alpha"}, []], ["bravo", {}, []]]]]],
+            ps.representation)
+
+        #
+        # change process instance (charly instead of bravo)
+
+        #puts ps.collect { |fexp| fexp.fei.to_s }.join("\n")
+
+        bravo_fei = ps.find { |fexp| fexp.fei.expid == "0.0.1" }.fei
+
+        @engine.update_raw_expression bravo_fei, ["charly", {}, []]
+
+        ps = @engine.process_stack fei, true
+
+        assert_equal(
+            ["process-definition", {"name"=>"Test", "revision"=>"0"}, [["sequence", {}, [["alpha", {"ref"=>"alpha"}, []], ["charly", {}, []]]]]],
+            ps.representation)
+    end
+
+    #
+    # TEST 1
+
+    class Test1 < OpenWFE::ProcessDefinition
+
+        description "interference of the description"
+
+        sequence do
+            alpha
+            bravo
+        end
+    end
+
+    def test_1
+
+        @engine.register_participant "alpha", OpenWFE::NullParticipant
+
+        fei = @engine.launch Test1
+
+        sleep 0.350
+
+        ps = @engine.process_stack fei, true
+
+        assert_equal(
+            ["process-definition", {"name"=>"Test", "revision"=>"1"}, [["description", {}, ["interference of the description"]], ["sequence", {}, [["alpha", {"ref"=>"alpha"}, []], ["bravo", {}, []]]]]],
+            ps.representation)
+
+        #
+        # change process instance (charly instead of bravo)
+
+        bravo_fei = ps.find { |fexp| fexp.fei.expid == "0.1.1" }.fei
+
+        @engine.update_raw_expression bravo_fei, ["charly", {}, []]
+
+        ps = @engine.process_stack fei, true
+
+        assert_equal(
+            ["process-definition", {"name"=>"Test", "revision"=>"1"}, [["description", {}, ["interference of the description"]], ["sequence", {}, [["alpha", {"ref"=>"alpha"}, []], ["charly", {}, []]]]]],
+            ps.representation)
+
+        #
+        # nuke participant charly
+
+        @engine.cancel_expression bravo_fei
+
+        sleep 0.350
+
+        ps = @engine.process_stack fei, true
+
+        #p ps.representation
+
+        assert_equal(
+            ["process-definition", {"name"=>"Test", "revision"=>"1"}, [["description", {}, ["interference of the description"]], ["sequence", {}, [["alpha", {"ref"=>"alpha"}, []]]]]],
+            ps.representation)
+
+        assert_equal(
+            ["process-definition", {"name"=>"Test", "revision"=>"1"}, [["description", {}, ["interference of the description"]], ["sequence", {}, [["alpha", {"ref"=>"alpha"}, []]]]]],
+            @engine.process_representation(fei.wfid))
+    end
+
+    # see also test/ft_84_updateexp.rb
+
+end