RubyGems - savon - Versions diffs - 2.2.0 → 2.12.1 - Mend

savon 2.2.0 → 2.12.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (60) hide show

checksums.yaml +7 -0
data/.gitignore +2 -0
data/.travis.yml +20 -9
data/CHANGELOG.md +157 -10
data/CONTRIBUTING.md +1 -1
data/Gemfile +10 -2
data/README.md +38 -13
data/donate.png +0 -0
data/lib/savon/builder.rb +81 -15
data/lib/savon/client.rb +6 -2
data/lib/savon/core_ext/string.rb +0 -1
data/lib/savon/header.rb +68 -17
data/lib/savon/log_message.rb +7 -3
data/lib/savon/message.rb +6 -7
data/lib/savon/mock/expectation.rb +12 -2
data/lib/savon/model.rb +4 -0
data/lib/savon/operation.rb +45 -38
data/lib/savon/options.rb +149 -22
data/lib/savon/qualified_message.rb +31 -25
data/lib/savon/request.rb +24 -4
data/lib/savon/request_logger.rb +48 -0
data/lib/savon/response.rb +35 -18
data/lib/savon/soap_fault.rb +11 -11
data/lib/savon/version.rb +1 -3
data/savon.gemspec +12 -11
data/spec/fixtures/response/empty_soap_fault.xml +13 -0
data/spec/fixtures/response/f5.xml +39 -0
data/spec/fixtures/response/no_body.xml +1 -0
data/spec/fixtures/response/soap_fault_funky.xml +8 -0
data/spec/fixtures/wsdl/brand.xml +624 -0
data/spec/fixtures/wsdl/elements_in_types.xml +43 -0
data/spec/fixtures/wsdl/no_message_tag.xml +1267 -0
data/spec/fixtures/wsdl/vies.xml +176 -0
data/spec/integration/centra_spec.rb +67 -0
data/spec/integration/email_example_spec.rb +1 -1
data/spec/integration/random_quote_spec.rb +23 -0
data/spec/integration/stockquote_example_spec.rb +7 -1
data/spec/integration/support/application.rb +1 -1
data/spec/integration/zipcode_example_spec.rb +1 -1
data/spec/savon/builder_spec.rb +50 -0
data/spec/savon/client_spec.rb +78 -0
data/spec/savon/core_ext/string_spec.rb +9 -9
data/spec/savon/features/message_tag_spec.rb +5 -0
data/spec/savon/http_error_spec.rb +2 -2
data/spec/savon/log_message_spec.rb +18 -1
data/spec/savon/message_spec.rb +70 -0
data/spec/savon/mock_spec.rb +31 -0
data/spec/savon/model_spec.rb +28 -0
data/spec/savon/operation_spec.rb +69 -3
data/spec/savon/options_spec.rb +515 -87
data/spec/savon/qualified_message_spec.rb +101 -0
data/spec/savon/request_logger_spec.rb +37 -0
data/spec/savon/request_spec.rb +85 -10
data/spec/savon/response_spec.rb +118 -27
data/spec/savon/soap_fault_spec.rb +25 -5
data/spec/savon/softlayer_spec.rb +27 -0
data/spec/spec_helper.rb +5 -2
data/spec/support/adapters.rb +48 -0
data/spec/support/integration.rb +1 -1
metadata +76 -93

data/spec/savon/core_ext/string_spec.rb CHANGED

@@ -4,33 +4,33 @@ describe String do
   describe "snakecase" do
     it "lowercases one word CamelCase" do
-      "Merb".snakecase.should == "merb"
+      expect("Merb".snakecase).to eq("merb")
     end
     it "makes one underscore snakecase two word CamelCase" do
-      "MerbCore".snakecase.should == "merb_core"
+      expect("MerbCore".snakecase).to eq("merb_core")
     end
     it "handles CamelCase with more than 2 words" do
-      "SoYouWantContributeToMerbCore".snakecase.should == "so_you_want_contribute_to_merb_core"
+      expect("SoYouWantContributeToMerbCore".snakecase).to eq("so_you_want_contribute_to_merb_core")
     end
     it "handles CamelCase with more than 2 capital letter in a row" do
-      "CNN".snakecase.should == "cnn"
-      "CNNNews".snakecase.should == "cnn_news"
-      "HeadlineCNNNews".snakecase.should == "headline_cnn_news"
+      expect("CNN".snakecase).to eq("cnn")
+      expect("CNNNews".snakecase).to eq("cnn_news")
+      expect("HeadlineCNNNews".snakecase).to eq("headline_cnn_news")
     end
     it "does NOT change one word lowercase" do
-      "merb".snakecase.should == "merb"
+      expect("merb".snakecase).to eq("merb")
     end
     it "leaves snake_case as is" do
-      "merb_core".snakecase.should == "merb_core"
+      expect("merb_core".snakecase).to eq("merb_core")
     end
     it "converts period characters to underscores" do
-      "User.GetEmail".snakecase.should == "user_get_email"
+      expect("User.GetEmail".snakecase).to eq("user_get_email")
     end
   end

data/spec/savon/features/message_tag_spec.rb CHANGED

@@ -27,6 +27,11 @@ describe Savon do
     expect(message_tag).to eq(['http://www.betfair.com/publicapi/v5/BFExchangeService/', 'getBet'])
   end
+  it 'knows the message tag for :vies' do
+    message_tag = message_tag_for(:vies, :check_vat)
+    expect(message_tag).to eq(['urn:ec.europa.eu:taxud:vies:services:checkVat:types', 'checkVat'])
+  end
   it 'knows the message tag for :wasmuth' do
     message_tag = message_tag_for(:wasmuth, :get_st_tables)
     expect(message_tag).to eq(['http://ws.online.msw/', 'getStTables'])

data/spec/savon/http_error_spec.rb CHANGED

@@ -11,11 +11,11 @@ describe Savon::HTTPError do
   describe ".present?" do
     it "returns true if there was an HTTP error" do
       http = new_response(:code => 404, :body => "Not Found")
-      expect(Savon::HTTPError.present? http).to be_true
+      expect(Savon::HTTPError.present? http).to be_truthy
     end
     it "returns false unless there was an HTTP error" do
-      expect(Savon::HTTPError.present? new_response).to be_false
+      expect(Savon::HTTPError.present? new_response).to be_falsey
     end
   end

data/spec/savon/log_message_spec.rb CHANGED

@@ -21,9 +21,26 @@ describe Savon::LogMessage do
     expect(message).to include("\n  <body>")
   end
-  it "filters tags in a given message" do
+  it "filters tags in a given message without pretty printing" do
     message = log_message("<root><password>secret</password></root>", [:password], false).to_s
     expect(message).to include("<password>***FILTERED***</password>")
+    expect(message).to_not include("\n  <password>***FILTERED***</password>") # no pretty printing
+  end
+  it "filters tags in a given message with pretty printing" do
+    message = log_message("<root><password>secret</password></root>", [:password], true).to_s
+    expect(message).to include("\n  <password>***FILTERED***</password>")
+  end
+  it "properly applies Proc filter" do
+    filter = Proc.new do |document|
+      document.xpath('//password').each do |node|
+        node.content = "FILTERED"
+      end
+    end
+    message = log_message("<root><password>secret</password></root>", [filter], false).to_s
+    expect(message).to include("<password>FILTERED</password>")
   end
   def log_message(*args)

data/spec/savon/message_spec.rb ADDED

@@ -0,0 +1,70 @@
+require "spec_helper"
+require "integration/support/server"
+describe Savon::Message do
+  before do
+    @server = IntegrationServer.run
+  end
+  after do
+    @server.stop
+  end
+  let(:client_config) {
+    {
+      :endpoint => @server.url(:repeat),
+      :namespace => 'http://example.com',
+      :log => false,
+      :element_form_default => :qualified,
+      :convert_request_keys_to => :camelcase,
+      :convert_response_tags_to => nil
+    }
+  }
+  let(:client) { Savon.client(client_config) }
+  context "with a qualified message" do
+    let(:message) {
+      {
+       :email_count => 3,
+       :user_name   => 'josh',
+       :order!      => [:user_name, :email_count]
+      }
+    }
+    let(:converted_keys) {
+      '<wsdl:UserName>josh</wsdl:UserName><wsdl:EmailCount>3</wsdl:EmailCount>'
+    }
+    it "converts request Hash keys for which there is not namespace" do
+      response = client.call(:something, :message => message)
+      expect(response.xml).to include(converted_keys)
+    end
+  end
+  context 'use_wsa_headers' do
+    let(:client_config) { super().merge(use_wsa_headers: true) }
+    context 'headers' do
+      [ 'wsa:Action', 'wsa:To', 'wsa:MessageID' ].each do |header|
+        it "should include #{header} header" do
+          response = client.call(:something, message: {})
+          expect(response.xml).to include(header)
+        end
+      end
+    end
+    context 'wsa:MessageID' do
+      let(:message_id_tag) {
+        '<wsa:MessageID xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/08/addressing">'
+      }
+      it 'should include xmlns:wsa attribute' do
+        response = client.call(:something, message: {})
+        expect(response.xml).to include(message_id_tag)
+      end
+    end
+  end
+end

data/spec/savon/mock_spec.rb CHANGED

@@ -23,6 +23,17 @@ describe "Savon's mock interface" do
     expect(response.http.body).to eq("<fixture/>")
   end
+  it "can verify a request with any parameters and return a fixture response" do
+    message = { :username => "luke", :password => :any }
+    savon.expects(:authenticate).with(:message => message).returns("<fixture/>")
+    response = new_client.call(:authenticate) do
+      message(:username => "luke", :password => "secret")
+    end
+    expect(response.http.body).to eq("<fixture/>")
+  end
   it "accepts a Hash to specify the response code, headers and body" do
     soap_fault = Fixture.response(:soap_fault)
     response = { :code => 500, :headers => { "X-Result" => "invalid" }, :body => soap_fault }
@@ -114,6 +125,26 @@ describe "Savon's mock interface" do
                                               "  with this message: #{message.inspect}")
   end
+  it "does not fail when any message is expected and an actual message" do
+    savon.expects(:find_user).with(:message => :any).returns("<fixture/>")
+    message = { :username => "luke" }
+    expect { new_client.call(:find_user, :message => message) }.to_not raise_error
+  end
+  it "does not fail when any message is expected and no actual message" do
+    savon.expects(:find_user).with(:message => :any).returns("<fixture/>")
+    expect { new_client.call(:find_user) }.to_not raise_error
+  end
+  it "matchers can be used to specify the message" do
+    savon.expects(:find_user).with(:message => include(:username)).returns("<fixture/>")
+    message = { :username => "Han Solo", password: "querty"}
+    expect { new_client.call(:find_user, :message => message) }.to_not raise_error
+  end
   it "allows code to rescue Savon::Error and still report test failures" do
     message = { :username => "luke" }
     savon.expects(:find_user).with(:message => message).returns("<fixture/>")

data/spec/savon/model_spec.rb CHANGED

@@ -151,4 +151,32 @@ describe Savon::Model do
     supermodel.authenticate(:message => { :username => "luke", :password => "secret" })
   end
+  describe ".all_operations" do
+    it "should call operations with all available client operations" do
+      model = Class.new {
+        extend Savon::Model
+        client :wsdl => Fixture.wsdl(:taxcloud)
+        all_operations
+      }
+      [:verify_address,
+      :lookup_for_date,
+      :lookup,
+      :authorized,
+      :authorized_with_capture,
+      :captured,
+      :returned,
+      :get_tic_groups,
+      :get_ti_cs,
+      :get_ti_cs_by_group,
+      :add_exempt_certificate,
+      :delete_exempt_certificate,
+      :get_exempt_certificates].each do |method|
+        expect(model).to respond_to(method)
+      end
+    end
+  end
 end

data/spec/savon/operation_spec.rb CHANGED

@@ -44,6 +44,16 @@ describe Savon::Operation do
       expect { new_operation(:no_such_operation, wsdl, globals) }.
         to raise_error(Savon::UnknownOperationError, /Unable to find SOAP operation: :no_such_operation/)
     end
+    it "raises if the endpoint cannot be reached" do
+      message = "Error!"
+      response = HTTPI::Response.new(500, {}, message)
+      error = Wasabi::Resolver::HTTPError.new(message, response)
+      Wasabi::Document.any_instance.stubs(:soap_actions).raises(error)
+      expect { new_operation(:verify_address, wsdl, globals) }.
+        to raise_error(Savon::HTTPError, /#{message}/)
+    end
   end
   describe ".create without a WSDL" do
@@ -77,7 +87,7 @@ describe Savon::Operation do
       # stub the actual request
       http_response = HTTPI::Response.new(200, {}, "")
-      operation.expects(:call!).returns(http_response)
+      operation.expects(:call_with_logging).returns(http_response)
       operation.call
     end
@@ -90,7 +100,7 @@ describe Savon::Operation do
       # stub the actual request
       http_response = HTTPI::Response.new(200, {}, "")
-      operation.expects(:call!).returns(http_response)
+      operation.expects(:call_with_logging).returns(http_response)
       operation.call
     end
@@ -154,11 +164,67 @@ describe Savon::Operation do
       actual_soap_action = inspect_request(response).soap_action
       expect(actual_soap_action).to eq(%("authenticate"))
     end
+    it "returns a Savon::Multipart::Response if available and requested globally" do
+      globals.multipart true
+      with_multipart_mocked do
+        operation = new_operation(:authenticate, no_wsdl, globals)
+        response = operation.call
+        expect(response).to be_a(Savon::Multipart::Response)
+      end
+    end
+    it "returns a Savon::Multipart::Response if available and requested locally" do
+      with_multipart_mocked do
+        operation = new_operation(:authenticate, no_wsdl, globals)
+        response = operation.call(:multipart => true)
+        expect(response).to be_a(Savon::Multipart::Response)
+      end
+    end
+    it "raises if savon-multipart is not available and it was requested globally" do
+      globals.multipart true
+      operation = new_operation(:authenticate, no_wsdl, globals)
+      expect { operation.call }.
+        to raise_error RuntimeError, /Unable to find Savon::Multipart/
+    end
+    it "raises if savon-multipart is not available and it was requested locally" do
+      operation = new_operation(:authenticate, no_wsdl, globals)
+      expect { operation.call(:multipart => true) }.
+        to raise_error RuntimeError, /Unable to find Savon::Multipart/
+    end
+  end
+  describe "#request" do
+    it "returns the request" do
+      operation = new_operation(:verify_address, wsdl, globals)
+      request = operation.request
+      expect(request.body).to include('<tns:VerifyAddress></tns:VerifyAddress>')
+    end
+  end
+  def with_multipart_mocked
+    multipart_response = Class.new { def initialize(*args); end }
+    multipart_mock = Module.new
+    multipart_mock.const_set('Response', multipart_response)
+    Savon.const_set('Multipart', multipart_mock)
+    yield
+  ensure
+    Savon.send(:remove_const, :Multipart) if Savon.const_defined? :Multipart
   end
   def inspect_request(response)
     hash = JSON.parse(response.http.body)
     OpenStruct.new(hash)
   end
 end

data/spec/savon/options_spec.rb CHANGED

@@ -45,6 +45,35 @@ describe "Options" do
     end
   end
+  context "global: :no_message_tag" do
+    it "omits the 'message tag' encapsulation step" do
+      client = new_client(:endpoint => @server.url(:repeat), :no_message_tag => true,
+                          :wsdl => Fixture.wsdl(:no_message_tag))
+      msg = {'extLoginData' => {'Login' => 'test.user', 'Password' => 'secret', 'FacilityID' => 1,
+               'ThreePLKey' => '{XXXX-XXXX-XXXX-XXXX}', 'ThreePLID' => 1},
+             'Items' => ['Item' => {'SKU' => '001002003A', 'CustomerID' => 1,
+              'InventoryMethod' => 'FIFO', 'UPC' => '001002003A'}]}
+      response = client.call(:create_items, :message => msg)
+      expect(response.http.body.scan(/<tns:extLoginData>/).count).to eq(1)
+    end
+    it "includes the 'message tag' encapsulation step" do
+      # This test is probably just exposing a bug while the previous
+      # test is using a workaround fix.
+      # That is just a guess though. I don't really have to properly debug the WSDL parser.
+      client = new_client(:endpoint => @server.url(:repeat), :no_message_tag => false,
+                          :wsdl => Fixture.wsdl(:no_message_tag))
+      msg = {'extLoginData' => {'Login' => 'test.user', 'Password' => 'secret', 'FacilityID' => 1,
+               'ThreePLKey' => '{XXXX-XXXX-XXXX-XXXX}', 'ThreePLID' => 1},
+             'Items' => ['Item' => {'SKU' => '001002003A', 'CustomerID' => 1,
+              'InventoryMethod' => 'FIFO', 'UPC' => '001002003A'}]}
+      response = client.call(:create_items, :message => msg)
+      expect(response.http.body.scan(/<tns:extLoginData>/).count).to eq(2)
+    end
+  end
   context "global :namespaces" do
     it "adds additional namespaces to the SOAP envelope" do
       namespaces = { "xmlns:whatever" => "http://whatever.example.com" }
@@ -55,6 +84,24 @@ describe "Options" do
     end
   end
+  context 'global :follow_redirects' do
+    it 'sets whether or not request should follow redirects' do
+      client = new_client(:endpoint => @server.url, :follow_redirects => true)
+      HTTPI::Request.any_instance.expects(:follow_redirect=).with(true)
+      response = client.call(:authenticate)
+    end
+    it 'defaults to false' do
+      client = new_client(:endpoint => @server.url)
+      HTTPI::Request.any_instance.expects(:follow_redirect=).with(false)
+      response = client.call(:authenticate)
+    end
+  end
   context "global :proxy" do
     it "sets the proxy server to use" do
       proxy_url = "http://example.com"
@@ -67,6 +114,15 @@ describe "Options" do
     end
   end
+  context "global :host" do
+    it "overrides the WSDL endpoint host" do
+      client = new_client(:wsdl => Fixture.wsdl(:no_message_tag), host: "https://example.com:8080")
+      request = client.build_request(:update_orders)
+      expect(request.url.to_s).to eq "https://example.com:8080/webserviceexternal/contracts.asmx"
+    end
+  end
   context "global :headers" do
     it "sets the HTTP headers for the next request" do
       client = new_client(:endpoint => @server.url(:inspect_request), :headers => { "X-Token" => "secret" })
@@ -80,11 +136,14 @@ describe "Options" do
   context "global :open_timeout" do
     it "makes the client timeout after n seconds" do
-      non_routable_ip = "http://10.255.255.1"
+      non_routable_ip = "http://192.0.2.0"
       client = new_client(:endpoint => non_routable_ip, :open_timeout => 0.1)
       expect { client.call(:authenticate) }.to raise_error { |error|
-        if error.kind_of? Errno::EHOSTUNREACH
+        host_unreachable = error.kind_of? Errno::EHOSTUNREACH
+        net_unreachable = error.kind_of? Errno::ENETUNREACH
+        socket_err = error.kind_of? SocketError
+        if host_unreachable || net_unreachable || socket_err
           warn "Warning: looks like your network may be down?!\n" +
                "-> skipping spec at #{__FILE__}:#{__LINE__}"
         else
@@ -125,10 +184,23 @@ describe "Options" do
   context "global :soap_header" do
     it "accepts a Hash of SOAP header information" do
       client = new_client(:endpoint => @server.url(:repeat), :soap_header => { :auth_token => "secret" })
       response = client.call(:authenticate)
       expect(response.http.body).to include("<env:Header><authToken>secret</authToken></env:Header>")
     end
+    it "accepts anything other than a String and calls #to_s on it" do
+      to_s_header = Class.new {
+        def to_s
+          "to_s_header"
+        end
+      }.new
+      client = new_client(:endpoint => @server.url(:repeat), :soap_header => to_s_header)
+      response = client.call(:authenticate)
+      expect(response.http.body).to include("<env:Header>to_s_header</env:Header>")
+    end
   end
   context "global :element_form_default" do
@@ -147,6 +219,17 @@ describe "Options" do
       expect(response.http.body).to include("<user>lea</user>")
       expect(response.http.body).to include("<password>top-secret</password>")
     end
+    it "qualifies elements embedded in complex types" do
+      client = new_client(:endpoint => @server.url(:repeat),
+                          :wsdl => Fixture.wsdl(:elements_in_types))
+      msg = {":TopLevelTransaction"=>{":Qualified"=>"A Value"}}
+      response = client.call(:top_level_transaction, :message => msg)
+      expect(response.http.body.scan(/<tns:Qualified>/).count).to eq(1)
+    end
   end
   context "global :env_namespace" do
@@ -262,6 +345,15 @@ describe "Options" do
       expect(logger).to eq(custom_logger)
     end
+    it "sets the logger of HTTPI as well" do
+      custom_logger = Logger.new($stdout)
+      client = new_client(:logger => custom_logger, :log => true)
+      expect(HTTPI.logger).to be custom_logger
+    end
   end
   context "global :log_level" do
@@ -308,18 +400,27 @@ describe "Options" do
   context "global :ssl_version" do
     it "sets the SSL version to use" do
-      HTTPI::Auth::SSL.any_instance.expects(:ssl_version=).with(:SSLv3).twice
+      HTTPI::Auth::SSL.any_instance.expects(:ssl_version=).with(:TLSv1).twice
-      client = new_client(:endpoint => @server.url, :ssl_version => :SSLv3)
+      client = new_client(:endpoint => @server.url, :ssl_version => :TLSv1)
       client.call(:authenticate)
     end
   end
   context "global :ssl_verify_mode" do
     it "sets the verify mode to use" do
-      HTTPI::Auth::SSL.any_instance.expects(:verify_mode=).with(:none).twice
+      HTTPI::Auth::SSL.any_instance.expects(:verify_mode=).with(:peer).twice
-      client = new_client(:endpoint => @server.url, :ssl_verify_mode => :none)
+      client = new_client(:endpoint => @server.url, :ssl_verify_mode => :peer)
+      client.call(:authenticate)
+    end
+  end
+  context "global :ssl_ciphers" do
+    it "sets the ciphers to use" do
+      HTTPI::Auth::SSL.any_instance.expects(:ciphers=).with(:none).twice
+      client = new_client(:endpoint => @server.url, :ssl_ciphers => :none)
       client.call(:authenticate)
     end
   end
@@ -334,6 +435,17 @@ describe "Options" do
     end
   end
+  context "global :ssl_cert_key" do
+    it "sets the cert key to use" do
+      cert_key = File.open(File.expand_path("../../fixtures/ssl/client_key.pem", __FILE__)).read
+      HTTPI::Auth::SSL.any_instance.expects(:cert_key=).with(cert_key).twice
+      client = new_client(:endpoint => @server.url, :ssl_cert_key => cert_key)
+      client.call(:authenticate)
+    end
+  end
   context "global :ssl_cert_key_password" do
     it "sets the encrypted cert key file password to use" do
       cert_key = File.expand_path("../../fixtures/ssl/client_encrypted_key.pem", __FILE__)
@@ -357,6 +469,16 @@ describe "Options" do
     end
   end
+  context "global :ssl_cert" do
+    it "sets the cert to use" do
+      cert = File.open(File.expand_path("../../fixtures/ssl/client_cert.pem", __FILE__)).read
+      HTTPI::Auth::SSL.any_instance.expects(:cert=).with(cert).twice
+      client = new_client(:endpoint => @server.url, :ssl_cert => cert)
+      client.call(:authenticate)
+    end
+  end
   context "global :ssl_ca_cert_file" do
     it "sets the ca cert file to use" do
       ca_cert = File.expand_path("../../fixtures/ssl/client_cert.pem", __FILE__)
@@ -367,6 +489,37 @@ describe "Options" do
     end
   end
+  context "global :ssl_ca_cert_path" do
+    it "sets the ca cert path to use" do
+      ca_cert_path = "../../fixtures/ssl"
+      HTTPI::Auth::SSL.any_instance.expects(:ca_cert_path=).with(ca_cert_path).twice
+      client = new_client(:endpoint => @server.url, :ssl_ca_cert_path => ca_cert_path)
+      client.call(:authenticate)
+    end
+  end
+  context "global :ssl_ca_cert_store" do
+    it "sets the cert store to use" do
+      cert_store = OpenSSL::X509::Store.new
+      HTTPI::Auth::SSL.any_instance.expects(:cert_store=).with(cert_store).twice
+      client = new_client(:endpoint => @server.url, :ssl_cert_store => cert_store)
+      client.call(:authenticate)
+    end
+  end
+  context "global :ssl_ca_cert" do
+    it "sets the ca cert file to use" do
+      ca_cert = File.open(File.expand_path("../../fixtures/ssl/client_cert.pem", __FILE__)).read
+      HTTPI::Auth::SSL.any_instance.expects(:ca_cert=).with(ca_cert).twice
+      client = new_client(:endpoint => @server.url, :ssl_ca_cert => ca_cert)
+      client.call(:authenticate)
+    end
+  end
   context "global :basic_auth" do
     it "sets the basic auth credentials" do
       client = new_client(:endpoint => @server.url(:basic_auth), :basic_auth => ["admin", "secret"])
@@ -385,133 +538,278 @@ describe "Options" do
     end
   end
+  context "global :ntlm" do
+    it "sets the ntlm credentials to use" do
+      credentials = ["admin", "secret"]
+      client = new_client(:endpoint => @server.url, :ntlm => credentials)
+      # TODO: find a way to integration test this. including an entire ntlm
+      # server implementation seems a bit over the top though.
+      HTTPI::Auth::Config.any_instance.expects(:ntlm).with(*credentials)
+      response = client.call(:authenticate)
+    end
+  end
   context "global :filters" do
     it "filters a list of XML tags from logged SOAP messages" do
-      silence_stdout do
+      captured = mock_stdout do
         client = new_client(:endpoint => @server.url(:repeat), :log => true)
         client.globals[:filters] << :password
-        # filter out logs we're not interested in
-        client.globals[:logger].expects(:info).at_least_once
-        # check whether the password is filtered
-        client.globals[:logger].expects(:debug).with { |message|
-          message.include? "<password>***FILTERED***</password>"
-        }.twice
         message = { :username => "luke", :password => "secret" }
         client.call(:authenticate, :message => message)
       end
+      captured.rewind
+      messages = captured.readlines.join("\n")
+      expect(messages).to include("<password>***FILTERED***</password>")
     end
   end
   context "global :pretty_print_xml" do
     it "is a nice but expensive way to debug XML messages" do
-      silence_stdout do
-        client = new_client(:endpoint => @server.url(:repeat), :pretty_print_xml => true, :log => true)
+      captured = mock_stdout do
+        client = new_client(
+          :endpoint => @server.url(:repeat),
+          :pretty_print_xml => true,
+          :log => true)
+        client.globals[:logger].formatter = proc { |*, msg| "#{msg}\n" }
-        # filter out logs we're not interested in
-        client.globals[:logger].expects(:info).at_least_once
+        client.call(:authenticate)
+      end
-        # check whether the message is pretty printed
-        client.globals[:logger].expects(:debug).with { |message|
-          envelope    = message =~ /\n<env:Envelope/
-          body        = message =~ /\n  <env:Body>/
-          message_tag = message =~ /\n    <tns:authenticate\/>/
+      captured.rewind
+      messages = captured.readlines.join("\n")
-          envelope && body && message_tag
-        }.twice
+      expect(messages).to match(/\n<env:Envelope/)
+      expect(messages).to match(/\n  <env:Body/)
+      expect(messages).to match(/\n    <tns:authenticate/)
+    end
+  end
-        client.call(:authenticate)
+  context ":wsse_auth" do
+    let(:username) { "luke" }
+    let(:password) { "secret" }
+    let(:request) { response.http.body }
+    shared_examples "WSSE basic auth" do
+      it "adds WSSE basic auth information to the request" do
+        # the header and wsse security node
+        wsse_namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
+        expect(request).to include("<env:Header><wsse:Security xmlns:wsse=\"#{wsse_namespace}\">")
+        # split up to prevent problems with unordered Hash attributes in 1.8 [dh, 2012-12-13]
+        expect(request).to include("<wsse:UsernameToken")
+        expect(request).to include("wsu:Id=\"UsernameToken-1\"")
+        expect(request).to include("xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\"")
+        # the username and password node with type attribute
+        expect(request).to include("<wsse:Username>#{username}</wsse:Username>")
+        password_text = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText"
+        expect(request).to include("<wsse:Password Type=\"#{password_text}\">#{password}</wsse:Password>")
       end
     end
-  end
-  context "global :wsse_auth" do
-    it "adds WSSE basic auth information to the request" do
-      client = new_client(:endpoint => @server.url(:repeat), :wsse_auth => ["luke", "secret"])
-      response = client.call(:authenticate)
+    shared_examples "WSSE digest auth" do
+      it "adds WSSE digest auth information to the request" do
+        # the header and wsse security node
+        wsse_namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
+        expect(request).to include("<env:Header><wsse:Security xmlns:wsse=\"#{wsse_namespace}\">")
-      request = response.http.body
+        # split up to prevent problems with unordered Hash attributes in 1.8 [dh, 2012-12-13]
+        expect(request).to include("<wsse:UsernameToken")
+        expect(request).to include("wsu:Id=\"UsernameToken-1\"")
+        expect(request).to include("xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\"")
-      # the header and wsse security node
-      wsse_namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
-      expect(request).to include("<env:Header><wsse:Security xmlns:wsse=\"#{wsse_namespace}\">")
+        # the username node
+        expect(request).to include("<wsse:Username>#{username}</wsse:Username>")
-      # split up to prevent problems with unordered Hash attributes in 1.8 [dh, 2012-12-13]
-      expect(request).to include("<wsse:UsernameToken")
-      expect(request).to include("wsu:Id=\"UsernameToken-1\"")
-      expect(request).to include("xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\"")
+        # the nonce node
+        expect(request).to match(/<wsse:Nonce.*>.+\n?<\/wsse:Nonce>/)
-      # the username and password node with type attribute
-      expect(request).to include("<wsse:Username>luke</wsse:Username>")
-      password_text = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText"
-      expect(request).to include("<wsse:Password Type=\"#{password_text}\">secret</wsse:Password>")
+        # the created node with a timestamp
+        expect(request).to match(/<wsu:Created>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.*<\/wsu:Created>/)
+        # the password node contains the encrypted value
+        password_digest = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordDigest"
+        expect(request).to match(/<wsse:Password Type=\"#{password_digest}\">.+<\/wsse:Password>/)
+        expect(request).to_not include(password)
+      end
     end
-    it "adds WSSE digest auth information to the request" do
-      client = new_client(:endpoint => @server.url(:repeat), :wsse_auth => ["lea", "top-secret", :digest])
-      response = client.call(:authenticate)
+    shared_examples "no WSSE auth" do
+      it "does not add WSSE auth to the request" do
+        expect(request).not_to include("<wsse:UsernameToken")
+      end
+    end
-      request = response.http.body
+    describe "global" do
+      context "enabled" do
+        context "without digest" do
+          let(:client) { new_client(:endpoint => @server.url(:repeat), :wsse_auth => [username, password]) }
+          let(:response) { client.call(:authenticate) }
+          include_examples "WSSE basic auth"
+        end
+        context "with digest" do
+          let(:client) { new_client(:endpoint => @server.url(:repeat), :wsse_auth => [username, password, :digest]) }
+          let(:response) { client.call(:authenticate) }
+          include_examples "WSSE digest auth"
+        end
-      # the header and wsse security node
-      wsse_namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
-      expect(request).to include("<env:Header><wsse:Security xmlns:wsse=\"#{wsse_namespace}\">")
+        context "local override" do
+          let(:client) { new_client(:endpoint => @server.url(:repeat), :wsse_auth => ["luke", "secret"]) }
+          context "enabled" do
+            let(:username) { "lea" }
+            let(:password) { "top-secret" }
+            context "without digest" do
+              let(:response) { client.call(:authenticate) {|locals| locals.wsse_auth(username, password)} }
+              include_examples "WSSE basic auth"
+            end
+            context "with digest" do
+              let(:response) { client.call(:authenticate) {|locals| locals.wsse_auth(username, password, :digest)} }
+              include_examples "WSSE digest auth"
+            end
+          end
+          context "disabled" do
+            let(:response) { client.call(:authenticate) {|locals| locals.wsse_auth(false)} }
+            include_examples "no WSSE auth"
+          end
+          context "set to nil" do
+            let(:response) { client.call(:authenticate) {|locals| locals.wsse_auth(nil)} }
+            include_examples "WSSE basic auth"
+          end
+        end
-      # split up to prevent problems with unordered Hash attributes in 1.8 [dh, 2012-12-13]
-      expect(request).to include("<wsse:UsernameToken")
-      expect(request).to include("wsu:Id=\"UsernameToken-1\"")
-      expect(request).to include("xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\"")
+        context "global" do
+          let(:client) { new_client(:endpoint => @server.url(:repeat), :wsse_auth => [username, password, :digest]) }
+          let(:response) { client.call(:authenticate) }
+          include_examples "WSSE digest auth"
+        end
+      end
-      # the username node
-      expect(request).to include("<wsse:Username>lea</wsse:Username>")
+      context "not enabled" do
+        let(:client) { new_client(:endpoint => @server.url(:repeat)) }
-      # the nonce node
-      expect(request).to match(/<wsse:Nonce>.+<\/wsse:Nonce>/)
+        describe "local" do
+          context "enabled" do
+            let(:response) { client.call(:authenticate) {|locals| locals.wsse_auth(username, password, :digest)} }
+            include_examples "WSSE digest auth"
+          end
-      # the created node with a timestamp
-      expect(request).to match(/<wsu:Created>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.*<\/wsu:Created>/)
+          context "disabled" do
+            let(:response) { client.call(:authenticate) { |locals| locals.wsse_auth(false)} }
+            include_examples "no WSSE auth"
+          end
-      # the password node contains the encrypted value
-      password_digest = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordDigest"
-      expect(request).to match(/<wsse:Password Type=\"#{password_digest}\">.+<\/wsse:Password>/)
-      expect(request).to_not include("top-secret")
+          context "set to nil" do
+            let(:response) { client.call(:authenticate) { |locals| locals.wsse_auth(nil)} }
+            include_examples "no WSSE auth"
+          end
+        end
+      end
     end
   end
-  context "global :wsse_timestamp" do
-    it "adds WSSE timestamp auth information to the request" do
-      client = new_client(:endpoint => @server.url(:repeat), :wsse_timestamp => true)
-      response = client.call(:authenticate)
+  context ":wsse_timestamp" do
+    let(:request) { response.http.body }
-      request = response.http.body
+    shared_examples "WSSE timestamp" do
+      it "adds WSSE timestamp auth information to the request" do
+        # the header and wsse security node
+        wsse_namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
+        expect(request).to include("<env:Header><wsse:Security xmlns:wsse=\"#{wsse_namespace}\">")
-      # the header and wsse security node
-      wsse_namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
-      expect(request).to include("<env:Header><wsse:Security xmlns:wsse=\"#{wsse_namespace}\">")
+        # split up to prevent problems with unordered Hash attributes in 1.8 [dh, 2012-12-13]
+        expect(request).to include("<wsu:Timestamp")
+        expect(request).to include("wsu:Id=\"Timestamp-1\"")
+        expect(request).to include("xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\"")
-      # split up to prevent problems with unordered Hash attributes in 1.8 [dh, 2012-12-13]
-      expect(request).to include("<wsu:Timestamp")
-      expect(request).to include("wsu:Id=\"Timestamp-1\"")
-      expect(request).to include("xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\"")
+        # the created node with a timestamp
+        expect(request).to match(/<wsu:Created>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.*<\/wsu:Created>/)
-      # the created node with a timestamp
-      expect(request).to match(/<wsu:Created>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.*<\/wsu:Created>/)
+        # the expires node with a timestamp
+        expect(request).to match(/<wsu:Expires>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.*<\/wsu:Expires>/)
+      end
+    end
-      # the expires node with a timestamp
-      expect(request).to match(/<wsu:Expires>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.*<\/wsu:Expires>/)
+    shared_examples "no WSSE timestamp" do
+      it "does not add WSSE timestamp to the request" do
+        expect(request).not_to include("<wsu:Timestamp")
+      end
+    end
+    describe "global" do
+      context "enabled" do
+        context "through block without arguments" do
+          let(:client) do
+            new_client(:endpoint => @server.url(:repeat)) do |globals|
+              globals.wsse_timestamp
+            end
+          end
+          let(:response) { client.call(:authenticate) }
+          include_examples "WSSE timestamp"
+        end
+        context "through initializer options" do
+          let(:client) { new_client(:endpoint => @server.url(:repeat), :wsse_timestamp => true) }
+          let(:response) { client.call(:authenticate) }
+          include_examples "WSSE timestamp"
+        end
+        context "with local override" do
+          let(:client) { new_client(:endpoint => @server.url(:repeat), :wsse_timestamp => true) }
+          context "enabled" do
+            let(:response) { client.call(:authenticate) {|locals| locals.wsse_timestamp} }
+            include_examples "WSSE timestamp"
+          end
+          context "disabled" do
+            let(:response) { client.call(:authenticate) {|locals| locals.wsse_timestamp(false) } }
+            include_examples "no WSSE timestamp"
+          end
+          context "set to nil" do
+            let(:response) { client.call(:authenticate) {|locals| locals.wsse_timestamp(nil) } }
+            include_examples "WSSE timestamp"
+          end
+        end
+      end
+      context "not enabled" do
+        let(:client) { new_client(:endpoint => @server.url(:repeat)) }
+        describe "local" do
+          context "enabled" do
+            let(:response) { client.call(:authenticate) {|locals| locals.wsse_timestamp} }
+            include_examples "WSSE timestamp"
+          end
+          context "disabled" do
+            let(:response) { client.call(:authenticate) {|locals| locals.wsse_timestamp(false) } }
+            include_examples "no WSSE timestamp"
+          end
+          context "set to nil" do
+            let(:response) { client.call(:authenticate) {|locals| locals.wsse_timestamp(nil) } }
+            include_examples "no WSSE timestamp"
+          end
+        end
+      end
     end
   end
   context "global :strip_namespaces" do
     it "can be changed to not strip any namespaces" do
-      client = new_client(:endpoint => @server.url(:repeat), :convert_response_tags_to => lambda { |tag| tag.snakecase }, :strip_namespaces => false)
-      response = client.call(:authenticate, :xml => Fixture.response(:authentication))
+      client = new_client(
+        :endpoint => @server.url(:repeat),
+        :convert_response_tags_to => lambda { |tag| tag.snakecase },
+        :strip_namespaces => false
+      )
-      # the header/body convenience methods fails when conventions are not met. [dh, 2012-12-12]
-      expect { response.body }.to raise_error(Savon::InvalidResponseError)
+      response = client.call(:authenticate, :xml => Fixture.response(:authentication))
       expect(response.hash["soap:envelope"]["soap:body"]).to include("ns2:authenticate_response")
     end
@@ -562,6 +860,125 @@ describe "Options" do
     end
   end
+  context "global :convert_attributes_to" do
+    it "changes how XML tag attributes from the SOAP response are translated into Hash keys" do
+      client = new_client(:endpoint => @server.url(:repeat), :convert_attributes_to => lambda {|k,v| [k,v]})
+      response = client.call(:authenticate, :xml => Fixture.response(:f5))
+      expect(response.body[:get_agent_listen_address_response][:return][:item].first[:ipport][:address]).to eq({:"@s:type"=>"y:string"})
+    end
+    it "strips the attributes if an appropriate lambda is set" do
+      client = new_client(:endpoint => @server.url(:repeat), :convert_attributes_to => lambda {|k,v| []})
+      response = client.call(:authenticate, :xml => Fixture.response(:f5))
+      expect(response.body[:get_agent_listen_address_response][:return][:item].first[:ipport][:address]).to eq(nil)
+    end
+    it "accepts a block in the block-based interface" do
+      client = Savon.client do |globals|
+        globals.log                      false
+        globals.wsdl                     Fixture.wsdl(:authentication)
+        globals.endpoint                 @server.url(:repeat)
+        globals.convert_attributes_to    {|k,v| [k,v]}
+      end
+      response = client.call(:authenticate) do |locals|
+        locals.xml Fixture.response(:f5)
+      end
+      expect(response.body[:get_agent_listen_address_response][:return][:item].first[:ipport][:address]).to eq({:"@s:type"=>"y:string"})
+    end
+  end
+  context 'global: :adapter' do
+    it 'passes option to Wasabi initializer for WSDL fetching' do
+      ## I want to use there something similar to the next mock expectation, but I can't
+      ## as due to how Savon sets up Wasabi::Document and Wasabi::Document initialize itself
+      ## adapter= method is called first time with nil and second time with adapter. [Envek, 2014-05-03]
+      # Wasabi::Document.any_instance.expects(:adapter=).with(:fake_adapter_for_test)
+      client = Savon.client(
+          :log => false,
+          :wsdl => @server.url(:authentication),
+          :adapter => :fake_adapter_for_test,
+      )
+      operations = client.operations
+      expect(operations).to eq([:authenticate])
+      expect(FakeAdapterForTest.class_variable_get(:@@requests).size).to eq(1)
+      expect(FakeAdapterForTest.class_variable_get(:@@requests).first.url).to eq(URI.parse(@server.url(:authentication)))
+      expect(FakeAdapterForTest.class_variable_get(:@@methods)).to eq([:get])
+    end
+    it 'instructs HTTPI to use provided adapter for performing SOAP requests' do
+      client = new_client_without_wsdl(
+          :endpoint => @server.url(:repeat),
+          :namespace => "http://v1.example.com",
+          :adapter => :adapter_for_test,
+      )
+      response = client.call(:authenticate)
+      expect(response.http.body).to include('xmlns:wsdl="http://v1.example.com"')
+      expect(response.http.body).to include('<wsdl:authenticate>')
+      expect(AdapterForTest.class_variable_get(:@@requests).size).to eq(1)
+      expect(AdapterForTest.class_variable_get(:@@requests).first.url).to eq(URI.parse(@server.url(:repeat)))
+      expect(AdapterForTest.class_variable_get(:@@methods)).to eq([:post])
+    end
+  end
+  context "global and request :soap_header" do
+    it "merges the headers if both were provided as Hashes" do
+      global_soap_header = {
+        :global_header => { :auth_token => "secret" },
+        :merged => { :global => true }
+      }
+      request_soap_header = {
+        :request_header => { :auth_token => "secret" },
+        :merged => { :request => true }
+      }
+      client = new_client(:endpoint => @server.url(:repeat), :soap_header => global_soap_header)
+      response = client.call(:authenticate, :soap_header => request_soap_header)
+      request_body = response.http.body
+      expect(request_body).to include("<globalHeader><authToken>secret</authToken></globalHeader>")
+      expect(request_body).to include("<requestHeader><authToken>secret</authToken></requestHeader>")
+      expect(request_body).to include("<merged><request>true</request></merged>")
+    end
+    it "prefers the request over the global option if at least one of them is not a Hash" do
+      global_soap_header  = "<global>header</global>"
+      request_soap_header = "<request>header</request>"
+      client = new_client(:endpoint => @server.url(:repeat), :soap_header => global_soap_header)
+      response = client.call(:authenticate, :soap_header => request_soap_header)
+      request_body = response.http.body
+      expect(request_body).to include("<env:Header><request>header</request></env:Header>")
+    end
+  end
+  context "request :soap_header" do
+    it "accepts a Hash of SOAP header information" do
+      client = new_client(:endpoint => @server.url(:repeat))
+      response = client.call(:authenticate, :soap_header => { :auth_token => "secret" })
+      expect(response.http.body).to include("<env:Header><authToken>secret</authToken></env:Header>")
+    end
+    it "accepts anything other than a String and calls #to_s on it" do
+      to_s_header = Class.new {
+        def to_s
+          "to_s_header"
+        end
+      }.new
+      client = new_client(:endpoint => @server.url(:repeat))
+      response = client.call(:authenticate, :soap_header => to_s_header)
+      expect(response.http.body).to include("<env:Header>to_s_header</env:Header>")
+    end
+  end
   context "request: message_tag" do
     it "when set, changes the SOAP message tag" do
       response = new_client(:endpoint => @server.url(:repeat)).call(:authenticate, :message_tag => :doAuthenticate)
@@ -669,6 +1086,17 @@ describe "Options" do
     end
   end
+  context "request :headers" do
+    it "sets headers" do
+      client = new_client(:endpoint => @server.url(:inspect_request))
+      response = client.call(:authenticate, :headers => { "X-Token" => "secret" })
+      x_token  = inspect_request(response).x_token
+      expect(x_token).to eq("secret")
+    end
+  end
   def new_client(globals = {}, &block)
     globals = { :wsdl => Fixture.wsdl(:authentication), :log => false }.merge(globals)
     Savon.client(globals, &block)