savon 2.13.1 → 2.14.0

data/spec/savon/response_spec.rb

@@ -1,276 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-RSpec.describe Savon::Response do
-
-  let(:globals) { Savon::GlobalOptions.new }
-  let(:locals)  { Savon::LocalOptions.new }
-
-  describe ".new" do
-    it "should raise a Savon::Fault in case of a SOAP fault" do
-      expect { soap_fault_response }.to raise_error(Savon::SOAPFault)
-    end
-
-    it "should not raise a Savon::Fault in case the default is turned off" do
-      globals[:raise_errors] = false
-      expect { soap_fault_response }.not_to raise_error
-    end
-
-    it "should raise a Savon::HTTP::Error in case of an HTTP error" do
-      expect { soap_response :code => 500 }.to raise_error(Savon::HTTPError)
-    end
-
-    it "should not raise a Savon::HTTP::Error in case the default is turned off" do
-      globals[:raise_errors] = false
-      soap_response :code => 500
-    end
-  end
-
-  describe "#success?" do
-    before { globals[:raise_errors] = false }
-
-    it "should return true if the request was successful" do
-      expect(soap_response).to be_a_success
-    end
-
-    it "should return false if there was a SOAP fault" do
-      expect(soap_fault_response).not_to be_a_success
-    end
-
-    it "should return false if there was an HTTP error" do
-      expect(http_error_response).not_to be_a_success
-    end
-  end
-
-  describe "#soap_fault?" do
-    before { globals[:raise_errors] = false }
-
-    it "should not return true in case the response seems to be ok" do
-      expect(soap_response.soap_fault?).to be_falsey
-    end
-
-    it "should return true in case of a SOAP fault" do
-      expect(soap_fault_response.soap_fault?).to be_truthy
-    end
-  end
-
-  describe "#soap_fault" do
-    before { globals[:raise_errors] = false }
-
-    it "should return nil in case the response seems to be ok" do
-      expect(soap_response.soap_fault).to be_nil
-    end
-
-    it "should return a SOAPFault in case of a SOAP fault" do
-      expect(soap_fault_response.soap_fault).to be_a(Savon::SOAPFault)
-    end
-  end
-
-  describe "#http_error?" do
-    before { globals[:raise_errors] = false }
-
-    it "should not return true in case the response seems to be ok" do
-      expect(soap_response.http_error?).not_to be_truthy
-    end
-
-    it "should return true in case of an HTTP error" do
-      expect(soap_response(:code => 500).http_error?).to be_truthy
-    end
-  end
-
-  describe "#http_error" do
-    before { globals[:raise_errors] = false }
-
-    it "should return nil in case the response seems to be ok" do
-      expect(soap_response.http_error).to be_nil
-    end
-
-    it "should return a HTTPError in case of an HTTP error" do
-      expect(soap_response(:code => 500).http_error).to be_a(Savon::HTTPError)
-    end
-  end
-
-  describe "#header" do
-    it "should return the SOAP response header as a Hash" do
-      response = soap_response :body => Fixture.response(:header)
-      expect(response.header).to include(:session_number => "ABCD1234")
-    end
-
-    it 'respects the global :strip_namespaces option' do
-      globals[:strip_namespaces] = false
-
-      response_with_header = soap_response(:body => Fixture.response(:header))
-      header = response_with_header.header
-
-      expect(header).to be_a(Hash)
-
-      # notice: :session_number is a snake_case Symbol without namespaces,
-      # but the Envelope and Header elements are qualified.
-      expect(header.keys).to include(:session_number)
-    end
-
-    it 'respects the global :convert_response_tags_to option' do
-      globals[:convert_response_tags_to] = lambda { |key| key.upcase }
-
-      response_with_header = soap_response(:body => Fixture.response(:header))
-      header = response_with_header.header
-
-      expect(header).to be_a(Hash)
-      expect(header.keys).to include('SESSIONNUMBER')
-    end
-
-    it 'respects the global :convert_attributes_to option' do
-      globals[:convert_attributes_to] = lambda { |k,v| [] }
-
-      response_with_header = soap_response(:body => Fixture.response(:header))
-      header = response_with_header.header
-
-      expect(header).to be_a(Hash)
-      expect(header.keys).to include(:session_number)
-    end
-
-    it "should throw an exception when the response header isn't parsable" do
-      expect { invalid_soap_response.header }.to raise_error Savon::InvalidResponseError
-    end
-  end
-
-  %w(body to_hash).each do |method|
-    describe "##{method}" do
-      it "should return the SOAP response body as a Hash" do
-        expect(soap_response.send(method)[:authenticate_response][:return]).to eq(
-          Fixture.response_hash(:authentication)[:authenticate_response][:return]
-        )
-      end
-
-      it "should return a Hash for a SOAP multiRef response" do
-        hash = soap_response(:body => Fixture.response(:multi_ref)).send(method)
-
-        expect(hash[:list_response]).to be_a(Hash)
-        expect(hash[:multi_ref]).to be_an(Array)
-      end
-
-      it "should add existing namespaced elements as an array" do
-        hash = soap_response(:body => Fixture.response(:list)).send(method)
-
-        expect(hash[:multi_namespaced_entry_response][:history]).to be_a(Hash)
-        expect(hash[:multi_namespaced_entry_response][:history][:case]).to be_an(Array)
-      end
-
-      it 'respects the global :strip_namespaces option' do
-        globals[:strip_namespaces] = false
-
-        body = soap_response.body
-
-        expect(body).to be_a(Hash)
-        expect(body.keys).to include(:"ns2:authenticate_response")
-      end
-
-      it 'respects the global :convert_response_tags_to option' do
-        globals[:convert_response_tags_to] = lambda { |key| key.upcase }
-
-        body = soap_response.body
-
-        expect(body).to be_a(Hash)
-        expect(body.keys).to include('AUTHENTICATERESPONSE')
-      end
-    end
-  end
-
-  describe "#to_array" do
-    context "when the given path exists" do
-      it "should return an Array containing the path value" do
-        expect(soap_response.to_array(:authenticate_response, :return)).to eq(
-          [Fixture.response_hash(:authentication)[:authenticate_response][:return]]
-        )
-      end
-
-      it "should properly return FalseClass values [#327]" do
-        body = Gyoku.xml(:envelope => { :body => { :return => { :success => false } } })
-        expect(soap_response(:body => body).to_array(:return, :success)).to eq([false])
-      end
-    end
-
-    context "when the given path returns nil" do
-      it "should return an empty Array" do
-        expect(soap_response.to_array(:authenticate_response, :undefined)).to eq([])
-      end
-    end
-
-    context "when the given path does not exist at all" do
-      it "should return an empty Array" do
-        expect(soap_response.to_array(:authenticate_response, :some, :undefined, :path)).to eq([])
-      end
-    end
-  end
-
-  describe "#hash" do
-    it "should return the complete SOAP response XML as a Hash" do
-      response = soap_response :body => Fixture.response(:header)
-      expect(response.hash[:envelope][:header][:session_number]).to eq("ABCD1234")
-    end
-  end
-
-  describe "#to_xml" do
-    it "should return the raw SOAP response body" do
-      expect(soap_response.to_xml).to eq(Fixture.response(:authentication))
-    end
-  end
-
-  describe "#doc" do
-    it "returns a Nokogiri::XML::Document for the SOAP response XML" do
-      expect(soap_response.doc).to be_a(Nokogiri::XML::Document)
-    end
-  end
-
-  describe "#xpath" do
-    it "permits XPath access to elements in the request" do
-      expect(soap_response.xpath("//client").first.inner_text).to eq("radclient")
-      expect(soap_response.xpath("//ns2:authenticateResponse/return/success").first.inner_text).to eq("true")
-    end
-  end
-
-  describe '#find' do
-    it 'delegates to Nori#find to find child elements inside the Envelope' do
-      result = soap_response.find('Body', 'authenticateResponse', 'return')
-
-      expect(result).to be_a(Hash)
-      expect(result.keys).to include(:authentication_value)
-    end
-
-    it 'fails correctly when envelope contains only string' do
-      response = soap_response({ :body => Fixture.response(:no_body) })
-      expect { response.find('Body') }.to raise_error Savon::InvalidResponseError
-    end
-  end
-
-  describe "#http" do
-    it "should return the HTTPI::Response" do
-      expect(soap_response.http).to be_an(HTTPI::Response)
-    end
-  end
-
-  def soap_response(options = {})
-    defaults = { :code => 200, :headers => {}, :body => Fixture.response(:authentication) }
-    response = defaults.merge options
-    http_response = HTTPI::Response.new(response[:code], response[:headers], response[:body])
-
-    Savon::Response.new(http_response, globals, locals)
-  end
-
-  def soap_fault_response
-    soap_response :code => 500, :body => Fixture.response(:soap_fault)
-  end
-
-  def http_error_response
-    soap_response :code => 404, :body => "Not found"
-  end
-
-  def invalid_soap_response(options = {})
-    defaults = { :code => 200, :headers => {}, :body => "I'm not SOAP" }
-    response = defaults.merge options
-    http_response = HTTPI::Response.new(response[:code], response[:headers], response[:body])
-
-    Savon::Response.new(http_response, globals, locals)
-  end
-
-end

data/spec/savon/soap_fault_spec.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-RSpec.describe Savon::SOAPFault do
-  let(:soap_fault) { Savon::SOAPFault.new new_response(:body => Fixture.response(:soap_fault)), nori }
-  let(:empty_soap_fault) { Savon::SOAPFault.new new_response(:body => Fixture.response(:empty_soap_fault)), nori }
-  let(:soap_fault2) { Savon::SOAPFault.new new_response(:body => Fixture.response(:soap_fault12)), nori }
-  let(:soap_fault_funky) { Savon::SOAPFault.new new_response(:body => Fixture.response(:soap_fault_funky)), nori }
-  let(:soap_fault_nc) { Savon::SOAPFault.new new_response(:body => Fixture.response(:soap_fault)), nori_no_convert }
-  let(:soap_fault_nc2) { Savon::SOAPFault.new new_response(:body => Fixture.response(:soap_fault12)), nori_no_convert }
-  let(:another_soap_fault) { Savon::SOAPFault.new new_response(:body => Fixture.response(:another_soap_fault)), nori }
-  let(:soap_fault_no_body) { Savon::SOAPFault.new new_response(:body => {}), nori }
-  let(:no_fault) { Savon::SOAPFault.new new_response, nori }
-
-  let(:nori) { Nori.new(:strip_namespaces => true, :convert_tags_to => lambda { |tag| tag.snakecase.to_sym }) }
-  let(:nori_no_convert) { Nori.new(:strip_namespaces => true, :convert_tags_to => nil) }
-
-  it "inherits from Savon::Error" do
-    expect(Savon::SOAPFault.ancestors).to include(Savon::Error)
-  end
-
-  describe "#http" do
-    it "returns the HTTPI::Response" do
-      expect(soap_fault.http).to be_an(HTTPI::Response)
-    end
-  end
-
-  describe ".present?" do
-    it "returns true if the HTTP response contains a SOAP 1.1 fault" do
-      http = new_response(:body => Fixture.response(:soap_fault))
-      expect(Savon::SOAPFault.present? http).to be_truthy
-    end
-
-    it "returns true if the HTTP response contains a SOAP 1.1 fault with empty fault tags" do
-      http = new_response(:body => Fixture.response(:empty_soap_fault))
-      expect(Savon::SOAPFault.present? http).to be_truthy
-    end
-
-    it "returns true if the HTTP response contains a SOAP 1.2 fault" do
-      http = new_response(:body => Fixture.response(:soap_fault12))
-      expect(Savon::SOAPFault.present? http).to be_truthy
-    end
-
-    it "returns true if the HTTP response contains a SOAP fault with different namespaces" do
-      http = new_response(:body => Fixture.response(:another_soap_fault))
-      expect(Savon::SOAPFault.present? http).to be_truthy
-    end
-
-    it "returns false unless the HTTP response contains a SOAP fault" do
-      expect(Savon::SOAPFault.present? new_response).to be_falsey
-    end
-  end
-
-  [:message, :to_s].each do |method|
-    describe "##{method}" do
-      it "returns a SOAP 1.1 fault message" do
-        expect(soap_fault.send method).to eq("(soap:Server) Fault occurred while processing.")
-      end
-
-      it "returns an empty fault message" do
-        expect(empty_soap_fault.send method).to eq(nil)
-      end
-
-      it "returns a SOAP 1.2 fault message" do
-        expect(soap_fault2.send method).to eq("(soap:Sender) Sender Timeout")
-      end
-
-      it "returns a SOAP fault message (with different namespaces)" do
-        expect(another_soap_fault.send method).to eq("(ERR_NO_SESSION) Wrong session message")
-      end
-
-      it "works even if the keys are different in a SOAP 1.1 fault message" do
-        expect(soap_fault_nc.send method).to eq("(soap:Server) Fault occurred while processing.")
-      end
-
-      it "works even if the keys are different in a SOAP 1.2 fault message" do
-        expect(soap_fault_nc2.send method).to eq("(soap:Sender) Sender Timeout")
-      end
-
-      it "works even if the keys are different in a funky SOAP fault message" do
-        expect(soap_fault_funky.send method).to eq("(42) The Answer to Life The Universe And Everything")
-      end
-    end
-  end
-
-  describe "#to_hash" do
-    it "returns the SOAP response as a Hash unless a SOAP fault is present" do
-      expect(no_fault.to_hash[:authenticate_response][:return][:success]).to be_truthy
-    end
-
-    it "returns a SOAP 1.1 fault as a Hash" do
-      expected = {
-        :fault => {
-          :faultstring => "Fault occurred while processing.",
-          :faultcode   => "soap:Server"
-        }
-      }
-
-      expect(soap_fault.to_hash).to eq(expected)
-    end
-
-    it "returns a SOAP 1.2 fault as a Hash" do
-      expected = {
-        :fault => {
-          :detail => { :max_time => "P5M" },
-          :reason => { :text => "Sender Timeout" },
-          :code   => { :value => "soap:Sender", :subcode => { :value => "m:MessageTimeout" } }
-        }
-      }
-
-      expect(soap_fault2.to_hash).to eq(expected)
-    end
-
-    it "works even if the keys are different" do
-      expected = {
-        "Fault" => {
-          "Code" => {
-            "Value"  => "soap:Sender",
-            "Subcode"=> {
-              "Value" => "m:MessageTimeout"
-            }
-          },
-          "Reason" => {
-            "Text" => "Sender Timeout"
-          },
-          "Detail" => {
-            "MaxTime" => "P5M"
-          }
-        }
-      }
-
-      expect(soap_fault_nc2.to_hash).to eq(expected)
-    end
-
-    it "returns empty hash" do
-      expect(soap_fault_no_body.to_hash).to eq({})
-    end
-  end
-
-  def new_response(options = {})
-    defaults = { :code => 500, :headers => {}, :body => Fixture.response(:authentication) }
-    response = defaults.merge options
-
-    HTTPI::Response.new response[:code], response[:headers], response[:body]
-  end
-
-end

data/spec/savon/softlayer_spec.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-RSpec.describe Savon::Builder do
-
-  subject(:builder) { Savon::Builder.new(:create_object, wsdl, globals, locals) }
-
-  let(:globals)     { Savon::GlobalOptions.new }
-  # let(:locals)      { Savon::LocalOptions.new }
-  let(:wsdl)        { Wasabi::Document.new Fixture.wsdl(:brand) }
-  let(:no_wsdl)     { Wasabi::Document.new }
-
-  describe "#to_s" do
-    it "defaults to include the default envelope namespace of :env" do
-      message = {
-        :message=>{
-          :template_object=>{
-            :longName=>"Zertico LLC Reseller"
-          }
-        }
-      }
-
-      expected_namespaces = {
-        'xmlns'           => "http://schemas.xmlsoap.org/wsdl/",
-        'xmlns:xsd'       => "http://www.w3.org/2001/XMLSchema",
-        'xmlns:xsi'       => "http://www.w3.org/2001/XMLSchema-instance",
-        'xmlns:tns'       => "http://api.service.softlayer.com/soap/v3/",
-        'xmlns:env'       => "http://schemas.xmlsoap.org/soap/envelope/",
-        'xmlns:soap'      => "http://schemas.xmlsoap.org/wsdl/soap/",
-        'xmlns:soap-enc'  => "http://schemas.xmlsoap.org/soap/encoding/",
-        'xmlns:wsdl'      => "http://schemas.xmlsoap.org/wsdl/"
-      }
-
-      locals = Savon::LocalOptions.new(message)
-      builder = Savon::Builder.new(:create_object, wsdl, globals, locals)
-
-      envelope = Nokogiri::XML(builder.to_s).xpath('./env:Envelope').first
-
-      expect(envelope.namespaces).to match(expected_namespaces)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-require "bundler"
-require "byebug"
-Bundler.setup(:default, :development)
-
-unless RUBY_PLATFORM =~ /java/
-  require "simplecov"
-  SimpleCov.start do
-      add_filter "spec"
-  end
-end
-
-require "savon"
-require "rspec"
-
-# don't have HTTPI lazy-load HTTPClient, because then
-# it can't actually be refered to inside the specs.
-require "httpclient"
-
-support_files = File.expand_path("spec/support/**/*.rb")
-Dir[support_files].sort.each { |file| require file }
-
-RSpec.configure do |config|
-  config.include SpecSupport
-  config.mock_with :mocha
-  config.order = "random"
-  config.example_status_persistence_file_path = ".rspec_status"
-  config.disable_monkey_patching!
-end
-
-HTTPI.log = false

data/spec/support/adapters.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-require 'httpi/adapter/httpclient'
-
-# Proxy adapter. Records all requests and passes them to HTTPClient
-class AdapterForTest < HTTPI::Adapter::Base
-
-  register :adapter_for_test
-
-  def initialize(request)
-    @@requests ||= []
-    @@requests.push request
-    @request = request
-    @worker = HTTPI::Adapter::HTTPClient.new(request)
-  end
-
-  def client
-    @worker.client
-  end
-
-  def request(method)
-    @@methods ||= []
-    @@methods.push method
-    @worker.request(method)
-  end
-
-end
-
-# Fake adapter with request recording.
-# Takes path from url and returns fixture WSDL with that name.
-class FakeAdapterForTest < HTTPI::Adapter::Base
-
-  register :fake_adapter_for_test
-
-  def initialize(request)
-    @@requests ||= []
-    @@requests.push request
-    @request = request
-  end
-
-  attr_reader :client
-
-  def request(method)
-    @@methods ||= []
-    @@methods.push method
-    target = @request.url.path.to_sym
-    HTTPI::Response.new(200, {}, Fixture.wsdl(target))
-  end
-
-end

data/spec/support/endpoint.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-class Endpoint
-  class << self
-
-    # Returns the WSDL endpoint for a given +type+ of request.
-    def wsdl(type = nil)
-      case type
-        when :no_namespace       then "http://nons.example.com/Service?wsdl"
-        when :namespaced_actions then "http://nsactions.example.com/Service?wsdl"
-        when :geotrust           then "https://test-api.geotrust.com/webtrust/query.jws?WSDL"
-        else                          soap(type)
-      end
-    end
-
-    # Returns the SOAP endpoint for a given +type+ of request.
-    def soap(type = nil)
-      case type
-        when :soap_fault then "http://soapfault.example.com/Service?wsdl"
-        when :http_error then "http://httperror.example.com/Service?wsdl"
-        when :invalid    then "http://invalid.example.com/Service?wsdl"
-        else                  "http://example.com/validation/1.0/AuthenticationService"
-      end
-    end
-
-  end
-end

data/spec/support/fixture.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-class Fixture
-
-  TYPES = { :gzip => "gz", :response => "xml", :wsdl => "xml" }
-
-  class << self
-
-    def [](type, fixture)
-      fixtures(type)[fixture] ||= read_file type, fixture
-    end
-
-    def response_hash(fixture)
-      @response_hash ||= {}
-      @response_hash[fixture] ||= nori.parse(response(fixture))[:envelope][:body]
-    end
-
-    TYPES.each do |type, ext|
-      define_method(type) { |fixture| self[type, fixture] }
-    end
-
-  private
-
-    def nori
-      Nori.new(:strip_namespaces => true, :convert_tags_to => lambda { |tag| tag.snakecase.to_sym })
-    end
-
-    def fixtures(type)
-      @fixtures ||= {}
-      @fixtures[type] ||= {}
-    end
-
-    def read_file(type, fixture)
-      path = File.expand_path "../../fixtures/#{type}/#{fixture}.#{TYPES[type]}", __FILE__
-      raise ArgumentError, "Unable to load: #{path}" unless File.exist? path
-
-      File.read path
-    end
-
-  end
-end

data/spec/support/integration.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-module SpecSupport
-
-  def call_and_fail_gracefully(client, *args, &block)
-    client.call(*args, &block)
-  rescue Savon::SOAPFault => e
-    puts e.message
-  end
-
-end

data/spec/support/stdout.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-module SpecSupport
-
-  def mock_stdout
-    original_stdout = $stdout
-
-    stdout = StringIO.new
-    $stdout = stdout
-
-    yield
-
-    $stdout = original_stdout
-    stdout
-  end
-
-  def silence_stdout
-    original_stdout = $stdout
-    $stdout = StringIO.new
-
-    result = yield
-
-    $stdout = original_stdout
-    result
-  end
-
-end