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

savon 2.2.0 → 2.12.1

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)