smacks-savon 0.1.61 → 0.2.0

data/lib/savon/response.rb

@@ -1,173 +0,0 @@
-require "rubygems"
-require "hpricot"
-require "apricoteatsgorilla"
-
-module Savon
-
-  # Savon::HTTPResponse containes methods exclusive to a Net::HTTPResponse
-  # to be included in Savon::Response.
-  module HTTPResponse
-
-    # Returns the error code.
-    attr_reader :error_code
-
-    # Returns the error message.
-    attr_reader :error_message
-
-    # Returns +true+ in case the request was successful, +false+ otherwise
-    # or +nil+ in case there was no request at all.
-    def success?
-      return nil unless @response
-      @error_code.nil?
-    end
-
-    # Returns +false+ in case the request was not successful, +true+ otherwise
-    # or +nil+ in case there was no request at all.
-    def error?
-      return nil unless @response
-      !@error_code.nil?
-    end
-
-  private
-
-    # Validates the response against HTTP errors and SOAP faults and sets the
-    # +error_code+ and +error_message+ in case the request was not successful.
-    def validate_response
-      if @response.code.to_i >= 300
-        @error_message = @response.message
-        @error_code = @response.code
-      else
-        soap_fault = ApricotEatsGorilla[@response.body, "//soap:Fault"]
-        unless soap_fault.nil? || soap_fault.empty?
-          @error_message = soap_fault[:faultstring]
-          @error_code = soap_fault[:faultcode]
-        end
-      end
-    end
-
-    # Translates the response body into a Hash. Takes an optional +root_node+
-    # argument to start parsing the response body at a custom root node.
-    def response_to_hash(root_node = nil)
-      ApricotEatsGorilla[@response.body, root_node]
-    end
-
-  end
-
-  # Savon::Response represents the HTTP/SOAP response.
-  class Response
-
-    include Savon::HTTPResponse
-
-    # The default root node to start parsing the SOAP response at.
-    @@default_root_node = "//return"
-
-    # Returns the default root node.
-    def self.default_root_node
-      @@default_root_node
-    end
-
-    # Sets the default root node.
-    def self.default_root_node=(root_node)
-      @@default_root_node = root_node if root_node.kind_of?(String)
-    end
-
-    # The core (inherited) methods to shadow.
-    @@core_methods_to_shadow = [:id]
-
-    # Returns the core methods to shadow.
-    def self.core_methods_to_shadow
-      @@core_methods_to_shadow
-    end
-
-    # Sets the core +methods+ to shadow.
-    def self.core_methods_to_shadow=(methods)
-      @@core_methods_to_shadow = methods if methods.kind_of?(Array)
-    end
-
-    # Initializer expects the +source+ to initialize from. Sets up the instance
-    # from a given Net::HTTPResponse or a Hash depending on the given +source+.
-    # May be called with a custom +root_node+ to start parsing the response at
-    # in case the given +source+ is a Net::HTTPResponse.
-    def initialize(source, root_node = nil)
-      if source.kind_of? Hash
-        initialize_from_hash(source)
-      elsif source.respond_to? :body
-        initialize_from_response(source, root_node)
-      end
-    end
-
-    # Returns the value from a given +key+ from the response Hash.
-    def [](key)
-      return @hash unless @hash.kind_of?(Hash)
-      value_from_hash(key)
-    end
-
-    # Returns the response Hash. Takes an optional +root_node+ to start parsing
-    # the SOAP response at instead of the +@@default_root_node+.
-    def to_hash(root_node = nil)
-      return @hash if root_node.nil?
-      response_to_hash(root_node)
-    end
-
-    # Returns the response body in case there is any, +nil+ otherwise.
-    def to_s
-      return nil unless @response
-      @response.body
-    end
-
-    # Intercepts calls to missing methods and returns values from the response
-    # Hash in case the name of the missing +method+ matches one of its key.
-    # Returns a new Savon::Response instance containing the value or returns
-    # the actual value in case it is not a Hash.
-    def method_missing(method, *args)
-      return @hash unless @hash.kind_of?(Hash)
-
-      value = value_from_hash(method)
-      return value unless value.kind_of?(Hash)
-      Savon::Response.new(value)
-    end
-
-  private
-
-    # Initializes the instance from a Net::HTTPResponse. Validates the +response+
-    # against HTTP errors and SOAP faults. Continues to translate the response
-    # body into a Hash and delegates to initializing the instance from this Hash
-    # in case the request was successful. An optional +root_node+ to start parsing
-    # the response at might be supplied.
-    def initialize_from_response(response, root_node = nil)
-      @response = response
-      validate_response
-
-      if success?
-        root_node ||= @@default_root_node
-        hash = response_to_hash(root_node)
-        initialize_from_hash(hash)
-      end
-    end
-
-    # Initializes the instance from a given +hash+.
-    def initialize_from_hash(hash)
-      @hash = hash
-      shadow_core_methods if @hash.kind_of?(Hash)
-    end
-
-    # Dynamically defines methods from the Array of +@@core_methods_to_shadow+
-    # to "shadow" inherited methods. Returns a value from the response Hash in
-    # case a matching public method and a key from the Hash could be found.
-    def shadow_core_methods
-      @@core_methods_to_shadow.each do |method|
-        if self.public_methods.include?(method.to_s) && value_from_hash(method)
-          self.class.send(:define_method, method) { value_from_hash(method) }
-        end
-      end
-    end
-
-    # Returns a value from the response Hash. Tries to convert the given +key+
-    # into a Symbol or a String to find the value to return.
-    def value_from_hash(key)
-      return nil unless @hash
-      @hash[key.to_sym] || @hash[key.to_s]
-    end
-  end
-
-end

data/test/factories/wsdl.rb

@@ -1,127 +0,0 @@
-class WsdlFactory
-  attr_accessor :namespace_uri, :service_methods, :choice_elements
-
-  def initialize(new_options = {})
-    options = {
-      :namespace_uri => "http://some.example.com",
-      :service_methods => {"findById" => ["id"]},
-      :choice_elements => {}
-    }.update(new_options)
-
-    @namespace_uri = options[:namespace_uri]
-    @service_methods = options[:service_methods]
-    @choice_elements = options[:choice_elements]
-  end
-
-  def build
-    wsdl = '<wsdl:definitions name="SomeService" targetNamespace="' << namespace_uri << '"
-      xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="http://example.com"
-      xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
-      <wsdl:types>
-        <xs:schema attributeFormDefault="unqualified" elementFormDefault="unqualified"
-          targetNamespace="http://example.com" xmlns:tns="http://example.com"
-          xmlns:xs="http://www.w3.org/2001/XMLSchema">'
-    wsdl << build_elements
-    wsdl << '<xs:element name="result" type="tns:result" />'
-    wsdl << build_complex_types
-    wsdl << '<xs:complexType name="result">
-            <xs:sequence><xs:element name="token" type="xs:token" /></xs:sequence>
-          </xs:complexType>
-        </xs:schema>
-      </wsdl:types>'
-    wsdl << build_messages
-    wsdl << '<wsdl:portType name="SomeWebService">'
-    wsdl << build_operation_input_output
-    wsdl << '</wsdl:portType>
-      <wsdl:binding name="SomeServiceSoapBinding" type="tns:SomeService">
-        <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />'
-    wsdl << build_operation_input_output_body
-    wsdl << '</wsdl:binding>
-      <wsdl:service name="SomeService">
-        <wsdl:port binding="tns:SomeServiceSoapBinding" name="SomeServicePort">
-          <soap:address location="http://example.com/SomeService" />
-        </wsdl:port>
-      </wsdl:service>
-    </wsdl:definitions>'
-  end
-
-  def build_elements
-    wsdl = service_methods.keys.map { |method|
-      '<xs:element name="' << method << '" type="tns:' << method << '" />
-      <xs:element name="' << method << 'Response" type="tns:' << method << 'Response" />'
-    }.to_s
-    wsdl << choice_elements.map { |c_method, c_elements|
-      c_elements.map { |c_element|
-        '<xs:element name="' << c_element << '" type="tns:' << c_element << 'Value" />'
-      }.to_s
-    }.to_s
-    wsdl
-  end
-
-  def build_complex_types
-    service_methods.map { |method, inputs|
-      wsdl = '<xs:complexType name="' << method << '"><xs:sequence>'
-      inputs.each do |input|
-        if choice_elements.keys.include? input
-          wsdl << '<xs:choice>'
-          wsdl << choice_elements[input].map { |element|
-            '<xs:element ref="tns:' << element << '"/>'
-          }.to_s
-          wsdl << '</xs:choice>'
-        else
-          wsdl << '<xs:element minOccurs="0" name="' << input << '" type="xs:string" />'
-        end
-      end
-      wsdl << '</xs:sequence></xs:complexType>'
-      wsdl << build_complex_types_choice_elements
-      wsdl << '<xs:complexType name="' << method << 'Response"><xs:sequence>
-          <xs:element minOccurs="0" name="return" type="tns:result" />
-        </xs:sequence></xs:complexType>'
-    }.to_s
-  end
-
-  def build_complex_types_choice_elements
-    choice_elements.map { |c_method, c_elements|
-        c_elements.map { |c_element|
-          '<xs:complexType name="' << c_element << 'Value"><xs:sequence>
-          <xs:element minOccurs="0" name="' << c_element << '" type="xs:string" />
-          </xs:sequence></xs:complexType>'
-        }.to_s
-      }.to_s
-  end
-
-  def build_messages
-    service_methods.keys.map { |method|
-      '<wsdl:message name="' << method << '">
-        <wsdl:part element="tns:' << method << '" name="parameters"> </wsdl:part>
-      </wsdl:message>
-      <wsdl:message name="' << method << 'Response">
-        <wsdl:part element="tns:' << method << 'Response" name="parameters"> </wsdl:part>
-      </wsdl:message>'
-    }.to_s
-  end
-
-  def build_operation_input_output
-    service_methods.keys.map { |method|
-      '<wsdl:operation name="' << method << '">
-        <wsdl:input message="tns:' << method << '" name="' << method << '"> </wsdl:input>
-        <wsdl:output message="tns:' << method << 'Response" name="' << method << 'Response"> </wsdl:output>
-      </wsdl:operation>'
-    }.to_s
-  end
-
-  def build_operation_input_output_body
-    service_methods.keys.map { |method|
-      '<wsdl:operation name="' << method << '">
-        <soap:operation soapAction="" style="document" />
-        <wsdl:input name="' << method << '">
-          <soap:body use="literal" />
-        </wsdl:input>
-        <wsdl:output name="' << method << 'Response">
-          <soap:body use="literal" />
-        </wsdl:output>
-      </wsdl:operation>'
-    }.to_s
-  end
-
-end

data/test/fixtures/soap_response_fixture.rb

@@ -1,75 +0,0 @@
-module SoapResponseFixture
-
-  def some_response_hash
-    {
-      :authentication => {
-        :user => "example",
-        :password => "secret"
-      },
-      :success => true,
-      :tokens => ["abc", "xyz", "123"]
-    }
-  end
-
-  def response_hash_with_id
-    some_response_hash.dup.update :id => "shadow_id"
-  end
-
-  def response_hash_with_inspect
-    some_response_hash.dup.update :inspect => "shadow_inspect"
-  end
-
-  def some_soap_response
-    build_soap_response
-  end
-
-  def soap_response_with_id
-    build_soap_response '<id>shadow_id</id>'
-  end
-
-  def soap_response_with_inspect
-    build_soap_response '<inspect>shadow_inspect</inspect>'
-  end
-
-  def soap_fault_response
-    '<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">' <<
-       '<soap:Body>' <<
-          '<soap:Fault>' <<
-             '<faultcode>' << soap_fault_code << '</faultcode>' <<
-             '<faultstring>' << soap_fault_message << '</faultstring>' <<
-          '</soap:Fault>' <<
-       '</soap:Body>' <<
-    '</soap:Envelope>'
-  end
-
-  def soap_fault_message
-    "Failed to authenticate client."
-  end
-
-  def soap_fault_code
-    "soap:Server"
-  end
-
-private
-
-  def build_soap_response(mixin = "")
-    '<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">' <<
-      '<soap:Body>' <<
-        '<ns2:result xmlns:ns2="http://example.com/">' <<
-          '<return>' <<
-            '<authentication>' <<
-              '<user>example</user>' <<
-              '<password>secret</password>' <<
-            '</authentication>' <<
-            mixin <<
-            '<success>true</success>' <<
-            '<tokens>abc</tokens>' <<
-            '<tokens>xyz</tokens>' <<
-            '<tokens>123</tokens>' <<
-          '</return>' <<
-        '</ns2:result>' <<
-      '</soap:Body>' <<
-    '</soap:Envelope>'
-  end
-
-end

data/test/helper.rb

@@ -1,48 +0,0 @@
-require "rubygems"
-require "test/unit"
-require "mocha"
-require "shoulda"
-require "apricoteatsgorilla"
-
-require File.join(File.dirname(__FILE__), "..", "lib", "savon")
-require File.join(File.dirname(__FILE__), "factories", "wsdl")
-require File.join(File.dirname(__FILE__), "fixtures", "soap_response_fixture")
-
-module TestHelper
-
-  def some_url
-    "http://example.com"
-  end
-
-  def some_uri
-    URI(some_url)
-  end
-
-  def service_http_mock(response_body)
-    http_mock = mock("Net::HTTP")
-    http_mock.stubs(:get).returns(response_mock(WsdlFactory.new.build))
-    http_mock.stubs(:request_post).returns(response_mock(response_body))
-    http_mock
-  end
-
-  def http_mock(response_body)
-    http_mock = mock("Net::HTTP")
-    http_mock.stubs(:get).returns(response_mock(response_body))
-    http_mock
-  end
-
-  def response_mock(response_body)
-    build_response_mock("200", "OK", response_body)
-  end
-
-  def response_error_mock
-    build_response_mock("404", "NotFound")
-  end
-
-  def build_response_mock(code, message, body = nil)
-    response_mock = mock("Net::HTTPResponse")
-    response_mock.stubs(:code => code, :message => message, :body => body)
-    response_mock
-  end
-
-end

data/test/savon/test_response.rb

@@ -1,191 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "helper")
-
-class TestSavonResponse < Test::Unit::TestCase
-
-  include TestHelper
-  include SoapResponseFixture
-
-  context "A Savon::Response instance" do
-    setup do
-      ApricotEatsGorilla.sort_keys = true
-      Savon::Response.core_methods_to_shadow = [:id] # set to default
-    end
-
-    context "initialized with a Net::HTTPResponse containing a successful SOAP response" do
-      setup { @response = Savon::Response.new response_mock(some_soap_response) }
-
-      should "return that the request was successful" do
-        assert_equal true, @response.success?
-        assert_equal false, @response.error?
-      end
-
-      should "return nil for error_code and error_message" do
-        assert_nil @response.error_code
-        assert_nil @response.error_message
-      end
-
-      should "return the SOAP response XML when calling to_s" do
-        assert_equal some_soap_response, @response.to_s
-      end
-
-      should "return the Hash translated from the SOAP response XML when calling to_hash" do
-        assert_kind_of Hash, @response.to_hash
-        assert_equal some_response_hash, @response.to_hash
-      end
-
-      should "return a Hash for Hash values accessed through []" do
-        assert_kind_of Hash, @response[:authentication]
-        assert_equal some_response_hash[:authentication], @response[:authentication]
-      end
-
-      should "return the actual value for values other than Hashes through []" do
-        assert_kind_of TrueClass, @response[:success]
-        assert_kind_of Array, @response[:tokens]
-        assert_equal some_response_hash[:success], @response[:success]
-        assert_equal some_response_hash[:tokens], @response[:tokens]
-      end
-
-      should "return nil when trying to access a not-existing key from the Hash" do
-        assert_nil @response.some_undefined_key
-      end
-
-      should "return a Savon::Response for Hash values accessed through method_missing" do
-        assert_kind_of Savon::Response, @response.authentication
-      end
-
-      should "return the actual value for values other than Hashes through method_missing" do
-        assert_kind_of TrueClass, @response.success
-        assert_kind_of Array, @response.tokens
-        assert_equal some_response_hash[:success], @response.success
-        assert_equal some_response_hash[:tokens], @response.tokens
-      end
-
-      should "by default shadow the :id method if it was found in the Hash" do
-        response_with_id = Savon::Response.new response_mock(soap_response_with_id)
-        assert_equal response_hash_with_id[:id], response_with_id.id
-      end
-
-      should "shadow user-specified core methods in case they were found in the Hash" do
-        Savon::Response.core_methods_to_shadow = [:inspect]
-        response_with_inspect = Savon::Response.new response_mock(soap_response_with_inspect)
-
-        assert_equal response_hash_with_inspect[:inspect], response_with_inspect.inspect
-      end
-    end
-
-    context "initialized with a Hash" do
-      setup { @response = Savon::Response.new some_response_hash }
-
-      should "return nil for HTTP::Response-specific methods" do
-        assert_nil @response.success?
-        assert_nil @response.error?
-        assert_nil @response.error_code
-        assert_nil @response.error_message
-        assert_nil @response.to_s
-      end
-
-      should "return the given Hash when calling to_hash" do
-        assert_kind_of Hash, @response.to_hash
-        assert_equal some_response_hash, @response.to_hash
-      end
-
-      should "return a Hash for Hash values accessed through []" do
-        assert_kind_of Hash, @response[:authentication]
-        assert_equal some_response_hash[:authentication], @response[:authentication]
-      end
-
-      should "return the actual value for values other than Hashes through []" do
-        assert_kind_of TrueClass, @response[:success]
-        assert_kind_of Array, @response[:tokens]
-        assert_equal some_response_hash[:success], @response[:success]
-        assert_equal some_response_hash[:tokens], @response[:tokens]
-      end
-
-      should "return a Savon::Response for Hash values accessed through method_missing" do
-        assert_kind_of Savon::Response, @response.authentication
-      end
-
-      should "return the actual value for values other than Hashes through method_missing" do
-        assert_kind_of TrueClass, @response.success
-        assert_kind_of Array, @response.tokens
-        assert_equal some_response_hash[:success], @response.success
-        assert_equal some_response_hash[:tokens], @response.tokens
-      end
-
-      should "by default shadow the :id method if it was found in the Hash" do
-        hash_with_id = response_hash_with_id
-        @response = Savon::Response.new hash_with_id
-        assert_equal hash_with_id[:id], @response.id
-      end
-
-      should "shadow user-specified core methods in case they were found in the Hash" do
-        Savon::Response.core_methods_to_shadow = [:inspect]
-        response_with_inspect = Savon::Response.new response_hash_with_inspect
-
-        assert_equal response_hash_with_inspect[:inspect], response_with_inspect.inspect
-      end
-    end
-
-    context "initialized with a Net::HTTPResponse containing a SOAP fault" do
-      setup { @response = Savon::Response.new response_mock(soap_fault_response) }
-
-      should "return that the request was not successful" do
-        assert_equal false, @response.success?
-        assert_equal true, @response.error?
-      end
-
-      should "return the error_code and error_message" do
-        assert_equal soap_fault_code, @response.error_code
-        assert_equal soap_fault_message, @response.error_message
-      end
-
-      should "return the SOAP response XML when calling to_s" do
-        assert_equal soap_fault_response, @response.to_s
-      end
-
-      should "return nil when calling to_hash" do
-        assert_nil @response.to_hash
-      end
-
-      should "return nil when trying to access Hash values through []" do
-        assert_nil @response[:some_key]
-      end
-
-      should "return nil when trying to access Hash values through method_missing" do
-        assert_nil @response.some_key
-      end
-    end
-
-    context "initialized with a Net::HTTPResponse error" do
-      setup { @response = Savon::Response.new response_error_mock }
-
-      should "return that the request was not successful" do
-        assert_equal false, @response.success?
-        assert_equal true, @response.error?
-      end
-
-      should "return the error_code and error_message" do
-        assert_equal "404", @response.error_code
-        assert_equal "NotFound", @response.error_message
-      end
-
-      should "return nil when calling to_s" do
-        assert_nil @response.to_s
-      end
-
-      should "return nil when calling to_hash" do
-        assert_nil @response.to_hash
-      end
-
-      should "return nil when trying to access Hash values through []" do
-        assert_nil @response[:some_key]
-      end
-
-      should "return nil when trying to access Hash values through method_missing" do
-        assert_nil @response.some_key
-      end
-    end
-
-  end
-
-end