rtiss_soap4r 2.1.0 → 3.0.0.beta

data/test/soap/ssl/sslsvr.rb

@@ -0,0 +1,57 @@
+require 'webrick/https'
+require 'logger'
+require 'rbconfig'
+require 'soap/rpc/httpserver'
+require File.join(File.dirname(File.expand_path(__FILE__)), '..', '..', 'test_helper.rb')
+
+class HelloWorldServer < SOAP::RPC::HTTPServer
+private
+
+  def on_init
+    self.level = Logger::Severity::FATAL
+    @default_namespace = 'urn:ssltst'
+    add_method(self, 'hello_world', 'from')
+  end
+
+  def hello_world(from)
+    "Hello World, from #{ from }"
+  end
+end
+
+
+if $0 == __FILE__
+  PORT = TestUtil.get_free_port
+  DIR = File.dirname(File.expand_path(__FILE__))
+
+  def cert(filename)
+    OpenSSL::X509::Certificate.new(File.open(File.join(DIR, filename)) { |f|
+      f.read
+    })
+  end
+
+  def key(filename)
+    OpenSSL::PKey::RSA.new(File.open(File.join(DIR, filename)) { |f|
+      f.read
+    })
+  end
+
+  $server = HelloWorldServer.new(
+    :BindAddress => "0.0.0.0",
+    :Port => PORT,
+    :AccessLog => [],
+    :SSLEnable => true,
+    :SSLCACertificateFile => File.join(DIR, 'ca.cert'),
+    :SSLCertificate => cert('server.cert'),
+    :SSLPrivateKey => key('server.key'),
+    :SSLVerifyClient => nil, #OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT|OpenSSL::SSL::VERIFY_PEER,
+    :SSLClientCA => cert('ca.cert'),
+    :SSLCertName => nil
+  )
+  t = Thread.new {
+    Thread.current.abort_on_exception = true
+    $server.start
+  }
+  STDOUT.sync = true
+  puts $$
+  t.join
+end

data/test/soap/ssl/subca.cert

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDaDCCAlCgAwIBAgIBATANBgkqhkiG9w0BAQUFADA8MQswCQYDVQQGDAJKUDES
+MBAGA1UECgwJSklOLkdSLkpQMQwwCgYDVQQLDANSUlIxCzAJBgNVBAMMAkNBMB4X
+DTA0MDEzMDAwNDMyN1oXDTM1MDEyMjAwNDMyN1owPzELMAkGA1UEBgwCSlAxEjAQ
+BgNVBAoMCUpJTi5HUi5KUDEMMAoGA1UECwwDUlJSMQ4wDAYDVQQDDAVTdWJDQTCC
+ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJ0Ou7AyRcRXnB/kVHv/6kwe
+ANzgg/DyJfsAUqW90m7Lu1nqyug8gK0RBd77yU0w5HOAMHTVSdpjZK0g2sgx4Mb1
+d/213eL9TTl5MRVEChTvQr8q5DVG/8fxPPE7fMI8eOAzd98/NOAChk+80r4Sx7fC
+kGVEE1bKwY1MrUsUNjOY2d6t3M4HHV3HX1V8ShuKfsHxgCmLzdI8U+5CnQedFgkm
+3e+8tr8IX5RR1wA1Ifw9VadF7OdI/bGMzog/Q8XCLf+WPFjnK7Gcx6JFtzF6Gi4x
+4dp1Xl45JYiVvi9zQ132wu8A1pDHhiNgQviyzbP+UjcB/tsOpzBQF8abYzgEkWEC
+AwEAAaNyMHAwDwYDVR0TAQH/BAUwAwEB/zAxBglghkgBhvhCAQ0EJBYiUnVieS9P
+cGVuU1NMIEdlbmVyYXRlZCBDZXJ0aWZpY2F0ZTAdBgNVHQ4EFgQUlCjXWLsReYzH
+LzsxwVnCXmKoB/owCwYDVR0PBAQDAgEGMA0GCSqGSIb3DQEBBQUAA4IBAQCJ/OyN
+rT8Cq2Y+G2yA/L1EMRvvxwFBqxavqaqHl/6rwsIBFlB3zbqGA/0oec6MAVnYynq4
+c4AcHTjx3bQ/S4r2sNTZq0DH4SYbQzIobx/YW8PjQUJt8KQdKMcwwi7arHP7A/Ha
+LKu8eIC2nsUBnP4NhkYSGhbmpJK+PFD0FVtD0ZIRlY/wsnaZNjWWcnWF1/FNuQ4H
+ySjIblqVQkPuzebv3Ror6ZnVDukn96Mg7kP4u6zgxOeqlJGRe1M949SS9Vudjl8X
+SF4aZUUB9pQGhsqQJVqaz2OlhGOp9D0q54xko/rekjAIcuDjl1mdX4F2WRrzpUmZ
+uY/bPeOBYiVsOYVe
+-----END CERTIFICATE-----

data/test/soap/ssl/test_ssl.rb

@@ -0,0 +1,238 @@
+require 'test/unit'
+begin
+  require 'httpclient'
+rescue LoadError
+end
+require 'soap/rpc/driver'
+require File.join(File.dirname(File.expand_path(__FILE__)), '..', '..', 'test_helper.rb')
+
+if defined?(HTTPClient) and defined?(OpenSSL)
+
+module SOAP; module SSL
+
+
+class TestSSL < Test::Unit::TestCase
+  PORT = 17171
+
+  DIR = File.dirname(File.expand_path(__FILE__))
+  require 'rbconfig'
+  RUBY = File.join(
+    RbConfig::CONFIG["bindir"],
+    RbConfig::CONFIG["ruby_install_name"] + RbConfig::CONFIG["EXEEXT"]
+  )
+
+  def setup
+    @url = "https://localhost:#{PORT}/hello"
+    @serverpid = @client = nil
+    @verify_callback_called = false
+    setup_server
+    setup_client
+  end
+
+  def teardown
+    teardown_client
+    teardown_server
+  end
+
+  def test_options
+    cfg = @client.streamhandler.client.ssl_config
+    assert_nil(cfg.client_cert)
+    assert_nil(cfg.client_key)
+    assert_nil(cfg.client_ca)
+    assert_equal(OpenSSL::SSL::VERIFY_PEER | OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT, cfg.verify_mode)
+    assert_nil(cfg.verify_callback)
+    assert_nil(cfg.timeout)
+    assert_equal("ALL:!aNULL:!eNULL:!SSLv2", cfg.ciphers)
+    assert_instance_of(OpenSSL::X509::Store, cfg.cert_store)
+    # dummy call to ensure sslsvr initialization finished.
+    assert_raise(OpenSSL::SSL::SSLError) do
+      @client.hello_world("ssl client")
+    end
+  end
+
+  def test_verification
+    cfg = @client.options
+    cfg["protocol.http.ssl_config.verify_callback"] = method(:verify_callback).to_proc
+    begin
+      @verify_callback_called = false
+      @client.hello_world("ssl client")
+      assert(false)
+    rescue OpenSSL::SSL::SSLError => ssle
+      assert(/certificate verify failed/ =~ ssle.message)
+      assert(@verify_callback_called)
+    end
+    #
+    cfg["protocol.http.ssl_config.client_cert"] = File.join(DIR, "client.cert")
+    cfg["protocol.http.ssl_config.client_key"] = File.join(DIR, "client.key")
+    @verify_callback_called = false
+    begin
+      @client.hello_world("ssl client")
+      assert(false)
+    rescue OpenSSL::SSL::SSLError => ssle
+      assert(/certificate verify failed/ =~ ssle.message)
+      assert(@verify_callback_called)
+    end
+    #
+    cfg["protocol.http.ssl_config.ca_file"] = File.join(DIR, "ca.cert")
+    @verify_callback_called = false
+    begin
+      @client.hello_world("ssl client")
+      assert(false)
+    rescue OpenSSL::SSL::SSLError => ssle
+      assert(/certificate verify failed/ =~ ssle.message)
+      assert(@verify_callback_called)
+    end
+    #
+    cfg["protocol.http.ssl_config.ca_file"] = File.join(DIR, "subca.cert")
+    @verify_callback_called = false
+    assert_equal("Hello World, from ssl client", @client.hello_world("ssl client"))
+    assert(@verify_callback_called)
+    #
+    cfg["protocol.http.ssl_config.verify_depth"] = "1"
+    @verify_callback_called = false
+    begin
+      @client.hello_world("ssl client")
+      assert(false)
+    rescue OpenSSL::SSL::SSLError => ssle
+      assert(/certificate verify failed/ =~ ssle.message)
+      assert(@verify_callback_called)
+    end
+    #
+    cfg["protocol.http.ssl_config.verify_depth"] = ""
+    cfg["protocol.http.ssl_config.cert_store"] = OpenSSL::X509::Store.new
+    cfg["protocol.http.ssl_config.verify_mode"] = OpenSSL::SSL::VERIFY_PEER.to_s
+    begin
+      @client.hello_world("ssl client")
+      assert(false)
+    rescue OpenSSL::SSL::SSLError => ssle
+      assert(/certificate verify failed/ =~ ssle.message)
+    end
+    #
+    cfg["protocol.http.ssl_config.verify_mode"] = ""
+    assert_equal("Hello World, from ssl client", @client.hello_world("ssl client"))
+  end
+
+  def test_property
+    testpropertyname = File.join(DIR, 'soapclient.properties')
+    File.open(testpropertyname, "w") do |f|
+      f << <<STRING
+protocol.http.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_PEER
+# depth: 1 causes an error (intentional)
+protocol.http.ssl_config.verify_depth = 1
+protocol.http.ssl_config.client_cert = #{File.join(DIR, 'client.cert')}
+protocol.http.ssl_config.client_key = #{File.join(DIR, 'client.key')}
+protocol.http.ssl_config.ca_file = #{File.join(DIR, 'ca.cert')}
+protocol.http.ssl_config.ca_file = #{File.join(DIR, 'subca.cert')}
+protocol.http.ssl_config.ciphers = ALL
+STRING
+    end
+    begin
+      @client.loadproperty(testpropertyname)
+      @client.options["protocol.http.ssl_config.verify_callback"] = method(:verify_callback).to_proc
+      @verify_callback_called = false
+      # NG with String
+      begin
+        @client.hello_world("ssl client")
+        assert(false)
+      rescue OpenSSL::SSL::SSLError => ssle
+        #assert(/certificate verify failed/ =~ ssle.message)
+        assert(@verify_callback_called)
+      end
+      # NG with Integer
+      @client.options["protocol.http.ssl_config.verify_depth"] = 0
+      begin
+        @client.hello_world("ssl client")
+        assert(false)
+      rescue OpenSSL::SSL::SSLError => ssle
+        assert(/certificate verify failed/ =~ ssle.message)
+        assert(@verify_callback_called)
+      end
+      # OK with empty
+      @client.options["protocol.http.ssl_config.verify_depth"] = ""
+      @verify_callback_called = false
+      assert_equal("Hello World, from ssl client", @client.hello_world("ssl client"))
+      assert(@verify_callback_called)
+      # OK with nil
+      @client.options["protocol.http.ssl_config.verify_depth"] = nil
+      @verify_callback_called = false
+      assert_equal("Hello World, from ssl client", @client.hello_world("ssl client"))
+      assert(@verify_callback_called)
+      # OK with String
+      @client.options["protocol.http.ssl_config.verify_depth"] = "3"
+      @verify_callback_called = false
+      assert_equal("Hello World, from ssl client", @client.hello_world("ssl client"))
+      assert(@verify_callback_called)
+      # OK with Integer
+      @client.options["protocol.http.ssl_config.verify_depth"] = 3
+      @verify_callback_called = false
+      assert_equal("Hello World, from ssl client", @client.hello_world("ssl client"))
+      assert(@verify_callback_called)
+    ensure
+      File.unlink(testpropertyname)
+    end
+  end
+
+  # def test_ciphers
+  #   cfg = @client.options
+  #   cfg["protocol.http.ssl_config.client_cert"] = File.join(DIR, 'client.cert')
+  #   cfg["protocol.http.ssl_config.client_key"] = File.join(DIR, 'client.key')
+  #   cfg["protocol.http.ssl_config.ca_file"] = File.join(DIR, "ca.cert")
+  #   cfg["protocol.http.ssl_config.ca_file"] = File.join(DIR, "subca.cert")
+  #   cfg["protocol.http.ssl_config.ciphers"] = "HIGH:!aNULL:!eNULL:!EXPORT:!SSLv2:!MD5:!RC4"
+  #
+  #   begin
+  #     @client.hello_world("ssl client")
+  #     assert(false)
+  #   rescue OpenSSL::SSL::SSLError => ssle
+  #     # Updated regex to match both possible error messages
+  #     assert_match(/\A(?:SSL_CTX_set_cipher_list: no cipher match|no ciphers available)\z/, ssle.message)
+  #   end
+  #
+  #   cfg["protocol.http.ssl_config.ciphers"] = "ALL"
+  #   assert_equal("Hello World, from ssl client", @client.hello_world("ssl client"))
+  # end
+
+private
+
+  def q(str)
+    %Q["#{str}"]
+  end
+
+  def setup_server
+    svrcmd = "#{q(RUBY)} "
+    svrcmd << File.join(DIR, "sslsvr.rb")
+    svrout = IO.popen(svrcmd)
+    @serverpid = Integer(svrout.gets(chomp: true))
+  end
+
+  def setup_client
+    @client = SOAP::RPC::Driver.new(@url, 'urn:ssltst')
+    @client.add_method("hello_world", "from")
+  end
+
+  def teardown_server
+    if @serverpid
+      begin
+        Process.kill('KILL', @serverpid)
+        Process.waitpid(@serverpid, Process::WNOHANG)
+      rescue Errno::ESRCH, Errno::ECHILD
+        # Process already terminated or reaped
+      end
+    end
+  end
+
+  def teardown_client
+    @client.reset_stream if @client
+  end
+
+  def verify_callback(ok, cert)
+    @verify_callback_called = true
+    p ["client", ok, cert] if $DEBUG
+    ok
+  end
+end
+
+
+end; end
+
+end

data/test/soap/struct/test_struct.rb

@@ -0,0 +1,69 @@
+require 'test/unit'
+require 'soap/rpc/httpserver'
+require 'soap/rpc/driver'
+require 'test_helper'
+
+module SOAP; module Struct
+
+
+class TestStruct < Test::Unit::TestCase
+  Namespace = "urn:example.com:simpletype-rpc"
+  class Server < ::SOAP::RPC::HTTPServer
+    @@test_struct = ::Struct.new(:one, :two)
+
+    def on_init
+      add_method(self, 'a_method')
+    end
+  
+    def a_method
+      @@test_struct.new("string", 1)
+    end
+  end
+
+  Port = TestUtil.get_free_port
+
+  def setup
+    setup_server
+    setup_client
+  end
+
+  def setup_server
+    @server = Server.new(
+      :Port => Port,
+      :BindAddress => "0.0.0.0",
+      :AccessLog => [],
+      :SOAPDefaultNamespace => Namespace
+    )
+    @server.level = Logger::Severity::ERROR
+    @server_thread = TestUtil.start_server_thread(@server)
+  end
+
+  def setup_client
+    @client = ::SOAP::RPC::Driver.new("http://localhost:#{Port}/", Namespace)
+    @client.wiredump_dev = STDERR if $DEBUG
+    @client.add_method('a_method')
+  end
+
+  def teardown
+    teardown_server if @server
+    teardown_client if @client
+  end
+
+  def teardown_server
+    @server.shutdown
+    @server_thread.kill
+    @server_thread.join
+  end
+
+  def teardown_client
+    @client.reset_stream
+  end
+
+  def test_struct
+    assert_equal("string", @client.a_method.one)
+    assert_equal(1, @client.a_method.two)
+  end
+end
+
+
+end; end

data/test/soap/styleuse/client.rb

@@ -0,0 +1,20 @@
+require 'soap/rpc/driver'
+
+server = 'http://localhost:7000/'
+
+app = SOAP::RPC::Driver.new(server, 'urn:styleuse')
+app.add_rpc_method('rpc_serv', 'obj1', 'obj2')
+app.add_document_method('doc_serv', 'urn:doc_serv#doc_serv',
+  [XSD::QName.new('urn:styleuse', 'req')],
+  [XSD::QName.new('urn:styleuse', 'res')])
+app.add_document_method('doc_serv2', 'urn:doc_serv#doc_serv2',
+  [XSD::QName.new('urn:styleuse', 'req')],
+  [XSD::QName.new('urn:styleuse', 'res')])
+app.wiredump_dev = STDOUT
+
+p app.rpc_serv(true, false)
+p app.rpc_serv("foo", "bar")
+p app.doc_serv({"a" => "2"})
+p app.doc_serv({"a" => {"b" => "2"}})
+p app.doc_serv2({"a" => "2"})
+p app.doc_serv2({"a" => {"b" => "2"}})

data/test/soap/styleuse/server.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+
+require 'soap/rpc/standaloneServer'
+
+class Server < SOAP::RPC::StandaloneServer
+  class RpcServant
+    def rpc_serv(obj1, obj2)
+      [obj1, obj2]
+    end
+  end
+
+  class DocumentServant
+    def doc_serv(hash)
+      hash
+    end
+
+    def doc_serv2(hash)
+      { 'newroot' => hash }
+    end
+  end
+
+  class GenericServant
+
+    # method name style: requeststyle_requestuse_responsestyle_responseuse
+
+    def rpc_enc_rpc_enc(obj1, obj2)
+      [obj1, obj2]
+    end
+
+    alias rpc_enc_rpc_lit rpc_enc_rpc_enc
+
+    def rpc_enc_doc_enc(obj1, obj2)
+      obj1
+    end
+
+    alias rpc_enc_doc_lit rpc_enc_doc_enc
+
+    def doc_enc_rpc_enc(obj)
+      [obj, obj]
+    end
+
+    alias doc_enc_rpc_lit doc_enc_rpc_enc
+
+    def doc_enc_doc_enc(obj)
+      obj
+    end
+
+    alias doc_enc_doc_lit doc_enc_doc_enc
+  end
+
+  def initialize(*arg)
+    super
+    rpcservant = RpcServant.new
+    docservant = DocumentServant.new
+    add_rpc_servant(rpcservant)
+    add_document_method(docservant, 'urn:doc_serv#doc_serv', 'doc_serv',
+      [XSD::QName.new('urn:styleuse', 'req')],
+      [XSD::QName.new('urn:styleuse', 'res')])
+    add_document_method(docservant, 'urn:doc_serv#doc_serv2', 'doc_serv2',
+      [XSD::QName.new('urn:styleuse', 'req')],
+      [XSD::QName.new('urn:styleuse', 'res')])
+
+    #servant = Servant.new
+    # ToDo: too plain: should add bare test case
+    #qname ||= XSD::QName.new(@default_namespace, name)
+    #add_operation(qname, nil, servant, "rpc_enc_rpc_enc", param_def,
+    #  opt(:rpc, :rpc, :encoded, :encoded))
+  end
+
+  def opt(request_style, request_use, response_style, response_use)
+    {
+      :request_style => request_style,
+      :request_use => request_use,
+      :response_style => response_style,
+      :response_use => response_use
+    }
+  end
+end
+
+if $0 == __FILE__
+  server = Server.new('Server', 'urn:styleuse', '0.0.0.0', 7000)
+  trap(:INT) do
+    server.shutdown
+  end
+  server.start
+end

data/test/soap/swa/test_file.rb

@@ -0,0 +1,76 @@
+require 'test/unit'
+require 'soap/rpc/driver'
+require 'soap/rpc/standaloneServer'
+require 'soap/attachment'
+require 'test_helper'
+
+
+module SOAP
+  module SWA
+
+    class TestFile < Test::Unit::TestCase
+
+      Port = TestUtil.get_free_port
+      THIS_FILE = File.expand_path(__FILE__)
+
+      class SwAService
+        def get_file
+          {
+            'name' => $0,
+            'file' => SOAP::Attachment.new(File.open(THIS_FILE)) # closed when GCed.
+          }
+        end
+
+        def put_file(name, file)
+          "File '#{name}' was received ok."
+        end
+      end
+
+      def setup
+        @server = SOAP::RPC::StandaloneServer.new('SwAServer',
+                                                  'http://www.acmetron.com/soap', '0.0.0.0', Port)
+        @server.add_servant(SwAService.new)
+        @server.level = Logger::Severity::ERROR
+        @t = Thread.new {
+          @server.start
+        }
+        @endpoint = "http://localhost:#{Port}/"
+        @client = SOAP::RPC::Driver.new(@endpoint, 'http://www.acmetron.com/soap')
+        @client.add_method('get_file')
+        @client.add_method('put_file', 'name', 'file')
+        @client.wiredump_dev = STDERR if $DEBUG
+      end
+
+      def teardown
+        @server.shutdown if @server
+        if @t
+          @t.kill
+          @t.join
+        end
+        @client.reset_stream if @client
+      end
+
+      def test_get_file
+        assert_equal(
+          File.open(THIS_FILE) { |f| f.read },
+          @client.get_file['file'].content
+        )
+      end
+
+      def test_put_file
+        assert_equal(
+          "File 'foo' was received ok.",
+          @client.put_file('foo',
+                           SOAP::Attachment.new(File.open(THIS_FILE)))
+        )
+        assert_equal(
+          "File 'bar' was received ok.",
+          @client.put_file('bar',
+                           SOAP::Attachment.new(File.open(THIS_FILE) { |f| f.read }))
+        )
+      end
+    end
+
+
+  end
+end