425 lines
10 KiB
Ruby
425 lines
10 KiB
Ruby
require 'test/unit'
|
|
require 'soap/property'
|
|
|
|
|
|
module SOAP
|
|
|
|
|
|
class TestProperty < Test::Unit::TestCase
|
|
FrozenError = (RUBY_VERSION >= "1.9.0") ? RuntimeError : TypeError
|
|
|
|
def setup
|
|
@prop = ::SOAP::Property.new
|
|
end
|
|
|
|
def teardown
|
|
# Nothing to do.
|
|
end
|
|
|
|
def test_s_load
|
|
propstr = <<__EOP__
|
|
|
|
# comment1
|
|
|
|
# comment2\r
|
|
# comment2
|
|
|
|
\r
|
|
a.b.0 = 1
|
|
a.b.1 = 2
|
|
a.b.2 = 3
|
|
client.protocol.http.proxy=http://myproxy:8080 \r
|
|
client.protocol.http.no_proxy: intranet.example.com,local.example.com\r
|
|
client.protocol.http.protocol_version = 1.0
|
|
foo\\:bar\\=baz = qux
|
|
foo\\\\.bar.baz=\tq\\\\ux\ttab
|
|
a\\ b = 1
|
|
[ppp.qqq.rrr]
|
|
sss = 3
|
|
ttt.uuu = 4
|
|
|
|
[ sss.ttt.uuu ]
|
|
vvv.www = 5
|
|
[ ]
|
|
xxx.yyy.zzz = 6
|
|
__EOP__
|
|
prop = Property.load(propstr)
|
|
assert_equal(["1", "2", "3"], prop["a.b"].values.sort)
|
|
assert_equal("intranet.example.com,local.example.com",
|
|
prop["client.protocol.http.no_proxy"])
|
|
assert_equal("http://myproxy:8080", prop["client.protocol.http.proxy"])
|
|
assert_equal("1.0", prop["client.protocol.http.protocol_version"])
|
|
assert_equal("q\\ux\ttab", prop['foo\.bar.baz'])
|
|
assert_equal("1", prop['a b'])
|
|
assert_equal("3", prop['ppp.qqq.rrr.sss'])
|
|
assert_equal("4", prop['ppp.qqq.rrr.ttt.uuu'])
|
|
assert_equal("5", prop['sss.ttt.uuu.vvv.www'])
|
|
assert_equal("6", prop['xxx.yyy.zzz'])
|
|
end
|
|
|
|
def test_load
|
|
prop = Property.new
|
|
hooked = false
|
|
prop.add_hook("foo.bar.baz") do |name, value|
|
|
assert_equal(["foo", "bar", "baz"], name)
|
|
assert_equal("123", value)
|
|
hooked = true
|
|
end
|
|
prop.lock
|
|
prop["foo.bar"].lock
|
|
prop.load("foo.bar.baz = 123")
|
|
assert(hooked)
|
|
assert_raises(FrozenError) do
|
|
prop.load("foo.bar.qux = 123")
|
|
end
|
|
prop.load("foo.baz = 456")
|
|
assert_equal("456", prop["foo.baz"])
|
|
end
|
|
|
|
def test_initialize
|
|
prop = ::SOAP::Property.new
|
|
# store is empty
|
|
assert_nil(prop["a"])
|
|
# does hook work?
|
|
assert_equal(1, prop["a"] = 1)
|
|
end
|
|
|
|
def test_aref
|
|
# name_to_a
|
|
assert_nil(@prop[:foo])
|
|
assert_nil(@prop["foo"])
|
|
assert_nil(@prop[[:foo]])
|
|
assert_nil(@prop[["foo"]])
|
|
assert_raises(ArgumentError) do
|
|
@prop[1]
|
|
end
|
|
@prop[:foo] = :foo
|
|
assert_equal(:foo, @prop[:foo])
|
|
assert_equal(:foo, @prop["foo"])
|
|
assert_equal(:foo, @prop[[:foo]])
|
|
assert_equal(:foo, @prop[["foo"]])
|
|
end
|
|
|
|
def test_referent
|
|
# referent(1)
|
|
assert_nil(@prop["foo.foo"])
|
|
assert_nil(@prop[["foo", "foo"]])
|
|
assert_nil(@prop[["foo", :foo]])
|
|
@prop["foo.foo"] = :foo
|
|
assert_equal(:foo, @prop["foo.foo"])
|
|
assert_equal(:foo, @prop[["foo", "foo"]])
|
|
assert_equal(:foo, @prop[[:foo, "foo"]])
|
|
# referent(2)
|
|
@prop["bar.bar.bar"] = :bar
|
|
assert_equal(:bar, @prop["bar.bar.bar"])
|
|
assert_equal(:bar, @prop[["bar", "bar", "bar"]])
|
|
assert_equal(:bar, @prop[[:bar, "bar", :bar]])
|
|
end
|
|
|
|
def test_to_key_and_deref
|
|
@prop["foo.foo"] = :foo
|
|
assert_equal(:foo, @prop["fOo.FoO"])
|
|
assert_equal(:foo, @prop[[:fOO, :FOO]])
|
|
assert_equal(:foo, @prop[["FoO", :Foo]])
|
|
# deref_key negative test
|
|
assert_raises(ArgumentError) do
|
|
@prop["baz"] = 1
|
|
@prop["baz.qux"] = 2
|
|
end
|
|
end
|
|
|
|
def test_hook_name
|
|
tag = Object.new
|
|
tested = false
|
|
@prop.add_hook("foo.bar") do |key, value|
|
|
assert_raise(FrozenError) do
|
|
key << "baz"
|
|
end
|
|
tested = true
|
|
end
|
|
@prop["foo.bar"] = tag
|
|
assert(tested)
|
|
end
|
|
|
|
def test_value_hook
|
|
tag = Object.new
|
|
tested = false
|
|
@prop.add_hook("FOO.BAR.BAZ") do |key, value|
|
|
assert_equal(["Foo", "baR", "baZ"], key)
|
|
assert_equal(tag, value)
|
|
tested = true
|
|
end
|
|
@prop["Foo.baR.baZ"] = tag
|
|
assert_equal(tag, @prop["foo.bar.baz"])
|
|
assert(tested)
|
|
@prop["foo.bar"] = 1 # unhook the above block
|
|
assert_equal(1, @prop["foo.bar"])
|
|
end
|
|
|
|
def test_key_hook_no_cascade
|
|
tag = Object.new
|
|
tested = 0
|
|
@prop.add_hook do |key, value|
|
|
assert(false)
|
|
end
|
|
@prop.add_hook(false) do |key, value|
|
|
assert(false)
|
|
end
|
|
@prop.add_hook("foo") do |key, value|
|
|
assert(false)
|
|
end
|
|
@prop.add_hook("foo.bar", false) do |key, value|
|
|
assert(false)
|
|
end
|
|
@prop.add_hook("foo.bar.baz") do |key, value|
|
|
assert(false)
|
|
end
|
|
@prop.add_hook("foo.bar.baz.qux", false) do |key, value|
|
|
assert_equal(["foo", "bar", "baz", "qux"], key)
|
|
assert_equal(tag, value)
|
|
tested += 1
|
|
end
|
|
@prop["foo.bar.baz.qux"] = tag
|
|
assert_equal(tag, @prop["foo.bar.baz.qux"])
|
|
assert_equal(1, tested)
|
|
end
|
|
|
|
def test_key_hook_cascade
|
|
tag = Object.new
|
|
tested = 0
|
|
@prop.add_hook(true) do |key, value|
|
|
assert_equal(["foo", "bar", "baz", "qux"], key)
|
|
assert_equal(tag, value)
|
|
tested += 1
|
|
end
|
|
@prop.add_hook("foo", true) do |key, value|
|
|
assert_equal(["foo", "bar", "baz", "qux"], key)
|
|
assert_equal(tag, value)
|
|
tested += 1
|
|
end
|
|
@prop.add_hook("foo.bar", true) do |key, value|
|
|
assert_equal(["foo", "bar", "baz", "qux"], key)
|
|
assert_equal(tag, value)
|
|
tested += 1
|
|
end
|
|
@prop.add_hook("foo.bar.baz", true) do |key, value|
|
|
assert_equal(["foo", "bar", "baz", "qux"], key)
|
|
assert_equal(tag, value)
|
|
tested += 1
|
|
end
|
|
@prop.add_hook("foo.bar.baz.qux", true) do |key, value|
|
|
assert_equal(["foo", "bar", "baz", "qux"], key)
|
|
assert_equal(tag, value)
|
|
tested += 1
|
|
end
|
|
@prop["foo.bar.baz.qux"] = tag
|
|
assert_equal(tag, @prop["foo.bar.baz.qux"])
|
|
assert_equal(5, tested)
|
|
end
|
|
|
|
def test_keys
|
|
assert(@prop.keys.empty?)
|
|
@prop["foo"] = 1
|
|
@prop["bar"]
|
|
@prop["BAz"] = 2
|
|
assert_equal(2, @prop.keys.size)
|
|
assert(@prop.keys.member?("foo"))
|
|
assert(@prop.keys.member?("baz"))
|
|
#
|
|
assert_nil(@prop["a"])
|
|
@prop["a.a"] = 1
|
|
assert_instance_of(::SOAP::Property, @prop["a"])
|
|
@prop["a.b"] = 1
|
|
@prop["a.c"] = 1
|
|
assert_equal(3, @prop["a"].keys.size)
|
|
assert(@prop["a"].keys.member?("a"))
|
|
assert(@prop["a"].keys.member?("b"))
|
|
assert(@prop["a"].keys.member?("c"))
|
|
end
|
|
|
|
def test_lshift
|
|
assert(@prop.empty?)
|
|
@prop << 1
|
|
assert_equal([1], @prop.values)
|
|
assert_equal(1, @prop["0"])
|
|
@prop << 1
|
|
assert_equal([1, 1], @prop.values)
|
|
assert_equal(1, @prop["1"])
|
|
@prop << 1
|
|
assert_equal([1, 1, 1], @prop.values)
|
|
assert_equal(1, @prop["2"])
|
|
#
|
|
@prop["abc.def"] = o = SOAP::Property.new
|
|
tested = 0
|
|
o.add_hook do |k, v|
|
|
tested += 1
|
|
end
|
|
@prop["abc.def"] << 1
|
|
@prop["abc.def"] << 2
|
|
@prop["abc.def"] << 3
|
|
@prop["abc.def"] << 4
|
|
assert_equal(4, tested)
|
|
end
|
|
|
|
def test_lock_each
|
|
@prop["a.b.c.d.e"] = 1
|
|
@prop["a.b.d"] = branch = ::SOAP::Property.new
|
|
@prop["a.b.d.e.f"] = 2
|
|
@prop.lock
|
|
assert(@prop.locked?)
|
|
assert_instance_of(::SOAP::Property, @prop["a"])
|
|
assert_raises(FrozenError) do
|
|
@prop["b"]
|
|
end
|
|
#
|
|
@prop["a"].lock
|
|
assert_raises(FrozenError) do
|
|
@prop["a"]
|
|
end
|
|
assert_instance_of(::SOAP::Property, @prop["a.b"])
|
|
#
|
|
@prop["a.b"].lock
|
|
assert_raises(FrozenError) do
|
|
@prop["a.b"]
|
|
end
|
|
assert_raises(FrozenError) do
|
|
@prop["a"]
|
|
end
|
|
#
|
|
@prop["a.b.c.d"].lock
|
|
assert_instance_of(::SOAP::Property, @prop["a.b.c"])
|
|
assert_raises(FrozenError) do
|
|
@prop["a.b.c.d"]
|
|
end
|
|
assert_instance_of(::SOAP::Property, @prop["a.b.d"])
|
|
#
|
|
branch["e"].lock
|
|
assert_instance_of(::SOAP::Property, @prop["a.b.d"])
|
|
assert_raises(FrozenError) do
|
|
@prop["a.b.d.e"]
|
|
end
|
|
assert_raises(FrozenError) do
|
|
branch["e"]
|
|
end
|
|
end
|
|
|
|
def test_lock_cascade
|
|
@prop["a.a"] = nil
|
|
@prop["a.b.c"] = 1
|
|
@prop["b"] = false
|
|
@prop.lock(true)
|
|
assert(@prop.locked?)
|
|
assert_equal(nil, @prop["a.a"])
|
|
assert_equal(1, @prop["a.b.c"])
|
|
assert_equal(false, @prop["b"])
|
|
assert_raises(FrozenError) do
|
|
@prop["c"]
|
|
end
|
|
assert_raises(FrozenError) do
|
|
@prop["c"] = 2
|
|
end
|
|
assert_raises(FrozenError) do
|
|
@prop["a.b.R"]
|
|
end
|
|
assert_raises(FrozenError) do
|
|
@prop.add_hook do
|
|
assert(false)
|
|
end
|
|
end
|
|
assert_raises(FrozenError) do
|
|
@prop.add_hook("c") do
|
|
assert(false)
|
|
end
|
|
end
|
|
assert_raises(FrozenError) do
|
|
@prop.add_hook("a.c") do
|
|
assert(false)
|
|
end
|
|
end
|
|
assert_nil(@prop["a.a"])
|
|
@prop["a.a"] = 2
|
|
assert_equal(2, @prop["a.a"])
|
|
#
|
|
@prop.unlock(true)
|
|
assert_nil(@prop["c"])
|
|
@prop["c"] = 2
|
|
assert_equal(2, @prop["c"])
|
|
@prop["a.d.a.a"] = :foo
|
|
assert_equal(:foo, @prop["a.d.a.a"])
|
|
tested = false
|
|
@prop.add_hook("a.c") do |name, value|
|
|
assert(true)
|
|
tested = true
|
|
end
|
|
@prop["a.c"] = 3
|
|
assert(tested)
|
|
end
|
|
|
|
def test_hook_then_lock
|
|
tested = false
|
|
@prop.add_hook("a.b.c") do |name, value|
|
|
assert_equal(["a", "b", "c"], name)
|
|
tested = true
|
|
end
|
|
@prop["a.b"].lock
|
|
assert(!tested)
|
|
@prop["a.b.c"] = 5
|
|
assert(tested)
|
|
assert_equal(5, @prop["a.b.c"])
|
|
assert_raises(FrozenError) do
|
|
@prop["a.b.d"] = 5
|
|
end
|
|
end
|
|
|
|
def test_lock_unlock_return
|
|
assert_equal(@prop, @prop.lock)
|
|
assert_equal(@prop, @prop.unlock)
|
|
end
|
|
|
|
def test_lock_split
|
|
@prop["a.b.c"] = 1
|
|
assert_instance_of(::SOAP::Property, @prop["a.b"])
|
|
@prop["a.b.d"] = branch = ::SOAP::Property.new
|
|
@prop["a.b.d.e"] = 2
|
|
assert_equal(branch, @prop["a.b.d"])
|
|
assert_equal(branch, @prop[:a][:b][:d])
|
|
@prop.lock(true)
|
|
# split error 1
|
|
assert_raises(FrozenError) do
|
|
@prop["a.b"]
|
|
end
|
|
# split error 2
|
|
assert_raises(FrozenError) do
|
|
@prop["a"]
|
|
end
|
|
@prop["a.b.c"] = 2
|
|
assert_equal(2, @prop["a.b.c"])
|
|
# replace error
|
|
assert_raises(FrozenError) do
|
|
@prop["a.b.c"] = ::SOAP::Property.new
|
|
end
|
|
# override error
|
|
assert_raises(FrozenError) do
|
|
@prop["a.b"] = 1
|
|
end
|
|
#
|
|
assert_raises(FrozenError) do
|
|
@prop["a.b.d"] << 1
|
|
end
|
|
assert_raises(FrozenError) do
|
|
branch << 1
|
|
end
|
|
branch.unlock(true)
|
|
branch << 1
|
|
branch << 2
|
|
branch << 3
|
|
assert_equal(2, @prop["a.b.d.e"])
|
|
assert_equal(1, @prop["a.b.d.1"])
|
|
assert_equal(2, @prop["a.b.d.2"])
|
|
assert_equal(3, @prop["a.b.d.3"])
|
|
end
|
|
end
|
|
|
|
|
|
end
|