savon 1.1.0 → 1.2.0

data/lib/savon/http/error.rb

@@ -25,7 +25,7 @@ module Savon
       # Returns the HTTP error message.
       def to_s
         return "" unless present?
-        
+
         @message ||= begin
           message = "HTTP error (#{http.code})"
           message << ": #{http.body}" unless http.body.empty?

data/lib/savon/soap/request_builder.rb

@@ -0,0 +1,205 @@
+module Savon
+  module SOAP
+
+    # = Savon::SOAP::RequestBuilder
+    #
+    # Savon::SOAP::RequestBuilder builds Savon::SOAP::Request instances.
+    # The RequestBuilder is configured by the client that instantiates it.
+    # It uses the options set by the client to build an appropriate request.
+    class RequestBuilder
+
+      # Initialize a new +RequestBuilder+ with the given SOAP operation.
+      # The operation may be specified using a symbol or a string.
+      def initialize(operation, options = {})
+        @operation = operation
+        assign_options(options)
+      end
+
+      # Writer for the <tt>HTTPI::Request</tt> object.
+      attr_writer :http
+
+      # Writer for the <tt>Savon::SOAP::XML</tt> object.
+      attr_writer :soap
+
+      # Writer for the <tt>Akami::WSSE</tt> object.
+      attr_writer :wsse
+
+      # Writer for the <tt>Wasabi::Document</tt> object.
+      attr_writer :wsdl
+
+      # Writer for the <tt>Savon::Config</tt> object.
+      attr_writer :config
+
+      # Writer for the attributes of the SOAP input tag. Accepts a Hash.
+      attr_writer :attributes
+
+      # Writer for the namespace identifer of the <tt>Savon::SOAP::XML</tt>
+      # object.
+      attr_writer :namespace_identifier
+
+      # Writer for the SOAP action of the <tt>Savon::SOAP::XML</tt> object.
+      attr_writer :soap_action
+
+      # Reader for the operation of the request being built by the request builder.
+      attr_reader :operation
+
+      # Builds and returns a <tt>Savon::SOAP::Request</tt> object. You may optionally
+      # pass a block to the method that will be run after the initial configuration of
+      # the dependencies. +self+ will be yielded to the block if the block accepts an
+      # argument.
+      def request(&post_configuration_block)
+        configure_dependencies
+
+        if post_configuration_block
+          # Only yield self to the block if our block takes an argument
+          args = [] and (args << self if post_configuration_block.arity == 1)
+          post_configuration_block.call(*args)
+        end
+
+        Request.new(config, http, soap)
+      end
+
+      # Returns the identifier for the default namespace. If an operation namespace
+      # identifier is defined for the current operation in the WSDL document, this
+      # namespace identifier is used. Otherwise, the +@namespace_identifier+ instance
+      # variable is used.
+      def namespace_identifier
+        if operation_namespace_defined_in_wsdl?
+          wsdl.operations[operation][:namespace_identifier].to_sym
+        else
+          @namespace_identifier
+        end
+      end
+
+      # Returns the namespace identifier to be used for the the SOAP input tag.
+      # If +@namespace_identifier+ is not +nil+, it will be returned. Otherwise, the
+      # default namespace identifier as returned by +namespace_identifier+ will be
+      # returned.
+      def input_namespace_identifier
+        @namespace_identifier || namespace_identifier
+      end
+
+      # Returns the default namespace to be used for the SOAP request. If a namespace
+      # is defined for the operation in the WSDL document, this namespace will be
+      # returned. Otherwise, the default WSDL document namespace will be returned.
+      def namespace
+        if operation_namespace_defined_in_wsdl?
+          wsdl.parser.namespaces[namespace_identifier.to_s]
+        else
+          wsdl.namespace
+        end
+      end
+
+      # Returns true if the operation's namespace is defined within the WSDL
+      # document.
+      def operation_namespace_defined_in_wsdl?
+        return false unless wsdl.document?
+        (operation = wsdl.operations[self.operation]) && operation[:namespace_identifier]
+      end
+
+      # Returns the SOAP action. If +@soap_action+ has been defined, this will
+      # be returned. Otherwise, if there is a WSDL document defined, the SOAP
+      # action corresponding to the operation will be returned. Failing this,
+      # the operation name will be used to form the SOAP action.
+      def soap_action
+        return @soap_action if @soap_action
+
+        if wsdl.document?
+          wsdl.soap_action(operation.to_sym)
+        else
+          Gyoku::XMLKey.create(operation).to_sym
+        end
+      end
+
+      # Returns the SOAP operation input tag. If there is a WSDL document defined,
+      # and the operation's input tag is defined in the document, this will be
+      # returned. Otherwise, the operation name will be used to form the input tag.
+      def soap_input_tag
+        if wsdl.document? && (input = wsdl.soap_input(operation.to_sym))
+          input
+        else
+          Gyoku::XMLKey.create(operation)
+        end
+      end
+
+      # Changes the body of the SOAP request to +body+.
+      def body=(body)
+        soap.body = body
+      end
+
+      # Returns the body of the SOAP request.
+      def body
+        soap.body
+      end
+
+      # Returns the attributes of the SOAP input tag. Defaults to
+      # an empty Hash.
+      def attributes
+        @attributes ||= {}
+      end
+
+      # Returns the <tt>Savon::Config</tt> object for the request. Defaults
+      # to a clone of <tt>Savon.config</tt>.
+      def config
+        @config ||= Savon.config.clone
+      end
+
+      # Returns the <tt>HTTPI::Request</tt> object.
+      def http
+        @http ||= HTTPI::Request.new
+      end
+
+      # Returns the <tt>SOAP::XML</tt> object.
+      def soap
+        @soap ||= XML.new(config)
+      end
+
+      # Returns the <tt>Wasabi::Document</tt> object.
+      def wsdl
+        @wsdl ||= Wasabi::Document.new
+      end
+
+      # Returns the <tt>Akami::WSSE</tt> object.
+      def wsse
+        @wsse ||= Akami.wsse
+      end
+
+      private
+
+      def configure_dependencies
+        soap.endpoint = wsdl.endpoint
+        soap.element_form_default = wsdl.element_form_default
+        soap.wsse = wsse
+
+        soap.namespace = namespace
+        soap.namespace_identifier = namespace_identifier
+
+        add_wsdl_namespaces_to_soap
+        add_wsdl_types_to_soap
+
+        soap.input = [input_namespace_identifier, soap_input_tag.to_sym, attributes]
+
+        http.headers["SOAPAction"] = %{"#{soap_action}"}
+      end
+
+      def add_wsdl_namespaces_to_soap
+        wsdl.type_namespaces.each do |path, uri|
+          soap.use_namespace(path, uri)
+        end
+      end
+
+      def add_wsdl_types_to_soap
+        wsdl.type_definitions.each do |path, type|
+          soap.types[path] = type
+        end
+      end
+
+      def assign_options(options)
+        options.each do |option, value|
+          send(:"#{option}=", value) if value
+        end
+      end
+
+    end
+  end
+end

data/lib/savon/soap/xml.rb

@@ -220,7 +220,7 @@ module Savon
 
       def add_namespaces_to_body(hash, path = [input[1].to_s])
         return unless hash
-        return hash if hash.kind_of?(Array)
+        return hash.map { |value| add_namespaces_to_body(value, path) } if hash.kind_of?(Array)
         return hash.to_s unless hash.kind_of? Hash
 
         hash.inject({}) do |newhash, (key, value)|

data/lib/savon/version.rb

@@ -1,5 +1,5 @@
 module Savon
 
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 
 end

data/spec/fixtures/wsdl/multiple_namespaces.xml

@@ -19,8 +19,20 @@
                     </s:sequence>
                 </s:complexType>
             </s:element>
+            <s:element name="Lookup">
+              <s:complexType>
+                <s:sequence>
+                  <s:element minOccurs="0" maxOccurs="1" name="articles" type="article:ArrayOfArticle" />
+                </s:sequence>
+              </s:complexType>
+            </s:element>
         </s:schema>
         <s:schema elementFormDefault="qualified" targetNamespace="http://example.com/article">
+            <s:complexType name="ArrayOfArticle">
+              <s:sequence>
+                <s:element minOccurs="0" maxOccurs="unbounded" name="Article" type="article:Article"/>
+              </s:sequence>
+            </s:complexType>
             <s:complexType name="Article">
                 <s:sequence>
                     <s:element minOccurs="0" name="Author" type="s:string"/>
@@ -35,11 +47,21 @@
     <message name="SaveSoapOut">
         <part name="parameters" element="actions:SaveResponse"/>
     </message>
+    <message name="LookupSoapIn">
+        <part name="parameters" element="actions:Lookup"/>
+    </message>
+    <message name="LookupSoapOut">
+        <part name="parameters" element="actions:LookupResponse"/>
+    </message>
     <portType name="ArticleSoap">
         <operation name="Save">
             <input message="actions:SaveSoapIn"/>
             <output message="actions:SaveSoapOut"/>
         </operation>
+        <operation name="Lookup">
+            <input message="actions:LookupSoapIn"/>
+            <input message="actions:LookupSoapOut"/>
+        </operation>
     </portType>
     <binding name="ArticleSoap" type="actions:ArticleSoap">
         <soap:binding transport="http://schemas.xmlsoap.org/soap/http" style="document"/>
@@ -52,6 +74,15 @@
                 <soap:body use="literal"/>
             </output>
         </operation>
+        <operation name="Lookup">
+            <soap:operation soapAction="http://example.com/actions.Lookup" style="document"/>
+            <input>
+                <soap:body use="literal"/>
+            </input>
+            <output>
+                <soap:body use="literal"/>
+            </output>
+        </operation>
     </binding>
     <service name="StudyMDL">
         <port name="StudyMDLSoap" binding="actions:StudyMDLSoap">

data/spec/integration/request_spec.rb

@@ -2,21 +2,60 @@ require "spec_helper"
 
 describe "Integration" do
 
-  it "returns the result in a CDATA tag" do
-    client = Savon.client("http://www.webservicex.net/stockquote.asmx?WSDL")
-    response = client.request(:get_quote, :body => { :symbol => "AAPL" })
+  subject(:client) {
+    client = Savon.client(service_endpoint)
+    client.http.open_timeout = 10
+    client.http.read_timeout = 10
+    client
+  }
 
-    cdata = response[:get_quote_response][:get_quote_result]
-    result = Nori.parse(cdata)
-    result[:stock_quotes][:stock][:symbol].should == "AAPL"
+  context "stockquote" do
+    let(:service_endpoint) { "http://www.webservicex.net/stockquote.asmx?WSDL" }
+
+    it "returns the result in a CDATA tag" do
+      response = client.request(:get_quote, :body => { :symbol => "AAPL" })
+
+      cdata = response[:get_quote_response][:get_quote_result]
+      result = Nori.parse(cdata)
+      result[:stock_quotes][:stock][:symbol].should == "AAPL"
+    end
+  end
+
+  context "email" do
+    let(:service_endpoint) { "http://ws.cdyne.com/emailverify/Emailvernotestemail.asmx?wsdl" }
+
+    it "passes Strings as they are" do
+      response = client.request(:verify_email, :body => { :email => "soap@example.com", "LicenseKey" => "?" })
+
+      response_text = response[:verify_email_response][:verify_email_result][:response_text]
+      response_text.should == "Email Domain Not Found"
+    end
   end
 
-  it "passes Strings as they are" do
-    client = Savon.client("http://ws.cdyne.com/emailverify/Emailvernotestemail.asmx?wsdl")
-    response = client.request(:verify_email, :body => { :email => "soap@example.com", "LicenseKey" => "?" })
+  context "zip code" do
+    let(:service_endpoint) { "http://www.thomas-bayer.com/axis2/services/BLZService?wsdl" }
+
+    it "supports threads making requests simultaneously" do
+      mutex = Mutex.new
+
+      request_data = [70070010, 24050110, 20050550]
+      threads_waiting = request_data.size
+
+      threads = request_data.map do |blz|
+        Thread.new do
+          response = client.request :get_bank, :body => { :blz => blz }
+          Thread.current[:value] = response[:get_bank_response][:details]
+          mutex.synchronize { threads_waiting -= 1 }
+        end
+      end
+
+      sleep(1) until threads_waiting == 0
+
+      threads.each &:kill
+      values = threads.map { |thr| thr[:value] }.compact
 
-    response_text = response[:verify_email_response][:verify_email_result][:response_text]
-    response_text.should == "Email Domain Not Found"
+      values.uniq.size.should == values.size
+    end
   end
 
 end

data/spec/savon/client_spec.rb

@@ -14,14 +14,14 @@ describe Savon::Client do
 
     context "with a block expecting one argument" do
       it "should yield the WSDL object" do
-        Savon::Client.new { |wsdl| wsdl.should be_a(Savon::Wasabi::Document) }
+        Savon::Client.new { |wsdl| wsdl.should be_a(Wasabi::Document) }
       end
     end
 
     context "with a block expecting two arguments" do
       it "should yield the WSDL and HTTP objects" do
         Savon::Client.new do |wsdl, http|
-          wsdl.should be_an(Savon::Wasabi::Document)
+          wsdl.should be_an(Wasabi::Document)
           http.should be_an(HTTPI::Request)
         end
       end
@@ -30,7 +30,7 @@ describe Savon::Client do
     context "with a block expecting three arguments" do
       it "should yield the WSDL, HTTP and WSSE objects" do
         Savon::Client.new do |wsdl, http, wsse|
-          wsdl.should be_an(Savon::Wasabi::Document)
+          wsdl.should be_an(Wasabi::Document)
           http.should be_an(HTTPI::Request)
           wsse.should be_an(Akami::WSSE)
         end
@@ -39,7 +39,7 @@ describe Savon::Client do
 
     context "with a block expecting no arguments" do
       it "should let you access the WSDL object" do
-        Savon::Client.new { wsdl.should be_a(Savon::Wasabi::Document) }
+        Savon::Client.new { wsdl.should be_a(Wasabi::Document) }
       end
 
       it "should let you access the HTTP object" do
@@ -54,7 +54,7 @@ describe Savon::Client do
 
   describe "#wsdl" do
     it "should return the Savon::Wasabi::Document" do
-      client.wsdl.should be_a(Savon::Wasabi::Document)
+      client.wsdl.should be_a(Wasabi::Document)
     end
   end
 
@@ -71,9 +71,16 @@ describe Savon::Client do
   end
 
   describe "#request" do
+    let(:request_builder) { stub_everything('request_builder') }
+    let(:response) { mock('response') }
+
     before do
       HTTPI.stubs(:get).returns(new_response(:body => Fixture.wsdl(:authentication)))
       HTTPI.stubs(:post).returns(new_response)
+
+      Savon::SOAP::RequestBuilder.stubs(:new).returns(request_builder)
+      request_builder.stubs(:request).returns(stub(:response => response))
+      response.stubs(:http).returns(new_response)
     end
 
     context "without any arguments" do
@@ -82,73 +89,61 @@ describe Savon::Client do
       end
     end
 
-    context "with a single argument (Symbol)" do
-      it "should set the input tag to result in <getUser>" do
-        client.request(:get_user) { soap.input.should == [nil, :getUser, {}] }
+    describe "setting dependencies of the request builder" do
+      it "sets the wsdl property with the client's WSDL document" do
+        request_builder.expects(:wsdl=).with(client.wsdl)
+        client.request(:get_user)
       end
 
-      it "should set the target namespace with the default identifier" do
-        namespace = 'xmlns:wsdl="http://v1_0.ws.auth.order.example.com/"'
-        HTTPI::Request.any_instance.expects(:body=).with { |value| value.include? namespace }
-
-        client.request :get_user
+      it "sets the http property with an HTTPI::Request object" do
+        request_builder.expects(:http=).with { |http| http.is_a?(HTTPI::Request) }
+        client.request(:get_user)
       end
 
-      it "should not set the target namespace if soap.namespace was set to nil" do
-        namespace = 'wsdl="http://v1_0.ws.auth.order.example.com/"'
-        HTTPI::Request.any_instance.expects(:body=).with { |value| !value.include?(namespace) }
-
-        client.request(:get_user) { soap.namespace = nil }
+      it "sets the wsse property with an Akami:WSSE object" do
+        request_builder.expects(:wsse=).with { |wsse| wsse.is_a?(Akami::WSSE) }
+        client.request(:get_user)
       end
 
-      context "when the wsdl's operation namespace identifier matches a document identifier" do
-        before do
-          client.wsdl.operations[:authenticate][:namespace_identifier] = "tns"
-        end
-
-        it "sets the soap's namespace identifier to the matching operation's namespace identifier" do
-          client.request(:authenticate) { soap.namespace_identifier.should == :tns }
-        end
-
-        it "sets the soap's namespace to the namspace matching the identifier" do
-          client.request(:authenticate) { soap.namespace.should == "http://v1_0.ws.auth.order.example.com/" }
-        end
-
-        it "sets the input tag to result in <tns:authenticate>" do
-          client.request(:authenticate) { soap.input.should == [:tns, :authenticate, {}] }
-        end
+      it "sets the config property with a Savon::Config object" do
+        request_builder.expects(:config=).with { |config| config.is_a?(Savon::Config) }
+        client.request(:get_user)
       end
     end
 
-    context "with a single argument (String)" do
-      it "should set the input tag to result in <get_user>" do
-        client.request("get_user") { soap.input.should == [nil, :get_user, {}] }
+    context "with a single argument" do
+      it "sets the operation of the request builder to the argument" do
+        expect_request_builder_to_receive(:get_user)
+        client.request(:get_user)
       end
     end
 
     context "with a Symbol and a Hash" do
-      it "should set the input tag to result in <getUser active='true'>" do
-        client.request(:get_user, :active => true) { soap.input.should == [nil, :getUser, { :active => true }] }
+      it "uses the hash to set attributes of the request builder" do
+        expect_request_builder_to_receive(:get_user, :attributes => { :active => true })
+        client.request(:get_user, :active => true)
       end
 
-      it "should use the :soap_action key to set the SOAPAction header" do
-        client.request(:get_user, :soap_action => :test_action) { http.headers["SOAPAction"].should == %{"testAction"} }
+      it "uses the :soap_action key of the hash to set the SOAP action of the request builder" do
+        expect_request_builder_to_receive(:get_user, :soap_action => :test_action)
+        client.request(:get_user, :soap_action => :test_action)
+      end
+
+      it "uses the :body key of the hash to set the SOAP body of the request builder" do
+        expect_request_builder_to_receive(:get_user, :body => { :foo => "bar" })
+        client.request(:get_user, :body => { :foo => "bar" })
       end
     end
 
     context "with two Symbols" do
-      it "should set the input tag to result in <wsdl:getUser>" do
-        client.request(:v1, :get_user) { soap.input.should == [:v1, :getUser, {}] }
+      it "uses the first symbol to set the namespace and the second symbol to set the operation of the request builder" do
+        expect_request_builder_to_receive(:get_user, :namespace_identifier => :v1)
+        client.request(:v1, :get_user)
       end
 
-      it "should set the target namespace with the given identifier" do
-        namespace = 'xmlns:v1="http://v1_0.ws.auth.order.example.com/"'
-        HTTPI::Request.any_instance.expects(:body=).with { |value| value.include? namespace }
-
-        client.request :v1, :get_user
-      end
+      it "should not set the target namespace if soap.namespace was set to nil in the post-configuration block" do
+        Savon::SOAP::RequestBuilder.unstub(:new)
 
-      it "should not set the target namespace if soap.namespace was set to nil" do
         namespace = 'xmlns:v1="http://v1_0.ws.auth.order.example.com/"'
         HTTPI::Request.any_instance.expects(:body=).with { |value| !value.include?(namespace) }
 
@@ -157,66 +152,118 @@ describe Savon::Client do
     end
 
     context "with two Symbols and a Hash" do
-      it "should set the input tag to result in <wsdl:getUser active='true'>" do
-        client.request(:wsdl, :get_user, :active => true) { soap.input.should == [:wsdl, :getUser, { :active => true }] }
+      it "uses the first symbol to set the namespace and the second symbol to set the operation of the request builder" do
+        expect_request_builder_to_receive(:get_user, :namespace_identifier => :wsdl)
+        client.request(:wsdl, :get_user)
       end
 
-      it "should use the :soap_action key to set the SOAPAction header" do
-        client.request(:wsdl, :get_user, :soap_action => :test_action) { http.headers["SOAPAction"].should == %{"testAction"} }
+      it "should use the hash to set the attributes of the request builder" do
+        expect_request_builder_to_receive(:get_user, :namespace_identifier => :wsdl, :attributes => { :active => true })
+        client.request(:wsdl, :get_user, :active => true)
       end
-    end
 
-    context "with a block expecting one argument" do
-      it "should yield the SOAP object" do
-        client.request(:authenticate) { |soap| soap.should be_a(Savon::SOAP::XML) }
+      it "should use the :soap_action key of the hash to set the SOAP action of the request builder" do
+        expect_request_builder_to_receive(:get_user, :namespace_identifier => :wsdl, :soap_action => :test_action)
+        client.request(:wsdl, :get_user, :soap_action => :test_action)
+      end
+
+      it "should use the :body key of the hash to set the SOAP body of the request builder" do
+        expect_request_builder_to_receive(:get_user, :namespace_identifier => :wsdl, :body => { :foo => "bar" })
+        client.request(:wsdl, :get_user, :body => { :foo => "bar" })
       end
     end
 
-    context "with a block expecting two arguments" do
-      it "should yield the SOAP and WSDL objects" do
-        client.request(:authenticate) do |soap, wsdl|
-          soap.should be_a(Savon::SOAP::XML)
-          wsdl.should be_an(Savon::Wasabi::Document)
+    context "with a block" do
+      before do
+        Savon::SOAP::RequestBuilder.unstub(:new)
+      end
+
+      it "passes the block to the request builder" do
+        # this is painful. it would be trivial to test in > Ruby 1.9, but this is
+        # the only way I know how in < 1.9.
+        dummy = Object.new
+        dummy.instance_eval do
+          class << self; attr_accessor :request_builder, :block_given; end
+          def request
+            self.block_given = block_given?
+            request_builder.request
+          end
+
+          def method_missing(_, *args)
+          end
         end
+
+        dummy.request_builder = request_builder
+        Savon::SOAP::RequestBuilder.stubs(:new).returns(dummy)
+
+        blk = lambda {}
+        client.request(:authenticate, &blk)
+
+        dummy.block_given.should == true
       end
-    end
 
-    context "with a block expecting three arguments" do
-      it "should yield the SOAP, WSDL and HTTP objects" do
-        client.request(:authenticate) do |soap, wsdl, http|
-          soap.should be_a(Savon::SOAP::XML)
-          wsdl.should be_an(Savon::Wasabi::Document)
-          http.should be_an(HTTPI::Request)
+      it "executes the block in the context of the request builder" do
+        Savon::SOAP::RequestBuilder.class_eval do
+          def who
+            self
+          end
         end
+
+        client.request(:authenticate) { who.should be_a Savon::SOAP::RequestBuilder }
       end
-    end
 
-    context "with a block expecting four arguments" do
-      it "should yield the SOAP, WSDL, HTTP and WSSE objects" do
-        client.request(:authenticate) do |soap, wsdl, http, wsse|
-          soap.should be_a(Savon::SOAP::XML)
-          wsdl.should be_a(Savon::Wasabi::Document)
-          http.should be_an(HTTPI::Request)
-          wsse.should be_a(Akami::WSSE)
+      context "with a block expecting one argument" do
+        it "should yield the SOAP object" do
+          client.request(:authenticate) { |soap| soap.should be_a Savon::SOAP::XML }
         end
       end
-    end
 
-    context "with a block expecting no arguments" do
-      it "should let you access the SOAP object" do
-        client.request(:authenticate) { soap.should be_a(Savon::SOAP::XML) }
+      context "with a block expecting two arguments" do
+        it "should yield the SOAP and WSDL objects" do
+          client.request(:authenticate) do |soap, wsdl|
+            soap.should be_a(Savon::SOAP::XML)
+            wsdl.should be_an(Wasabi::Document)
+          end
+        end
       end
 
-      it "should let you access the HTTP object" do
-        client.request(:authenticate) { http.should be_an(HTTPI::Request) }
+      context "with a block expecting three arguments" do
+        it "should yield the SOAP, WSDL and HTTP objects" do
+          client.request(:authenticate) do |soap, wsdl, http|
+            soap.should be_a(Savon::SOAP::XML)
+            wsdl.should be_an(Wasabi::Document)
+            http.should be_an(HTTPI::Request)
+          end
+        end
       end
 
-      it "should let you access the WSSE object" do
-        client.request(:authenticate) { wsse.should be_a(Akami::WSSE) }
+      context "with a block expecting four arguments" do
+        it "should yield the SOAP, WSDL, HTTP and WSSE objects" do
+          client.request(:authenticate) do |soap, wsdl, http, wsse|
+            soap.should be_a(Savon::SOAP::XML)
+            wsdl.should be_a(Wasabi::Document)
+            http.should be_an(HTTPI::Request)
+            wsse.should be_a(Akami::WSSE)
+          end
+        end
       end
 
-      it "should let you access the WSDL object" do
-        client.request(:authenticate) { wsdl.should be_a(Savon::Wasabi::Document) }
+      context "with a block expecting no arguments" do
+        it "should let you access the SOAP object" do
+          client.request(:authenticate) { soap.should be_a(Savon::SOAP::XML) }
+        end
+
+        it "should let you access the HTTP object" do
+          client.request(:authenticate) { http.should be_an(HTTPI::Request) }
+        end
+
+        it "should let you access the WSSE object" do
+          client.request(:authenticate) { wsse.should be_a(Akami::WSSE) }
+        end
+
+        it "should let you access the WSDL object" do
+          client.request(:authenticate) { wsdl.should be_a(Wasabi::Document) }
+        end
       end
     end
 
@@ -383,29 +430,55 @@ describe Savon::Client do
   end
 
   context "with an Array of namespaced items" do
-    let(:client) { Savon::Client.new { wsdl.document = "spec/fixtures/wsdl/taxcloud.xml" } }
+    context "with a single namespace" do
+      let(:client) { Savon::Client.new { wsdl.document = "spec/fixtures/wsdl/taxcloud.xml" } }
 
-    before do
-      HTTPI.stubs(:get).returns(new_response(:body => Fixture.wsdl(:taxcloud)))
-      HTTPI.stubs(:post).returns(new_response)
+      before do
+        HTTPI.stubs(:get).returns(new_response(:body => Fixture.wsdl(:taxcloud)))
+        HTTPI.stubs(:post).returns(new_response)
+      end
+
+      it "should namespaces each Array item as expected" do
+        HTTPI::Request.any_instance.expects(:body=).with do |value|
+          xml = Nokogiri::XML(value)
+          !!xml.at_xpath(".//tc:cartItems/tc:CartItem/tc:ItemID", { "tc" => "http://taxcloud.net" })
+        end
+
+        address = { "Address1" => "888 6th Ave", "Address2" => nil, "City" => "New York", "State" => "NY", "Zip5" => "10001", "Zip4" => nil }
+        cart_item = { "Index" => 0, "ItemID" => "SKU-TEST", "TIC" => "00000", "Price" => 50.0, "Qty" => 1 }
+
+        client.request :lookup, :body => {
+          "customerID"  => 123,
+          "cartID"      => 456,
+          "cartItems"   => { "CartItem" => [cart_item] },
+          "origin"      => address,
+          "destination" => address
+        }
+      end
     end
 
-    it "should namespaces each Array item as expected" do
-      HTTPI::Request.any_instance.expects(:body=).with do |value|
-        value.include?("<ins0:cartItems><ins0:CartItem>") && value.include?("<tns:ItemID>SKU-TEST</tns:ItemID>")
+    context "with multiple namespaces" do
+      let(:client) { Savon::Client.new { wsdl.document = "spec/fixtures/wsdl/multiple_namespaces.xml" } }
+
+      before do
+        HTTPI.stubs(:get).returns(new_response(:body => Fixture.wsdl(:multiple_namespaces)))
+        HTTPI.stubs(:post).returns(new_response)
       end
 
-      address = { "Address1" => "888 6th Ave", "Address2" => nil, "City" => "New York", "State" => "NY", "Zip5" => "10001", "Zip4" => nil }
-      cart_item = { "Index" => 0, "ItemID" => "SKU-TEST", "TIC" => "00000", "Price" => 50.0, "Qty" => 1 }
+      it "should namespace each Array item as expected" do
+        HTTPI::Request.any_instance.expects(:body=).with do |value|
+          xml = Nokogiri::XML(value)
+          namespaces = { "actions" => "http://example.com/actions", "article" => "http://example.com/article" }
+          !!xml.at_xpath(".//actions:Lookup/actions:articles/article:Article/article:Author", namespaces)
+        end
 
-      client.request :lookup, :body => {
-        "customerID"  => 123,
-        "cartID"      => 456,
-        "cartItems"   => { "CartItem" => [cart_item] },
-        "origin"      => address,
-        "destination" => address
-      }
+        article = { "Author" => "John Smith", "Title" => "Modern SOAP" }
+        client.request :lookup, :body => {
+          "articles" => { "Article" => [article] }
+        }
+      end
     end
+
   end
 
   context "without a WSDL document" do
@@ -476,4 +549,8 @@ describe Savon::Client do
     HTTPI::Response.new response[:code], response[:headers], response[:body]
   end
 
+  def expect_request_builder_to_receive(operation, options = {})
+    Savon::SOAP::RequestBuilder.expects(:new).with(operation, options).returns(request_builder)
+  end
+
 end