malagant-soap4r 1.5.8.20141127181857

data/test/wsdl/test_emptycomplextype.rb

@@ -0,0 +1,22 @@
+# encoding: ASCII-8BIT
+require 'helper'
+require 'wsdl/parser'
+
+
+module WSDL
+
+
+class TestWSDL < Test::Unit::TestCase
+  def setup
+    @file = File.join(File.dirname(File.expand_path(__FILE__)), 'emptycomplextype.wsdl')
+  end
+
+  def test_wsdl
+    @wsdl = WSDL::Parser.new.parse(File.open(@file) { |f| f.read })
+    assert(/\{urn:jp.gr.jin.rrr.example.emptycomplextype\}emptycomplextype/ =~ @wsdl.inspect)
+  end
+end
+
+
+
+end

data/test/wsdl/test_fault.rb

@@ -0,0 +1,51 @@
+# encoding: ASCII-8BIT
+require 'helper'
+require 'soap/processor'
+require 'soap/mapping'
+require 'soap/rpc/element'
+require 'wsdl/parser'
+
+
+module WSDL
+
+
+class TestFault < Test::Unit::TestCase
+  def setup
+    @xml =<<__EOX__
+<?xml version="1.0" encoding="utf-8" ?>
+<env:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+    xmlns:env="http://schemas.xmlsoap.org/soap/envelope/"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <env:Body>
+    <env:Fault xmlns:n1="http://schemas.xmlsoap.org/soap/encoding/"
+        env:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
+      <faultcode>Server</faultcode>
+      <faultstring>faultstring</faultstring>
+      <faultactor>faultactor</faultactor>
+      <detail xmlns:n2="http://www.ruby-lang.org/xmlns/ruby/type/custom"
+          xsi:type="n2:SOAPException">
+	<excn_type_name xsi:type="xsd:string">type</excn_type_name>
+	<cause href="#id123"/>
+      </detail>
+    </env:Fault>
+    <cause id="id123" xsi:type="xsd:int">5</cause>
+  </env:Body>
+</env:Envelope>
+__EOX__
+  end
+
+  def test_by_wsdl
+    rpc_decode_typemap = WSDL::Definitions.soap_rpc_complextypes
+    opt = {}
+    opt[:default_encodingstyle] = ::SOAP::EncodingNamespace
+    header, body = ::SOAP::Processor.unmarshal(@xml, opt)
+    fault = ::SOAP::Mapping.soap2obj(body.response)
+    assert_equal("Server", fault.faultcode)
+    assert_equal("faultstring", fault.faultstring)
+    assert_equal("faultactor", fault.faultactor)
+    assert_equal(5, fault.detail.cause)
+  end
+end
+
+
+end

data/test/wsdl/test_multiplefault.rb

@@ -0,0 +1,42 @@
+# encoding: ASCII-8BIT
+require 'helper'
+require 'wsdl/parser'
+require 'wsdl/soap/classDefCreator'
+require 'wsdl/soap/classNameCreator'
+
+
+module WSDL
+
+
+class TestMultipleFault < Test::Unit::TestCase
+  def self.setup(filename)
+    @@filename = filename
+  end
+
+  def test_multiplefault
+    @wsdl = WSDL::Parser.new.parse(File.open(@@filename) { |f| f.read })
+    name_creator = WSDL::SOAP::ClassNameCreator.new
+    classdefstr = WSDL::SOAP::ClassDefCreator.new(@wsdl, name_creator).dump
+    yield_eval_binding(classdefstr) do |b|
+      assert_equal(
+	WSDL::TestMultipleFault::AuthenticationError,
+	eval("AuthenticationError", b)
+      )
+      assert_equal(
+	WSDL::TestMultipleFault::AuthorizationError,
+	eval("AuthorizationError", b)
+      )
+    end
+  end
+
+  def yield_eval_binding(evaled)
+    b = binding
+    eval(evaled, b)
+    yield(b)
+  end
+end
+
+TestMultipleFault.setup(File.join(File.dirname(__FILE__), 'multiplefault.wsdl'))
+
+
+end

data/test/xsd/codegen/test_classdef.rb

@@ -0,0 +1,245 @@
+# encoding: ASCII-8BIT
+require 'helper'
+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_innermodule
+    c = ClassDef.new("Foo")
+    c.def_const("BAR", 1)
+    c.def_method('baz') { "Qux.new.quxx" }
+    c2 = ClassDef.new("Qux")
+    c2.def_method('quxx') { "Quxx::QUXXX" }
+    m3 = ModuleDef.new("Quxx")
+    m3.def_const("QUXXX", 2)
+    c.innermodule << c2 << m3
+    assert_equal(format(<<-EOD), c.dump)
+      class Foo
+        BAR = 1
+
+        class Qux
+          def quxx
+            Quxx::QUXXX
+          end
+        end
+
+        module Quxx
+          QUXXX = 2
+        end
+
+        def baz
+          Qux.new.quxx
+        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

data/test/xsd/noencoding.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="euc-jp"?>
+<schema xmlns="http://www.w3.org/2001/XMLSchema">
+  <!-- ������ -->
+</schema>

data/test/xsd/test_noencoding.rb

@@ -0,0 +1,33 @@
+# encoding: ASCII-8BIT
+require 'helper'
+require 'wsdl/xmlSchema/parser'
+
+
+module XSD
+
+
+class TestEmptyCharset < Test::Unit::TestCase
+  def setup
+    @file = File.join(File.dirname(File.expand_path(__FILE__)), 'noencoding.xml')
+  end
+
+  def test_wsdl
+    begin
+      xml = WSDL::XMLSchema::Parser.new.parse(File.open(@file) { |f| f.read })
+    rescue RuntimeError
+      if XSD::XMLParser.const_defined?("REXMLParser")
+	STDERR.puts("rexml cannot handle euc-jp without iconv/uconv.")
+	return
+      end
+      raise
+    rescue Errno::EINVAL
+      # unsupported encoding
+      return
+    end
+    assert_equal(WSDL::XMLSchema::Schema, xml.class)
+    assert_equal(0, xml.collect_elements.size)
+  end
+end
+
+
+end

data/test/xsd/test_ns.rb

@@ -0,0 +1,42 @@
+# encoding: ASCII-8BIT
+require 'helper'
+require 'soap/marshal'
+
+
+module XSD
+
+
+class TestNS < Test::Unit::TestCase
+  def test_xmllang
+    @file = File.join(File.dirname(File.expand_path(__FILE__)), 'xmllang.xml')
+    obj = SOAP::Marshal.load(File.open(@file) { |f| f.read })
+    assert_equal("12345", obj.partyDataLine.gln)
+    lang = obj.partyDataLine.__xmlattr[
+      XSD::QName.new(XSD::NS::Namespace, "lang")]
+    assert_equal("EN", lang)
+  end
+
+  def test_no_default_namespace
+    env = SOAP::Processor.unmarshal(NO_DEFAULT_NAMESPACE)
+    array = env.body.root_node["array"]
+    item = array["item"]
+    assert_equal("urn:ns", array.elename.namespace)
+    assert_equal(nil, item.elename.namespace)
+  end
+
+NO_DEFAULT_NAMESPACE = <<__XML__
+<?xml version="1.0" encoding="utf-8"?>
+<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+  <env:Body>
+    <response xmlns="urn:ns">
+      <array>
+        <item attr="1" xmlns=""/>
+      </array>
+    </response>
+  </env:Body>
+</env:Envelope>
+__XML__
+end
+
+
+end

data/test/xsd/test_xmlschemaparser.rb

@@ -0,0 +1,23 @@
+# encoding: ASCII-8BIT
+require 'helper'
+require 'wsdl/xmlSchema/parser'
+
+
+module XSD
+
+
+class TestXMLSchemaParser < Test::Unit::TestCase
+  def setup
+    @file = File.join(File.dirname(File.expand_path(__FILE__)), 'xmlschema.xml')
+  end
+
+  def test_wsdl
+    @wsdl = WSDL::XMLSchema::Parser.new.parse(File.open(@file) { |f| f.read })
+    assert_equal(WSDL::XMLSchema::Schema, @wsdl.class)
+    assert_equal(1, @wsdl.collect_elements.size)
+  end
+end
+
+
+
+end