savon-SU 2.11.1b

data/lib/savon/core_ext/string.rb

@@ -0,0 +1,29 @@
+
+module Savon
+  module CoreExt
+    module String
+
+      def self.included(base)
+        unless "savon".respond_to?(:snakecase)
+          base.send(:include, Extension)
+        end
+      end
+
+      module Extension
+        def snakecase
+          str = dup
+          str.gsub! /::/, '/'
+          str.gsub! /([A-Z]+)([A-Z][a-z])/, '\1_\2'
+          str.gsub! /([a-z\d])([A-Z])/, '\1_\2'
+          str.tr! ".", "_"
+          str.tr! "-", "_"
+          str.downcase!
+          str
+        end
+      end
+
+    end
+  end
+end
+
+String.send :include, Savon::CoreExt::String

data/lib/savon/header.rb

@@ -0,0 +1,93 @@
+require "akami"
+require "gyoku"
+require "securerandom"
+
+module Savon
+  class Header
+
+    def initialize(globals, locals)
+      @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?
+      @header.empty?
+    end
+
+    def to_s
+      @header
+    end
+
+    private
+
+    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 build_wsse_header
+      wsse_header = akami
+      wsse_header.respond_to?(:to_xml) ? wsse_header.to_xml : ""
+    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}",
+         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
+end

data/lib/savon/http_error.rb

@@ -0,0 +1,27 @@
+require "savon"
+
+module Savon
+  class HTTPError < Error
+
+    def self.present?(http)
+      http.error?
+    end
+
+    def initialize(http)
+      @http = http
+    end
+
+    attr_reader :http
+
+    def to_s
+      message = "HTTP error (#{@http.code})"
+      message << ": #{@http.body}" unless @http.body.empty?
+      message
+    end
+
+    def to_hash
+      { :code => @http.code, :headers => @http.headers, :body => @http.body }
+    end
+
+  end
+end

data/lib/savon/log_message.rb

@@ -0,0 +1,52 @@
+require "nokogiri"
+
+module Savon
+  class LogMessage
+
+    def initialize(message, filters = [], pretty_print = false)
+      @message      = message
+      @filters      = filters
+      @pretty_print = pretty_print
+    end
+
+    def to_s
+      message_is_xml = @message =~ /^</
+      has_filters    = @filters.any?
+      pretty_print   = @pretty_print
+
+      return @message unless message_is_xml
+      return @message unless has_filters || pretty_print
+
+      document = Nokogiri.XML(@message)
+      document = apply_filter(document) if has_filters
+      document.to_xml(nokogiri_options)
+    end
+
+    private
+
+    def apply_filter(document)
+      return document unless document.errors.empty?
+
+      @filters.each do |filter|
+        apply_filter! document, filter
+      end
+
+      document
+    end
+
+    def apply_filter!(document, filter)
+      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 } : {}
+    end
+
+  end
+end

data/lib/savon/message.rb

@@ -0,0 +1,37 @@
+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
+      @types = types
+      @used_namespaces = used_namespaces
+
+      @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
+        @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
+      }
+
+      Gyoku.xml(@message, gyoku_options)
+    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/mock/expectation.rb

@@ -0,0 +1,80 @@
+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].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."
+
+        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
+
+    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/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/model.rb

@@ -0,0 +1,84 @@
+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
+
+    def all_operations
+      operations(*client.operations)
+    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