ruote 0.9.18 → 0.9.19

data/test/restart_when_test.rb

@@ -19,94 +19,94 @@ require 'rutest_utils'
 
 class RestartWhenTest < Test::Unit::TestCase
 
-    #def setup
-    #    @engine = $WORKFLOW_ENGINE_CLASS.new()
-    #end
-
-    #def teardown
-    #end
-
-    class RestartWhenDefinition0 < OpenWFE::ProcessDefinition
-        concurrence do
-            _when :test => "${v:done} == true", :frequency => "1s" do
-            #_when :test => "${v:done} == true" do
-                _print "when triggered"
-            end
-            sequence do
-                _sleep "2s"
-                _set :variable => "done", :value => "true"
-                _print "done"
-            end
-        end
+  #def setup
+  #  @engine = $WORKFLOW_ENGINE_CLASS.new()
+  #end
+
+  #def teardown
+  #end
+
+  class RestartWhenDefinition0 < OpenWFE::ProcessDefinition
+    concurrence do
+      _when :test => "${v:done} == true", :frequency => "1s" do
+      #_when :test => "${v:done} == true" do
+        _print "when triggered"
+      end
+      sequence do
+        _sleep "2s"
+        _set :variable => "done", :value => "true"
+        _print "done"
+      end
     end
+  end
 
-    def test_0
-        dotest OpenWFE::FilePersistedEngine
-    end
-    def test_1
-        dotest OpenWFE::CachedFilePersistedEngine
-    end
+  def test_0
+    dotest OpenWFE::FilePersistedEngine
+  end
+  def test_1
+    dotest OpenWFE::CachedFilePersistedEngine
+  end
 
-    protected
+  protected
 
-        def dotest (engine_class)
+    def dotest (engine_class)
 
-            engine = new_engine engine_class
+      engine = new_engine engine_class
 
-            li = OpenWFE::LaunchItem.new RestartWhenDefinition0
+      li = OpenWFE::LaunchItem.new RestartWhenDefinition0
 
-            engine.launch li
+      engine.launch li
 
-            sleep 1
+      sleep 1
 
-            engine.stop
+      engine.stop
 
-            $OWFE_LOG.warn " === stopped the engine"
-            #display_pool :one
+      $OWFE_LOG.warn " === stopped the engine"
+      #display_pool :one
 
-            old_engine = engine
-            engine = new_engine engine_class
+      old_engine = engine
+      engine = new_engine engine_class
 
-            $OWFE_LOG.warn " === started the new engine"
-            #display_pool :two
+      $OWFE_LOG.warn " === started the new engine"
+      #display_pool :two
 
-            sleep 3 
-            #display_pool :three
+      sleep 3
+      #display_pool :three
 
-            s_old = old_engine.application_context["__tracer"].to_s
-            s_now = engine.application_context["__tracer"].to_s
+      s_old = old_engine.application_context["__tracer"].to_s
+      s_now = engine.application_context["__tracer"].to_s
 
-            #uts "__ s_old >>>#{s_old}<<<"
-            #uts "__ s_now >>>#{s_now}<<<"
+      #uts "__ s_old >>>#{s_old}<<<"
+      #uts "__ s_now >>>#{s_now}<<<"
 
-            assert \
-                (s_old == "" and s_now == "done\nwhen triggered"), 
-                "old : '#{s_old}'  /  new : '#{s_now}'  BAD for #{engine_class}"
+      assert \
+        (s_old == "" and s_now == "done\nwhen triggered"),
+        "old : '#{s_old}'  /  new : '#{s_now}'  BAD for #{engine_class}"
 
-            engine.stop
-        end
+      engine.stop
+    end
 
-        #def display_pool (msg)
-        #    puts 
-        #    puts ".... #{msg}"
-        #    puts `ls -R work`
-        #    puts 
-        #end
+    #def display_pool (msg)
+    #  puts
+    #  puts ".... #{msg}"
+    #  puts `ls -R work`
+    #  puts
+    #end
 
-        def new_engine (engine_class)
+    def new_engine (engine_class)
 
-            engine = engine_class.new :definition_in_launchitem_allowed => true
+      engine = engine_class.new :definition_in_launchitem_allowed => true
 
-            #$OWFE_LOG.level = Logger::DEBUG
+      #$OWFE_LOG.level = Logger::DEBUG
 
-            tracer = Tracer.new
-            engine.application_context["__tracer"] = tracer
+      tracer = Tracer.new
+      engine.application_context["__tracer"] = tracer
 
-            #engine.reschedule
-            engine.reload
+      #engine.reschedule
+      engine.reload
 
-            engine
-        end
+      engine
+    end
 
 end
 

data/test/ruby_procdef_test.rb

@@ -18,115 +18,115 @@ require 'openwfe/participants/storeparticipants'
 
 
 #
-# fighting bug at : 
+# 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
+  def setup
 
-        @engine = OpenWFE::CachedFilePersistedEngine.new(
-            :definition_in_launchitem_allowed => true)
+    @engine = OpenWFE::CachedFilePersistedEngine.new(
+      :definition_in_launchitem_allowed => true)
 
-        @engine.register_participant :alpha, OpenWFE::HashParticipant
-    end
+    @engine.register_participant :alpha, OpenWFE::HashParticipant
+  end
 
-    def teardown
+  def teardown
 
-        @engine.stop if @engine
-    end
+    @engine.stop if @engine
+  end
 
-    #
-    # TESTS
+  #
+  # TESTS
 
-    class Test0 < OpenWFE::ProcessDefinition
-        sequence do
-            alpha
-        end
+  class Test0 < OpenWFE::ProcessDefinition
+    sequence do
+      alpha
     end
+  end
 
-    def test_0
+  def test_0
 
-        fei0 = @engine.launch Test0
-        sleep 0.100
-        fei1 = @engine.launch Test0
-        sleep 0.200
+    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
+    stack0 = @engine.process_stack fei0.wfid
+    stack1 = @engine.process_stack fei1.wfid
 
-        assert_equal 3, stack0.size
-        assert_equal 3, stack1.size
+    assert_equal 3, stack0.size
+    assert_equal 3, stack1.size
 
-        assert_equal 4, count_files(fei0.wfid)
-        assert_equal 4, count_files(fei1.wfid)
+    assert_equal 4, count_files(fei0.wfid)
+    assert_equal 4, count_files(fei1.wfid)
 
-        @engine.cancel_process(fei0.wfid)
-        @engine.cancel_process(fei1.wfid)
+    @engine.cancel_process(fei0.wfid)
+    @engine.cancel_process(fei1.wfid)
 
-        sleep 0.350
-    end
+    sleep 0.350
+  end
 
 
-    TEST1 = """
+  TEST1 = """
 class Test1 < OpenWFE::ProcessDefinition
-    sequence do
-        alpha
-    end
+  sequence do
+    alpha
+  end
 end
-    """
+  """
 
-    def test_1
+  def test_1
 
-        fei0 = launch TEST1
-        sleep 0.100
-        fei1 = launch TEST1
-        sleep 0.200
+    fei0 = launch TEST1
+    sleep 0.100
+    fei1 = launch TEST1
+    sleep 0.200
 
-        assert_equal(
-            OpenWFE::ProcessDefinition::Test1,
-            OpenWFE::ProcessDefinition.extract_class(TEST1))
+    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
+    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 3, stack0.size
+    assert_equal 3, stack1.size
 
-        assert_equal 4, count_files(fei0.wfid)
-        assert_equal 4, count_files(fei1.wfid)
+    assert_equal 4, count_files(fei0.wfid)
+    assert_equal 4, count_files(fei1.wfid)
 
-        @engine.cancel_process(fei0.wfid)
-        @engine.cancel_process(fei1.wfid)
+    @engine.cancel_process(fei0.wfid)
+    @engine.cancel_process(fei1.wfid)
 
-        sleep 0.350
-    end
+    sleep 0.350
+  end
 
-    protected
+  protected
 
-        def launch (test_string)
+    def launch (test_string)
 
-            filename = "work/procdef.rb"
+      filename = "work/procdef.rb"
 
-            File.open(filename, "w") do |f|
-                f.puts test_string
-            end
-            @engine.launch filename
-        end
+      File.open(filename, "w") do |f|
+        f.puts test_string
+      end
+      @engine.launch filename
+    end
 
-        def count_files (wfid)
+    def count_files (wfid)
 
-            count = 0
+      count = 0
 
-            Find.find("work/expool/") do |path|
-                next unless path.match(wfid+"__.*\.yaml")
-                count += 1
-            end
+      Find.find("work/expool/") do |path|
+        next unless path.match(wfid+"__.*\.yaml")
+        count += 1
+      end
 
-            count
-        end
+      count
+    end
 
 end

data/test/rutest_utils.rb

@@ -11,26 +11,26 @@ 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
+  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
 
 #
@@ -38,19 +38,19 @@ end
 #
 def new_fei
 
-    fei = OpenWFE::FlowExpressionId.new
+  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.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
+  fei
 end
 
 #
@@ -58,6 +58,6 @@ end
 #
 def on_jruby?
 
-    (defined?(JRUBY_VERSION) != nil)
+  (defined?(JRUBY_VERSION) != nil)
 end
 

data/test/sec_test.rb

@@ -7,6 +7,8 @@
 # Tue Jan  2 13:14:37 JST 2007
 #
 
+require 'rubygems'
+
 require 'test/unit'
 
 require 'openwfe/workitem'
@@ -15,191 +17,190 @@ require 'openwfe/engine/engine'
 
 class SecTest < Test::Unit::TestCase
 
-    #def setup
-    #end
+  #def setup
+  #end
 
-    #def teardown
-    #end
+  #def teardown
+  #end
 
-    def test_sec_0
+  def test_sec_0
 
-        engine = OpenWFE::Engine.new
+    engine = OpenWFE::Engine.new
 
-        engine.ac[:ruby_eval_allowed] = true
-        engine.ac[:definition_in_launchitem_allowed] = true
+    engine.ac[:ruby_eval_allowed] = true
+    engine.ac[:definition_in_launchitem_allowed] = true
 
-        def0 = \
+    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 =
+  <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(
+        "exception : .:call, .:const, :File.. is excluded",
+        "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 =
+  <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>''' 
+  <sequence>
+    <reval>self.ac[:ruby_eval_allowed] = false</reval>
+    <reval>puts self.ac[:ruby_eval_allowed]</reval>
+  </sequence>
+</process-definition>'''
 
-        dotest(engine, def3)
+    dotest(engine, def3)
 
-        assert OpenWFE::grep(
-            "evaluation of ruby code is not allowed", "logs/openwferu.log")
+    assert OpenWFE::grep(
+      "evaluation of ruby code is not allowed", "logs/openwferu.log")
 
-        engine.stop
-    end
+    engine.stop
+  end
 
-    def test_sec_0b
+  def test_sec_0b
 
-        engine = OpenWFE::Engine.new
+    engine = OpenWFE::Engine.new
 
-        engine.ac[:ruby_eval_allowed] = true
-        engine.ac[:definition_in_launchitem_allowed] = true
+    engine.ac[:ruby_eval_allowed] = true
+    engine.ac[:definition_in_launchitem_allowed] = true
 
-        def1 =
+    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 =
+  <sequence>
+    <reval>
+      class Object
+        def my_name
+          "toto"
+        end
+      end
+      "stringobject".my_name
+    </reval>
+  </sequence>
+</process-definition>'''
+
+    dotest engine, def1
+
+    assert_equal(
+      2, # now and previously
+      OpenWFE::grep(
+        'is forbidden',
+        "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>''' 
+  <sequence>
+    <set field="f" value="${ruby:5*7}" />
+    <toto/>
+  </sequence>
+</process-definition>'''
 
-    def test_sec_1
+  def test_sec_1
 
-        value = nil
+    value = nil
 
-        engine = OpenWFE::Engine.new :definition_in_launchitem_allowed => true
+    engine = OpenWFE::Engine.new :definition_in_launchitem_allowed => true
 
-        engine.register_participant(:toto) do |workitem|
+    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.
+      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
+      value = "#{workitem.attributes.size}_#{workitem.f}"
+    end
 
-        engine.launch XMLDEF
+    engine.launch XMLDEF
 
-        sleep 0.350
+    sleep 0.350
 
-        assert_equal "3_", value
+    assert_equal "3_", value
 
-        engine.stop
-    end
-    
-    def test_sec_1b
+    engine.stop
+  end
 
-        value = nil
+  def test_sec_1b
 
-        engine = OpenWFE::Engine.new
+    value = nil
 
-        engine.register_participant(:toto) do |workitem|
+    engine = OpenWFE::Engine.new
 
-            workitem.attributes.delete("___map_type")
-                #
-                # if the xmlencoder was used in previous, this field
-                # might be set, removing it.
+    engine.register_participant(:toto) do |workitem|
 
-            value = "#{workitem.attributes.size}_#{workitem.f}"
-        end
+      workitem.attributes.delete("___map_type")
+        #
+        # if the xmlencoder was used in previous, this field
+        # might be set, removing it.
 
-        engine.ac[:ruby_eval_allowed] = true
-        engine.ac[:definition_in_launchitem_allowed] = true
+      value = "#{workitem.attributes.size}_#{workitem.f}"
+    end
 
-        engine.launch XMLDEF
+    engine.ac[:ruby_eval_allowed] = true
+    engine.ac[:definition_in_launchitem_allowed] = true
 
-        sleep 0.350
+    engine.launch XMLDEF
 
-        assert_equal "3_35", value
+    sleep 0.350
 
-        engine.stop
-    end
+    assert_equal "3_35", value
 
-    def test_sec_2
+    engine.stop
+  end
 
-        assert_equal 35, Rufus::eval_safely("5*7", 4)
-        assert_equal 35, Rufus::eval_safely("5*7", 4, binding())
-    end
+  def test_sec_2
 
-    protected
+    assert_not_nil OpenWFE::TreeChecker.new(nil, {}).check("5*7")
+  end
 
-        def dotest (engine, def_or_li)
+  protected
 
-            li = if def_or_li.is_a?(OpenWFE::LaunchItem)
-                def_or_li
-            else
-                OpenWFE::LaunchItem.new(def_or_li)
-            end
-            
-            engine.launch(li)
+    def dotest (engine, def_or_li)
 
-            sleep 0.350
-        end
+      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