ruote 0.9.18

data/test/filter_test.rb

@@ -0,0 +1,109 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+
+require 'test/unit'
+
+require 'openwfe/filterdef'
+
+
+class FilterTest < Test::Unit::TestCase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    def test_filter_in
+
+        f0 = OpenWFE::FilterDefinition.new
+        f0.closed = true
+        f0.add_field("a", "r")
+        f0.add_field("b", "rw")
+        f0.add_field("c", "")
+
+        m0 = {
+            "a" => "A",
+            "b" => "B",
+            "c" => "C",
+            "d" => "D",
+        }
+
+        m1 = f0.filter_in m0
+
+        #require 'pp'; pp m0
+        #require 'pp'; pp m1
+        assert_equal m1, { "a" => "A", "b" => "B" }
+
+        f0.closed = false
+
+        m2 = f0.filter_in m0
+
+        #require 'pp'; pp m0
+        #require 'pp'; pp m2
+        assert_equal m2, { "a" => "A", "b" => "B", "d" => "D" }
+    end
+
+    def test_filter_out_0
+
+        f0 = OpenWFE::FilterDefinition.new
+        f0.closed = false
+        f0.add_ok = true
+        f0.remove_ok = true
+        f0.add_field("a", "r")
+        f0.add_field("b", "rw")
+        f0.add_field("c", "")
+
+        m0 = {
+            "a" => "A",
+            "b" => "B",
+            "c" => "C",
+            "d" => "D",
+        }
+
+        #
+        # 0
+
+        m1 = {
+            "z" => "Z"
+        }
+
+        m2 = f0.filter_out m0, m1
+
+        #require 'pp'; pp m2
+        assert_equal m2, {"z"=>"Z"}
+
+        #
+        # 1
+
+        f0.remove_ok = false
+
+        m2 = f0.filter_out m0, m1
+
+        #require 'pp'; pp m2
+        assert_equal m2, {"a"=>"A", "b"=>"B", "c"=>"C", "z"=>"Z", "d"=>"D"}
+
+        #
+        # 2
+
+        f0.remove_allowed = true
+
+        m1 = {
+            "a" => 0,
+            "b" => 1,
+            "c" => 2,
+            "d" => 3
+        }
+
+        m2 = f0.filter_out m0, m1
+
+        #require 'pp'; pp m2
+        assert_equal m2, {"a"=>"A", "b"=>1, "c"=>"C", "d"=>3}
+    end
+
+end
+

data/test/flowtestbase.rb

@@ -0,0 +1,351 @@
+#_
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Sun Oct 29 15:41:44 JST 2006
+#
+# somewhere between Philippina and the Japan
+#
+
+require 'rubygems'
+require 'test/unit'
+
+require 'openwfe/workitem'
+require 'openwfe/engine/engine'
+require 'openwfe/rudefinitions'
+require 'openwfe/participants/participants'
+
+require 'rutest_utils'
+
+
+$WORKFLOW_ENGINE_CLASS = OpenWFE::Engine
+
+persistence = ENV["__persistence__"]
+
+
+if persistence == "pure-persistence"
+
+    require "openwfe/engine/file_persisted_engine"
+    $WORKFLOW_ENGINE_CLASS = OpenWFE::FilePersistedEngine
+
+elsif persistence == "cached-persistence"
+
+    require "openwfe/engine/file_persisted_engine"
+    $WORKFLOW_ENGINE_CLASS = OpenWFE::CachedFilePersistedEngine
+
+elsif persistence == "db-persistence"
+
+    require 'extras/active_connection'
+    require 'openwfe/extras/engine/db_persisted_engine'
+    $WORKFLOW_ENGINE_CLASS = OpenWFE::Extras::DbPersistedEngine
+
+elsif persistence == "cached-db-persistence"
+
+    require 'extras/active_connection'
+    require 'openwfe/extras/engine/db_persisted_engine'
+    $WORKFLOW_ENGINE_CLASS = OpenWFE::Extras::CachedDbPersistedEngine
+end
+    
+
+puts
+puts "testing with engine of class " + $WORKFLOW_ENGINE_CLASS.to_s
+puts
+
+module FlowTestBase
+
+    attr_reader \
+        :engine, :tracer
+
+    #
+    # SETUP
+    #
+    def setup
+
+        @engine = $WORKFLOW_ENGINE_CLASS.new
+
+        $OWFE_LOG.info(
+            "setup() started engine #{@engine.object_id} @ #{caller[-1]}")
+
+        @terminated_processes = []
+        @engine.get_expression_pool.add_observer(:terminate) do |c, fe, wi|
+            @terminated_processes << fe.fei.wfid
+            #p [ :terminated, @terminated_processes ]
+        end
+        #@terminated = false
+        #@engine.get_expression_pool.add_observer(:terminate) do |c, fe, wi|
+        #    @terminated = true
+        #end
+
+        @engine.application_context[:ruby_eval_allowed] = true
+        @engine.application_context[:definition_in_launchitem_allowed] = true
+
+        @tracer = Tracer.new
+        @engine.application_context["__tracer"] = @tracer
+
+        @engine.register_participant('pp-workitem') do |workitem|
+
+            puts
+            require 'pp'; pp workitem
+            puts
+        end
+
+        @engine.register_participant('pp-fields') do |workitem|
+
+            workitem.attributes.keys.sort.each do |field|
+                next if field == "___map_type" or field == "__result__"
+                next if field == "params"
+                @tracer << "#{field}: #{workitem.attributes[field]}\n"
+            end
+            @tracer << "--\n"
+        end
+
+        @engine.register_participant 'test-.*', OpenWFE::PrintParticipant.new
+
+        @engine.register_participant('block-participant') do |workitem|
+            @tracer << "the block participant received a workitem"
+            @tracer << "\n"
+        end
+
+        @engine.register_participant('p-toto') do |workitem|
+            @tracer << "toto"
+        end
+    end
+
+    #
+    # TEARDOWN
+    #
+    def teardown
+
+        if @engine
+            $OWFE_LOG.level = Logger::INFO
+            @engine.stop 
+        end
+    end
+
+    protected
+
+        def log_level_to_debug
+            $OWFE_LOG.level = Logger::DEBUG
+        end
+
+        def print_exp_list (l)
+            puts
+            l.each do |fexp|
+                puts "   - #{fexp.fei.to_debug_s}"
+            end
+            puts
+        end
+
+        def name_of_test
+
+            s = caller(1)[0]
+            i = s.index('`')
+            s[i+6..s.length-2]
+        end
+
+        #
+        # some tests return quickly, leverage the @terminated_processes
+        # of the test engine to determine those processes that are
+        # already over...
+        #
+        def wait_for (fei)
+
+            #for i in (0..42)
+            for i in (0..217)
+                Thread.pass
+                return if @terminated_processes.include?(fei.wfid)
+                #return if @terminated
+            end
+
+            @engine.wait_for fei  
+        end
+
+        #
+        # calling 
+        #
+        #     launch li 
+        #
+        # instead of
+        #
+        #     @engine.launch li
+        #
+        # ensures that the logs will contain a mention of the wfid of the
+        # flow just started along with the test method (and it's location
+        # in its source file).
+        #
+        def launch (li)
+
+            fei = @engine.launch li
+
+            $OWFE_LOG.info(
+                "dotest() launched #{fei.to_short_s} "+
+                "@ #{caller[1]} on engine #{@engine.object_id}")
+
+            fei
+        end
+
+        #
+        # dotest()
+        #
+        def dotest (
+            flowDef, 
+            expected_trace, 
+            join=false, 
+            allow_remaining_expressions=false)
+
+            @tracer.clear
+
+            li = if flowDef.kind_of?(OpenWFE::LaunchItem)
+                flowDef
+            else
+                OpenWFE::LaunchItem.new flowDef
+            end
+
+            #start = Time.now.to_f
+
+            fei = launch li
+
+            if join.is_a?(Numeric)
+                sleep join
+            else
+                wait_for fei
+            end
+
+            #puts "// took #{Time.now.to_f - start} s"
+
+
+            trace = @tracer.to_s
+
+            #if trace == ''
+            #    Thread.pass; sleep 0.350
+            #    trace = @tracer.to_s
+            #end
+                #
+                # occurs when the tracing is done from a participant
+                # (participant dispatching occurs in a thread)
+
+            #for i in  0..70
+            #    Thread.pass; sleep 0.140
+            #    trace = @trace.to_s
+            #    p [ :trace, trace ]
+            #    break if trace != ''
+            #end if trace == ''
+
+            #puts "...'#{trace}' ?= '#{expected_trace}'"
+
+            if expected_trace.is_a?(Array)
+
+                result = expected_trace.find do |etrace|
+                    trace == etrace
+                end
+                assert(
+                    (result != nil),
+                    """flow failed : 
+                   
+  trace doesn't correspond to any of the expected traces...
+
+  traced :
+                    
+'#{trace}'
+
+""")
+            elsif expected_trace.kind_of?(Regexp)
+
+                assert trace.match(expected_trace)
+            else
+
+                assert(
+                    trace == expected_trace,
+                    """flow failed : 
+
+  traced :
+                    
+'#{trace}'
+
+  but was expecting :
+
+'#{expected_trace}'
+""")
+            end
+
+            if allow_remaining_expressions
+
+                purge_engine
+
+                return fei
+            end
+
+            #Thread.pass; sleep 0.003; Thread.pass
+
+            exp_storage = engine.get_expression_storage
+
+            view = exp_storage.to_s
+            size = exp_storage.size
+
+            if size != 1
+                sleep 0.350
+                view = exp_storage.to_s
+                size = exp_storage.size
+            end
+
+            if size != 1
+                puts
+                puts "    remaining expressions : #{size}"
+                puts
+                puts view
+                puts
+                puts OpenWFE::caller_to_s(0, 2)
+                puts
+
+                purge_engine
+            end
+
+            assert_equal(
+                1,
+                size,
+                "there are expressions remaining in the expression pool " +
+                "(right now : #{exp_storage.length})")
+
+            fei
+        end
+
+        #
+        # makes sure to purge the engine's expression storage
+        #
+        def purge_engine
+
+            @engine.get_expression_storages.each do |storage|
+                storage.purge
+            end
+        end
+
+        def assert_trace (desired_trace)
+
+            assert_equal desired_trace, @tracer.to_s
+        end
+
+end
+
+#
+# A bunch of methods for testing the journal component
+#
+module JournalTestBase
+
+    def get_journal
+
+        @engine.get_journal
+    end
+
+    def get_error_count (wfid)
+
+        fn = get_journal.workdir + "/" + wfid + ".journal"
+
+        get_journal.flush_buckets
+
+        events = get_journal.load_events(fn)
+
+        events.inject(0) { |r, evt| r += 1 if evt[0] == :error; r }
+    end
+end
+