rtiss_soap4r 1.6.1 → 2.0.4

data/test/wsdl/any/any.wsdl

@@ -1,114 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<definitions name="echo"
-    xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
-    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
-    xmlns:tns="urn:example.com:echo"
-    xmlns:txd="urn:example.com:echo-type"
-    targetNamespace="urn:example.com:echo"
-    xmlns="http://schemas.xmlsoap.org/wsdl/">
-  <types>
-    <xsd:schema targetNamespace="urn:example.com:echo-type">
-      <xsd:complexType name="foo.bar">
-        <xsd:sequence>
-          <xsd:element name="before" type="xsd:string"/>
-          <xsd:any/>
-          <xsd:element name="after" type="xsd:string"/>
-        </xsd:sequence>
-      </xsd:complexType>
-      <xsd:element name="foo.bar" type="txd:foo.bar"/>
-
-      <!-- from #323 -->
-      <xsd:element name="setOutputAndCompleteRequest">
-        <xsd:complexType>
-          <xsd:sequence>
-            <xsd:element name="taskId" type="xsd:string"/>
-            <xsd:element name="data">
-              <xsd:complexType>
-                <xsd:sequence>
-                  <xsd:any maxOccurs="unbounded" minOccurs="0" />
-                </xsd:sequence>
-              </xsd:complexType>
-            </xsd:element>
-            <xsd:element name="participantToken" type="xsd:string">
-            </xsd:element>
-          </xsd:sequence>
-        </xsd:complexType>
-      </xsd:element>
-    </xsd:schema>
-  </types>
-
-  <message name="msg_echoitem">
-    <part name="parameters" type="txd:foo.bar"/>
-  </message>
-
-  <message name="msg_echoany_request">
-  </message>
-
-  <message name="msg_echoany_response">
-    <part name="echoany_return" type="xsd:anyType"/>
-  </message>
-
-  <message name="setOutputAndCompleteRequest">
-    <part name="parameters" element="txd:setOutputAndCompleteRequest"/>
-  </message>
-
-  <message name="okResponse">
-    <part name="parameters" element="txd:setOutputAndCompleteRequest"/>
-  </message>
-
-  <portType name="echo_port_type">
-    <operation name="echo">
-      <input message="tns:msg_echoitem"/>
-      <output message="tns:msg_echoitem"/>
-    </operation>
-
-    <operation name="echoAny">
-      <input message="tns:msg_echoany_request"/>
-      <output message="tns:msg_echoany_response"/>
-    </operation>
-
-    <operation name="setOutputAndComplete">
-      <input message="tns:setOutputAndCompleteRequest"/>
-      <output message="tns:okResponse"/>
-    </operation>
-  </portType>
-
-  <binding name="echo_binding" type="tns:echo_port_type">
-    <soap:binding transport="http://schemas.xmlsoap.org/soap/http" style="document"/>
-    <operation name="echo">
-      <soap:operation soapAction="urn:example.com:echo"/>
-      <input>
-        <soap:body use="literal"/>
-      </input>
-      <output>
-        <soap:body use="literal"/>
-      </output>
-    </operation>
-
-    <operation name="echoAny">
-      <soap:operation style="rpc" soapAction="urn:example.com:echoAny"/>
-      <input>
-        <soap:body use="encoded"/>
-      </input>
-      <output>
-        <soap:body use="encoded"/>
-      </output>
-    </operation>
-
-    <operation name="setOutputAndComplete">
-      <soap:operation soapAction="urn:example.com:echo"/>
-      <input>
-        <soap:body use="literal"/>
-      </input>
-      <output>
-        <soap:body use="literal"/>
-      </output>
-    </operation>
-  </binding>
-
-  <service name="echo_service">
-    <port name="echo_port" binding="tns:echo_binding">
-      <soap:address location="http://localhost:10080"/>
-    </port>
-  </service>
-</definitions>

data/test/wsdl/any/expectedDriver.rb

@@ -1,69 +0,0 @@
-# encoding: ASCII-8BIT
-require 'echo.rb'
-require 'echoMappingRegistry.rb'
-require 'soap/rpc/driver'
-
-module WSDL::Any
-
-class Echo_port_type < ::SOAP::RPC::Driver
-  DefaultEndpointUrl = "http://localhost:10080"
-  NsEcho = "urn:example.com:echo"
-
-  Methods = [
-    [ "urn:example.com:echo",
-      "echo",
-      [ [:in, "parameters", ["::SOAP::SOAPElement", "urn:example.com:echo-type", "foo.bar"]],
-        [:out, "parameters", ["::SOAP::SOAPElement", "urn:example.com:echo-type", "foo.bar"]] ],
-      { :request_style =>  :document, :request_use =>  :literal,
-        :response_style => :document, :response_use => :literal,
-        :faults => {} }
-    ],
-    [ XSD::QName.new(NsEcho, "echoAny"),
-      "urn:example.com:echoAny",
-      "echoAny",
-      [ [:retval, "echoany_return", [nil]] ],
-      { :request_style =>  :rpc, :request_use =>  :encoded,
-        :response_style => :rpc, :response_use => :encoded,
-        :faults => {} }
-    ],
-    [ "urn:example.com:echo",
-      "setOutputAndComplete",
-      [ [:in, "parameters", ["::SOAP::SOAPElement", "urn:example.com:echo-type", "setOutputAndCompleteRequest"]],
-        [:out, "parameters", ["::SOAP::SOAPElement", "urn:example.com:echo-type", "setOutputAndCompleteRequest"]] ],
-      { :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 = EchoMappingRegistry::EncodedRegistry
-    self.literal_mapping_registry = EchoMappingRegistry::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/any/expectedEcho.rb

@@ -1,58 +0,0 @@
-# encoding: ASCII-8BIT
-require 'xsd/qname'
-
-module WSDL; module Any
-
-
-# {urn:example.com:echo-type}foo.bar
-#   before - SOAP::SOAPString
-#   after - SOAP::SOAPString
-class FooBar
-  attr_accessor :before
-  attr_reader :__xmlele_any
-  attr_accessor :after
-
-  def set_any(elements)
-    @__xmlele_any = elements
-  end
-
-  def initialize(before = nil, after = nil)
-    @before = before
-    @__xmlele_any = nil
-    @after = after
-  end
-end
-
-# {urn:example.com:echo-type}setOutputAndCompleteRequest
-#   taskId - SOAP::SOAPString
-#   data - WSDL::Any::SetOutputAndCompleteRequest::C_Data
-#   participantToken - SOAP::SOAPString
-class SetOutputAndCompleteRequest
-
-  # inner class for member: data
-  # {}data
-  class C_Data
-    attr_reader :__xmlele_any
-
-    def set_any(elements)
-      @__xmlele_any = elements
-    end
-
-    def initialize
-      @__xmlele_any = nil
-    end
-  end
-
-  attr_accessor :taskId
-  attr_accessor :data
-  attr_accessor :participantToken
-
-  def initialize(taskId = nil, data = nil, participantToken = nil)
-    @taskId = taskId
-    @data = data
-    @participantToken = participantToken
-  end
-end
-
-
-end; end

data/test/wsdl/any/expectedMappingRegistry.rb

@@ -1,64 +0,0 @@
-# encoding: ASCII-8BIT
-require 'echo.rb'
-require 'soap/mapping'
-
-module WSDL; module Any
-
-module EchoMappingRegistry
-  EncodedRegistry = ::SOAP::Mapping::EncodedRegistry.new
-  LiteralRegistry = ::SOAP::Mapping::LiteralRegistry.new
-  NsEchoType = "urn:example.com:echo-type"
-  NsXMLSchema = "http://www.w3.org/2001/XMLSchema"
-
-  EncodedRegistry.register(
-    :class => WSDL::Any::FooBar,
-    :schema_type => XSD::QName.new(NsEchoType, "foo.bar"),
-    :schema_element => [
-      ["before", ["SOAP::SOAPString", XSD::QName.new(nil, "before")]],
-      ["any", [nil, XSD::QName.new(NsXMLSchema, "anyType")]],
-      ["after", ["SOAP::SOAPString", XSD::QName.new(nil, "after")]]
-    ]
-  )
-
-  LiteralRegistry.register(
-    :class => WSDL::Any::FooBar,
-    :schema_type => XSD::QName.new(NsEchoType, "foo.bar"),
-    :schema_element => [
-      ["before", ["SOAP::SOAPString", XSD::QName.new(nil, "before")]],
-      ["any", [nil, XSD::QName.new(NsXMLSchema, "anyType")]],
-      ["after", ["SOAP::SOAPString", XSD::QName.new(nil, "after")]]
-    ]
-  )
-
-  LiteralRegistry.register(
-    :class => WSDL::Any::FooBar,
-    :schema_name => XSD::QName.new(NsEchoType, "foo.bar"),
-    :schema_element => [
-      ["before", ["SOAP::SOAPString", XSD::QName.new(nil, "before")]],
-      ["any", [nil, XSD::QName.new(NsXMLSchema, "anyType")]],
-      ["after", ["SOAP::SOAPString", XSD::QName.new(nil, "after")]]
-    ]
-  )
-
-  LiteralRegistry.register(
-    :class => WSDL::Any::SetOutputAndCompleteRequest,
-    :schema_name => XSD::QName.new(NsEchoType, "setOutputAndCompleteRequest"),
-    :schema_element => [
-      ["taskId", ["SOAP::SOAPString", XSD::QName.new(nil, "taskId")]],
-      ["data", ["WSDL::Any::SetOutputAndCompleteRequest::C_Data", XSD::QName.new(nil, "data")]],
-      ["participantToken", ["SOAP::SOAPString", XSD::QName.new(nil, "participantToken")]]
-    ]
-  )
-
-  LiteralRegistry.register(
-    :class => WSDL::Any::SetOutputAndCompleteRequest::C_Data,
-    :schema_name => XSD::QName.new(nil, "data"),
-    :is_anonymous => true,
-    :schema_qualified => false,
-    :schema_element => [
-      ["any", [nil, XSD::QName.new(NsXMLSchema, "anyType")]]
-    ]
-  )
-end
-
-end; end

data/test/wsdl/any/expectedService.rb

@@ -1,70 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: ASCII-8BIT
-require 'echoServant.rb'
-require 'echoMappingRegistry.rb'
-require 'soap/rpc/standaloneServer'
-
-module WSDL; module Any
-
-class Echo_port_type
-  NsEcho = "urn:example.com:echo"
-
-  Methods = [
-    [ "urn:example.com:echo",
-      "echo",
-      [ [:in, "parameters", ["::SOAP::SOAPElement", "urn:example.com:echo-type", "foo.bar"]],
-        [:out, "parameters", ["::SOAP::SOAPElement", "urn:example.com:echo-type", "foo.bar"]] ],
-      { :request_style =>  :document, :request_use =>  :literal,
-        :response_style => :document, :response_use => :literal,
-        :faults => {} }
-    ],
-    [ XSD::QName.new(NsEcho, "echoAny"),
-      "urn:example.com:echoAny",
-      "echoAny",
-      [ [:retval, "echoany_return", [nil]] ],
-      { :request_style =>  :rpc, :request_use =>  :encoded,
-        :response_style => :rpc, :response_use => :encoded,
-        :faults => {} }
-    ],
-    [ "urn:example.com:echo",
-      "setOutputAndComplete",
-      [ [:in, "parameters", ["::SOAP::SOAPElement", "urn:example.com:echo-type", "setOutputAndCompleteRequest"]],
-        [:out, "parameters", ["::SOAP::SOAPElement", "urn:example.com:echo-type", "setOutputAndCompleteRequest"]] ],
-      { :request_style =>  :document, :request_use =>  :literal,
-        :response_style => :document, :response_use => :literal,
-        :faults => {} }
-    ]
-  ]
-end
-
-end; end
-
-module WSDL; module Any
-
-class Echo_port_typeApp < ::SOAP::RPC::StandaloneServer
-  def initialize(*arg)
-    super(*arg)
-    servant = WSDL::Any::Echo_port_type.new
-    WSDL::Any::Echo_port_type::Methods.each do |definitions|
-      opt = definitions.last
-      if opt[:request_style] == :document
-        @router.add_document_operation(servant, *definitions)
-      else
-        @router.add_rpc_operation(servant, *definitions)
-      end
-    end
-    self.mapping_registry = EchoMappingRegistry::EncodedRegistry
-    self.literal_mapping_registry = EchoMappingRegistry::LiteralRegistry
-  end
-end
-
-end; end
-
-if $0 == __FILE__
-  # Change listen port.
-  server = WSDL::Any::Echo_port_typeApp.new('app', nil, '0.0.0.0', 10080)
-  trap(:INT) do
-    server.shutdown
-  end
-  server.start
-end

data/test/wsdl/any/test_any.rb

@@ -1,194 +0,0 @@
-# encoding: ASCII-8BIT
-require 'helper'
-require 'testutil'
-require 'wsdl/parser'
-require 'wsdl/soap/wsdl2ruby'
-require 'soap/rpc/standaloneServer'
-require 'soap/wsdlDriver'
-
-
-module WSDL; module Any
-
-
-class TestAny < Test::Unit::TestCase
-  Namespace = 'urn:example.com:echo'
-  TypeNamespace = 'urn:example.com:echo-type'
-
-  class Server < ::SOAP::RPC::StandaloneServer
-    def on_init
-      # use WSDL to serialize/deserialize
-      wsdlfile = File.join(DIR, 'any.wsdl')
-      wsdl = WSDL::Importer.import(wsdlfile)
-      port = wsdl.services[0].ports[0]
-      wsdl_elements = wsdl.collect_elements
-      wsdl_types = wsdl.collect_complextypes + wsdl.collect_simpletypes
-      rpc_decode_typemap = wsdl_types +
-        wsdl.soap_rpc_complextypes(port.find_binding)
-      @router.mapping_registry =
-        ::SOAP::Mapping::WSDLEncodedRegistry.new(rpc_decode_typemap)
-      @router.literal_mapping_registry =
-        ::SOAP::Mapping::WSDLLiteralRegistry.new(wsdl_types, wsdl_elements)
-      # add method
-      add_document_method(
-        self,
-        Namespace + ':echo',
-        'echo',
-        XSD::QName.new(TypeNamespace, 'foo.bar'),
-        XSD::QName.new(TypeNamespace, 'foo.bar')
-      )
-      add_rpc_operation(self, 
-        XSD::QName.new("urn:example.com:echo", "echoAny"),
-        "urn:example.com:echoAny",
-        "echoAny",
-        [ [:retval, "echoany_return", [XSD::QName.new("http://www.w3.org/2001/XMLSchema", "anyType")]] ],
-        { :request_style =>  :rpc, :request_use =>  :encoded,
-          :response_style => :rpc, :response_use => :encoded,
-          :faults => {} }
-      )
-    end
-  
-    def echo(arg)
-      res = FooBar.new(arg.before, arg.after)
-      res.set_any([
-        ::SOAP::SOAPElement.new("foo", "bar"),
-        ::SOAP::SOAPElement.new("baz", "qux")
-      ])
-      res
-      # TODO: arg
-    end
-
-    AnyStruct = Struct.new(:a, :b)
-    def echoAny
-      AnyStruct.new(1, Time.mktime(2007, 1, 1))
-    end
-  end
-
-  DIR = File.dirname(File.expand_path(__FILE__))
-
-  Port = 17171
-
-  def setup
-    setup_server
-    setup_classdef
-    @client = nil
-  end
-
-  def teardown
-    teardown_server if @server
-    unless $DEBUG
-      File.unlink(pathname('echo.rb')) if File.exist?(pathname('echo.rb'))
-      File.unlink(pathname('echoMappingRegistry.rb')) if File.exist?(pathname('echoMappingRegistry.rb'))
-      File.unlink(pathname('echoDriver.rb')) if File.exist?(pathname('echoDriver.rb'))
-      File.unlink(pathname('echoServant.rb')) if File.exist?(pathname('echoServant.rb'))
-      File.unlink(pathname('echo_service.rb')) if File.exist?(pathname('echo_service.rb'))
-      File.unlink(pathname('echo_serviceClient.rb')) if File.exist?(pathname('echo_serviceClient.rb'))
-    end
-    @client.reset_stream if @client
-  end
-
-  def setup_server
-    @server = Server.new('Test', Namespace, '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("any.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, 'echoDriver.rb', 'echoMappingRegistry.rb', 'echo.rb')
-  end
-
-  def teardown_server
-    @server.shutdown
-    @server_thread.kill
-    @server_thread.join
-  end
-
-  def pathname(filename)
-    File.join(DIR, filename)
-  end
-
-  def test_any
-    gen = WSDL::SOAP::WSDL2Ruby.new
-    gen.location = pathname("any.wsdl")
-    gen.basedir = DIR
-    gen.logger.level = Logger::FATAL
-    gen.opt['module_path'] = self.class.to_s.sub(/::[^:]+$/, '')
-    gen.opt['classdef'] = nil
-    gen.opt['mapping_registry'] = nil
-    gen.opt['driver'] = nil
-    gen.opt['client_skelton'] = nil
-    gen.opt['servant_skelton'] = nil
-    gen.opt['standalone_server_stub'] = nil
-    gen.opt['force'] = true
-    TestUtil.silent do
-      gen.run
-    end
-    compare("expectedEcho.rb", "echo.rb")
-    compare("expectedMappingRegistry.rb", "echoMappingRegistry.rb")
-    compare("expectedDriver.rb", "echoDriver.rb")
-    compare("expectedService.rb", "echo_service.rb")
-  end
-
-  def compare(expected, actual)
-    TestUtil.filecompare(pathname(expected), pathname(actual))
-  end
-
-  def test_anyreturl_wsdl
-    wsdl = File.join(DIR, 'any.wsdl')
-    @client = ::SOAP::WSDLDriverFactory.new(wsdl).create_rpc_driver
-    @client.endpoint_url = "http://localhost:#{Port}/"
-    @client.wiredump_dev = STDOUT if $DEBUG
-    res = @client.echoAny
-    assert_equal(1, res.a)
-    assert_equal(2007, res.b.year)
-  end
-
-  def test_wsdl
-    wsdl = File.join(DIR, 'any.wsdl')
-    @client = ::SOAP::WSDLDriverFactory.new(wsdl).create_rpc_driver
-    @client.endpoint_url = "http://localhost:#{Port}/"
-    @client.wiredump_dev = STDOUT if $DEBUG
-    arg = FooBar.new("before", "after")
-    arg.set_any(
-      [
-        ::SOAP::SOAPElement.new("foo", "bar"),
-        ::SOAP::SOAPElement.new("baz", "qux")
-      ]
-    )
-    res = @client.echo(arg)
-    assert_equal(arg.before, res.before)
-    assert_equal("bar", res.foo)
-    assert_equal("qux", res.baz)
-    assert_equal(arg.after, res.after)
-  end
-
-  def test_naive
-    @client = Echo_port_type.new
-    @client.endpoint_url = "http://localhost:#{Port}/"
-    @client.wiredump_dev = STDOUT if $DEBUG
-    arg = FooBar.new("before", "after")
-    arg.set_any(
-      [
-        ::SOAP::SOAPElement.new("foo", "bar"),
-        ::SOAP::SOAPElement.new("baz", "qux")
-      ]
-    )
-    res = @client.echo(arg)
-    assert_equal(arg.before, res.before)
-    assert_equal("bar", res.foo)
-    assert_equal("qux", res.baz)
-    assert_equal(arg.after, res.after)
-  end
-end
-
-
-end; end