ruote 0.9.18

data/test/lookup_att_test.rb

@@ -0,0 +1,90 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+
+require 'test/unit'
+require 'openwfe/utils'
+
+
+class LookupAttTest < Test::Unit::TestCase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    def test_0
+
+        l0 = [
+            {"name"=>"companyA","DunsNr" => "JGE4753"},
+            {"name"=>"companyB","DunsNr" => "ZUTE8555"},
+            {"name"=>"companyC","DunsNr" => "GTI6775"},
+            {"name"=>"companyD","DunsNr" => "XUE6755"}
+        ]
+        h0 = { "supplierList" => l0 }
+
+        do_lookup_test(
+            h0, "supplierList", l0)
+        do_lookup_test(
+            h0, "supplierList.1", {"name"=>"companyB","DunsNr" => "ZUTE8555"})
+        do_lookup_test(
+            h0, "supplierList.1.DunsNr", "ZUTE8555")
+
+        do_has_attribute_test(
+            h0, "supplierList.1.DunsNr", true)
+        do_has_attribute_test(
+            h0, "supplierList.1.Whatever", false)
+        do_has_attribute_test(
+            h0, "supplierList.whatever", false)
+        do_has_attribute_test(
+            h0, "whatever", false)
+
+        h1 = { "supplierList" => l0.to_s }
+        do_lookup_test(
+            h1, "supplierList.1.DunsNr", nil)
+
+        do_has_attribute_test(
+            nil, "whatever", false)
+        do_has_attribute_test(
+            {}, "whatever", false)
+        do_has_attribute_test(
+            [], "whatever", false)
+        do_has_attribute_test(
+            "string",  "whatever", false)
+
+        do_has_attribute_test(
+            [ nil, nil ], "1.name", false)
+    end
+
+    def test_1
+
+        h = { "0" => [ "a", "A" ], "1" => { "b" => "B"} }
+
+        do_lookup_test(h, "0", [ "a", "A" ])
+        do_lookup_test(h, "1.b", "B")
+        do_has_attribute_test(h, "0", true)
+        do_has_attribute_test(h, "1.b", true)
+    end
+
+    protected
+
+        def do_lookup_test (container, expression, expected_value)
+
+            assert_equal(
+                expected_value, 
+                OpenWFE::lookup_attribute(container, expression))
+        end
+
+        def do_has_attribute_test (container, expression, expected_boolean)
+
+            assert_equal(
+                expected_boolean, 
+                OpenWFE::has_attribute?(container, expression))
+        end
+
+end
+

data/test/lookup_vf_test.rb

@@ -0,0 +1,94 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Tue Mar 11 13:44:11 JST 2008
+#
+
+require 'test/unit'
+
+require 'rubygems'
+require 'openwfe/workitem'
+require 'openwfe/expressions/expressionmap'
+
+
+class LookupVfTest < Test::Unit::TestCase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+
+    def test_0
+
+        fexp = new_exp({
+            "on-value" => "toto"
+        })
+        wi = new_wi({
+            "toto" => "whatever"
+        })
+
+        assert_equal(
+            "toto", 
+            fexp.lookup_vf_attribute(wi, "value", :prefix => "on"))
+
+        fexp = new_exp({ "on-variable-value" => "toto" }, { "toto" => "surf" })
+
+        assert_equal(
+            "surf", 
+            fexp.lookup_vf_attribute(wi, "value", :prefix => "on"))
+
+        fexp = new_exp({ "on-field-value" => "toto" })
+
+        assert_equal(
+            "whatever", 
+            fexp.lookup_vf_attribute(wi, "value", :prefix => "on"))
+    end
+
+    def test_1
+
+        fexp = new_exp({
+            "on" => "surf"
+        })
+        wi = new_wi
+
+        assert_equal(
+            "surf", 
+            fexp.lookup_vf_attribute(wi, "", :prefix => "on"))
+
+        assert_equal(
+            "surf", 
+            fexp.lookup_vf_attribute(wi, "", :prefix => :on))
+    end
+
+    protected
+
+        def new_exp (atts, vars={})
+
+            fexp = OpenWFE::ParticipantExpression.new
+            fexp.attributes = atts
+
+            fexp.instance_variable_set :@vars, vars
+
+            class << fexp
+                def lookup_variable (var_name)
+                    @vars[var_name]
+                end
+            end
+
+            fexp
+        end
+
+        def new_wi (atts={})
+
+            wi = OpenWFE::InFlowWorkItem.new
+            wi.attributes = atts
+            wi
+        end
+
+end
+

data/test/misc_test.rb

@@ -0,0 +1,90 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Sun Oct 29 16:18:25 JST 2006
+#
+
+require 'test/unit'
+
+require 'openwfe/utils'
+require 'openwfe/expressions/raw'
+#require 'openwfe/def'
+require 'openwfe/expressions/fe_define'
+require 'openwfe/expressions/expressionmap'
+
+#
+# testing misc things
+#
+
+class MiscTest < Test::Unit::TestCase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    def test_starts_with
+
+        assert OpenWFE::starts_with("//a", "//")
+        assert (not OpenWFE::starts_with("/a", "//"))
+    end
+
+    def test_ends_with
+
+        assert OpenWFE::ends_with("c'est la fin", "fin")
+    end
+
+    def test_ensure_for_filename
+
+        assert_equal OpenWFE::ensure_for_filename("abc"), "abc"
+        assert_equal OpenWFE::ensure_for_filename("a/c"), "a_c"
+        assert_equal OpenWFE::ensure_for_filename("a\\c"), "a_c"
+        assert_equal OpenWFE::ensure_for_filename("a*c"), "a_c"
+        assert_equal OpenWFE::ensure_for_filename("a+?"), "a__"
+        assert_equal OpenWFE::ensure_for_filename("a b"), "a_b"
+    end
+
+    def test_clean_path
+
+        assert_equal OpenWFE::clean_path("my//file/path"), "my/file/path"
+        assert_equal OpenWFE::clean_path("my//file//path"), "my/file/path"
+    end
+
+    def test_stu
+
+        assert_equal "a_b_c", OpenWFE::stu("a b c")
+    end
+
+    def test_grep_0
+
+        assert OpenWFE::grep("sputnik", "Rakefile").empty?
+        assert_equal 2, OpenWFE::grep("Mettraux", "Rakefile").size
+
+        OpenWFE::grep "Mettraux", "Rakefile" do |line|
+            assert_match "Mettraux", line
+        end
+    end
+
+    def test_expmap_get_classes
+
+        em = OpenWFE::ExpressionMap.new
+
+        assert_equal \
+            em.get_expression_classes(Rufus::Schedulable),
+            [
+                OpenWFE::ParticipantExpression,
+                OpenWFE::SleepExpression,
+                OpenWFE::CronExpression,
+                OpenWFE::WhenExpression,
+                OpenWFE::WaitExpression,
+                #OpenWFE::ReserveExpression,
+                OpenWFE::ListenExpression,
+                OpenWFE::TimeoutExpression,
+                OpenWFE::Environment
+            ]
+    end
+end

data/test/nut_0_irb.rb

@@ -0,0 +1,20 @@
+
+#
+# NUT = not a unit test
+# some kind of a manual test
+#
+# John Mettraux at openwfe.org
+#
+# Mon Oct  9 22:19:44 JST 2006
+#
+
+require 'openwfe/util/irb'
+require 'openwfe/engine/engine'
+
+
+engine = OpenWFE::Engine.new
+
+OpenWFE::trap_int_irb(binding())
+
+sleep(20)
+

data/test/obs_test.rb

@@ -0,0 +1,142 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Sun Oct 29 16:18:25 JST 2006
+#
+
+require 'test/unit'
+
+require 'openwfe/util/observable'
+
+
+#
+# testing the observer module (mixin)
+#
+
+class ObsTest < Test::Unit::TestCase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    class Observed
+        include OpenWFE::OwfeObservable
+
+        attr_reader :observers
+
+        def initialize
+            super
+            @observers = {}
+        end
+
+        public :onotify
+    end
+
+    def test_0
+
+        $s = nil
+
+        observed = Observed.new
+
+        observed.add_observer :channel0 do
+            $s = 0
+        end
+
+        observer1 = Object.new
+        class << observer1
+            def call channel, *args
+                $s = 1
+            end
+        end
+        observed.add_observer :channel1, observer1
+
+        observer2 = lambda do |channel, args|
+            $s = 2
+        end
+        observed.add_observer :channel2, observer2
+
+        observed.onotify :channel0, :nothing
+        assert_equal $s, 0
+
+        observed.onotify :channel1, :nothing
+        assert_equal $s, 1
+
+        observed.onotify :channel2, :nothing
+        assert_equal $s, 2
+
+        $s = nil
+
+        observed.remove_observer observer2, :channel99
+
+        observed.onotify :channel2, :nothing
+        assert_equal $s, 2
+
+        $s = nil
+
+        observed.remove_observer observer2
+
+        observed.onotify :channel2, :nothing
+        assert_nil $s
+
+        $s = nil
+
+        observed.remove_observer observer1, :channel1
+
+        observed.onotify :channel1, :nothing
+        assert_nil $s
+    end
+
+
+    def test_1
+
+        $s = nil
+
+        observed = Observed.new
+
+        observed.add_observer :channel0 do
+            $s = 0
+        end
+        observed.add_observer "channel[0-9]+" do
+            $s = 9
+        end
+
+        $s = nil
+        observed.onotify "channel2", :nothing
+        assert_equal $s, 9
+
+        $s = nil
+        observed.onotify "channelZ", :nothing
+        assert_nil $s
+    end
+
+    def test_2
+
+        observed = Observed.new
+
+        o1 = observed.add_observer :channel0 do
+            puts "whatever"
+        end
+        o2 = observed.add_observer :channel0 do
+            puts "whatever"
+        end
+
+        assert_equal observed.observers.size, 1
+        assert_equal observed.observers[:channel0].size, 2
+
+        observed.remove_observer o1
+
+        assert_equal observed.observers.size, 1
+        assert_equal observed.observers[:channel0].size, 1
+
+        observed.remove_observer o2
+
+        assert_equal observed.observers.size, 1
+        assert_equal observed.observers[:channel0].size, 0
+    end
+
+end

data/test/orest_test.rb

@@ -0,0 +1,251 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+
+require 'rubygems'
+
+require 'test/unit'
+require 'fileutils'
+require 'webrick'
+
+require 'rutest_utils'
+require 'openwfe/orest/worklistclient'
+require 'openwfe/engine/engine'
+require 'openwfe/worklist/oldrest'
+require 'openwfe/worklist/storelocks'
+require 'openwfe/participants/storeparticipants'
+require 'openwfe/worklist/worklist'
+
+
+class OldRestTest < Test::Unit::TestCase
+
+    def setup
+
+        #$DEBUG = true
+
+        @engine = OpenWFE::Engine.new(
+            { :definition_in_launchitem_allowed => true })
+
+        FileUtils.mkdir "logs" unless File.exist?("logs")
+
+        logger = WEBrick::Log.new "logs/orest_test.webrick.log"
+        logger.level = WEBrick::Log::DEBUG
+
+        #
+        # preparing a worklist
+
+        @worklist = OpenWFE::Worklist.new(
+            @engine.application_context,
+            :auth_system => { "foo" => "bar" })
+            #:launchables => {})
+
+        @worklist.add_store(
+            "alpha", 
+            "alpha", 
+            OpenWFE::StoreWithLocks.new(OpenWFE::HashParticipant))
+        @worklist.add_store(
+            "bravo", 
+            "bravo", 
+            OpenWFE::StoreWithLocks.new(OpenWFE::HashParticipant))
+
+        #
+        # registering the worklist (behind two participants)
+        
+        @engine.register_participant :alpha, @worklist
+        @engine.register_participant :bravo, @worklist
+
+        #
+        # preparing and starting the webserver
+        # (it's a REST interface after all)
+
+        @server = WEBrick::HTTPServer.new(
+            :Port => 5080,
+            :BindAddress => "0.0.0.0",
+            :Logger => logger,
+            :AccessLog => [[ 
+                File.open("logs/orest_test.access.log", "w"), 
+                WEBrick::AccessLog::COMMON_LOG_FORMAT ]])
+
+        @server.mount(
+            "/worklist", 
+            OpenWFE::OldRestWorklistServlet, 
+            :AuthSystem => @worklist,
+            :Worklist => @worklist)
+
+        Thread.new do
+            @server.start
+        end
+    end
+
+    def get_servlet
+        servlet_class = @server.search_servlet("/worklist")[0]
+        servlet_class.get_instance(@server, {})
+    end
+
+    def teardown
+        @server.shutdown
+        @engine.stop
+    end
+
+
+    def test_0
+
+        #sleep 0.1
+
+        #
+        # just checking that we get bounced in case of wrong credentials
+        
+        assert_raise RuntimeError do
+            client = OpenWFE::WorklistClient.new(
+                "http://localhost:5080/worklist", "foo", "foo")
+        end
+
+        client = OpenWFE::WorklistClient.new(
+            "http://localhost:5080/worklist", "foo", "bar")
+
+        assert client.session_id > 0
+
+        assert_equal get_servlet.instance_variable_get(:@sessions).size, 1
+
+        #
+        # are there two stores in this worklist ?
+
+        l = client.list_stores
+
+        assert_equal l.size, 2
+
+        store = l[0]
+
+        assert_equal store.name, "alpha"
+
+        #
+        # playing with a mock workitem
+
+        assert_raise RuntimeError do
+            client.get_headers "nada"
+        end
+
+        actual_store = @worklist.get_store "alpha"
+        actual_store.consume(new_workitem())
+
+        headers = client.get_headers "alpha"
+        #headers = client.get_headers "Store.alpha"
+
+        assert_equal 1, headers.length
+        assert_equal "surf", headers[0].attributes["nada"]
+        assert_equal "surf", headers[0].nada
+
+        #
+        # launching a new process...
+
+        li = OpenWFE::LaunchItem.new('''
+<process-definition name="orest" revision="1">
+    <sequence>
+        <participant ref="alpha" />
+        <participant ref="bravo" />
+    </sequence>
+</process-definition>
+        '''.strip)
+        li.myfield = "myvalue"
+
+        fei = client.launch_flow "any", li
+
+        assert_kind_of OpenWFE::FlowExpressionId, fei
+
+        sleep 0.7
+
+        headers = client.get_headers "alpha"
+
+        #require 'pp'; pp headers
+
+        assert_equal headers.size, 2
+
+        # yes, the workitem of our newly launched process has arrived...
+
+        fei.expression_id = "0.0.0"
+        fei.expression_name = "participant"
+
+        wi = client.get_workitem "alpha", fei
+
+        assert_equal wi.myfield, "myvalue"
+
+        wi = client.get_and_lock_workitem "alpha", fei
+
+        # got the workitem and made sure others can't modify / forward it
+
+        assert_equal wi.myfield, "myvalue"
+
+        headers = client.get_headers "alpha"
+
+        h = nil
+        headers.each do |hh|
+            if hh.locked
+                h = hh
+                break
+            end
+        end
+
+        assert_equal h.fei, fei
+
+        feis = client.find_flow_instance "alpha", fei.wfid
+
+        assert_equal feis.size, 1
+
+        # releasing the fish...
+
+        client.release_workitem wi
+
+        headers = client.get_headers "alpha"
+
+        assert (not (headers[0].locked or headers[1].locked))
+
+        assert_raise RuntimeError do
+            client.save_workitem wi
+        end
+
+        # catching it again
+
+        wi = client.get_and_lock_workitem "alpha", fei
+
+        wi.got_forwarded = true
+
+        client.forward_workitem wi
+
+        headers = client.get_headers "alpha"
+
+        assert_equal headers.size, 1
+
+        assert_nil headers[0].attributes['got_forwarded']
+            #
+            # still our old initial workitem, inserted manually
+
+        sleep 0.500
+
+        headers = client.get_headers "bravo"
+
+        assert_equal headers.size, 1
+
+        assert_equal headers[0].got_forwarded, true
+
+        #
+        # done
+
+        client.close
+
+        assert_equal get_servlet.instance_variable_get(:@sessions).size, 0
+    end
+
+    protected
+
+        def new_workitem ()
+            wi = OpenWFE::InFlowWorkItem.new
+            wi.fei = new_fei()
+            wi.attributes = { "nada" => "surf" }
+            wi
+        end
+
+end
+