rubyjedi-soap4r 1.5.8.20100619003610 → 2.0.2.1

data/test/soap/test_property.rb

@@ -1,429 +0,0 @@
-# encoding: ASCII-8BIT
-# coding: utf-8
-require 'helper'
-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
-a.b.3 = 日本語
-a.b.表 = 1表2
-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", prop["a.b.表"])
-    assert_equal(["1", "1表2", "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

data/test/soap/test_response_as_xml.rb

@@ -1,118 +0,0 @@
-# encoding: ASCII-8BIT
-require 'helper'
-require 'testutil'
-require 'soap/rpc/httpserver'
-require 'soap/rpc/driver'
-require 'rexml/document'
-
-
-module SOAP
-
-
-class TestResponseAsXml < Test::Unit::TestCase
-  Namespace = "urn:example.com:hello"
-  class Server < ::SOAP::RPC::HTTPServer
-    def on_init
-      add_method(self, 'hello', 'name')
-    end
-  
-    def hello(name)
-      "hello #{name}"
-    end
-  end
-
-  Port = 17171
-
-  def setup
-    setup_server
-    setup_client
-  end
-
-  def setup_server
-    @server = Server.new(
-      :Port => Port,
-      :BindAddress => "0.0.0.0",
-      :AccessLog => [],
-      :SOAPDefaultNamespace => Namespace
-    )
-    @server.level = Logger::Severity::ERROR
-    @server_thread = TestUtil.start_server_thread(@server)
-  end
-
-  def setup_client
-    @client = ::SOAP::RPC::Driver.new("http://localhost:#{Port}/", Namespace)
-    @client.wiredump_dev = STDERR if $DEBUG
-    @client.add_method('hello', 'name')
-    @client.add_document_method('hellodoc', Namespace, XSD::QName.new(Namespace, 'helloRequest'), XSD::QName.new(Namespace, 'helloResponse'))
-  end
-
-  def teardown
-    teardown_server if @server
-    teardown_client if @client
-  end
-
-  def teardown_server
-    @server.shutdown
-    @server_thread.kill
-    @server_thread.join
-  end
-
-  def teardown_client
-    @client.reset_stream
-  end
-
-  RESPONSE_AS_XML=<<__XML__.chomp
-<?xml version="1.0" encoding="utf-8" ?>
-<env:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema"
-    xmlns:env="http://schemas.xmlsoap.org/soap/envelope/"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-  <env:Body>
-    <n1:helloResponse xmlns:n1="urn:example.com:hello"
-        env:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
-      <return xsi:type="xsd:string">hello world</return>
-    </n1:helloResponse>
-  </env:Body>
-</env:Envelope>
-__XML__
-
-  def test_hello
-    assert_xml_equal("hello world", @client.hello("world"))
-    @client.return_response_as_xml = true
-    xml = @client.hello("world")
-    assert_xml_equal(RESPONSE_AS_XML, xml, [RESPONSE_AS_XML, xml].join("\n\n"))
-    doc = REXML::Document.new(@client.hello("world"))
-    assert_equal("hello world",
-      REXML::XPath.match(doc, "//*[name()='return']")[0].text)
-  end
-
-  RESPONSE_CDATA = <<__XML__.chomp
-<env:Envelope xmlns:env='http://schemas.xmlsoap.org/soap/envelope/'>
-  <env:Body>
-    <gno:helloResponse xmlns:gno='urn:example.com:hello'>
-      <gno:htmlContent>
-        <![CDATA[<span>some html</span>]]>
-      </gno:htmlContent>
-    </gno:helloResponse>
-  </env:Body>
-</env:Envelope>
-__XML__
-  def test_cdata
-    @client.return_response_as_xml = false
-    @client.test_loopback_response << RESPONSE_CDATA
-    ret = @client.hellodoc(nil)
-    assert_equal("\n        <span>some html</span>\n      ", ret.htmlContent)
-    #
-    @client.return_response_as_xml = true
-    @client.test_loopback_response << RESPONSE_CDATA
-    xml = @client.hello(nil)
-    assert_equal(RESPONSE_CDATA, xml)
-    require 'rexml/document'
-    doc = REXML::Document.new(xml)
-    assert_equal("<span>some html</span>",
-      REXML::XPath.match(doc, "//*[name()='gno:htmlContent']")[0][1].value)
-    #
-  end
-end
-
-
-end