activeresource 2.0.5 → 2.1.0

data/lib/active_resource/connection.rb

@@ -18,6 +18,14 @@ module ActiveResource
     end
   end
 
+  # Raised when a Timeout::Error occurs.
+  class TimeoutError < ConnectionError
+    def initialize(message)
+      @message = message
+    end
+    def to_s; @message ;end
+  end
+
   # 3xx Redirection
   class Redirection < ConnectionError # :nodoc:
     def to_s; response['Location'] ? "#{super} => #{response['Location']}" : super; end    
@@ -55,7 +63,7 @@ module ActiveResource
   # This class is used by ActiveResource::Base to interface with REST
   # services.
   class Connection
-    attr_reader :site
+    attr_reader :site, :user, :password, :timeout
     attr_accessor :format
 
     class << self
@@ -68,6 +76,7 @@ module ActiveResource
     # attribute to the URI for the remote resource service.
     def initialize(site, format = ActiveResource::Formats[:xml])
       raise ArgumentError, 'Missing site URI' unless site
+      @user = @password = nil
       self.site = site
       self.format = format
     end
@@ -75,6 +84,23 @@ module ActiveResource
     # Set URI for remote service.
     def site=(site)
       @site = site.is_a?(URI) ? site : URI.parse(site)
+      @user = URI.decode(@site.user) if @site.user
+      @password = URI.decode(@site.password) if @site.password
+    end
+
+    # Set user for remote service.
+    def user=(user)
+      @user = user
+    end
+
+    # Set password for remote service.
+    def password=(password)
+      @password = password
+    end
+
+    # Set the number of seconds after which HTTP requests to the remote service should time out.
+    def timeout=(timeout)
+      @timeout = timeout
     end
 
     # Execute a GET request.
@@ -101,6 +127,12 @@ module ActiveResource
       request(:post, path, body.to_s, build_request_headers(headers))
     end
 
+    # Execute a HEAD request.
+    # Used to obtain meta-information about resources, such as whether they exist and their size (via response headers).
+    def head(path, headers = {})
+      request(:head, path, build_request_headers(headers))
+    end
+
 
     private
       # Makes request to remote service.
@@ -108,8 +140,10 @@ module ActiveResource
         logger.info "#{method.to_s.upcase} #{site.scheme}://#{site.host}:#{site.port}#{path}" if logger
         result = nil
         time = Benchmark.realtime { result = http.send(method, path, *arguments) }
-        logger.info "--> #{result.code} #{result.message} (#{result.body ? result.body : 0}b %.2fs)" % time if logger
+        logger.info "--> #{result.code} #{result.message} (#{result.body ? result.body.length : 0}b %.2fs)" % time if logger
         handle_response(result)
+      rescue Timeout::Error => e
+        raise TimeoutError.new(e.message)
       end
 
       # Handles response and error codes from remote service.
@@ -148,21 +182,22 @@ module ActiveResource
         http             = Net::HTTP.new(@site.host, @site.port)
         http.use_ssl     = @site.is_a?(URI::HTTPS)
         http.verify_mode = OpenSSL::SSL::VERIFY_NONE if http.use_ssl
+        http.read_timeout = @timeout if @timeout # If timeout is not set, the default Net::HTTP timeout (60s) is used.
         http
       end
 
       def default_header
         @default_header ||= { 'Content-Type' => format.mime_type }
       end
-      
+
       # Builds headers for request to remote service.
       def build_request_headers(headers)
         authorization_header.update(default_header).update(headers)
       end
-      
-      # Sets authorization header; authentication information is pulled from credentials provided with site URI.
+
+      # Sets authorization header
       def authorization_header
-        (@site.user || @site.password ? { 'Authorization' => 'Basic ' + ["#{@site.user}:#{ @site.password}"].pack('m').delete("\r\n") } : {})
+        (@user || @password ? { 'Authorization' => 'Basic ' + ["#{@user}:#{ @password}"].pack('m').delete("\r\n") } : {})
       end
 
       def logger #:nodoc:

data/lib/active_resource/custom_methods.rb

@@ -7,12 +7,12 @@ module ActiveResource
   #                           :member => { :promote => :put, :deactivate => :delete }
   #                           :collection => { :active => :get }
   #
-  #  This route set creates routes for the following http requests:
+  #  This route set creates routes for the following HTTP requests:
   #
-  #    POST    /people/new/register.xml #=> PeopleController.register
-  #    PUT     /people/1/promote.xml    #=> PeopleController.promote with :id => 1
-  #    DELETE  /people/1/deactivate.xml #=> PeopleController.deactivate with :id => 1
-  #    GET     /people/active.xml       #=> PeopleController.active
+  #    POST    /people/new/register.xml # PeopleController.register
+  #    PUT     /people/1/promote.xml    # PeopleController.promote with :id => 1
+  #    DELETE  /people/1/deactivate.xml # PeopleController.deactivate with :id => 1
+  #    GET     /people/active.xml       # PeopleController.active
   #
   # Using this module, Active Resource can use these custom REST methods just like the
   # standard methods.
@@ -48,8 +48,8 @@ module ActiveResource
           #   # => [{:id => 1, :name => 'Ryan'}]
           #
           # Note: the objects returned from this method are not automatically converted
-          # into ActiveResource instances - they are ordinary Hashes. If you are expecting
-          # ActiveResource instances, use the <tt>find</tt> class method with the
+          # into Active Resource instances - they are ordinary Hashes. If you are expecting
+          # Active Resource instances, use the <tt>find</tt> class method with the
           # <tt>:from</tt> option. For example:
           #
           #   Person.find(:all, :from => :active)

data/lib/active_resource/formats/xml_format.rb

@@ -21,7 +21,7 @@ module ActiveResource
       
       private
         # Manipulate from_xml Hash, because xml_simple is not exactly what we
-        # want for ActiveResource.
+        # want for Active Resource.
         def from_xml_data(data)
           if data.is_a?(Hash) && data.keys.size == 1
             data.values.first

data/lib/active_resource/http_mock.rb

@@ -3,13 +3,57 @@ require 'active_resource/connection'
 module ActiveResource
   class InvalidRequestError < StandardError; end #:nodoc:
 
+  # One thing that has always been a pain with remote web services is testing.  The HttpMock
+  # class makes it easy to test your Active Resource models by creating a set of mock responses to specific
+  # requests.
+  #
+  # To test your Active Resource model, you simply call the ActiveResource::HttpMock.respond_to
+  # method with an attached block.  The block declares a set of URIs with expected input, and the output
+  # each request should return.  The passed in block has any number of entries in the following generalized
+  # format:
+  #
+  #   mock.http_method(path, request_headers = {}, body = nil, status = 200, response_headers = {})
+  #
+  # * <tt>http_method</tt> - The HTTP method to listen for.  This can be +get+, +post+, +put+, +delete+ or
+  #   +head+.
+  # * <tt>path</tt> - A string, starting with a "/", defining the URI that is expected to be
+  #   called.
+  # * <tt>request_headers</tt> - Headers that are expected along with the request.  This argument uses a
+  #   hash format, such as <tt>{ "Content-Type" => "application/xml" }</tt>.  This mock will only trigger
+  #   if your tests sends a request with identical headers.
+  # * <tt>body</tt> - The data to be returned.  This should be a string of Active Resource parseable content,
+  #   such as XML.
+  # * <tt>status</tt> - The HTTP response code, as an integer, to return with the response.
+  # * <tt>response_headers</tt> - Headers to be returned with the response.  Uses the same hash format as
+  #   <tt>request_headers</tt> listed above.
+  #
+  # In order for a mock to deliver its content, the incoming request must match by the <tt>http_method</tt>,
+  # +path+ and <tt>request_headers</tt>.  If no match is found an InvalidRequestError exception
+  # will be raised letting you know you need to create a new mock for that request.
+  #
+  # ==== Example
+  #   def setup
+  #     @matz  = { :id => 1, :name => "Matz" }.to_xml(:root => "person")
+  #     ActiveResource::HttpMock.respond_to do |mock|
+  #       mock.post   "/people.xml",   {}, @matz, 201, "Location" => "/people/1.xml"
+  #       mock.get    "/people/1.xml", {}, @matz
+  #       mock.put    "/people/1.xml", {}, nil, 204
+  #       mock.delete "/people/1.xml", {}, nil, 200
+  #     end
+  #   end
+  #   
+  #   def test_get_matz
+  #     person = Person.find(1)
+  #     assert_equal "Matz", person.name
+  #   end
+  #
   class HttpMock
-    class Responder
+    class Responder #:nodoc:
       def initialize(responses)
         @responses = responses
       end
 
-      for method in [ :post, :put, :get, :delete ]
+      for method in [ :post, :put, :get, :delete, :head ]
         module_eval <<-EOE, __FILE__, __LINE__
           def #{method}(path, request_headers = {}, body = nil, status = 200, response_headers = {})
             @responses[Request.new(:#{method}, path, nil, request_headers)] = Response.new(body || "", status, response_headers)
@@ -19,15 +63,41 @@ module ActiveResource
     end
 
     class << self
+
+      # Returns an array of all request objects that have been sent to the mock.  You can use this to check
+      # wether or not your model actually sent an HTTP request.
+      #
+      # ==== Example
+      #   def setup
+      #     @matz  = { :id => 1, :name => "Matz" }.to_xml(:root => "person")
+      #     ActiveResource::HttpMock.respond_to do |mock|
+      #       mock.get "/people/1.xml", {}, @matz
+      #     end
+      #   end
+      #   
+      #   def test_should_request_remote_service
+      #     person = Person.find(1)  # Call the remote service
+      #     
+      #     # This request object has the same HTTP method and path as declared by the mock
+      #     expected_request = ActiveResource::Request.new(:get, "/people/1.xml")
+      #     
+      #     # Assert that the mock received, and responded to, the expected request from the model
+      #     assert ActiveResource::HttpMock.requests.include?(expected_request)
+      #   end
       def requests
         @@requests ||= []
       end
 
+      # Returns a hash of <tt>request => response</tt> pairs for all all responses this mock has delivered, where +request+
+      # is an instance of ActiveResource::Request and the response is, naturally, an instance of
+      # ActiveResource::Response.
       def responses
         @@responses ||= {}
       end
 
-      def respond_to(pairs = {})
+      # Accepts a block which declares a set of requests and responses for the HttpMock to respond to. See the main
+      # ActiveResource::HttpMock description for a more detailed explanation.
+      def respond_to(pairs = {}) #:yields: mock
         reset!
         pairs.each do |(path, response)|
           responses[path] = response
@@ -40,6 +110,7 @@ module ActiveResource
         end
       end
 
+      # Deletes all logged requests and responses.
       def reset!
         requests.clear
         responses.clear
@@ -56,7 +127,7 @@ module ActiveResource
       EOE
     end
 
-    for method in [ :get, :delete ]
+    for method in [ :get, :delete, :head ]
       module_eval <<-EOE, __FILE__, __LINE__
         def #{method}(path, headers)
           request = ActiveResource::Request.new(:#{method}, path, nil, headers)
@@ -66,7 +137,7 @@ module ActiveResource
       EOE
     end
 
-    def initialize(site)
+    def initialize(site) #:nodoc:
       @site = site
     end
   end

data/lib/active_resource/validations.rb

@@ -216,8 +216,8 @@ module ActiveResource
     end
   end
   
-  # Module to allow validation of ActiveResource objects, which creates an Errors instance for every resource.
-  # Methods are implemented by overriding +Base#validate+ or its variants   Each of these methods can inspect 
+  # Module to allow validation of Active Resource objects, which creates an Errors instance for every resource.
+  # Methods are implemented by overriding Base#validate or its variants   Each of these methods can inspect 
   # the state of the object, which usually means  ensuring that a number of attributes have a certain value 
   # (such as not empty, within a given range, matching a certain regular expression and so on).
   #

data/lib/active_resource/version.rb

@@ -1,8 +1,8 @@
 module ActiveResource
   module VERSION #:nodoc:
     MAJOR = 2
-    MINOR = 0
-    TINY  = 5
+    MINOR = 1
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/abstract_unit.rb

@@ -7,4 +7,16 @@ require 'active_resource/http_mock'
 $:.unshift "#{File.dirname(__FILE__)}/../test"
 require 'setter_trap'
 
-ActiveResource::Base.logger = Logger.new("#{File.dirname(__FILE__)}/debug.log")
+ActiveResource::Base.logger = Logger.new("#{File.dirname(__FILE__)}/debug.log")
+
+# Wrap tests that use Mocha and skip if unavailable.
+def uses_mocha(test_name)
+  unless Object.const_defined?(:Mocha)
+    require 'mocha'
+    require 'stubba'
+  end
+  yield
+rescue LoadError => load_error
+  raise unless load_error.message =~ /mocha/i
+  $stderr.puts "Skipping #{test_name} tests. `gem install mocha` and try again."
+end

data/test/authorization_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/abstract_unit"
+require 'abstract_unit'
 
 class AuthorizationTest < Test::Unit::TestCase
   Response = Struct.new(:code)
@@ -45,6 +45,47 @@ class AuthorizationTest < Test::Unit::TestCase
     assert_equal ["", "test123"], ActiveSupport::Base64.decode64(authorization[1]).split(":")[0..1]
   end
   
+  def test_authorization_header_with_decoded_credentials_from_url
+    @conn = ActiveResource::Connection.new("http://my%40email.com:%31%32%33@localhost")
+    authorization_header = @conn.send!(:authorization_header)
+    authorization = authorization_header["Authorization"].to_s.split
+
+    assert_equal "Basic", authorization[0]
+    assert_equal ["my@email.com", "123"], ActiveSupport::Base64.decode64(authorization[1]).split(":")[0..1]
+  end
+
+  def test_authorization_header_explicitly_setting_username_and_password
+    @authenticated_conn = ActiveResource::Connection.new("http://@localhost")
+    @authenticated_conn.user = 'david'
+    @authenticated_conn.password = 'test123'
+    authorization_header = @authenticated_conn.send!(:authorization_header)
+    assert_equal @authorization_request_header['Authorization'], authorization_header['Authorization']
+    authorization = authorization_header["Authorization"].to_s.split
+
+    assert_equal "Basic", authorization[0]
+    assert_equal ["david", "test123"], ActiveSupport::Base64.decode64(authorization[1]).split(":")[0..1]
+  end
+
+  def test_authorization_header_explicitly_setting_username_but_no_password
+    @conn = ActiveResource::Connection.new("http://@localhost")
+    @conn.user = "david"
+    authorization_header = @conn.send!(:authorization_header)
+    authorization = authorization_header["Authorization"].to_s.split
+
+    assert_equal "Basic", authorization[0]
+    assert_equal ["david"], ActiveSupport::Base64.decode64(authorization[1]).split(":")[0..1]
+  end
+
+  def test_authorization_header_explicitly_setting_password_but_no_username
+    @conn = ActiveResource::Connection.new("http://@localhost")
+    @conn.password = "test123"
+    authorization_header = @conn.send!(:authorization_header)
+    authorization = authorization_header["Authorization"].to_s.split
+
+    assert_equal "Basic", authorization[0]
+    assert_equal ["", "test123"], ActiveSupport::Base64.decode64(authorization[1]).split(":")[0..1]
+  end
+
   def test_get
     david = @authenticated_conn.get("/people/2.xml")
     assert_equal "David", david["name"]

data/test/base/custom_methods_test.rb

@@ -1,6 +1,6 @@
-require "#{File.dirname(__FILE__)}/../abstract_unit"
-require "#{File.dirname(__FILE__)}/../fixtures/person"
-require "#{File.dirname(__FILE__)}/../fixtures/street_address"
+require 'abstract_unit'
+require 'fixtures/person'
+require 'fixtures/street_address'
 
 class CustomMethodsTest < Test::Unit::TestCase
   def setup
@@ -32,6 +32,9 @@ class CustomMethodsTest < Test::Unit::TestCase
       mock.put    "/people/1/addresses/sort.xml?by=name", {}, nil, 204
       mock.post   "/people/1/addresses/new/link.xml", {}, { :street => '12345 Street' }.to_xml(:root => 'address'), 201, 'Location' => '/people/1/addresses/2.xml'
     end
+
+    Person.user = nil
+    Person.password = nil
   end  
 
   def teardown

data/test/base/equality_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../abstract_unit"
+require 'abstract_unit'
 require "fixtures/person"
 require "fixtures/street_address"
 

data/test/base/load_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../abstract_unit"
+require 'abstract_unit'
 require "fixtures/person"
 require "fixtures/street_address"
 

data/test/base_errors_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/abstract_unit"
+require 'abstract_unit'
 require "fixtures/person"
 
 class BaseErrorsTest < Test::Unit::TestCase

data/test/base_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/abstract_unit"
+require 'abstract_unit'
 require "fixtures/person"
 require "fixtures/street_address"
 require "fixtures/beast"
@@ -7,36 +7,49 @@ class BaseTest < Test::Unit::TestCase
   def setup
     @matz  = { :id => 1, :name => 'Matz' }.to_xml(:root => 'person')
     @david = { :id => 2, :name => 'David' }.to_xml(:root => 'person')
+    @greg  = { :id => 3, :name => 'Greg' }.to_xml(:root => 'person')    
     @addy  = { :id => 1, :street => '12345 Street' }.to_xml(:root => 'address')
     @default_request_headers = { 'Content-Type' => 'application/xml' }
     @rick = { :name => "Rick", :age => 25 }.to_xml(:root => "person")
     @people = [{ :id => 1, :name => 'Matz' }, { :id => 2, :name => 'David' }].to_xml(:root => 'people')
     @people_david = [{ :id => 2, :name => 'David' }].to_xml(:root => 'people')
     @addresses = [{ :id => 1, :street => '12345 Street' }].to_xml(:root => 'addresses')
-    
+
     ActiveResource::HttpMock.respond_to do |mock|
-      mock.get    "/people/1.xml",             {}, @matz
-      mock.get    "/people/2.xml",             {}, @david
-      mock.get    "/people/3.xml",             {'key' => 'value'}, nil, 404
-      mock.put    "/people/1.xml",             {}, nil, 204
-      mock.delete "/people/1.xml",             {}, nil, 200
-      mock.delete "/people/2.xml",             {}, nil, 400
-      mock.get    "/people/99.xml",            {}, nil, 404
-      mock.post   "/people.xml",               {}, @rick, 201, 'Location' => '/people/5.xml'
-      mock.get    "/people.xml",               {}, @people
-      mock.get    "/people/1/addresses.xml",   {}, @addresses
-      mock.get    "/people/1/addresses/1.xml", {}, @addy
-      mock.get    "/people/1/addresses/2.xml", {}, nil, 404
-      mock.get    "/people/2/addresses/1.xml", {}, nil, 404
-      mock.put    "/people/1/addresses/1.xml", {}, nil, 204
-      mock.delete "/people/1/addresses/1.xml", {}, nil, 200
-      mock.post   "/people/1/addresses.xml",   {}, nil, 201, 'Location' => '/people/1/addresses/5'
-      mock.get    "/people//addresses.xml",    {}, nil, 404
-      mock.get    "/people//addresses/1.xml",  {}, nil, 404
-      mock.put    "/people//addresses/1.xml",  {}, nil, 404
-      mock.delete "/people//addresses/1.xml",  {}, nil, 404
-      mock.post   "/people//addresses.xml",    {}, nil, 404
+      mock.get    "/people/1.xml",                {}, @matz
+      mock.get    "/people/2.xml",                {}, @david
+      mock.get    "/people/Greg.xml",             {}, @greg      
+      mock.get    "/people/4.xml",                {'key' => 'value'}, nil, 404
+      mock.put    "/people/1.xml",                {}, nil, 204
+      mock.delete "/people/1.xml",                {}, nil, 200
+      mock.delete "/people/2.xml",                {}, nil, 400
+      mock.get    "/people/99.xml",               {}, nil, 404
+      mock.post   "/people.xml",                  {}, @rick, 201, 'Location' => '/people/5.xml'
+      mock.get    "/people.xml",                  {}, @people
+      mock.get    "/people/1/addresses.xml",      {}, @addresses
+      mock.get    "/people/1/addresses/1.xml",    {}, @addy
+      mock.get    "/people/1/addresses/2.xml",    {}, nil, 404
+      mock.get    "/people/2/addresses/1.xml",    {}, nil, 404
+      mock.get    "/people/Greg/addresses/1.xml", {}, @addy      
+      mock.put    "/people/1/addresses/1.xml",    {}, nil, 204
+      mock.delete "/people/1/addresses/1.xml",    {}, nil, 200
+      mock.post   "/people/1/addresses.xml",      {}, nil, 201, 'Location' => '/people/1/addresses/5'
+      mock.get    "/people//addresses.xml",       {}, nil, 404
+      mock.get    "/people//addresses/1.xml",     {}, nil, 404
+      mock.put    "/people//addresses/1.xml",     {}, nil, 404
+      mock.delete "/people//addresses/1.xml",     {}, nil, 404
+      mock.post   "/people//addresses.xml",       {}, nil, 404
+      mock.head   "/people/1.xml",                {}, nil, 200
+      mock.head   "/people/Greg.xml",             {}, nil, 200
+      mock.head   "/people/99.xml",               {}, nil, 404
+      mock.head   "/people/1/addresses/1.xml",    {}, nil, 200
+      mock.head   "/people/1/addresses/2.xml",    {}, nil, 404
+      mock.head   "/people/2/addresses/1.xml",    {}, nil, 404
+      mock.head   "/people/Greg/addresses/1.xml", {}, nil, 200
     end
+
+    Person.user = nil
+    Person.password = nil
   end
 
 
@@ -63,6 +76,61 @@ class BaseTest < Test::Unit::TestCase
     assert_nil actor.site    
   end
 
+  def test_should_accept_setting_user
+    Forum.user = 'david'
+    assert_equal('david', Forum.user)
+    assert_equal('david', Forum.connection.user)
+  end
+
+  def test_should_accept_setting_password
+    Forum.password = 'test123'
+    assert_equal('test123', Forum.password)
+    assert_equal('test123', Forum.connection.password)
+  end
+
+  def test_should_accept_setting_timeout
+    Forum.timeout = 5
+    assert_equal(5, Forum.timeout)
+    assert_equal(5, Forum.connection.timeout)
+  end
+
+  def test_user_variable_can_be_reset
+    actor = Class.new(ActiveResource::Base)
+    actor.site = 'http://cinema'
+    assert_nil actor.user
+    actor.user = 'username'
+    actor.user = nil
+    assert_nil actor.user
+    assert_nil actor.connection.user
+  end
+
+  def test_password_variable_can_be_reset
+    actor = Class.new(ActiveResource::Base)
+    actor.site = 'http://cinema'
+    assert_nil actor.password
+    actor.password = 'username'
+    actor.password = nil
+    assert_nil actor.password
+    assert_nil actor.connection.password
+  end
+
+  def test_timeout_variable_can_be_reset
+    actor = Class.new(ActiveResource::Base)
+    actor.site = 'http://cinema'
+    assert_nil actor.timeout
+    actor.timeout = 5
+    actor.timeout = nil
+    assert_nil actor.timeout
+    assert_nil actor.connection.timeout
+  end
+
+  def test_credentials_from_site_are_decoded
+    actor = Class.new(ActiveResource::Base)
+    actor.site = 'http://my%40email.com:%31%32%33@cinema'
+    assert_equal("my@email.com", actor.user)
+    assert_equal("123", actor.password)
+  end
+
   def test_site_reader_uses_superclass_site_until_written
     # Superclass is Object so returns nil.
     assert_nil ActiveResource::Base.site
@@ -98,12 +166,122 @@ class BaseTest < Test::Unit::TestCase
     apple = Class.new(fruit)
     
     fruit.site = 'http://market'
-    assert_equal fruit.site, apple.site, 'subclass did not adopt changes to parent class'
+    assert_equal fruit.site, apple.site, 'subclass did not adopt changes from parent class'
     
     fruit.site = 'http://supermarket'
-    assert_equal fruit.site, apple.site, 'subclass did not adopt changes to parent class'    
+    assert_equal fruit.site, apple.site, 'subclass did not adopt changes from parent class'
   end
   
+  def test_user_reader_uses_superclass_user_until_written
+    # Superclass is Object so returns nil.
+    assert_nil ActiveResource::Base.user
+    assert_nil Class.new(ActiveResource::Base).user
+    Person.user = 'anonymous'
+
+    # Subclass uses superclass user.
+    actor = Class.new(Person)
+    assert_equal Person.user, actor.user
+
+    # Subclass returns frozen superclass copy.
+    assert !Person.user.frozen?
+    assert actor.user.frozen?
+
+    # Changing subclass user doesn't change superclass user.
+    actor.user = 'david'
+    assert_not_equal Person.user, actor.user
+
+    # Changing superclass user doesn't overwrite subclass user.
+    Person.user = 'john'
+    assert_not_equal Person.user, actor.user
+
+    # Changing superclass user after subclassing changes subclass user.
+    jester = Class.new(actor)
+    actor.user = 'john.doe'
+    assert_equal actor.user, jester.user
+
+    # Subclasses are always equal to superclass user when not overridden
+    fruit = Class.new(ActiveResource::Base)
+    apple = Class.new(fruit)
+
+    fruit.user = 'manager'
+    assert_equal fruit.user, apple.user, 'subclass did not adopt changes from parent class'
+
+    fruit.user = 'client'
+    assert_equal fruit.user, apple.user, 'subclass did not adopt changes from parent class'
+  end
+
+  def test_password_reader_uses_superclass_password_until_written
+    # Superclass is Object so returns nil.
+    assert_nil ActiveResource::Base.password
+    assert_nil Class.new(ActiveResource::Base).password
+    Person.password = 'my-password'
+
+    # Subclass uses superclass password.
+    actor = Class.new(Person)
+    assert_equal Person.password, actor.password
+
+    # Subclass returns frozen superclass copy.
+    assert !Person.password.frozen?
+    assert actor.password.frozen?
+
+    # Changing subclass password doesn't change superclass password.
+    actor.password = 'secret'
+    assert_not_equal Person.password, actor.password
+
+    # Changing superclass password doesn't overwrite subclass password.
+    Person.password = 'super-secret'
+    assert_not_equal Person.password, actor.password
+
+    # Changing superclass password after subclassing changes subclass password.
+    jester = Class.new(actor)
+    actor.password = 'even-more-secret'
+    assert_equal actor.password, jester.password
+
+    # Subclasses are always equal to superclass password when not overridden
+    fruit = Class.new(ActiveResource::Base)
+    apple = Class.new(fruit)
+
+    fruit.password = 'mega-secret'
+    assert_equal fruit.password, apple.password, 'subclass did not adopt changes from parent class'
+
+    fruit.password = 'ok-password'
+    assert_equal fruit.password, apple.password, 'subclass did not adopt changes from parent class'
+  end
+
+  def test_timeout_reader_uses_superclass_timeout_until_written
+    # Superclass is Object so returns nil.
+    assert_nil ActiveResource::Base.timeout
+    assert_nil Class.new(ActiveResource::Base).timeout
+    Person.timeout = 5
+
+    # Subclass uses superclass timeout.
+    actor = Class.new(Person)
+    assert_equal Person.timeout, actor.timeout
+
+    # Changing subclass timeout doesn't change superclass timeout.
+    actor.timeout = 10
+    assert_not_equal Person.timeout, actor.timeout
+
+    # Changing superclass timeout doesn't overwrite subclass timeout.
+    Person.timeout = 15
+    assert_not_equal Person.timeout, actor.timeout
+
+    # Changing superclass timeout after subclassing changes subclass timeout.
+    jester = Class.new(actor)
+    actor.timeout = 20
+    assert_equal actor.timeout, jester.timeout
+
+    # Subclasses are always equal to superclass timeout when not overridden.
+    fruit = Class.new(ActiveResource::Base)
+    apple = Class.new(fruit)
+
+    fruit.timeout = 25
+    assert_equal fruit.timeout, apple.timeout, 'subclass did not adopt changes from parent class'
+
+    fruit.timeout = 30
+    assert_equal fruit.timeout, apple.timeout, 'subclass did not adopt changes from parent class'
+  end
+
   def test_updating_baseclass_site_object_wipes_descendent_cached_connection_objects
     # Subclasses are always equal to superclass site when not overridden    
     fruit = Class.new(ActiveResource::Base)
@@ -111,9 +289,60 @@ class BaseTest < Test::Unit::TestCase
     
     fruit.site = 'http://market'
     assert_equal fruit.connection.site, apple.connection.site
+    first_connection = apple.connection.object_id
     
     fruit.site = 'http://supermarket'
-    assert_equal fruit.connection.site, apple.connection.site    
+    assert_equal fruit.connection.site, apple.connection.site
+    second_connection = apple.connection.object_id
+    assert_not_equal(first_connection, second_connection, 'Connection should be re-created')
+  end
+
+  def test_updating_baseclass_user_wipes_descendent_cached_connection_objects
+    # Subclasses are always equal to superclass user when not overridden
+    fruit = Class.new(ActiveResource::Base)
+    apple = Class.new(fruit)
+    fruit.site = 'http://market'
+
+    fruit.user = 'david'
+    assert_equal fruit.connection.user, apple.connection.user
+    first_connection = apple.connection.object_id
+
+    fruit.user = 'john'
+    assert_equal fruit.connection.user, apple.connection.user
+    second_connection = apple.connection.object_id
+    assert_not_equal(first_connection, second_connection, 'Connection should be re-created')
+  end
+
+  def test_updating_baseclass_password_wipes_descendent_cached_connection_objects
+    # Subclasses are always equal to superclass password when not overridden
+    fruit = Class.new(ActiveResource::Base)
+    apple = Class.new(fruit)
+    fruit.site = 'http://market'
+
+    fruit.password = 'secret'
+    assert_equal fruit.connection.password, apple.connection.password
+    first_connection = apple.connection.object_id
+
+    fruit.password = 'supersecret'
+    assert_equal fruit.connection.password, apple.connection.password
+    second_connection = apple.connection.object_id
+    assert_not_equal(first_connection, second_connection, 'Connection should be re-created')
+  end
+
+  def test_updating_baseclass_timeout_wipes_descendent_cached_connection_objects
+    # Subclasses are always equal to superclass timeout when not overridden
+    fruit = Class.new(ActiveResource::Base)
+    apple = Class.new(fruit)
+    fruit.site = 'http://market'
+
+    fruit.timeout = 5
+    assert_equal fruit.connection.timeout, apple.connection.timeout
+    first_connection = apple.connection.object_id
+
+    fruit.timeout = 10
+    assert_equal fruit.connection.timeout, apple.connection.timeout
+    second_connection = apple.connection.object_id
+    assert_not_equal(first_connection, second_connection, 'Connection should be re-created')
   end
 
   def test_collection_name
@@ -144,6 +373,30 @@ class BaseTest < Test::Unit::TestCase
   def test_custom_element_path
     assert_equal '/people/1/addresses/1.xml', StreetAddress.element_path(1, :person_id => 1)
     assert_equal '/people/1/addresses/1.xml', StreetAddress.element_path(1, 'person_id' => 1)
+    assert_equal '/people/Greg/addresses/1.xml', StreetAddress.element_path(1, 'person_id' => 'Greg')    
+  end
+  
+  def test_custom_element_path_with_redefined_to_param
+    Person.module_eval do
+      alias_method :original_to_param_element_path, :to_param
+       def to_param  
+         name
+       end
+    end
+
+    # Class method.
+    assert_equal '/people/Greg.xml', Person.element_path('Greg')
+    
+    # Protected Instance method.
+    assert_equal '/people/Greg.xml', Person.find('Greg').send(:element_path)
+
+    ensure
+      # revert back to original
+      Person.module_eval do
+        # save the 'new' to_param so we don't get a warning about discarding the method
+        alias_method :element_path_to_param, :to_param
+        alias_method :to_param, :original_to_param_element_path
+      end
   end
 
   def test_custom_element_path_with_parameters
@@ -248,7 +501,7 @@ class BaseTest < Test::Unit::TestCase
 
   def test_custom_header
     Person.headers['key'] = 'value'
-    assert_raises(ActiveResource::ResourceNotFound) { Person.find(3) }
+    assert_raises(ActiveResource::ResourceNotFound) { Person.find(4) }
   ensure
     Person.headers.delete('key')
   end
@@ -329,6 +582,26 @@ class BaseTest < Test::Unit::TestCase
     assert_equal address, address.reload
   end
   
+  def test_reload_with_redefined_to_param
+    Person.module_eval do
+      alias_method :original_to_param_reload, :to_param
+       def to_param  
+         name
+       end
+    end
+
+    person = Person.find('Greg')
+    assert_equal person, person.reload
+
+    ensure
+      # revert back to original
+      Person.module_eval do
+        # save the 'new' to_param so we don't get a warning about discarding the method
+        alias_method :reload_to_param, :to_param
+        alias_method :to_param, :original_to_param_reload
+      end
+  end  
+  
   def test_reload_works_without_prefix_options    
     person = Person.find(:first)
     assert_equal person, person.reload
@@ -351,6 +624,41 @@ class BaseTest < Test::Unit::TestCase
     assert_raises(ActiveResource::ResourceConflict) { Person.create(:name => 'Rick') }
   end
 
+  def test_clone
+   matz = Person.find(1)
+   matz_c = matz.clone
+   assert matz_c.new?
+   matz.attributes.each do |k, v|
+     assert_equal v, matz_c.send(k) if k != Person.primary_key
+   end
+ end
+
+ def test_nested_clone
+   addy = StreetAddress.find(1, :params => {:person_id => 1})
+   addy_c = addy.clone
+   assert addy_c.new?
+   addy.attributes.each do |k, v|
+     assert_equal v, addy_c.send(k) if k != StreetAddress.primary_key
+   end
+   assert_equal addy.prefix_options, addy_c.prefix_options
+ end
+
+ def test_complex_clone
+   matz = Person.find(1)
+   matz.address = StreetAddress.find(1, :params => {:person_id => matz.id})
+   matz.non_ar_hash = {:not => "an ARes instance"}
+   matz.non_ar_arr = ["not", "ARes"]
+   matz_c = matz.clone
+   assert matz_c.new?
+   assert_raises(NoMethodError) {matz_c.address}
+   assert_equal matz.non_ar_hash, matz_c.non_ar_hash
+   assert_equal matz.non_ar_arr, matz_c.non_ar_arr
+
+   # Test that actual copy, not just reference copy
+   matz.non_ar_hash[:not] = "changed"
+   assert_not_equal matz.non_ar_hash, matz_c.non_ar_hash
+ end
+
   def test_update
     matz = Person.find(:first)
     matz.name = "David"
@@ -437,6 +745,35 @@ class BaseTest < Test::Unit::TestCase
     assert !StreetAddress.new({:id => 2, :person_id => 1}).exists?
   end
   
+  def test_exists_with_redefined_to_param
+    Person.module_eval do
+      alias_method :original_to_param_exists, :to_param
+       def to_param  
+         name
+       end
+    end
+
+    # Class method.
+    assert Person.exists?('Greg')    
+
+    # Instance method.
+    assert Person.find('Greg').exists?    
+
+    # Nested class method.
+    assert StreetAddress.exists?(1,  :params => { :person_id => Person.find('Greg').to_param })    
+
+    # Nested instance method.
+    assert StreetAddress.find(1, :params => { :person_id => Person.find('Greg').to_param }).exists?
+
+    ensure
+      # revert back to original
+      Person.module_eval do
+        # save the 'new' to_param so we don't get a warning about discarding the method
+        alias_method :exists_to_param, :to_param
+        alias_method :to_param, :original_to_param_exists
+      end
+  end  
+  
   def test_to_xml
     matz = Person.find(1)
     xml = matz.to_xml