ruote 0.9.19 → 0.9.20

data/test/{obs_test.rb → unit/ut_5_observable.rb}

@@ -1,28 +1,18 @@
 
 #
-# Testing OpenWFE
+# Testing Ruote (OpenWFEru)
 #
 # John Mettraux at openwfe.org
 #
 # Sun Oct 29 16:18:25 JST 2006
 #
 
-require 'test/unit'
+require File.dirname(__FILE__) + '/../test_helper.rb'
 
 require 'openwfe/util/observable'
 
 
-#
-# testing the observer module (mixin)
-#
-
-class ObsTest < Test::Unit::TestCase
-
-  #def setup
-  #end
-
-  #def teardown
-  #end
+class ObservableTest < Test::Unit::TestCase
 
   class Observed
     include OpenWFE::OwfeObservable
@@ -49,7 +39,7 @@ class ObsTest < Test::Unit::TestCase
 
     observer1 = Object.new
     class << observer1
-      def call channel, *args
+      def call (channel, *args)
         $s = 1
       end
     end
@@ -101,16 +91,16 @@ class ObsTest < Test::Unit::TestCase
     observed.add_observer :channel0 do
       $s = 0
     end
-    observed.add_observer "channel[0-9]+" do
+    observed.add_observer 'channel[0-9]+' do
       $s = 9
     end
 
     $s = nil
-    observed.onotify "channel2", :nothing
+    observed.onotify 'channel2', :nothing
     assert_equal $s, 9
 
     $s = nil
-    observed.onotify "channelZ", :nothing
+    observed.onotify 'channelZ', :nothing
     assert_nil $s
   end
 
@@ -119,10 +109,10 @@ class ObsTest < Test::Unit::TestCase
     observed = Observed.new
 
     o1 = observed.add_observer :channel0 do
-      puts "whatever"
+      puts 'whatever'
     end
     o2 = observed.add_observer :channel0 do
-      puts "whatever"
+      puts 'whatever'
     end
 
     assert_equal observed.observers.size, 1

data/test/unit/ut_6_treechecker.rb

@@ -0,0 +1,101 @@
+
+#
+# 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

@@ -0,0 +1,344 @@
+
+#
+# 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
+