soap5r 2.0.0

data/test/wsdl/fault/test_fault.rb

@@ -0,0 +1,120 @@
+# encoding: ASCII-8BIT
+require 'helper'
+require 'testutil'
+require 'wsdl/soap/wsdl2ruby'
+require 'soap/wsdlDriver'
+
+
+module WSDL; module Fault
+
+
+class TestFault < Test::Unit::TestCase
+  DIR = File.dirname(File.expand_path(__FILE__))
+  Port = 17171
+
+  def setup
+    setup_classdef
+    setup_server
+    @client = nil
+  end
+
+  def teardown
+    teardown_server if defined?(@server)
+    unless $DEBUG
+      File.unlink(pathname('Add.rb'))
+      File.unlink(pathname('AddMappingRegistry.rb'))
+      File.unlink(pathname('AddServant.rb'))
+      File.unlink(pathname('AddService.rb'))
+    end
+    @client.reset_stream if @client
+  end
+
+  def setup_server
+    AddPortType.class_eval do
+      define_method(:add) do |request|
+        @sum ||= 0
+        if (request.value > 100)
+        fault = AddFault.new("Value #{request.value} is too large", "Critical")
+          raise fault
+        end
+        @sum += request.value
+        return AddResponse.new(@sum)
+      end
+    end
+    @server = AddPortTypeApp.new('app', nil, '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("fault.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['servant_skelton'] = nil
+    gen.opt['standalone_server_stub'] = nil
+    gen.opt['force'] = true
+    TestUtil.silent do
+      gen.run
+    end
+    TestUtil.require(DIR, 'Add.rb', 'AddMappingRegistry.rb', 'AddServant.rb', 'AddService.rb')
+  end
+
+  def teardown_server
+    @server.shutdown
+    @server_thread.kill
+    @server_thread.join
+  end
+
+  def pathname(filename)
+    File.join(DIR, filename)
+  end
+
+  def test_driver
+    @client = ::SOAP::RPC::Driver.new("http://localhost:#{Port}/")
+    @client.mapping_registry = AddMappingRegistry::EncodedRegistry
+    @client.literal_mapping_registry = AddMappingRegistry::LiteralRegistry
+    @client.add_document_operation(
+      "Add",
+      "add",
+      [ [:in, "request", ["::SOAP::SOAPElement", "http://fault.test/Faulttest", "Add"]],
+        [:out, "response", ["::SOAP::SOAPElement", "http://fault.test/Faulttest", "AddResponse"]] ],
+      { :request_style =>  :document, :request_use =>  :literal,
+        :response_style => :document, :response_use => :literal,
+        :faults => {"AddFault"=>{:namespace=>nil, :name=>"AddFault", :use=>"literal", :encodingstyle=>"document", :ns=>"http://fault.test/Faulttest"}} }
+    )
+    @client.wiredump_dev = STDOUT if $DEBUG
+    do_test(@client)
+  end
+
+  def test_wsdl
+    wsdl = File.join(DIR, 'fault.wsdl')
+    @client = ::SOAP::WSDLDriverFactory.new(wsdl).create_rpc_driver
+    @client.endpoint_url = "http://localhost:#{Port}/"
+    @client.mapping_registry = AddMappingRegistry::EncodedRegistry
+    @client.literal_mapping_registry = AddMappingRegistry::LiteralRegistry
+    @client.wiredump_dev = STDOUT if $DEBUG
+    do_test(@client)
+  end
+
+  def do_test(client)
+    assert_equal(100, client.add(Add.new(100)).sum)
+    assert_equal(100, client.add(Add.new(0)).sum)
+    assert_equal(150, client.add(Add.new(50)).sum)
+    begin
+      client.add(Add.new(101))
+      assert(false)
+    rescue Exception => e
+      assert_equal(::SOAP::FaultError, e.class)
+      assert_equal("WSDL::Fault::AddFault", e.faultstring.data)
+      assert_equal("Value 101 is too large", e.detail.addFault.reason)
+      assert_equal("Critical", e.detail.addFault.severity)
+    end
+  end
+end
+
+
+end; end

data/test/wsdl/fault/test_multifault.rb

@@ -0,0 +1,135 @@
+# encoding: ASCII-8BIT
+require 'helper'
+require 'testutil'
+require 'wsdl/soap/wsdl2ruby'
+require 'soap/wsdlDriver'
+
+
+module WSDL; module Fault
+
+
+class TestMultiFault < Test::Unit::TestCase
+  DIR = File.dirname(File.expand_path(__FILE__))
+  Port = 17171
+
+  def setup
+    setup_classdef
+    setup_server
+    @client = nil
+  end
+
+  def teardown
+    teardown_server if defined?(@server)
+    unless $DEBUG
+      File.unlink(pathname('AddMulti.rb'))
+      File.unlink(pathname('AddMultiMappingRegistry.rb'))
+      File.unlink(pathname('AddMultiServant.rb'))
+      File.unlink(pathname('AddMultiService.rb'))
+    end
+    @client.reset_stream if @client
+  end
+
+  def setup_server
+    AddPortType.class_eval do
+      define_method(:add) do |request|
+        @sum ||= 0
+        if (request.value > 100)
+          fault = AddMultiFault.new("Value #{request.value} is too large", "Critical")
+          raise fault
+        end
+
+        if (request.value < 0)
+          fault = NegativeValueFault.new("Value #{request.value} is negative", "Fatal")
+          raise fault
+        end
+
+        @sum += request.value
+        return AddResponse.new(@sum)
+      end
+    end
+    @server = AddPortTypeApp.new('app', nil, '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("multifault.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['servant_skelton'] = nil
+    gen.opt['standalone_server_stub'] = nil
+    gen.opt['force'] = true
+    TestUtil.silent do
+      gen.run
+    end
+    TestUtil.require(DIR, 'AddMulti.rb', 'AddMultiMappingRegistry.rb', 'AddMultiServant.rb', 'AddMultiService.rb')
+  end
+
+  def teardown_server
+    @server.shutdown
+    @server_thread.kill
+    @server_thread.join
+  end
+
+  def pathname(filename)
+    File.join(DIR, filename)
+  end
+
+  def test_driver
+    @client = ::SOAP::RPC::Driver.new("http://localhost:#{Port}/")
+    @client.mapping_registry = AddMappingRegistry::EncodedRegistry
+    @client.literal_mapping_registry = AddMappingRegistry::LiteralRegistry
+    @client.add_document_operation(
+      "Add",
+      "add",
+      [ [:in, "request", ["::SOAP::SOAPElement", "http://fault.test/Faulttest", "Add"]],
+        [:out, "response", ["::SOAP::SOAPElement", "http://fault.test/Faulttest", "AddResponse"]] ],
+      { :request_style =>  :document, :request_use =>  :literal,
+        :response_style => :document, :response_use => :literal,
+        :faults => {"AddMultiFault"=>{:namespace=>nil, :name=>"AddMultiFault", :use=>"literal", :encodingstyle=>"document", :ns=>"http://fault.test/Faulttest"}} }
+    )
+    @client.wiredump_dev = STDOUT if $DEBUG
+    do_test(@client)
+  end
+
+  def test_wsdl
+    wsdl = File.join(DIR, 'multifault.wsdl')
+    @client = ::SOAP::WSDLDriverFactory.new(wsdl).create_rpc_driver
+    @client.endpoint_url = "http://localhost:#{Port}/"
+    @client.mapping_registry = AddMappingRegistry::EncodedRegistry
+    @client.literal_mapping_registry = AddMappingRegistry::LiteralRegistry
+    @client.wiredump_dev = STDOUT if $DEBUG
+    do_test(@client)
+  end
+
+  def do_test(client)
+    assert_equal(100, client.add(Add.new(100)).sum)
+    assert_equal(100, client.add(Add.new(0)).sum)
+    assert_equal(150, client.add(Add.new(50)).sum)
+    begin
+      client.add(Add.new(101))
+      assert(false)
+    rescue Exception => e
+      assert_equal(::SOAP::FaultError, e.class)
+      assert_equal("WSDL::Fault::AddMultiFault", e.faultstring.data)
+      assert_equal("Value 101 is too large", e.detail.addMultiFault.reason)
+      assert_equal("Critical", e.detail.addMultiFault.severity)
+    end
+    begin
+      client.add(Add.new(-50))
+      assert(false)
+    rescue Exception => e
+      assert_equal(::SOAP::FaultError, e.class)
+      assert_equal("WSDL::Fault::NegativeValueFault", e.faultstring.data)
+      assert_equal("Value -50 is negative", e.detail.negativeValueFault.reason)
+      assert_equal("Fatal", e.detail.negativeValueFault.severity)
+    end
+  end
+end
+
+
+end; end

data/test/wsdl/group/expectedClassdef.rb

@@ -0,0 +1,59 @@
+# encoding: ASCII-8BIT
+require 'xsd/qname'
+
+module WSDL; module Group
+
+
+# {urn:grouptype}groupele_type
+#   comment - SOAP::SOAPString
+#   element - SOAP::SOAPString
+#   eletype - SOAP::SOAPString
+#   var - SOAP::SOAPString
+#   xmlattr_attr_min - SOAP::SOAPDecimal
+#   xmlattr_attr_max - SOAP::SOAPDecimal
+class Groupele_type
+  AttrAttr_max = XSD::QName.new(nil, "attr_max")
+  AttrAttr_min = XSD::QName.new(nil, "attr_min")
+
+  attr_accessor :comment
+  attr_reader :__xmlele_any
+  attr_accessor :element
+  attr_accessor :eletype
+  attr_accessor :var
+
+  def set_any(elements)
+    @__xmlele_any = elements
+  end
+
+  def __xmlattr
+    @__xmlattr ||= {}
+  end
+
+  def xmlattr_attr_min
+    __xmlattr[AttrAttr_min]
+  end
+
+  def xmlattr_attr_min=(value)
+    __xmlattr[AttrAttr_min] = value
+  end
+
+  def xmlattr_attr_max
+    __xmlattr[AttrAttr_max]
+  end
+
+  def xmlattr_attr_max=(value)
+    __xmlattr[AttrAttr_max] = value
+  end
+
+  def initialize(comment = nil, element = nil, eletype = nil, var = nil)
+    @comment = comment
+    @__xmlele_any = nil
+    @element = element
+    @eletype = eletype
+    @var = var
+    @__xmlattr = {}
+  end
+end
+
+
+end; end

data/test/wsdl/group/expectedDriver.rb

@@ -0,0 +1,52 @@
+# encoding: ASCII-8BIT
+require 'echo.rb'
+require 'echoMappingRegistry.rb'
+require 'soap/rpc/driver'
+
+module WSDL::Group
+
+class Group_porttype < ::SOAP::RPC::Driver
+  DefaultEndpointUrl = "http://localhost:17171/"
+
+  Methods = [
+    [ "urn:group:echo",
+      "echo",
+      [ [:in, "parameters", ["::SOAP::SOAPElement", "urn:grouptype", "groupele"]],
+        [:out, "parameters", ["::SOAP::SOAPElement", "urn:grouptype", "groupele"]] ],
+      { :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/group/expectedMappingRegistry.rb

@@ -0,0 +1,68 @@
+# encoding: ASCII-8BIT
+require 'echo.rb'
+require 'soap/mapping'
+
+module WSDL; module Group
+
+module EchoMappingRegistry
+  EncodedRegistry = ::SOAP::Mapping::EncodedRegistry.new
+  LiteralRegistry = ::SOAP::Mapping::LiteralRegistry.new
+  NsGrouptype = "urn:grouptype"
+  NsXMLSchema = "http://www.w3.org/2001/XMLSchema"
+
+  EncodedRegistry.register(
+    :class => WSDL::Group::Groupele_type,
+    :schema_type => XSD::QName.new(NsGrouptype, "groupele_type"),
+    :schema_element => [
+      ["comment", "SOAP::SOAPString", [0, 1]],
+      ["any", [nil, XSD::QName.new(NsXMLSchema, "anyType")]],
+      [ :choice,
+        ["element", ["SOAP::SOAPString", XSD::QName.new(nil, "element")]],
+        ["eletype", ["SOAP::SOAPString", XSD::QName.new(nil, "eletype")]]
+      ],
+      ["var", ["SOAP::SOAPString", XSD::QName.new(nil, "var")]]
+    ],
+    :schema_attribute => {
+      XSD::QName.new(nil, "attr_min") => "SOAP::SOAPDecimal",
+      XSD::QName.new(nil, "attr_max") => "SOAP::SOAPDecimal"
+    }
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Group::Groupele_type,
+    :schema_type => XSD::QName.new(NsGrouptype, "groupele_type"),
+    :schema_element => [
+      ["comment", "SOAP::SOAPString", [0, 1]],
+      ["any", [nil, XSD::QName.new(NsXMLSchema, "anyType")]],
+      [ :choice,
+        ["element", ["SOAP::SOAPString", XSD::QName.new(nil, "element")]],
+        ["eletype", ["SOAP::SOAPString", XSD::QName.new(nil, "eletype")]]
+      ],
+      ["var", ["SOAP::SOAPString", XSD::QName.new(nil, "var")]]
+    ],
+    :schema_attribute => {
+      XSD::QName.new(nil, "attr_min") => "SOAP::SOAPDecimal",
+      XSD::QName.new(nil, "attr_max") => "SOAP::SOAPDecimal"
+    }
+  )
+
+  LiteralRegistry.register(
+    :class => WSDL::Group::Groupele_type,
+    :schema_name => XSD::QName.new(NsGrouptype, "groupele"),
+    :schema_element => [
+      ["comment", "SOAP::SOAPString", [0, 1]],
+      ["any", [nil, XSD::QName.new(NsXMLSchema, "anyType")]],
+      [ :choice,
+        ["element", ["SOAP::SOAPString", XSD::QName.new(nil, "element")]],
+        ["eletype", ["SOAP::SOAPString", XSD::QName.new(nil, "eletype")]]
+      ],
+      ["var", ["SOAP::SOAPString", XSD::QName.new(nil, "var")]]
+    ],
+    :schema_attribute => {
+      XSD::QName.new(nil, "attr_min") => "SOAP::SOAPDecimal",
+      XSD::QName.new(nil, "attr_max") => "SOAP::SOAPDecimal"
+    }
+  )
+end
+
+end; end

data/test/wsdl/group/group.wsdl

@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="utf-8"?>
+<definitions
+    name="echo"
+    targetNamespace="urn:group"
+    xmlns:tns="urn:group"
+    xmlns:txd="urn:grouptype"
+    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+    xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
+    xmlns="http://schemas.xmlsoap.org/wsdl/">
+    <types>
+      <xsd:schema elementFormDefault="unqualified" targetNamespace="urn:grouptype">
+
+        <xsd:element name="comment" type="xsd:string"/>
+
+        <xsd:simpleType name="attr_type">
+          <xsd:restriction base="xsd:decimal">
+            <xsd:maxInclusive value="-50"/>
+            <xsd:minInclusive value="50"/>
+          </xsd:restriction>
+        </xsd:simpleType>
+
+        <xsd:group name="common">
+          <xsd:sequence>
+            <xsd:element ref="txd:comment" minOccurs="0"/>
+            <xsd:any namespace="##any" minOccurs="0"/>
+          </xsd:sequence>
+        </xsd:group>
+
+        <xsd:attributeGroup name="common_attr">
+          <xsd:attribute name="attr_min" type="txd:attr_type" default="0"/>
+          <xsd:attribute name="attr_max" type="txd:attr_type" default="0"/>
+        </xsd:attributeGroup>
+
+        <xsd:group name="common_element">
+          <xsd:sequence>
+            <xsd:group ref="txd:common"/>
+            <xsd:choice>
+              <xsd:element name="element" type="xsd:string"/>
+              <xsd:element name="eletype" type="xsd:string"/>
+            </xsd:choice>
+          </xsd:sequence>
+        </xsd:group>
+
+        <xsd:complexType name="groupele_type">
+          <xsd:sequence>
+            <xsd:group ref="txd:common_element"/>
+            <xsd:element name="var" type="xsd:string"/>
+          </xsd:sequence>
+          <xsd:attributeGroup ref="txd:common_attr"/>
+        </xsd:complexType>
+
+        <xsd:element name="groupele" type="txd:groupele_type"/>
+      </xsd:schema>
+    </types>
+
+  <message name="echo_in">
+    <part name="parameters" element="txd:groupele" />
+  </message>
+  <message name="echo_out">
+    <part name="parameters" element="txd:groupele" />
+  </message>
+
+  <portType name="group_porttype">
+    <operation name="echo">
+      <input message="tns:echo_in" />
+      <output message="tns:echo_out" />
+    </operation>
+  </portType>
+
+  <binding name="group_binding" type="tns:group_porttype">
+    <soap:binding transport="http://schemas.xmlsoap.org/soap/http" style="document" />
+    <operation name="echo">
+      <soap:operation soapAction="urn:group:echo" style="document" />
+      <input>
+        <soap:body use="literal" />
+      </input>
+      <output>
+        <soap:body use="literal" />
+      </output>
+    </operation>
+  </binding>
+
+  <service name="group_service">
+    <port name="docprc_service_port" binding="tns:group_binding">
+      <soap:address location="http://localhost:17171/" />
+    </port>
+  </service>
+</definitions>

data/test/wsdl/group/test_rpc.rb

@@ -0,0 +1,146 @@
+# encoding: ASCII-8BIT
+require 'helper'
+require 'testutil'
+require 'wsdl/parser'
+require 'wsdl/soap/wsdl2ruby'
+require 'soap/rpc/standaloneServer'
+require 'soap/wsdlDriver'
+
+
+module WSDL; module Group
+
+
+class TestGroup < Test::Unit::TestCase
+  class Server < ::SOAP::RPC::StandaloneServer
+    Namespace = 'urn:group'
+    TypeNamespace = 'urn:grouptype'
+
+    def on_init
+      add_document_method(
+        self,
+        Namespace + ':echo',
+        'echo',
+        XSD::QName.new(TypeNamespace, 'groupele'),
+        XSD::QName.new(TypeNamespace, 'groupele')
+      )
+      self.literal_mapping_registry = EchoMappingRegistry::LiteralRegistry
+    end
+  
+    def echo(arg)
+      # arg
+      # need to convert for 'any'
+      ret = Groupele_type.new(arg.comment, arg.element, arg.eletype, arg.var)
+      ret.xmlattr_attr_max = arg.xmlattr_attr_max
+      ret.xmlattr_attr_min = arg.xmlattr_attr_min
+      ret.set_any([::SOAP::SOAPElement.new("foo", arg.foo)])
+      ret
+    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
+    File.unlink(pathname('echo.rb')) unless $DEBUG
+    File.unlink(pathname('echoMappingRegistry.rb')) unless $DEBUG
+    File.unlink(pathname('echoDriver.rb')) unless $DEBUG
+    @client.reset_stream if @client
+  end
+
+  def setup_server
+    @server = Server.new('Test', "urn:group", '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("group.wsdl")
+    gen.basedir = DIR
+    gen.logger.level = Logger::FATAL
+    gen.opt['classdef'] = nil
+    gen.opt['mapping_registry'] = nil
+    gen.opt['driver'] = nil
+    gen.opt['module_path'] = self.class.to_s.sub(/::[^:]+$/, '')
+    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 compare(expected, actual)
+    TestUtil.filecompare(pathname(expected), pathname(actual))
+  end
+
+  def test_generate
+    compare("expectedClassdef.rb", "echo.rb")
+    compare("expectedMappingRegistry.rb", "echoMappingRegistry.rb")
+    compare("expectedDriver.rb", "echoDriver.rb")
+  end
+
+  def test_wsdl
+    wsdl = File.join(DIR, 'group.wsdl')
+    @client = ::SOAP::WSDLDriverFactory.new(wsdl).create_rpc_driver
+    @client.endpoint_url = "http://localhost:#{Port}/"
+    @client.wiredump_dev = STDOUT if $DEBUG
+    @client.literal_mapping_registry = EchoMappingRegistry::LiteralRegistry
+    #
+    do_test_arg
+  end
+
+  def test_naive
+    @client = ::SOAP::RPC::Driver.new("http://localhost:#{Port}/")
+    @client.add_document_method('echo', 'urn:group:echo',
+      XSD::QName.new('urn:grouptype', 'groupele'),
+      XSD::QName.new('urn:grouptype', 'groupele'))
+    @client.literal_mapping_registry = EchoMappingRegistry::LiteralRegistry
+    @client.wiredump_dev = STDOUT if $DEBUG
+    #
+    do_test_arg
+  end
+
+  def test_stub
+    @client = Group_porttype.new("http://localhost:#{Port}/")
+    @client.wiredump_dev = STDOUT if $DEBUG
+    #
+    do_test_arg
+  end
+
+  def do_test_arg
+    arg = Groupele_type.new
+    arg.comment = "comment"
+    arg.set_any(
+      [::SOAP::SOAPElement.new("foo", "bar")]
+    )
+    arg.eletype = "eletype"
+    arg.var = "var"
+    arg.xmlattr_attr_min = -3
+    arg.xmlattr_attr_max = 3
+    ret = @client.echo(arg)
+    assert_equal(arg.comment, ret.comment)
+    assert_equal(arg.eletype, ret.eletype)
+    assert_nil(ret.element)
+    assert_equal(arg.var, ret.var)
+    assert_equal("bar", ret.foo)
+  end
+end
+
+
+end; end