ruote 0.9.19 → 0.9.20

data/test/ft_46_pparams.rb

@@ -1,62 +0,0 @@
-
-#
-# Testing OpenWFEru
-#
-# John Mettraux at openwfe.org
-#
-
-require 'flowtestbase'
-require 'openwfe/def'
-
-
-class FlowTest46 < Test::Unit::TestCase
-  include FlowTestBase
-
-  #def setup
-  #end
-
-  #def teardown
-  #end
-
-
-  #
-  # Test 0
-  #
-
-  class TestPTask46a0 < OpenWFE::ProcessDefinition
-    sequence do
-
-      participant :ref => :nemo, :description => "clean the desk"
-
-      _print "${f:description}"
-        # just checking that the description is wiped after usage
-
-      participant :ref => :nemo, :task => "force"
-
-      _print "${f:task}"
-    end
-  end
-
-  def test_0
-
-    @engine.register_participant :nemo do |workitem|
-      @tracer.puts workitem.params['ref']
-      @tracer.puts workitem.params['description']
-      @tracer.puts workitem.params['task']
-    end
-
-    dotest(
-      TestPTask46a0,
-      """
-nemo
-clean the desk
-
-
-nemo
-
-force
-      """.strip)
-  end
-
-end
-

data/test/ft_47_filter.rb

@@ -1,160 +0,0 @@
-
-#
-# Testing OpenWFEru
-#
-# John Mettraux at openwfe.org
-#
-
-require 'flowtestbase'
-require 'openwfe/def'
-
-
-class FlowTest47 < Test::Unit::TestCase
-  include FlowTestBase
-
-  #def setup
-  #end
-
-  #def teardown
-  #end
-
-
-  #
-  # Test 0
-  #
-
-  class TestFilter47a0 < OpenWFE::ProcessDefinition
-    sequence do
-      _print "${v0}"
-      _print "${v1}"
-      filter_definition :name => "filter1" do
-      end
-      _defined :variable => :filter0
-      _print "${f:__result__}"
-      _defined :variable => :filter1
-      _print "${f:__result__}"
-    end
-    filter_definition :name => "filter0" do
-    end
-    set :variable => "v0", :value => "toto"
-    set :variable => "v1", :value => "hector"
-  end
-
-  def test_0
-    dotest(
-      TestFilter47a0,
-      "toto\nhector\ntrue\ntrue")
-  end
-
-
-  #
-  # Test 1
-  #
-
-  class TestFilter47a1 < OpenWFE::ProcessDefinition
-    sequence do
-
-      set :field => "readable", :value => "bible"
-      set :field => "writable", :value => "sand"
-      set :field => "randw", :value => "notebook"
-      set :field => "hidden", :value => "playboy"
-
-      toto
-      toto :filter => "filter0"
-
-      _print "${f:readable}"
-      _print "${f:writable}"
-      _print "${f:randw}"
-      _print "${f:hidden}"
-    end
-
-    filter_definition :name => "filter0" do
-      field :regex => "readable", :permissions => "r"
-      field :regex => "writable", :permissions => "w"
-      field :regex => "randw", :permissions => "rw"
-      field :regex => "hidden", :permissions => ""
-    end
-  end
-
-  def test_1
-
-    @engine.register_participant :toto do |workitem|
-
-      @tracer << "filter.size is #{workitem.filter.fields.size}\n" \
-        if workitem.filter
-
-      @tracer << "r  : #{workitem.attributes['readable']}\n"
-      @tracer << "w  : #{workitem.attributes['writable']}\n"
-      @tracer << "rw : #{workitem.attributes['randw']}\n"
-      @tracer << "h  : #{workitem.attributes['hidden']}\n"
-      @tracer << "--\n"
-    end
-
-    dotest(
-      TestFilter47a1,
-      """
-r  : bible
-w  : sand
-rw : notebook
-h  : playboy
---
-filter.size is 4
-r  : bible
-w  : 
-rw : notebook
-h  : 
---
-bible
-sand
-notebook
-playboy
-      """.strip)
-  end
-
-
-  #
-  # Test 2
-  #
-
-  class TestFilter47a2 < OpenWFE::ProcessDefinition
-    sequence do
-
-      set :field => "readable", :value => "bible"
-      set :field => "writable", :value => "sand"
-      set :field => "randw", :value => "notebook"
-      set :field => "hidden", :value => "playboy"
-
-      alice :filter => "filter0"
-      pp_fields
-    end
-
-    filter_definition :name => "filter0" do
-      field :regex => "readable", :permissions => "r"
-      field :regex => "writable", :permissions => "w"
-      field :regex => "randw", :permissions => "rw"
-      field :regex => "hidden", :permissions => ""
-    end
-  end
-
-  def test_2
-
-    @engine.register_participant :alice do |workitem|
-      workitem.readable = "nada"
-      workitem.writable = "nada"
-      workitem.randw = "nada"
-      workitem.hidden = "nada"
-    end
-
-    dotest(
-      TestFilter47a2,
-      """
-hidden: playboy
-randw: nada
-readable: bible
-writable: nada
---
-      """.strip)
-  end
-
-end
-

data/test/ft_48_fe_filter.rb

@@ -1,88 +0,0 @@
-
-#
-# Testing OpenWFEru
-#
-# John Mettraux at openwfe.org
-#
-
-require 'flowtestbase'
-require 'openwfe/def'
-
-
-class FlowTest48 < Test::Unit::TestCase
-  include FlowTestBase
-
-  #def setup
-  #end
-
-  #def teardown
-  #end
-
-
-  #
-  # Test 0
-  #
-
-  class TestFilter48a0 < OpenWFE::ProcessDefinition
-    sequence do
-
-      set :field => "readable", :value => "bible"
-      set :field => "writable", :value => "sand"
-      set :field => "randw", :value => "notebook"
-      set :field => "hidden", :value => "playboy"
-
-      alice
-
-      filter :name => "filter0" do
-        alice
-      end
-
-      alice
-    end
-
-    filter_definition :name => "filter0" do
-      field :regex => "readable", :permissions => "r"
-      field :regex => "writable", :permissions => "w"
-      field :regex => "randw", :permissions => "rw"
-      field :regex => "hidden", :permissions => ""
-    end
-  end
-
-  def test_0
-
-    @engine.register_participant :alice do |workitem|
-
-      @tracer << "filter.size is #{workitem.filter.fields.size}\n" \
-        if workitem.filter
-
-      @tracer << "r  : #{workitem.attributes['readable']}\n"
-      @tracer << "w  : #{workitem.attributes['writable']}\n"
-      @tracer << "rw : #{workitem.attributes['randw']}\n"
-      @tracer << "h  : #{workitem.attributes['hidden']}\n"
-      @tracer << "--\n"
-    end
-
-    dotest(
-      TestFilter48a0,
-      """
-r  : bible
-w  : sand
-rw : notebook
-h  : playboy
---
-filter.size is 4
-r  : bible
-w  : 
-rw : notebook
-h  : 
---
-r  : bible
-w  : sand
-rw : notebook
-h  : playboy
---
-      """.strip)
-  end
-
-end
-

data/test/ft_49_condition.rb

@@ -1,133 +0,0 @@
-
-#
-# Testing OpenWFEru
-#
-# John Mettraux at openwfe.org
-#
-
-require 'flowtestbase'
-require 'openwfe/def'
-
-
-class FlowTest49 < Test::Unit::TestCase
-  include FlowTestBase
-
-  #def setup
-  #end
-
-  #def teardown
-  #end
-
-
-  #
-  # Test 0
-  #
-
-  class TestCondition49a0 < OpenWFE::ProcessDefinition
-    sequence do
-
-      _if :test => "false"
-      _print "0 ${f:__result__}"
-
-      _if :test => "true; false"
-      _print "1 ${f:__result__}"
-
-      _if :test => "false; true"
-      _print "2 ${f:__result__}"
-
-      #_if :test => "print ''; true"
-      _if :test => "''; true"
-      _print "3 ${f:__result__}"
-
-      #_if :test => "begin print ''; end; true"
-      _if :test => "begin ''; end; true"
-      _print "4 ${f:__result__}"
-
-      unset :field => "__result__"
-
-      _if :test => "true == "
-      _print "5 ${f:__result__}"
-      _if :test => " == true"
-      _print "6 ${f:__result__}"
-    end
-  end
-
-  def test_0
-
-    log_level_to_debug
-
-    dotest(
-      TestCondition49a0,
-      [ "0 false",
-        "1 true",
-        "2 true",
-        "3 true",
-        "4 true",
-        "5 false",
-        "6 false" ].join("\n"))
-  end
-
-
-  #
-  # Test 1
-  #
-
-  class TestCondition49a1 < OpenWFE::ProcessDefinition
-    sequence do
-      _if :test => "true and false and false"
-      _print "0 ${f:__result__}"
-      _if :rtest => "true and true and true"
-      _print "1 ${f:__result__}"
-      _if :rtest => "false or false or true"
-      _print "2 ${f:__result__}"
-    end
-  end
-
-  def test_1
-
-    dotest(
-      TestCondition49a1,
-      [ "0 false", "1 true", "2 true" ].join("\n"))
-  end
-
-
-  #
-  # Test 2
-  #
-
-  class TestCondition49a2 < OpenWFE::ProcessDefinition
-    sequence do
-      _if :test => "true"
-      _print "0 ${f:__result__}"
-      _if :not => "false"
-      _print "1 ${f:__result__}"
-      _if :rnot => "1 > 3"
-      _print "2 ${f:__result__}"
-
-      unset :field => "__result__"
-
-      _if :rnot => "1 > -1"
-      _print "3 ${f:__result__}"
-
-      _if :rtest => "workitem.is_a?(String)"
-      _print "4 ${f:__result__}"
-
-      _if :rtest => "wi.is_a?(InFlowWorkItem)"
-      _print "5 ${f:__result__}"
-    end
-  end
-
-  def test_2
-
-    dotest(
-      TestCondition49a2,
-      [ "0 true",
-        "1 true",
-        "2 true",
-        "3 false",
-        "4 false",
-        "5 true" ].join("\n"))
-  end
-
-end
-

data/test/ft_4_misc.rb

@@ -1,232 +0,0 @@
-
-#
-# Testing OpenWFE
-#
-# John Mettraux at openwfe.org
-#
-# Mon Oct  9 22:19:44 JST 2006
-#
-
-require 'flowtestbase'
-
-
-class FlowTest4 < Test::Unit::TestCase
-  include FlowTestBase
-
-  #def setup
-  #end
-
-  #def teardown
-  #end
-
-  def test_print_0
-    dotest(
-'''<process-definition name="print_0" revision="0">
-  <sequence>
-    <print escape="true">${f:xxx}</print>
-  </sequence>
-</process-definition>''', "${f:xxx}")
-  end
-
-  class TestPrint1 < OpenWFE::ProcessDefinition
-    sequence do
-      _set :v => "toto", :value => '0'
-      _print "${toto}"
-      _print "${toto}", :escape => false
-      _print "${toto}", :escape => true
-    end
-  end
-  def test_print_1
-    dotest TestPrint1, "0\n0\n${toto}"
-  end
-
-  def test_reval_0
-    dotest(
-'''<process-definition name="reval_0" revision="0">
-  <sequence>
-    <reval><![CDATA[
-      workitem.attributes["from_ruby"] = "ok"
-    ]]></reval>
-    <print>${f:from_ruby}</print>
-  </sequence>
-</process-definition>''', "ok")
-  end
-
-  def test_reval_1
-    dotest(
-'''<process-definition name="reval_1" revision="0">
-  <sequence>
-    <set variable="field-name" value="from_ruby" />
-    <reval>
-      workitem.attributes["${field-name}"] = "ok"
-    </reval>
-    <print>${f:${field-name}}</print>
-  </sequence>
-</process-definition>''', "ok")
-  end
-
-  def test_reval_2
-    dotest(
-'''<process-definition name="reval_2" revision="0">
-  <sequence>
-    <set variable="field-value" value="ok" />
-    <reval>
-      workitem.attributes["from_ruby"] = "${field-value}"
-    </reval>
-    <print>${f:from_ruby}</print>
-  </sequence>
-</process-definition>''', "ok")
-  end
-
-  def test_reval_3
-    dotest(
-'''<process-definition name="reval_3" revision="0">
-  <sequence>
-    <set variable="v">
-      <reval code="1 == 2" />
-    </set>
-    <print>${v}</print>
-  </sequence>
-</process-definition>''', "false")
-  end
-
-   class Reval4 < OpenWFE::ProcessDefinition
-     _print do
-       reval "sv('i', 0); 1"
-     end
-   end
-   def test_reval_4
-     dotest Reval4, '1'
-   end
-
-  #class Reval5 < OpenWFE::ProcessDefinition
-  #  sequence do
-  #    reval """
-  #      wi.customer_name = 'dubious'
-  #      'surf'
-  #    """
-  #    _print "${f:__result__}"
-  #    _print "${f:customer_name}"
-  #  end
-  #end
-  #def test_reval_5
-  #  dotest Reval5, "surf\ndubious"
-  #end
-
-  class Reval6 < OpenWFE::ProcessDefinition
-    sequence do
-      set :field => "f0", :value => "3 + 2 + 2"
-      set :field => "f1" do
-        reval :field_code => "f0"
-      end
-      _print "${f:f1}"
-
-      set :variable => "v0", :value => "5 - 5"
-      set :variable => "v1" do
-        reval :variable_code => "v0"
-      end
-      _print "${v1}"
-    end
-  end
-
-  def test_reval_6
-    #log_level_to_debug
-    dotest Reval6, "7\n0"
-  end
-
-  #
-  # DRU tests
-
-  def test_dru_0
-    dotest(
-'''<process-definition name="dru_0" revision="0">
-  <sequence>
-    <print>${r:1+2}</print>
-  </sequence>
-</process-definition>''', "3")
-  end
-
-  def test_dru_1
-    dotest(
-'''<process-definition name="dru_1" revision="0">
-  <sequence>
-    <print>${r:"x"*3}</print>
-  </sequence>
-</process-definition>''', "xxx")
-  end
-
-  def test_dru_2
-    dotest(
-'''<process-definition name="dru_2" revision="0">
-  <sequence>
-    <set
-      variable="v"
-      value="${r:5*2}"
-    />
-    <print>${v}</print>
-  </sequence>
-</process-definition>''', "10")
-  end
-
-  def test_dru_3
-    dotest(
-'''<process-definition name="dru_3" revision="0">
-  <sequence>
-    <set variable="w" value="W" />
-    <set variable="v">
-      <!--
-      <reval>self.lookup_variable("w") * 3</reval>
-      <reval>lookup_variable("w") * 3</reval>
-      -->
-      <reval>"W" * 3</reval>
-    </set>
-    <print>${v}</print>
-  </sequence>
-</process-definition>''', "WWW")
-  end
-
-  def test_dru_4
-    dotest(
-'''<process-definition name="dru_4" revision="0">
-  <sequence>
-    <set variable="v">
-      <reval>fei.workflow_definition_name</reval>
-    </set>
-    <print>${v}</print>
-
-    <print>${r:fei.workflow_definition_name}</print>
-  </sequence>
-</process-definition>''', """dru_4
-dru_4""")
-  end
-
-  class TestSetEscape0 < OpenWFE::ProcessDefinition
-    sequence do
-      _set :v => "t0" do
-        "This is ${my template}"
-      end
-      _set :v => "t1", :escape => true do
-        "This is ${my template}"
-      end
-      _set :v => "t2", :val => "This is ${my template}", :escape => "true"
-      peek
-      #_print { v "t0" }
-      #_print { v "t1" }
-    end
-  end
-  def test_set_escape_0
-    @engine.register_participant :peek do |fexp, wi|
-      @tracer << fexp.get_environment.variables['t0']
-      @tracer << "\n"
-      @tracer << fexp.get_environment.variables['t1']
-      @tracer << "\n"
-      @tracer << fexp.get_environment.variables['t2']
-      @tracer << "\n"
-    end
-    dotest(
-      TestSetEscape0,
-      "This is \nThis is ${my template}\nThis is ${my template}")
-  end
-
-end
-