ruote 0.9.20 → 2.1.1

data/test/unit/ut_5_observable.rb

@@ -1,132 +0,0 @@
-
-#
-# Testing Ruote (OpenWFEru)
-#
-# John Mettraux at openwfe.org
-#
-# Sun Oct 29 16:18:25 JST 2006
-#
-
-require File.dirname(__FILE__) + '/../test_helper.rb'
-
-require 'openwfe/util/observable'
-
-
-class ObservableTest < Test::Unit::TestCase
-
-  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/unit/ut_6_treechecker.rb

@@ -1,101 +0,0 @@
-
-#
-# Testing Ruote (OpenWFEru)
-#
-# John Mettraux at openwfe.org
-#
-# Mon May 12 14:12:54 JST 2008
-#
-
-require File.dirname(__FILE__) + '/../test_helper.rb'
-
-require 'openwfe/util/treechecker'
-require 'openwfe/expressions/rprocdef'
-
-
-class TreeCheckerTest < Test::Unit::TestCase
-
-  def test_0
-
-    assert_safe :check, '1+1'
-    assert_unsafe :check, 'exit'
-    assert_unsafe :check, 'puts $BATEAU'
-    assert_unsafe :check, 'def surf }'
-    assert_unsafe :check, 'abort'
-    assert_unsafe :check, "abort; puts 'ok'"
-    assert_unsafe :check, "puts 'ok'; abort"
-
-    assert_unsafe :check, 'exit 0'
-    assert_unsafe :check, "system('whatever')"
-
-    assert_unsafe :check, 'alias :a :b'
-    assert_unsafe :check, 'alias_method :a :b'
-
-    assert_unsafe :check, "File.open('x')"
-    assert_unsafe :check, "FileUtils.rm('x')"
-
-    assert_unsafe :check, "eval 'nada'"
-    assert_unsafe :check, "M.module_eval 'nada'"
-    assert_unsafe :check, "o.instance_eval 'nada'"
-  end
-
-  def test_1
-
-    assert_safe :check_conditional, '1 == 1'
-    assert_unsafe :check_conditional, "puts 'ok'; 1 == 1"
-    assert_unsafe :check_conditional, 'exit'
-
-    assert_unsafe :check_conditional, 'a = 2'
-  end
-
-  def test_2
-
-    assert_safe :check, "class Toto < OpenWFE::ProcessDefinition\nend"
-    assert_unsafe :check, "class String\nend"
-    assert_unsafe :check, "module Whatever\nend"
-    assert_unsafe :check, "class << e\nend"
-  end
-
-  def test_3
-
-    assert_unsafe :check, 'trap'
-    assert_unsafe :check, 'Kernel.trap'
-    assert_unsafe :check, 'k = Kernel; k.trap'
-    assert_unsafe :check, 'k = Kernel; k.trap(x)'
-    assert_unsafe :check, 'k = ::Kernel; k.trap(x)'
-  end
-
-  protected
-
-  def assert_safe (check_method, code)
-
-    assert check(check_method, code)
-  end
-
-  def assert_unsafe (check_method, code)
-
-    assert (not check(check_method, code))
-  end
-
-  def check (check_method, code)
-
-    begin
-
-      tc = OpenWFE::TreeChecker.new(nil, {})
-      #tc.instance_variable_get(:@checker).ptree code
-      #puts "\n==="
-      #puts tc.instance_variable_get(:@checker)
-      #puts "==="
-      #puts tc.instance_variable_get(:@cchecker)
-      tc.send check_method, code
-
-    rescue Exception => e
-      #puts "caught..."
-      #puts ":: #{e}"
-      #puts e.backtrace
-      return false
-    end
-
-    true
-  end
-end

data/test/unit/ut_7_parser_ruby.rb

@@ -1,344 +0,0 @@
-
-#
-# Testing Ruote (OpenWFEru)
-#
-# John Mettraux at openwfe.org
-#
-# Mon Oct  9 22:19:44 JST 2006
-#
-
-require File.dirname(__FILE__) + '/../test_helper.rb'
-
-require 'openwfe/def'
-require 'openwfe/expool/def_parser'
-
-
-class ParserRubyTest < Test::Unit::TestCase
-
-  XML_0 = %(
-<process-definition name='test0' revision='0'>
-<sequence>
-<participant ref='a'/>
-<participant ref='b'/>
-</sequence>
-</process-definition>
-  ).strip.gsub(/\n/, '')
-
-  class TestDefinition < OpenWFE::ProcessDefinition
-    def make
-      process_definition :name => 'test0', :revision => '0' do
-        sequence do
-          participant :ref => 'a'
-          participant :ref => 'b'
-        end
-      end
-    end
-  end
-
-  def test_0
-
-    s = OpenWFE::ExpressionTree.to_s(TestDefinition.new.make)
-
-    assert_equal XML_0, s
-  end
-
-  def test_1
-
-    #s = TestDefinition.do_make.to_s
-    s = OpenWFE::ExpressionTree.to_s(TestDefinition.do_make)
-
-    assert_equal XML_0, s
-  end
-
-  def test_2
-
-    pg = OpenWFE::ProcessDefinition.new
-
-    class << pg
-      def my_proc
-        process_definition :name => "test0", :revision => "0" do
-          sequence do
-            participant :ref => "a"
-            participant :ref => "b"
-          end
-        end
-      end
-    end
-    pdef = pg.my_proc
-    s = pdef.to_s
-
-    assert XML_0, s
-  end
-
-  class TestDefinition3 < OpenWFE::ProcessDefinition
-    def make
-      process_definition :name => 'test2', :revision => '0' do
-        sequence do
-          set :field => 'toto' do
-            'nada'
-          end
-          participant :ref => 'b'
-        end
-      end
-    end
-  end
-
-  XML_3 = %{
-<process-definition name='test2' revision='0'>
-<sequence>
-<set field='toto'>
-nada
-</set>
-<participant ref='b'/>
-</sequence>
-</process-definition>
-  }.strip.gsub(/\n/, '')
-
-  def test_3
-
-    s = OpenWFE::ExpressionTree.to_s(TestDefinition3.do_make)
-
-    assert_equal XML_3, s
-
-    #puts
-    #puts TestDefinition2.do_make.to_code_s
-  end
-
-  class TestDefinition4 < OpenWFE::ProcessDefinition
-    def make
-      process_definition :name => "test4", :revision => "0" do
-        _if do
-          equals :field_value => "nada", :other_value => "surf"
-          participant :ref => "b"
-        end
-      end
-    end
-  end
-
-  XML_4 =
-    "<process-definition name='test4' revision='0'>"+
-    "<if>"+
-    "<equals field-value='nada' other-value='surf'/>"+
-    "<participant ref='b'/>"+
-    "</if>"+
-    "</process-definition>"
-
-  CODE_4 = %{
-process_definition :name => "test4", :revision => "0" do
-  _if do
-    equals :field_value => "nada", :other_value => "surf"
-    participant :ref => "b"
-  end
-end
-  }.strip
-
-  def test_4
-
-    s = OpenWFE::ExpressionTree.to_s(TestDefinition4.do_make)
-
-    assert_equal(XML_4, s)
-
-    assert_equal(
-      CODE_4,
-      OpenWFE::ExpressionTree.to_code_s(TestDefinition4.do_make))
-
-    r = OpenWFE::DefParser.parse(s)
-
-    assert_equal(CODE_4, OpenWFE::ExpressionTree.to_code_s(r))
-  end
-
-  class TestDefinition5 < OpenWFE::ProcessDefinition
-    def make
-      process_definition :name => 'test5', :revision => '0' do
-        sequence do
-          3.times { participant :ref => 'b' }
-        end
-      end
-    end
-  end
-
-  CODE_5 = %{
-process_definition :name => "test5", :revision => "0" do
-  sequence do
-    participant :ref => "b"
-    participant :ref => "b"
-    participant :ref => "b"
-  end
-end}.strip
-
-  def test_5
-
-    assert_equal(
-      CODE_5,
-      OpenWFE::ExpressionTree.to_code_s(TestDefinition5.do_make))
-  end
-
-  class TestDefinition6 < OpenWFE::ProcessDefinition
-    def make
-      sequence do
-        [ :b, :b, :b ].each do |p|
-          participant p
-        end
-      end
-    end
-  end
-
-  CODE_6 = %{
-process_definition :name => "Test", :revision => "6" do
-  sequence do
-    participant 'b'
-    participant 'b'
-    participant 'b'
-  end
-end
-  }.strip
-
-  def test_6
-
-    assert_equal(
-      CODE_6,
-      OpenWFE::ExpressionTree.to_code_s(TestDefinition6.do_make))
-  end
-
-  class TestDefinition7 < OpenWFE::ProcessDefinition
-    def make
-      sequence do
-        participant :ref => :toto
-        sub0
-      end
-      process_definition :name => 'sub0' do
-        nada
-      end
-    end
-  end
-
-  CODE_7 = %{
-process_definition :name => "Test", :revision => "7" do
-  sequence do
-    participant :ref => :toto
-    sub0
-  end
-  process_definition :name => "sub0" do
-    nada
-  end
-end
-  }.strip
-
-  def test_7
-
-    assert_equal(
-      CODE_7,
-      OpenWFE::ExpressionTree.to_code_s(TestDefinition7.do_make))
-  end
-
-  class TestDefinition8 < OpenWFE::ProcessDefinition
-    def make
-      sequence do
-        participant :ref => :toto
-        nada
-      end
-    end
-  end
-
-  CODE_8 = %{
-process_definition :name => "Test", :revision => "8" do
-  sequence do
-    participant :ref => :toto
-    nada
-  end
-end
-  }.strip
-
-  def test_8
-
-    assert_equal(
-      CODE_8,
-      OpenWFE::ExpressionTree.to_code_s(TestDefinition8.do_make))
-  end
-
-  class TestDefinition9 < OpenWFE::ProcessDefinition
-    def make
-      participant :ref => :toto
-    end
-  end
-
-  CODE_9 = %{
-process_definition :name => "Test", :revision => "9" do
-  participant :ref => :toto
-end
-  }.strip
-
-  TREE_9 = [
-    'process-definition',
-    { 'name'=>'Test', 'revision'=>'9' },
-    [ [ 'participant', { 'ref' => :toto }, [] ] ]
-  ]
-
-  def test_9
-
-    assert_equal(
-      CODE_9,
-      OpenWFE::ExpressionTree.to_code_s(TestDefinition9.do_make))
-
-    assert_equal(
-      TREE_9,
-      TestDefinition9.do_make)
-  end
-
-  JSON_10 = %{
-    ["process-definition",{"name":"mydef","revision":"0"},["alpha",{},[]]]
-  }.strip
-
-  def test_10
-
-    require 'json'
-
-    assert_equal(
-      ["process-definition", {"name"=>"mydef", "revision"=>"0"}, ["alpha", {}, []]],
-      OpenWFE::DefParser.parse(JSON_10))
-  end
-
-  YAML_11 = "--- \n- process-definition\n- name: mydef\n  revision: \"0\"\n- - alpha\n  - {}\n\n  - []\n\n"
-
-  def test_11
-
-    assert_equal(
-      ["process-definition", {"name"=>"mydef", "revision"=>"0"}, ["alpha", {}, []]],
-      OpenWFE::DefParser.parse(YAML_11))
-  end
-
-  class TestDefinition12 < OpenWFE::ProcessDefinition
-    set_fields :value => { 'type' => 'horse' }
-  end
-
-  #class TestDefinition12b < OpenWFE::ProcessDefinition
-  #  set_fields do
-  #    { 'type' => 'horse' }
-  #  end
-  #end
-    #
-    # TODO : wire me back in
-
-  def test_12
-
-    assert_equal(
-      %{process_definition :name => "Test", :revision => "12" do
-  set_fields :value => {"type"=>"horse"}
-end},
-      OpenWFE::ExpressionTree.to_code_s(TestDefinition12.do_make))
-
-    assert_equal(
-      %{<process-definition name='Test' revision='12'><set-fields><hash><entry><string>type</string><string>horse</string></entry></hash></set-fields></process-definition>},
-      OpenWFE::ExpressionTree.to_xml(TestDefinition12.do_make).to_s)
-  end
-
-  def test_13
-
-    assert_equal(
-      "error 'sthing went wrong', :if => \"${f:surf}\"",
-      OpenWFE::ExpressionTree.to_code_s(
-        [ 'error', { 'if' => '${f:surf}' }, [ 'sthing went wrong' ] ]))
-  end
-
-end
-