rtiss_soap4r 1.6.0

data/test/interopR2/clientZSI.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# encoding: ASCII-8BIT
+
+$serverName = 'ZSI'
+
+$serverBase = 'http://63.142.188.184:1122/'
+$serverGroupB = 'http://63.142.188.184:1122/'
+
+require 'clientBase'
+#$soapAction = 'urn:soapinterop'
+
+drvBase = SOAP::RPC::Driver.new($serverBase, InterfaceNS)
+methodDef( drvBase )
+
+drvGroupB = SOAP::RPC::Driver.new($serverGroupB, InterfaceNS)
+methodDefGroupB( drvGroupB )
+
+doTestBase( drvBase )
+doTestGroupB( drvGroupB )
+submitTestResult

data/test/interopR2/clienteSOAP.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# encoding: ASCII-8BIT
+
+$serverName = 'eSoap'
+
+$serverBase = 'http://www.quakersoft.net/cgi-bin/interop2_server.cgi'
+$noEchoMap = true
+
+require 'clientBase'
+
+drvBase = SOAP::RPC::Driver.new($serverBase, InterfaceNS)
+methodDefBase(drvBase)
+
+#drvGroupB = SOAP::RPC::Driver.new($serverGroupB, InterfaceNS)
+#methodDefGroupB(drvGroupB)
+
+doTestBase(drvBase)
+#doTestGroupB(drvGroupB)
+submitTestResult

data/test/interopR2/clientgSOAP.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# encoding: ASCII-8BIT
+
+$serverName = 'gSOAP'
+
+$serverBase = 'http://websrv.cs.fsu.edu/~engelen/interop2.cgi'
+$serverGroupB = 'http://websrv.cs.fsu.edu/~engelen/interop2B.cgi'
+
+require 'clientBase'
+
+drvBase = SOAP::RPC::Driver.new($serverBase, InterfaceNS)
+methodDef(drvBase)
+
+drvGroupB = SOAP::RPC::Driver.new($serverGroupB, InterfaceNS)
+methodDefGroupB(drvGroupB)
+
+doTestBase(drvBase)
+doTestGroupB(drvGroupB)
+submitTestResult

data/test/interopR2/clientkSOAP.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# encoding: ASCII-8BIT
+
+$serverName = 'kSOAP'
+
+$serverBase = 'http://kissen.cs.uni-dortmund.de:8080/ksoapinterop'
+
+require 'clientBase'
+
+drvBase = SOAP::RPC::Driver.new($serverBase, InterfaceNS)
+methodDef(drvBase)
+
+#drvGroupB = SOAP::RPC::Driver.new($serverGroupB, InterfaceNS)
+#methodDefGroupB(drvGroupB)
+
+doTestBase(drvBase)
+#doTestGroupB(drvGroupB)
+submitTestResult

data/test/interopR2/iSimonReg.rb

@@ -0,0 +1,113 @@
+# encoding: ASCII-8BIT
+require 'soap/soap'
+require 'soap/rpcUtils'
+
+module SimonReg
+  TypeNS = 'http://soap.pocketsoap.com/registration/types'
+
+  module Services
+
+    InterfaceNS = 'http://soap.pocketsoap.com/registration/services'
+
+    class Service
+      include SOAP::Marshallable
+      @typeName = 'Service'
+      @typeNamespace = SimonReg::TypeNS
+
+      attr_accessor :id, :name, :description, :wsdlURL, :websiteURL
+
+      def initialize( id = nil, name = nil, description = nil, wsdlURL = nil, websiteURL = nil )
+
+	@id = id
+	@name = name
+	@description = description
+	@wsdlURL = wsdlURL
+	@websiteURL = websiteURL
+      end
+    end
+
+    Methods = {
+      'ServiceList' => [ 'services' ],
+      'Servers' => [ 'Servers', 'serviceID' ],
+      'Clients' => [ 'Clients', 'serviceID' ],
+    }
+  end
+
+  module Clients
+
+    InterfaceNS = 'http://soap.pocketsoap.com/registration/clients'
+
+    class ClientInfo
+      include SOAP::Marshallable
+      @typeName = 'clientInfo'
+      @typeNamespace = SimonReg::TypeNS
+
+      attr_accessor :name, :version, :resultsURL
+
+      def initialize( name = nil, version = nil, resultsURL = nil )
+
+	@name = name
+	@version = version
+	@resultsURL = resultsURL
+      end
+    end
+
+    Methods = {
+      'RegisterClient' => [ 'clientID', 'serviceID', 'clientInfo' ],
+      'UpdateClient' => [ 'void', 'clientID', 'clientInfo' ],
+      'RemoveClient' => [ 'void', 'clientID' ],
+    }
+  end
+
+  module Servers
+
+    InterfaceNS = 'http://soap.pocketsoap.com/registration/servers'
+
+    class ServerInfo
+      include SOAP::Marshallable
+      @typeName = 'serverInfo'
+      @typeNamespace = SimonReg::TypeNS
+
+      attr_accessor :name, :version, :endpointURL, :wsdlURL
+
+      def initialize( name = nil, version = nil, endpointURL = nil, wsdlURL = nil )
+
+	@name = name
+	@version = version
+	@endpointURL = endpointURL
+	@wsdlURL = wsdlURL
+      end
+    end
+
+    Methods = {
+      'RegisterServer' => [ 'serverID', 'serviceID', 'serverInfo' ],
+      'UpdateServer' => [ 'void', 'serverID', 'serverInfo' ],
+      'RemoveServer' => [ 'void', 'serverID' ],
+    }
+  end
+
+  module Subscriber
+
+    InterfaceNS = 'http://soap.pocketsoap.com/registration/subscriber'
+
+    class SubscriberInfo
+      include SOAP::Marshallable
+      @typeName = 'subscriberInfo'
+      @typeNamespace = SimonReg::TypeNS
+
+      attr_accessor :notificationID, :expires
+
+      def initialize( notificationID = nil, expires = nil )
+
+	@notificationID = notificationID
+	@expires = expires
+      end
+    end
+
+    Methods = {
+      'Subscribe' => [ 'subscriberInfo', 'serviceID', 'ServerChanges', 'ClientChanges', 'NotificationURL' ],
+      'Renew' => [ 'expires', 'notificationID' ],
+      'Cancel' => [ 'void', 'notificationID' ],
+    }
+  end
+end

data/test/interopR2/interopResultBase.rb

@@ -0,0 +1,115 @@
+# encoding: ASCII-8BIT
+require 'soap/mapping'
+
+
+module SOAPBuildersInteropResult
+extend SOAP
+
+
+InterfaceNS = 'http://www.jin.gr.jp/~nahi/Ruby/SOAP4R/SOAPBuildersInteropResult/0.0.1'
+TypeNS = 'http://www.jin.gr.jp/~nahi/Ruby/SOAP4R/SOAPBuildersInteropResult/type/0.0.1'
+
+
+class Endpoint
+  include SOAP::Marshallable
+
+  attr_accessor :processorName, :processorVersion, :endpointName, :uri, :wsdl
+
+  def initialize( endpointName = nil, uri = nil, wsdl = nil )
+    @processorName = 'unknown'
+    @processorVersion = nil
+    @endpointName = endpointName
+    @uri = uri
+    @wsdl = wsdl
+  end
+  
+  def name
+    if @endpointName
+      @endpointName
+    elsif @processorVersion
+      "#{ @processorName }-#{ @processorVersion }"
+    else
+      "#{ @processorName }"
+    end
+  end
+end
+
+
+class TestResult
+  include SOAP::Marshallable
+
+  attr_accessor :testName, :result, :comment, :wiredump
+
+  def initialize( testName, result, comment = nil, wiredump = nil )
+    @testName = testName
+    @result = result
+    @comment = comment
+    @wiredump = wiredump
+  end
+end
+
+
+class InteropResults
+  include SOAP::Marshallable
+  include Enumerable
+
+  attr_accessor :dateTime, :server, :client
+
+  def initialize( client = nil, server = nil )
+    @dateTime = Time.now
+    @server = server
+    @client = client
+    @testResults = []
+  end
+
+  def add( testResult )
+    @testResults << testResult
+  end
+
+  def clear
+    @testResults.clear
+  end
+
+  def each
+    @testResults.each do | item |
+      yield( item )
+    end
+  end
+
+  def size
+    @testResults.size
+  end
+end
+
+
+Methods = [
+  [ 'addResults', [:in, 'interopResults' ]],
+  [ 'deleteResults', [:in, 'client'], [:in, 'server']],
+]
+
+
+
+MappingRegistry = SOAP::Mapping::Registry.new
+
+MappingRegistry.set(
+  ::SOAPBuildersInteropResult::Endpoint,
+  ::SOAP::SOAPStruct,
+  ::SOAP::Mapping::Registry::TypedStructFactory,
+  [ XSD::QName.new(TypeNS, 'Endpoint') ]
+)
+
+MappingRegistry.set(
+  ::SOAPBuildersInteropResult::TestResult,
+  ::SOAP::SOAPStruct,
+  ::SOAP::Mapping::Registry::TypedStructFactory,
+  [ XSD::QName.new(TypeNS, 'TestResult') ]
+)
+MappingRegistry.set(
+  ::SOAPBuildersInteropResult::InteropResults,
+  ::SOAP::SOAPStruct,
+  ::SOAP::Mapping::Registry::TypedStructFactory,
+  [ XSD::QName.new(TypeNS, 'InteropResults') ]
+)
+
+
+end

data/test/interopR2/interopService.rb

@@ -0,0 +1,248 @@
+# encoding: ASCII-8BIT
+require 'interopbase'
+
+class InteropService
+  include SOAP
+
+  # In echoVoid, 'retval' is not defined.  So nothing will be returned.
+  def echoVoid
+    return SOAP::RPC::SOAPVoid.new
+  end
+
+  def echoBoolean(inputBoolean)
+    inputBoolean
+  end
+
+  def echoString(inputString)
+    clone(inputString)
+  end
+
+  def echoStringArray(inputStringArray)
+    clone(inputStringArray)
+  end
+
+  def echoInteger(inputInteger)
+    SOAP::SOAPInt.new(clone(inputInteger))
+  end
+
+  def echoIntegerArray(inputIntegerArray)
+    clone(inputIntegerArray)
+  end
+
+  # Float is mapped to SOAPDouble by default.
+  def echoFloat(inputFloat)
+    SOAP::SOAPFloat.new(inputFloat)
+  end
+
+  def echoDecimal(inputDecimal)
+    SOAP::SOAPDecimal.new(clone(inputDecimal))
+  end
+
+  def echoFloatArray(inputFloatArray)
+    outArray = SOAPBuildersInterop::FloatArray.new
+    inputFloatArray.each do |f|
+      outArray << SOAPFloat.new(f)
+    end
+    outArray
+  end
+
+  def echoStruct(inputStruct)
+    clone_Struct(inputStruct)
+  end
+
+  def echoStructArray(inputStructArray)
+    clone_StructArray(inputStructArray)
+  end
+
+  def echoDate(inputDate)
+    clone(inputDate)
+  end
+
+  def echoBase64(inputBase64)
+    o = SOAP::SOAPBase64.new(clone(inputBase64))
+    o.as_xsd
+    o
+  end
+
+  def echoHexBinary(inputHexBinary)
+    SOAP::SOAPHexBinary.new(clone(inputHexBinary))
+  end
+
+  def echoDouble(inputDouble)
+    SOAP::SOAPDouble.new(inputDouble)
+  end
+
+  # for Round 2 group B
+  def echoStructAsSimpleTypes(inputStruct)
+    outputString = inputStruct.varString
+    outputInteger = inputStruct.varInt
+    outputFloat = inputStruct.varFloat ? SOAPFloat.new(inputStruct.varFloat) : nil
+    # retVal is not returned to SOAP client because retVal of this method is
+    #   not defined in method definition.
+    # retVal, out, out, out
+    return nil, outputString, outputInteger, outputFloat
+  end
+
+  def echoSimpleTypesAsStruct(inputString, inputInt, inputFloat)
+    SOAPBuildersInterop::SOAPStruct.new(inputInt, inputFloat, inputString)
+  end
+
+  def echo2DStringArray(ary)
+    # In Ruby, M-D Array is converted to Array of Array now.
+    mdary = SOAP::Mapping.ary2md(ary, 2, XSD::Namespace, XSD::StringLiteral)
+    if mdary.include?(nil)
+      mdary.sparse = true
+    end
+    mdary
+  end
+
+  def echoNestedStruct(inputStruct)
+    clone_StructStruct(inputStruct)
+  end
+
+  def echoNestedArray(inputStruct)
+    clone_Struct(inputStruct)
+  end
+
+  def echoMap(inputMap)
+    clone(inputMap)
+  end
+
+  def echoMapArray(inputMapArray)
+    clone(inputMapArray)
+  end
+
+  def echoPolyMorph(anObject)
+    clone(anObject)
+  end
+
+  alias echoPolyMorphStruct echoPolyMorph
+  alias echoPolyMorphArray echoPolyMorph
+
+
+  def echoXSDBoolean(inputBoolean)
+    inputBoolean
+  end
+
+  def echoXSDString(inputString)
+    clone(inputString)
+  end
+
+  def echoXSDDecimal(inputDecimal)
+    SOAP::SOAPDecimal.new(clone(inputDecimal))
+  end
+
+  def echoXSDFloat(inputFloat)
+    SOAPFloat.new(inputFloat)
+  end
+
+  def echoXSDDouble(inputDouble)
+    SOAP::SOAPDouble.new(clone(inputDouble))
+  end
+
+  def echoXSDDuration(inputDuration)
+    SOAP::SOAPDuration.new(clone(inputDuration))
+  end
+
+  def echoXSDDateTime(inputXSDDateTime)
+    clone(inputXSDDateTime)
+  end
+
+  def echoXSDTime(inputXSDTime)
+    SOAP::SOAPTime.new(clone(inputXSDTime))
+  end
+
+  def echoXSDDate(inputXSDDate)
+    SOAP::SOAPDate.new(clone(inputXSDDate))
+  end
+
+  def echoXSDgYearMonth(inputGYearMonth)
+    SOAP::SOAPgYearMonth.new(clone(inputGYearMonth))
+  end
+
+  def echoXSDgYear(inputGYear)
+    SOAP::SOAPgYear.new(clone(inputGYear))
+  end
+
+  def echoXSDgMonthDay(inputGMonthDay)
+    SOAP::SOAPgMonthDay.new(clone(inputGMonthDay))
+  end
+
+  def echoXSDgDay(inputGDay)
+    SOAP::SOAPgDay.new(clone(inputGDay))
+  end
+
+  def echoXSDgMonth(inputGMonth)
+    SOAP::SOAPgMonth.new(clone(inputGMonth))
+  end
+
+  def echoXSDHexBinary(inputHexBinary)
+    SOAP::SOAPHexBinary.new(clone(inputHexBinary))
+  end
+
+  def echoXSDBase64(inputBase64)
+    o = SOAP::SOAPBase64.new(clone(inputBase64))
+    o.as_xsd
+    o
+  end
+
+  def echoXSDanyURI(inputAnyURI)
+    clone(inputAnyURI)
+  end
+
+  def echoXSDQName(inputQName)
+    SOAP::SOAPQName.new(clone(inputQName))
+  end
+
+  def echoXSDInteger(inputXSDInteger)
+    clone(inputXSDInteger)
+  end
+
+  def echoXSDLong(inputLong)
+    SOAP::SOAPLong.new(clone(inputLong))
+  end
+
+  def echoXSDInt(inputInt)
+    SOAP::SOAPInt.new(clone(inputInteger))
+  end
+
+  def echoPolyMorph(anObject)
+    clone(anObject)
+  end
+
+  alias echoPolyMorphStruct echoPolyMorph
+  alias echoPolyMorphArray echoPolyMorph
+
+private
+
+  def clone(obj)
+    begin
+      return Marshal.load(Marshal.dump(obj))
+    rescue TypeError
+      return obj
+    end
+  end
+
+  def clone_Struct(struct)
+    result = clone(struct)
+    result.varFloat = SOAPFloat.new(struct.varFloat) if struct.varFloat
+    result
+  end
+  
+  def clone_StructArray(structArray)
+    result = clone(structArray)
+    result.map { |ele|
+      ele.varFloat = SOAPFloat.new(ele.varFloat) if ele.varFloat
+    }
+    result
+  end
+  
+  def clone_StructStruct(structStruct)
+    result = clone(structStruct)
+    result.varFloat = SOAPFloat.new(structStruct.varFloat) if structStruct.varFloat
+    if struct = result.varStruct
+      struct.varFloat = SOAPFloat.new(struct.varFloat) if struct.varFloat
+    end
+    result
+  end
+end

data/test/interopR2/rwikiInteropService.rb

@@ -0,0 +1,106 @@
+# encoding: ASCII-8BIT
+require 'drb/drb'
+require 'rw-lib'
+require 'interopResultBase'
+
+class RWikiInteropService
+  def initialize
+    @rwiki_uri = 'druby://localhost:7174'
+    @rwiki = DRbObject.new(nil, @rwiki_uri)
+  end
+
+  #  [ 'addResults', [:in, 'interopResults' ]]
+  #  [ 'deleteResults', [:in, 'client'], [:in, 'server']]
+
+  def addResults(interopResults)
+    pageName = pageName(interopResults.client, interopResults.server)
+
+    passResults = interopResults.find_all { | testResult |
+      testResult.result
+    }
+    passStr = passResults.collect { | passResult |
+      str = "* #{ passResult.testName } ((<[wiredump]|\"##{passResult.testName}\">))\n"
+      if passResult.comment
+	str << "\n  #{ passResult.comment.gsub(/[\r\n]/, '') }\n"
+      end
+      str
+    }
+    passStr = 'Nothing...' if passStr.empty?
+
+    failResults = interopResults.find_all { | testResult |
+      !testResult.result
+    }
+    failStr = failResults.collect { | failResult |
+      str = ":#{ failResult.testName } ((<[wiredump]|\"##{failResult.testName}\">))\n  Result:\n"
+      resultStr = failResult.comment.gsub(/\r?\n/, "\n    ")
+      str << "    #{ resultStr }\n"
+      str
+    }
+    failStr = 'Nothing!' if failStr.empty?
+
+    pageStr =<<__EOS__
+= #{ pageName }
+
+* Date: #{ interopResults.dateTime }
+* Server
+  * Name: #{ interopResults.server.name }
+  * Endpoint: #{ interopResults.server.uri }
+  * WSDL: #{ interopResults.server.wsdl }
+* Client
+  * Name: #{ interopResults.client.name }
+  * Endpoint: #{ interopResults.client.uri }
+  * WSDL: #{ interopResults.client.wsdl }
+
+== Pass
+
+#{ passResults.size } / #{ interopResults.size }
+
+#{ passStr }
+
+== Fail
+
+#{ failResults.size } / #{ interopResults.size }
+
+#{ failStr }
+
+== Wiredumps
+
+__EOS__
+
+    interopResults.each do | testResult |
+      pageStr <<<<__EOS__
+=== #{ testResult.testName }
+
+  #{ testResult.wiredump.gsub(/\r/, '^M').gsub(/\t/, '^I').gsub(/\n/, "\n  ") }
+
+__EOS__
+    end
+
+    set(pageName, pageStr)
+
+    msg = "; #{ passResults.size } / #{ interopResults.size } (#{ interopResults.dateTime })"
+    addLink(pageName, msg)
+  end
+
+  def deleteResults(client, server)
+    set(pageName(client, server), '')
+  end
+
+private
+
+  def set(pageName, pageSrc)
+    page = @rwiki.page(pageName)
+    page.src = pageSrc
+  end
+
+  def pageName(client, server)
+    "InteropResults::#{ client.name }-#{ server.name }"
+  end
+
+  def addLink(pageName, msg)
+    page = @rwiki.page('InteropResults')
+    # Race condition...  Page source might be mixed with others's.
+    page.src = (page.src || '') << "\n* ((<\"#{ pageName }\">))\n  #{ msg }"
+  end
+end
+