lolsoap 0.1.0

data/test/unit/test_client.rb

@@ -0,0 +1,12 @@
+require 'helper'
+require 'lolsoap/client'
+
+module LolSoap
+  describe Client do
+    it 'can be instantiated with an already-parsed WSDL object' do
+      wsdl = Object.new
+      client = Client.new(wsdl)
+      client.wsdl.must_equal wsdl
+    end
+  end
+end

data/test/unit/test_envelope.rb

@@ -0,0 +1,112 @@
+require 'helper'
+require 'lolsoap/envelope'
+
+module LolSoap
+  describe Envelope do
+    let(:wsdl) { OpenStruct.new(:type_namespaces => { 'foo' => 'http://example.com/foo' }) }
+    let(:operation) do
+      OpenStruct.new(:input => OpenStruct.new(:prefix => 'foo', :name => 'WashHandsRequest'))
+    end
+
+    subject { Envelope.new(wsdl, operation) }
+
+    let(:doc) { subject.doc }
+    let(:header) { doc.at_xpath('/soap:Envelope/soap:Header', doc.namespaces) }
+    let(:input) { doc.at_xpath('/soap:Envelope/soap:Body/foo:WashHandsRequest', doc.namespaces) }
+
+    it 'has a skeleton SOAP envelope structure when first created' do
+      doc.namespaces.must_equal(
+        'xmlns:soap' => Envelope::SOAP_NAMESPACE,
+        'xmlns:foo'  => 'http://example.com/foo'
+      )
+
+      header.wont_equal nil
+      header.children.length.must_equal 0
+
+      input.wont_equal nil
+      input.children.length.must_equal 0
+    end
+
+    describe '#body' do
+      it 'yields and returns a builder object for the body' do
+        builder = Object.new
+
+        builder_klass = MiniTest::Mock.new
+        builder_klass.expect(:new, builder, [input, operation.input])
+
+        block = nil
+        ret = subject.body(builder_klass) { |b| block = b }
+
+        ret.must_equal builder
+        block.must_equal builder
+      end
+
+      it "doesn't require a block" do
+        builder = Object.new
+
+        builder_klass = MiniTest::Mock.new
+        builder_klass.expect(:new, builder, [input, operation.input])
+
+        subject.body(builder_klass).must_equal builder
+      end
+    end
+
+    describe '#header' do
+      it 'yields and returns the xml builder object for the header' do
+        builder = Object.new
+
+        builder_klass = MiniTest::Mock.new
+        builder_klass.expect(:new, builder, [header])
+
+        block = nil
+        ret = subject.header(builder_klass) { |b| block = b }
+
+        ret.must_equal builder
+        block.must_equal builder
+      end
+
+      it "doesn't require a block" do
+        builder = Object.new
+
+        builder_klass = MiniTest::Mock.new
+        builder_klass.expect(:new, builder, [header])
+
+        subject.header(builder_klass).must_equal builder
+      end
+    end
+
+    describe '#endpoint' do
+      it 'delegates to wsdl' do
+        wsdl.endpoint = 'lol'
+        subject.endpoint.must_equal 'lol'
+      end
+    end
+
+    describe '#to_xml' do
+      it 'returns the xml of the doc' do
+        def subject.doc; OpenStruct.new(:to_xml => '<lol>'); end
+        subject.to_xml.must_equal '<lol>'
+      end
+    end
+
+    describe '#action' do
+      it "returns the operation's action" do
+        operation.action = 'lol'
+        subject.action.must_equal 'lol'
+      end
+    end
+
+    describe '#input_type' do
+      it "returns the operation's input" do
+        subject.input_type.must_equal operation.input
+      end
+    end
+
+    describe '#output' do
+      it "returns the operation's output" do
+        operation.output = 'lol'
+        subject.output_type.must_equal 'lol'
+      end
+    end
+  end
+end

data/test/unit/test_fault.rb

@@ -0,0 +1,33 @@
+require 'helper'
+require 'lolsoap/envelope'
+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
+
+    subject { Fault.new(request, node) }
+
+    describe '#code' do
+      it 'returns the code' do
+        subject.code.must_equal 'soap:Sender'
+      end
+    end
+
+    describe '#reason' do
+      it 'returns the reason' do
+        subject.reason.must_match(/^Omg.*crashed!$/)
+      end
+    end
+
+    describe '#detail' do
+      it 'returns the detail' do
+        subject.detail.must_equal '<Foo>Some detail</Foo>'
+      end
+    end
+  end
+end

data/test/unit/test_hash_builder.rb

@@ -0,0 +1,127 @@
+require 'helper'
+require 'lolsoap/wsdl'
+require 'lolsoap/hash_builder'
+require 'nokogiri'
+
+module LolTypes
+  class Type
+    def element(name)
+      elements.fetch(name) { LolSoap::WSDL::NullElement.new }
+    end
+  end
+
+  class Person < Type
+    def elements
+      @elements ||= {
+        'name'    => OpenStruct.new(:type => LolTypes.name,               :singular? => true),
+        'age'     => OpenStruct.new(:type => LolSoap::WSDL::NullType.new, :singular? => true),
+        'friends' => OpenStruct.new(:type => LolTypes.person,             :singular? => false)
+      }
+    end
+  end
+
+  class Name < Type
+    def elements
+      @elements ||= {
+        'firstName' => OpenStruct.new(:type => LolSoap::WSDL::NullType.new, :singular? => true),
+        'lastName'  => OpenStruct.new(:type => LolSoap::WSDL::NullType.new, :singular? => true)
+      }
+    end
+  end
+
+  def self.person; @person ||= Person.new; end
+  def self.name;   @name   ||= Name.new;   end
+end
+
+module LolSoap
+  describe HashBuilder do
+    it 'converts an XML node to a hash using the type' do
+      xml = Nokogiri::XML::Builder.new do
+        person do
+          name do
+            firstName 'Jon'
+            lastName  'Leighton'
+          end
+          age '22'
+        end
+      end
+      node = xml.doc.root
+
+      builder = HashBuilder.new(node, LolTypes.person)
+      builder.output.must_equal({
+        'name' => {
+          'firstName' => 'Jon',
+          'lastName'  => 'Leighton'
+        },
+        'age'  => '22'
+      })
+    end
+
+    it 'converts nodes that have an unknown type' do
+      xml = Nokogiri::XML::Builder.new { person { foo 'bar' } }
+      node = xml.doc.root
+
+      builder = HashBuilder.new(node, LolTypes.person)
+      builder.output.must_equal({ 'foo' => 'bar' })
+    end
+
+    it 'converts fields which can occur multiple times into arrays' do
+      xml = Nokogiri::XML::Builder.new do
+        person do
+          friends { age '20' }
+        end
+      end
+      node = xml.doc.root
+
+      builder = HashBuilder.new(node, LolTypes.person)
+      builder.output.must_equal({
+        'friends' => [
+          { 'age' => '20' }
+        ]
+      })
+
+      xml = Nokogiri::XML::Builder.new do
+        person do
+          friends { age '20' }
+          friends { age '50' }
+          friends { age '30' }
+        end
+      end
+      node = xml.doc.root
+
+      builder = HashBuilder.new(node, LolTypes.person)
+      builder.output.must_equal({
+        'friends' => [
+          { 'age' => '20' },
+          { 'age' => '50' },
+          { 'age' => '30' }
+        ]
+      })
+    end
+
+    it 'converts fields which occur multiple times, even if their element says they shouldnt, into arrays' do
+      xml = Nokogiri::XML::Builder.new do
+        person do
+          age '20'
+          age '30'
+        end
+      end
+      node = xml.doc.root
+
+      builder = HashBuilder.new(node, LolTypes.person)
+      builder.output.must_equal({ 'age' => ['20', '30'] })
+
+      xml = Nokogiri::XML::Builder.new do
+        person do
+          age '20'
+          age '30'
+          age '40'
+        end
+      end
+      node = xml.doc.root
+
+      builder = HashBuilder.new(node, LolTypes.person)
+      builder.output.must_equal({ 'age' => ['20', '30', '40'] })
+    end
+  end
+end

data/test/unit/test_request.rb

@@ -0,0 +1,48 @@
+require 'helper'
+require 'lolsoap/request'
+
+module LolSoap
+  describe Request do
+    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'
+        subject.url.must_equal 'lol'
+      end
+    end
+
+    describe '#headers' do
+      it 'returns the necessary headers' do
+        envelope.to_xml = '<lol>'
+        envelope.action = 'http://example.com/LolOutLoud'
+
+        subject.headers.must_equal({
+          'Content-Type'   => 'application/soap+xml;charset=UTF-8',
+          'Content-Length' => '5',
+          'SOAPAction'     => 'http://example.com/LolOutLoud'
+        })
+      end
+    end
+
+    describe '#content' do
+      it 'returns the envelope as an xml string' do
+        envelope.to_xml = '<lol>'
+        subject.content.must_equal '<lol>'
+      end
+    end
+  end
+end

data/test/unit/test_response.rb

@@ -0,0 +1,39 @@
+require 'helper'
+require 'lolsoap/envelope'
+require 'lolsoap/response'
+
+module LolSoap
+  describe Response do
+    let(:request) { OpenStruct.new(:soap_namespace => Envelope::SOAP_NAMESPACE, :output => Object.new) }
+    let(:doc) { Nokogiri::XML(File.read(TEST_ROOT + '/fixtures/stock_quote_response.xml')) }
+
+    subject { Response.new(request, doc) }
+
+    describe '#body' do
+      it 'returns the first node under the envelope body' do
+        subject.body.must_equal doc.at_xpath('/soap:Envelope/soap:Body/m:GetStockPriceResponse')
+      end
+    end
+
+    describe '#body_hash' do
+      it 'builds a hash from the body node' do
+        builder = OpenStruct.new(:output => Object.new)
+        builder_klass = MiniTest::Mock.new
+        builder_klass.expect(:new, builder, [subject.body, request.output])
+
+        subject.body_hash(builder_klass).must_equal builder.output
+      end
+    end
+
+    describe '#header' do
+      it 'returns the header element' do
+        subject.header.must_equal doc.at_xpath('/soap:Envelope/soap:Header')
+      end
+    end
+
+    it 'should raise a FaultRaised error when initialized, if there is a SOAP fault' do
+      lambda { Response.new(request, Nokogiri::XML(File.read(TEST_ROOT + '/fixtures/stock_quote_fault.xml'))) }.
+        must_raise FaultRaised
+    end
+  end
+end

data/test/unit/test_wsdl.rb

@@ -0,0 +1,143 @@
+require 'helper'
+require 'lolsoap/wsdl'
+
+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 = {
+            'washHands' => {
+              :action => 'urn:washHands',
+              :input  => { :name => 'WashHandsRequest' },
+              :output => { :name => 'WashHandsResponse' }
+            }
+          }
+        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' => {
+              :elements => {
+                'handleColor' => {
+                  :name     => 'handleColor',
+                  :type     => 'bla:Color',
+                  :singular => true
+                },
+                'age' => {
+                  :name     => 'age',
+                  :type     => 'xs:int',
+                  :singular => false
+                }
+              },
+              :namespace => namespace
+            },
+            'Color' => {
+              :elements => {
+                'name' => {
+                  :name     => 'name',
+                  :type     => 'xs:string',
+                  :singular => true
+                },
+                'hex' => {
+                  :name     => 'hex',
+                  :type     => 'xs:string',
+                  :singular => true
+                }
+              },
+              :namespace => namespace
+            }
+          }
+        end
+
+        describe '#types' do
+          it 'returns a hash of types' do
+            subject.types.length.must_equal 2
+
+            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
+
+            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
+        end
+
+        describe '#type' do
+          it 'returns a single type' do
+            subject.type('Color').must_equal subject.types['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 used by types' do
+            parser.namespaces['foo'] = 'bar'
+            subject.type_namespaces.must_equal 'bla' => namespace
+          end
+        end
+      end
+    end
+  end
+end