savon-ng-1.6 2.4.0

data/lib/savon/mock/expectation.rb

@@ -0,0 +1,71 @@
+require "httpi"
+
+module Savon
+  class MockExpectation
+
+    def initialize(operation_name)
+      @expected = { :operation_name => operation_name }
+      @actual = nil
+    end
+
+    def with(locals)
+      @expected[:message] = locals[:message]
+      self
+    end
+
+    def returns(response)
+      response = { :code => 200, :headers => {}, :body => response } if response.kind_of?(String)
+      @response = response
+      self
+    end
+
+    def actual(operation_name, builder, globals, locals)
+      @actual = {
+        :operation_name => operation_name,
+        :message        => locals[:message]
+      }
+    end
+
+    def verify!
+      unless @actual
+        raise ExpectationError, "Expected a request to the #{@expected[:operation_name].inspect} operation, " \
+                                "but no request was executed."
+      end
+
+      verify_operation_name!
+      verify_message!
+    end
+
+    def response!
+      unless @response
+        raise ExpectationError, "This expectation was not set up with a response."
+      end
+
+      HTTPI::Response.new(@response[:code], @response[:headers], @response[:body])
+    end
+
+    private
+
+    def verify_operation_name!
+      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] == :any
+      unless @expected[:message] == @actual[: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}"
+      end
+    end
+
+  end
+end

data/lib/savon/mock/spec_helper.rb

@@ -0,0 +1,62 @@
+require "savon/mock"
+
+module Savon
+  module SpecHelper
+
+    class Interface
+
+      def mock!
+        Savon.observers << self
+      end
+
+      def unmock!
+        Savon.observers.clear
+      end
+
+      def expects(operation_name)
+        expectation = MockExpectation.new(operation_name)
+        expectations << expectation
+        expectation
+      end
+
+      def expectations
+        @expectations ||= []
+      end
+
+      def notify(operation_name, builder, globals, locals)
+        expectation = expectations.shift
+
+        if expectation
+          expectation.actual(operation_name, builder, globals, locals)
+
+          expectation.verify!
+          expectation.response!
+        else
+          raise ExpectationError, "Unexpected request to the #{operation_name.inspect} operation."
+        end
+      rescue ExpectationError
+        @expectations.clear
+        raise
+      end
+
+      def verify!
+        return if expectations.empty?
+        expectations.each(&:verify!)
+      rescue ExpectationError
+        @expectations.clear
+        raise
+      end
+
+    end
+
+    def savon
+      @savon ||= Interface.new
+    end
+
+    def verify_mocks_for_rspec
+      super if defined? super
+      savon.verify!
+    end
+
+  end
+end

data/lib/savon/mock.rb

@@ -0,0 +1,5 @@
+module Savon
+  class ExpectationError < StandardError; end
+end
+
+require "savon/mock/expectation"

data/lib/savon/model.rb

@@ -0,0 +1,80 @@
+module Savon
+  module Model
+
+    def self.extended(base)
+      base.setup
+    end
+
+    def setup
+      class_operation_module
+      instance_operation_module
+    end
+
+    # Accepts one or more SOAP operations and generates both class and instance methods named
+    # after the given operations. Each generated method accepts an optional SOAP message Hash.
+    def operations(*operations)
+      operations.each do |operation|
+        define_class_operation(operation)
+        define_instance_operation(operation)
+      end
+    end
+
+    private
+
+    # Defines a class-level SOAP operation.
+    def define_class_operation(operation)
+      class_operation_module.module_eval %{
+        def #{operation.to_s.snakecase}(locals = {})
+          client.call #{operation.inspect}, locals
+        end
+      }
+    end
+
+    # Defines an instance-level SOAP operation.
+    def define_instance_operation(operation)
+      instance_operation_module.module_eval %{
+        def #{operation.to_s.snakecase}(locals = {})
+          self.class.#{operation.to_s.snakecase} locals
+        end
+      }
+    end
+
+    # Class methods.
+    def class_operation_module
+      @class_operation_module ||= Module.new {
+
+        def client(globals = {})
+          @client ||= Savon::Client.new(globals)
+        rescue InitializationError
+          raise_initialization_error!
+        end
+
+        def global(option, *value)
+          client.globals[option] = value
+        end
+
+        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"
+        end
+
+      }.tap { |mod| extend(mod) }
+    end
+
+    # Instance methods.
+    def instance_operation_module
+      @instance_operation_module ||= Module.new {
+
+        def client
+          self.class.client
+        end
+
+      }.tap { |mod| include(mod) }
+    end
+
+  end
+end

data/lib/savon/operation.rb

@@ -0,0 +1,127 @@
+require "savon/options"
+require "savon/block_interface"
+require "savon/request"
+require "savon/builder"
+require "savon/response"
+require "savon/request_logger"
+
+module Savon
+  class Operation
+
+    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)
+    end
+
+    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
+    end
+
+    def self.ensure_name_is_symbol!(operation_name)
+      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)
+      @name = name
+      @wsdl = wsdl
+      @globals = globals
+
+      @logger = RequestLogger.new(globals)
+    end
+
+    def build(locals = {}, &block)
+      set_locals(locals, block)
+      Builder.new(@name, @wsdl, @globals, @locals)
+    end
+
+    def call(locals = {}, &block)
+      builder = build(locals, &block)
+
+      response = Savon.notify_observers(@name, builder, @globals, @locals)
+      response ||= call_with_logging build_request(builder)
+
+      raise_expected_httpi_response! unless response.kind_of?(HTTPI::Response)
+
+      create_response(response)
+    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
+
+      @locals = locals
+    end
+
+    def call_with_logging(request)
+      @logger.log(request) { HTTPI.post(request) }
+    end
+
+    def build_request(builder)
+      request = SOAPRequest.new(@globals).build(
+        :soap_action => soap_action,
+        :cookies     => @locals[:cookies]
+      )
+
+      request.url = endpoint
+      request.body = builder.to_s
+
+      # TODO: could HTTPI do this automatically in case the header
+      #       was not specified manually? [dh, 2013-01-04]
+      request.headers["Content-Length"] = request.body.bytesize.to_s
+
+      request
+    end
+
+    def 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
+      soap_action = @locals[:soap_action]
+      # with no local option, but a wsdl, ask it for the soap_action
+      soap_action ||= @wsdl.soap_action(@name.to_sym) if @wsdl.document?
+      # if there is no soap_action up to this point, fallback to a simple default
+      soap_action ||= Gyoku.xml_tag(@name, :key_converter => @globals[:convert_request_keys_to])
+    end
+
+    def endpoint
+      @globals[:endpoint] || @wsdl.endpoint
+    end
+
+    def raise_expected_httpi_response!
+      raise Error, "Observers need to return an HTTPI::Response to mock " \
+                   "the request or nil to execute the request."
+    end
+
+  end
+end

data/lib/savon/options.rb

@@ -0,0 +1,330 @@
+require "logger"
+require "httpi"
+
+module Savon
+  class Options
+
+    def initialize(options = {})
+      @options = {}
+      assign options
+    end
+
+    attr_reader :option_type
+
+    def [](option)
+      @options[option]
+    end
+
+    def []=(option, value)
+      value = [value].flatten
+      self.send(option, *value)
+    end
+
+    def include?(option)
+      @options.key? option
+    end
+
+    private
+
+    def assign(options)
+      options.each do |option, value|
+        self.send(option, value)
+      end
+    end
+
+    def method_missing(option, _)
+      raise UnknownOptionError, "Unknown #{option_type} option: #{option.inspect}"
+    end
+
+  end
+
+  class GlobalOptions < Options
+
+    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},
+        :multipart                 => false,
+      }
+
+      options = defaults.merge(options)
+
+      # this option is a shortcut on the logger which needs to be set
+      # before it can be modified to set the option.
+      delayed_level = options.delete(:log_level)
+
+      super(options)
+
+      log_level(delayed_level) unless delayed_level.nil?
+    end
+
+    # Location of the local or remote WSDL document.
+    def wsdl(wsdl_address)
+      @options[:wsdl] = wsdl_address
+    end
+
+    # SOAP endpoint.
+    def endpoint(endpoint)
+      @options[:endpoint] = endpoint
+    end
+
+    # Target namespace.
+    def namespace(namespace)
+      @options[:namespace] = namespace
+    end
+
+    # The namespace identifer.
+    def namespace_identifier(identifier)
+      @options[:namespace_identifier] = identifier
+    end
+
+    # Namespaces for the SOAP envelope.
+    def namespaces(namespaces)
+      @options[:namespaces] = namespaces
+    end
+
+    # Proxy server to use for all requests.
+    def proxy(proxy)
+      @options[:proxy] = proxy
+    end
+
+    # A Hash of HTTP headers.
+    def headers(headers)
+      @options[:headers] = headers
+    end
+
+    # Open timeout in seconds.
+    def open_timeout(open_timeout)
+      @options[:open_timeout] = open_timeout
+    end
+
+    # Read timeout in seconds.
+    def read_timeout(read_timeout)
+      @options[:read_timeout] = read_timeout
+    end
+
+    # The encoding to use. Defaults to "UTF-8".
+    def encoding(encoding)
+      @options[:encoding] = encoding
+    end
+
+    # 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.
+    # 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)
+      @options[:element_form_default] = element_form_default
+    end
+
+    # Can be used to change the SOAP envelope namespace identifier.
+    # If you need to use this option, please open an issue and make
+    # sure to add your WSDL document for debugging.
+    def env_namespace(env_namespace)
+      @options[:env_namespace] = env_namespace
+    end
+
+    # Changes the SOAP version to 1 or 2.
+    def soap_version(soap_version)
+      @options[:soap_version] = soap_version
+    end
+
+    # Whether or not to raise SOAP fault and HTTP errors.
+    def raise_errors(raise_errors)
+      @options[:raise_errors] = raise_errors
+    end
+
+    # Whether or not to log.
+    def log(log)
+      HTTPI.log = log
+      @options[:log] = log
+    end
+
+    # The logger to use. Defaults to a Savon::Logger instance.
+    def logger(logger)
+      @options[:logger] = logger
+    end
+
+    # Changes the Logger's log level.
+    def log_level(level)
+      levels = { :debug => 0, :info => 1, :warn => 2, :error => 3, :fatal => 4 }
+
+      unless levels.include? level
+        raise ArgumentError, "Invalid log level: #{level.inspect}\n" \
+                             "Expected one of: #{levels.keys.inspect}"
+      end
+
+      @options[:logger].level = levels[level]
+    end
+
+    # A list of XML tags to filter from logged SOAP messages.
+    def filters(*filters)
+      @options[:filters] = filters.flatten
+    end
+
+    # Whether to pretty print request and response XML log messages.
+    def pretty_print_xml(pretty_print_xml)
+      @options[:pretty_print_xml] = pretty_print_xml
+    end
+
+    # Specifies the SSL version to use.
+    def ssl_version(version)
+      @options[:ssl_version] = version
+    end
+
+    # Whether and how to to verify the connection.
+    def ssl_verify_mode(verify_mode)
+      @options[:ssl_verify_mode] = verify_mode
+    end
+
+    # Sets the cert key file to use.
+    def ssl_cert_key_file(file)
+      @options[:ssl_cert_key_file] = file
+    end
+
+    # Sets the cert key password to use.
+    def ssl_cert_key_password(password)
+      @options[:ssl_cert_key_password] = password
+    end
+
+    # Sets the cert file to use.
+    def ssl_cert_file(file)
+      @options[:ssl_cert_file] = file
+    end
+
+    # Sets the ca cert file to use.
+    def ssl_ca_cert_file(file)
+      @options[:ssl_ca_cert_file] = file
+    end
+
+    # HTTP basic auth credentials.
+    def basic_auth(*credentials)
+      @options[:basic_auth] = credentials.flatten
+    end
+
+    # HTTP digest auth credentials.
+    def digest_auth(*credentials)
+      @options[:digest_auth] = credentials.flatten
+    end
+
+    # NTLM auth credentials.
+    def ntlm(*credentials)
+      @options[:ntlm] = 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
+    end
+
+    # Instruct Nori whether to strip namespaces from XML nodes.
+    def strip_namespaces(strip_namespaces)
+      @options[:strip_namespaces] = strip_namespaces
+    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 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
+
+    # Instruct Savon to create a multipart response if available.
+    def multipart(multipart)
+      @options[:multipart] = multipart
+    end
+  end
+
+  class LocalOptions < Options
+
+    def initialize(options = {})
+      @option_type = :local
+
+      defaults = {
+        :advanced_typecasting => true,
+        :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
+    end
+
+    # SOAP message tag (formerly known as SOAP input tag). If it's not set, Savon retrieves the name from
+    # the WSDL document (if available). Otherwise, Gyoku converts the operation name into an XML element.
+    def message_tag(message_tag)
+      @options[:message_tag] = message_tag
+    end
+
+    # Attributes for the SOAP message tag.
+    def attributes(attributes)
+      @options[:attributes] = attributes
+    end
+
+    # Value of the SOAPAction HTTP header.
+    def soap_action(soap_action)
+      @options[:soap_action] = soap_action
+    end
+
+    # Cookies to be used for the next request.
+    def cookies(cookies)
+      @options[:cookies] = cookies
+    end
+
+    # The SOAP request XML to send. Expected to be a String.
+    def xml(xml)
+      @options[:xml] = xml
+    end
+
+    # Instruct Nori to use advanced typecasting.
+    def advanced_typecasting(advanced)
+      @options[:advanced_typecasting] = advanced
+    end
+
+    # Instruct Nori to use :rexml or :nokogiri to parse the response.
+    def response_parser(parser)
+      @options[:response_parser] = parser
+    end
+
+    # Instruct Savon to create a multipart response if available.
+    def multipart(multipart)
+      @options[:multipart] = multipart
+    end
+
+  end
+end