rtiss_soap4r 1.6.0

data/test/wsdl/abstract/abstract.wsdl

@@ -0,0 +1,176 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsdl:definitions
+  name="abstract"
+  targetNamespace="urn:www.example.org:abstract"
+  xmlns="http://schemas.xmlsoap.org/wsdl/"
+  xmlns:tns="urn:www.example.org:abstract"
+  xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
+  xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
+  xmlns:wsdlsoap="http://schemas.xmlsoap.org/wsdl/soap/"
+  xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+
+  <wsdl:types>
+    <schema targetNamespace="urn:www.example.org:abstract"
+      xmlns="http://www.w3.org/2001/XMLSchema">
+
+      <import namespace="http://schemas.xmlsoap.org/soap/encoding/"/>
+
+      <complexType name="Book">
+        <sequence>
+          <element name="name" type="xsd:string"/>
+          <element name="author" type="tns:Author"/>
+        </sequence>
+      </complexType>
+
+      <element name="Author" type="tns:Author"/>
+      <complexType abstract="true" name="Author">
+        <sequence>
+          <element name="firstname" type="xsd:string"/>
+          <element name="lastname" type="xsd:string"/>
+        </sequence>
+      </complexType>
+
+      <complexType name="UserAuthor">
+        <complexContent>
+          <extension base="tns:Author">
+            <sequence>
+              <element name="userid" type="xsd:string"/>
+            </sequence>
+          </extension>
+        </complexContent>
+      </complexType>
+
+      <complexType name="NonUserAuthor">
+        <complexContent>
+          <extension base="tns:Author">
+            <sequence>
+              <element name="nonuserid" type="xsd:string"/>
+            </sequence>
+          </extension>
+        </complexContent>
+      </complexType>
+
+      <complexType name="BaseClass">
+        <sequence>
+          <element name="id" type="xsd:unsignedInt" minOccurs="1"
+            maxOccurs="1"/>
+        </sequence>
+      </complexType>
+
+      <complexType name="DerivedClass1">
+        <complexContent>
+          <extension base="tns:BaseClass">
+            <sequence>
+              <element name="someVar1" type="xsd:string"
+                minOccurs="0" maxOccurs="unbounded"/>
+            </sequence>
+          </extension>
+        </complexContent>
+      </complexType>
+
+      <complexType name="DerivedClass2">
+        <complexContent>
+          <extension base="tns:BaseClass">
+            <sequence>
+              <element name="someVar2" type="xsd:string"
+                minOccurs="0" maxOccurs="unbounded"/>
+            </sequence>
+          </extension>
+        </complexContent>
+      </complexType>
+    </schema>
+  </wsdl:types>
+
+  <wsdl:message name="echoRequest">
+    <wsdl:part name="name" type="xsd:string"/>
+    <wsdl:part name="author" type="tns:Author"/>
+  </wsdl:message>
+
+  <wsdl:message name="echoResponse">
+    <wsdl:part name="return" type="tns:Book"/>
+  </wsdl:message>
+
+  <wsdl:message name="echoLiteralRequest">
+    <wsdl:part name="author" element="tns:Author"/>
+  </wsdl:message>
+
+  <wsdl:message name="echoLiteralResponse">
+    <wsdl:part name="return" element="tns:Author"/>
+  </wsdl:message>
+
+  <wsdl:message name="echoDerivedRequest">
+    <wsdl:part name="parameter" type="tns:BaseClass"/>
+  </wsdl:message>
+
+  <wsdl:message name="echoDerivedResponse">
+    <wsdl:part name="return" type="tns:BaseClass"/>
+  </wsdl:message>
+
+  <wsdl:portType name="AbstractService">
+    <wsdl:operation name="echo" parameterOrder="obj typename">
+      <wsdl:input message="tns:echoRequest" name="echoRequest"/>
+      <wsdl:output message="tns:echoResponse" name="echoResponse"/>
+    </wsdl:operation>
+
+    <wsdl:operation name="echoLiteral">
+      <wsdl:input message="tns:echoLiteralRequest"/>
+      <wsdl:output message="tns:echoLiteralResponse"/>
+    </wsdl:operation>
+
+    <wsdl:operation name="echoDerived">
+      <wsdl:input message="tns:echoDerivedRequest" name="echoDerivedRequest"/>
+      <wsdl:output message="tns:echoDerivedResponse" name="echoDerivedResponse"/>
+    </wsdl:operation>
+  </wsdl:portType>
+
+  <wsdl:binding name="AbstractServiceSoapBinding"
+    type="tns:AbstractService">
+
+    <wsdlsoap:binding transport="http://schemas.xmlsoap.org/soap/http"/>
+
+    <wsdl:operation name="echo">
+      <wsdlsoap:operation style="rpc" soapAction=""/>
+      <wsdl:input name="echoRequest">
+        <wsdlsoap:body
+          encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
+          namespace="urn:www.example.org:abstract" use="encoded"/>
+      </wsdl:input>
+      <wsdl:output name="echoResponse">
+        <wsdlsoap:body
+          encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
+          namespace="urn:www.example.org:abstract" use="encoded"/>
+      </wsdl:output>
+    </wsdl:operation>
+
+    <wsdl:operation name="echoLiteral">
+      <wsdlsoap:operation style="document" soapAction=""/>
+      <wsdl:input name="echoLiteralRequest">
+        <wsdlsoap:body namespace="urn:www.example.org:abstract" use="literal"/>
+      </wsdl:input>
+      <wsdl:output name="echoLiteralResponse">
+        <wsdlsoap:body namespace="urn:www.example.org:abstract" use="literal"/>
+      </wsdl:output>
+    </wsdl:operation>
+
+    <wsdl:operation name="echoDerived">
+      <wsdlsoap:operation style="rpc" soapAction=""/>
+      <wsdl:input name="echoDerivedRequest">
+        <wsdlsoap:body
+          encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
+          namespace="urn:www.example.org:abstract" use="encoded"/>
+      </wsdl:input>
+      <wsdl:output name="echoDerivedResponse">
+        <wsdlsoap:body
+          encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
+          namespace="urn:www.example.org:abstract" use="encoded"/>
+      </wsdl:output>
+    </wsdl:operation>
+  </wsdl:binding>
+
+  <wsdl:service name="AbstractServiceService">
+    <wsdl:port name="AbstractService"
+      binding="tns:AbstractServiceSoapBinding">
+      <wsdlsoap:address location="http://localhost:8080/"/>
+    </wsdl:port>
+  </wsdl:service>
+</wsdl:definitions>

data/test/wsdl/abstract/test_abstract.rb

@@ -0,0 +1,160 @@
+# encoding: ASCII-8BIT
+require 'helper'
+require 'testutil'
+require 'wsdl/parser'
+require 'wsdl/soap/wsdl2ruby'
+require 'soap/rpc/standaloneServer'
+require 'soap/wsdlDriver'
+
+
+module WSDL; module Abstract
+
+
+class TestAbstract < Test::Unit::TestCase
+  class Server < ::SOAP::RPC::StandaloneServer
+    def on_init
+      add_rpc_method(self, 'echo', 'name', 'author')
+      add_rpc_method(self, 'echoDerived', 'parameter')
+      add_document_operation(
+        self,
+        "",
+        "echoLiteral",
+        [ [:in, "author", ["::SOAP::SOAPElement", "urn:www.example.org:abstract", "Author"]],
+          [:out, "return", ["::SOAP::SOAPElement", "urn:www.example.org:abstract", "Book"]] ],
+        { :request_style =>  :document, :request_use =>  :literal,
+          :response_style => :document, :response_use => :literal,
+          :faults => {} }
+      )
+      self.mapping_registry = AbstractMappingRegistry::EncodedRegistry
+      self.literal_mapping_registry = AbstractMappingRegistry::LiteralRegistry
+    end
+  
+    def echo(name, author)
+      Book.new(name, author)
+    end
+
+    def echoLiteral(author)
+      author
+    end
+
+    def echoDerived(parameter)
+      parameter
+    end
+  end
+
+  DIR = File.dirname(File.expand_path(__FILE__))
+
+  Port = 17171
+
+  def setup
+    setup_classdef
+    setup_server
+    @client = nil
+  end
+
+  def teardown
+    teardown_server if @server
+    unless $DEBUG
+      File.unlink(pathname('abstract.rb'))
+      File.unlink(pathname('abstractMappingRegistry.rb'))
+      File.unlink(pathname('abstractDriver.rb'))
+    end
+    @client.reset_stream if @client
+  end
+
+  def setup_server
+    @server = Server.new('Test', "urn:www.example.org:abstract", '0.0.0.0', Port)
+    @server.level = Logger::Severity::ERROR
+    @server_thread = TestUtil.start_server_thread(@server)
+  end
+
+  def setup_classdef
+    gen = WSDL::SOAP::WSDL2Ruby.new
+    gen.location = pathname("abstract.wsdl")
+    gen.basedir = DIR
+    gen.logger.level = Logger::FATAL
+    gen.opt['classdef'] = nil
+    gen.opt['mapping_registry'] = nil
+    gen.opt['module_path'] = self.class.to_s.sub(/::[^:]+$/, '')
+    gen.opt['driver'] = nil
+    gen.opt['force'] = true
+    gen.run
+    TestUtil.require(DIR, 'abstractDriver.rb', 'abstract.rb', 'abstractMappingRegistry.rb')
+  end
+
+  def teardown_server
+    @server.shutdown
+    @server_thread.kill
+    @server_thread.join
+  end
+
+  def pathname(filename)
+    File.join(DIR, filename)
+  end
+
+  def test_wsdl
+    wsdl = File.join(DIR, 'abstract.wsdl')
+    @client = ::SOAP::WSDLDriverFactory.new(wsdl).create_rpc_driver
+    @client.mapping_registry = AbstractMappingRegistry::EncodedRegistry
+    @client.endpoint_url = "http://localhost:#{Port}/"
+    @client.wiredump_dev = STDERR if $DEBUG
+
+    author = UserAuthor.new("first", "last", "uid")
+    ret = @client.echo("book1", author)
+    assert_equal("book1", ret.name)
+    assert_equal(author.firstname, ret.author.firstname)
+    assert_equal(author.lastname, ret.author.lastname)
+    assert_equal(author.userid, ret.author.userid)
+
+    author = NonUserAuthor.new("first", "last", "nonuserid")
+    ret = @client.echo("book2", author)
+    assert_equal("book2", ret.name)
+    assert_equal(author.firstname, ret.author.firstname)
+    assert_equal(author.lastname, ret.author.lastname)
+    assert_equal(author.nonuserid, ret.author.nonuserid)
+  end
+
+  def test_stub
+    @client = AbstractService.new("http://localhost:#{Port}/")
+    @client.wiredump_dev = STDERR if $DEBUG
+
+    author = UserAuthor.new("first", "last", "uid")
+    ret = @client.echo("book1", author)
+    assert_equal("book1", ret.name)
+    assert_equal(author.firstname, ret.author.firstname)
+    assert_equal(author.lastname, ret.author.lastname)
+    assert_equal(author.userid, ret.author.userid)
+    #
+    author = NonUserAuthor.new("first", "last", "nonuserid")
+    ret = @client.echo("book2", author)
+    assert_equal("book2", ret.name)
+    assert_equal(author.firstname, ret.author.firstname)
+    assert_equal(author.lastname, ret.author.lastname)
+    assert_equal(author.nonuserid, ret.author.nonuserid)
+  end
+
+  def test_literal_stub
+    @client = AbstractService.new("http://localhost:#{Port}/")
+    @client.wiredump_dev = STDERR if $DEBUG
+    author = NonUserAuthor.new("first", "last", "nonuserid")
+    ret = @client.echoLiteral(author)
+    assert_equal(author.firstname, ret.firstname)
+    assert_equal(author.lastname, ret.lastname)
+    assert_equal(author.nonuserid, ret.nonuserid)
+    assert_equal(NonUserAuthor, ret.class)
+  end
+
+  def test_stub_derived
+    @client = AbstractService.new("http://localhost:#{Port}/")
+    @client.wiredump_dev = STDERR if $DEBUG
+
+    parameter = DerivedClass1.new(123, "someVar1")
+    ret = @client.echoDerived(parameter)
+    assert_equal(123, ret.id)
+    assert_equal(["someVar1"], ret.someVar1)
+    assert_equal(DerivedClass1, ret.class)
+  end
+end
+
+
+end; end

data/test/wsdl/anonymous/expectedClassDef.rb

@@ -0,0 +1,129 @@
+# encoding: ASCII-8BIT
+require 'xsd/qname'
+
+module WSDL; module Anonymous
+
+
+# {urn:lp}Header
+#   header3 - SOAP::SOAPString
+class Header
+  attr_accessor :header3
+
+  def initialize(header3 = nil)
+    @header3 = header3
+  end
+end
+
+# {urn:lp}ExtraInfo
+class ExtraInfo < ::Array
+
+  # {}Entry
+  #   key - SOAP::SOAPString
+  #   value - SOAP::SOAPString
+  class Entry
+    attr_accessor :key
+    attr_accessor :value
+
+    def initialize(key = nil, value = nil)
+      @key = key
+      @value = value
+    end
+  end
+end
+
+# {urn:lp}loginResponse
+#   loginResult - WSDL::Anonymous::LoginResponse::LoginResult
+class LoginResponse
+
+  # inner class for member: loginResult
+  # {}loginResult
+  #   sessionID - SOAP::SOAPString
+  class LoginResult
+    attr_accessor :sessionID
+
+    def initialize(sessionID = nil)
+      @sessionID = sessionID
+    end
+  end
+
+  attr_accessor :loginResult
+
+  def initialize(loginResult = nil)
+    @loginResult = loginResult
+  end
+end
+
+# {urn:lp}Pack
+#   header - WSDL::Anonymous::Pack::Header
+class Pack
+
+  # inner class for member: Header
+  # {}Header
+  #   header1 - SOAP::SOAPString
+  class Header
+    attr_accessor :header1
+
+    def initialize(header1 = nil)
+      @header1 = header1
+    end
+  end
+
+  attr_accessor :header
+
+  def initialize(header = nil)
+    @header = header
+  end
+end
+
+# {urn:lp}Envelope
+#   header - WSDL::Anonymous::Envelope::Header
+class Envelope
+
+  # inner class for member: Header
+  # {}Header
+  #   header2 - SOAP::SOAPString
+  class Header
+    attr_accessor :header2
+
+    def initialize(header2 = nil)
+      @header2 = header2
+    end
+  end
+
+  attr_accessor :header
+
+  def initialize(header = nil)
+    @header = header
+  end
+end
+
+# {urn:lp}login
+#   loginRequest - WSDL::Anonymous::Login::LoginRequest
+class Login
+
+  # inner class for member: loginRequest
+  # {}loginRequest
+  #   username - SOAP::SOAPString
+  #   password - SOAP::SOAPString
+  #   timezone - SOAP::SOAPString
+  class LoginRequest
+    attr_accessor :username
+    attr_accessor :password
+    attr_accessor :timezone
+
+    def initialize(username = nil, password = nil, timezone = nil)
+      @username = username
+      @password = password
+      @timezone = timezone
+    end
+  end
+
+  attr_accessor :loginRequest
+
+  def initialize(loginRequest = nil)
+    @loginRequest = loginRequest
+  end
+end
+
+
+end; end

data/test/wsdl/anonymous/expectedDriver.rb

@@ -0,0 +1,60 @@
+# encoding: ASCII-8BIT
+require 'lp.rb'
+require 'lpMappingRegistry.rb'
+require 'soap/rpc/driver'
+
+module WSDL::Anonymous
+
+class Lp_porttype < ::SOAP::RPC::Driver
+  DefaultEndpointUrl = "http://localhost:17171/"
+
+  Methods = [
+    [ "urn:lp:login",
+      "login",
+      [ [:in, "parameters", ["::SOAP::SOAPElement", "urn:lp", "login"]],
+        [:out, "parameters", ["::SOAP::SOAPElement", "urn:lp", "loginResponse"]] ],
+      { :request_style =>  :document, :request_use =>  :literal,
+        :response_style => :document, :response_use => :literal,
+        :faults => {} }
+    ],
+    [ "urn:lp:echo",
+      "echo",
+      [ [:in, "parameters", ["::SOAP::SOAPElement", "urn:lp", "Pack"]],
+        [:out, "parameters", ["::SOAP::SOAPElement", "urn:lp", "Envelope"]] ],
+      { :request_style =>  :document, :request_use =>  :literal,
+        :response_style => :document, :response_use => :literal,
+        :faults => {} }
+    ]
+  ]
+
+  def initialize(endpoint_url = nil)
+    endpoint_url ||= DefaultEndpointUrl
+    super(endpoint_url, nil)
+    self.mapping_registry = LpMappingRegistry::EncodedRegistry
+    self.literal_mapping_registry = LpMappingRegistry::LiteralRegistry
+    init_methods
+  end
+
+private
+
+  def init_methods
+    Methods.each do |definitions|
+      opt = definitions.last
+      if opt[:request_style] == :document
+        add_document_operation(*definitions)
+      else
+        add_rpc_operation(*definitions)
+        qname = definitions[0]
+        name = definitions[2]
+        if qname.name != name and qname.name.capitalize == name.capitalize
+          ::SOAP::Mapping.define_singleton_method(self, qname.name) do |*arg|
+            __send__(name, *arg)
+          end
+        end
+      end
+    end
+  end
+end
+
+
+end

data/test/wsdl/anonymous/expectedMappingRegistry.rb

@@ -0,0 +1,177 @@
+# encoding: ASCII-8BIT
+require 'lp.rb'
+require 'soap/mapping'
+
+module WSDL; module Anonymous
+
+module LpMappingRegistry
+  EncodedRegistry = ::SOAP::Mapping::EncodedRegistry.new
+  LiteralRegistry = ::SOAP::Mapping::LiteralRegistry.new
+  NsLp = "urn:lp"
+
+  EncodedRegistry.register(
+    :class => WSDL::Anonymous::Header,
+    :schema_type => XSD::QName.new(NsLp, "Header"),
+    :schema_element => [
+      ["header3", ["SOAP::SOAPString", XSD::QName.new(nil, "Header3")]]
+    ]
+  )
+
+  EncodedRegistry.register(
+    :class => WSDL::Anonymous::ExtraInfo,
+    :schema_type => XSD::QName.new(NsLp, "ExtraInfo"),
+    :schema_element => [
+      ["entry", ["WSDL::Anonymous::ExtraInfo::Entry[]", XSD::QName.new(nil, "Entry")], [1, nil]]
+    ]
+  )
+
+  EncodedRegistry.register(
+    :class => WSDL::Anonymous::ExtraInfo::Entry,
+    :schema_name => XSD::QName.new(nil, "Entry"),
+    :is_anonymous => true,
+    :schema_qualified => false,
+    :schema_element => [
+      ["key", ["SOAP::SOAPString", XSD::QName.new(nil, "Key")]],
+      ["value", ["SOAP::SOAPString", XSD::QName.new(nil, "Value")]]
+    ]
+  )
+
+  EncodedRegistry.register(
+    :class => WSDL::Anonymous::LoginResponse,
+    :schema_type => XSD::QName.new(NsLp, "loginResponse"),
+    :schema_element => [
+      ["loginResult", ["WSDL::Anonymous::LoginResponse::LoginResult", XSD::QName.new(nil, "loginResult")]]
+    ]
+  )
+
+  EncodedRegistry.register(
+    :class => WSDL::Anonymous::LoginResponse::LoginResult,
+    :schema_name => XSD::QName.new(nil, "loginResult"),
+    :is_anonymous => true,
+    :schema_qualified => false,
+    :schema_element => [
+      ["sessionID", "SOAP::SOAPString"]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Anonymous::Header,
+    :schema_type => XSD::QName.new(NsLp, "Header"),
+    :schema_element => [
+      ["header3", ["SOAP::SOAPString", XSD::QName.new(nil, "Header3")]]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Anonymous::ExtraInfo,
+    :schema_type => XSD::QName.new(NsLp, "ExtraInfo"),
+    :schema_element => [
+      ["entry", ["WSDL::Anonymous::ExtraInfo::Entry[]", XSD::QName.new(nil, "Entry")], [1, nil]]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Anonymous::ExtraInfo::Entry,
+    :schema_name => XSD::QName.new(nil, "Entry"),
+    :is_anonymous => true,
+    :schema_qualified => false,
+    :schema_element => [
+      ["key", ["SOAP::SOAPString", XSD::QName.new(nil, "Key")]],
+      ["value", ["SOAP::SOAPString", XSD::QName.new(nil, "Value")]]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Anonymous::LoginResponse,
+    :schema_type => XSD::QName.new(NsLp, "loginResponse"),
+    :schema_element => [
+      ["loginResult", ["WSDL::Anonymous::LoginResponse::LoginResult", XSD::QName.new(nil, "loginResult")]]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Anonymous::LoginResponse::LoginResult,
+    :schema_name => XSD::QName.new(nil, "loginResult"),
+    :is_anonymous => true,
+    :schema_qualified => false,
+    :schema_element => [
+      ["sessionID", "SOAP::SOAPString"]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Anonymous::Pack,
+    :schema_name => XSD::QName.new(NsLp, "Pack"),
+    :schema_element => [
+      ["header", ["WSDL::Anonymous::Pack::Header", XSD::QName.new(nil, "Header")]]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Anonymous::Pack::Header,
+    :schema_name => XSD::QName.new(nil, "Header"),
+    :is_anonymous => true,
+    :schema_qualified => false,
+    :schema_element => [
+      ["header1", ["SOAP::SOAPString", XSD::QName.new(nil, "Header1")]]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Anonymous::Envelope,
+    :schema_name => XSD::QName.new(NsLp, "Envelope"),
+    :schema_element => [
+      ["header", ["WSDL::Anonymous::Envelope::Header", XSD::QName.new(nil, "Header")]]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Anonymous::Envelope::Header,
+    :schema_name => XSD::QName.new(nil, "Header"),
+    :is_anonymous => true,
+    :schema_qualified => false,
+    :schema_element => [
+      ["header2", ["SOAP::SOAPString", XSD::QName.new(nil, "Header2")]]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Anonymous::Login,
+    :schema_name => XSD::QName.new(NsLp, "login"),
+    :schema_element => [
+      ["loginRequest", ["WSDL::Anonymous::Login::LoginRequest", XSD::QName.new(nil, "loginRequest")]]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Anonymous::Login::LoginRequest,
+    :schema_name => XSD::QName.new(nil, "loginRequest"),
+    :is_anonymous => true,
+    :schema_qualified => false,
+    :schema_element => [
+      ["username", "SOAP::SOAPString"],
+      ["password", "SOAP::SOAPString"],
+      ["timezone", "SOAP::SOAPString", [0, 1]]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Anonymous::LoginResponse,
+    :schema_name => XSD::QName.new(NsLp, "loginResponse"),
+    :schema_element => [
+      ["loginResult", ["WSDL::Anonymous::LoginResponse::LoginResult", XSD::QName.new(nil, "loginResult")]]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Anonymous::LoginResponse::LoginResult,
+    :schema_name => XSD::QName.new(nil, "loginResult"),
+    :is_anonymous => true,
+    :schema_qualified => false,
+    :schema_element => [
+      ["sessionID", "SOAP::SOAPString"]
+    ]
+  )
+end
+
+end; end