rtiss_soap4r 2.1.0 → 3.0.0.beta

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/abstractDriver.rb

@@ -0,0 +1,73 @@
+require 'abstract.rb'
+require 'abstractMappingRegistry.rb'
+require 'soap/rpc/driver'
+
+module WSDL
+module Abstract
+
+class AbstractService < ::SOAP::RPC::Driver
+  DefaultEndpointUrl = "http://localhost:8080/"
+  NsAbstract = "urn:www.example.org:abstract"
+
+  Methods = [
+    [ XSD::QName.new(NsAbstract, "echo"),
+      "",
+      "echo",
+      [ [:in, "name", ["::SOAP::SOAPString"]],
+        [:in, "author", ["WSDL::Abstract::Author", "urn:www.example.org:abstract", "Author"]],
+        [:retval, "return", ["WSDL::Abstract::Book", "urn:www.example.org:abstract", "Book"]] ],
+      { :request_style =>  :rpc, :request_use =>  :encoded,
+        :response_style => :rpc, :response_use => :encoded,
+        :faults => {} }
+    ],
+    [ "",
+      "echoLiteral",
+      [ [:in, "author", ["::SOAP::SOAPElement", "urn:www.example.org:abstract", "Author"]],
+        [:out, "return", ["::SOAP::SOAPElement", "urn:www.example.org:abstract", "Author"]] ],
+      { :request_style =>  :document, :request_use =>  :literal,
+        :response_style => :document, :response_use => :literal,
+        :faults => {} }
+    ],
+    [ XSD::QName.new(NsAbstract, "echoDerived"),
+      "",
+      "echoDerived",
+      [ [:in, "parameter", ["WSDL::Abstract::BaseClass", "urn:www.example.org:abstract", "BaseClass"]],
+        [:retval, "return", ["WSDL::Abstract::BaseClass", "urn:www.example.org:abstract", "BaseClass"]] ],
+      { :request_style =>  :rpc, :request_use =>  :encoded,
+        :response_style => :rpc, :response_use => :encoded,
+        :faults => {} }
+    ]
+  ]
+
+  def initialize(endpoint_url = nil)
+    endpoint_url ||= DefaultEndpointUrl
+    super(endpoint_url, nil)
+    self.mapping_registry = AbstractMappingRegistry::EncodedRegistry
+    self.literal_mapping_registry = AbstractMappingRegistry::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
+end

data/test/wsdl/abstract/abstractMappingRegistry.rb

@@ -0,0 +1,139 @@
+require 'abstract.rb'
+require 'soap/mapping'
+
+module WSDL; module Abstract
+
+module AbstractMappingRegistry
+  EncodedRegistry = ::SOAP::Mapping::EncodedRegistry.new
+  LiteralRegistry = ::SOAP::Mapping::LiteralRegistry.new
+  NsAbstract = "urn:www.example.org:abstract"
+
+  EncodedRegistry.register(
+    :class => WSDL::Abstract::Book,
+    :schema_type => XSD::QName.new(NsAbstract, "Book"),
+    :schema_element => [
+      ["name", ["SOAP::SOAPString", XSD::QName.new(nil, "name")]],
+      ["author", ["WSDL::Abstract::Author", XSD::QName.new(nil, "author")]]
+    ]
+  )
+
+  EncodedRegistry.register(
+    :class => WSDL::Abstract::UserAuthor,
+    :schema_type => XSD::QName.new(NsAbstract, "UserAuthor"),
+    :schema_basetype => XSD::QName.new(NsAbstract, "Author"),
+    :schema_element => [
+      ["firstname", ["SOAP::SOAPString", XSD::QName.new(nil, "firstname")]],
+      ["lastname", ["SOAP::SOAPString", XSD::QName.new(nil, "lastname")]],
+      ["userid", ["SOAP::SOAPString", XSD::QName.new(nil, "userid")]]
+    ]
+  )
+
+  EncodedRegistry.register(
+    :class => WSDL::Abstract::NonUserAuthor,
+    :schema_type => XSD::QName.new(NsAbstract, "NonUserAuthor"),
+    :schema_basetype => XSD::QName.new(NsAbstract, "Author"),
+    :schema_element => [
+      ["firstname", ["SOAP::SOAPString", XSD::QName.new(nil, "firstname")]],
+      ["lastname", ["SOAP::SOAPString", XSD::QName.new(nil, "lastname")]],
+      ["nonuserid", ["SOAP::SOAPString", XSD::QName.new(nil, "nonuserid")]]
+    ]
+  )
+
+  EncodedRegistry.register(
+    :class => WSDL::Abstract::BaseClass,
+    :schema_type => XSD::QName.new(NsAbstract, "BaseClass"),
+    :schema_element => [
+      ["id", ["SOAP::SOAPUnsignedInt", XSD::QName.new(nil, "id")]]
+    ]
+  )
+
+  EncodedRegistry.register(
+    :class => WSDL::Abstract::DerivedClass1,
+    :schema_type => XSD::QName.new(NsAbstract, "DerivedClass1"),
+    :schema_basetype => XSD::QName.new(NsAbstract, "BaseClass"),
+    :schema_element => [
+      ["id", ["SOAP::SOAPUnsignedInt", XSD::QName.new(nil, "id")]],
+      ["someVar1", ["SOAP::SOAPString[]", XSD::QName.new(nil, "someVar1")], [0, nil]]
+    ]
+  )
+
+  EncodedRegistry.register(
+    :class => WSDL::Abstract::DerivedClass2,
+    :schema_type => XSD::QName.new(NsAbstract, "DerivedClass2"),
+    :schema_basetype => XSD::QName.new(NsAbstract, "BaseClass"),
+    :schema_element => [
+      ["id", ["SOAP::SOAPUnsignedInt", XSD::QName.new(nil, "id")]],
+      ["someVar2", ["SOAP::SOAPString[]", XSD::QName.new(nil, "someVar2")], [0, nil]]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Abstract::Book,
+    :schema_type => XSD::QName.new(NsAbstract, "Book"),
+    :schema_element => [
+      ["name", ["SOAP::SOAPString", XSD::QName.new(nil, "name")]],
+      ["author", ["WSDL::Abstract::Author", XSD::QName.new(nil, "author")]]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Abstract::UserAuthor,
+    :schema_type => XSD::QName.new(NsAbstract, "UserAuthor"),
+    :schema_basetype => XSD::QName.new(NsAbstract, "Author"),
+    :schema_element => [
+      ["firstname", ["SOAP::SOAPString", XSD::QName.new(nil, "firstname")]],
+      ["lastname", ["SOAP::SOAPString", XSD::QName.new(nil, "lastname")]],
+      ["userid", ["SOAP::SOAPString", XSD::QName.new(nil, "userid")]]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Abstract::NonUserAuthor,
+    :schema_type => XSD::QName.new(NsAbstract, "NonUserAuthor"),
+    :schema_basetype => XSD::QName.new(NsAbstract, "Author"),
+    :schema_element => [
+      ["firstname", ["SOAP::SOAPString", XSD::QName.new(nil, "firstname")]],
+      ["lastname", ["SOAP::SOAPString", XSD::QName.new(nil, "lastname")]],
+      ["nonuserid", ["SOAP::SOAPString", XSD::QName.new(nil, "nonuserid")]]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Abstract::BaseClass,
+    :schema_type => XSD::QName.new(NsAbstract, "BaseClass"),
+    :schema_element => [
+      ["id", ["SOAP::SOAPUnsignedInt", XSD::QName.new(nil, "id")]]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Abstract::DerivedClass1,
+    :schema_type => XSD::QName.new(NsAbstract, "DerivedClass1"),
+    :schema_basetype => XSD::QName.new(NsAbstract, "BaseClass"),
+    :schema_element => [
+      ["id", ["SOAP::SOAPUnsignedInt", XSD::QName.new(nil, "id")]],
+      ["someVar1", ["SOAP::SOAPString[]", XSD::QName.new(nil, "someVar1")], [0, nil]]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Abstract::DerivedClass2,
+    :schema_type => XSD::QName.new(NsAbstract, "DerivedClass2"),
+    :schema_basetype => XSD::QName.new(NsAbstract, "BaseClass"),
+    :schema_element => [
+      ["id", ["SOAP::SOAPUnsignedInt", XSD::QName.new(nil, "id")]],
+      ["someVar2", ["SOAP::SOAPString[]", XSD::QName.new(nil, "someVar2")], [0, nil]]
+    ]
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Abstract::Author,
+    :schema_name => XSD::QName.new(NsAbstract, "Author"),
+    :schema_element => [
+      ["firstname", ["SOAP::SOAPString", XSD::QName.new(nil, "firstname")]],
+      ["lastname", ["SOAP::SOAPString", XSD::QName.new(nil, "lastname")]]
+    ]
+  )
+end
+
+end; end

data/test/wsdl/abstract/test_abstract.rb

@@ -0,0 +1,158 @@
+require 'test_helper'
+require 'test/unit'
+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 = TestUtil.get_free_port
+
+    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, 'abstractMappingRegistry.rb', 'abstract.rb', 'abstractDriver.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,128 @@
+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