ruote-maestrodev 2.2.1

data/test/unit/test.rb

@@ -0,0 +1,28 @@
+
+#
+# testing ruote
+#
+# since Mon Oct  9 22:19:44 JST 2006
+#
+
+def l (t)
+
+  if ARGV.include?('--split')
+
+    _v = ARGV.include?('-v') ? ' -v' : ' '
+
+    puts
+    puts "=== #{t} :"
+    puts `ruby#{_v} #{t} #{ARGV.join(' ')}`
+
+    exit $?.exitstatus if $?.exitstatus != 0
+  else
+    load(t)
+  end
+end
+
+load File.join(File.dirname(__FILE__), 'storage.rb')
+
+Dir.glob(File.join(File.dirname(__FILE__), 'ut_*.rb')).sort.each { |t| l(t) }
+Dir.glob(File.join(File.dirname(__FILE__), 'hut_*.rb')).sort.each { |t| l(t) }
+

data/test/unit/ut_0_ruby_reader.rb

@@ -0,0 +1,223 @@
+
+#
+# testing ruote
+#
+# Tue May 12 15:31:26 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+require 'ruote/reader'
+
+
+class UtRubyReaderTest < Test::Unit::TestCase
+
+  #def test_whatever
+  #  tree = Ruote.define do
+  #    set "f:x" => 12
+  #  end
+  #  p tree
+  #end
+
+  def test_sequence
+
+    tree = Ruote.define :name => 'nada' do
+      sequence do
+        participant :ref => :alpha
+        bravo
+      end
+    end
+
+    assert_equal(
+      ["define", {"name"=>"nada"}, [
+        ["sequence", {}, [
+          ["participant", {"ref"=>"alpha"}, []], ["bravo", {}, []]]]]],
+      tree)
+  end
+
+  def test_empty_sub
+
+    tree = Ruote.define :name => 'nada' do
+      sequence do
+        alpha
+        bravo
+      end
+      define 'toto' do
+      end
+    end
+
+    assert_equal(
+      ["define", {"name"=>"nada"}, [
+        ["sequence", {}, [["alpha", {}, []], ["bravo", {}, []]]],
+        ["define", {"toto"=>nil}, []]
+      ]],
+      tree)
+  end
+
+  def test_echo
+
+    tree = Ruote.define :name => 'nada' do
+      echo 'a'
+    end
+
+    assert_equal(
+      ["define", {"name"=>"nada"}, [
+        ["echo", {"a"=>nil}, []]
+      ]],
+      tree)
+  end
+
+  def test_echo_with_escape
+
+    tree = Ruote.define :name => 'nada' do
+      echo 'a', :escape => true
+    end
+
+    assert_equal(
+      ["define", {"name"=>"nada"}, [
+        ["echo", {"a"=>nil, "escape"=>true}, []]
+      ]],
+      tree)
+  end
+
+  def test_set
+
+    tree = Ruote.define :name => 'nada' do
+      set :var => 'v', :val => %w[ 1 2 3 4 ]
+    end
+
+    assert_equal(
+      ["define", {"name"=>"nada"}, [
+        ["set", {"val"=>["1", "2", "3", "4"], "var"=>"v"}, []]
+      ]],
+      tree)
+  end
+
+  #def test_set_nested
+  #  tree = Ruote.define :name => 'nada' do
+  #    set do
+  #      %w[ 1 2 3 4 ]
+  #    end
+  #  end
+  #  assert_equal(
+  #    ["define", {"name"=>"nada"}, [
+  #      ["sequence", {}, [["alpha", {}, []], ["bravo", {}, []]]]
+  #    ]],
+  #    tree)
+  #end
+
+  def test_escaping_ruby_keywords
+
+    tree = Ruote.define do
+      _redo 'nada'
+    end
+
+    assert_equal(
+      ["define", {}, [["redo", {"nada"=>nil}, []]]],
+      tree)
+  end
+
+  def test_to_tree
+
+    assert_equal(
+      [ 'sequence', {}, [ [ 'alpha', {}, [] ], [ 'bravo', {}, [] ] ] ],
+      Ruote.to_tree { sequence { alpha; bravo } })
+  end
+
+  def test_treechecker
+
+    #assert_raise Nada do
+      Ruote::Reader.read %{ Ruote.define { alpha } }
+    #end
+
+    assert_raise Ruote::Reader::Error do
+      Ruote::Reader.read %{ Ruote.define { abort } }
+    end
+    assert_raise Ruote::Reader::Error do
+      Ruote::Reader.read %{ Ruote.define { exit } }
+    end
+    assert_raise Ruote::Reader::Error do
+      Ruote::Reader.read %{ Ruote.define { exit! } }
+    end
+
+    assert_raise Ruote::Reader::Error do
+      Ruote::Reader.read %{ Ruote.define { x = Kernel } }
+    end
+
+    assert_raise Ruote::Reader::Error do
+      Ruote::Reader.read %{ Ruote.define { module Nada; end } }
+    end
+
+    assert_raise Ruote::Reader::Error do
+      Ruote::Reader.read %{ Ruote.define { File.read('stuff') } }
+    end
+
+    assert_raise Ruote::Reader::Error do
+      Ruote::Reader.read %{ Ruote.define { at_exit { } } }
+    end
+
+    assert_raise Ruote::Reader::Error do
+      Ruote::Reader.read %{ Ruote.define { def nada; end } }
+    end
+  end
+
+  def test_attribute_text_regexp
+
+    tree = Ruote.define do
+      given "${target}" do
+        of "/^employee-/" do
+        end
+        of /^customer-/ do
+        end
+      end
+    end
+
+    assert_equal(
+      ["define", {}, [
+        ["given", {"${target}"=>nil}, [
+          ["of", {"/^employee-/"=>nil}, []],
+          ["of", {"/^customer-/"=>nil}, []]]]]],
+      tree)
+  end
+
+  def test_attribute_value_regexp
+
+    tree = Ruote.define do
+      subprocess 'alpha', :match => /^nada$/
+    end
+
+    assert_equal(
+      ["define", {}, [["subprocess", {"alpha"=>nil, "match"=>"/^nada$/"}, []]]],
+      tree)
+  end
+
+  def test_attribute_value_regexp_deep
+
+    tree = Ruote.define do
+      alpha :filter => { :in => [ { :field => /^private_/ } ] }
+    end
+
+    assert_equal(
+      [ "define", {}, [
+        [ "alpha", { "filter" => { "in" => [ { "field" => '/^private_/' } ] } }, [] ]
+      ] ],
+      tree)
+  end
+
+  def test_proc
+
+    tree = Ruote.define do
+      set 'v:v' => "lambda { |wi| p wi }\n"
+      set 'v:v' => lambda { |wi| p wi }
+      set 'v:v' => { 'on_workitem' => lambda { |wi| p wi } }
+    end
+
+    assert_equal(
+      [ 'define', {}, [
+        [ 'set', { 'v:v' => "lambda { |wi| p wi }\n" }, [] ],
+        [ 'set', { 'v:v' => "proc { |wi| p wi }\n" }, [] ],
+        [ 'set', { 'v:v' => { 'on_workitem' => "proc { |wi| p wi }\n" } }, [] ] ] ],
+      tree)
+  end
+end
+

data/test/unit/ut_11_lookup.rb

@@ -0,0 +1,122 @@
+
+#
+# testing ruote
+#
+# Mon Aug  3 19:19:58 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+require 'ruote/util/lookup'
+
+
+class LookupTest < Test::Unit::TestCase
+
+  def test_lookup
+
+    assert_equal(%w[ A B C ], Ruote.lookup({ 'h' => %w[ A B C ] }, 'h'))
+    assert_equal('B', Ruote.lookup({ 'h' => %w[ A B C ] }, 'h.1'))
+  end
+
+  def test_lookup_dot
+
+    h = { 'a' => 'b' }
+
+    assert_equal h, Ruote.lookup(h, '.')
+  end
+
+  def test_container_lookup
+
+    assert_equal(
+      %w[ A B C ],
+      Ruote.lookup({ 'h' => { 'hh' => %w[ A B C ]} }, 'h.hh', false))
+    assert_equal(
+      [ 'hh', { 'hh' => %w[ A B C ] } ],
+      Ruote.lookup({ 'h' => { 'hh' => %w[ A B C ]} }, 'h.hh', true))
+  end
+
+  def test_deep_container_lookup
+
+    h = { 'foo' => { 'bar' => { 'baz' => { 'fruit' => 'pineapple' } } } }
+
+    assert_equal(
+      "pineapple",
+      Ruote.lookup(h, 'foo.bar.baz.fruit', false))
+    assert_equal(
+      [ 'fruit', { 'fruit' => 'pineapple' } ],
+      Ruote.lookup(h, 'foo.bar.baz.fruit', true))
+  end
+
+  def test_missing_container_lookup
+
+    assert_equal(
+      [ 'nada', nil ],
+      Ruote.lookup({ 'h' => { 'hh' => %w[ A B C ]} }, 'nada.nada', true))
+  end
+
+  def test_set
+
+    h = { 'customer' => { 'name' => 'alpha' } }
+    Ruote.set(h, 'customer.name', 'bravo')
+
+    assert_equal({"customer"=>{"name"=>"bravo"}}, h)
+  end
+
+  # courtesy of Nando Sola
+  #
+  def test_deep_set
+
+    h = { 'foo' => { 'bar' => { 'baz' => { 'fruit' => 'pineapple' } } } }
+
+    Ruote.set(h, 'foo.bar.baz.fruit', 'orange')
+
+    assert_equal(
+      { "foo" => { "bar" => { "baz" => { "fruit" => "orange" } } } },
+      h)
+  end
+
+  def test_set_missing
+
+    h = {}
+    Ruote.set(h, 'customer.name', 'bravo')
+
+    assert_equal({"customer.name"=>"bravo"}, h)
+  end
+
+  def test_hash_unset
+
+    h = { 'customer' => { 'name' => 'alpha', 'rank' => '1st' } }
+    r = Ruote.unset(h, 'customer.rank')
+
+    assert_equal('1st', r)
+    assert_equal({ 'customer' => { 'name' => 'alpha' } }, h)
+  end
+
+  def test_array_unset
+
+    h = { 'customers' => %w[ alpha bravo charly ] }
+    r = Ruote.unset(h, 'customers.1')
+
+    assert_equal('bravo', r)
+    assert_equal({ 'customers' => %w[ alpha charly ] }, h)
+  end
+
+  def test_array_unset_fail
+
+    h = { 'customers' => %w[ alpha bravo charly ] }
+    r = Ruote.unset(h, 'customers.x')
+
+    assert_equal(nil, r)
+    assert_equal({ 'customers' => %w[ alpha bravo charly ] }, h)
+  end
+
+  def test_unset_fail
+
+    h = { 'customer' => { 'name' => 'alpha', 'rank' => '1st' } }
+    r = Ruote.unset(h, 'customer.rank.0')
+
+    assert_equal(nil, r)
+    assert_equal({ 'customer' => { 'name' => 'alpha', 'rank' => '1st' } }, h)
+  end
+end
+

data/test/unit/ut_13_serializer.rb

@@ -0,0 +1,65 @@
+
+#
+# testing ruote
+#
+# Thu Aug 27 10:44:44 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+require 'ruote/util/serializer'
+
+
+class UtSerializerTest < Test::Unit::TestCase
+
+  class Vehicle
+    attr_accessor :type
+    def initialize(t)
+      @type = t
+    end
+  end
+
+  #def setup
+  #end
+  #def teardown
+  #end
+
+  def test_yaml
+
+    s = Ruote::Serializer.new(:yaml)
+
+    data = s.encode(Vehicle.new('bike'))
+
+    assert_match /^---/, data
+
+    v = s.decode(data)
+
+    assert_equal Vehicle, v.class
+    assert_equal 'bike', v.type
+  end
+
+  def test_marshal
+
+    s = Ruote::Serializer.new(:marshal)
+
+    data = s.encode(Vehicle.new('bike'))
+
+    v = s.decode(data)
+
+    assert_equal Vehicle, v.class
+    assert_equal 'bike', v.type
+  end
+
+  def test_marshal64
+
+    s = Ruote::Serializer.new(:marshal64)
+
+    data = s.encode(Vehicle.new('bike'))
+
+    v = s.decode(data)
+
+    assert_equal Vehicle, v.class
+    assert_equal 'bike', v.type
+  end
+end
+

data/test/unit/ut_14_is_uri.rb

@@ -0,0 +1,28 @@
+
+#
+# testing ruote
+#
+# Tue Sep  1 13:39:43 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+require 'ruote/util/misc'
+
+
+class UtIsUriTest < Test::Unit::TestCase
+
+  def test_is
+
+    assert Ruote.is_uri?('definition.rb')
+    assert Ruote.is_uri?('/definition.xml')
+    assert Ruote.is_uri?('http://nada.example.com/')
+  end
+
+  def test_is_not
+
+    assert ! Ruote.is_uri?('toto')
+    assert ! Ruote.is_uri?('definition. nada')
+  end
+end
+