savon 2.2.0 → 2.12.1

data/lib/savon/client.rb

@@ -21,7 +21,7 @@ module Savon
       build_wsdl_document
     end
 
-    attr_reader :globals
+    attr_reader :globals, :wsdl
 
     def operations
       raise_missing_wsdl_error! unless @wsdl.document?
@@ -41,6 +41,10 @@ module Savon
       @wsdl.service_name
     end
 
+    def build_request(operation_name, locals = {}, &block)
+      operation(operation_name).request(locals, &block)
+    end
+
     private
 
     def set_globals(globals, block)
@@ -56,7 +60,7 @@ module Savon
       @wsdl.document    = @globals[:wsdl]        if @globals.include? :wsdl
       @wsdl.endpoint    = @globals[:endpoint]    if @globals.include? :endpoint
       @wsdl.namespace   = @globals[:namespace]   if @globals.include? :namespace
-      @wsdl.servicename = @globals[:servicename] if @globals.include? :servicename
+      @wsdl.adapter     = @globals[:adapter]     if @globals.include? :adapter
 
       @wsdl.request = WSDLRequest.new(@globals).build
     end

data/lib/savon/core_ext/string.rb

@@ -1,4 +1,3 @@
-require "savon/soap"
 
 module Savon
   module CoreExt

data/lib/savon/header.rb

@@ -1,41 +1,92 @@
 require "akami"
 require "gyoku"
+require "securerandom"
 
 module Savon
   class Header
 
     def initialize(globals, locals)
-      @globals = globals
-      @locals = locals
-      @wsse = create_wsse
+      @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]
+      @wsse_signature = locals[:wsse_signature].nil? ? globals[:wsse_signature] : locals[:wsse_signature]
+
+      @global_header  = globals[:soap_header]
+      @local_header   = locals[:soap_header]
+
+      @globals        = globals
+      @locals         = locals
+
+      @header = build
     end
 
+    attr_reader :local_header, :global_header, :gyoku_options,
+                :wsse_auth, :wsse_timestamp, :wsse_signature
+
     def empty?
-      to_s.empty?
+      @header.empty?
     end
 
     def to_s
-      return @header if @header
-
-      gyoku_options = { :key_converter => @globals[:convert_request_keys_to] }
-      @header = (Hash === header ? Gyoku.xml(header, gyoku_options) : header) + wsse_header
+      @header
     end
 
     private
 
-    def create_wsse
-      wsse = Akami.wsse
-      wsse.credentials(*@globals[:wsse_auth]) if @globals.include? :wsse_auth
-      wsse.timestamp = @globals[:wsse_timestamp] if @globals.include? :wsse_timestamp
-      wsse
+    def build
+      build_header + build_wsa_header + build_wsse_header
+    end
+
+    def build_header
+      header =
+        if global_header.kind_of?(Hash) && local_header.kind_of?(Hash)
+          global_header.merge(local_header)
+        elsif local_header
+          local_header
+        else
+          global_header
+        end
+
+      convert_to_xml(header)
     end
 
-    def header
-      @header ||= @globals.include?(:soap_header) ? @globals[:soap_header] : {}
+    def build_wsse_header
+      wsse_header = akami
+      wsse_header.respond_to?(:to_xml) ? wsse_header.to_xml : ""
     end
 
-    def wsse_header
-      @wsse.respond_to?(:to_xml) ? @wsse.to_xml : ""
+    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}",
+         attributes!: {
+          'wsa:MessageID' => {
+            "xmlns:wsa" => "http://schemas.xmlsoap.org/ws/2004/08/addressing"
+          }
+         }
+       })
+    end
+
+    def convert_to_xml(hash_or_string)
+      if hash_or_string.kind_of? Hash
+        Gyoku.xml(hash_or_string, gyoku_options)
+      else
+        hash_or_string.to_s
+      end
+    end
+
+    def akami
+      wsse = Akami.wsse
+      wsse.credentials(*wsse_auth) if wsse_auth
+      wsse.timestamp = wsse_timestamp if wsse_timestamp
+      if wsse_signature && wsse_signature.have_document?
+        wsse.signature = wsse_signature
+      end
+
+      wsse
     end
 
   end

data/lib/savon/log_message.rb

@@ -35,13 +35,17 @@ module Savon
     end
 
     def apply_filter!(document, filter)
-      document.xpath("//*[local-name()='#{filter}']").each do |node|
-        node.content = "***FILTERED***"
+      if filter.instance_of? Proc
+        filter.call document
+      else
+        document.xpath("//*[local-name()='#{filter}']").each do |node|
+          node.content = "***FILTERED***"
+        end
       end
     end
 
     def nokogiri_options
-      @pretty_print ? { :indent => 2 } : {}
+      @pretty_print ? { :indent => 2 } : { :save_with => Nokogiri::XML::Node::SaveOptions::AS_XML }
     end
 
   end

data/lib/savon/message.rb

@@ -4,8 +4,8 @@ require "gyoku"
 module Savon
   class Message
 
-    def initialize(operation_name, namespace_identifier, types, used_namespaces, message, element_form_default, key_converter)
-      @operation_name = operation_name
+    def initialize(message_tag, namespace_identifier, types, used_namespaces, message, element_form_default, key_converter, unwrap)
+      @message_tag = message_tag
       @namespace_identifier = namespace_identifier
       @types = types
       @used_namespaces = used_namespaces
@@ -13,22 +13,21 @@ module Savon
       @message = message
       @element_form_default = element_form_default
       @key_converter = key_converter
+      @unwrap = unwrap
     end
 
     def to_s
       return @message.to_s unless @message.kind_of? Hash
 
       if @element_form_default == :qualified
-        translated_operation_name = Gyoku.xml_tag(@operation_name, :key_converter => @key_converter).to_s
-        # XXX: there is no `@request_key_converter` instance variable!
-        #      the third argument is therefore always `nil`. [dh, 2013-03-09]
-        @message = QualifiedMessage.new(@types, @used_namespaces, @request_key_converter).to_hash(@message, [translated_operation_name])
+        @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
+        :key_converter        => @key_converter,
+        :unwrap               => @unwrap
       }
 
       Gyoku.xml(@message, gyoku_options)

data/lib/savon/mock/expectation.rb

@@ -54,7 +54,8 @@ module Savon
     end
 
     def verify_message!
-      unless @expected[:message] == @actual[: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."
 
@@ -62,9 +63,18 @@ module Savon
         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}"
+        "Received a request to the #{@actual[:operation_name].inspect} operation\n#{actual_message}"
       end
     end
 
+    def equals_except_any(msg_expected, msg_real)
+      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))
+        return false if expected_value != msg_real[key]
+      end
+      return true
+    end
   end
 end

data/lib/savon/model.rb

@@ -19,6 +19,10 @@ module Savon
       end
     end
 
+    def all_operations
+      operations(*client.operations)
+    end
+
     private
 
     # Defines a class-level SOAP operation.

data/lib/savon/operation.rb

@@ -3,7 +3,8 @@ require "savon/block_interface"
 require "savon/request"
 require "savon/builder"
 require "savon/response"
-require "savon/log_message"
+require "savon/request_logger"
+require "savon/http_error"
 
 module Savon
   class Operation
@@ -22,6 +23,8 @@ module Savon
         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.new(e.response)
     end
 
     def self.ensure_name_is_symbol!(operation_name)
@@ -35,6 +38,8 @@ module Savon
       @name = name
       @wsdl = wsdl
       @globals = globals
+
+      @logger = RequestLogger.new(globals)
     end
 
     def build(locals = {}, &block)
@@ -46,15 +51,38 @@ module Savon
       builder = build(locals, &block)
 
       response = Savon.notify_observers(@name, builder, @globals, @locals)
-      response ||= call! build_request(builder)
+      response ||= call_with_logging build_request(builder)
 
       raise_expected_httpi_response! unless response.kind_of?(HTTPI::Response)
 
-      Response.new(response, @globals, @locals)
+      create_response(response)
+    end
+
+    def request(locals = {}, &block)
+      builder = build(locals, &block)
+      build_request(builder)
     end
 
     private
 
+    def create_response(response)
+      if multipart_supported?
+        Multipart::Response.new(response, @globals, @locals)
+      else
+        Response.new(response, @globals, @locals)
+      end
+    end
+
+    def multipart_supported?
+      return false unless @globals[:multipart] || @locals[:multipart]
+
+      if Savon.const_defined? :Multipart
+        true
+      else
+        raise 'Unable to find Savon::Multipart. Make sure the savon-multipart gem is installed and loaded.'
+      end
+    end
+
     def set_locals(locals, block)
       locals = LocalOptions.new(locals)
       BlockInterface.new(locals).evaluate(block) if block
@@ -62,18 +90,18 @@ module Savon
       @locals = locals
     end
 
-    def call!(request)
-      log_request(request) if log?
-      response = HTTPI.post(request)
-      log_response(response) if log?
-
-      response
+    def call_with_logging(request)
+      @logger.log(request) { HTTPI.post(request, @globals[:adapter]) }
     end
 
     def build_request(builder)
+      @locals[:soap_action] ||= soap_action
+      @globals[:endpoint] ||= endpoint
+
       request = SOAPRequest.new(@globals).build(
         :soap_action => soap_action,
-        :cookies     => @locals[:cookies]
+        :cookies     => @locals[:cookies],
+        :headers     => @locals[:headers]
       )
 
       request.url = endpoint
@@ -99,34 +127,13 @@ module Savon
     end
 
     def endpoint
-      @globals[:endpoint] || @wsdl.endpoint
-    end
-
-    def log_request(request)
-      logger.info  "SOAP request: #{request.url}"
-      logger.info  headers_to_log(request.headers)
-      logger.debug body_to_log(request.body)
-    end
-
-    def log_response(response)
-      logger.info  "SOAP response (status #{response.code})"
-      logger.debug body_to_log(response.body)
-    end
-
-    def headers_to_log(headers)
-      headers.map { |key, value| "#{key}: #{value}" }.join(", ")
-    end
-
-    def body_to_log(body)
-      LogMessage.new(body, @globals[:filters], @globals[:pretty_print_xml]).to_s
-    end
-
-    def logger
-      @globals[:logger]
-    end
-
-    def log?
-      @globals[:log]
+      @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
 
     def raise_expected_httpi_response!

data/lib/savon/options.rb

@@ -35,25 +35,63 @@ module Savon
     def method_missing(option, _)
       raise UnknownOptionError, "Unknown #{option_type} option: #{option.inspect}"
     end
+  end
+
+  module SharedOptions
+    # WSSE auth credentials for Akami.
+    # Local will override the global wsse_auth value, e.g.
+    #   global == [user, pass] && local == [user2, pass2] => [user2, pass2]
+    #   global == [user, pass] && local == false => false
+    #   global == [user, pass] && local == nil   => [user, pass]
+    def wsse_auth(*credentials)
+      credentials.flatten!
+      if credentials.size == 1
+        @options[:wsse_auth] = credentials.first
+      else
+        @options[:wsse_auth] = credentials
+      end
+    end
+
+    # Instruct Akami to enable wsu:Timestamp headers.
+    # Local will override the global wsse_timestamp value, e.g.
+    #   global == true && local == true  => true
+    #   global == true && local == false => false
+    #   global == true && local == nil   => true
+    def wsse_timestamp(timestamp = true)
+      @options[:wsse_timestamp] = timestamp
+    end
 
+    def wsse_signature(signature)
+      @options[:wsse_signature] = signature
+    end
   end
 
   class GlobalOptions < Options
+    include SharedOptions
 
     def initialize(options = {})
       @option_type = :global
 
       defaults = {
-        :encoding                  => "UTF-8",
-        :soap_version              => 1,
-        :namespaces                => {},
-        :logger                    => Logger.new($stdout),
-        :log                       => true,
-        :filters                   => [],
-        :pretty_print_xml          => false,
-        :raise_errors              => true,
-        :strip_namespaces          => true,
-        :convert_response_tags_to  => lambda { |tag| tag.snakecase.to_sym }
+        :encoding                    => "UTF-8",
+        :soap_version                => 1,
+        :namespaces                  => {},
+        :logger                      => Logger.new($stdout),
+        :log                         => false,
+        :filters                     => [],
+        :pretty_print_xml            => false,
+        :raise_errors                => true,
+        :strip_namespaces            => true,
+        :delete_namespace_attributes => false,
+        :convert_response_tags_to    => lambda { |tag| tag.snakecase.to_sym},
+        :convert_attributes_to       => lambda { |k,v| [k,v] },
+        :multipart                   => false,
+        :adapter                     => nil,
+        :use_wsa_headers             => false,
+        :no_message_tag              => false,
+        :follow_redirects            => false,
+        :unwrap                      => false,
+        :host                        => nil
       }
 
       options = defaults.merge(options)
@@ -72,6 +110,11 @@ module Savon
       @options[:wsdl] = wsdl_address
     end
 
+    # set different host for actions in WSDL
+    def host(host)
+      @options[:host] = host
+    end
+
     # SOAP endpoint.
     def endpoint(endpoint)
       @options[:endpoint] = endpoint
@@ -94,7 +137,7 @@ module Savon
 
     # Proxy server to use for all requests.
     def proxy(proxy)
-      @options[:proxy] = proxy
+      @options[:proxy] = proxy unless proxy.nil?
     end
 
     # A Hash of HTTP headers.
@@ -117,12 +160,12 @@ module Savon
       @options[:encoding] = encoding
     end
 
-    # The global SOAP header. Expected to be a Hash.
+    # The global SOAP header. Expected to be a Hash or responding to #to_s.
     def soap_header(header)
       @options[:soap_header] = header
     end
 
-    # Sets whether elements should be :qualified or unqualified.
+    # Sets whether elements should be :qualified or :unqualified.
     # If you need to use this option, please open an issue and make
     # sure to add your WSDL document for debugging.
     def element_form_default(element_form_default)
@@ -154,6 +197,7 @@ module Savon
 
     # The logger to use. Defaults to a Savon::Logger instance.
     def logger(logger)
+      HTTPI.logger = logger
       @options[:logger] = logger
     end
 
@@ -194,6 +238,11 @@ module Savon
       @options[:ssl_cert_key_file] = file
     end
 
+    # Sets the cert key to use.
+    def ssl_cert_key(key)
+      @options[:ssl_cert_key] = key
+    end
+
     # Sets the cert key password to use.
     def ssl_cert_key_password(password)
       @options[:ssl_cert_key_password] = password
@@ -204,11 +253,35 @@ module Savon
       @options[:ssl_cert_file] = file
     end
 
+    # Sets the cert to use.
+    def ssl_cert(cert)
+      @options[:ssl_cert] = cert
+    end
+
     # Sets the ca cert file to use.
     def ssl_ca_cert_file(file)
       @options[:ssl_ca_cert_file] = file
     end
 
+    # Sets the ca cert to use.
+    def ssl_ca_cert(cert)
+      @options[:ssl_ca_cert] = cert
+    end
+
+    def ssl_ciphers(ciphers)
+      @options[:ssl_ciphers] = ciphers
+    end
+
+    # Sets the ca cert path.
+    def ssl_ca_cert_path(path)
+      @options[:ssl_ca_cert_path] = path
+    end
+
+    # Sets the ssl cert store.
+    def ssl_cert_store(store)
+      @options[:ssl_cert_store] = store
+    end
+
     # HTTP basic auth credentials.
     def basic_auth(*credentials)
       @options[:basic_auth] = credentials.flatten
@@ -219,14 +292,9 @@ module Savon
       @options[:digest_auth] = credentials.flatten
     end
 
-    # WSSE auth credentials for Akami.
-    def wsse_auth(*credentials)
-      @options[:wsse_auth] = credentials.flatten
-    end
-
-    # Instruct Akami to enable wsu:Timestamp headers.
-    def wsse_timestamp(*timestamp)
-      @options[:wsse_timestamp] = timestamp.flatten
+    # NTLM auth credentials.
+    def ntlm(*credentials)
+      @options[:ntlm] = credentials.flatten
     end
 
     # Instruct Nori whether to strip namespaces from XML nodes.
@@ -234,33 +302,84 @@ module Savon
       @options[:strip_namespaces] = strip_namespaces
     end
 
+    # Instruct Nori whether to delete namespace attributes from XML nodes.
+    def delete_namespace_attributes(delete_namespace_attributes)
+      @options[:delete_namespace_attributes] = delete_namespace_attributes
+    end
+
     # Tell Gyoku how to convert Hash key Symbols to XML tags.
     # Accepts one of :lower_camelcase, :camelcase, :upcase, or :none.
     def convert_request_keys_to(converter)
       @options[:convert_request_keys_to] = converter
     end
 
+    # Tell Gyoku to unwrap Array of Hashes
+    # Accepts a boolean, default to false
+    def unwrap(unwrap)
+      @options[:unwrap] = unwrap
+    end
+
     # Tell Nori how to convert XML tags from the SOAP response into Hash keys.
     # Accepts a lambda or a block which receives an XML tag and returns a Hash key.
     # Defaults to convert tags to snakecase Symbols.
     def convert_response_tags_to(converter = nil, &block)
       @options[:convert_response_tags_to] = block || converter
     end
+
+    # Tell Nori how to convert XML attributes on tags from the SOAP response into Hash keys.
+    # Accepts a lambda or a block which receives an XML tag and returns a Hash key.
+    # Defaults to doing nothing
+    def convert_attributes_to(converter = nil, &block)
+      @options[:convert_attributes_to] = block || converter
+    end
+
+    # Instruct Savon to create a multipart response if available.
+    def multipart(multipart)
+      @options[:multipart] = multipart
+    end
+
+    # Instruct Savon what HTTPI adapter it should use instead of default
+    def adapter(adapter)
+      @options[:adapter] = adapter
+    end
+
+    # Enable inclusion of WS-Addressing headers.
+    def use_wsa_headers(use)
+      @options[:use_wsa_headers] = use
+    end
+
+    def no_message_tag(bool)
+      @options[:no_message_tag] = bool
+    end
+
+    # Instruct requests to follow HTTP redirects.
+    def follow_redirects(follow_redirects)
+      @options[:follow_redirects] = follow_redirects
+    end
   end
 
   class LocalOptions < Options
+    include SharedOptions
 
     def initialize(options = {})
       @option_type = :local
 
       defaults = {
         :advanced_typecasting => true,
-        :response_parser      => :nokogiri
+        :response_parser      => :nokogiri,
+        :multipart            => false
       }
 
       super defaults.merge(options)
     end
 
+    # The local SOAP header. Expected to be a Hash or respond to #to_s.
+    # Will be merged with the global SOAP header if both are Hashes.
+    # Otherwise the local option will be prefered.
+    def soap_header(header)
+      @options[:soap_header] = header
+    end
+
     # The SOAP message to send. Expected to be a Hash or a String.
     def message(message)
       @options[:message] = message
@@ -302,5 +421,13 @@ module Savon
       @options[:response_parser] = parser
     end
 
+    # Instruct Savon to create a multipart response if available.
+    def multipart(multipart)
+      @options[:multipart] = multipart
+    end
+
+    def headers(headers)
+      @options[:headers] = headers
+    end
   end
 end