From 15b7d439885f4aa97e0f508ef485cadab4b23577 Mon Sep 17 00:00:00 2001 From: "(no author)" <(no author)@b2dd03c8-39d4-4d8f-98ff-823fe69b080e> Date: Sun, 22 May 2005 13:20:28 +0000 Subject: This commit was manufactured by cvs2svn to create branch 'ruby_1_8'. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_1_8@8501 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- lib/soap/httpconfigloader.rb | 116 +++++++++++ lib/wsdl/soap/wsdl2ruby.rb | 176 ++++++++++++++++ lib/wsdl/xmlSchema/annotation.rb | 34 +++ lib/wsdl/xmlSchema/importer.rb | 81 ++++++++ lib/wsdl/xmlSchema/include.rb | 54 +++++ lib/wsdl/xmlSchema/length.rb | 35 ++++ lib/wsdl/xmlSchema/pattern.rb | 36 ++++ lib/wsdl/xmlSchema/simpleExtension.rb | 54 +++++ lib/wsdl/xmlSchema/xsd2ruby.rb | 107 ++++++++++ lib/xsd/mapping.rb | 42 ++++ test/soap/fault/test_customfault.rb | 58 ++++++ test/soap/test_mapping.rb | 59 ++++++ test/soap/test_styleuse.rb | 333 ++++++++++++++++++++++++++++++ test/soap/wsdlDriver/calc.wsdl | 126 +++++++++++ test/soap/wsdlDriver/document.wsdl | 54 +++++ test/soap/wsdlDriver/test_calc.rb | 88 ++++++++ test/soap/wsdlDriver/test_document.rb | 78 +++++++ test/wsdl/document/document.wsdl | 74 +++++++ test/wsdl/document/echo.rb | 92 +++++++++ test/wsdl/document/number.wsdl | 54 +++++ test/wsdl/document/ping_nosoapaction.wsdl | 66 ++++++ test/wsdl/document/test_nosoapaction.rb | 109 ++++++++++ test/wsdl/document/test_number.rb | 99 +++++++++ test/wsdl/document/test_rpc.rb | 159 ++++++++++++++ test/wsdl/marshal/person.wsdl | 21 ++ test/wsdl/marshal/person_org.rb | 22 ++ test/wsdl/marshal/test_wsdlmarshal.rb | 80 +++++++ test/wsdl/raa/server.rb | 103 +++++++++ test/wsdl/rpc/rpc.wsdl | 75 +++++++ test/wsdl/rpc/test_rpc.rb | 118 +++++++++++ test/xsd/codegen/test_classdef.rb | 214 +++++++++++++++++++ 31 files changed, 2817 insertions(+) create mode 100644 lib/soap/httpconfigloader.rb create mode 100644 lib/wsdl/soap/wsdl2ruby.rb create mode 100644 lib/wsdl/xmlSchema/annotation.rb create mode 100644 lib/wsdl/xmlSchema/importer.rb create mode 100644 lib/wsdl/xmlSchema/include.rb create mode 100644 lib/wsdl/xmlSchema/length.rb create mode 100644 lib/wsdl/xmlSchema/pattern.rb create mode 100644 lib/wsdl/xmlSchema/simpleExtension.rb create mode 100644 lib/wsdl/xmlSchema/xsd2ruby.rb create mode 100644 lib/xsd/mapping.rb create mode 100644 test/soap/fault/test_customfault.rb create mode 100644 test/soap/test_mapping.rb create mode 100644 test/soap/test_styleuse.rb create mode 100644 test/soap/wsdlDriver/calc.wsdl create mode 100644 test/soap/wsdlDriver/document.wsdl create mode 100644 test/soap/wsdlDriver/test_calc.rb create mode 100644 test/soap/wsdlDriver/test_document.rb create mode 100644 test/wsdl/document/document.wsdl create mode 100644 test/wsdl/document/echo.rb create mode 100644 test/wsdl/document/number.wsdl create mode 100644 test/wsdl/document/ping_nosoapaction.wsdl create mode 100644 test/wsdl/document/test_nosoapaction.rb create mode 100644 test/wsdl/document/test_number.rb create mode 100644 test/wsdl/document/test_rpc.rb create mode 100644 test/wsdl/marshal/person.wsdl create mode 100644 test/wsdl/marshal/person_org.rb create mode 100644 test/wsdl/marshal/test_wsdlmarshal.rb create mode 100644 test/wsdl/raa/server.rb create mode 100644 test/wsdl/rpc/rpc.wsdl create mode 100644 test/wsdl/rpc/test_rpc.rb create mode 100644 test/xsd/codegen/test_classdef.rb diff --git a/lib/soap/httpconfigloader.rb b/lib/soap/httpconfigloader.rb new file mode 100644 index 0000000000..ebc17d8f99 --- /dev/null +++ b/lib/soap/httpconfigloader.rb @@ -0,0 +1,116 @@ +# SOAP4R - HTTP config loader. +# Copyright (C) 2005 NAKAMURA, Hiroshi . + +# This program is copyrighted free software by NAKAMURA, Hiroshi. You can +# redistribute it and/or modify it under the same terms of Ruby's license; +# either the dual license version in 2003, or any later version. + + +require 'soap/property' + + +module SOAP + + +module HTTPConfigLoader +module_function + + def set_options(client, options) + client.proxy = options["proxy"] + options.add_hook("proxy") do |key, value| + client.proxy = value + end + client.no_proxy = options["no_proxy"] + options.add_hook("no_proxy") do |key, value| + client.no_proxy = value + end + if client.respond_to?(:protocol_version=) + client.protocol_version = options["protocol_version"] + options.add_hook("protocol_version") do |key, value| + client.protocol_version = value + end + end + ssl_config = options["ssl_config"] ||= ::SOAP::Property.new + set_ssl_config(client, ssl_config) + ssl_config.add_hook(true) do |key, value| + set_ssl_config(client, ssl_config) + end + basic_auth = options["basic_auth"] ||= ::SOAP::Property.new + set_basic_auth(client, basic_auth) + basic_auth.add_hook do |key, value| + set_basic_auth(client, basic_auth) + end + options.add_hook("connect_timeout") do |key, value| + client.connect_timeout = value + end + options.add_hook("send_timeout") do |key, value| + client.send_timeout = value + end + options.add_hook("receive_timeout") do |key, value| + client.receive_timeout = value + end + end + + def set_basic_auth(client, basic_auth) + basic_auth.values.each do |url, userid, passwd| + client.set_basic_auth(url, userid, passwd) + end + end + + def set_ssl_config(client, ssl_config) + ssl_config.each do |key, value| + cfg = client.ssl_config + case key + when 'client_cert' + cfg.client_cert = cert_from_file(value) + when 'client_key' + cfg.client_key = key_from_file(value) + when 'client_ca' + cfg.client_ca = value + when 'ca_path' + cfg.set_trust_ca(value) + when 'ca_file' + cfg.set_trust_ca(value) + when 'crl' + cfg.set_crl(value) + when 'verify_mode' + cfg.verify_mode = ssl_config_int(value) + when 'verify_depth' + cfg.verify_depth = ssl_config_int(value) + when 'options' + cfg.options = value + when 'ciphers' + cfg.ciphers = value + when 'verify_callback' + cfg.verify_callback = value + when 'cert_store' + cfg.cert_store = value + else + raise ArgumentError.new("unknown ssl_config property #{key}") + end + end + end + + def ssl_config_int(value) + if value.nil? or value.to_s.empty? + nil + else + begin + Integer(value) + rescue ArgumentError + ::SOAP::Property::Util.const_from_name(value.to_s) + end + end + end + + def cert_from_file(filename) + OpenSSL::X509::Certificate.new(File.open(filename) { |f| f.read }) + end + + def key_from_file(filename) + OpenSSL::PKey::RSA.new(File.open(filename) { |f| f.read }) + end +end + + +end diff --git a/lib/wsdl/soap/wsdl2ruby.rb b/lib/wsdl/soap/wsdl2ruby.rb new file mode 100644 index 0000000000..16b05fb032 --- /dev/null +++ b/lib/wsdl/soap/wsdl2ruby.rb @@ -0,0 +1,176 @@ +# WSDL4R - WSDL to ruby mapping library. +# Copyright (C) 2002-2005 NAKAMURA, Hiroshi . + +# This program is copyrighted free software by NAKAMURA, Hiroshi. You can +# redistribute it and/or modify it under the same terms of Ruby's license; +# either the dual license version in 2003, or any later version. + + +require 'logger' +require 'xsd/qname' +require 'wsdl/importer' +require 'wsdl/soap/classDefCreator' +require 'wsdl/soap/servantSkeltonCreator' +require 'wsdl/soap/driverCreator' +require 'wsdl/soap/clientSkeltonCreator' +require 'wsdl/soap/standaloneServerStubCreator' +require 'wsdl/soap/cgiStubCreator' + + +module WSDL +module SOAP + + +class WSDL2Ruby + attr_accessor :location + attr_reader :opt + attr_accessor :logger + attr_accessor :basedir + + def run + unless @location + raise RuntimeError, "WSDL location not given" + end + @wsdl = import(@location) + @name = @wsdl.name ? @wsdl.name.name : 'default' + create_file + end + +private + + def initialize + @location = nil + @opt = {} + @logger = Logger.new(STDERR) + @basedir = nil + @wsdl = nil + @name = nil + end + + def create_file + create_classdef if @opt.key?('classdef') + create_servant_skelton(@opt['servant_skelton']) if @opt.key?('servant_skelton') + create_cgi_stub(@opt['cgi_stub']) if @opt.key?('cgi_stub') + create_standalone_server_stub(@opt['standalone_server_stub']) if @opt.key?('standalone_server_stub') + create_driver(@opt['driver']) if @opt.key?('driver') + create_client_skelton(@opt['client_skelton']) if @opt.key?('client_skelton') + end + + def create_classdef + @logger.info { "Creating class definition." } + @classdef_filename = @name + '.rb' + check_file(@classdef_filename) or return + write_file(@classdef_filename) do |f| + f << WSDL::SOAP::ClassDefCreator.new(@wsdl).dump + end + end + + def create_client_skelton(servicename) + @logger.info { "Creating client skelton." } + servicename ||= @wsdl.services[0].name.name + @client_skelton_filename = servicename + 'Client.rb' + check_file(@client_skelton_filename) or return + write_file(@client_skelton_filename) do |f| + f << shbang << "\n" + f << "require '#{@driver_filename}'\n\n" if @driver_filename + f << WSDL::SOAP::ClientSkeltonCreator.new(@wsdl).dump( + create_name(servicename)) + end + end + + def create_servant_skelton(porttypename) + @logger.info { "Creating servant skelton." } + @servant_skelton_filename = (porttypename || @name + 'Servant') + '.rb' + check_file(@servant_skelton_filename) or return + write_file(@servant_skelton_filename) do |f| + f << "require '#{@classdef_filename}'\n\n" if @classdef_filename + f << WSDL::SOAP::ServantSkeltonCreator.new(@wsdl).dump( + create_name(porttypename)) + end + end + + def create_cgi_stub(servicename) + @logger.info { "Creating CGI stub." } + servicename ||= @wsdl.services[0].name.name + @cgi_stubFilename = servicename + '.cgi' + check_file(@cgi_stubFilename) or return + write_file(@cgi_stubFilename) do |f| + f << shbang << "\n" + if @servant_skelton_filename + f << "require '#{@servant_skelton_filename}'\n\n" + end + f << WSDL::SOAP::CGIStubCreator.new(@wsdl).dump(create_name(servicename)) + end + end + + def create_standalone_server_stub(servicename) + @logger.info { "Creating standalone stub." } + servicename ||= @wsdl.services[0].name.name + @standalone_server_stub_filename = servicename + '.rb' + check_file(@standalone_server_stub_filename) or return + write_file(@standalone_server_stub_filename) do |f| + f << shbang << "\n" + f << "require '#{@servant_skelton_filename}'\n\n" if @servant_skelton_filename + f << WSDL::SOAP::StandaloneServerStubCreator.new(@wsdl).dump( + create_name(servicename)) + end + end + + def create_driver(porttypename) + @logger.info { "Creating driver." } + @driver_filename = (porttypename || @name) + 'Driver.rb' + check_file(@driver_filename) or return + write_file(@driver_filename) do |f| + f << "require '#{@classdef_filename}'\n\n" if @classdef_filename + f << WSDL::SOAP::DriverCreator.new(@wsdl).dump( + create_name(porttypename)) + end + end + + def write_file(filename) + if @basedir + filename = File.join(basedir, filename) + end + File.open(filename, "w") do |f| + yield f + end + end + + def check_file(filename) + if @basedir + filename = File.join(basedir, filename) + end + if FileTest.exist?(filename) + if @opt.key?('force') + @logger.warn { + "File '#{filename}' exists but overrides it." + } + true + else + @logger.warn { + "File '#{filename}' exists. #{$0} did not override it." + } + false + end + else + @logger.info { "Creates file '#{filename}'." } + true + end + end + + def shbang + "#!/usr/bin/env ruby" + end + + def create_name(name) + name ? XSD::QName.new(@wsdl.targetnamespace, name) : nil + end + + def import(location) + WSDL::Importer.import(location) + end +end + + +end +end diff --git a/lib/wsdl/xmlSchema/annotation.rb b/lib/wsdl/xmlSchema/annotation.rb new file mode 100644 index 0000000000..633bd196f1 --- /dev/null +++ b/lib/wsdl/xmlSchema/annotation.rb @@ -0,0 +1,34 @@ +# WSDL4R - WSDL SOAP documentation element. +# Copyright (C) 2003, 2005 NAKAMURA, Hiroshi . + +# This program is copyrighted free software by NAKAMURA, Hiroshi. You can +# redistribute it and/or modify it under the same terms of Ruby's license; +# either the dual license version in 2003, or any later version. + + +require 'wsdl/info' + + +module WSDL +module XMLSchema + + +class Annotation < Info + def initialize + super + end + + def parse_element(element) + # Accepts any element. + self + end + + def parse_attr(attr, value) + # Accepts any attribute. + true + end +end + + +end +end diff --git a/lib/wsdl/xmlSchema/importer.rb b/lib/wsdl/xmlSchema/importer.rb new file mode 100644 index 0000000000..8829d5240c --- /dev/null +++ b/lib/wsdl/xmlSchema/importer.rb @@ -0,0 +1,81 @@ +# WSDL4R - XSD importer library. +# Copyright (C) 2003, 2005 NAKAMURA, Hiroshi . + +# This program is copyrighted free software by NAKAMURA, Hiroshi. You can +# redistribute it and/or modify it under the same terms of Ruby's license; +# either the dual license version in 2003, or any later version. + + +require 'soap/httpconfigloader' +require 'wsdl/xmlSchema/parser' + + +module WSDL +module XMLSchema + + +class Importer + def self.import(location, originalroot = nil) + new.import(location, originalroot) + end + + def initialize + @web_client = nil + end + + def import(location, originalroot = nil) + unless location.is_a?(URI) + location = URI.parse(location) + end + content = parse(fetch(location), location, originalroot) + content.location = location + content + end + +private + + def parse(content, location, originalroot) + opt = { + :location => location, + :originalroot => originalroot + } + WSDL::XMLSchema::Parser.new(opt).parse(content) + end + + def fetch(location) + warn("importing: #{location}") if $DEBUG + content = nil + if location.scheme == 'file' or + (location.relative? and FileTest.exist?(location.path)) + content = File.open(location.path).read + else + client = web_client.new(nil, "WSDL4R") + client.proxy = ::SOAP::Env::HTTP_PROXY + client.no_proxy = ::SOAP::Env::NO_PROXY + if opt = ::SOAP::Property.loadproperty(::SOAP::PropertyName) + ::SOAP::HTTPConfigLoader.set_options(client, opt["client.protocol.http"]) + end + content = client.get_content(location) + end + content + end + + def web_client + @web_client ||= begin + require 'http-access2' + if HTTPAccess2::VERSION < "2.0" + raise LoadError.new("http-access/2.0 or later is required.") + end + HTTPAccess2::Client + rescue LoadError + warn("Loading http-access2 failed. Net/http is used.") if $DEBUG + require 'soap/netHttpClient' + ::SOAP::NetHttpClient + end + @web_client + end +end + + +end +end diff --git a/lib/wsdl/xmlSchema/include.rb b/lib/wsdl/xmlSchema/include.rb new file mode 100644 index 0000000000..af1ef942bb --- /dev/null +++ b/lib/wsdl/xmlSchema/include.rb @@ -0,0 +1,54 @@ +# WSDL4R - XMLSchema include definition. +# Copyright (C) 2005 NAKAMURA, Hiroshi . + +# This program is copyrighted free software by NAKAMURA, Hiroshi. You can +# redistribute it and/or modify it under the same terms of Ruby's license; +# either the dual license version in 2003, or any later version. + + +require 'wsdl/info' +require 'wsdl/xmlSchema/importer' + + +module WSDL +module XMLSchema + + +class Include < Info + attr_reader :schemalocation + attr_reader :content + + def initialize + super + @schemalocation = nil + @content = nil + end + + def parse_element(element) + nil + end + + def parse_attr(attr, value) + case attr + when SchemaLocationAttrName + @schemalocation = URI.parse(value.source) + if @schemalocation.relative? + @schemalocation = parent.location + @schemalocation + end + @content = import(@schemalocation) + @schemalocation + else + nil + end + end + +private + + def import(location) + Importer.import(location) + end +end + + +end +end diff --git a/lib/wsdl/xmlSchema/length.rb b/lib/wsdl/xmlSchema/length.rb new file mode 100644 index 0000000000..7f61602da9 --- /dev/null +++ b/lib/wsdl/xmlSchema/length.rb @@ -0,0 +1,35 @@ +# WSDL4R - XMLSchema length definition for WSDL. +# Copyright (C) 2005 NAKAMURA, Hiroshi . + +# This program is copyrighted free software by NAKAMURA, Hiroshi. You can +# redistribute it and/or modify it under the same terms of Ruby's license; +# either the dual license version in 2003, or any later version. + + +require 'wsdl/info' + + +module WSDL +module XMLSchema + + +class Length < Info + def initialize + super + end + + def parse_element(element) + nil + end + + def parse_attr(attr, value) + case attr + when ValueAttrName + value.source + end + end +end + + +end +end diff --git a/lib/wsdl/xmlSchema/pattern.rb b/lib/wsdl/xmlSchema/pattern.rb new file mode 100644 index 0000000000..f826be4578 --- /dev/null +++ b/lib/wsdl/xmlSchema/pattern.rb @@ -0,0 +1,36 @@ +# WSDL4R - XMLSchema pattern definition for WSDL. +# Copyright (C) 2005 NAKAMURA, Hiroshi . + +# This program is copyrighted free software by NAKAMURA, Hiroshi. You can +# redistribute it and/or modify it under the same terms of Ruby's license; +# either the dual license version in 2003, or any later version. + + +require 'wsdl/info' + + +module WSDL +module XMLSchema + + +class Pattern < Info + def initialize + super + end + + def parse_element(element) + nil + end + + def parse_attr(attr, value) + case attr + when ValueAttrName + parent.pattern = /\A#{value.source}\z/n + value.source + end + end +end + + +end +end diff --git a/lib/wsdl/xmlSchema/simpleExtension.rb b/lib/wsdl/xmlSchema/simpleExtension.rb new file mode 100644 index 0000000000..3c53a7328c --- /dev/null +++ b/lib/wsdl/xmlSchema/simpleExtension.rb @@ -0,0 +1,54 @@ +# WSDL4R - XMLSchema simpleType extension definition for WSDL. +# Copyright (C) 2005 NAKAMURA, Hiroshi . + +# This program is copyrighted free software by NAKAMURA, Hiroshi. You can +# redistribute it and/or modify it under the same terms of Ruby's license; +# either the dual license version in 2003, or any later version. + + +require 'wsdl/info' +require 'xsd/namedelements' + + +module WSDL +module XMLSchema + + +class SimpleExtension < Info + attr_reader :base + attr_reader :attributes + + def initialize + super + @base = nil + @attributes = XSD::NamedElements.new + end + + def targetnamespace + parent.targetnamespace + end + + def valid?(value) + true + end + + def parse_element(element) + case element + when AttributeName + o = Attribute.new + @attributes << o + o + end + end + + def parse_attr(attr, value) + case attr + when BaseAttrName + @base = value + end + end +end + + +end +end diff --git a/lib/wsdl/xmlSchema/xsd2ruby.rb b/lib/wsdl/xmlSchema/xsd2ruby.rb new file mode 100644 index 0000000000..afe5fc5ada --- /dev/null +++ b/lib/wsdl/xmlSchema/xsd2ruby.rb @@ -0,0 +1,107 @@ +# XSD4R - XSD to ruby mapping library. +# Copyright (C) 2005 NAKAMURA, Hiroshi . + +# This program is copyrighted free software by NAKAMURA, Hiroshi. You can +# redistribute it and/or modify it under the same terms of Ruby's license; +# either the dual license version in 2003, or any later version. + + +require 'xsd/codegen/gensupport' +require 'wsdl/xmlSchema/importer' +require 'wsdl/soap/classDefCreator' + + +module WSDL +module XMLSchema + + +class XSD2Ruby + attr_accessor :location + attr_reader :opt + attr_accessor :logger + attr_accessor :basedir + + def run + unless @location + raise RuntimeError, "XML Schema location not given" + end + @xsd = import(@location) + @name = create_classname(@xsd) + create_file + end + +private + + def initialize + @location = nil + @opt = {} + @logger = Logger.new(STDERR) + @basedir = nil + @xsd = nil + @name = nil + end + + def create_file + create_classdef + end + + def create_classdef + @logger.info { "Creating class definition." } + @classdef_filename = @name + '.rb' + check_file(@classdef_filename) or return + write_file(@classdef_filename) do |f| + f << WSDL::SOAP::ClassDefCreator.new(@xsd).dump + end + end + + def write_file(filename) + if @basedir + filename = File.join(basedir, filename) + end + File.open(filename, "w") do |f| + yield f + end + end + + def check_file(filename) + if @basedir + filename = File.join(basedir, filename) + end + if FileTest.exist?(filename) + if @opt.key?('force') + @logger.warn { + "File '#{filename}' exists but overrides it." + } + true + else + @logger.warn { + "File '#{filename}' exists. #{$0} did not override it." + } + false + end + else + @logger.info { "Creates file '#{filename}'." } + true + end + end + + def create_classname(xsd) + name = nil + if xsd.targetnamespace + name = xsd.targetnamespace.scan(/[a-zA-Z0-9]+$/)[0] + end + if name.nil? + 'default' + else + XSD::CodeGen::GenSupport.safevarname(name) + end + end + + def import(location) + WSDL::XMLSchema::Importer.import(location) + end +end + + +end +end diff --git a/lib/xsd/mapping.rb b/lib/xsd/mapping.rb new file mode 100644 index 0000000000..06d30d4cbf --- /dev/null +++ b/lib/xsd/mapping.rb @@ -0,0 +1,42 @@ +# XSD4R - XML Mapping for Ruby +# Copyright (C) 2005 NAKAMURA, Hiroshi . + +# This program is copyrighted free software by NAKAMURA, Hiroshi. You can +# redistribute it and/or modify it under the same terms of Ruby's license; +# either the dual license version in 2003, or any later version. + + +require "soap/parser" +require 'soap/encodingstyle/literalHandler' +require "soap/generator" +require "soap/mapping" +require "soap/mapping/wsdlliteralregistry" + + +module XSD + + +module Mapping + MappingRegistry = SOAP::Mapping::WSDLLiteralRegistry.new + MappingOpt = {:default_encodingstyle => SOAP::LiteralNamespace} + + def self.obj2xml(obj, elename = nil, io = nil) + if !elename.nil? and !elename.is_a?(XSD::QName) + elename = XSD::QName.new(nil, elename) + end + elename ||= XSD::QName.new(nil, SOAP::Mapping.name2elename(obj.class.to_s)) + soap = SOAP::Mapping.obj2soap(obj, MappingRegistry) + soap.elename = elename + generator = SOAP::SOAPGenerator.new(MappingOpt) + generator.generate(soap, io) + end + + def self.xml2obj(stream) + parser = SOAP::Parser.new(MappingOpt) + soap = parser.parse(stream) + SOAP::Mapping.soap2obj(soap, MappingRegistry) + end +end + + +end diff --git a/test/soap/fault/test_customfault.rb b/test/soap/fault/test_customfault.rb new file mode 100644 index 0000000000..2f7bc2be6e --- /dev/null +++ b/test/soap/fault/test_customfault.rb @@ -0,0 +1,58 @@ +require 'test/unit' +require 'soap/rpc/driver' +require 'soap/rpc/standaloneServer' + + +module SOAP +module Fault + + +class TestCustomFault < Test::Unit::TestCase + Port = 17171 + + class CustomFaultServer < SOAP::RPC::StandaloneServer + def on_init + add_method(self, 'fault', 'msg') + end + + def fault(msg) + SOAPFault.new(SOAPString.new("mycustom"), + SOAPString.new("error: #{msg}"), + SOAPString.new(self.class.name)) + end + end + + def setup + @server = CustomFaultServer.new('customfault', 'urn:customfault', '0.0.0.0', Port) + @server.level = Logger::Severity::ERROR + @t = Thread.new { + Thread.current.abort_on_exception = true + @server.start + } + @endpoint = "http://localhost:#{Port}/" + @client = SOAP::RPC::Driver.new(@endpoint, 'urn:customfault') + @client.wiredump_dev = STDERR if $DEBUG + @client.add_method("fault", "msg") + end + + def teardown + @server.shutdown + @t.kill + @t.join + @client.reset_stream + end + + def test_custom_fault + begin + @client.fault("message") + assert(false, 'exception not raised') + rescue SOAP::FaultError => e + assert(true, 'exception raised') + assert_equal('error: message', e.message) + end + end +end + + +end +end diff --git a/test/soap/test_mapping.rb b/test/soap/test_mapping.rb new file mode 100644 index 0000000000..26222e6719 --- /dev/null +++ b/test/soap/test_mapping.rb @@ -0,0 +1,59 @@ +require 'test/unit' +require 'soap/mapping' + + +module SOAP + + +class TestMapping < Test::Unit::TestCase + def test_date + targets = [ + ["2002-12-31", + "2002-12-31Z"], + ["2002-12-31+00:00", + "2002-12-31Z"], + ["2002-12-31-00:00", + "2002-12-31Z"], + ["-2002-12-31", + "-2002-12-31Z"], + ["-2002-12-31+00:00", + "-2002-12-31Z"], + ["-2002-12-31-00:00", + "-2002-12-31Z"], + ] + targets.each do |str, expectec| + d = Date.parse(str) + assert_equal(d.class, convert(d).class) + assert_equal(d, convert(d)) + end + end + + def test_datetime + targets = [ + ["2002-12-31T23:59:59.00", + "2002-12-31T23:59:59Z"], + ["2002-12-31T23:59:59+00:00", + "2002-12-31T23:59:59Z"], + ["2002-12-31T23:59:59-00:00", + "2002-12-31T23:59:59Z"], + ["-2002-12-31T23:59:59.00", + "-2002-12-31T23:59:59Z"], + ["-2002-12-31T23:59:59+00:00", + "-2002-12-31T23:59:59Z"], + ["-2002-12-31T23:59:59-00:00", + "-2002-12-31T23:59:59Z"], + ] + targets.each do |str, expectec| + d = DateTime.parse(str) + assert_equal(d.class, convert(d).class) + assert_equal(d, convert(d)) + end + end + + def convert(obj) + SOAP::Mapping.soap2obj(SOAP::Mapping.obj2soap(obj)) + end +end + + +end diff --git a/test/soap/test_styleuse.rb b/test/soap/test_styleuse.rb new file mode 100644 index 0000000000..4ea321848d --- /dev/null +++ b/test/soap/test_styleuse.rb @@ -0,0 +1,333 @@ +require 'test/unit' +require 'soap/rpc/httpserver' +require 'soap/rpc/driver' + + +module SOAP + + +class TestStyleUse < Test::Unit::TestCase + # rpc driver: obj in(Hash allowed for literal), obj out + # + # style: not visible from user + # rpc: wrapped element + # document: unwrappted element + # + # use: + # encoding: a graph (SOAP Data Model) + # literal: not a graph (SOAPElement) + # + # rpc stub: obj in, obj out(Hash is allowed for literal) + # + # style: not visible from user + # rpc: wrapped element + # document: unwrappted element + # + # use: + # encoding: a graph (SOAP Data Model) + # literal: not a graph (SOAPElement) + # + # document driver: SOAPElement in, SOAPElement out? [not implemented] + # + # style: ditto + # use: ditto + # + # + # document stub: SOAPElement in, SOAPElement out? [not implemented] + # + # style: ditto + # use: ditto + # + class GenericServant + # method name style: requeststyle_requestuse_responsestyle_responseuse + + # 2 params -> array + def rpc_enc_rpc_enc(obj1, obj2) + [obj1, [obj1, obj2]] + end + + # 2 objs -> array + def rpc_lit_rpc_enc(obj1, obj2) + [obj2, obj1] + end + + # 2 params -> 2 params + def rpc_enc_rpc_lit(obj1, obj2) + klass = [obj1.class.name, obj2.class.name] + [obj2, obj1] + end + + # 2 objs -> 2 objs + def rpc_lit_rpc_lit(obj1, obj2) + [obj1, obj2] + end + + # 2 params -> array + def doc_enc_doc_enc(obj1, obj2) + [obj1, [obj1, obj2]] + end + + # 2 objs -> array + def doc_lit_doc_enc(obj1, obj2) + [obj2, obj1] + end + + # 2 params -> 2 hashes + def doc_enc_doc_lit(obj1, obj2) + klass = [obj1.class.name, obj2.class.name] + return {'obj1' => {'klass' => klass}, 'misc' => 'hash does not have an order'}, + {'obj2' => {'klass' => klass}} + end + + # 2 objs -> 2 objs + def doc_lit_doc_lit(obj1, obj2) + return obj1, obj2 + end + end + + Namespace = "urn:styleuse" + + module Op + def self.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 + + Op_rpc_enc_rpc_enc = [ + XSD::QName.new(Namespace, 'rpc_enc_rpc_enc'), + nil, + 'rpc_enc_rpc_enc', [ + ['in', 'obj1', nil], + ['in', 'obj2', nil], + ['retval', 'return', nil]], + opt(:rpc, :encoded, :rpc, :encoded) + ] + + Op_rpc_lit_rpc_enc = [ + XSD::QName.new(Namespace, 'rpc_lit_rpc_enc'), + nil, + 'rpc_lit_rpc_enc', [ + ['in', 'obj1', nil], + ['in', 'obj2', nil], + ['retval', 'return', nil]], + opt(:rpc, :literal, :rpc, :encoded) + ] + + Op_rpc_enc_rpc_lit = [ + XSD::QName.new(Namespace, 'rpc_enc_rpc_lit'), + nil, + 'rpc_enc_rpc_lit', [ + ['in', 'obj1', nil], + ['in', 'obj2', nil], + ['retval', 'ret1', nil], + ['out', 'ret2', nil]], + opt(:rpc, :encoded, :rpc, :literal) + ] + + Op_rpc_lit_rpc_lit = [ + XSD::QName.new(Namespace, 'rpc_lit_rpc_lit'), + nil, + 'rpc_lit_rpc_lit', [ + ['in', 'obj1', nil], + ['in', 'obj2', nil], + ['retval', 'ret1', nil], + ['out', 'ret2', nil]], + opt(:rpc, :literal, :rpc, :literal) + ] + + Op_doc_enc_doc_enc = [ + Namespace + 'doc_enc_doc_enc', + 'doc_enc_doc_enc', [ + ['in', 'obj1', [nil, Namespace, 'obj1']], + ['in', 'obj2', [nil, Namespace, 'obj2']], + ['out', 'ret1', [nil, Namespace, 'ret1']], + ['out', 'ret2', [nil, Namespace, 'ret2']]], + opt(:document, :encoded, :document, :encoded) + ] + + Op_doc_lit_doc_enc = [ + Namespace + 'doc_lit_doc_enc', + 'doc_lit_doc_enc', [ + ['in', 'obj1', [nil, Namespace, 'obj1']], + ['in', 'obj2', [nil, Namespace, 'obj2']], + ['out', 'ret1', [nil, Namespace, 'ret1']], + ['out', 'ret2', [nil, Namespace, 'ret2']]], + opt(:document, :literal, :document, :encoded) + ] + + Op_doc_enc_doc_lit = [ + Namespace + 'doc_enc_doc_lit', + 'doc_enc_doc_lit', [ + ['in', 'obj1', [nil, Namespace, 'obj1']], + ['in', 'obj2', [nil, Namespace, 'obj2']], + ['out', 'ret1', [nil, Namespace, 'ret1']], + ['out', 'ret2', [nil, Namespace, 'ret2']]], + opt(:document, :encoded, :document, :literal) + ] + + Op_doc_lit_doc_lit = [ + Namespace + 'doc_lit_doc_lit', + 'doc_lit_doc_lit', [ + ['in', 'obj1', [nil, Namespace, 'obj1']], + ['in', 'obj2', [nil, Namespace, 'obj2']], + ['out', 'ret1', [nil, Namespace, 'ret1']], + ['out', 'ret2', [nil, Namespace, 'ret2']]], + opt(:document, :literal, :document, :literal) + ] + end + + include Op + + class Server < ::SOAP::RPC::HTTPServer + include Op + + def on_init + @servant = GenericServant.new + add_rpc_operation(@servant, *Op_rpc_enc_rpc_enc) + add_rpc_operation(@servant, *Op_rpc_lit_rpc_enc) + add_rpc_operation(@servant, *Op_rpc_enc_rpc_lit) + add_rpc_operation(@servant, *Op_rpc_lit_rpc_lit) + add_document_operation(@servant, *Op_doc_enc_doc_enc) + add_document_operation(@servant, *Op_doc_lit_doc_enc) + add_document_operation(@servant, *Op_doc_enc_doc_lit) + add_document_operation(@servant, *Op_doc_lit_doc_lit) + end + end + + Port = 17171 + + def setup + setup_server + setup_client + end + + def setup_server + @server = Server.new( + :BindAddress => "0.0.0.0", + :Port => Port, + :AccessLog => [], + :SOAPDefaultNamespace => Namespace + ) + @server.level = Logger::Severity::ERROR + @server_thread = 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_rpc_operation(*Op_rpc_enc_rpc_enc) + @client.add_rpc_operation(*Op_rpc_lit_rpc_enc) + @client.add_rpc_operation(*Op_rpc_enc_rpc_lit) + @client.add_rpc_operation(*Op_rpc_lit_rpc_lit) + @client.add_document_operation(*Op_doc_enc_doc_enc) + @client.add_document_operation(*Op_doc_lit_doc_enc) + @client.add_document_operation(*Op_doc_enc_doc_lit) + @client.add_document_operation(*Op_doc_lit_doc_lit) + end + + def teardown + teardown_server + teardown_client + end + + def teardown_server + @server.shutdown + @server_thread.kill + @server_thread.join + end + + def teardown_client + @client.reset_stream + end + + def start_server_thread(server) + t = Thread.new { + Thread.current.abort_on_exception = true + server.start + } + t + end + + def test_rpc_enc_rpc_enc + o = "hello" + obj1 = o + obj2 = [1] + ret = @client.rpc_enc_rpc_enc(obj1, obj2) + # server returns [obj1, [obj1, obj2]] + assert_equal([obj1, [obj1, obj2]], ret) + assert_same(ret[0], ret[1][0]) + end + + S1 = ::Struct.new(:a) + S2 = ::Struct.new(:c) + def test_rpc_lit_rpc_enc + ret1, ret2 = @client.rpc_lit_rpc_enc(S1.new('b'), S2.new('d')) + assert_equal('d', ret1.c) + assert_equal('b', ret2.a) + # Hash is allowed for literal + ret1, ret2 = @client.rpc_lit_rpc_enc({'a' => 'b'}, {'c' => 'd'}) + assert_equal('d', ret1.c) + assert_equal('b', ret2.a) + # simple value + assert_equal( + ['1', 'a'], + @client.rpc_lit_rpc_enc('a', 1) + ) + end + + def test_rpc_enc_rpc_lit + assert_equal( + ['1', 'a'], + @client.rpc_enc_rpc_lit('a', '1') + ) + end + + def test_rpc_lit_rpc_lit + ret1, ret2 = @client.rpc_lit_rpc_lit({'a' => 'b'}, {'c' => 'd'}) + assert_equal('b', ret1["a"]) + assert_equal('d', ret2["c"]) + end + + def test_doc_enc_doc_enc + o = "hello" + obj1 = o + obj2 = [1] + ret = @client.rpc_enc_rpc_enc(obj1, obj2) + # server returns [obj1, [obj1, obj2]] + assert_equal([obj1, [obj1, obj2]], ret) + assert_same(ret[0], ret[1][0]) + end + + def test_doc_lit_doc_enc + ret1, ret2 = @client.doc_lit_doc_enc({'a' => 'b'}, {'c' => 'd'}) + assert_equal('d', ret1.c) + assert_equal('b', ret2.a) + assert_equal( + ['a', '1'], + @client.doc_lit_doc_enc(1, 'a') + ) + end + + def test_doc_enc_doc_lit + ret1, ret2 = @client.doc_enc_doc_lit('a', 1) + # literal Array + assert_equal(['String', 'Fixnum'], ret1['obj1']['klass']) + # same value + assert_equal(ret1['obj1']['klass'], ret2['obj2']['klass']) + # not the same object (not encoded) + assert_not_same(ret1['obj1']['klass'], ret2['obj2']['klass']) + end + + def test_doc_lit_doc_lit + ret1, ret2 = @client.doc_lit_doc_lit({'a' => 'b'}, {'c' => 'd'}) + assert_equal('b', ret1["a"]) + assert_equal('d', ret2["c"]) + end +end + + +end diff --git a/test/soap/wsdlDriver/calc.wsdl b/test/soap/wsdlDriver/calc.wsdl new file mode 100644 index 0000000000..694a01e87e --- /dev/null +++ b/test/soap/wsdlDriver/calc.wsdl @@ -0,0 +1,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + calculator service + + + + + diff --git a/test/soap/wsdlDriver/document.wsdl b/test/soap/wsdlDriver/document.wsdl new file mode 100644 index 0000000000..5e9e74b9df --- /dev/null +++ b/test/soap/wsdlDriver/document.wsdl @@ -0,0 +1,54 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/test/soap/wsdlDriver/test_calc.rb b/test/soap/wsdlDriver/test_calc.rb new file mode 100644 index 0000000000..f1cc116a59 --- /dev/null +++ b/test/soap/wsdlDriver/test_calc.rb @@ -0,0 +1,88 @@ +require 'test/unit' +require 'soap/rpc/httpserver' +require 'soap/wsdlDriver' + + +module SOAP + + +class TestCalc < Test::Unit::TestCase + class Server < ::SOAP::RPC::HTTPServer + def on_init + add_method(self, 'add', 'x', 'y') + end + + def add(x, y) + x.to_f + y.to_f + end + end + + DIR = File.dirname(File.expand_path(__FILE__)) + Port = 17171 + + def setup + setup_server + setup_client + end + + def setup_server + @server = Server.new( + :BindAddress => "0.0.0.0", + :Port => Port, + :AccessLog => [], + :SOAPDefaultNamespace => 'http://www.fred.com' + ) + @server.level = Logger::Severity::ERROR + @server_thread = start_server_thread(@server) + end + + def setup_client + @wsdl = File.join(DIR, 'calc.wsdl') + end + + def teardown + teardown_server + teardown_client + end + + def teardown_server + @server.shutdown + @server_thread.kill + @server_thread.join + end + + def teardown_client + @client.reset_stream if @client + end + + def start_server_thread(server) + t = Thread.new { + Thread.current.abort_on_exception = true + server.start + } + t + end + + def test_rpc_driver + @client = ::SOAP::WSDLDriverFactory.new(@wsdl).create_rpc_driver + @client.wiredump_dev = STDOUT if $DEBUG + @client.endpoint_url = "http://localhost:#{Port}/" + @client.generate_explicit_type = true + assert_equal(0.3, @client.add(0.1, 0.2)) + @client.generate_explicit_type = false + assert_equal(0.3, @client.add(0.1, 0.2)) + end + + def test_old_driver + @client = ::SOAP::WSDLDriverFactory.new(@wsdl).create_driver + @client.wiredump_dev = STDOUT if $DEBUG + @client.endpoint_url = "http://localhost:#{Port}/" + @client.generate_explicit_type = true + assert_equal(0.3, @client.add(0.1, 0.2)) + @client.generate_explicit_type = false + assert_equal(0.3, @client.add(0.1, 0.2)) + end +end + + +end diff --git a/test/soap/wsdlDriver/test_document.rb b/test/soap/wsdlDriver/test_document.rb new file mode 100644 index 0000000000..634b827aae --- /dev/null +++ b/test/soap/wsdlDriver/test_document.rb @@ -0,0 +1,78 @@ +require 'test/unit' +require 'soap/rpc/standaloneServer' +require 'soap/wsdlDriver' + + +module SOAP + + +class TestDocument < Test::Unit::TestCase + Namespace = 'urn:example.com:document' + + class Server < ::SOAP::RPC::StandaloneServer + def on_init + add_document_method(self, 'urn:example.com:document#submit', 'submit', XSD::QName.new(Namespace, 'ruby'), XSD::QName.new(Namespace, 'ruby')) + end + + def submit(ruby) + ruby + end + end + + DIR = File.dirname(File.expand_path(__FILE__)) + + Port = 17171 + + def setup + setup_server + setup_client + end + + def setup_server + @server = Server.new('Test', Namespace, '0.0.0.0', Port) + @server.level = Logger::Severity::ERROR + @server_thread = start_server_thread(@server) + end + + def setup_client + wsdl = File.join(DIR, 'document.wsdl') + @client = ::SOAP::WSDLDriverFactory.new(wsdl).create_rpc_driver + @client.endpoint_url = "http://localhost:#{Port}/" + @client.wiredump_dev = STDOUT if $DEBUG + end + + def teardown + teardown_server + teardown_client + end + + def teardown_server + @server.shutdown + @server_thread.kill + @server_thread.join + end + + def teardown_client + @client.reset_stream + end + + def start_server_thread(server) + t = Thread.new { + Thread.current.abort_on_exception = true + server.start + } + t + end + + def test_document + msg = {'myversion' => "1.9", 'date' => "2004-01-01T00:00:00Z"} + reply_msg = @client.submit(msg) + assert_equal('1.9', reply_msg.myversion) + assert_equal('1.9', reply_msg['myversion']) + assert_equal('2004-01-01T00:00:00Z', reply_msg.date) + assert_equal('2004-01-01T00:00:00Z', reply_msg['date']) + end +end + + +end diff --git a/test/wsdl/document/document.wsdl b/test/wsdl/document/document.wsdl new file mode 100644 index 0000000000..fbf03fae8b --- /dev/null +++ b/test/wsdl/document/document.wsdl @@ -0,0 +1,74 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/test/wsdl/document/echo.rb b/test/wsdl/document/echo.rb new file mode 100644 index 0000000000..05f00412f4 --- /dev/null +++ b/test/wsdl/document/echo.rb @@ -0,0 +1,92 @@ +require 'xsd/qname' + +# {urn:docrpc}echoele +class Echoele + @@schema_type = "echoele" + @@schema_ns = "urn:docrpc" + @@schema_attribute = {XSD::QName.new(nil, "attr_string") => "SOAP::SOAPString", XSD::QName.new(nil, "attr-int") => "SOAP::SOAPInt"} + @@schema_element = [["struct1", "Echo_struct"], ["struct_2", ["Echo_struct", XSD::QName.new(nil, "struct-2")]]] + + attr_accessor :struct1 + attr_accessor :struct_2 + + def xmlattr_attr_string + (@__xmlattr ||= {})[XSD::QName.new(nil, "attr_string")] + end + + def xmlattr_attr_string=(value) + (@__xmlattr ||= {})[XSD::QName.new(nil, "attr_string")] = value + end + + def xmlattr_attr_int + (@__xmlattr ||= {})[XSD::QName.new(nil, "attr-int")] + end + + def xmlattr_attr_int=(value) + (@__xmlattr ||= {})[XSD::QName.new(nil, "attr-int")] = value + end + + def initialize(struct1 = nil, struct_2 = nil) + @struct1 = struct1 + @struct_2 = struct_2 + @__xmlattr = {} + end +end + +# {urn:docrpc}echo_response +class Echo_response + @@schema_type = "echo_response" + @@schema_ns = "urn:docrpc" + @@schema_attribute = {XSD::QName.new(nil, "attr_string") => "SOAP::SOAPString", XSD::QName.new(nil, "attr-int") => "SOAP::SOAPInt"} + @@schema_element = [["struct1", "Echo_struct"], ["struct_2", ["Echo_struct", XSD::QName.new(nil, "struct-2")]]] + + attr_accessor :struct1 + attr_accessor :struct_2 + + def xmlattr_attr_string + (@__xmlattr ||= {})[XSD::QName.new(nil, "attr_string")] + end + + def xmlattr_attr_string=(value) + (@__xmlattr ||= {})[XSD::QName.new(nil, "attr_string")] = value + end + + def xmlattr_attr_int + (@__xmlattr ||= {})[XSD::QName.new(nil, "attr-int")] + end + + def xmlattr_attr_int=(value) + (@__xmlattr ||= {})[XSD::QName.new(nil, "attr-int")] = value + end + + def initialize(struct1 = nil, struct_2 = nil) + @struct1 = struct1 + @struct_2 = struct_2 + @__xmlattr = {} + end +end + +# {urn:docrpc}echo_struct +class Echo_struct + @@schema_type = "echo_struct" + @@schema_ns = "urn:docrpc" + @@schema_attribute = {XSD::QName.new("urn:docrpc", "m_attr") => "SOAP::SOAPString"} + @@schema_element = [["m_string", "SOAP::SOAPString"], ["m_datetime", "SOAP::SOAPDateTime"]] + + attr_accessor :m_string + attr_accessor :m_datetime + + def xmlattr_m_attr + (@__xmlattr ||= {})[XSD::QName.new("urn:docrpc", "m_attr")] + end + + def xmlattr_m_attr=(value) + (@__xmlattr ||= {})[XSD::QName.new("urn:docrpc", "m_attr")] = value + end + + def initialize(m_string = nil, m_datetime = nil) + @m_string = m_string + @m_datetime = m_datetime + @__xmlattr = {} + end +end diff --git a/test/wsdl/document/number.wsdl b/test/wsdl/document/number.wsdl new file mode 100644 index 0000000000..cc3dd8e9f0 --- /dev/null +++ b/test/wsdl/document/number.wsdl @@ -0,0 +1,54 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/test/wsdl/document/ping_nosoapaction.wsdl b/test/wsdl/document/ping_nosoapaction.wsdl new file mode 100644 index 0000000000..ab9529e456 --- /dev/null +++ b/test/wsdl/document/ping_nosoapaction.wsdl @@ -0,0 +1,66 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/test/wsdl/document/test_nosoapaction.rb b/test/wsdl/document/test_nosoapaction.rb new file mode 100644 index 0000000000..77f642fe1b --- /dev/null +++ b/test/wsdl/document/test_nosoapaction.rb @@ -0,0 +1,109 @@ +require 'test/unit' +require 'wsdl/parser' +require 'wsdl/soap/wsdl2ruby' +require 'soap/rpc/standaloneServer' +require 'soap/wsdlDriver' +require 'soap/rpc/driver' + + +module WSDL; module Document + + +class TestNoSOAPAction < Test::Unit::TestCase + class Server < ::SOAP::RPC::StandaloneServer + Namespace = 'http://xmlsoap.org/Ping' + + def on_init + add_document_method( + self, + Namespace + '/ping', + 'ping_with_soapaction', + XSD::QName.new(Namespace, 'Ping'), + XSD::QName.new(Namespace, 'PingResponse') + ) + + add_document_method( + self, + nil, + 'ping', + XSD::QName.new(Namespace, 'Ping'), + XSD::QName.new(Namespace, 'PingResponse') + ) + + # When no SOAPAction given, latter method(ping) is called. + end + + def ping(arg) + arg.text = 'ping' + arg + end + + def ping_with_soapaction(arg) + arg.text = 'ping_with_soapaction' + arg + end + end + + DIR = File.dirname(File.expand_path(__FILE__)) + + Port = 17171 + + def setup + setup_server + @client = nil + end + + def teardown + teardown_server + @client.reset_stream if @client + end + + def setup_server + @server = Server.new('Test', Server::Namespace, '0.0.0.0', Port) + @server.level = Logger::Severity::ERROR + @server_thread = start_server_thread(@server) + end + + def teardown_server + @server.shutdown + @server_thread.kill + @server_thread.join + end + + def start_server_thread(server) + t = Thread.new { + Thread.current.abort_on_exception = true + server.start + } + t + end + + def test_with_soapaction + wsdl = File.join(DIR, 'ping_nosoapaction.wsdl') + @client = ::SOAP::WSDLDriverFactory.new(wsdl).create_rpc_driver + @client.endpoint_url = "http://localhost:#{Port}/" + @client.wiredump_dev = STDOUT if $DEBUG + rv = @client.ping(:scenario => 'scenario', :origin => 'origin', + :text => 'text') + assert_equal('scenario', rv.scenario) + assert_equal('origin', rv.origin) + assert_equal('ping', rv.text) + end + + def test_without_soapaction + @client = ::SOAP::RPC::Driver.new("http://localhost:#{Port}/", + Server::Namespace) + @client.add_document_method('ping', Server::Namespace + '/ping', + XSD::QName.new(Server::Namespace, 'Ping'), + XSD::QName.new(Server::Namespace, 'PingResponse')) + @client.wiredump_dev = STDOUT if $DEBUG + rv = @client.ping(:scenario => 'scenario', :origin => 'origin', + :text => 'text') + assert_equal('scenario', rv.scenario) + assert_equal('origin', rv.origin) + assert_equal('ping_with_soapaction', rv.text) + end +end + + +end; end diff --git a/test/wsdl/document/test_number.rb b/test/wsdl/document/test_number.rb new file mode 100644 index 0000000000..a640ef2a25 --- /dev/null +++ b/test/wsdl/document/test_number.rb @@ -0,0 +1,99 @@ +require 'test/unit' +require 'wsdl/parser' +require 'wsdl/soap/wsdl2ruby' +require 'soap/rpc/standaloneServer' +require 'soap/wsdlDriver' + + +module WSDL; module Document + + +class TestNumber < Test::Unit::TestCase + class Server < ::SOAP::RPC::StandaloneServer + Namespace = 'urn:foo' + + def on_init + add_document_method( + self, + Namespace + ':get_foo', + 'get_foo', + XSD::QName.new(Namespace, 'get_foo'), + XSD::QName.new(Namespace, 'get_foo_response') + ) + end + + def get_foo(arg) + arg.number + end + end + + DIR = File.dirname(File.expand_path(__FILE__)) + Port = 17171 + + def setup + setup_server + setup_classdef + @client = nil + end + + def teardown + teardown_server + File.unlink(pathname('foo.rb')) + @client.reset_stream if @client + end + + def setup_server + @server = Server.new('Test', "urn:rpc", '0.0.0.0', Port) + @server.level = Logger::Severity::ERROR + @server_thread = start_server_thread(@server) + end + + def setup_classdef + gen = WSDL::SOAP::WSDL2Ruby.new + gen.location = pathname("number.wsdl") + gen.basedir = DIR + gen.logger.level = Logger::FATAL + gen.opt['classdef'] = nil + gen.opt['force'] = true + gen.run + require pathname('foo') + end + + def teardown_server + @server.shutdown + @server_thread.kill + @server_thread.join + end + + def start_server_thread(server) + t = Thread.new { + Thread.current.abort_on_exception = true + server.start + } + t + end + + def pathname(filename) + File.join(DIR, filename) + end + + def test_wsdl + wsdl = File.join(DIR, 'number.wsdl') + @client = ::SOAP::WSDLDriverFactory.new(wsdl).create_rpc_driver + @client.endpoint_url = "http://localhost:#{Port}/" + @client.wiredump_dev = STDOUT if $DEBUG + + # with the Struct defined in foo.rb, which is generated from WSDL + assert_equal("12345", @client.get_foo(Get_foo.new("12345"))) + + # with Hash + assert_equal("12345", @client.get_foo({:number => "12345"})) + + # with Original struct + get_foo_struct = Struct.new(:number) + assert_equal("12345", @client.get_foo(get_foo_struct.new("12345"))) + end +end + + +end; end diff --git a/test/wsdl/document/test_rpc.rb b/test/wsdl/document/test_rpc.rb new file mode 100644 index 0000000000..66b804a0f9 --- /dev/null +++ b/test/wsdl/document/test_rpc.rb @@ -0,0 +1,159 @@ +require 'test/unit' +require 'wsdl/parser' +require 'wsdl/soap/wsdl2ruby' +require 'soap/rpc/standaloneServer' +require 'soap/wsdlDriver' + + +module WSDL; module Document + + +class TestRPC < Test::Unit::TestCase + class Server < ::SOAP::RPC::StandaloneServer + Namespace = 'urn:docrpc' + + def on_init + add_document_method( + self, + Namespace + ':echo', + 'echo', + XSD::QName.new(Namespace, 'echo'), + XSD::QName.new(Namespace, 'echo_response') + ) + end + + def echo(arg) + if arg.is_a?(Echoele) + # swap args + tmp = arg.struct1 + arg.struct1 = arg.struct_2 + arg.struct_2 = tmp + arg + else + # swap args + tmp = arg["struct1"] + arg["struct1"] = arg["struct-2"] + arg["struct-2"] = tmp + arg + end + end + end + + DIR = File.dirname(File.expand_path(__FILE__)) + + Port = 17171 + + def setup + setup_server + setup_classdef + @client = nil + end + + def teardown + teardown_server + #File.unlink(pathname('echo.rb')) + @client.reset_stream if @client + end + + def setup_server + @server = Server.new('Test', "urn:rpc", '0.0.0.0', Port) + @server.level = Logger::Severity::ERROR + @server_thread = start_server_thread(@server) + end + + def setup_classdef + gen = WSDL::SOAP::WSDL2Ruby.new + gen.location = pathname("document.wsdl") + gen.basedir = DIR + gen.logger.level = Logger::FATAL + gen.opt['classdef'] = nil + gen.opt['force'] = true + gen.run + require pathname('echo') + end + + def teardown_server + @server.shutdown + @server_thread.kill + @server_thread.join + end + + def start_server_thread(server) + t = Thread.new { + Thread.current.abort_on_exception = true + server.start + } + t + end + + def pathname(filename) + File.join(DIR, filename) + end + + def test_wsdl + wsdl = File.join(DIR, 'document.wsdl') + @client = ::SOAP::WSDLDriverFactory.new(wsdl).create_rpc_driver + @client.endpoint_url = "http://localhost:#{Port}/" + @client.wiredump_dev = STDOUT if $DEBUG + + struct1 = Echo_struct.new("mystring1", now1 = Time.now) + struct1.xmlattr_m_attr = 'myattr1' + struct2 = Echo_struct.new("mystring2", now2 = Time.now) + struct2.xmlattr_m_attr = 'myattr2' + echo = Echoele.new(struct1, struct2) + echo.xmlattr_attr_string = 'attr_string' + echo.xmlattr_attr_int = 5 + ret = @client.echo(echo) + + timeformat = "%Y-%m-%dT%H:%M:%S.%s" + assert_equal("mystring2", ret.struct1.m_string) + assert_equal(now2.strftime(timeformat), ret.struct1.m_datetime.strftime(timeformat)) + assert_equal("mystring1", ret.struct_2.m_string) + assert_equal(now1.strftime(timeformat), ret.struct_2.m_datetime.strftime(timeformat)) + assert_equal("attr_string", ret.xmlattr_attr_string) + assert_equal(5, ret.xmlattr_attr_int) + end + + include ::SOAP + def test_naive + @client = ::SOAP::RPC::Driver.new("http://localhost:#{Port}/") + @client.add_document_method('echo', 'urn:docrpc:echo', + XSD::QName.new('urn:docrpc', 'echoele'), + XSD::QName.new('urn:docrpc', 'echo_response')) + @client.wiredump_dev = STDOUT if $DEBUG + + echo = SOAPElement.new('foo') + echo.extraattr['attr_string'] = 'attr_string' + echo.extraattr['attr-int'] = 5 + echo.add(struct1 = SOAPElement.new('struct1')) + struct1.add(SOAPElement.new('m_string', 'mystring1')) + struct1.add(SOAPElement.new('m_datetime', '2005-03-17T19:47:31+01:00')) + struct1.extraattr['m_attr'] = 'myattr1' + echo.add(struct2 = SOAPElement.new('struct-2')) + struct2.add(SOAPElement.new('m_string', 'mystring2')) + struct2.add(SOAPElement.new('m_datetime', '2005-03-17T19:47:32+02:00')) + struct2.extraattr['m_attr'] = 'myattr2' + ret = @client.echo(echo) + timeformat = "%Y-%m-%dT%H:%M:%S" + assert_equal('mystring2', ret.struct1.m_string) + assert_equal('2005-03-17T19:47:32', ret.struct1.m_datetime.strftime(timeformat)) + #p ret.struct1.class + #p ret.struct_2.class + assert_equal("mystring1", ret.struct_2.m_string) + assert_equal('2005-03-17T19:47:31', ret.struct_2.m_datetime.strftime(timeformat)) + assert_equal('attr_string', ret.xmlattr_attr_string) + assert_equal(5, ret.xmlattr_attr_int) + + echo = {'struct1' => {'m_string' => 'mystring1', 'm_datetime' => '2005-03-17T19:47:31+01:00'}, + 'struct-2' => {'m_string' => 'mystring2', 'm_datetime' => '2005-03-17T19:47:32+02:00'}} + ret = @client.echo(echo) + timeformat = "%Y-%m-%dT%H:%M:%S" + assert_equal('mystring2', ret.struct1.m_string) + assert_equal('2005-03-17T19:47:32', ret.struct1.m_datetime.strftime(timeformat)) + assert_equal("mystring1", ret.struct_2.m_string) + assert_equal('2005-03-17T19:47:31', ret.struct_2.m_datetime.strftime(timeformat)) + end +end + + +end; end diff --git a/test/wsdl/marshal/person.wsdl b/test/wsdl/marshal/person.wsdl new file mode 100644 index 0000000000..6ea8a04825 --- /dev/null +++ b/test/wsdl/marshal/person.wsdl @@ -0,0 +1,21 @@ + + + + + + + + + + + + + + + + diff --git a/test/wsdl/marshal/person_org.rb b/test/wsdl/marshal/person_org.rb new file mode 100644 index 0000000000..55405b658d --- /dev/null +++ b/test/wsdl/marshal/person_org.rb @@ -0,0 +1,22 @@ +require 'xsd/qname' + +# {http://www.jin.gr.jp/~nahi/xmlns/sample/Person}Person +class Person + @@schema_type = "Person" + @@schema_ns = "http://www.jin.gr.jp/~nahi/xmlns/sample/Person" + @@schema_element = [["familyname", "SOAP::SOAPString"], ["givenname", "SOAP::SOAPString"], ["var1", "SOAP::SOAPInt"], ["var2", "SOAP::SOAPDouble"], ["var3", "SOAP::SOAPString"]] + + attr_accessor :familyname + attr_accessor :givenname + attr_accessor :var1 + attr_accessor :var2 + attr_accessor :var3 + + def initialize(familyname = nil, givenname = nil, var1 = nil, var2 = nil, var3 = nil) + @familyname = familyname + @givenname = givenname + @var1 = var1 + @var2 = var2 + @var3 = var3 + end +end diff --git a/test/wsdl/marshal/test_wsdlmarshal.rb b/test/wsdl/marshal/test_wsdlmarshal.rb new file mode 100644 index 0000000000..cd2bdb198a --- /dev/null +++ b/test/wsdl/marshal/test_wsdlmarshal.rb @@ -0,0 +1,80 @@ +require 'test/unit' +require 'wsdl/parser' +require 'soap/mapping/wsdlencodedregistry' +require 'soap/marshal' +require 'wsdl/soap/wsdl2ruby' + +class WSDLMarshaller + include SOAP + + def initialize(wsdlfile) + wsdl = WSDL::Parser.new.parse(File.open(wsdlfile) { |f| f.read }) + types = wsdl.collect_complextypes + @opt = { + :decode_typemap => types, + :generate_explicit_type => false, + :pretty => true + } + @mapping_registry = Mapping::WSDLEncodedRegistry.new(types) + end + + def dump(obj, io = nil) + type = Mapping.class2element(obj.class) + ele = Mapping.obj2soap(obj, @mapping_registry, type) + ele.elename = ele.type + Processor.marshal(SOAPEnvelope.new(nil, SOAPBody.new(ele)), @opt, io) + end + + def load(io) + header, body = Processor.unmarshal(io, @opt) + Mapping.soap2obj(body.root_node) + end +end + + +require File.join(File.dirname(__FILE__), 'person_org') + +class Person + def ==(rhs) + @familyname == rhs.familyname and @givenname == rhs.givenname and + @var1 == rhs.var1 and @var2 == rhs.var2 and @var3 == rhs.var3 + end +end + + +class TestWSDLMarshal < Test::Unit::TestCase + DIR = File.dirname(File.expand_path(__FILE__)) + + def test_marshal + marshaller = WSDLMarshaller.new(pathname('person.wsdl')) + obj = Person.new("NAKAMURA", "Hiroshi", 1, 1.0, "1") + str = marshaller.dump(obj) + obj2 = marshaller.load(str) + assert_equal(obj, obj2) + assert_equal(str, marshaller.dump(obj2)) + end + + def test_classdef + gen = WSDL::SOAP::WSDL2Ruby.new + gen.location = pathname("person.wsdl") + gen.basedir = DIR + gen.logger.level = Logger::FATAL + gen.opt['classdef'] = nil + gen.opt['force'] = true + gen.run + compare("person_org.rb", "Person.rb") + File.unlink(pathname('Person.rb')) + end + + def compare(expected, actual) + assert_equal(loadfile(expected), loadfile(actual), actual) + end + + def loadfile(file) + File.open(pathname(file)) { |f| f.read } + end + + def pathname(filename) + File.join(DIR, filename) + end +end diff --git a/test/wsdl/raa/server.rb b/test/wsdl/raa/server.rb new file mode 100644 index 0000000000..87bbc6f569 --- /dev/null +++ b/test/wsdl/raa/server.rb @@ -0,0 +1,103 @@ +#!/usr/bin/env ruby +require 'soap/rpc/standaloneServer' +require 'RAA.rb' + +class RAABaseServicePortType + MappingRegistry = SOAP::Mapping::Registry.new + + MappingRegistry.set( + StringArray, + ::SOAP::SOAPArray, + ::SOAP::Mapping::Registry::TypedArrayFactory, + { :type => XSD::QName.new("http://www.w3.org/2001/XMLSchema", "string") } + ) + MappingRegistry.set( + Map, + ::SOAP::SOAPStruct, + ::SOAP::Mapping::Registry::TypedStructFactory, + { :type => XSD::QName.new("http://xml.apache.org/xml-soap", "Map") } + ) + MappingRegistry.set( + Category, + ::SOAP::SOAPStruct, + ::SOAP::Mapping::Registry::TypedStructFactory, + { :type => XSD::QName.new("http://www.ruby-lang.org/xmlns/soap/interface/RAA/0.0.2/", "Category") } + ) + MappingRegistry.set( + InfoArray, + ::SOAP::SOAPArray, + ::SOAP::Mapping::Registry::TypedArrayFactory, + { :type => XSD::QName.new("http://www.ruby-lang.org/xmlns/soap/interface/RAA/0.0.2/", "Info") } + ) + MappingRegistry.set( + Info, + ::SOAP::SOAPStruct, + ::SOAP::Mapping::Registry::TypedStructFactory, + { :type => XSD::QName.new("http://www.ruby-lang.org/xmlns/soap/interface/RAA/0.0.2/", "Info") } + ) + MappingRegistry.set( + Product, + ::SOAP::SOAPStruct, + ::SOAP::Mapping::Registry::TypedStructFactory, + { :type => XSD::QName.new("http://www.ruby-lang.org/xmlns/soap/interface/RAA/0.0.2/", "Product") } + ) + MappingRegistry.set( + Owner, + ::SOAP::SOAPStruct, + ::SOAP::Mapping::Registry::TypedStructFactory, + { :type => XSD::QName.new("http://www.ruby-lang.org/xmlns/soap/interface/RAA/0.0.2/", "Owner") } + ) + + Methods = [ + ["getAllListings", "getAllListings", [ + ["retval", "return", + [::SOAP::SOAPArray, "http://www.w3.org/2001/XMLSchema", "string"]]], + "", "http://www.ruby-lang.org/xmlns/soap/interface/RAA/0.0.2/"], + ["getProductTree", "getProductTree", [ + ["retval", "return", + [::SOAP::SOAPStruct, "http://xml.apache.org/xml-soap", "Map"]]], + "", "http://www.ruby-lang.org/xmlns/soap/interface/RAA/0.0.2/"], + ["getInfoFromCategory", "getInfoFromCategory", [ + ["in", "category", + [::SOAP::SOAPStruct, "http://www.ruby-lang.org/xmlns/soap/interface/RAA/0.0.2/", "Category"]], + ["retval", "return", + [::SOAP::SOAPArray, "http://www.ruby-lang.org/xmlns/soap/interface/RAA/0.0.2/", "Info"]]], + "", "http://www.ruby-lang.org/xmlns/soap/interface/RAA/0.0.2/"], + ["getModifiedInfoSince", "getModifiedInfoSince", [ + ["in", "timeInstant", + [SOAP::SOAPDateTime]], + ["retval", "return", + [::SOAP::SOAPArray, "http://www.ruby-lang.org/xmlns/soap/interface/RAA/0.0.2/", "Info"]]], + "", "http://www.ruby-lang.org/xmlns/soap/interface/RAA/0.0.2/"], + ["getInfoFromName", "getInfoFromName", [ + ["in", "productName", + [SOAP::SOAPString]], + ["retval", "return", + [::SOAP::SOAPStruct, "http://www.ruby-lang.org/xmlns/soap/interface/RAA/0.0.2/", "Info"]]], + "", "http://www.ruby-lang.org/xmlns/soap/interface/RAA/0.0.2/"], + ["getInfoFromOwnerId", "getInfoFromOwnerId", [ + ["in", "ownerId", + [SOAP::SOAPInt]], + ["retval", "return", + [::SOAP::SOAPArray, "http://www.ruby-lang.org/xmlns/soap/interface/RAA/0.0.2/", "Info"]]], + "", "http://www.ruby-lang.org/xmlns/soap/interface/RAA/0.0.2/"] + ] + + def getAllListings + ["ruby", "soap4r"] + end +end + +class RAABaseServiceServer < SOAP::RPC::StandaloneServer + def initialize(*arg) + super + + servant = RAABaseServicePortType.new + RAABaseServicePortType::Methods.each do |name_as, name, params, soapaction, namespace| + qname = XSD::QName.new(namespace, name_as) + @router.add_method(servant, qname, soapaction, name, params) + end + + self.mapping_registry = RAABaseServicePortType::MappingRegistry + end +end diff --git a/test/wsdl/rpc/rpc.wsdl b/test/wsdl/rpc/rpc.wsdl new file mode 100644 index 0000000000..b0ee5c5e56 --- /dev/null +++ b/test/wsdl/rpc/rpc.wsdl @@ -0,0 +1,75 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/test/wsdl/rpc/test_rpc.rb b/test/wsdl/rpc/test_rpc.rb new file mode 100644 index 0000000000..7c4c3a7ad6 --- /dev/null +++ b/test/wsdl/rpc/test_rpc.rb @@ -0,0 +1,118 @@ +require 'test/unit' +require 'wsdl/parser' +require 'wsdl/soap/wsdl2ruby' +require 'soap/rpc/standaloneServer' +require 'soap/wsdlDriver' + + +module WSDL; module RPC + + +class TestRPC < Test::Unit::TestCase + class Server < ::SOAP::RPC::StandaloneServer + def on_init + self.generate_explicit_type = false + add_rpc_method(self, 'echo', 'arg1', 'arg2') + add_rpc_method(self, 'echo_err', 'arg1', 'arg2') + end + + DummyPerson = Struct.new("family-name".intern, :given_name) + def echo(arg1, arg2) + case arg1.family_name + when 'normal' + arg1.family_name = arg2.family_name + arg1.given_name = arg2.given_name + arg1.age = arg2.age + arg1 + when 'dummy' + DummyPerson.new("family-name", "given_name") + else + raise + end + end + + ErrPerson = Struct.new(:given_name, :no_such_element) + def echo_err(arg1, arg2) + ErrPerson.new(58, Time.now) + end + end + + DIR = File.dirname(File.expand_path(__FILE__)) + + Port = 17171 + + def setup + setup_server + setup_classdef + @client = nil + end + + def teardown + teardown_server + File.unlink(pathname('echo.rb')) + @client.reset_stream if @client + end + + def setup_server + @server = Server.new('Test', "urn:rpc", '0.0.0.0', Port) + @server.level = Logger::Severity::ERROR + @server_thread = start_server_thread(@server) + end + + def setup_classdef + gen = WSDL::SOAP::WSDL2Ruby.new + gen.location = pathname("rpc.wsdl") + gen.basedir = DIR + gen.logger.level = Logger::FATAL + gen.opt['classdef'] = nil + gen.opt['force'] = true + gen.run + require pathname('echo') + end + + def teardown_server + @server.shutdown + @server_thread.kill + @server_thread.join + end + + def start_server_thread(server) + t = Thread.new { + Thread.current.abort_on_exception = true + server.start + } + t + end + + def pathname(filename) + File.join(DIR, filename) + end + + def test_wsdl + wsdl = File.join(DIR, 'rpc.wsdl') + @client = ::SOAP::WSDLDriverFactory.new(wsdl).create_rpc_driver + @client.endpoint_url = "http://localhost:#{Port}/" + @client.wiredump_dev = STDOUT if $DEBUG + + ret = @client.echo(Person.new("normal", "", 12), Person.new("Hi", "Na", 21)) + assert_equal(Person, ret.class) + assert_equal("Hi", ret.family_name) + assert_equal("Na", ret.given_name) + assert_equal(21, ret.age) + + ret = @client.echo(Person.new("dummy", "", 12), Person.new("Hi", "Na", 21)) + assert_equal(Person, ret.class) + assert_equal("family-name", ret.family_name) + assert_equal("given_name", ret.given_name) + assert_equal(nil, ret.age) + + ret = @client.echo_err(Person.new("Na", "Hi"), Person.new("Hi", "Na")) + assert_equal(Person, ret.class) + assert_equal("58", ret.given_name) + assert_equal(nil, ret.family_name) + assert_equal(nil, ret.age) + end +end + + +end; end diff --git a/test/xsd/codegen/test_classdef.rb b/test/xsd/codegen/test_classdef.rb new file mode 100644 index 0000000000..64c4771918 --- /dev/null +++ b/test/xsd/codegen/test_classdef.rb @@ -0,0 +1,214 @@ +require 'test/unit' +require 'xsd/codegen/classdef' + + +module XSD; module CodeGen + + +class TestClassDefCreator < Test::Unit::TestCase + include XSD::CodeGen + include GenSupport + + def test_classdef_simple + c = ClassDef.new("Foo") + assert_equal(format(<<-EOD), c.dump) + class Foo + end + EOD + end + + def test_classdef_complex + c = ClassDef.new("Foo::Bar::Baz", String) + assert_equal(format(<<-EOD), c.dump) + module Foo; module Bar + + class Baz < String + end + + end; end + EOD + end + + def test_require + c = ClassDef.new("Foo") + c.def_require("foo/bar") + assert_equal(format(<<-EOD), c.dump) + require 'foo/bar' + + class Foo + end + EOD + end + + def test_comment + c = ClassDef.new("Foo") + c.def_require("foo/bar") + c.comment = <<-EOD + foo + EOD + assert_equal(format(<<-EOD), c.dump) + require 'foo/bar' + + # foo + class Foo + end + EOD + c.comment = <<-EOD + foo + + bar + baz + + EOD + assert_equal(format(<<-EOD), c.dump) + require 'foo/bar' + + # foo + # + # bar + # baz + # + class Foo + end + EOD + end + + def test_emptymethod + c = ClassDef.new("Foo") + c.def_method('foo') do + end + c.def_method('bar') do + '' + end + assert_equal(format(<<-EOD), c.dump) + class Foo + def foo + end + + def bar + end + end + EOD + end + + def test_full + c = ClassDef.new("Foo::Bar::HobbitName", String) + c.def_require("foo/bar") + c.comment = <<-EOD + foo + bar + baz + EOD + c.def_const("FOO", 1) + c.def_classvar("@@foo", "var".dump) + c.def_classvar("baz", "1".dump) + c.def_attr("Foo", true, "foo") + c.def_attr("bar") + c.def_attr("baz", true) + c.def_attr("Foo2", true, "foo2") + c.def_attr("foo3", false, "foo3") + c.def_method("foo") do + <<-EOD + foo.bar = 1 +\tbaz.each do |ele| +\t ele + end + EOD + end + c.def_method("baz", "qux") do + <<-EOD + [1, 2, 3].each do |i| + p i + end + EOD + end + + m = MethodDef.new("qux", "quxx", "quxxx") do + <<-EOD + p quxx + quxxx + EOD + end + m.comment = "hello world\n123" + c.add_method(m) + c.def_code <<-EOD + Foo.new + Bar.z + EOD + c.def_code <<-EOD + Foo.new + Bar.z + EOD + c.def_privatemethod("foo", "baz", "*arg", "&block") + + assert_equal(format(<<-EOD), c.dump) + require 'foo/bar' + + module Foo; module Bar + + # foo + # bar + # baz + class HobbitName < String + @@foo = "var" + @@baz = "1" + + FOO = 1 + + Foo.new + Bar.z + + Foo.new + Bar.z + + attr_accessor :bar + attr_accessor :baz + attr_reader :foo3 + + def Foo + @foo + end + + def Foo=(value) + @foo = value + end + + def Foo2 + @foo2 + end + + def Foo2=(value) + @foo2 = value + end + + def foo + foo.bar = 1 + baz.each do |ele| + ele + end + end + + def baz(qux) + [1, 2, 3].each do |i| + p i + end + end + + # hello world + # 123 + def qux(quxx, quxxx) + p quxx + quxxx + end + + private + + def foo(baz, *arg, &block) + end + end + + end; end + EOD + end +end + + +end; end -- cgit v1.2.3