lolsoap 0.1.4 → 0.2.0

data/test/fixtures/stock_quote_fault_soap_1_1.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0"?>
+<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
+<soap:Body>
+  <soap:Fault>
+    <soap:faultcode>soap:Sender</soap:faultcode>
+    <soap:faultstring>Omg! stock market has crashed!</soap:faultstring>
+    <soap:detail><Foo>Some detail</Foo></soap:detail>
+  </soap:Fault>
+</soap:Body>
+</soap:Envelope>

data/test/integration/test_envelope.rb

@@ -21,6 +21,7 @@ module LolSoap
           s.name 'LOCOLOCOLOCO'
         end
         b.lol
+        b.id 42
       end
 
       el = doc.at_xpath('//xsd1:TradePriceRequest/xsd1:tickerSymbol', doc.namespaces)
@@ -30,6 +31,9 @@ module LolSoap
       el = doc.at_xpath('//xsd1:TradePriceRequest/xsd1:specialTickerSymbol/xsd2:name', doc.namespaces)
       el.wont_equal nil
       el.text.to_s.must_equal 'LOCOLOCOLOCO'
+
+      attr = doc.at_xpath('//xsd1:TradePriceRequest/@id', doc.namespaces)
+      attr.to_s.must_equal "42"
     end
 
     it 'creates some header' do

data/test/integration/test_wsdl.rb

@@ -8,14 +8,13 @@ module LolSoap
     it 'should successfully parse a WSDL document' do
       subject.operations.length.must_equal 1
       subject.operations['GetLastTradePrice'].tap do |o|
-        o.input.must_equal  subject.types['TradePriceRequest']
+        o.input.must_equal  subject.types['xsd1:TradePriceRequest']
         o.action.must_equal 'http://example.com/GetLastTradePrice'
       end
 
       subject.types.length.must_equal 3
-      subject.types['TradePriceRequest'].tap do |t|
-        t.name.must_equal 'TradePriceRequest'
-        t.namespace.must_equal 'http://example.com/stockquote.xsd'
+      subject.types['xsd1:TradePriceRequest'].tap do |t|
+        t.prefix.must_equal 'xsd1'
       end
     end
 

data/test/unit/test_builder.rb

@@ -15,6 +15,7 @@ module LolSoap
     end
     let(:type) do
       type = OpenStruct.new(:prefix => 'a')
+      def type.has_attribute?(*); false; end
       def type.sub_type(name)
         @sub_types ||= { 'foo' => Object.new, 'bar' => Object.new, 'clone' => Object.new }
         @sub_types[name]

data/test/unit/test_envelope.rb

@@ -3,7 +3,13 @@ require 'lolsoap/envelope'
 
 module LolSoap
   describe Envelope do
-    let(:wsdl) { OpenStruct.new(:type_namespaces => { 'foo' => 'http://example.com/foo' }) }
+    let(:wsdl) do
+      OpenStruct.new(
+        :type_namespaces => { 'foo' => 'http://example.com/foo' },
+        :soap_version    => '1.2'
+      )
+    end
+
     let(:operation) do
       OpenStruct.new(:input => OpenStruct.new(:prefix => 'foo', :name => 'WashHandsRequest'))
     end
@@ -16,7 +22,7 @@ module LolSoap
 
     it 'has a skeleton SOAP envelope structure when first created' do
       doc.namespaces.must_equal(
-        'xmlns:soap' => Envelope::SOAP_NAMESPACE,
+        'xmlns:soap' => Envelope::SOAP_1_2,
         'xmlns:foo'  => 'http://example.com/foo'
       )
 
@@ -84,7 +90,11 @@ module LolSoap
 
     describe '#to_xml' do
       it 'returns the xml of the doc' do
-        def subject.doc; OpenStruct.new(:to_xml => '<lol>'); end
+        def subject.doc
+          doc = Object.new
+          def doc.to_xml(options); '<lol>'; end
+          doc
+        end
         subject.to_xml.must_equal '<lol>'
       end
     end
@@ -108,5 +118,15 @@ module LolSoap
         subject.output_type.must_equal 'lol'
       end
     end
+
+    describe '#soap_namespace' do
+      it 'returns the correct envelope namespace according to the SOAP version' do
+        wsdl.soap_version = '1.2'
+        subject.soap_namespace.must_equal Envelope::SOAP_1_2
+
+        wsdl.soap_version = '1.1'
+        subject.soap_namespace.must_equal Envelope::SOAP_1_1
+      end
+    end
   end
 end

data/test/unit/test_fault.rb

@@ -4,30 +4,48 @@ require 'lolsoap/fault'
 
 module LolSoap
   describe Fault do
-    let(:request) { OpenStruct.new(:soap_namespace => Envelope::SOAP_NAMESPACE) }
-    let(:node) do
-      doc = Nokogiri::XML(File.read(TEST_ROOT + '/fixtures/stock_quote_fault.xml'))
-      doc.at_xpath('//soap:Fault', 'soap' => Envelope::SOAP_NAMESPACE)
-    end
+    examples = proc do
+      describe '#code' do
+        it 'returns the code' do
+          subject.code.must_equal 'soap:Sender'
+        end
+      end
 
-    subject { Fault.new(request, node) }
+      describe '#reason' do
+        it 'returns the reason' do
+          subject.reason.must_match(/^Omg.*crashed!$/)
+        end
+      end
 
-    describe '#code' do
-      it 'returns the code' do
-        subject.code.must_equal 'soap:Sender'
+      describe '#detail' do
+        it 'returns the detail' do
+          subject.detail.must_equal '<Foo>Some detail</Foo>'
+        end
       end
     end
 
-    describe '#reason' do
-      it 'returns the reason' do
-        subject.reason.must_match(/^Omg.*crashed!$/)
+    describe 'SOAP 1.1' do
+      let(:request) { OpenStruct.new(:soap_version => '1.2', :soap_namespace => Envelope::SOAP_1_2) }
+      let(:node) do
+        doc = Nokogiri::XML(File.read(TEST_ROOT + '/fixtures/stock_quote_fault.xml'))
+        doc.at_xpath('//soap:Fault', 'soap' => Envelope::SOAP_1_2)
       end
+
+      subject { Fault.new(request, node) }
+
+      instance_eval(&examples)
     end
 
-    describe '#detail' do
-      it 'returns the detail' do
-        subject.detail.must_equal '<Foo>Some detail</Foo>'
+    describe 'SOAP 1.2' do
+      let(:request) { OpenStruct.new(:soap_version => '1.1', :soap_namespace => Envelope::SOAP_1_1) }
+      let(:node) do
+        doc = Nokogiri::XML(File.read(TEST_ROOT + '/fixtures/stock_quote_fault_soap_1_1.xml'))
+        doc.at_xpath('//soap:Fault', 'soap' => Envelope::SOAP_1_1)
       end
+
+      subject { Fault.new(request, node) }
+
+      instance_eval(&examples)
     end
   end
 end

data/test/unit/test_request.rb

@@ -6,18 +6,6 @@ module LolSoap
     let(:envelope) { OpenStruct.new }
     subject { Request.new(envelope) }
 
-    [:header, :body, :soap_namespace, :input_type, :output_type].each do |method|
-      describe "##{method}" do
-        let(:envelope) { MiniTest::Mock.new }
-
-        it 'delegates to the envelope' do
-          ret = Object.new
-          envelope.expect(method, ret)
-          subject.send(method).must_equal ret
-        end
-      end
-    end
-
     describe '#url' do
       it 'returns the envelope endpoint' do
         envelope.endpoint = 'lol'
@@ -27,7 +15,7 @@ module LolSoap
 
     describe '#headers' do
       it 'returns the necessary headers' do
-        envelope.to_xml = '<lol>'
+        def envelope.to_xml(options); '<lol>'; end
         envelope.action = 'http://example.com/LolOutLoud'
 
         subject.headers.must_equal({
@@ -40,9 +28,21 @@ module LolSoap
 
     describe '#content' do
       it 'returns the envelope as an xml string' do
-        envelope.to_xml = '<lol>'
+        def envelope.to_xml(options); '<lol>'; end
         subject.content.must_equal '<lol>'
       end
     end
+
+    describe '#mime' do
+      it 'is application/soap+xml for SOAP 1.2' do
+        envelope.soap_version = '1.2'
+        subject.mime.must_equal 'application/soap+xml'
+      end
+
+      it 'is text/xml for SOAP 1.1' do
+        envelope.soap_version = '1.1'
+        subject.mime.must_equal 'text/xml'
+      end
+    end
   end
 end

data/test/unit/test_response.rb

@@ -4,7 +4,7 @@ require 'lolsoap/response'
 
 module LolSoap
   describe Response do
-    let(:request) { OpenStruct.new(:soap_namespace => Envelope::SOAP_NAMESPACE, :output => Object.new) }
+    let(:request) { OpenStruct.new(:soap_namespace => Envelope::SOAP_1_2, :soap_version => '1.2', :output => Object.new) }
     let(:doc) { Nokogiri::XML(File.read(TEST_ROOT + '/fixtures/stock_quote_response.xml')) }
 
     subject { Response.new(request, doc) }

data/test/unit/test_wsdl.rb

@@ -5,137 +5,118 @@ module LolSoap
   describe WSDL do
     describe 'with a doc that can be parsed' do
       let(:namespace) { 'http://lolsoap.api/bla' }
-      let(:parser) { OpenStruct.new(:namespaces => { 'bla' => namespace }) }
 
-      subject { WSDL.new(parser) }
-
-      describe 'with operations' do
-        before do
-          def subject.type(n)
-            @types ||= { 'WashHandsRequest' => Object.new, 'WashHandsResponse' => Object.new }
-            @types[n]
-          end
-
-          parser.operations = {
+      let(:parser) do
+        OpenStruct.new(
+          :namespaces => { 'bla' => namespace },
+          :operations => {
             'washHands' => {
               :action => 'urn:washHands',
-              :input  => { :name => 'WashHandsRequest' },
-              :output => { :name => 'WashHandsResponse' }
+              :input  => 'bla:Brush',
+              :output => 'bla:Color'
             }
-          }
-        end
-
-        describe '#operations' do
-          it 'returns a hash of operations' do
-            subject.operations.length.must_equal 1
-            subject.operations['washHands'].tap do |op|
-              op.wsdl.must_equal   subject
-              op.action.must_equal "urn:washHands"
-              op.input.must_equal  subject.types['WashHandsRequest']
-              op.output.must_equal subject.types['WashHandsResponse']
-            end
-          end
-        end
-
-        describe '#operation' do
-          it 'returns a single operation' do
-            subject.operation('washHands').must_equal subject.operations['washHands']
-          end
-        end
-      end
-
-      describe '#endpoint' do
-        it 'returns the endpoint' do
-          parser.endpoint = 'http://lolsoap.api/v1'
-          subject.endpoint.must_equal 'http://lolsoap.api/v1'
-        end
-      end
-
-      describe '#namespaces' do
-        it 'returns a namespaces hash' do
-          subject.namespaces.must_equal({ 'bla' => namespace })
-        end
-      end
-
-      describe '#prefixes' do
-        it 'returns the prefixes-to-namespace mapping' do
-          subject.prefixes.must_equal({ namespace => 'bla' })
-        end
-      end
-
-      describe 'with types' do
-        before do
-          parser.types = {
-            'Brush' => {
+          },
+          :types => {
+            'bla:Brush' => {
               :elements => {
                 'handleColor' => {
-                  :name     => 'handleColor',
                   :type     => 'bla:Color',
                   :singular => true
                 },
                 'age' => {
-                  :name     => 'age',
                   :type     => 'xs:int',
                   :singular => false
                 }
               },
-              :namespace => namespace
+              :attributes => ['id'],
+              :prefix => 'bla'
             },
-            'Color' => {
+            'bla:Color' => {
               :elements => {
                 'name' => {
-                  :name     => 'name',
                   :type     => 'xs:string',
                   :singular => true
                 },
                 'hex' => {
-                  :name     => 'hex',
                   :type     => 'xs:string',
                   :singular => true
                 }
               },
-              :namespace => namespace
+              :attributes => [],
+              :prefix => 'bla'
             }
           }
+        )
+      end
+
+      subject { WSDL.new(parser) }
+
+      describe '#operations' do
+        it 'returns a hash of operations' do
+          subject.operations.length.must_equal 1
+          subject.operations['washHands'].tap do |op|
+            op.wsdl.must_equal   subject
+            op.action.must_equal "urn:washHands"
+            op.input.must_equal  subject.types['bla:Brush']
+            op.output.must_equal subject.types['bla:Color']
+          end
         end
+      end
 
-        describe '#types' do
-          it 'returns a hash of types' do
-            subject.types.length.must_equal 2
+      describe '#operation' do
+        it 'returns a single operation' do
+          subject.operation('washHands').must_equal subject.operations['washHands']
+        end
+      end
 
-            subject.types['Brush'].tap do |t|
-              t.namespace.must_equal namespace
-              t.elements.length.must_equal 2
-              t.element('handleColor').type.must_equal subject.types['Color']
-              t.element('handleColor').singular?.must_equal true
-              t.element('age').type.must_equal WSDL::NullType.new
-              t.element('age').singular?.must_equal false
-            end
+      describe '#endpoint' do
+        it 'returns the endpoint' do
+          parser.endpoint = 'http://lolsoap.api/v1'
+          subject.endpoint.must_equal 'http://lolsoap.api/v1'
+        end
+      end
 
-            subject.types['Color'].tap do |t|
-              t.namespace.must_equal namespace
-              t.elements.length.must_equal 2
-              t.element('name').type.must_equal WSDL::NullType.new
-              t.element('hex').type.must_equal WSDL::NullType.new
-            end
-          end
+      describe '#namespaces' do
+        it 'returns a namespaces hash' do
+          subject.namespaces.must_equal({ 'bla' => namespace })
         end
+      end
 
-        describe '#type' do
-          it 'returns a single type' do
-            subject.type('Color').must_equal subject.types['Color']
+      describe '#types' do
+        it 'returns a hash of types' do
+          subject.types.length.must_equal 2
+
+          subject.types['bla:Brush'].tap do |t|
+            t.elements.length.must_equal 2
+            t.element('handleColor').type.must_equal subject.types['bla:Color']
+            t.element('handleColor').singular?.must_equal true
+            t.element('age').type.must_equal WSDL::NullType.new
+            t.element('age').singular?.must_equal false
+            t.attributes.must_equal ['id']
           end
 
-          it 'returns a null object if a type is missing' do
-            subject.type('FooBar').must_equal WSDL::NullType.new
+          subject.types['bla:Color'].tap do |t|
+            t.elements.length.must_equal 2
+            t.element('name').type.must_equal WSDL::NullType.new
+            t.element('hex').type.must_equal WSDL::NullType.new
           end
         end
+      end
 
-        describe '#type_namespaces' do
-          it 'returns only the namespaces that used by types' do
-            parser.namespaces['foo'] = 'bar'
-            subject.type_namespaces.must_equal 'bla' => namespace
-          end
+      describe '#type' do
+        it 'returns a single type' do
+          subject.type('bla:Color').must_equal subject.types['bla:Color']
+        end
+
+        it 'returns a null object if a type is missing' do
+          subject.type('FooBar').must_equal WSDL::NullType.new
+        end
+      end
+
+      describe '#type_namespaces' do
+        it 'returns only the namespaces that are used by types' do
+          parser.namespaces['foo'] = 'bar'
+          subject.type_namespaces.must_equal 'bla' => namespace
         end
       end
     end

data/test/unit/test_wsdl_parser.rb

@@ -3,7 +3,12 @@ require 'lolsoap/wsdl_parser'
 
 module LolSoap
   describe WSDLParser do
-    let(:doc) { Nokogiri::XML(File.read(TEST_ROOT + '/fixtures/stock_quote.wsdl')) }
+    def raw_doc
+      File.read(TEST_ROOT + '/fixtures/stock_quote.wsdl')
+    end
+
+    let(:doc) { Nokogiri::XML(raw_doc) }
+
     subject { WSDLParser.new(doc) }
 
     describe '#namespaces' do
@@ -12,7 +17,9 @@ module LolSoap
           'tns'  => 'http://example.com/stockquote.wsdl',
           'xsd1' => 'http://example.com/stockquote.xsd',
           'xsd2' => 'http://example.com/stockquote2.xsd',
-          'soap' => 'http://schemas.xmlsoap.org/wsdl/soap12/'
+          'xsd3' => 'http://example.com/stockquote.xsd',
+          'soap' => 'http://schemas.xmlsoap.org/wsdl/soap12/',
+          'xs'   => 'http://www.w3.org/2001/XMLSchema'
         })
       end
     end
@@ -26,43 +33,42 @@ module LolSoap
     describe '#types' do
       it 'returns the types, with attributes and namespace' do
         subject.types.must_equal({
-          'TradePriceRequest' => {
-            :name      => 'TradePriceRequest',
-            :namespace => 'http://example.com/stockquote.xsd',
-            :elements  => {
+          'xsd1:TradePriceRequest' => {
+            :prefix   => 'xsd1',
+            :name     => 'TradePriceRequest',
+            :elements => {
               'tickerSymbol' => {
-                :name     => 'tickerSymbol',
-                :type     => 'string',
+                :type     => 'xs:string',
                 :singular => false
               },
               'specialTickerSymbol' => {
-                :name     => 'specialTickerSymbol',
                 :type     => 'xsd2:TickerSymbol',
                 :singular => false
               }
-            }
+            },
+            :attributes => ['id']
           },
-          'TradePrice' => {
-            :name      => 'TradePrice',
-            :namespace => 'http://example.com/stockquote.xsd',
-            :elements  => {
+          'xsd1:TradePrice' => {
+            :prefix   => 'xsd1',
+            :name     => 'TradePrice',
+            :elements => {
               'price' => {
-                :name     => 'price',
-                :type     => 'float',
+                :type     => 'xs:float',
                 :singular => true
               }
-            }
+            },
+            :attributes => []
           },
-          'TickerSymbol' => {
-            :name      => 'TickerSymbol',
-            :namespace => 'http://example.com/stockquote2.xsd',
-            :elements  => {
+          'xsd2:TickerSymbol' => {
+            :prefix   => 'xsd2',
+            :name     => 'TickerSymbol',
+            :elements => {
               'name' => {
-                :name     => 'name',
-                :type     => 'string',
+                :type     => 'xs:string',
                 :singular => true
               }
-            }
+            },
+            :attributes => []
           }
         })
       end
@@ -71,8 +77,8 @@ module LolSoap
     describe '#messages' do
       it 'maps message names to types' do
         subject.messages.must_equal({
-          'GetLastTradePriceInput'  => subject.types['TradePriceRequest'],
-          'GetLastTradePriceOutput' => subject.types['TradePrice']
+          'GetLastTradePriceInput'  => 'xsd1:TradePriceRequest',
+          'GetLastTradePriceOutput' => 'xsd1:TradePrice'
         })
       end
     end
@@ -81,9 +87,8 @@ module LolSoap
       it 'is a hash containing input and output types' do
         subject.port_type_operations.must_equal({
           'GetLastTradePrice' => {
-            :name   => 'GetLastTradePrice',
-            :input  => subject.types['TradePriceRequest'],
-            :output => subject.types['TradePrice']
+            :input  => 'xsd1:TradePriceRequest',
+            :output => 'xsd1:TradePrice'
           }
         })
       end
@@ -93,13 +98,22 @@ module LolSoap
       it 'is a hash of operations with their action and input type' do
         subject.operations.must_equal({
           'GetLastTradePrice' => {
-            :name   => 'GetLastTradePrice',
             :action => 'http://example.com/GetLastTradePrice',
-            :input  => subject.types['TradePriceRequest'],
-            :output => subject.types['TradePrice']
+            :input  => 'xsd1:TradePriceRequest',
+            :output => 'xsd1:TradePrice'
           }
         })
       end
     end
+
+    describe 'soap 1.1' do
+      def raw_doc
+        super.sub("http://schemas.xmlsoap.org/wsdl/soap12/", "http://schemas.xmlsoap.org/wsdl/soap/")
+      end
+
+      it 'is supported' do
+        subject.operations.empty?.must_equal false
+      end
+    end
   end
 end

data/test/unit/wsdl/test_type.rb

@@ -3,13 +3,13 @@ require 'lolsoap/wsdl'
 
 class LolSoap::WSDL
   describe Type do
-    let(:wsdl) { OpenStruct.new(:prefixes => { 'http://example.com/foo' => 'foo' }) }
     let(:elements) { { 'soapColor' => OpenStruct.new(:type => Object.new) } }
-    subject { Type.new(wsdl, 'WashHandsRequest', 'http://example.com/foo', elements) }
+
+    subject { Type.new('WashHandsRequest', 'prfx', elements, {}) }
 
     describe '#prefix' do
-      it 'returns the prefix from the WSDL doc' do
-        subject.prefix.must_equal 'foo'
+      it 'returns the prefix' do
+        subject.prefix.must_equal 'prfx'
       end
     end