smacks-savon 0.1.1 → 0.1.2

data/lib/savon/response.rb

@@ -4,77 +4,135 @@ require "apricoteatsgorilla"
 
 module Savon
 
-  # Savon::Response represents the HTTP response.
+  # Savon::Response validates and represents the HTTP/SOAP response.
   class Response
 
-    # The HTTP error or SOAP fault message.
-    attr_reader :error_message
+    # 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
 
-    # The HTTP error or SOAP fault code.
+    # Sets the core +methods+ to shadow.
+    def self.core_methods_to_shadow=(methods)
+      @@core_methods_to_shadow = methods if methods.kind_of? Array
+    end
+
+    # Returns the error code.
     attr_reader :error_code
 
-    # Initializer expects the HTTP response and checks for HTTP or SOAP faults.
-    #
-    # === Parameters
-    #
-    # * +response+ - The Net::HTTP response.
-    def initialize(response)
-      @response = response
-      validate
+    # Returns the error message.
+    attr_reader :error_message
+
+    # 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)
+      value_from_hash(key)
     end
 
-    # Returns true if the request was successful, false otherwise.
+    # Returns +true+ in case the request was successful, +false+ otherwise
+    # or +nil+ in case there's no request at all.
     def success?
+      return nil unless @response
       @error_code.nil?
     end
 
-    # Returns true if there was a HTTP or SOAP fault, false otherwise.
+    # Returns +false+ in case the request was not successful, +false+ otherwise
+    # or +nil+ in case there's no request at all.
     def error?
+      return nil unless @response
       !@error_code.nil?
     end
 
-    # Returns the SOAP response message as a Hash. Call with XPath expession
-    # (Hpricot search) to define a custom +root_node+ to start parsing at.
-    # Defaults to "//return". The root node will not be included in the Hash.
-    #
-    # === Parameters
-    #
-    # * +root_node+ - Optional. Custom root node to start parsing at.
-    def to_hash(root_node = "//return")
-      return nil if error?
-      ApricotEatsGorilla[@response.body, root_node]
+    # Returns the response Hash.
+    def to_hash
+      @hash
     end
 
-    # Returns the SOAP response message as a Savon::Mash object. Call with
-    # XPath expession to define a custom +root_node+. Defaults to "//return".
-    # The root node will not be included in the Mash object.
-    #
-    # === Parameters
-    #
-    # * +root_node+ - Optional. Custom root node to start parsing at.
-    def to_mash(root_node = "//return")
-      return nil if error?
-      hash = to_hash(root_node)
-      Savon::Mash.new(hash)
-    end
-
-    # Returns the SOAP response XML.
+    # 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)
+      value = value_from_hash method
+      return value unless value.kind_of? Hash
+      Savon::Response.new value
+    end
+
   private
 
-    # Checks for HTTP errors and SOAP faults.
-    def validate
+    # 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 ||= "//return"
+        hash = ApricotEatsGorilla[@response.body, 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
+    end
+
+    # 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, @error_code = @response.message, @response.code
+        @error_message = @response.message
+        @error_code = @response.code
       else
-        soap_fault = to_hash("//soap:Fault")
-        @error_message = soap_fault[:faultstring] unless soap_fault.nil?
-        @error_code = soap_fault[:faultcode] unless soap_fault.nil?
+        soap_fault = ApricotEatsGorilla[@response.body, "//soap:Fault"]
+        unless soap_fault.nil?
+          @error_message = soap_fault[:faultstring]
+          @error_code = soap_fault[:faultcode]
+        end
+      end
+    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)
+      @hash[key.to_sym] || @hash[key.to_s]
+    end
+
   end
 end

data/lib/savon/service.rb

@@ -14,24 +14,23 @@ module Savon
   # of options for the service method to receive.
   class Service
 
-    # The logger to use.
+    # The logger instance to use.
     @@logger = nil
 
-    # Initializer expects the WSDL +endpoint+ URI to use and sets up
-    # Apricot eats Gorilla.
-    #
-    # ==== Parameters
-    #
-    # * +endpoint+ - WSDL endpoint URI to use.
+    # The log level to use.
+    @@log_level = :debug
+
+    # Initializer expects the WSDL +endpoint+ URI and defines nodes to
+    # namespace for Apricot eats Gorilla.
     def initialize(endpoint)
       @uri = URI(endpoint)
       ApricotEatsGorilla.nodes_to_namespace = wsdl.choice_elements
       ApricotEatsGorilla.node_namespace = "wsdl"
     end
 
-    # Returns an instance of the WSDL.
+    # Returns an instance of the Savon::Wsdl.
     def wsdl
-      @wsdl = Savon::Wsdl.new(@uri, http) if @wsdl.nil?
+      @wsdl = Savon::Wsdl.new(@uri, http) unless @wsdl
       @wsdl
     end
 
@@ -40,73 +39,77 @@ module Savon
       @http = http
     end
 
-    # Sets the logger to use.
+    # Sets the logger instance to use.
     def self.logger=(logger)
       @@logger = logger
     end
 
+    # Sets the log level to use.
+    def self.log_level=(log_level)
+      @@log_level = log_level
+    end
+
   private
 
-    # Sets up and dispatches the SOAP request. Returns a Savon::Response object.
-    def call_service
-      headers = { "Content-Type" => "text/xml; charset=utf-8", "SOAPAction" => @action }
+    # Constructs and dispatches the SOAP request. Returns a Savon::Response.
+    def dispatch(root_node = nil)
+      headers = { "Content-Type" => "text/xml; charset=utf-8", "SOAPAction" => @soap_action }
 
       body = ApricotEatsGorilla.soap_envelope("wsdl" => wsdl.namespace_uri) do
-        ApricotEatsGorilla["wsdl:#{@action}" => @options]
+        ApricotEatsGorilla["wsdl:#{@soap_action}" => @options]
       end
 
       debug do |logger|
-        logger.info "Requesting #{@uri}"
-        logger.info headers.map { |key, value| "#{key}: #{value}" }.join("\n")
-        logger.info body
+        logger.send @@log_level, "Requesting #{@uri}"
+        logger.send @@log_level, headers.map { |key, value| "#{key}: #{value}" }.join("\n")
+        logger.send @@log_level, body
       end
-      response = @http.request_post(@uri.path, body, headers)
+      response = http.request_post(@uri.path, body, headers)
       debug do |logger|
-        logger.info "Response (Status #{response.code}):"
-        logger.info response.body
+        logger.send @@log_level, "Response (Status #{response.code}):"
+        logger.send @@log_level, response.body
       end
-      Savon::Response.new(response)
+      Savon::Response.new response, root_node
     end
 
     # Returns the Net::HTTP instance to use.
     def http
       if @http.nil?
-        raise ArgumentError, "Invalid endpoint URI" unless @uri.scheme
+        raise ArgumentError, "Invalid endpoint URI: #{@uri}" unless @uri.scheme
         @http = Net::HTTP.new(@uri.host, @uri.port)
       end
       @http
     end
 
-    # Checks if the requested SOAP service method is available.
-    # Raises an ArgumentError in case it is not.
-    def validate_action
-      unless wsdl.service_methods.include? @action
-        raise ArgumentError, "Invalid service method '#{@action}'"
+    # Checks if the requested SOAP action was found on the WSDL.
+    # Raises an ArgumentError in case it was not found.
+    def validate_soap_action
+      unless wsdl.service_methods.include? @soap_action
+        raise ArgumentError, "Invalid service method: #{@soap_action}"
       end
     end
 
-    # Logs a given +message+ using the @@logger instance or yields the logger
-    # to a given +block+ for logging multiple things at once.
+    # Logs a given +message+ using the +@@logger+ instance or yields the logger
+    # to a given +block+ for logging multiple messages at once.
     def debug(message = nil)
       if @@logger
-        @@logger.info(message) if message
+        @@logger.send(@@log_level, message) if message
         yield @@logger if block_given?
       end
     end
 
-    # Method missing catches SOAP service methods called on this object. This
-    # is the default way of calling a SOAP service. The given +method+ will be
-    # validated against the WSDL and dispatched if available. Values supplied
-    # through the optional Hash of +options+ will be send to the service method.
-    #
-    # === Parameters
-    #
-    # * +method+ - The SOAP service method to call.
-    # * +options+ - Hash of options for the service method to receive.
-    def method_missing(method, options = {})
-      @action, @options = method.to_s, options
-      validate_action
-      call_service
+    # Catches SOAP actions called on the Savon::Service instance.
+    # This is the default way of calling a SOAP action.
+    # 
+    # The given +method+ will be validated against available SOAP actions found
+    # on the WSDL and dispatched if available. Options for the SOAP action to
+    # receive can be given through the optional Hash of +options+. A custom
+    # +root_node+ to start parsing the SOAP response at might be supplied as well.
+    def method_missing(method, options = {}, root_node = nil)
+      @soap_action = ApricotEatsGorilla.to_lower_camel_case(method)
+      @options = options
+      validate_soap_action
+      dispatch(root_node)
     end
 
   end

data/lib/savon/wsdl.rb

@@ -18,11 +18,6 @@ module Savon
 
     # Initializer expects an endpoint +uri+ and an +http+ connection instance,
     # then gets and parses the WSDL at the given URI.
-    #
-    # === Parameters
-    #
-    # * +uri+ - The URI of the WSDL.
-    # * +http+ - The Net::HTTP connection instance to use.
     def initialize(uri, http)
       @uri, @http = uri, http
       get_wsdl

data/lib/savon.rb

@@ -1,5 +1,4 @@
 $:.unshift(File.join(File.dirname(__FILE__), "savon"))
 require "service"
-require "response"
 require "wsdl"
-require "mash"
+require "response"

data/test/fixtures/soap_response_fixture.rb

@@ -0,0 +1,75 @@
+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 << '</faultstring>' <<
+          '</soap:Fault>' <<
+       '</soap:Body>' <<
+    '</soap:Envelope>'
+  end
+
+  def soap_fault
+    "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

@@ -6,7 +6,7 @@ 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")
+require File.join(File.dirname(__FILE__), "fixtures", "soap_response_fixture")
 
 module TestHelper
 

data/test/savon/response_test.rb

@@ -5,116 +5,129 @@ class SavonResponseTest < Test::Unit::TestCase
   include TestHelper
   include SoapResponseFixture
 
-  context "Savon::Response with some SOAP response" do
-    setup do
-      ApricotEatsGorilla.sort_keys = true
-      @response = Savon::Response.new(response_mock(some_soap_response))
-    end
-
-    should "return a Hash on to_hash" do
-      assert_kind_of Hash, @response.to_hash
-    end
-
-    should "return a Hash equal to the response on to_hash" do
-      assert_equal ApricotEatsGorilla[some_soap_response, "//return"], @response.to_hash
-    end
-
-    should "return a Mash object on to_mash" do
-      assert_kind_of Savon::Mash, @response.to_mash
-    end
-
-    should "return a Mash object equal to the response on to_mash" do
-      assert_equal "secret", @response.to_mash.token
-    end
-
-    should "return the raw XML response on to_s" do
-      assert_equal some_soap_response, @response.to_s
-    end
-
-    should "return 'true' on success?" do
-      assert_equal true, @response.success?
-    end
-
-    should "return 'false' on error?" do
-      assert_equal false, @response.error?
-    end
-
-    should "return 'nil' for error_message" do
-      assert_equal nil, @response.error_message
-    end
-
-    should "return 'nil' for error_code" do
-      assert_equal nil, @response.error_code
-    end
-  end
-
-  context "Savon::Response with SOAP::Fault response" do
-    setup do
-      ApricotEatsGorilla.sort_keys = true
-      @response = Savon::Response.new(response_mock(soap_fault_response))
-    end
-
-    should "return 'nil' on to_hash" do
-      assert_equal nil, @response.to_hash
-    end
-
-    should "return 'nil' on to_mash" do
-      assert_equal nil, @response.to_mash
-    end
-
-    should "return the raw XML response on to_s" do
-      assert_equal soap_fault_response, @response.to_s
-    end
-
-    should "return 'false' on success?" do
-      assert_equal false, @response.success?
-    end
-
-    should "return 'true' on error?" do
-      assert_equal true, @response.error?
-    end
-
-    should "return the error message on error_message" do
-      assert_equal soap_fault, @response.error_message
-    end
-
-    should "return the error code on error_code" do
-      assert_equal soap_fault_code, @response.error_code
-    end
-  end
-
-  context "Savon::Response with 404 error" do
-    setup do
-      ApricotEatsGorilla.sort_keys = true
-      @response = Savon::Response.new(response_fault_mock)
-    end
-
-    should "return 'nil' on to_hash" do
-      assert_equal nil, @response.to_hash
-    end
-
-    should "return 'nil' on to_mash" do
-      assert_equal nil, @response.to_mash
-    end
-
-    should "return nil on to_s" do
-      assert_equal nil, @response.to_s
-    end
-
-    should "return 'false' on success?" do
-      assert_equal false, @response.success?
-    end
-
-    should "return 'true' on error?" do
-      assert_equal true, @response.error?
-    end
-
-    should "return the error message on error_message" do
-      assert_equal "NotFound", @response.error_message
-    end
-
-    should "return the error code on error_code" do
-      assert_equal "404", @response.error_code
+  context "A Savon::Response instance" do
+
+    context "initialized with a Net::HTTPResponse containing a successful SOAP response" do
+      setup do
+        ApricotEatsGorilla.sort_keys = true
+        Savon::Response.core_methods_to_shadow = [:id] # set to default
+        @response = Savon::Response.new response_mock(some_soap_response)
+      end
+
+      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 do
+        ApricotEatsGorilla.sort_keys = true
+        Savon::Response.core_methods_to_shadow = [:id] # set to default
+        @response = Savon::Response.new some_response_hash
+      end
+
+      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
 
   end

data/test/savon_test.rb

@@ -1,5 +1,4 @@
 $:.unshift(File.join(File.dirname(__FILE__), "savon"))
 require "service_test"
-require "response_test"
-require "mash_test"
 require "wsdl_test"
+require "response_test"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: smacks-savon
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Daniel Harrington
@@ -30,7 +30,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.4.1
+        version: 0.4.3
     version: 
 description: Ruby SOAP client library to enjoy.
 email: 
@@ -46,7 +46,6 @@ files:
 - lib/savon/service.rb
 - lib/savon/wsdl.rb
 - lib/savon/response.rb
-- lib/savon/mash.rb
 has_rdoc: true
 homepage: http://github.com/smacks/savon
 post_install_message: 
@@ -78,8 +77,7 @@ test_files:
 - test/savon_test.rb
 - test/helper.rb
 - test/factories/wsdl.rb
-- test/fixtures/soap_response.rb
+- test/fixtures/soap_response_fixture.rb
 - test/savon/service_test.rb
 - test/savon/response_test.rb
 - test/savon/wsdl_test.rb
-- test/savon/mash_test.rb

data/lib/savon/mash.rb

@@ -1,61 +0,0 @@
-module Savon
-
-  # Savon::Mash converts a given Hash into an Object.
-  class Mash
-
-    # Iterates through a given +hash+, stores each value in an instance
-    # variable and creates getter and setter methods.
-    #
-    # === Parameters
-    #
-    # * +hash+ - The Hash to convert.
-    def initialize(hash)
-      hash.each do |key,value|
-        value = Savon::Mash.new(value) if value.is_a? Hash
-
-        if value.is_a? Array
-          value = value.map do |item|
-            if item.is_a?(Hash) then Savon::Mash.new(item) else item end
-          end
-        end
-
-        set_instance_variable(key, value)
-        define_reader(key)
-        define_writer(key)
-      end
-    end
-
-  private
-
-    # Sets and instance variable with a given +name+ and +value+.
-    #
-    # === Parameters
-    #
-    # * +name+ - Name of the instance variable.
-    # * +value+ - Value of the instance variable.
-    def set_instance_variable(name, value)
-      self.instance_variable_set("@#{name}", value)
-    end
-
-    # Defines a reader method for a given instance +variable+.
-    #
-    # === Parameters
-    #
-    # * +variable+ - Name of the instance variable.
-    def define_reader(variable)
-      method = proc { self.instance_variable_get("@#{variable}") }
-      self.class.send(:define_method, variable, method)
-    end
-
-    # Defines a writer method for a given instance +variable+.
-    #
-    # === Parameters
-    #
-    # * +variable+ - Name of the instance variable.
-    def define_writer(variable)
-      method = proc { |value| self.instance_variable_set("@#{variable}", value) }
-      self.class.send(:define_method, "#{variable}=", method)
-    end
-
-  end
-end

data/test/fixtures/soap_response.rb

@@ -1,34 +0,0 @@
-module SoapResponseFixture
-
-  def some_soap_response
-    '<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">' <<
-      '<soap:Body>' <<
-        '<ns2:result xmlns:ns2="http://example.com/">' <<
-          '<return>' <<
-            '<token>secret</token>' <<
-          '</return>' <<
-        '</ns2:result>' <<
-      '</soap:Body>' <<
-    '</soap:Envelope>'
-  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 << '</faultstring>' <<
-          '</soap:Fault>' <<
-       '</soap:Body>' <<
-    '</soap:Envelope>'
-  end
-
-  def soap_fault
-    "Failed to authenticate client."
-  end
-
-  def soap_fault_code
-    "soap:Server"
-  end
-
-end

data/test/savon/mash_test.rb

@@ -1,18 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "helper")
-
-class SavonMashTest < Test::Unit::TestCase
-
-  context "Creating a new Savon::Mash" do
-    context "with a simple Hash" do
-      should "return a Mash object matching the given Hash" do
-        hash = { :some => { :simple => "test" } }
-        mash = Savon::Mash.new(hash)
-
-        assert_respond_to(mash, :some)
-        assert_respond_to(mash, :simple)
-        assert_equal "test", mash.some.simple
-      end
-    end
-  end
-
-end