savon 2.13.0 → 2.14.0

data/spec/integration/zipcode_example_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-RSpec.describe "ZIP code example" do
-  it "supports threads making requests simultaneously" do
-    client = Savon.client(
-      :wsdl => "http://www.thomas-bayer.com/axis2/services/BLZService?wsdl",
-
-      # Lower timeouts so these specs don't take forever when the service is not available.
-      :open_timeout => 10,
-      :read_timeout => 10,
-
-      :log => false # Disable logging for cleaner spec output.
-    )
-
-    mutex = Mutex.new
-
-    request_data = [70070010, 24050110, 20050550]
-    threads_waiting = request_data.size
-
-    threads = request_data.map do |blz|
-      thread = Thread.new do
-        response = call_and_fail_gracefully(client, :get_bank, :message => { :blz => blz })
-        Thread.current[:value] = response.body[:get_bank_response][:details]
-        mutex.synchronize { threads_waiting -= 1 }
-      end
-
-      thread.abort_on_exception = true
-      thread
-    end
-
-    sleep(1) until threads_waiting == 0
-
-    threads.each(&:kill)
-    values = threads.map { |thr| thr[:value] }.compact
-
-    expect(values.uniq.size).to eq(values.size)
-  end
-end

data/spec/savon/builder_spec.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-RSpec.describe Savon::Builder do
-
-  subject(:builder) { Savon::Builder.new(:authenticate, wsdl, globals, locals) }
-
-  let(:globals)     { Savon::GlobalOptions.new }
-  let(:locals)      { Savon::LocalOptions.new }
-  let(:wsdl)        { Wasabi::Document.new Fixture.wsdl(:authentication) }
-  let(:no_wsdl)     { Wasabi::Document.new }
-
-  describe "#pretty" do
-    it "returns the pretty printed request" do
-      expect(builder.pretty).to include("<env:Body>\n    <tns:authenticate/>")
-    end
-  end
-
-  describe "#to_s" do
-    it "includes the global :env_namespace if it's available" do
-      globals[:env_namespace] = :soapenv
-      expect(builder.to_s).to include("<soapenv:Envelope")
-    end
-
-    it "defaults to include the default envelope namespace of :env" do
-      expect(builder.to_s).to include("<env:Envelope")
-    end
-
-    it "includes the target namespace from the WSDL" do
-      expect(builder.to_s).to include('xmlns:tns="http://v1_0.ws.auth.order.example.com/"')
-    end
-
-    it "includes the target namespace from the global :namespace if it's available" do
-      globals[:namespace] = "http://v1.example.com"
-      expect(builder.to_s).to include('xmlns:tns="http://v1.example.com"')
-    end
-
-    it "includes the local :message_tag if available" do
-      locals[:message_tag] = "doAuthenticate"
-      expect(builder.to_s).to include("<tns:doAuthenticate>")
-    end
-
-    it "includes the message tag from the WSDL if its available" do
-      expect(builder.to_s).to include("<tns:authenticate>")
-    end
-
-    it "includes a message tag created by Gyoku if both option and WSDL are missing" do
-      globals[:namespace] = "http://v1.example.com"
-
-      locals = Savon::LocalOptions.new
-      builder = Savon::Builder.new(:authenticate, no_wsdl, globals, locals)
-
-      expect(builder.to_s).to include("<wsdl:authenticate>")
-    end
-
-    it "uses the global :namespace_identifier option if it's available" do
-      globals[:namespace_identifier] = :v1
-      expect(builder.to_s).to include("<v1:authenticate>")
-    end
-
-    it "uses the WSDL's namespace_identifier if the global option was not specified" do
-      expect(builder.to_s).to include("<tns:authenticate>")
-    end
-
-    it "uses the default :wsdl identifier if both option and WSDL were not specified" do
-      globals[:namespace] = "http://v1.example.com"
-
-      builder = Savon::Builder.new(:authenticate, no_wsdl, globals, locals)
-      expect(builder.to_s).to include("<wsdl:authenticate>")
-    end
-
-    it "uses the global :element_form_default option if it's available " do
-      globals[:element_form_default] = :qualified
-      locals[:message] = { :username => "luke", :password => "secret" }
-
-      expect(builder.to_s).to include("<tns:username>luke</tns:username>")
-    end
-
-    it "uses the WSDL's element_form_default value if the global option was set specified" do
-      locals[:message] = { :username => "luke", :password => "secret" }
-      wsdl.element_form_default = :qualified
-
-      expect(builder.to_s).to include("<tns:username>luke</tns:username>")
-    end
-
-    describe "#wsse_signature" do
-      fixture_dir = File.join(File.dirname(__FILE__), '..', 'fixtures', 'ssl')
-
-      let(:cert)        { File.join(fixture_dir, 'client_cert.pem') }
-      let(:private_key) { File.join(fixture_dir, 'client_key.pem') }
-      let(:signature) do
-        Akami::WSSE::Signature.new(
-          Akami::WSSE::Certs.new(
-            :cert_file => cert,
-            :private_key_file => private_key
-          )
-        )
-      end
-      let(:globals) { Savon::GlobalOptions.new(wsse_signature: signature) }
-
-      subject(:signed_message_nn) {Nokogiri::XML(builder.to_s).remove_namespaces!}
-      subject(:signed_message) {Nokogiri::XML(builder.to_s)}
-
-      it "should contain a header" do
-        expect(signed_message_nn.xpath('/Envelope/Header').size).to eq(1)
-      end
-
-      it "should contain a wsse:Security" do
-        expect(signed_message_nn.xpath('/Envelope/Header/Security').size).to eq(1)
-      end
-
-      it "should have a Body[@wsu:Id]" do
-        #must investigate: acts funny in mri ruby
-        #expect(signed_message.xpath('//soapenv:Body', soapenv: "http://schemas.xmlsoap.org/soap/envelope/").attribute('ws:Id').value).to include('Body-')
-        expect(signed_message_nn.xpath('//Body').attr('Id').value).to include('Body-')
-      end
-
-      it "signature should be valid" do
-        certs = Akami::WSSE::Certs.new(:cert_file => cert, :private_key_file => private_key)
-        signature_value = signed_message_nn.xpath('//SignatureValue').text
-        signed_info_fragment = signed_message.xpath('//default:SignedInfo', default: "http://www.w3.org/2000/09/xmldsig#").to_xml
-        data = Nokogiri::XML(signed_info_fragment){|config| config.options = Nokogiri::XML::ParseOptions::NOBLANKS}
-        data.root.default_namespace='http://www.w3.org/2000/09/xmldsig#'
-
-        signed_info = data.canonicalize Nokogiri::XML::XML_C14N_EXCLUSIVE_1_0
-
-        signature = certs.private_key.sign(OpenSSL::Digest::SHA1.new, signed_info)
-        expect(Base64.encode64(signature).gsub("\n", '')).to eq(signature_value)
-      end
-    end
-  end
-
-  describe '#body_attributes' do
-    it 'should not be nil' do
-      expect(builder.body_attributes).to eq({})
-    end
-  end
-end

data/spec/savon/client_spec.rb

@@ -1,272 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-require "integration/support/server"
-
-RSpec.describe Savon::Client do
-
-  before :all do
-    @server = IntegrationServer.run
-  end
-
-  after :all do
-    @server.stop
-  end
-
-  describe ".new" do
-    it "supports a block without arguments to create a client with global options" do
-      client = Savon.client do
-        wsdl Fixture.wsdl(:authentication)
-      end
-
-      expect(client.globals[:wsdl]).to eq(Fixture.wsdl(:authentication))
-    end
-
-    it "supports a block with one argument to create a client with global options" do
-      client = Savon.client do |globals|
-        globals.wsdl Fixture.wsdl(:authentication)
-      end
-
-      expect(client.globals[:wsdl]).to eq(Fixture.wsdl(:authentication))
-    end
-
-    it "builds an HTTPI request for Wasabi" do
-      http_request = mock
-      wsdl_request = mock(:build => http_request)
-      Savon::WSDLRequest.expects(:new).with(instance_of(Savon::GlobalOptions)).returns(wsdl_request)
-
-      Wasabi::Document.any_instance.expects(:request=).with(http_request)
-      Savon.client(:wsdl => "http://example.com")
-    end
-
-    it "raises if initialized with anything other than a Hash" do
-      expect { Savon.client("http://example.com") }.
-        to raise_error(Savon::InitializationError, /Some code tries to initialize Savon with the "http:\/\/example\.com" \(String\)/)
-    end
-
-    it "raises if not initialized with either a :wsdl or both :endpoint and :namespace options" do
-      expect { Savon.client(:endpoint => "http://example.com") }.
-        to raise_error(Savon::InitializationError, /Expected either a WSDL document or the SOAP endpoint and target namespace options/)
-    end
-
-    it "raises a when given an unknown option via the Hash syntax" do
-      expect { Savon.client(:invalid_global_option => true) }.
-        to raise_error(Savon::UnknownOptionError, "Unknown global option: :invalid_global_option")
-    end
-
-    it "raises a when given an unknown option via the block syntax" do
-      expect { Savon.client { another_invalid_global_option true } }.
-        to raise_error(Savon::UnknownOptionError, "Unknown global option: :another_invalid_global_option")
-    end
-  end
-
-  describe "#globals" do
-    it "returns the current set of global options" do
-      expect(new_client.globals).to be_an_instance_of(Savon::GlobalOptions)
-    end
-
-    fit "defaults :log to false" do
-      client = Savon.client(:wsdl => Fixture.wsdl(:authentication))
-      expect(client.globals[:log]).to be_falsey
-    end
-  end
-
-  describe "#service_name" do
-    it "returns the name of the service" do
-      expect(new_client.service_name).to eq('AuthenticationWebServiceImplService')
-    end
-  end
-
-  describe "#operations" do
-    it "returns all operation names" do
-      operations = new_client.operations
-      expect(operations).to eq([:authenticate])
-    end
-
-    it "raises when there is no WSDL document" do
-      expect { new_client_without_wsdl.operations }.to raise_error("Unable to inspect the service without a WSDL document.")
-    end
-  end
-
-  describe "#operation" do
-    it "returns a new SOAP operation" do
-      operation = new_client.operation(:authenticate)
-      expect(operation).to be_a(Savon::Operation)
-    end
-
-    it "raises if there's no such SOAP operation" do
-      expect { new_client.operation(:does_not_exist) }.
-        to raise_error(Savon::UnknownOperationError)
-    end
-
-    it "does not raise when there is no WSDL document" do
-      new_client_without_wsdl.operation(:does_not_exist)
-    end
-  end
-
-  describe "#call" do
-    it "calls a new SOAP operation" do
-      locals = { :message => { :symbol => "AAPL" } }
-      soap_response = new_soap_response
-
-      wsdl = Wasabi::Document.new('http://example.com')
-      operation = Savon::Operation.new(:authenticate, wsdl, Savon::GlobalOptions.new)
-      operation.expects(:call).with(locals).returns(soap_response)
-
-      Savon::Operation.expects(:create).with(
-        :authenticate,
-        instance_of(Wasabi::Document),
-        instance_of(Savon::GlobalOptions)
-      ).returns(operation)
-
-      response = new_client.call(:authenticate, locals)
-      expect(response).to eq(soap_response)
-    end
-
-    it "supports a block without arguments to call an operation with local options" do
-      client = new_client(:endpoint => @server.url(:repeat))
-
-      response = client.call(:authenticate) do
-        message(:symbol => "AAPL" )
-      end
-
-      expect(response.http.body).to include("<symbol>AAPL</symbol>")
-    end
-
-    it "supports a block with one argument to call an operation with local options" do
-      client = new_client(:endpoint => @server.url(:repeat))
-
-      # supports instance variables!
-      @instance_variable = { :symbol => "AAPL" }
-
-      response = client.call(:authenticate) do |locals|
-        locals.message(@instance_variable)
-      end
-
-      expect(response.http.body).to include("<symbol>AAPL</symbol>")
-    end
-
-    it "accepts arguments for the message tag" do
-      client   = new_client(:endpoint => @server.url(:repeat))
-      response = client.call(:authenticate, :attributes => { "ID" => "ABC321"})
-
-      expect(response.http.body).to include('<tns:authenticate ID="ABC321">')
-    end
-
-    it "raises when the operation name is not a symbol" do
-      expect { new_client.call("not a symbol") }.to raise_error(
-        ArgumentError,
-        "Expected the first parameter (the name of the operation to call) to be a symbol\n" \
-        "Actual: \"not a symbol\" (String)"
-      )
-    end
-
-    it "raises a when given an unknown option via the Hash syntax" do
-      expect { new_client.call(:authenticate, :invalid_local_option => true) }.
-        to raise_error(Savon::UnknownOptionError, "Unknown local option: :invalid_local_option")
-    end
-
-    it "raises a when given an unknown option via the block syntax" do
-      expect { new_client.call(:authenticate) { another_invalid_local_option true } }.
-        to raise_error(Savon::UnknownOptionError, "Unknown local option: :another_invalid_local_option")
-    end
-  end
-
-  describe "#build_request" do
-    it "returns the request without making an actual call" do
-      expected_request = mock('request')
-      wsdl = Wasabi::Document.new('http://example.com')
-
-      operation = Savon::Operation.new(
-        :authenticate,
-        wsdl,
-        Savon::GlobalOptions.new
-      )
-      operation.expects(:request).returns(expected_request)
-
-      Savon::Operation.expects(:create).with(
-        :authenticate,
-        instance_of(Wasabi::Document),
-        instance_of(Savon::GlobalOptions)
-      ).returns(operation)
-
-      operation.expects(:call).never
-
-      client = new_client(:endpoint => @server.url(:repeat))
-      request = client.build_request(:authenticate) do
-        message(:symbol => "AAPL" )
-      end
-
-      expect(request).to eq expected_request
-    end
-
-    it "accepts a block without arguments" do
-      client = new_client(:endpoint => @server.url(:repeat))
-      request = client.build_request(:authenticate) do
-        message(:symbol => "AAPL" )
-      end
-
-      expect(request.body).
-        to include('<tns:authenticate><symbol>AAPL</symbol></tns:authenticate>')
-    end
-
-    it "accepts a block with one argument" do
-      client = new_client(:endpoint => @server.url(:repeat))
-
-      # supports instance variables!
-      @instance_variable = { :symbol => "AAPL" }
-
-      request = client.build_request(:authenticate) do |locals|
-        locals.message(@instance_variable)
-      end
-
-      expect(request.body).
-        to include("<tns:authenticate><symbol>AAPL</symbol></tns:authenticate>")
-    end
-
-    it "accepts argument for the message tag" do
-      client = new_client(:endpoint => @server.url(:repeat))
-      request = client.build_request(:authenticate, :attributes => { "ID" => "ABC321" })
-
-      expect(request.body).
-        to include("<tns:authenticate ID=\"ABC321\"></tns:authenticate>")
-    end
-
-    it "raises when the operation name is not a symbol" do
-      expect { new_client.build_request("not a symbol") }.to raise_error ArgumentError
-    end
-
-    it "raises when given an unknown option via the Hash syntax" do
-      expect { new_client.build_request(:authenticate, :invalid_local_option => true) }.to raise_error Savon::UnknownOptionError
-    end
-
-    it "raises when given an unknown option via the block syntax" do
-      expect { new_client.build_request(:authenticate) { another_invalid_local_option true } }.to raise_error Savon::UnknownOptionError
-    end
-  end
-
-  def new_http_response(options = {})
-    defaults = { :code => 200, :headers => {}, :body => Fixture.response(:authentication) }
-    response = defaults.merge options
-
-    HTTPI::Response.new response[:code], response[:headers], response[:body]
-  end
-
-  def new_soap_response(options = {})
-    http = new_http_response(options)
-    globals = Savon::GlobalOptions.new
-    locals = Savon::LocalOptions.new
-
-    Savon::Response.new(http, globals, locals)
-  end
-
-  def new_client(globals = {})
-    globals = { :wsdl => Fixture.wsdl(:authentication), :log => false }.merge(globals)
-    Savon.client(globals)
-  end
-
-  def new_client_without_wsdl(globals = {})
-    globals = { :endpoint => "http://example.co", :namespace => "http://v1.example.com", :log => false }.merge(globals)
-    Savon.client(globals)
-  end
-
-end

data/spec/savon/core_ext/string_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-RSpec.describe String do
-
-  describe "snakecase" do
-    it "lowercases one word CamelCase" do
-      expect("Merb".snakecase).to eq("merb")
-    end
-
-    it "makes one underscore snakecase two word CamelCase" do
-      expect("MerbCore".snakecase).to eq("merb_core")
-    end
-
-    it "handles CamelCase with more than 2 words" do
-      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
-      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
-      expect("merb".snakecase).to eq("merb")
-    end
-
-    it "leaves snake_case as is" do
-      expect("merb_core".snakecase).to eq("merb_core")
-    end
-
-    it "converts period characters to underscores" do
-      expect("User.GetEmail".snakecase).to eq("user_get_email")
-    end
-  end
-
-end

data/spec/savon/features/message_tag_spec.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-RSpec.describe Savon do
-
-  it 'knows the message tag for :authentication' do
-    message_tag = message_tag_for(:authentication, :authenticate)
-    expect(message_tag).to eq(['http://v1_0.ws.auth.order.example.com/', 'authenticate'])
-  end
-
-  it 'knows the message tag for :taxcloud' do
-    message_tag = message_tag_for(:taxcloud, :verify_address)
-    expect(message_tag).to eq(['http://taxcloud.net', 'VerifyAddress'])
-  end
-
-  it 'knows the message tag for :team_software' do
-    message_tag = message_tag_for(:team_software, :login)
-    expect(message_tag).to eq(['http://tempuri.org/', 'Login'])
-  end
-
-  it 'knows the message tag for :interhome' do
-    message_tag = message_tag_for(:interhome, :price_list)
-    expect(message_tag).to eq(['http://www.interhome.com/webservice', 'PriceList'])
-  end
-
-  it 'knows the message tag for :betfair' do
-    message_tag = message_tag_for(:betfair, :get_bet)
-    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'])
-  end
-
-  def message_tag_for(fixture, operation_name)
-    globals     = Savon::GlobalOptions.new(:log => false)
-    wsdl        = Wasabi::Document.new Fixture.wsdl(fixture)
-    operation   = Savon::Operation.create(operation_name, wsdl, globals)
-    request_xml = operation.build.to_s
-
-    nsid, local = extract_message_tag_from_request(request_xml)
-    namespace   = extract_namespace_from_request(nsid, request_xml)
-
-    [namespace, local]
-  end
-
-  def extract_message_tag_from_request(xml)
-    match = xml.match(/<\w+?:Body><(.+?):(.+?)>/)
-    [ match[1], match[2] ]
-  end
-
-  def extract_namespace_from_request(nsid, xml)
-    xml.match(/xmlns:#{nsid}="(.+?)"/)[1]
-  end
-
-end

data/spec/savon/http_error_spec.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-RSpec.describe Savon::HTTPError do
-  let(:http_error) { Savon::HTTPError.new new_response(:code => 404, :body => "Not Found") }
-  let(:http_error_with_empty_body) { Savon::HTTPError.new new_response(:code => 404, :body => "") }
-  let(:no_error) { Savon::HTTPError.new new_response }
-
-  it "inherits from Savon::Error" do
-    expect(Savon::HTTPError.ancestors).to include(Savon::Error)
-  end
-
-  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_truthy
-    end
-
-    it "returns false unless there was an HTTP error" do
-      expect(Savon::HTTPError.present? new_response).to be_falsey
-    end
-  end
-
-  describe "#http" do
-    it "returns the HTTPI::Response" do
-      expect(http_error.http).to be_a(HTTPI::Response)
-    end
-  end
-
-  [:message, :to_s].each do |method|
-    describe "##{method}" do
-      it "returns the HTTP error message" do
-        expect(http_error.send method).to eq("HTTP error (404): Not Found")
-      end
-
-      context "when the body is empty" do
-        it "returns the HTTP error without the body message" do
-          expect(http_error_with_empty_body.send method).to eq("HTTP error (404)")
-        end
-      end
-    end
-  end
-
-  describe "#to_hash" do
-    it "returns the HTTP response details as a Hash" do
-      expect(http_error.to_hash).to eq(:code => 404, :headers => {}, :body => "Not Found")
-    end
-  end
-
-  def new_response(options = {})
-    defaults = { :code => 200, :headers => {}, :body => Fixture.response(:authentication) }
-    response = defaults.merge options
-
-    HTTPI::Response.new response[:code], response[:headers], response[:body]
-  end
-
-end

data/spec/savon/log_message_spec.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-RSpec.describe Savon::LogMessage do
-
-  it "returns the message if it's not XML" do
-    message = log_message("hello", [:password], :pretty_print).to_s
-    expect(message).to eq("hello")
-  end
-
-  it "returns the message if it shouldn't be filtered or pretty printed" do
-    Nokogiri.expects(:XML).never
-
-    message = log_message("<hello/>", [], false).to_s
-    expect(message).to eq("<hello/>")
-  end
-
-  it "pretty prints a given message" do
-    message = log_message("<envelope><body>hello</body></envelope>", [], :pretty_print).to_s
-
-    expect(message).to include("\n<envelope>")
-    expect(message).to include("\n  <body>")
-  end
-
-  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)
-    Savon::LogMessage.new(*args)
-  end
-
-end