savon 1.2.0 → 2.0.0

data/lib/savon/header.rb

@@ -0,0 +1,42 @@
+require "akami"
+require "gyoku"
+
+module Savon
+  class Header
+
+    def initialize(globals, locals)
+      @globals = globals
+      @locals = locals
+      @wsse = create_wsse
+    end
+
+    def empty?
+      to_s.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
+    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
+    end
+
+    def header
+      @header ||= @globals.include?(:soap_header) ? @globals[:soap_header] : {}
+    end
+
+    def wsse_header
+      @wsse.respond_to?(:to_xml) ? @wsse.to_xml : ""
+    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

@@ -1,49 +1,47 @@
+require "nokogiri"
+
 module Savon
   class LogMessage
 
-    def initialize(message, filters, options = {})
-      @message = message
-      @filters = filters
-      @options = options
+    def initialize(message, filters = [], pretty_print = false)
+      @message      = message
+      @filters      = filters
+      @pretty_print = pretty_print
     end
 
     def to_s
-      return @message unless pretty? || filter?
-
-      doc = Nokogiri.XML(@message)
-      doc = apply_filter(doc) if filter?
-      doc.to_xml(pretty_options)
-    end
+      message_is_xml = @message =~ /^</
+      has_filters    = @filters.any?
+      pretty_print   = @pretty_print
 
-    private
+      return @message unless message_is_xml
+      return @message unless has_filters || pretty_print
 
-    def filter?
-      @options[:filter] && @filters.any?
+      document = Nokogiri.XML(@message)
+      document = apply_filter(document) if has_filters
+      document.to_xml(nokogiri_options)
     end
 
-    def pretty?
-      @options[:pretty]
-    end
+    private
 
-    def apply_filter(doc)
-      return doc unless doc.errors.empty?
+    def apply_filter(document)
+      return document unless document.errors.empty?
 
       @filters.each do |filter|
-        apply_filter!(doc, filter)
+        apply_filter! document, filter
       end
 
-      doc
+      document
     end
 
-    def apply_filter!(doc, filter)
-      doc.xpath("//*[local-name()='#{filter}']").each do |node|
+    def apply_filter!(document, filter)
+      document.xpath("//*[local-name()='#{filter}']").each do |node|
         node.content = "***FILTERED***"
       end
     end
 
-    def pretty_options
-      return {} unless pretty?
-      { :indent => 2 }
+    def nokogiri_options
+      @pretty_print ? { :indent => 2 } : {}
     end
 
   end

data/lib/savon/message.rb

@@ -0,0 +1,35 @@
+require "savon/qualified_message"
+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
+      @namespace_identifier = namespace_identifier
+      @types = types
+      @used_namespaces = used_namespaces
+
+      @message = message
+      @element_form_default = element_form_default
+      @key_converter = key_converter
+    end
+
+    def to_s
+      return @message.to_s unless @message.kind_of? Hash
+
+      if @element_form_default == :qualified
+        @message = QualifiedMessage.new(@types, @used_namespaces, @request_key_converter).to_hash(@message, [@operation_name.to_s])
+      end
+
+      gyoku_options = {
+        :element_form_default => @element_form_default,
+        :namespace            => @namespace_identifier,
+        :key_converter        => @key_converter
+      }
+
+      Gyoku.xml(@message, gyoku_options)
+    end
+
+  end
+end

data/lib/savon/mock.rb

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

data/lib/savon/mock/expectation.rb

@@ -0,0 +1,70 @@
+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!
+      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/model.rb

@@ -1,8 +1,4 @@
 module Savon
-
-  # = Savon::Model
-  #
-  # Model for SOAP service oriented applications.
   module Model
 
     def self.extended(base)
@@ -10,92 +6,74 @@ module Savon
     end
 
     def setup
-      class_action_module
-      instance_action_module
+      class_operation_module
+      instance_operation_module
     end
 
-    # Accepts one or more SOAP actions and generates both class and instance methods named
-    # after the given actions. Each generated method accepts an optional SOAP body Hash and
-    # a block to be passed to <tt>Savon::Client#request</tt> and executes a SOAP request.
-    def actions(*actions)
-      actions.each do |action|
-        define_class_action(action)
-        define_instance_action(action)
+    # 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 action method.
-    def define_class_action(action)
-      class_action_module.module_eval %{
-        def #{action.to_s.snakecase}(body = nil, &block)
-          client.request :wsdl, #{action.inspect}, :body => body, &block
+    # 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 action method.
-    def define_instance_action(action)
-      instance_action_module.module_eval %{
-        def #{action.to_s.snakecase}(body = nil, &block)
-          self.class.#{action.to_s.snakecase} body, &block
+    # 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_action_module
-      @class_action_module ||= Module.new do
-
-        # Returns the memoized <tt>Savon::Client</tt>.
-        def client(&block)
-          @client ||= Savon::Client.new(&block)
-        end
-
-        # Sets the SOAP endpoint to the given +uri+.
-        def endpoint(uri)
-          client.wsdl.endpoint = uri
-        end
-
-        # Sets the target namespace.
-        def namespace(uri)
-          client.wsdl.namespace = uri
-        end
-
-        # Sets the WSDL document to the given +uri+.
-        def document(uri)
-          client.wsdl.document = uri
-        end
+    def class_operation_module
+      @class_operation_module ||= Module.new {
 
-        # Sets the HTTP headers.
-        def headers(headers)
-          client.http.headers = headers
+        def client(globals = {})
+          @client ||= Savon::Client.new(globals)
+        rescue InitializationError
+          raise_initialization_error!
         end
 
-        # Sets basic auth +login+ and +password+.
-        def basic_auth(login, password)
-          client.http.auth.basic(login, password)
+        def global(option, *value)
+          client.globals[option] = value
         end
 
-        # Sets WSSE auth credentials.
-        def wsse_auth(*args)
-          client.wsse.credentials(*args)
+        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
 
-      end.tap { |mod| extend(mod) }
+      }.tap { |mod| extend(mod) }
     end
 
     # Instance methods.
-    def instance_action_module
-      @instance_action_module ||= Module.new do
+    def instance_operation_module
+      @instance_operation_module ||= Module.new {
 
-        # Returns the <tt>Savon::Client</tt> from the class instance.
-        def client(&block)
-          self.class.client(&block)
+        def client
+          self.class.client
         end
 
-      end.tap { |mod| include(mod) }
+      }.tap { |mod| include(mod) }
     end
 
   end