activerecord 2.0.5 → 2.1.0

data/test/{defaults_test.rb → cases/defaults_test.rb}

@@ -1,11 +1,11 @@
-require 'abstract_unit'
-require 'fixtures/default'
-require 'fixtures/entrant'
+require "cases/helper"
+require 'models/default'
+require 'models/entrant'
 
-class DefaultTest < Test::Unit::TestCase
+class DefaultTest < ActiveRecord::TestCase
   def test_nil_defaults_for_not_null_columns
     column_defaults =
-      if current_adapter?(:MysqlAdapter)
+      if current_adapter?(:MysqlAdapter) && Mysql.client_version < 50051
         { 'id' => nil, 'name' => '',  'course_id' => nil }
       else
         { 'id' => nil, 'name' => nil, 'course_id' => nil }
@@ -61,7 +61,9 @@ class DefaultTest < Test::Unit::TestCase
 
   if current_adapter?(:PostgreSQLAdapter)
     def test_multiline_default_text
-      assert_equal "--- []\n\n", Default.columns_hash['multiline_default'].default
+      # older postgres versions represent the default with escapes ("\\012" for a newline)
+      assert ( "--- []\n\n" == Default.columns_hash['multiline_default'].default ||
+               "--- []\\012\\012" == Default.columns_hash['multiline_default'].default)
     end
   end
 end

data/test/{deprecated_finder_test.rb → cases/deprecated_finder_test.rb}

@@ -1,7 +1,7 @@
-require 'abstract_unit'
-require 'fixtures/entrant'
+require "cases/helper"
+require 'models/entrant'
 
-class DeprecatedFinderTest < Test::Unit::TestCase
+class DeprecatedFinderTest < ActiveRecord::TestCase
   fixtures :entrants
 
   def test_deprecated_find_all_was_removed

data/test/cases/dirty_test.rb

@@ -0,0 +1,163 @@
+require 'cases/helper'
+require 'models/topic'    # For booleans
+require 'models/pirate'   # For timestamps
+require 'models/parrot'
+
+class Pirate # Just reopening it, not defining it
+  attr_accessor :detected_changes_in_after_update # Boolean for if changes are detected
+  attr_accessor :changes_detected_in_after_update # Actual changes
+
+  after_update :check_changes
+
+private
+  # after_save/update in sweepers, observers, and the model itself
+  # can end up checking dirty status and acting on the results
+  def check_changes
+    if self.changed?
+      self.detected_changes_in_after_update = true
+      self.changes_detected_in_after_update = self.changes
+    end
+  end
+end
+
+class DirtyTest < ActiveRecord::TestCase
+  def test_attribute_changes
+    # New record - no changes.
+    pirate = Pirate.new
+    assert !pirate.catchphrase_changed?
+    assert_nil pirate.catchphrase_change
+
+    # Change catchphrase.
+    pirate.catchphrase = 'arrr'
+    assert pirate.catchphrase_changed?
+    assert_nil pirate.catchphrase_was
+    assert_equal [nil, 'arrr'], pirate.catchphrase_change
+
+    # Saved - no changes.
+    pirate.save!
+    assert !pirate.catchphrase_changed?
+    assert_nil pirate.catchphrase_change
+
+    # Same value - no changes.
+    pirate.catchphrase = 'arrr'
+    assert !pirate.catchphrase_changed?
+    assert_nil pirate.catchphrase_change
+  end
+
+  def test_nullable_integer_not_marked_as_changed_if_new_value_is_blank
+    pirate = Pirate.new
+
+    ["", nil].each do |value|
+      pirate.parrot_id = value
+      assert !pirate.parrot_id_changed?
+      assert_nil pirate.parrot_id_change
+    end
+  end
+
+  def test_object_should_be_changed_if_any_attribute_is_changed
+    pirate = Pirate.new
+    assert !pirate.changed?
+    assert_equal [], pirate.changed
+    assert_equal Hash.new, pirate.changes
+
+    pirate.catchphrase = 'arrr'
+    assert pirate.changed?
+    assert_nil pirate.catchphrase_was
+    assert_equal %w(catchphrase), pirate.changed
+    assert_equal({'catchphrase' => [nil, 'arrr']}, pirate.changes)
+
+    pirate.save
+    assert !pirate.changed?
+    assert_equal [], pirate.changed
+    assert_equal Hash.new, pirate.changes
+  end
+
+  def test_attribute_will_change!
+    pirate = Pirate.create!(:catchphrase => 'arr')
+
+    pirate.catchphrase << ' matey'
+    assert !pirate.catchphrase_changed?
+
+    assert pirate.catchphrase_will_change!
+    assert pirate.catchphrase_changed?
+    assert_equal ['arr matey', 'arr matey'], pirate.catchphrase_change
+
+    pirate.catchphrase << '!'
+    assert pirate.catchphrase_changed?
+    assert_equal ['arr matey', 'arr matey!'], pirate.catchphrase_change
+  end
+
+  def test_association_assignment_changes_foreign_key
+    pirate = Pirate.create!(:catchphrase => 'jarl')
+    pirate.parrot = Parrot.create!
+    assert pirate.changed?
+    assert_equal %w(parrot_id), pirate.changed
+  end
+
+  def test_attribute_should_be_compared_with_type_cast
+    topic = Topic.new
+    assert topic.approved?
+    assert !topic.approved_changed?
+
+    # Coming from web form.
+    params = {:topic => {:approved => 1}}
+    # In the controller.
+    topic.attributes = params[:topic]
+    assert topic.approved?
+    assert !topic.approved_changed?
+  end
+
+  def test_partial_update
+    pirate = Pirate.new(:catchphrase => 'foo')
+    old_updated_on = 1.hour.ago.beginning_of_day
+
+    with_partial_updates Pirate, false do
+      assert_queries(2) { 2.times { pirate.save! } }
+      Pirate.update_all({ :updated_on => old_updated_on }, :id => pirate.id)
+    end
+
+    with_partial_updates Pirate, true do
+      assert_queries(0) { 2.times { pirate.save! } }
+      assert_equal old_updated_on, pirate.reload.updated_on
+
+      assert_queries(1) { pirate.catchphrase = 'bar'; pirate.save! }
+      assert_not_equal old_updated_on, pirate.reload.updated_on
+    end
+  end
+
+  def test_changed_attributes_should_be_preserved_if_save_failure
+    pirate = Pirate.new
+    pirate.parrot_id = 1
+    assert !pirate.save
+    check_pirate_after_save_failure(pirate)
+
+    pirate = Pirate.new
+    pirate.parrot_id = 1
+    assert_raises(ActiveRecord::RecordInvalid) { pirate.save! }
+    check_pirate_after_save_failure(pirate)
+  end
+
+  def test_reload_should_clear_changed_attributes
+    pirate = Pirate.create!(:catchphrase => "shiver me timbers")
+    pirate.catchphrase = "*hic*"
+    assert pirate.changed?
+    pirate.reload
+    assert !pirate.changed?
+  end
+
+  private
+    def with_partial_updates(klass, on = true)
+      old = klass.partial_updates?
+      klass.partial_updates = on
+      yield
+    ensure
+      klass.partial_updates = old
+    end
+
+    def check_pirate_after_save_failure(pirate)
+      assert pirate.changed?
+      assert pirate.parrot_id_changed?
+      assert_equal %w(parrot_id), pirate.changed
+      assert_nil pirate.parrot_id_was
+    end
+end

data/test/cases/finder_respond_to_test.rb

@@ -0,0 +1,76 @@
+require "cases/helper"
+require 'models/topic'
+
+class FinderRespondToTest < ActiveRecord::TestCase
+
+  fixtures :topics
+
+  def test_should_preserve_normal_respond_to_behaviour_and_respond_to_newly_added_method
+    class << Topic; self; end.send(:define_method, :method_added_for_finder_respond_to_test) { }
+    assert Topic.respond_to?(:method_added_for_finder_respond_to_test)
+  ensure
+    class << Topic; self; end.send(:remove_method, :method_added_for_finder_respond_to_test)
+  end
+
+  def test_should_preserve_normal_respond_to_behaviour_and_respond_to_standard_object_method
+    assert Topic.respond_to?(:to_s)
+  end
+
+  def test_should_respond_to_find_by_one_attribute_before_caching
+    ensure_topic_method_is_not_cached(:find_by_title)
+    assert Topic.respond_to?(:find_by_title)
+  end
+
+  def test_should_respond_to_find_all_by_one_attribute
+    ensure_topic_method_is_not_cached(:find_all_by_title)
+    assert Topic.respond_to?(:find_all_by_title)
+  end
+
+  def test_should_respond_to_find_all_by_two_attributes
+    ensure_topic_method_is_not_cached(:find_all_by_title_and_author_name)
+    assert Topic.respond_to?(:find_all_by_title_and_author_name)
+  end
+
+  def test_should_respond_to_find_by_two_attributes
+    ensure_topic_method_is_not_cached(:find_by_title_and_author_name)
+    assert Topic.respond_to?(:find_by_title_and_author_name)
+  end
+
+  def test_should_respond_to_find_or_initialize_from_one_attribute
+    ensure_topic_method_is_not_cached(:find_or_initialize_by_title)
+    assert Topic.respond_to?(:find_or_initialize_by_title)
+  end
+
+  def test_should_respond_to_find_or_initialize_from_two_attributes
+    ensure_topic_method_is_not_cached(:find_or_initialize_by_title_and_author_name)
+    assert Topic.respond_to?(:find_or_initialize_by_title_and_author_name)
+  end
+
+  def test_should_respond_to_find_or_create_from_one_attribute
+    ensure_topic_method_is_not_cached(:find_or_create_by_title)
+    assert Topic.respond_to?(:find_or_create_by_title)
+  end
+
+  def test_should_respond_to_find_or_create_from_two_attributes
+    ensure_topic_method_is_not_cached(:find_or_create_by_title_and_author_name)
+    assert Topic.respond_to?(:find_or_create_by_title_and_author_name)
+  end
+
+  def test_should_not_respond_to_find_by_one_missing_attribute
+    assert !Topic.respond_to?(:find_by_undertitle)
+  end
+
+  def test_should_not_respond_to_find_by_invalid_method_syntax
+    assert !Topic.respond_to?(:fail_to_find_by_title)
+    assert !Topic.respond_to?(:find_by_title?)
+    assert !Topic.respond_to?(:fail_to_find_or_create_by_title)
+    assert !Topic.respond_to?(:find_or_create_by_title?)
+  end
+
+  private
+
+  def ensure_topic_method_is_not_cached(method_id)
+    class << Topic; self; end.send(:remove_method, method_id) if Topic.public_methods.any? { |m| m.to_s == method_id.to_s }
+  end
+
+end

data/test/{finder_test.rb → cases/finder_test.rb}

@@ -1,15 +1,18 @@
-require 'abstract_unit'
-require 'fixtures/author'
-require 'fixtures/comment'
-require 'fixtures/company'
-require 'fixtures/topic'
-require 'fixtures/reply'
-require 'fixtures/entrant'
-require 'fixtures/developer'
-require 'fixtures/post'
-
-class FinderTest < Test::Unit::TestCase
-  fixtures :companies, :topics, :entrants, :developers, :developers_projects, :posts, :comments, :accounts, :authors
+require "cases/helper"
+require 'models/author'
+require 'models/comment'
+require 'models/company'
+require 'models/topic'
+require 'models/reply'
+require 'models/entrant'
+require 'models/developer'
+require 'models/post'
+require 'models/customer'
+require 'models/job'
+require 'models/categorization'
+
+class FinderTest < ActiveRecord::TestCase
+  fixtures :companies, :topics, :entrants, :developers, :developers_projects, :posts, :comments, :accounts, :authors, :customers
 
   def test_find
     assert_equal(topics(:first).title, Topic.find(1).title)
@@ -40,6 +43,21 @@ class FinderTest < Test::Unit::TestCase
     assert_raise(NoMethodError) { Topic.exists?([1,2]) }
   end
 
+  def test_exists_with_aggregate_having_three_mappings
+    existing_address = customers(:david).address
+    assert Customer.exists?(:address => existing_address)
+  end
+
+  def test_exists_with_aggregate_having_three_mappings_with_one_difference
+    existing_address = customers(:david).address
+    assert !Customer.exists?(:address =>
+      Address.new(existing_address.street, existing_address.city, existing_address.country + "1"))
+    assert !Customer.exists?(:address =>
+      Address.new(existing_address.street, existing_address.city + "1", existing_address.country))
+    assert !Customer.exists?(:address =>
+      Address.new(existing_address.street + "1", existing_address.city, existing_address.country))
+  end
+
   def test_find_by_array_of_one_id
     assert_kind_of(Array, Topic.find([ 1 ]))
     assert_equal(1, Topic.find([ 1 ]).length)
@@ -127,6 +145,14 @@ class FinderTest < Test::Unit::TestCase
     first = Topic.find(:first, :conditions => "title = 'The First Topic!'")
     assert_nil(first)
   end
+  
+  def test_first
+    assert_equal topics(:second).title, Topic.first(:conditions => "title = 'The Second Topic of the day'").title
+  end
+  
+  def test_first_failing
+    assert_nil Topic.first(:conditions => "title = 'The Second Topic of the day!'")
+  end
 
   def test_unexisting_record_exception_handling
     assert_raises(ActiveRecord::RecordNotFound) {
@@ -145,13 +171,13 @@ class FinderTest < Test::Unit::TestCase
     assert topic.attribute_present?("author_name")
     assert topic.respond_to?("author_name")
   end
-  
+
   def test_find_on_blank_conditions
     [nil, " ", [], {}].each do |blank|
       assert_nothing_raised { Topic.find(:first, :conditions => blank) }
     end
   end
-  
+
   def test_find_on_blank_bind_conditions
     [ [""], ["",{}] ].each do |blank|
       assert_nothing_raised { Topic.find(:first, :conditions => blank) }
@@ -173,6 +199,14 @@ class FinderTest < Test::Unit::TestCase
     assert_raises(ActiveRecord::RecordNotFound) { Topic.find(1, :conditions => { 'topics.approved' => true }) }
   end
 
+  def test_find_on_hash_conditions_with_explicit_table_name_and_aggregate
+    david = customers(:david)
+    assert Customer.find(david.id, :conditions => { 'customers.name' => david.name, :address => david.address })
+    assert_raises(ActiveRecord::RecordNotFound) {
+      Customer.find(david.id, :conditions => { 'customers.name' => david.name + "1", :address => david.address })
+    }
+  end
+
   def test_find_on_association_proxy_conditions
     assert_equal [1, 2, 3, 5, 6, 7, 8, 9, 10], Comment.find_all_by_post_id(authors(:david).posts).map(&:id).sort
   end
@@ -238,6 +272,48 @@ class FinderTest < Test::Unit::TestCase
     assert_nil topic.last_read
   end
 
+  def test_hash_condition_find_with_aggregate_having_one_mapping
+    balance = customers(:david).balance
+    assert_kind_of Money, balance
+    found_customer = Customer.find(:first, :conditions => {:balance => balance})
+    assert_equal customers(:david), found_customer
+  end
+
+  def test_hash_condition_find_with_aggregate_attribute_having_same_name_as_field_and_key_value_being_aggregate
+    gps_location = customers(:david).gps_location
+    assert_kind_of GpsLocation, gps_location
+    found_customer = Customer.find(:first, :conditions => {:gps_location => gps_location})
+    assert_equal customers(:david), found_customer
+  end
+
+  def test_hash_condition_find_with_aggregate_having_one_mapping_and_key_value_being_attribute_value
+    balance = customers(:david).balance
+    assert_kind_of Money, balance
+    found_customer = Customer.find(:first, :conditions => {:balance => balance.amount})
+    assert_equal customers(:david), found_customer
+  end
+
+  def test_hash_condition_find_with_aggregate_attribute_having_same_name_as_field_and_key_value_being_attribute_value
+    gps_location = customers(:david).gps_location
+    assert_kind_of GpsLocation, gps_location
+    found_customer = Customer.find(:first, :conditions => {:gps_location => gps_location.gps_location})
+    assert_equal customers(:david), found_customer
+  end
+
+  def test_hash_condition_find_with_aggregate_having_three_mappings
+    address = customers(:david).address
+    assert_kind_of Address, address
+    found_customer = Customer.find(:first, :conditions => {:address => address})
+    assert_equal customers(:david), found_customer
+  end
+
+  def test_hash_condition_find_with_one_condition_being_aggregate_and_another_not
+    address = customers(:david).address
+    assert_kind_of Address, address
+    found_customer = Customer.find(:first, :conditions => {:address => address, :name => customers(:david).name})
+    assert_equal customers(:david), found_customer
+  end
+
   def test_bind_variables
     assert_kind_of Firm, Company.find(:first, :conditions => ["name = ?", "37signals"])
     assert_nil Company.find(:first, :conditions => ["name = ?", "37signals!"])
@@ -273,6 +349,8 @@ class FinderTest < Test::Unit::TestCase
   def test_named_bind_variables
     assert_equal '1', bind(':a', :a => 1) # ' ruby-mode
     assert_equal '1 1', bind(':a :a', :a => 1)  # ' ruby-mode
+    
+    assert_nothing_raised { bind("'+00:00'", :foo => "bar") }
 
     assert_kind_of Firm, Company.find(:first, :conditions => ["name = :name", { :name => "37signals" }])
     assert_nil Company.find(:first, :conditions => ["name = :name", { :name => "37signals!" }])
@@ -337,18 +415,18 @@ class FinderTest < Test::Unit::TestCase
     assert_equal topics(:first), Topic.find_by_title("The First Topic")
     assert_nil Topic.find_by_title("The First Topic!")
   end
-  
+
   def test_find_by_one_attribute_caches_dynamic_finder
     # ensure this test can run independently of order
-    class << Topic; self; end.send(:remove_method, :find_by_title) if Topic.respond_to?(:find_by_title)
-    assert !Topic.respond_to?(:find_by_title)
+    class << Topic; self; end.send(:remove_method, :find_by_title) if Topic.public_methods.any? { |m| m.to_s == 'find_by_title' }
+    assert !Topic.public_methods.any? { |m| m.to_s == 'find_by_title' }
     t = Topic.find_by_title("The First Topic")
-    assert Topic.respond_to?(:find_by_title)
+    assert Topic.public_methods.any? { |m| m.to_s == 'find_by_title' }
   end
 
   def test_dynamic_finder_returns_same_results_after_caching
     # ensure this test can run independently of order
-    class << Topic; self; end.send(:remove_method, :find_by_title) if Topic.respond_to?(:find_by_title)
+    class << Topic; self; end.send(:remove_method, :find_by_title) if Topic.public_method_defined?(:find_by_title)
     t = Topic.find_by_title("The First Topic")
     assert_equal t, Topic.find_by_title("The First Topic") # find_by_title has been cached
   end
@@ -362,17 +440,51 @@ class FinderTest < Test::Unit::TestCase
     assert_equal accounts(:rails_core_account), Account.find_by_credit_limit(50, :conditions => ['firm_id = ?', 6])
   end
 
+  def test_find_by_one_attribute_that_is_an_aggregate
+    address = customers(:david).address
+    assert_kind_of Address, address
+    found_customer = Customer.find_by_address(address)
+    assert_equal customers(:david), found_customer
+  end
+
+  def test_find_by_one_attribute_that_is_an_aggregate_with_one_attribute_difference
+    address = customers(:david).address
+    assert_kind_of Address, address
+    missing_address = Address.new(address.street, address.city, address.country + "1")
+    assert_nil Customer.find_by_address(missing_address)
+    missing_address = Address.new(address.street, address.city + "1", address.country)
+    assert_nil Customer.find_by_address(missing_address)
+    missing_address = Address.new(address.street + "1", address.city, address.country)
+    assert_nil Customer.find_by_address(missing_address)
+  end
+
+  def test_find_by_two_attributes_that_are_both_aggregates
+    balance = customers(:david).balance
+    address = customers(:david).address
+    assert_kind_of Money, balance
+    assert_kind_of Address, address
+    found_customer = Customer.find_by_balance_and_address(balance, address)
+    assert_equal customers(:david), found_customer
+  end
+
+  def test_find_by_two_attributes_with_one_being_an_aggregate
+    balance = customers(:david).balance
+    assert_kind_of Money, balance
+    found_customer = Customer.find_by_balance_and_name(balance, customers(:david).name)
+    assert_equal customers(:david), found_customer
+  end
+
   def test_dynamic_finder_on_one_attribute_with_conditions_caches_method
     # ensure this test can run independently of order
-    class << Account; self; end.send(:remove_method, :find_by_credit_limit) if Account.respond_to?(:find_by_credit_limit)
-    assert !Account.respond_to?(:find_by_credit_limit)
+    class << Account; self; end.send(:remove_method, :find_by_credit_limit) if Account.public_methods.any? { |m| m.to_s == 'find_by_credit_limit' }
+    assert !Account.public_methods.any? { |m| m.to_s == 'find_by_credit_limit' }
     a = Account.find_by_credit_limit(50, :conditions => ['firm_id = ?', 6])
-    assert Account.respond_to?(:find_by_credit_limit)
+    assert Account.public_methods.any? { |m| m.to_s == 'find_by_credit_limit' }
   end
 
   def test_dynamic_finder_on_one_attribute_with_conditions_returns_same_results_after_caching
     # ensure this test can run independently of order
-    class << Account; self; end.send(:remove_method, :find_by_credit_limit) if Account.respond_to?(:find_by_credit_limit)
+    class << Account; self; end.send(:remove_method, :find_by_credit_limit) if Account.public_methods.any? { |m| m.to_s == 'find_by_credit_limit' }
     a = Account.find_by_credit_limit(50, :conditions => ['firm_id = ?', 6])
     assert_equal a, Account.find_by_credit_limit(50, :conditions => ['firm_id = ?', 6]) # find_by_credit_limit has been cached
   end
@@ -405,6 +517,32 @@ class FinderTest < Test::Unit::TestCase
     assert_equal [], Topic.find_all_by_title("The First Topic!!")
   end
 
+  def test_find_all_by_one_attribute_that_is_an_aggregate
+    balance = customers(:david).balance
+    assert_kind_of Money, balance
+    found_customers = Customer.find_all_by_balance(balance)
+    assert_equal 1, found_customers.size
+    assert_equal customers(:david), found_customers.first
+  end
+
+  def test_find_all_by_two_attributes_that_are_both_aggregates
+    balance = customers(:david).balance
+    address = customers(:david).address
+    assert_kind_of Money, balance
+    assert_kind_of Address, address
+    found_customers = Customer.find_all_by_balance_and_address(balance, address)
+    assert_equal 1, found_customers.size
+    assert_equal customers(:david), found_customers.first
+  end
+
+  def test_find_all_by_two_attributes_with_one_being_an_aggregate
+    balance = customers(:david).balance
+    assert_kind_of Money, balance
+    found_customers = Customer.find_all_by_balance_and_name(balance, customers(:david).name)
+    assert_equal 1, found_customers.size
+    assert_equal customers(:david), found_customers.first
+  end
+
   def test_find_all_by_one_attribute_with_options
     topics = Topic.find_all_by_content("Have a nice day", :order => "id DESC")
     assert topics(:first), topics.last
@@ -414,7 +552,7 @@ class FinderTest < Test::Unit::TestCase
   end
 
   def test_find_all_by_array_attribute
-    assert_equal 2, Topic.find_all_by_title(["The First Topic", "The Second Topic's of the day"]).size
+    assert_equal 2, Topic.find_all_by_title(["The First Topic", "The Second Topic of the day"]).size
   end
 
   def test_find_all_by_boolean_attribute
@@ -423,7 +561,7 @@ class FinderTest < Test::Unit::TestCase
     assert topics.include?(topics(:first))
 
     topics = Topic.find_all_by_approved(true)
-    assert_equal 1, topics.size
+    assert_equal 3, topics.size
     assert topics.include?(topics(:second))
   end
 
@@ -435,8 +573,8 @@ class FinderTest < Test::Unit::TestCase
 
   def test_find_all_by_nil_attribute
     topics = Topic.find_all_by_last_read nil
-    assert_equal 1, topics.size
-    assert_nil topics[0].last_read
+    assert_equal 3, topics.size
+    assert topics.collect(&:last_read).all?(&:nil?)
   end
 
   def test_find_by_nil_and_not_nil_attributes
@@ -466,6 +604,14 @@ class FinderTest < Test::Unit::TestCase
     assert !another.new_record?
   end
 
+  def test_find_or_create_from_two_attributes_with_one_being_an_aggregate
+    number_of_customers = Customer.count
+    created_customer = Customer.find_or_create_by_balance_and_name(Money.new(123), "Elizabeth")
+    assert_equal number_of_customers + 1, Customer.count
+    assert_equal created_customer, Customer.find_or_create_by_balance(Money.new(123), "Elizabeth")
+    assert !created_customer.new_record?
+  end
+
   def test_find_or_create_from_one_attribute_and_hash
     number_of_companies = Company.count
     sig38 = Company.find_or_create_by_name({:name => "38signals", :firm_id => 17, :client_of => 23})
@@ -477,18 +623,60 @@ class FinderTest < Test::Unit::TestCase
     assert_equal 23, sig38.client_of
   end
 
+  def test_find_or_create_from_one_aggregate_attribute
+    number_of_customers = Customer.count
+    created_customer = Customer.find_or_create_by_balance(Money.new(123))
+    assert_equal number_of_customers + 1, Customer.count
+    assert_equal created_customer, Customer.find_or_create_by_balance(Money.new(123))
+    assert !created_customer.new_record?
+  end
+
+  def test_find_or_create_from_one_aggregate_attribute_and_hash
+    number_of_customers = Customer.count
+    balance = Money.new(123)
+    name = "Elizabeth"
+    created_customer = Customer.find_or_create_by_balance({:balance => balance, :name => name})
+    assert_equal number_of_customers + 1, Customer.count
+    assert_equal created_customer, Customer.find_or_create_by_balance({:balance => balance, :name => name})
+    assert !created_customer.new_record?
+    assert_equal balance, created_customer.balance
+    assert_equal name, created_customer.name
+  end
+
   def test_find_or_initialize_from_one_attribute
     sig38 = Company.find_or_initialize_by_name("38signals")
     assert_equal "38signals", sig38.name
     assert sig38.new_record?
   end
-  
+
+  def test_find_or_initialize_from_one_aggregate_attribute
+    new_customer = Customer.find_or_initialize_by_balance(Money.new(123))
+    assert_equal 123, new_customer.balance.amount
+    assert new_customer.new_record?
+  end
+
+  def test_find_or_initialize_from_one_attribute_should_not_set_attribute_even_when_protected
+    c = Company.find_or_initialize_by_name({:name => "Fortune 1000", :rating => 1000})
+    assert_equal "Fortune 1000", c.name
+    assert_not_equal 1000, c.rating
+    assert c.valid?
+    assert c.new_record?
+  end
+
+  def test_find_or_create_from_one_attribute_should_set_not_attribute_even_when_protected
+    c = Company.find_or_create_by_name({:name => "Fortune 1000", :rating => 1000})
+    assert_equal "Fortune 1000", c.name
+    assert_not_equal 1000, c.rating
+    assert c.valid?
+    assert !c.new_record?
+  end
+
   def test_find_or_initialize_from_one_attribute_should_set_attribute_even_when_protected
     c = Company.find_or_initialize_by_name_and_rating("Fortune 1000", 1000)
     assert_equal "Fortune 1000", c.name
     assert_equal 1000, c.rating
     assert c.valid?
-    assert c.new_record?    
+    assert c.new_record?
   end
 
   def test_find_or_create_from_one_attribute_should_set_attribute_even_when_protected
@@ -496,14 +684,30 @@ class FinderTest < Test::Unit::TestCase
     assert_equal "Fortune 1000", c.name
     assert_equal 1000, c.rating
     assert c.valid?
-    assert !c.new_record?    
+    assert !c.new_record?
+  end
+
+  def test_find_or_initialize_should_set_protected_attributes_if_given_as_block
+    c = Company.find_or_initialize_by_name(:name => "Fortune 1000") { |f| f.rating = 1000 }
+    assert_equal "Fortune 1000", c.name
+    assert_equal 1000.to_f, c.rating.to_f
+    assert c.valid?
+    assert c.new_record?
   end
 
+  def test_find_or_create_should_set_protected_attributes_if_given_as_block
+    c = Company.find_or_create_by_name(:name => "Fortune 1000") { |f| f.rating = 1000 }
+    assert_equal "Fortune 1000", c.name
+    assert_equal 1000.to_f, c.rating.to_f
+    assert c.valid?
+    assert !c.new_record?
+  end
+  
   def test_dynamic_find_or_initialize_from_one_attribute_caches_method
-    class << Company; self; end.send(:remove_method, :find_or_initialize_by_name) if Company.respond_to?(:find_or_initialize_by_name)    
-    assert !Company.respond_to?(:find_or_initialize_by_name)
+    class << Company; self; end.send(:remove_method, :find_or_initialize_by_name) if Company.public_methods.any? { |m| m.to_s == 'find_or_initialize_by_name' }
+    assert !Company.public_methods.any? { |m| m.to_s == 'find_or_initialize_by_name' }
     sig38 = Company.find_or_initialize_by_name("38signals")
-    assert Company.respond_to?(:find_or_initialize_by_name)
+    assert Company.public_methods.any? { |m| m.to_s == 'find_or_initialize_by_name' }
   end
 
   def test_find_or_initialize_from_two_attributes
@@ -513,6 +717,13 @@ class FinderTest < Test::Unit::TestCase
     assert another.new_record?
   end
 
+  def test_find_or_initialize_from_one_aggregate_attribute_and_one_not
+    new_customer = Customer.find_or_initialize_by_balance_and_name(Money.new(123), "Elizabeth")
+    assert_equal 123, new_customer.balance.amount
+    assert_equal "Elizabeth", new_customer.name
+    assert new_customer.new_record?
+  end
+
   def test_find_or_initialize_from_one_attribute_and_hash
     sig38 = Company.find_or_initialize_by_name({:name => "38signals", :firm_id => 17, :client_of => 23})
     assert_equal "38signals", sig38.name
@@ -521,6 +732,15 @@ class FinderTest < Test::Unit::TestCase
     assert sig38.new_record?
   end
 
+  def test_find_or_initialize_from_one_aggregate_attribute_and_hash
+    balance = Money.new(123)
+    name = "Elizabeth"
+    new_customer = Customer.find_or_initialize_by_balance({:balance => balance, :name => name})
+    assert_equal balance, new_customer.balance
+    assert_equal name, new_customer.name
+    assert new_customer.new_record?
+  end
+
   def test_find_with_bad_sql
     assert_raises(ActiveRecord::StatementInvalid) { Topic.find_by_sql "select 1 from badtable" }
   end
@@ -639,6 +859,19 @@ class FinderTest < Test::Unit::TestCase
       Company.connection.select_rows("SELECT id, name FROM companies WHERE id IN (1,2,3) ORDER BY id").map! {|i| i.map! {|j| j.to_s unless j.nil?}}
   end
 
+  def test_find_with_order_on_included_associations_with_construct_finder_sql_for_association_limiting_and_is_distinct
+    assert_equal 2, Post.find(:all, :include => { :authors => :author_address }, :order => ' author_addresses.id DESC ', :limit => 2).size
+
+    assert_equal 3, Post.find(:all, :include => { :author => :author_address, :authors => :author_address},
+                              :order => ' author_addresses_authors.id DESC ', :limit => 3).size
+  end
+
+  def test_with_limiting_with_custom_select
+    posts = Post.find(:all, :include => :author, :select => ' posts.*, authors.id as "author_id"', :limit => 3, :order => 'posts.id')
+    assert_equal 3, posts.size
+    assert_equal [0, 1, 1], posts.map(&:author_id).sort
+  end
+
   protected
     def bind(statement, *vars)
       if vars.first.is_a?(Hash)