savon 2.17.4 → 3.0.0.rc1

data/lib/savon/operation.rb

@@ -1,67 +1,54 @@
 # frozen_string_literal: true
-
 require "savon/options"
-require "savon/effective_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, transport
+        ensure_exists! operation_name, wsdl
       end
 
-      new(operation_name, wsdl, globals, transport)
+      new(operation_name, wsdl, globals)
     end
 
-    # Verifies the operation is provided by the WSDL.
-    def self.ensure_exists!(operation_name, wsdl, transport)
+    def self.ensure_exists!(operation_name, wsdl)
       unless wsdl.soap_actions.include? operation_name
         raise UnknownOperationError, "Unable to find SOAP operation: #{operation_name.inspect}\n" \
                                      "Operations provided by your service: #{wsdl.soap_actions.inspect}"
       end
     rescue Wasabi::Resolver::HTTPError => e
-      raise HTTPError, transport.normalize_response(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)
@@ -69,45 +56,32 @@ 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)
-      observer_response = Savon.notify_observers(@name, builder, @globals, @locals)
-
-      transport_response =
-        if observer_response.nil?
-          body = builder.to_s
-          headers = soap_headers(builder)
-          @transport.post(endpoint.to_s, headers, body, @locals)
-        else
-          normalize_observer_response(observer_response)
-        end
 
-      Response.new(transport_response, @globals, @locals)
+      response = Savon.notify_observers(@name, builder, @globals, @locals)
+      response ||= call_with_logging build_connection(builder)
+
+      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
 
+    def create_response(response)
+      Response.new(response, @globals, @locals)
+    end
+
     def set_locals(locals, block)
       locals = LocalOptions.new(locals)
       BlockInterface.new(locals).evaluate(block) if block
@@ -115,69 +89,75 @@ module Savon
       @locals = locals
     end
 
-    # The effective options view for the current request. Built on demand
-    # instead of being cached, so it always reflects the current per-request
-    # options.
-    def effective_options
-      EffectiveOptions.new(@name, @wsdl, @globals, @locals)
+    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
 
-    # 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 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
 
-    # The resolved SOAPAction of the request, used for the HTTP header.
-    # {Savon::EffectiveOptions#soap_action} owns the precedence rules.
     def soap_action
-      effective_options.soap_action
+      # soap_action explicitly set to something falsy
+      return if @locals.include?(:soap_action) && !@locals[:soap_action]
+
+      # 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])
     end
 
-    # The resolved endpoint URL the request is sent to.
-    # {Savon::EffectiveOptions#endpoint} owns the precedence rules.
     def endpoint
-      effective_options.endpoint
-    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(observer_response)
-      return observer_response if observer_response.is_a?(Transport::Response)
-
-      if observer_response.is_a?(HTTPI::Response)
-        warn "Observers returning HTTPI::Response is deprecated - return Savon::Transport::Response instead.", uplevel: 1
-        return Transport::Response.from_httpi(observer_response)
+      @globals[:endpoint] || @wsdl.endpoint.tap do |url|
+        if @globals[:host]
+          host_url = URI.parse(@globals[:host])
+          url.host = host_url.host
+          url.port = host_url.port
+        end
       end
+    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