savon 0.7.9 → 0.8.0.beta.1

data/lib/savon/wsdl/request.rb

@@ -0,0 +1,35 @@
+require "httpi"
+
+module Savon
+  module WSDL
+
+    # = Savon::WSDL::Request
+    #
+    # Executes WSDL requests.
+    class Request
+
+      # Expects an <tt>HTTPI::Request</tt>.
+      def initialize(request)
+        self.request = request
+      end
+
+      # Accessor for the <tt>HTTPI::Request</tt>.
+      attr_accessor :request
+
+      # Executes the request and returns the response.
+      def response
+        @response ||= with_logging { HTTPI.get request }
+      end
+
+    private
+
+      # Logs the HTTP request and yields to a given +block+.
+      def with_logging
+        Savon.log "Retrieving WSDL from: #{request.url}"
+        Savon.log "Using :#{request.auth.type} authentication" if request.auth?
+        yield
+      end
+
+    end
+  end
+end

data/lib/savon/wsse.rb

@@ -1,131 +1,53 @@
+require "base64"
+require "digest/sha1"
+require "builder"
+
+require "savon/core_ext/string"
+require "savon/soap"
+
 module Savon
 
   # = Savon::WSSE
   #
-  # Savon::WSSE represents WSSE authentication. Pass a block to your SOAP call and the WSSE object
-  # is passed to it as the second argument. The object allows setting the WSSE username, password
-  # and whether to use digest authentication.
-  #
-  # == Credentials
-  #
-  # By default, Savon does not use WSSE authentication. Simply specify a username and password to
-  # change this.
-  #
-  #   response = client.get_all_users do |soap, wsse|
-  #     wsse.username = "eve"
-  #     wsse.password = "secret"
-  #   end
-  #
-  # == Digest
-  #
-  # To use WSSE digest authentication, just use the digest method and set it to +true+.
-  #
-  #   response = client.get_all_users do |soap, wsse|
-  #     wsse.username = "eve"
-  #     wsse.password = "secret"
-  #     wsse.digest = true
-  #   end
-  #
-  # == Default to WSSE
-  #
-  # In case all you're services require WSSE authentication, you can set your credentials and whether
-  # to use WSSE digest for every request:
-  #
-  #   Savon::WSSE.username = "eve"
-  #   Savon::WSSE.password = "secret"
-  #   Savon::WSSE.digest = true
+  # Provides WSSE authentication.
   class WSSE
 
-    # Base address for WSSE docs.
-    BaseAddress = "http://docs.oasis-open.org/wss/2004/01"
-
     # Namespace for WS Security Secext.
-    WSENamespace = "#{BaseAddress}/oasis-200401-wss-wssecurity-secext-1.0.xsd"
+    WSENamespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
 
     # Namespace for WS Security Utility.
-    WSUNamespace = "#{BaseAddress}/oasis-200401-wss-wssecurity-utility-1.0.xsd"
+    WSUNamespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
 
     # URI for "wsse:Password/@Type" #PasswordText.
-    PasswordTextURI = "#{BaseAddress}/oasis-200401-wss-username-token-profile-1.0#PasswordText"
+    PasswordTextURI = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText"
 
     # URI for "wsse:Password/@Type" #PasswordDigest.
-    PasswordDigestURI = "#{BaseAddress}/oasis-200401-wss-username-token-profile-1.0#PasswordDigest"
-
-    # Global WSSE username.
-    @@username = nil
-
-    # Returns the global WSSE username.
-    def self.username
-      @@username
-    end
-
-    # Sets the global WSSE username.
-    def self.username=(username)
-      @@username = username.nil? ? nil : username.to_s
-    end
-
-    # Global WSSE password.
-    @@password = nil
-
-    # Returns the global WSSE password.
-    def self.password
-      @@password
-    end
+    PasswordDigestURI = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordDigest"
 
-    # Sets the global WSSE password.
-    def self.password=(password)
-      @@password = password.nil? ? nil : password.to_s
+    # Sets the authentication credentials. Also accepts whether to use WSSE digest.
+    def credentials(username, password, digest = false)
+      self.username = username
+      self.password = password
+      self.digest = digest
     end
 
-    # Global setting of whether to use WSSE digest.
-    @@digest = false
+    attr_accessor :username, :password
 
-    # Returns the global setting of whether to use WSSE digest.
-    def self.digest?
-      @@digest
-    end
-
-    # Global setting of whether to use WSSE digest.
-    def self.digest=(digest)
-      @@digest = digest
-    end
-
-    # Sets the WSSE username per request.
-    def username=(username)
-      @username = username.nil? ? nil : username.to_s
-    end
-
-    # Returns the WSSE username. Defaults to the global setting.
-    def username
-      @username || self.class.username
-    end
-
-    # Sets the WSSE password per request.
-    def password=(password)
-      @password = password.nil? ? nil : password.to_s
-    end
-
-    # Returns the WSSE password. Defaults to the global setting.
-    def password
-      @password || self.class.password
+    # Returns whether to use WSSE digest. Defaults to +false+.
+    def digest?
+      !!@digest
     end
 
-    # Sets whether to use WSSE digest per request.
     attr_writer :digest
 
-    # Returns whether to use WSSE digest. Defaults to the global setting.
-    def digest?
-      @digest || self.class.digest?
-    end
-
-    # Returns the XML for a WSSE header or an empty String unless both username and password
-    # were specified.
-    def header
+    # Returns the XML for a WSSE header or an empty String unless authentication
+    # credentials were specified.
+    def to_xml
       return "" unless username && password
 
       builder = Builder::XmlMarkup.new
       builder.wsse :Security, "xmlns:wsse" => WSENamespace do |xml|
-        xml.wsse :UsernameToken, "xmlns:wsu" => WSUNamespace do
+        xml.wsse :UsernameToken, "wsu:Id" => wsu_id, "xmlns:wsu" => WSUNamespace do
           xml.wsse :Username, username
           xml.wsse :Nonce, nonce
           xml.wsu :Created, timestamp
@@ -151,7 +73,12 @@ module Savon
 
     # Returns a WSSE nonce.
     def nonce
-      @nonce ||= Digest::SHA1.hexdigest String.random + timestamp
+      @nonce ||= Digest::SHA1.hexdigest random_string + timestamp
+    end
+
+    # Returns a random String of 100 characters.
+    def random_string
+      (0...100).map { ("a".."z").to_a[rand(26)] }.join
     end
 
     # Returns a WSSE timestamp.
@@ -159,5 +86,16 @@ module Savon
       @timestamp ||= Time.now.strftime Savon::SOAP::DateTimeFormat
     end
 
+    # Returns the "wsu:Id" attribute.
+    def wsu_id
+      "UsernameToken-#{count}"
+    end
+
+    # Simple counter.
+    def count
+      @count ||= 0
+      @count += 1
+    end
+
   end
 end

data/savon.gemspec

@@ -0,0 +1,26 @@
+lib = File.expand_path("../lib", __FILE__)
+$:.unshift lib unless $:.include? lib
+
+require "savon/version"
+
+Gem::Specification.new do |s|
+  s.name = "savon"
+  s.version = Savon::Version
+  s.authors = "Daniel Harrington"
+  s.email = "me@rubiii.com"
+  s.homepage = "http://github.com/rubiii/#{s.name}"
+  s.summary = "Heavy metal Ruby SOAP client"
+  s.description = "Savon is the heavy metal Ruby SOAP client."
+
+  s.rubyforge_project = s.name
+
+  s.add_dependency "builder", "~> 2.1.2"
+  s.add_dependency "crack", "~> 0.1.8"
+  s.add_dependency "httpi", ">= 0.6.0"
+
+  s.add_development_dependency "rspec", "~> 2.0.0"
+  s.add_development_dependency "mocha", "~> 0.9.7"
+
+  s.files = `git ls-files`.split("\n")
+  s.require_path = "lib"
+end

data/spec/fixtures/response/response_fixture.rb

@@ -1,36 +1,36 @@
 class ResponseFixture
+  class << self
 
-  def self.authentication(value = nil)
-    case value
-      when :to_hash
-        { :success => true,
-          :authentication_value => {
-            :token => "a68d1d6379b62ff339a0e0c69ed4d9cf",
-            :token_hash => "AAAJxA;cIedoT;mY10ExZwG6JuKgp2OYKxow==",
-            :client => "radclient"
-          }
-        }
-      else
-        @@authentication ||= load_fixture :authentication
+    def authentication(value = nil)
+      @authentication ||= load_fixture :authentication
+      
+      case value
+        when :to_hash then Savon::SOAP::XML.to_hash(@authentication)[:authenticate_response][:return]
+        else               @authentication
+      end
     end
-  end
 
-  def self.soap_fault
-    @@soap_fault ||= load_fixture :soap_fault
-  end
+    def soap_fault
+      @soap_fault ||= load_fixture :soap_fault
+    end
 
-  def self.soap_fault12
-    @@soap_fault12 ||= load_fixture :soap_fault12
-  end
+    def soap_fault12
+      @soap_fault12 ||= load_fixture :soap_fault12
+    end
 
-  def self.multi_ref
-    @@multi_ref ||= load_fixture :multi_ref
-  end
+    def multi_ref
+      @multi_ref ||= load_fixture :multi_ref
+    end
 
-private
+    def list
+      @list ||= load_fixture :list
+    end
 
-  def self.load_fixture(fixture)
-    File.read File.dirname(__FILE__) + "/xml/#{fixture}.xml"
-  end
+  private
 
+    def load_fixture(fixture)
+      File.read File.dirname(__FILE__) + "/xml/#{fixture}.xml"
+    end
+
+  end
 end

data/spec/fixtures/response/xml/list.xml

@@ -0,0 +1,18 @@
+<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+   <soapenv:Body>
+      <MultiNamespacedEntryResponse xmlns="http://www.example.com/BusinessRulesEngine/xsd">
+         <history>
+                <ns10:case xmlns:ns10="http://www.example.com/Common/xsd">
+                    <ns10:logTime>2010-09-21T18:22:01.558+10:00</ns10:logTime>
+                    <ns10:logType>Notes Log</ns10:logType>
+                    <ns10:logText>test</ns10:logText>
+                </ns10:case>
+                <ns11:case xmlns:ns11="http://www.example.com/Common/xsd">
+                    <ns11:logTime>2010-09-21T18:22:07.038+10:00</ns11:logTime>
+                    <ns11:logType>Notes Log</ns11:logType>
+                    <ns11:logText>another test</ns11:logText>
+                </ns11:case>
+         </history>
+      </MultiNamespacedEntryResponse>
+   </soapenv:Body>
+</soapenv:Envelope>

data/spec/fixtures/wsdl/wsdl_fixture.rb

@@ -3,6 +3,12 @@ require "erb"
 
 class WSDLFixture
 
+  # Returns a given +fixture+. Defaults to :authentication.
+  def self.load(fixture = nil)
+    fixture ||= :authentication
+    method_missing fixture
+  end
+
   # Returns a WSDL document matching a given +method+ name when called without
   # arguments. Otherwise returns the expected value for a given +method+ name
   # matching a fixture.

data/spec/fixtures/wsdl/wsdl_fixture.yml

@@ -1,12 +1,12 @@
 :authentication:
-  :namespace_uri: "http://v1_0.ws.auth.order.example.com/"
+  :namespace: "http://v1_0.ws.auth.order.example.com/"
   :operations:
     :authenticate:
       :action: "authenticate"
       :input: "authenticate"
 
 :no_namespace:
-  :namespace_uri: "urn:ActionWebService"
+  :namespace: "urn:ActionWebService"
   :operations:
     :get_all_contacts:
       :action: "/api/api/GetAllContacts"
@@ -19,7 +19,7 @@
       :input: "GetUserLoginById"
 
 :namespaced_actions:
-  :namespace_uri: "http://api.example.com/api/"
+  :namespace: "http://api.example.com/api/"
   :operations:
     :get_api_key:
       :input: "GetApiKey"
@@ -32,7 +32,7 @@
       :action: "http://api.example.com/api/User.GetClients"
 
 :geotrust:
-  :namespace_uri: "http://api.geotrust.com/webtrust/query"
+  :namespace: "http://api.geotrust.com/webtrust/query"
   :operations:
     :get_quick_approver_list:
       :action: "GetQuickApproverList"

data/spec/savon/client_spec.rb

@@ -1,86 +1,309 @@
 require "spec_helper"
 
 describe Savon::Client do
-  before { @client = Savon::Client.new EndpointHelper.wsdl_endpoint }
+  let(:client) { Savon::Client.new { wsdl.document = Endpoint.wsdl } }
 
-  it "should be initialized with an endpoint String" do
-    client = Savon::Client.new EndpointHelper.wsdl_endpoint
-    client.request.http.proxy?.should be_false
-  end
+  describe ".new" 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::WSDL::Document) }
+      end
+    end
 
-  it "should accept a proxy URI via an optional Hash of options" do
-    client = Savon::Client.new EndpointHelper.wsdl_endpoint, :proxy => "http://proxy"
-    client.request.http.proxy?.should be_true
-    client.request.http.proxy_address == "http://proxy"
+    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::WSDL::Document)
+          http.should be_an(HTTPI::Request)
+        end
+      end
+    end
+
+    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::WSDL::Document)
+          http.should be_an(HTTPI::Request)
+          wsse.should be_an(Savon::WSSE)
+        end
+      end
+    end
+
+    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::WSDL::Document) }
+      end
+
+      it "should let you access the HTTP object" do
+        Savon::Client.new { http.should be_an(HTTPI::Request) }
+      end
+
+      it "should let you access the WSSE object" do
+        Savon::Client.new { wsse.should be_a(Savon::WSSE) }
+      end
+    end
   end
 
-  it "should accept a SOAP endpoint via an optional Hash of options" do
-    client = Savon::Client.new EndpointHelper.wsdl_endpoint, :soap_endpoint => "http://localhost"
-    client.wsdl.soap_endpoint.should == "http://localhost"
+  describe "#wsdl" do
+    it "should return the Savon::WSDL::Document" do
+      client.wsdl.should be_a(Savon::WSDL::Document)
+    end
   end
 
-  it "should have a method that returns the Savon::WSDL" do
-    @client.wsdl.should be_a(Savon::WSDL)
+  describe "#http" do
+    it "should return the HTTPI::Request" do
+      client.http.should be_an(HTTPI::Request)
+    end
   end
 
-  it "should have a method that returns the Savon::Request" do
-    @client.request.should be_a(Savon::Request)
+  describe "#wsse" do
+    it "should return the Savon::WSSE object" do
+      client.wsse.should be_a(Savon::WSSE)
+    end
   end
 
-  it "should respond to available SOAP actions while behaving as expected otherwise" do
-    WSDLFixture.authentication(:operations).keys.each do |soap_action|
-      @client.respond_to?(soap_action).should be_true
+  describe "#request" do
+    before do
+      HTTPI.stubs(:get).returns(new_response(:body => WSDLFixture.load))
+      HTTPI.stubs(:post).returns(new_response)
     end
 
-    @client.respond_to?(:object_id).should be_true
-    @client.respond_to?(:some_undefined_method).should be_false
-  end
+    context "without any arguments" do
+      it "should raise an ArgumentError" do
+        lambda { client.request }.should raise_error(ArgumentError)
+      end
+    end
 
-  it "should dispatch available SOAP calls via method_missing and return the Savon::Response" do
-    @client.authenticate.should be_a(Savon::Response)
-  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 == [:getUser, {}] }
+      end
 
-  it "should disable the Savon::WSDL when passed a method with an exclamation mark" do
-    @client.wsdl.enabled?.should be_true
-    [:operations, :namespace_uri, :soap_endpoint].each do |method|
-      Savon::WSDL.any_instance.expects(method).never
+      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
+      end
+
+      it "should not set the target namespace if soap.namespace was set to nil" do
+        namespace = "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 }
+      end
     end
 
-    response = @client.authenticate! do |soap|
-      soap.input.should == "authenticate"
-      soap.input.should == "authenticate"
+    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 == [: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 == [:getUser, { :active => true }] }
+      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, {}] }
+      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" do
+        namespace = "http://v1_0.ws.auth.order.example.com/"
+        HTTPI::Request.any_instance.expects(:body=).with { |value| !value.include?(namespace) }
+        
+        client.request(:v1, :get_user) { soap.namespace = nil }
+      end
+    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 }] }
+      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) }
+      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::WSDL::Document)
+        end
+      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::WSDL::Document)
+          http.should be_an(HTTPI::Request)
+        end
+      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::WSDL::Document)
+          http.should be_an(HTTPI::Request)
+          wsse.should be_a(Savon::WSSE)
+        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) }
+      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(Savon::WSSE) }
+      end
+
+      it "should let you access the WSDL object" do
+        client.request(:authenticate) { wsdl.should be_a(Savon::WSDL::Document) }
+      end
     end
-    response.should be_a(Savon::Response)
-    @client.wsdl.enabled?.should be_false
   end
 
-  it "should raise a Savon::SOAPFault in case of a SOAP fault" do
-    client = Savon::Client.new EndpointHelper.wsdl_endpoint(:soap_fault)
-    lambda { client.authenticate! }.should raise_error(Savon::SOAPFault)
+  context "with a remote WSDL document" do
+    let(:client) { Savon::Client.new { wsdl.document = Endpoint.wsdl } }
+    before { HTTPI.expects(:get).returns(new_response(:body => WSDLFixture.load)) }
+
+    it "should return a list of available SOAP actions" do
+      client.wsdl.soap_actions.should == [:authenticate]
+    end
+
+    it "adds a SOAPAction header containing the SOAP action name" do
+      HTTPI.stubs(:post).returns(new_response)
+      
+      client.request :authenticate do
+        http.headers["SOAPAction"].should == %{"authenticate"}
+      end
+    end
+
+    it "should execute SOAP requests and return the response" do
+      HTTPI.expects(:post).returns(new_response)
+      response = client.request(:authenticate)
+      
+      response.should be_a(Savon::SOAP::Response)
+      response.to_xml.should == ResponseFixture.authentication
+    end
   end
 
-  it "should raise a Savon::HTTPError in case of an HTTP error" do
-    client = Savon::Client.new EndpointHelper.wsdl_endpoint(:http_error)
-    lambda { client.authenticate! }.should raise_error(Savon::HTTPError)
+  context "with a local WSDL document" do
+    let(:client) { Savon::Client.new { wsdl.document = "spec/fixtures/wsdl/xml/authentication.xml" } } 
+
+    before { HTTPI.expects(:get).never }
+
+    it "should return a list of available SOAP actions" do
+      client.wsdl.soap_actions.should == [:authenticate]
+    end
+
+    it "adds a SOAPAction header containing the SOAP action name" do
+      HTTPI.stubs(:post).returns(new_response)
+      
+      client.request :authenticate do
+        http.headers["SOAPAction"].should == %{"authenticate"}
+      end
+    end
+
+    it "should execute SOAP requests and return the response" do
+      HTTPI.expects(:post).returns(new_response)
+      response = client.request(:authenticate)
+      
+      response.should be_a(Savon::SOAP::Response)
+      response.to_xml.should == ResponseFixture.authentication
+    end
   end
 
-  it "should yield an instance of Savon::SOAP to a given block expecting one argument" do
-    @client.authenticate { |soap| soap.should be_a(Savon::SOAP) }
+  context "without a WSDL document" do
+    let(:client) do
+      Savon::Client.new do
+        wsdl.endpoint = Endpoint.soap
+        wsdl.namespace = "http://v1_0.ws.auth.order.example.com/"
+      end
+    end
+
+    before { HTTPI.expects(:get).never }
+
+    it "raise an ArgumentError when trying to access the WSDL" do
+      lambda { client.wsdl.soap_actions }.should raise_error(ArgumentError)
+    end
+
+    it "adds a SOAPAction header containing the SOAP action name" do
+      HTTPI.stubs(:post).returns(new_response)
+      
+      client.request :authenticate do
+        http.headers["SOAPAction"].should == %{"authenticate"}
+      end
+    end
+
+    it "should execute SOAP requests and return the response" do
+      HTTPI.expects(:post).returns(new_response)
+      response = client.request(:authenticate)
+      
+      response.should be_a(Savon::SOAP::Response)
+      response.to_xml.should == ResponseFixture.authentication
+    end
   end
 
-  it "should yield an instance of Savon::SOAP and Savon::WSSE to a gven block expecting two arguments" do
-    @client.authenticate do |soap, wsse|
-      soap.should be_a(Savon::SOAP)
-      wsse.should be_a(Savon::WSSE)
+  context "when encountering a SOAP fault" do
+    let(:client) do
+      Savon::Client.new do
+        wsdl.endpoint = Endpoint.soap
+        wsdl.namespace = "http://v1_0.ws.auth.order.example.com/"
+      end
+    end
+
+    before { HTTPI::expects(:post).returns(new_response(:code => 500, :body => ResponseFixture.soap_fault)) }
+
+    it "should raise a Savon::SOAP::Fault" do
+      lambda { client.request :authenticate }.should raise_error(Savon::SOAP::Fault)
     end
   end
 
-  it "should have a call method that forwards to method_missing for SOAP actions named after existing methods" do
-    @client.call(:authenticate) { |soap| soap.should be_a(Savon::SOAP) }
+  context "when encountering an HTTP error" do
+    let(:client) do
+      Savon::Client.new do
+        wsdl.endpoint = Endpoint.soap
+        wsdl.namespace = "http://v1_0.ws.auth.order.example.com/"
+      end
+    end
+
+    before { HTTPI::expects(:post).returns(new_response(:code => 500)) }
+
+    it "should raise a Savon::HTTP::Error" do
+      lambda { client.request :authenticate }.should raise_error(Savon::HTTP::Error)
+    end
   end
 
-  it "should raise a NoMethodError when the method does not match an available SOAP action or method" do
-    lambda { @client.some_undefined_method }.should raise_error(NoMethodError)
+  def new_response(options = {})
+    defaults = { :code => 200, :headers => {}, :body => ResponseFixture.authentication }
+    response = defaults.merge options
+    
+    HTTPI::Response.new response[:code], response[:headers], response[:body]
   end
 
-end
+end