ruote 0.9.18

data/test/ruby_procdef_test.rb

@@ -0,0 +1,132 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Tue Aug 21 10:22:18 JST 2007
+#
+
+require 'rubygems'
+
+require 'test/unit'
+
+require 'find'
+
+require 'openwfe/engine/file_persisted_engine'
+require 'openwfe/participants/storeparticipants'
+
+
+#
+# fighting bug at : 
+# http://rubyforge.org/tracker/index.php?func=detail&aid=13238&group_id=2609&atid=10023
+#
+
+class RubyProcDefTest < Test::Unit::TestCase
+
+    def setup
+
+        @engine = OpenWFE::CachedFilePersistedEngine.new(
+            :definition_in_launchitem_allowed => true)
+
+        @engine.register_participant :alpha, OpenWFE::HashParticipant
+    end
+
+    def teardown
+
+        @engine.stop if @engine
+    end
+
+    #
+    # TESTS
+
+    class Test0 < OpenWFE::ProcessDefinition
+        sequence do
+            alpha
+        end
+    end
+
+    def test_0
+
+        fei0 = @engine.launch Test0
+        sleep 0.100
+        fei1 = @engine.launch Test0
+        sleep 0.200
+
+        stack0 = @engine.process_stack fei0.wfid
+        stack1 = @engine.process_stack fei1.wfid
+
+        assert_equal 3, stack0.size
+        assert_equal 3, stack1.size
+
+        assert_equal 4, count_files(fei0.wfid)
+        assert_equal 4, count_files(fei1.wfid)
+
+        @engine.cancel_process(fei0.wfid)
+        @engine.cancel_process(fei1.wfid)
+
+        sleep 0.350
+    end
+
+
+    TEST1 = """
+class Test1 < OpenWFE::ProcessDefinition
+    sequence do
+        alpha
+    end
+end
+    """
+
+    def test_1
+
+        fei0 = launch TEST1
+        sleep 0.100
+        fei1 = launch TEST1
+        sleep 0.200
+
+        assert_equal(
+            OpenWFE::ProcessDefinition::Test1,
+            OpenWFE::ProcessDefinition.extract_class(TEST1))
+
+        stack0 = @engine.process_stack fei0.wfid
+        #puts stack0
+        stack1 = @engine.process_stack fei1.wfid
+        #puts stack1
+
+        assert_equal 3, stack0.size
+        assert_equal 3, stack1.size
+
+        assert_equal 4, count_files(fei0.wfid)
+        assert_equal 4, count_files(fei1.wfid)
+
+        @engine.cancel_process(fei0.wfid)
+        @engine.cancel_process(fei1.wfid)
+
+        sleep 0.350
+    end
+
+    protected
+
+        def launch (test_string)
+
+            filename = "work/procdef.rb"
+
+            File.open(filename, "w") do |f|
+                f.puts test_string
+            end
+            @engine.launch filename
+        end
+
+        def count_files (wfid)
+
+            count = 0
+
+            Find.find("work/expool/") do |path|
+                next unless path.match(wfid+"__.*\.yaml")
+                count += 1
+            end
+
+            count
+        end
+
+end

data/test/rutest_utils.rb

@@ -0,0 +1,63 @@
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Mon Oct  9 22:19:44 JST 2006
+#
+
+require 'openwfe/version'
+
+
+class Tracer
+
+    def initialize
+        super
+        @trace = ""
+    end
+
+    def to_s
+        @trace.to_s.strip
+    end
+
+    def << s
+        @trace << s
+    end
+
+    def clear
+        @trace = ""
+    end
+
+    def puts s
+        @trace << "#{s}\n"
+    end
+end
+
+#
+# Returns a new FlowExpressionId, for testing purposes
+#
+def new_fei
+
+    fei = OpenWFE::FlowExpressionId.new
+
+    fei.owfe_version = OpenWFE::OPENWFERU_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'
+
+    fei
+end
+
+#
+# Returns true when on JRuby
+#
+def on_jruby?
+
+    (defined?(JRUBY_VERSION) != nil)
+end
+

data/test/sec_test.rb

@@ -0,0 +1,205 @@
+
+#
+# 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 test_sec_0
+
+        engine = OpenWFE::Engine.new
+
+        engine.ac[:ruby_eval_allowed] = true
+        engine.ac[:definition_in_launchitem_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>''' 
+
+        dotest engine, def0
+
+        assert(
+            OpenWFE::grep(
+                "Insecure operation - initialize", 
+                "logs/openwferu.log").size > 0)
+
+        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>''' 
+
+        dotest(engine, def2)
+
+        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>''' 
+
+        dotest(engine, def3)
+
+        assert OpenWFE::grep(
+            "evaluation of ruby code is not allowed", "logs/openwferu.log")
+
+        engine.stop
+    end
+
+    def test_sec_0b
+
+        engine = OpenWFE::Engine.new
+
+        engine.ac[:ruby_eval_allowed] = true
+        engine.ac[:definition_in_launchitem_allowed] = true
+
+        def1 =
+'''<process-definition name="" revision="0">
+    <sequence>
+        <reval>
+            class Object
+                def my_name
+                    "toto"
+                end
+            end
+            "stringobject".my_name
+        </reval>
+    </sequence>
+</process-definition>''' 
+
+        dotest engine, def1
+
+        assert_equal(
+            1, 
+            OpenWFE::grep(
+                "undefined method `my_name' for \"stringobject\":String", 
+                "logs/openwferu.log").size)
+        #assert_equal(
+        #    1, 
+        #    OpenWFE::grep(
+        #        "Insecure: can't set constant",
+        #        "logs/openwferu.log").size)
+            #
+            # level 4 is too much (can't modify hashes)...
+    end
+
+    XMLDEF =
+'''<process-definition name="" revision="0">
+    <sequence>
+        <set field="f" value="${ruby:5*7}" />
+        <toto/>
+    </sequence>
+</process-definition>''' 
+
+    def test_sec_1
+
+        value = nil
+
+        engine = OpenWFE::Engine.new :definition_in_launchitem_allowed => true
+
+        engine.register_participant(:toto) do |workitem|
+
+            workitem.attributes.delete("___map_type")
+                #
+                # if the xmlencoder was used in previous, this field
+                # might be set, removing it.
+
+            value = "#{workitem.attributes.size}_#{workitem.f}"
+        end
+
+        engine.launch XMLDEF
+
+        sleep 0.350
+
+        assert_equal "3_", value
+
+        engine.stop
+    end
+    
+    def test_sec_1b
+
+        value = nil
+
+        engine = OpenWFE::Engine.new
+
+        engine.register_participant(:toto) do |workitem|
+
+            workitem.attributes.delete("___map_type")
+                #
+                # if the xmlencoder was used in previous, this field
+                # might be set, removing it.
+
+            value = "#{workitem.attributes.size}_#{workitem.f}"
+        end
+
+        engine.ac[:ruby_eval_allowed] = true
+        engine.ac[:definition_in_launchitem_allowed] = true
+
+        engine.launch XMLDEF
+
+        sleep 0.350
+
+        assert_equal "3_35", value
+
+        engine.stop
+    end
+
+    def test_sec_2
+
+        assert_equal 35, Rufus::eval_safely("5*7", 4)
+        assert_equal 35, Rufus::eval_safely("5*7", 4, binding())
+    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
+            
+            engine.launch(li)
+
+            sleep 0.350
+        end
+
+end
+

data/test/slock_test.rb

@@ -0,0 +1,80 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+
+require 'test/unit'
+require 'openwfe/worklist/storelocks'
+require 'openwfe/participants/storeparticipants'
+
+
+class MockItem
+    attr_reader :fei
+    def initialize (fei)
+        @fei = fei
+    end
+    def flow_expression_id
+        @fei
+    end
+end
+
+class StoreLockTest < Test::Unit::TestCase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    def test_0
+
+        store = StoreWithLocks.new(HashParticipant)
+
+        wi0 = MockItem.new("fei")
+
+        store.store.push(wi0)
+
+        wi1 = store.get_and_lock("locker_a", "fei")
+
+        assert_not_nil wi1
+        assert_equal wi0.object_id, wi1.object_id
+
+        assert_raise RuntimeError do
+            wi2 = store.get_and_lock("locker_b", "fei")
+        end
+
+        assert_equal store.get_locker("fei"), "locker_a"
+
+        assert_raise RuntimeError do
+            store.release "locker_b", "fei"
+        end
+
+        store.release "locker_a", "fei"
+
+        assert_nil store.get_locker("fei")
+    end
+
+    def test_1
+
+        store = StoreWithLocks.new(
+            HashParticipant,
+            nil,
+            :lock_max_age => "100")
+
+        wi0 = MockItem.new("fei")
+
+        store.store.push(wi0)
+
+        wi1 = store.get_and_lock("locker_a", "fei")
+
+        assert_not_nil wi1
+
+        sleep 1
+
+        assert_nil store.get_locker("fei")
+    end
+
+end
+