rtiss_soap4r 2.1.1 → 3.0.0.beta

data/test/soap/test_property.rb

@@ -0,0 +1,427 @@
+# coding: utf-8
+
+require 'test/unit'
+require 'soap/property'
+
+module SOAP
+
+
+class TestProperty < Test::Unit::TestCase
+
+  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

@@ -0,0 +1,116 @@
+require 'test/unit'
+require 'soap/rpc/httpserver'
+require 'soap/rpc/driver'
+require 'rexml/document'
+require 'test_helper'
+
+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 = TestUtil.get_free_port
+
+    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
+      sleep 0.5  # Allow OS to release port
+    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:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+    xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+  <env:Body>
+    <n1:helloResponse env:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
+        xmlns:n1="urn:example.com:hello">
+      <return xsi:type="xsd:string">hello world</return>
+    </n1:helloResponse>
+  </env:Body>
+</env:Envelope>
+__XML__
+
+    def test_hello
+      assert_equal("hello world", @client.hello("world"))
+      @client.return_response_as_xml = true
+      xml = @client.hello("world")
+      assert_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

data/test/soap/test_soapelement.rb

@@ -0,0 +1,138 @@
+require 'test/unit'
+require 'soap/baseData'
+require 'soap/mapping'
+
+
+module SOAP
+
+
+class TestSOAPElement < Test::Unit::TestCase
+  include SOAP
+
+  def setup
+    # Nothing to do.
+  end
+
+  def teardown
+    # Nothing to do.
+  end
+
+  def d(elename = nil, text = nil)
+    elename ||= n(nil, nil)
+    if text
+      SOAPElement.new(elename, text)
+    else
+      SOAPElement.new(elename)	# do not merge.
+    end
+  end
+
+  def n(namespace, name)
+    XSD::QName.new(namespace, name)
+  end
+
+  def test_initialize
+    elename = n(nil, nil)
+    obj = d(elename)
+    assert_equal(elename, obj.elename)
+    assert_equal(LiteralNamespace, obj.encodingstyle)
+    assert_equal({}, obj.extraattr)
+    assert_equal([], obj.precedents)
+    assert_equal(nil, obj.qualified)
+    assert_equal(nil, obj.text)
+    assert(obj.members.empty?)
+
+    obj = d("foo", "text")
+    assert_equal(n(nil, "foo"), obj.elename)
+    assert_equal("text", obj.text)
+  end
+
+  def test_add
+    obj = d()
+    child = d("abc")
+    obj.add(child)
+    assert(obj.key?("abc"))
+    assert_same(child, obj["abc"])
+    assert_same(child, obj["abc"])
+    child = d("foo")
+    obj.add(child)
+    assert_equal(child, obj["foo"])
+    child = d("_?a?b_")
+    obj.add(child)
+    assert_equal(child, obj["_?a?b_"])
+  end
+
+  def test_member
+    obj = d()
+    c1 = d("c1")
+    obj.add(c1)
+    c2 = d("c2")
+    obj.add(c2)
+    assert(obj.key?("c1"))
+    assert(obj.key?("c2"))
+    assert_equal(c1, obj["c1"])
+    assert_equal(c2, obj["c2"])
+    c22 = d("c22")
+    obj["c2"] = c22
+    assert(obj.key?("c2"))
+    assert_equal(c22, obj["c2"])
+    assert_equal(["c1", "c2"], obj.members.sort)
+    #
+    k_expect = ["c1", "c2"]
+    v_expect = [c1, c22]
+    obj.each do |k, v|
+      assert(k_expect.include?(k))
+      assert(v_expect.include?(v))
+      k_expect.delete(k)
+      v_expect.delete(v)
+    end
+    assert(k_expect.empty?)
+    assert(v_expect.empty?)
+  end
+
+  def test_to_obj
+    obj = d("root")
+    ct1 = d("ct1", "t1")
+    obj.add(ct1)
+    c2 = d("c2")
+    ct2 = d("ct2", "t2")
+    c2.add(ct2)
+    obj.add(c2)
+    assert_equal({ "ct1" => "t1", "c2" => { "ct2" => "t2" }}, obj.to_obj) 
+    #
+    assert_equal(nil, d().to_obj)
+    assert_equal("abc", d(nil, "abc").to_obj)
+    assert_equal(nil, d("abc", nil).to_obj)
+  end
+
+  def test_from_obj
+    source = { "ct1" => "t1", "c2" => { "ct2" => "t2" }}
+    assert_equal(source, SOAPElement.from_obj(source).to_obj)
+    source = { "1" => nil }
+    assert_equal(source, SOAPElement.from_obj(source).to_obj)
+    source = {}
+    assert_equal(nil, SOAPElement.from_obj(source).to_obj)	# not {}
+    source = nil
+    assert_equal(nil, SOAPElement.from_obj(source).to_obj)
+  end
+
+  def test_from_obj_xmlattr
+    source = { "xmlattr_c1" => "t1",
+      "ymlattr_c2" => {
+        XSD::QName.new("urn:foo", "xmlattr_c2") => "t2",
+        XSD::QName.new("urn:foo", "ymlattr_c3") => "t3" }}
+    obj = SOAPElement.from_obj(source)
+    assert_equal("t1", obj.extraattr[XSD::QName.new(nil, "c1")])
+    assert_equal("t2", obj["ymlattr_c2"].extraattr[XSD::QName.new("urn:foo", "c2")])
+    assert_equal("t3", obj["ymlattr_c2"]["ymlattr_c3"].text)
+    #
+    source = { "xmlattr_xmlattr_c1" => "t1",
+      "xmlele_xmlattr_c2" => {
+        XSD::QName.new("urn:foo", "xmlele_xmlele_c3") => "t3" }}
+    obj = SOAPElement.from_obj(source)
+    assert_equal("t1", obj.extraattr[XSD::QName.new(nil, "xmlattr_c1")])
+    assert_equal("t3", obj["xmlattr_c2"]["xmlele_c3"].text)
+  end
+end
+
+
+end