webroar 0.2.2

data/src/admin_panel/vendor/rails/activeresource/lib/active_resource/validations.rb

@@ -0,0 +1,274 @@
+module ActiveResource
+  class ResourceInvalid < ClientError  #:nodoc:
+  end
+
+  # Active Resource validation is reported to and from this object, which is used by Base#save
+  # to determine whether the object in a valid state to be saved. See usage example in Validations.  
+  class Errors
+    include Enumerable
+    attr_reader :errors
+
+    delegate :empty?, :to => :errors
+    
+    def initialize(base) # :nodoc:
+      @base, @errors = base, {}
+    end
+
+    # Add an error to the base Active Resource object rather than an attribute.
+    #
+    # ==== Examples
+    #   my_folder = Folder.find(1)
+    #   my_folder.errors.add_to_base("You can't edit an existing folder")
+    #   my_folder.errors.on_base
+    #   # => "You can't edit an existing folder"
+    #
+    #   my_folder.errors.add_to_base("This folder has been tagged as frozen")
+    #   my_folder.valid?
+    #   # => false
+    #   my_folder.errors.on_base
+    #   # => ["You can't edit an existing folder", "This folder has been tagged as frozen"]
+    #
+    def add_to_base(msg)
+      add(:base, msg)
+    end
+
+    # Adds an error to an Active Resource object's attribute (named for the +attribute+ parameter)
+    # with the error message in +msg+.
+    #
+    # ==== Examples
+    #   my_resource = Node.find(1)
+    #   my_resource.errors.add('name', 'can not be "base"') if my_resource.name == 'base'
+    #   my_resource.errors.on('name')
+    #   # => 'can not be "base"!'
+    #
+    #   my_resource.errors.add('desc', 'can not be blank') if my_resource.desc == ''
+    #   my_resource.valid?
+    #   # => false
+    #   my_resource.errors.on('desc')
+    #   # => 'can not be blank!'
+    #
+    def add(attribute, msg)
+      @errors[attribute.to_s] = [] if @errors[attribute.to_s].nil?
+      @errors[attribute.to_s] << msg
+    end
+
+    # Returns true if the specified +attribute+ has errors associated with it.
+    #
+    # ==== Examples
+    #   my_resource = Disk.find(1)
+    #   my_resource.errors.add('location', 'must be Main') unless my_resource.location == 'Main'
+    #   my_resource.errors.on('location')
+    #   # => 'must be Main!'
+    #
+    #   my_resource.errors.invalid?('location')
+    #   # => true
+    #   my_resource.errors.invalid?('name')
+    #   # => false
+    def invalid?(attribute)
+      !@errors[attribute.to_s].nil?
+    end
+
+    # A method to return the errors associated with +attribute+, which returns nil, if no errors are 
+    # associated with the specified +attribute+, the error message if one error is associated with the specified +attribute+,
+    # or an array of error messages if more than one error is associated with the specified +attribute+.
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #   my_person.errors.on('login')
+    #   # => nil
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.on('login')
+    #   # => 'can not be empty'
+    #
+    #   my_person.errors.add('login', 'can not be longer than 10 characters') if my_person.login.length > 10
+    #   my_person.errors.on('login')
+    #   # => ['can not be empty', 'can not be longer than 10 characters']
+    def on(attribute)
+      errors = @errors[attribute.to_s]
+      return nil if errors.nil?
+      errors.size == 1 ? errors.first : errors
+    end
+    
+    alias :[] :on
+
+    # A method to return errors assigned to +base+ object through add_to_base, which returns nil, if no errors are 
+    # associated with the specified +attribute+, the error message if one error is associated with the specified +attribute+,
+    # or an array of error messages if more than one error is associated with the specified +attribute+.
+    #
+    # ==== Examples
+    #   my_account = Account.find(1)
+    #   my_account.errors.on_base
+    #   # => nil
+    #
+    #   my_account.errors.add_to_base("This account is frozen")
+    #   my_account.errors.on_base
+    #   # => "This account is frozen"
+    #
+    #   my_account.errors.add_to_base("This account has been closed")
+    #   my_account.errors.on_base
+    #   # => ["This account is frozen", "This account has been closed"]
+    #
+    def on_base
+      on(:base)
+    end
+
+    # Yields each attribute and associated message per error added.
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
+    #   messages = ''
+    #   my_person.errors.each {|attr, msg| messages += attr.humanize + " " + msg + "<br />"}
+    #   messages
+    #   # => "Login can not be empty<br />Password can not be empty<br />"
+    #
+    def each
+      @errors.each_key { |attr| @errors[attr].each { |msg| yield attr, msg } }
+    end
+
+    # Yields each full error message added. So Person.errors.add("first_name", "can't be empty") will be returned
+    # through iteration as "First name can't be empty".
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
+    #   messages = ''
+    #   my_person.errors.each_full {|msg| messages += msg + "<br/>"}
+    #   messages
+    #   # => "Login can not be empty<br />Password can not be empty<br />"
+    #
+    def each_full
+      full_messages.each { |msg| yield msg }
+    end
+
+    # Returns all the full error messages in an array.
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
+    #   messages = ''
+    #   my_person.errors.full_messages.each {|msg| messages += msg + "<br/>"}
+    #   messages
+    #   # => "Login can not be empty<br />Password can not be empty<br />"
+    #
+    def full_messages
+      full_messages = []
+
+      @errors.each_key do |attr|
+        @errors[attr].each do |msg|
+          next if msg.nil?
+
+          if attr == "base"
+            full_messages << msg
+          else
+            full_messages << [attr.humanize, msg].join(' ')
+          end
+        end
+      end
+      full_messages
+    end
+
+    def clear
+      @errors = {}
+    end
+
+    # Returns the total number of errors added. Two errors added to the same attribute will be counted as such
+    # with this as well.
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #   my_person.errors.size
+    #   # => 0
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
+    #   my_person.error.size
+    #   # => 2
+    #
+    def size
+      @errors.values.inject(0) { |error_count, attribute| error_count + attribute.size }
+    end
+
+    alias_method :count, :size
+    alias_method :length, :size
+    
+    # Grabs errors from the XML response.
+    def from_xml(xml)
+      clear
+      humanized_attributes = @base.attributes.keys.inject({}) { |h, attr_name| h.update(attr_name.humanize => attr_name) }
+      messages = Array.wrap(Hash.from_xml(xml)['errors']['error']) rescue []
+      messages.each do |message|
+        attr_message = humanized_attributes.keys.detect do |attr_name|
+          if message[0, attr_name.size + 1] == "#{attr_name} "
+            add humanized_attributes[attr_name], message[(attr_name.size + 1)..-1]
+          end
+        end
+        
+        add_to_base message if attr_message.nil?
+      end
+    end
+  end
+  
+  # Module to support validation and errors with Active Resource objects. The module overrides
+  # Base#save to rescue ActiveResource::ResourceInvalid exceptions and parse the errors returned 
+  # in the web service response. The module also adds an +errors+ collection that mimics the interface 
+  # of the errors provided by ActiveRecord::Errors.
+  #
+  # ==== Example
+  #
+  # Consider a Person resource on the server requiring both a +first_name+ and a +last_name+ with a 
+  # <tt>validates_presence_of :first_name, :last_name</tt> declaration in the model:
+  #
+  #   person = Person.new(:first_name => "Jim", :last_name => "")
+  #   person.save                   # => false (server returns an HTTP 422 status code and errors)
+  #   person.valid?                 # => false
+  #   person.errors.empty?          # => false
+  #   person.errors.count           # => 1
+  #   person.errors.full_messages   # => ["Last name can't be empty"]
+  #   person.errors.on(:last_name)  # => "can't be empty"
+  #   person.last_name = "Halpert"  
+  #   person.save                   # => true (and person is now saved to the remote service)
+  #
+  module Validations
+    def self.included(base) # :nodoc:
+      base.class_eval do
+        alias_method_chain :save, :validation
+      end
+    end
+
+    # Validate a resource and save (POST) it to the remote web service.
+    def save_with_validation
+      save_without_validation
+      true
+    rescue ResourceInvalid => error
+      errors.from_xml(error.response.body)
+      false
+    end
+
+    # Checks for errors on an object (i.e., is resource.errors empty?).
+    # 
+    # ==== Examples
+    #   my_person = Person.create(params[:person])
+    #   my_person.valid?
+    #   # => true
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.valid?
+    #   # => false
+    def valid?
+      errors.empty?
+    end
+
+    # Returns the Errors object that holds all information about attribute error messages.
+    def errors
+      @errors ||= Errors.new(self)
+    end
+  end
+end

data/src/admin_panel/vendor/rails/activeresource/lib/active_resource/version.rb

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

data/src/admin_panel/vendor/rails/activeresource/lib/active_resource.rb

@@ -0,0 +1,44 @@
+#--
+# Copyright (c) 2006 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+begin
+  require 'active_support'
+rescue LoadError
+  activesupport_path = "#{File.dirname(__FILE__)}/../../activesupport/lib"
+  if File.directory?(activesupport_path)
+    $:.unshift activesupport_path
+    require 'active_support'
+  end
+end
+
+require 'active_resource/formats'
+require 'active_resource/base'
+require 'active_resource/validations'
+require 'active_resource/custom_methods'
+
+module ActiveResource
+  Base.class_eval do
+    include Validations
+    include CustomMethods
+  end
+end

data/src/admin_panel/vendor/rails/activeresource/lib/activeresource.rb

@@ -0,0 +1 @@
+require 'active_resource'

data/src/admin_panel/vendor/rails/activeresource/test/abstract_unit.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'test/unit'
+
+gem 'mocha', '>= 0.9.5'
+require 'mocha'
+
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+$:.unshift "#{File.dirname(__FILE__)}/../../activesupport/lib"
+require 'active_resource'
+require 'active_resource/http_mock'
+
+$:.unshift "#{File.dirname(__FILE__)}/../test"
+require 'setter_trap'
+
+ActiveResource::Base.logger = Logger.new("#{File.dirname(__FILE__)}/debug.log")
+
+def uses_gem(gem_name, test_name, version = '> 0')
+  gem gem_name.to_s, version
+  require gem_name.to_s
+  yield
+rescue LoadError
+  $stderr.puts "Skipping #{test_name} tests. `gem install #{gem_name}` and try again."
+end

data/src/admin_panel/vendor/rails/activeresource/test/authorization_test.rb

@@ -0,0 +1,122 @@
+require 'abstract_unit'
+
+class AuthorizationTest < Test::Unit::TestCase
+  Response = Struct.new(:code)
+
+  def setup
+    @conn = ActiveResource::Connection.new('http://localhost')
+    @matz  = { :id => 1, :name => 'Matz' }.to_xml(:root => 'person')
+    @david = { :id => 2, :name => 'David' }.to_xml(:root => 'person')
+    @authenticated_conn = ActiveResource::Connection.new("http://david:test123@localhost")
+    @authorization_request_header = { 'Authorization' => 'Basic ZGF2aWQ6dGVzdDEyMw==' }
+
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.get    "/people/2.xml",           @authorization_request_header, @david
+      mock.put    "/people/2.xml",           @authorization_request_header, nil, 204
+      mock.delete "/people/2.xml",           @authorization_request_header, nil, 200
+      mock.post   "/people/2/addresses.xml", @authorization_request_header, nil, 201, 'Location' => '/people/1/addresses/5'
+    end
+  end
+
+  def test_authorization_header
+    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_with_username_but_no_password
+    @conn = ActiveResource::Connection.new("http://david:@localhost")
+    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_with_password_but_no_username
+    @conn = ActiveResource::Connection.new("http://:test123@localhost")
+    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_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"]
+  end
+  
+  def test_post
+    response = @authenticated_conn.post("/people/2/addresses.xml")
+    assert_equal "/people/1/addresses/5", response["Location"]
+  end
+  
+  def test_put
+    response = @authenticated_conn.put("/people/2.xml")
+    assert_equal 204, response.code
+  end
+  
+  def test_delete
+    response = @authenticated_conn.delete("/people/2.xml")
+    assert_equal 200, response.code
+  end
+
+  def test_raises_invalid_request_on_unauthorized_requests
+    assert_raise(ActiveResource::InvalidRequestError) { @conn.post("/people/2.xml") }
+    assert_raise(ActiveResource::InvalidRequestError) { @conn.post("/people/2/addresses.xml") }
+    assert_raise(ActiveResource::InvalidRequestError) { @conn.put("/people/2.xml") }
+    assert_raise(ActiveResource::InvalidRequestError) { @conn.delete("/people/2.xml") }
+  end
+
+  protected
+    def assert_response_raises(klass, code)
+      assert_raise(klass, "Expected response code #{code} to raise #{klass}") do
+        @conn.__send__(:handle_response, Response.new(code))
+      end
+    end
+end

data/src/admin_panel/vendor/rails/activeresource/test/base/custom_methods_test.rb

@@ -0,0 +1,100 @@
+require 'abstract_unit'
+require 'fixtures/person'
+require 'fixtures/street_address'
+
+class CustomMethodsTest < Test::Unit::TestCase
+  def setup
+    @matz  = { :id => 1, :name => 'Matz' }.to_xml(:root => 'person')
+    @matz_deep  = { :id => 1, :name => 'Matz', :other => 'other' }.to_xml(:root => 'person')
+    @matz_array = [{ :id => 1, :name => 'Matz' }].to_xml(:root => 'people')
+    @ryan  = { :name => 'Ryan' }.to_xml(:root => 'person')
+    @addy  = { :id => 1, :street => '12345 Street' }.to_xml(:root => 'address')
+    @addy_deep  = { :id => 1, :street => '12345 Street', :zip => "27519" }.to_xml(:root => 'address')
+
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.get    "/people/1.xml",             {}, @matz
+      mock.get    "/people/1/shallow.xml", {}, @matz
+      mock.get    "/people/1/deep.xml", {}, @matz_deep
+      mock.get    "/people/retrieve.xml?name=Matz", {}, @matz_array
+      mock.get    "/people/managers.xml", {}, @matz_array
+      mock.post   "/people/hire.xml?name=Matz", {}, nil, 201
+      mock.put    "/people/1/promote.xml?position=Manager", {}, nil, 204
+      mock.put    "/people/promote.xml?name=Matz", {}, nil, 204, {}
+      mock.put    "/people/sort.xml?by=name", {}, nil, 204
+      mock.delete "/people/deactivate.xml?name=Matz", {}, nil, 200
+      mock.delete "/people/1/deactivate.xml", {}, nil, 200
+      mock.post   "/people/new/register.xml",      {}, @ryan, 201, 'Location' => '/people/5.xml'
+      mock.post   "/people/1/register.xml", {}, @matz, 201
+      mock.get    "/people/1/addresses/1.xml", {}, @addy
+      mock.get    "/people/1/addresses/1/deep.xml", {}, @addy_deep
+      mock.put    "/people/1/addresses/1/normalize_phone.xml?locale=US", {}, nil, 204
+      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
+    ActiveResource::HttpMock.reset!
+  end
+
+  def test_custom_collection_method
+    # GET
+    assert_equal([{ "id" => 1, "name" => 'Matz' }], Person.get(:retrieve, :name => 'Matz'))
+
+    # POST
+    assert_equal(ActiveResource::Response.new("", 201, {}), Person.post(:hire, :name => 'Matz'))
+
+    # PUT
+    assert_equal ActiveResource::Response.new("", 204, {}),
+                   Person.put(:promote, {:name => 'Matz'}, 'atestbody')
+    assert_equal ActiveResource::Response.new("", 204, {}), Person.put(:sort, :by => 'name')
+
+    # DELETE
+    Person.delete :deactivate, :name => 'Matz'
+
+    # Nested resource
+    assert_equal ActiveResource::Response.new("", 204, {}), StreetAddress.put(:sort, :person_id => 1, :by => 'name')
+  end
+
+  def test_custom_element_method
+    # Test GET against an element URL
+    assert_equal Person.find(1).get(:shallow), {"id" => 1, "name" => 'Matz'}
+    assert_equal Person.find(1).get(:deep), {"id" => 1, "name" => 'Matz', "other" => 'other'}
+    
+    # Test PUT against an element URL
+    assert_equal ActiveResource::Response.new("", 204, {}), Person.find(1).put(:promote, {:position => 'Manager'}, 'body')
+    
+    # Test DELETE against an element URL
+    assert_equal ActiveResource::Response.new("", 200, {}), Person.find(1).delete(:deactivate)
+    
+    # With nested resources
+    assert_equal StreetAddress.find(1, :params => { :person_id => 1 }).get(:deep),
+                  { "id" => 1, "street" => '12345 Street', "zip" => "27519" }
+    assert_equal ActiveResource::Response.new("", 204, {}),
+                   StreetAddress.find(1, :params => { :person_id => 1 }).put(:normalize_phone, :locale => 'US')
+  end
+
+  def test_custom_new_element_method
+    # Test POST against a new element URL
+    ryan = Person.new(:name => 'Ryan')
+    assert_equal ActiveResource::Response.new(@ryan, 201, {'Location' => '/people/5.xml'}), ryan.post(:register)
+    expected_request = ActiveResource::Request.new(:post, '/people/new/register.xml', @ryan)
+    assert_equal expected_request.body, ActiveResource::HttpMock.requests.first.body
+
+    # Test POST against a nested collection URL
+    addy = StreetAddress.new(:street => '123 Test Dr.', :person_id => 1)
+    assert_equal ActiveResource::Response.new({ :street => '12345 Street' }.to_xml(:root => 'address'), 
+                   201, {'Location' => '/people/1/addresses/2.xml'}),
+                 addy.post(:link)
+
+    matz = Person.new(:id => 1, :name => 'Matz')
+    assert_equal ActiveResource::Response.new(@matz, 201), matz.post(:register)
+  end
+
+  def test_find_custom_resources
+    assert_equal 'Matz', Person.find(:all, :from => :managers).first.name
+  end
+end

data/src/admin_panel/vendor/rails/activeresource/test/base/equality_test.rb

@@ -0,0 +1,52 @@
+require 'abstract_unit'
+require "fixtures/person"
+require "fixtures/street_address"
+
+class BaseEqualityTest < Test::Unit::TestCase
+  def setup
+    @new = Person.new
+    @one = Person.new(:id => 1)
+    @two = Person.new(:id => 2)
+    @street = StreetAddress.new(:id => 2)
+  end
+
+  def test_should_equal_self
+    assert @new == @new, '@new == @new'
+    assert @one == @one, '@one == @one'
+  end
+
+  def test_shouldnt_equal_new_resource
+    assert @new != @one, '@new != @one'
+    assert @one != @new, '@one != @new'
+  end
+
+  def test_shouldnt_equal_different_class
+    assert @two != @street, 'person != street_address with same id'
+    assert @street != @two, 'street_address != person with same id'
+  end
+
+  def test_eql_should_alias_equals_operator
+    assert_equal @new == @new, @new.eql?(@new)
+    assert_equal @new == @one, @new.eql?(@one)
+
+    assert_equal @one == @one, @one.eql?(@one)
+    assert_equal @one == @new, @one.eql?(@new)
+
+    assert_equal @one == @street, @one.eql?(@street)
+  end
+
+  def test_hash_should_be_id_hash
+    [@new, @one, @two, @street].each do |resource|
+      assert_equal resource.id.hash, resource.hash
+    end
+  end
+
+	def test_with_prefix_options
+    assert_equal @one == @one, @one.eql?(@one)
+    assert_equal @one == @one.dup, @one.eql?(@one.dup)
+    new_one = @one.dup
+    new_one.prefix_options = {:foo => 'bar'}
+    assert_not_equal @one, new_one
+	end
+
+end