savon 2.17.2 → 3.0.0.rc1

data/lib/savon/header.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
-
 require "akami"
 require "gyoku"
 require "securerandom"
 
 module Savon
   class Header
+
     def initialize(globals, locals)
-      @gyoku_options  = { key_converter: globals[:convert_request_keys_to] }
+      @gyoku_options  = { :key_converter => globals[:convert_request_keys_to] }
 
       @wsse_auth      = locals[:wsse_auth].nil? ? globals[:wsse_auth] : locals[:wsse_auth]
       @wsse_timestamp = locals[:wsse_timestamp].nil? ? globals[:wsse_timestamp] : locals[:wsse_timestamp]
@@ -41,7 +41,7 @@ module Savon
 
     def build_header
       header =
-        if global_header.is_a?(Hash) && local_header.is_a?(Hash)
+        if global_header.kind_of?(Hash) && local_header.kind_of?(Hash)
           global_header.merge(local_header)
         elsif local_header
           local_header
@@ -58,17 +58,16 @@ module Savon
     end
 
     def build_wsa_header
-      return '' unless @globals[:use_wsa_headers]
-
-      convert_to_xml({
-        'wsa:Action'    => @locals[:soap_action],
-        'wsa:To'        => @globals[:endpoint],
-        'wsa:MessageID' => "urn:uuid:#{SecureRandom.uuid}"
-      })
+       return '' unless @globals[:use_wsa_headers]
+       convert_to_xml({
+         'wsa:Action' => @locals[:soap_action],
+         'wsa:To' => @globals[:endpoint],
+         'wsa:MessageID' => "urn:uuid:#{SecureRandom.uuid}"
+       })
     end
 
     def convert_to_xml(hash_or_string)
-      if hash_or_string.is_a? Hash
+      if hash_or_string.kind_of? Hash
         Gyoku.xml(hash_or_string, gyoku_options)
       else
         hash_or_string.to_s
@@ -79,11 +78,12 @@ module Savon
       wsse = Akami.wsse
       wsse.credentials(*wsse_auth) if wsse_auth
       wsse.timestamp = wsse_timestamp if wsse_timestamp
-      if wsse_signature&.have_document?
+      if wsse_signature && wsse_signature.have_document?
         wsse.signature = wsse_signature
       end
 
       wsse
     end
+
   end
 end

data/lib/savon/http_error.rb

@@ -2,8 +2,9 @@
 
 module Savon
   class HTTPError < Error
+
     def self.present?(http)
-      http.error?
+      !http.success?
     end
 
     def initialize(http)
@@ -13,13 +14,14 @@ module Savon
     attr_reader :http
 
     def to_s
-      String.new("HTTP error (#{@http.code})").tap do |str_error|
+      String.new("HTTP error (#{@http.status})").tap do |str_error|
         str_error << ": #{@http.body}" unless @http.body.empty?
       end
     end
 
     def to_hash
-      { code: @http.code, headers: @http.headers, body: @http.body }
+      { :code => @http.status, :headers => @http.headers, :body => @http.body }
     end
+
   end
 end

data/lib/savon/log_message.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
-
 require "nokogiri"
 
 module Savon
   class LogMessage
+
     def initialize(message, filters = [], pretty_print = false)
       @message      = message
       @filters      = filters
@@ -46,7 +46,8 @@ module Savon
     end
 
     def nokogiri_options
-      @pretty_print ? { indent: 2 } : { save_with: Nokogiri::XML::Node::SaveOptions::AS_XML }
+      @pretty_print ? { :indent => 2 } : { :save_with => Nokogiri::XML::Node::SaveOptions::AS_XML }
     end
+
   end
 end

data/lib/savon/message.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
-
 require "savon/qualified_message"
 require "gyoku"
 
 module Savon
   class Message
+
     def initialize(message_tag, namespace_identifier, types, used_namespaces, message, element_form_default, key_converter, unwrap)
       @message_tag = message_tag
       @namespace_identifier = namespace_identifier
@@ -18,20 +18,21 @@ module Savon
     end
 
     def to_s
-      return @message.to_s unless @message.is_a? Hash
+      return @message.to_s unless @message.kind_of? Hash
 
       if @element_form_default == :qualified
         @message = QualifiedMessage.new(@types, @used_namespaces, @key_converter).to_hash(@message, [@message_tag.to_s])
       end
 
       gyoku_options = {
-        element_form_default: @element_form_default,
-        namespace: @namespace_identifier,
-        key_converter: @key_converter,
-        unwrap: @unwrap
+        :element_form_default => @element_form_default,
+        :namespace            => @namespace_identifier,
+        :key_converter        => @key_converter,
+        :unwrap               => @unwrap
       }
 
       Gyoku.xml(@message, gyoku_options)
     end
+
   end
 end

data/lib/savon/mock/expectation.rb

@@ -1,18 +1,11 @@
 # frozen_string_literal: true
-
-require "httpi"
-require "savon/transport/response"
+require "faraday"
 
 module Savon
-  # A single test expectation set up by Savon's mock interface.
-  # One expectation covers one operation call in one test.
-  #
-  # Records the expected operation name and message, captures what was
-  # actually called, and either returns a synthetic response or raises
-  # an error on mismatch.
   class MockExpectation
+
     def initialize(operation_name)
-      @expected = { operation_name: operation_name }
+      @expected = { :operation_name => operation_name }
       @actual = nil
     end
 
@@ -22,15 +15,15 @@ module Savon
     end
 
     def returns(response)
-      response = { code: 200, headers: {}, body: response } if response.is_a?(String)
+      response = { :code => 200, :headers => {}, :body => response } if response.kind_of?(String)
       @response = response
       self
     end
 
-    def actual(operation_name, _builder, _globals, locals)
+    def actual(operation_name, builder, globals, locals)
       @actual = {
-        operation_name: operation_name,
-        message: locals[:message]
+        :operation_name => operation_name,
+        :message        => locals[:message]
       }
     end
 
@@ -44,49 +37,42 @@ module Savon
       verify_message!
     end
 
-    # Builds and returns a Transport::Response from the configured response hash.
-    #
-    # @return [Transport::Response]
-    # @raise  [ExpectationError] if no response was configured for this expectation
     def response!
       unless @response
         raise ExpectationError, "This expectation was not set up with a response."
       end
-
-      Transport::Response.new(@response[:code], @response[:headers], @response[:body])
+      env = Faraday::Env.from(status: @response[:code], response_headers: @response[:headers], response_body: @response[:body])
+      Faraday::Response.new(env)
     end
 
     private
 
     def verify_operation_name!
-      return if @expected[:operation_name] == @actual[:operation_name]
-
-      raise ExpectationError, "Expected a request to the #{@expected[:operation_name].inspect} operation.\n" \
-                              "Received a request to the #{@actual[:operation_name].inspect} operation instead."
+      unless @expected[:operation_name] == @actual[:operation_name]
+        raise ExpectationError, "Expected a request to the #{@expected[:operation_name].inspect} operation.\n" \
+                                "Received a request to the #{@actual[:operation_name].inspect} operation instead."
+      end
     end
 
     def verify_message!
       return if @expected[:message].eql? :any
+      unless equals_except_any(@expected[:message], @actual[:message])
+        expected_message = "  with this message: #{@expected[:message].inspect}" if @expected[:message]
+        expected_message ||= "  with no message."
 
-      return if equals_except_any(@expected[:message], @actual[:message])
+        actual_message = "  with this message: #{@actual[:message].inspect}" if @actual[:message]
+        actual_message ||= "  with no message."
 
-      expected_message = "  with this message: #{@expected[:message].inspect}" if @expected[:message]
-      expected_message ||= "  with no message."
-
-      actual_message = "  with this message: #{@actual[:message].inspect}" if @actual[:message]
-      actual_message ||= "  with no message."
-
-      raise ExpectationError, "Expected a request to the #{@expected[:operation_name].inspect} operation\n#{expected_message}\n" \
-      "Received a request to the #{@actual[:operation_name].inspect} operation\n#{actual_message}"
+        raise ExpectationError, "Expected a request to the #{@expected[:operation_name].inspect} operation\n#{expected_message}\n" \
+        "Received a request to the #{@actual[:operation_name].inspect} operation\n#{actual_message}"
+      end
     end
 
     def equals_except_any(msg_expected, msg_real)
-      # === allows RSpec matchers (e.g. include(:key)) to be used as expected values
-      return true if msg_expected === msg_real # rubocop:disable Style/CaseEquality
-      return false if msg_expected.nil? || msg_real.nil? # If both are nil has returned true
-
+      return true if msg_expected === msg_real
+      return false if (msg_expected.nil? || msg_real.nil?) # If both are nil has returned true
       msg_expected.each do |key, expected_value|
-        next if expected_value == :any && msg_real.include?(key)
+        next if (expected_value == :any &&  msg_real.include?(key))
         return false if expected_value != msg_real[key]
       end
       true

data/lib/savon/mock/spec_helper.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
-
 require "savon/mock"
 
 module Savon
   module SpecHelper
+
     class Interface
+
       def mock!
         Savon.observers << self
       end
@@ -26,12 +27,14 @@ module Savon
       def notify(operation_name, builder, globals, locals)
         expectation = expectations.shift
 
-        raise ExpectationError, "Unexpected request to the #{operation_name.inspect} operation." unless expectation
-
-        expectation.actual(operation_name, builder, globals, locals)
+        if expectation
+          expectation.actual(operation_name, builder, globals, locals)
 
-        expectation.verify!
-        expectation.response!
+          expectation.verify!
+          expectation.response!
+        else
+          raise ExpectationError, "Unexpected request to the #{operation_name.inspect} operation."
+        end
       rescue ExpectationError
         @expectations.clear
         raise
@@ -39,12 +42,12 @@ module Savon
 
       def verify!
         return if expectations.empty?
-
         expectations.each(&:verify!)
       rescue ExpectationError
         @expectations.clear
         raise
       end
+
     end
 
     def savon
@@ -55,5 +58,6 @@ module Savon
       super if defined? super
       savon.verify!
     end
+
   end
 end

data/lib/savon/mock.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 module Savon
   class ExpectationError < StandardError; end
 end

data/lib/savon/model.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
-
 module Savon
   module Model
+
     def self.extended(base)
       base.setup
     end
@@ -28,30 +28,26 @@ module Savon
 
     # Defines a class-level SOAP operation.
     def define_class_operation(operation)
-      method_name = operation_method_name(operation)
-
-      class_operation_module.define_method(method_name) do |locals = {}|
-        client.call operation, locals
-      end
+      class_operation_module.module_eval %{
+        def #{StringUtils.snakecase(operation.to_s)}(locals = {})
+          client.call #{operation.inspect}, locals
+        end
+      }
     end
 
     # Defines an instance-level SOAP operation.
     def define_instance_operation(operation)
-      method_name = operation_method_name(operation)
-
-      instance_operation_module.define_method(method_name) do |locals = {}|
-        self.class.public_send(method_name, locals)
-      end
-    end
-
-    # Returns the generated Ruby method name for a SOAP operation.
-    def operation_method_name(operation)
-      StringUtils.snakecase(operation.to_s).to_sym
+      instance_operation_module.module_eval %{
+        def #{StringUtils.snakecase(operation.to_s)}(locals = {})
+          self.class.#{StringUtils.snakecase(operation.to_s)} locals
+        end
+      }
     end
 
     # Class methods.
     def class_operation_module
-      @class_operation_module ||= Module.new do
+      @class_operation_module ||= Module.new {
+
         def client(globals = {})
           @client ||= Savon::Client.new(globals)
         rescue InitializationError
@@ -64,22 +60,26 @@ module Savon
 
         def raise_initialization_error!
           raise InitializationError,
-                "Expected the model to be initialized with either a WSDL document or the SOAP endpoint and target namespace options.\n" \
-                "Make sure to setup the model by calling the .client class method before calling the .global method.\n\n" \
-                "client(wsdl: '/Users/me/project/service.wsdl')                              # to use a local WSDL document\n" \
-                "client(wsdl: 'http://example.com?wsdl')                                     # to use a remote WSDL document\n" \
-                "client(endpoint: 'http://example.com', namespace: 'http://v1.example.com')  # if you don't have a WSDL document"
+            "Expected the model to be initialized with either a WSDL document or the SOAP endpoint and target namespace options.\n" \
+            "Make sure to setup the model by calling the .client class method before calling the .global method.\n\n" \
+            "client(wsdl: '/Users/me/project/service.wsdl')                              # to use a local WSDL document\n" \
+            "client(wsdl: 'http://example.com?wsdl')                                     # to use a remote WSDL document\n" \
+            "client(endpoint: 'http://example.com', namespace: 'http://v1.example.com')  # if you don't have a WSDL document"
         end
-      end.tap { |mod| extend(mod) }
+
+      }.tap { |mod| extend(mod) }
     end
 
     # Instance methods.
     def instance_operation_module
-      @instance_operation_module ||= Module.new do
+      @instance_operation_module ||= Module.new {
+
         def client
           self.class.client
         end
-      end.tap { |mod| include(mod) }
+
+      }.tap { |mod| include(mod) }
     end
+
   end
 end

data/lib/savon/operation.rb

@@ -1,42 +1,30 @@
 # frozen_string_literal: true
-
 require "savon/options"
 require "savon/block_interface"
+require "savon/request"
 require "savon/builder"
 require "savon/response"
+require "savon/request_logger"
 require "savon/http_error"
-require "savon/transport/httpi"
-require "savon/transport/faraday"
 require "mail"
+require 'faraday/gzip'
+
 
 module Savon
-  # Represents a single named SOAP operation.
-  #
-  # Bridges the SOAP layer (envelope building, action headers, multipart) and the
-  # transport layer (execution, logging). Knows nothing about transport internals
-  # such as proxy, SSL, or auth.
   class Operation
-    # SOAP Content-Type values indexed by SOAP version.
-    # SOAP 1.1 §6 (HTTP binding), SOAP 1.2 Part 2 §7.1.4 (HTTP media type)
-    CONTENT_TYPE = {
-      1 => "text/xml;charset=%s",
-      2 => "application/soap+xml;charset=%s"
-    }.freeze
-
-    # Maps SOAP version to the base MIME type used in multipart requests.
-    # RFC 2387 §3.1 (multipart/related Content-Type parameter)
+
     SOAP_REQUEST_TYPE = {
       1 => "text/xml",
       2 => "application/soap+xml"
-    }.freeze
+    }
 
-    def self.create(operation_name, wsdl, globals, transport)
+    def self.create(operation_name, wsdl, globals)
       if wsdl.document?
         ensure_name_is_symbol! operation_name
         ensure_exists! operation_name, wsdl
       end
 
-      new(operation_name, wsdl, globals, transport)
+      new(operation_name, wsdl, globals)
     end
 
     def self.ensure_exists!(operation_name, wsdl)
@@ -45,21 +33,22 @@ module Savon
                                      "Operations provided by your service: #{wsdl.soap_actions.inspect}"
       end
     rescue Wasabi::Resolver::HTTPError => e
-      raise HTTPError, e.response
+      raise HTTPError.new(e.response)
     end
 
     def self.ensure_name_is_symbol!(operation_name)
-      return if operation_name.is_a? Symbol
-
-      raise ArgumentError, "Expected the first parameter (the name of the operation to call) to be a symbol\n" \
-                           "Actual: #{operation_name.inspect} (#{operation_name.class})"
+      unless operation_name.kind_of? Symbol
+        raise ArgumentError, "Expected the first parameter (the name of the operation to call) to be a symbol\n" \
+                             "Actual: #{operation_name.inspect} (#{operation_name.class})"
+      end
     end
 
-    def initialize(name, wsdl, globals, transport)
-      @name      = name
-      @wsdl      = wsdl
-      @globals   = globals
-      @transport = transport
+    def initialize(name, wsdl, globals)
+      @name = name
+      @wsdl = wsdl
+      @globals = globals
+
+      @logger = RequestLogger.new(globals)
     end
 
     def build(locals = {}, &block)
@@ -67,41 +56,24 @@ module Savon
       Builder.new(@name, @wsdl, @globals, @locals)
     end
 
-    # Executes the SOAP operation and returns a Savon::Response.
-    #
-    # Observer short-circuit: if any registered observer returns a
-    # Transport::Response (or legacy HTTPI::Response), the HTTP call
-    # is skipped and that response is used directly.
     def call(locals = {}, &block)
-      builder  = build(locals, &block)
+      builder = build(locals, &block)
+
       response = Savon.notify_observers(@name, builder, @globals, @locals)
+      response ||= call_with_logging build_connection(builder)
 
-      response =
-        if response.nil?
-          body = builder.to_s
-          headers = soap_headers(builder)
-          @transport.post(endpoint.to_s, headers, body, @locals)
-        else
-          normalize_observer_response(response)
-        end
+      raise_expected_faraday_response! unless response.kind_of?(Faraday::Response)
 
       create_response(response)
     end
 
-    # Builds and returns the HTTPI::Request that would be sent for this
-    # operation, without executing it. Useful for inspection and debugging.
-    # Not supported with transport: :faraday.
     def request(locals = {}, &block)
-      if @globals[:transport] == :faraday
-        raise ArgumentError, "#request returns an HTTPI::Request and is not supported " \
-                             "with transport: :faraday. Use client.faraday to configure " \
-                             "the connection"
-      end
-
       builder = build(locals, &block)
-      # Build the body before soap_headers - see #call.
-      body = builder.to_s
-      @transport.to_httpi_request(endpoint.to_s, soap_headers(builder), body, @locals)
+      connection = build_connection(builder)
+      connection.build_request(:post) do |req|
+        req.url(@globals[:endpoint])
+        req.body = @locals[:body]
+      end
     end
 
     private
@@ -117,33 +89,47 @@ module Savon
       @locals = locals
     end
 
-    # Assembles the SOAP-level request headers for the given builder.
-    #
-    # Our responsibility regardless of transport:
-    #   * Content-Type (SOAP 1.1 §6 / SOAP 1.2 Part 2 §7.1.4)
-    #   * SOAPAction (SOAP 1.1 §6.1.1)
-    #   * Multipart Content-Type (RFC 2387), MIME-Version (RFC 2045 §4), Accept-Encoding (RFC 9110 §12.5.3)
-    def soap_headers(builder)
-      headers = {}
-
-      if builder.multipart
-        # RFC 2387 §3 (multipart/related) - SOAP envelope is the root body part
-        headers["Content-Type"] = [
-          "multipart/related",
-          "type=\"#{SOAP_REQUEST_TYPE[@globals[:soap_version]]}\"",
-          "start=\"#{builder.multipart[:start]}\"",
-          "boundary=\"#{builder.multipart[:multipart_boundary]}\""
-        ].join("; ")
-        headers["MIME-Version"] = "1.0"
-        headers["Accept-Encoding"] = "gzip,deflate"
-      else
-        headers["Content-Type"] = CONTENT_TYPE[@globals[:soap_version]] % @globals[:encoding]
+    def call_with_logging(connection)
+      ntlm_auth = handle_ntlm(connection) if @globals.include?(:ntlm)
+      @logger.log_response(connection.post(@globals[:endpoint]) { |request|
+        request.body = @locals[:body]
+        request.headers['Authorization'] = "NTLM #{auth.encode64}" if ntlm_auth
+        @logger.log_request(request)
+      })
+    end
+
+    def handle_ntlm(connection)
+      ntlm_message = Net::NTLM::Message
+      response = connection.get(@globals[:endpoint]) do |request|
+        request.headers['Authorization'] = 'NTLM ' + ntlm_message::Type1.new.encode64
+      end
+      challenge = response.headers['www-authenticate'][/(?:NTLM|Negotiate) (.*)$/, 1]
+      message = ntlm_message::Type2.decode64(challenge)
+      message.response([:user, :password, :domain].zip(@globals[:ntlm]).to_h)
+    end
+
+    def build_connection(builder)
+      @globals[:endpoint] ||= endpoint
+      @locals[:soap_action] ||= soap_action
+      @locals[:body] = builder.to_s
+      @connection = SOAPRequest.new(@globals).build(
+        :soap_action => soap_action,
+        :cookies     => @locals[:cookies],
+        :headers     => @locals[:headers]
+      ) do |connection|
+        if builder.multipart
+          connection.request :gzip
+          connection.headers["Content-Type"] = %W[multipart/related
+                                                  type="#{SOAP_REQUEST_TYPE[@globals[:soap_version]]}",
+                                                  start="#{builder.multipart[:start]}",
+                                                  boundary="#{builder.multipart[:multipart_boundary]}"].join("; ")
+          connection.headers["MIME-Version"] = "1.0"
+        end
+
+        connection.headers["Content-Length"] = @locals[:body].bytesize.to_s
       end
 
-      action = soap_action
-      headers["SOAPAction"] = %("#{action}") if action
 
-      headers
     end
 
     def soap_action
@@ -152,10 +138,10 @@ module Savon
 
       # get the soap_action from local options
       @locals[:soap_action] ||
-        # with no local option, but a wsdl, ask it for the soap_action
-        @wsdl.document? && @wsdl.soap_action(@name.to_sym) ||
-        # if there is no soap_action up to this point, fallback to a simple default
-        Gyoku.xml_tag(@name, key_converter: @globals[:convert_request_keys_to])
+      # with no local option, but a wsdl, ask it for the soap_action
+      @wsdl.document? && @wsdl.soap_action(@name.to_sym) ||
+      # if there is no soap_action up to this point, fallback to a simple default
+      Gyoku.xml_tag(@name, :key_converter => @globals[:convert_request_keys_to])
     end
 
     def endpoint
@@ -168,26 +154,10 @@ module Savon
       end
     end
 
-    # Normalizes an observer return value into a Transport::Response.
-    #
-    # Accepts Transport::Response directly (current contract), wraps
-    # HTTPI::Response with a deprecation warning (legacy observer support),
-    # and raises on anything else.
-    def normalize_observer_response(response)
-      return response if response.is_a?(Transport::Response)
-
-      if response.is_a?(HTTPI::Response)
-        warn "Observers returning HTTPI::Response is deprecated - return Savon::Transport::Response instead.", uplevel: 1
-        return Transport::Response.new(
-          response.code,
-          response.headers,
-          response.body,
-          cookies: HTTPI::Cookie.list_from_headers(response.headers)
-        )
-      end
-
-      raise Error, "Observers need to return a Savon::Transport::Response " \
-                   "to mock the request or nil to execute the request."
+    def raise_expected_faraday_response!
+      raise Error, "Observers need to return a Faraday::Response to mock " \
+                   "the request or nil to execute the request."
     end
+
   end
 end