From 2931f413a51f75e7365ac7dfe2e0bc2a27224c94 Mon Sep 17 00:00:00 2001
From: Nick Rogers <ncrogers@gmail.com>
Date: Wed, 7 Mar 2012 23:56:23 -0500
Subject: Tests for removing a HABTM association when optimistic locking is
 enabled.

---
 activerecord/test/cases/locking_test.rb          | 12 +++++++++++-
 activerecord/test/fixtures/peoples_treasures.yml |  3 +++
 activerecord/test/models/person.rb               |  6 ++++++
 activerecord/test/schema/schema.rb               |  5 +++++
 4 files changed, 25 insertions(+), 1 deletion(-)
 create mode 100644 activerecord/test/fixtures/peoples_treasures.yml

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/locking_test.rb b/activerecord/test/cases/locking_test.rb
index 807274ca67..a8fb3548f6 100644
--- a/activerecord/test/cases/locking_test.rb
+++ b/activerecord/test/cases/locking_test.rb
@@ -22,7 +22,7 @@ class ReadonlyFirstNamePerson < Person
 end
 
 class OptimisticLockingTest < ActiveRecord::TestCase
-  fixtures :people, :legacy_things, :references, :string_key_objects
+  fixtures :people, :legacy_things, :references, :string_key_objects, :peoples_treasures
 
   def test_non_integer_lock_existing
     s1 = StringKeyObject.find("record1")
@@ -239,6 +239,16 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     end
     assert car.destroyed?
   end
+  
+  def test_removing_has_and_belongs_to_many_associations_upon_destroy
+    p = RichPerson.create!
+    p.treasures.create!
+    assert !p.treasures.empty?
+    p.destroy
+    assert p.treasures.empty?
+    assert RichPerson.connection.select_all("SELECT * FROM peoples_treasures WHERE rich_person_id = 1").empty?
+  end
+  
 end
 
 class OptimisticLockingWithSchemaChangeTest < ActiveRecord::TestCase
diff --git a/activerecord/test/fixtures/peoples_treasures.yml b/activerecord/test/fixtures/peoples_treasures.yml
new file mode 100644
index 0000000000..a72b190d0c
--- /dev/null
+++ b/activerecord/test/fixtures/peoples_treasures.yml
@@ -0,0 +1,3 @@
+michael_diamond:
+  rich_person_id: <%= ActiveRecord::Fixtures.identify(:michael) %>
+  treasure_id: <%= ActiveRecord::Fixtures.identify(:diamond) %>
diff --git a/activerecord/test/models/person.rb b/activerecord/test/models/person.rb
index d2a0c6b40c..ad06afcace 100644
--- a/activerecord/test/models/person.rb
+++ b/activerecord/test/models/person.rb
@@ -83,3 +83,9 @@ class TightPerson < ActiveRecord::Base
 end
 
 class TightDescendant < TightPerson; end
+
+class RichPerson < ActiveRecord::Base
+  self.table_name = 'people'
+  
+  has_and_belongs_to_many :treasures, :join_table => 'peoples_treasures'
+end
diff --git a/activerecord/test/schema/schema.rb b/activerecord/test/schema/schema.rb
index 428a85ab4e..097a973107 100644
--- a/activerecord/test/schema/schema.rb
+++ b/activerecord/test/schema/schema.rb
@@ -467,6 +467,11 @@ ActiveRecord::Schema.define do
     t.references :best_friend_of
     t.timestamps
   end
+  
+  create_table :peoples_treasures, :id => false, :force => true do |t|
+    t.column :rich_person_id, :integer
+    t.column :treasure_id, :integer
+  end
 
   create_table :pets, :primary_key => :pet_id ,:force => true do |t|
     t.string :name
-- 
cgit v1.2.3


From e96d04a2e4e244ea5053cb4e8ab97db604d0c796 Mon Sep 17 00:00:00 2001
From: Aaron Patterson <aaron.patterson@gmail.com>
Date: Tue, 27 Mar 2012 11:27:51 -0700
Subject: attributes are cached by string keys, so to_s to support symbols.
 fixes #5549

---
 activerecord/test/cases/base_test.rb | 16 +++++++++++++++-
 activerecord/test/schema/schema.rb   |  1 +
 2 files changed, 16 insertions(+), 1 deletion(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index fb2f66c4f8..ff39285f62 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -62,7 +62,11 @@ end
 
 class Weird < ActiveRecord::Base; end
 
-class Boolean < ActiveRecord::Base; end
+class Boolean < ActiveRecord::Base
+  def has_fun
+    super
+  end
+end
 
 class LintTest < ActiveRecord::TestCase
   include ActiveModel::Lint::Tests
@@ -957,6 +961,16 @@ class BasicsTest < ActiveRecord::TestCase
     assert b_true.value?
   end
 
+  def test_boolean_without_questionmark
+    b_true = Boolean.create({ "value" => true })
+    true_id = b_true.id
+
+    subclass   = Class.new(Boolean).find true_id
+    superclass = Boolean.find true_id
+
+    assert_equal superclass.read_attribute(:has_fun), subclass.read_attribute(:has_fun)
+  end
+
   def test_boolean_cast_from_string
     b_blank = Boolean.create({ "value" => "" })
     blank_id = b_blank.id
diff --git a/activerecord/test/schema/schema.rb b/activerecord/test/schema/schema.rb
index 428a85ab4e..5e7985c530 100644
--- a/activerecord/test/schema/schema.rb
+++ b/activerecord/test/schema/schema.rb
@@ -91,6 +91,7 @@ ActiveRecord::Schema.define do
 
   create_table :booleans, :force => true do |t|
     t.boolean :value
+    t.boolean :has_fun, :null => false, :default => false
   end
 
   create_table :bulbs, :force => true do |t|
-- 
cgit v1.2.3


From 135d704a55b87b1c5371f4a552151f44964a8fed Mon Sep 17 00:00:00 2001
From: Jonathan Mukai & Peter Jaros <pair+jmukai+pjaros@pivotallabs.com>
Date: Thu, 8 Sep 2011 15:39:44 -0400
Subject: Nested attribute setters can be overridden.

Overriding implementation can call super.
---
 activerecord/test/cases/nested_attributes_test.rb | 13 +++++++++++++
 activerecord/test/schema/schema.rb                |  1 +
 2 files changed, 14 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/nested_attributes_test.rb b/activerecord/test/cases/nested_attributes_test.rb
index 09276a034e..0559bbbe9a 100644
--- a/activerecord/test/cases/nested_attributes_test.rb
+++ b/activerecord/test/cases/nested_attributes_test.rb
@@ -172,6 +172,19 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
     man.interests_attributes = [{:id => interest.id, :topic => 'gardening'}]
     assert_equal man.interests.first.topic, man.interests[0].topic
   end
+
+  def test_allows_class_to_override_setter_and_call_super
+    mean_pirate_class = Class.new(Pirate) do
+      accepts_nested_attributes_for :parrot
+      def parrot_attributes=(attrs)
+        super(attrs.merge(:color => "blue"))
+      end
+    end
+    mean_pirate = mean_pirate_class.new
+    mean_pirate.parrot_attributes = { :name => "James" }
+    assert_equal "James", mean_pirate.parrot.name
+    assert_equal "blue", mean_pirate.parrot.color
+  end
 end
 
 class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
diff --git a/activerecord/test/schema/schema.rb b/activerecord/test/schema/schema.rb
index 5e7985c530..d5e4f165cb 100644
--- a/activerecord/test/schema/schema.rb
+++ b/activerecord/test/schema/schema.rb
@@ -439,6 +439,7 @@ ActiveRecord::Schema.define do
 
   create_table :parrots, :force => true do |t|
     t.column :name, :string
+    t.column :color, :string
     t.column :parrot_sti_class, :string
     t.column :killer_id, :integer
     t.column :created_at, :datetime
-- 
cgit v1.2.3


From 01ede9a211d91d415488d42ff8015809de2ac497 Mon Sep 17 00:00:00 2001
From: Guillermo Iguaran <guilleiguaran@gmail.com>
Date: Sat, 10 Mar 2012 19:39:13 -0500
Subject: Add ActiveRecord::Base#slice to slice method calls

---
 activerecord/test/cases/base_test.rb | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index ff39285f62..f0fbca190c 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -2057,4 +2057,16 @@ class BasicsTest < ActiveRecord::TestCase
   def test_typecasting_aliases
     assert_equal 10, Topic.select('10 as tenderlove').first.tenderlove
   end
+
+  def test_slice
+    company = Company.new(:rating => 1, :name => "37signals", :firm_name => "37signals")
+    hash = company.slice(:name, :rating, "arbitrary_method")
+    assert_equal hash[:name], company.name
+    assert_equal hash['name'], company.name
+    assert_equal hash[:rating], company.rating
+    assert_equal hash['arbitrary_method'], company.arbitrary_method
+    assert_equal hash[:arbitrary_method], company.arbitrary_method
+    assert_nil hash[:firm_name]
+    assert_nil hash['firm_name']
+  end
 end
-- 
cgit v1.2.3


From f50c160cd028bd3e16c46dcba7692439daf709c8 Mon Sep 17 00:00:00 2001
From: Carlos Antonio da Silva <carlosantoniodasilva@gmail.com>
Date: Thu, 29 Mar 2012 21:12:23 -0300
Subject: Deprecate Column#type_cast_code

---
 activerecord/test/cases/attribute_methods/read_test.rb | 4 ----
 1 file changed, 4 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/attribute_methods/read_test.rb b/activerecord/test/cases/attribute_methods/read_test.rb
index 764305459d..98c38535a6 100644
--- a/activerecord/test/cases/attribute_methods/read_test.rb
+++ b/activerecord/test/cases/attribute_methods/read_test.rb
@@ -6,10 +6,6 @@ module ActiveRecord
   module AttributeMethods
     class ReadTest < ActiveRecord::TestCase
       class FakeColumn < Struct.new(:name)
-        def type_cast_code(var)
-          var
-        end
-
         def type; :integer; end
       end
 
-- 
cgit v1.2.3


From 13b3c77e393b8fb02588f39e6bfa10c832e251ff Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 30 Mar 2012 12:44:45 +0100
Subject: Add Relation#find_by and Relation#find_by!

---
 activerecord/test/cases/base_test.rb      | 14 +++++++++++++
 activerecord/test/cases/relations_test.rb | 34 +++++++++++++++++++++++++++++++
 2 files changed, 48 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index f0fbca190c..5fb49d540f 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -2069,4 +2069,18 @@ class BasicsTest < ActiveRecord::TestCase
     assert_nil hash[:firm_name]
     assert_nil hash['firm_name']
   end
+
+  ["find_by", "find_by!"].each do |meth|
+    test "#{meth} delegates to scoped" do
+      record = stub
+
+      scope = mock
+      scope.expects(meth).with(:foo, :bar).returns(record)
+
+      klass = Class.new(ActiveRecord::Base)
+      klass.stubs(:scoped => scope)
+
+      assert_equal record, klass.public_send(meth, :foo, :bar)
+    end
+  end
 end
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 3edc237c44..25eb7c1672 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -1256,4 +1256,38 @@ class RelationTest < ActiveRecord::TestCase
 
     assert topics.loaded?
   end
+
+  test "find_by with hash conditions returns the first matching record" do
+    assert_equal posts(:eager_other), Post.order(:id).find_by(author_id: 2)
+  end
+
+  test "find_by with non-hash conditions returns the first matching record" do
+    assert_equal posts(:eager_other), Post.order(:id).find_by("author_id = 2")
+  end
+
+  test "find_by with multi-arg conditions returns the first matching record" do
+    assert_equal posts(:eager_other), Post.order(:id).find_by('author_id = ?', 2)
+  end
+
+  test "find_by returns nil if the record is missing" do
+    assert_equal nil, Post.scoped.find_by("1 = 0")
+  end
+
+  test "find_by! with hash conditions returns the first matching record" do
+    assert_equal posts(:eager_other), Post.order(:id).find_by!(author_id: 2)
+  end
+
+  test "find_by! with non-hash conditions returns the first matching record" do
+    assert_equal posts(:eager_other), Post.order(:id).find_by!("author_id = 2")
+  end
+
+  test "find_by! with multi-arg conditions returns the first matching record" do
+    assert_equal posts(:eager_other), Post.order(:id).find_by!('author_id = ?', 2)
+  end
+
+  test "find_by! raises RecordNotFound if the record is missing" do
+    assert_raises(ActiveRecord::RecordNotFound) do
+      Post.scoped.find_by!("1 = 0")
+    end
+  end
 end
-- 
cgit v1.2.3


From bd40e5c9e4d9da045cbcc0dfef27633da85ebc31 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 30 Mar 2012 14:36:33 +0100
Subject: whitespace :scissors:

---
 activerecord/test/cases/locking_test.rb | 7 +++----
 activerecord/test/schema/schema.rb      | 2 +-
 2 files changed, 4 insertions(+), 5 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/locking_test.rb b/activerecord/test/cases/locking_test.rb
index a8fb3548f6..5c59ab3187 100644
--- a/activerecord/test/cases/locking_test.rb
+++ b/activerecord/test/cases/locking_test.rb
@@ -230,16 +230,16 @@ class OptimisticLockingTest < ActiveRecord::TestCase
 
   def test_polymorphic_destroy_with_dependencies_and_lock_version
     car = Car.create!
-    
+
     assert_difference 'car.wheels.count'  do
     	car.wheels << Wheel.create!
-    end 
+    end
     assert_difference 'car.wheels.count', -1  do
       car.destroy
     end
     assert car.destroyed?
   end
-  
+
   def test_removing_has_and_belongs_to_many_associations_upon_destroy
     p = RichPerson.create!
     p.treasures.create!
@@ -248,7 +248,6 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert p.treasures.empty?
     assert RichPerson.connection.select_all("SELECT * FROM peoples_treasures WHERE rich_person_id = 1").empty?
   end
-  
 end
 
 class OptimisticLockingWithSchemaChangeTest < ActiveRecord::TestCase
diff --git a/activerecord/test/schema/schema.rb b/activerecord/test/schema/schema.rb
index 04c20c9128..377fde5c96 100644
--- a/activerecord/test/schema/schema.rb
+++ b/activerecord/test/schema/schema.rb
@@ -469,7 +469,7 @@ ActiveRecord::Schema.define do
     t.references :best_friend_of
     t.timestamps
   end
-  
+
   create_table :peoples_treasures, :id => false, :force => true do |t|
     t.column :rich_person_id, :integer
     t.column :treasure_id, :integer
-- 
cgit v1.2.3


From 43f9622c6749d04867534e1a8838df619c2a79f0 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 30 Mar 2012 14:37:37 +0100
Subject: fix test

---
 activerecord/test/cases/locking_test.rb | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/locking_test.rb b/activerecord/test/cases/locking_test.rb
index 5c59ab3187..cc6baa6153 100644
--- a/activerecord/test/cases/locking_test.rb
+++ b/activerecord/test/cases/locking_test.rb
@@ -9,6 +9,7 @@ require 'models/string_key_object'
 require 'models/car'
 require 'models/engine'
 require 'models/wheel'
+require 'models/treasure'
 
 class LockWithoutDefault < ActiveRecord::Base; end
 
@@ -241,7 +242,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
   end
 
   def test_removing_has_and_belongs_to_many_associations_upon_destroy
-    p = RichPerson.create!
+    p = RichPerson.create! first_name: 'Jon'
     p.treasures.create!
     assert !p.treasures.empty?
     p.destroy
-- 
cgit v1.2.3


From 86aefdb4f2b957acc6d6c7eef557dff6a3888803 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 30 Mar 2012 16:18:39 +0100
Subject: Fix #5667. Preloading should ignore scoping.

---
 activerecord/test/cases/associations/eager_test.rb | 11 +++++++++++
 1 file changed, 11 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index b27a93f857..efdb7cbb36 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -1169,4 +1169,15 @@ class EagerAssociationTest < ActiveRecord::TestCase
     assert_no_queries { assert_equal 1, posts[0].categories[1].categorizations.length }
     assert_no_queries { assert_equal 2, posts[1].categories[0].categorizations.length }
   end
+
+  test "scoping with a circular preload" do
+    assert_equal Comment.find(1), Comment.preload(:post => :comments).scoping { Comment.find(1) }
+  end
+
+  test "preload ignores the scoping" do
+    assert_equal(
+      Comment.find(1).post,
+      Post.where('1 = 0').scoping { Comment.preload(:post).find(1).post }
+    )
+  end
 end
-- 
cgit v1.2.3


From f09bb33bb534fe2e729e292c8ac6b0e2ffdcea2a Mon Sep 17 00:00:00 2001
From: Doug Cole <doug@estately.com>
Date: Sat, 31 Mar 2012 13:38:11 -0700
Subject: add use_returning as a postgresql connection config

---
 .../adapters/postgresql/postgresql_adapter_test.rb |  9 +++++++
 .../test/schema/postgresql_specific_schema.rb      | 29 ++++++++++++++++++++--
 2 files changed, 36 insertions(+), 2 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
index a71d0bb848..19da6163b5 100644
--- a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
@@ -49,6 +49,15 @@ module ActiveRecord
         assert_equal expect, id
       end
 
+      def test_insert_sql_with_returning_disabled
+        @connection.use_returning = false
+        id = @connection.insert_sql("insert into postgresql_partitioned_table_parent (number) VALUES (1)")
+        expect = @connection.query('select max(id) from postgresql_partitioned_table_parent').first.first
+        assert_equal expect, id
+      ensure
+        @connection.use_returning = true
+      end
+
       def test_serial_sequence
         assert_equal 'public.accounts_id_seq',
           @connection.serial_sequence('accounts', 'id')
diff --git a/activerecord/test/schema/postgresql_specific_schema.rb b/activerecord/test/schema/postgresql_specific_schema.rb
index 25b416a906..84228cdd0a 100644
--- a/activerecord/test/schema/postgresql_specific_schema.rb
+++ b/activerecord/test/schema/postgresql_specific_schema.rb
@@ -1,8 +1,8 @@
 ActiveRecord::Schema.define do
 
   %w(postgresql_tsvectors postgresql_hstores postgresql_arrays postgresql_moneys postgresql_numbers postgresql_times postgresql_network_addresses postgresql_bit_strings
-      postgresql_oids postgresql_xml_data_type defaults geometrics postgresql_timestamp_with_zones).each do |table_name|
-    execute "DROP TABLE  IF EXISTS #{quote_table_name table_name}"
+      postgresql_oids postgresql_xml_data_type defaults geometrics postgresql_timestamp_with_zones postgresql_partitioned_table postgresql_partitioned_table_parent).each do |table_name|
+    execute "DROP TABLE IF EXISTS #{quote_table_name table_name}"
   end
 
   execute 'DROP SEQUENCE IF EXISTS companies_nonstd_seq CASCADE'
@@ -10,6 +10,8 @@ ActiveRecord::Schema.define do
   execute "ALTER TABLE companies ALTER COLUMN id SET DEFAULT nextval('companies_nonstd_seq')"
   execute 'DROP SEQUENCE IF EXISTS companies_id_seq'
 
+  execute 'DROP FUNCTION IF EXISTS partitioned_insert_trigger()'
+
   %w(accounts_id_seq developers_id_seq projects_id_seq topics_id_seq customers_id_seq orders_id_seq).each do |seq_name|
     execute "SELECT setval('#{seq_name}', 100)"
   end
@@ -125,6 +127,29 @@ _SQL
   );
 _SQL
 
+  execute <<_SQL
+  CREATE TABLE postgresql_partitioned_table_parent (
+    id SERIAL PRIMARY KEY,
+    number integer
+  );
+  CREATE TABLE postgresql_partitioned_table ( )
+    INHERITS (postgresql_partitioned_table_parent);
+
+  CREATE OR REPLACE FUNCTION partitioned_insert_trigger()
+  RETURNS TRIGGER AS $$
+  BEGIN
+    INSERT INTO postgresql_partitioned_table VALUES (NEW.*);
+    RETURN NULL;
+  END;
+  $$
+  LANGUAGE plpgsql;
+
+  CREATE TRIGGER insert_partitioning_trigger
+    BEFORE INSERT ON postgresql_partitioned_table_parent
+    FOR EACH ROW EXECUTE PROCEDURE partitioned_insert_trigger();
+_SQL
+
+
   begin
     execute <<_SQL
     CREATE TABLE postgresql_xml_data_type (
-- 
cgit v1.2.3


From 945c53e7b54eff25e1cc1cf81ba6c96cce6664de Mon Sep 17 00:00:00 2001
From: Doug Cole <doug@estately.com>
Date: Sat, 31 Mar 2012 18:41:24 -0700
Subject: improve test coverage

---
 .../adapters/postgresql/postgresql_adapter_test.rb | 26 ++++++++++++++++++++++
 1 file changed, 26 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
index 19da6163b5..1452911974 100644
--- a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
@@ -58,6 +58,32 @@ module ActiveRecord
         @connection.use_returning = true
       end
 
+      def test_exec_insert_with_returning_disabled
+        @connection.use_returning = false
+        result = @connection.exec_insert("insert into postgresql_partitioned_table_parent (number) VALUES (1)", nil, [], 'id', 'postgresql_partitioned_table_parent_id_seq')
+        expect = @connection.query('select max(id) from postgresql_partitioned_table_parent').first.first
+        assert_equal expect, result.rows.first.first
+      ensure
+        @connection.use_returning = true
+      end
+
+      def test_exec_insert_with_returning_disabled_and_no_sequence_name_given
+        @connection.use_returning = false
+        result = @connection.exec_insert("insert into postgresql_partitioned_table_parent (number) VALUES (1)", nil, [], 'id')
+        expect = @connection.query('select max(id) from postgresql_partitioned_table_parent').first.first
+        assert_equal expect, result.rows.first.first
+      ensure
+        @connection.use_returning = true
+      end
+
+      def test_sql_for_insert_with_returning_disabled
+        @connection.use_returning = false
+        result = @connection.sql_for_insert('sql', nil, nil, nil, 'binds')
+        assert_equal ['sql', 'binds'], result
+      ensure
+        @connection.use_returning = true
+      end
+
       def test_serial_sequence
         assert_equal 'public.accounts_id_seq',
           @connection.serial_sequence('accounts', 'id')
-- 
cgit v1.2.3


From 3a0d08163a76427611df0c109a5159daaf5b51bf Mon Sep 17 00:00:00 2001
From: Doug Cole <doug@estately.com>
Date: Sun, 1 Apr 2012 15:23:06 -0700
Subject: pick better names and add a little documentation

---
 .../cases/adapters/postgresql/postgresql_adapter_test.rb | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
index 1452911974..3073b9f011 100644
--- a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
@@ -50,38 +50,38 @@ module ActiveRecord
       end
 
       def test_insert_sql_with_returning_disabled
-        @connection.use_returning = false
+        @connection.disable_insert_returning!
         id = @connection.insert_sql("insert into postgresql_partitioned_table_parent (number) VALUES (1)")
         expect = @connection.query('select max(id) from postgresql_partitioned_table_parent').first.first
         assert_equal expect, id
       ensure
-        @connection.use_returning = true
+        @connection.enable_insert_returning!
       end
 
       def test_exec_insert_with_returning_disabled
-        @connection.use_returning = false
+        @connection.disable_insert_returning!
         result = @connection.exec_insert("insert into postgresql_partitioned_table_parent (number) VALUES (1)", nil, [], 'id', 'postgresql_partitioned_table_parent_id_seq')
         expect = @connection.query('select max(id) from postgresql_partitioned_table_parent').first.first
         assert_equal expect, result.rows.first.first
       ensure
-        @connection.use_returning = true
+        @connection.enable_insert_returning!
       end
 
       def test_exec_insert_with_returning_disabled_and_no_sequence_name_given
-        @connection.use_returning = false
+        @connection.disable_insert_returning!
         result = @connection.exec_insert("insert into postgresql_partitioned_table_parent (number) VALUES (1)", nil, [], 'id')
         expect = @connection.query('select max(id) from postgresql_partitioned_table_parent').first.first
         assert_equal expect, result.rows.first.first
       ensure
-        @connection.use_returning = true
+        @connection.enable_insert_returning!
       end
 
       def test_sql_for_insert_with_returning_disabled
-        @connection.use_returning = false
+        @connection.disable_insert_returning!
         result = @connection.sql_for_insert('sql', nil, nil, nil, 'binds')
         assert_equal ['sql', 'binds'], result
       ensure
-        @connection.use_returning = true
+        @connection.enable_insert_returning!
       end
 
       def test_serial_sequence
-- 
cgit v1.2.3


From 68677ffb8298105eb9d3efa26d928dd88cc5e006 Mon Sep 17 00:00:00 2001
From: Benedikt Deicke <benedikt@synatic.net>
Date: Tue, 3 Apr 2012 16:51:36 +0200
Subject: Removes caching from ActiveRecord::Core::ClassMethods#relation

The #relation method gets called in four places and the return value was instantly cloned in three of them. The only place that did not clone was ActiveRecord::Scoping::Default::ClassMethods#unscoped. This introduced a bug described in #5667 and should really clone the relation, too. This means all four places would clone the relation, so it doesn't make a lot of sense caching it in the first place.

The four places with calls to relations are:

activerecord/lib/active_record/scoping/default.rb:110:in `block in build_default_scope'"
activerecord/lib/active_record/scoping/default.rb:42:in `unscoped'"
activerecord/lib/active_record/scoping/named.rb:38:in `scoped'"
activerecord/lib/active_record/scoping/named.rb:52:in `scope_attributes'"
---
 activerecord/test/cases/relations_test.rb | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 25eb7c1672..af25db05cf 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -1099,6 +1099,10 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal 'honda', FastCar.unscoped { FastCar.order_using_old_style.limit(1).first.name}
   end
 
+  def test_unscoped_relation_clones
+    assert_not_equal CoolCar.unscoped.object_id, CoolCar.unscoped.object_id
+  end
+
   def test_intersection_with_array
     relation = Author.where(:name => "David")
     rails_author = relation.first
-- 
cgit v1.2.3


From bfb9b7165ef4cb18835f65be600778bd8b1d6d11 Mon Sep 17 00:00:00 2001
From: kennyj <kennyj@gmail.com>
Date: Wed, 4 Apr 2012 01:21:35 +0900
Subject: Get a properly aliased_table_name, when we use a polymorphic
 association.

---
 activerecord/test/cases/associations/belongs_to_associations_test.rb | 1 +
 1 file changed, 1 insertion(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/associations/belongs_to_associations_test.rb b/activerecord/test/cases/associations/belongs_to_associations_test.rb
index 1160d236c9..9dd041af81 100644
--- a/activerecord/test/cases/associations/belongs_to_associations_test.rb
+++ b/activerecord/test/cases/associations/belongs_to_associations_test.rb
@@ -168,6 +168,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
     sponsor.sponsorable = Member.new :name => "Bert"
     assert_equal Member, sponsor.association(:sponsorable).send(:klass)
+    assert_equal "members", sponsor.association(:sponsorable).aliased_table_name
   end
 
   def test_with_polymorphic_and_condition
-- 
cgit v1.2.3


From 402576b044ce1cb06c3e48061f62542d0908fa17 Mon Sep 17 00:00:00 2001
From: Benedikt Deicke <benedikt@synatic.net>
Date: Tue, 3 Apr 2012 21:13:24 +0200
Subject: Adds test to check that circular preloading does not modify
 Model.unscoped (as described in #5667)

---
 activerecord/test/cases/associations/eager_test.rb | 6 ++++++
 activerecord/test/cases/relations_test.rb          | 4 ----
 activerecord/test/models/comment.rb                | 2 ++
 3 files changed, 8 insertions(+), 4 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index efdb7cbb36..f7f44208b3 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -1174,6 +1174,12 @@ class EagerAssociationTest < ActiveRecord::TestCase
     assert_equal Comment.find(1), Comment.preload(:post => :comments).scoping { Comment.find(1) }
   end
 
+  test "circular preload does not modify unscoped" do
+    expected = FirstPost.unscoped.find(2)
+    FirstPost.preload(:comments => :first_post).find(1)
+    assert_equal expected, FirstPost.unscoped.find(2)
+  end
+
   test "preload ignores the scoping" do
     assert_equal(
       Comment.find(1).post,
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index af25db05cf..25eb7c1672 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -1099,10 +1099,6 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal 'honda', FastCar.unscoped { FastCar.order_using_old_style.limit(1).first.name}
   end
 
-  def test_unscoped_relation_clones
-    assert_not_equal CoolCar.unscoped.object_id, CoolCar.unscoped.object_id
-  end
-
   def test_intersection_with_array
     relation = Author.where(:name => "David")
     rails_author = relation.first
diff --git a/activerecord/test/models/comment.rb b/activerecord/test/models/comment.rb
index 00f5a74070..cf73c28ded 100644
--- a/activerecord/test/models/comment.rb
+++ b/activerecord/test/models/comment.rb
@@ -9,6 +9,8 @@ class Comment < ActiveRecord::Base
   belongs_to :post, :counter_cache => true
   has_many :ratings
 
+  belongs_to :first_post, :foreign_key => :post_id
+
   has_many :children, :class_name => 'Comment', :foreign_key => :parent_id
   belongs_to :parent, :class_name => 'Comment', :counter_cache => :children_count
 
-- 
cgit v1.2.3


From cd6ddc865a68d126a845d03337e1c7f775588db2 Mon Sep 17 00:00:00 2001
From: Doug Cole <doug@estately.com>
Date: Sat, 7 Apr 2012 18:23:26 -0700
Subject: refactor configuration of insert_returning

---
 .../adapters/postgresql/postgresql_adapter_test.rb | 34 ++++++++++------------
 1 file changed, 15 insertions(+), 19 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
index 3073b9f011..92e31a3e44 100644
--- a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
@@ -50,38 +50,30 @@ module ActiveRecord
       end
 
       def test_insert_sql_with_returning_disabled
-        @connection.disable_insert_returning!
-        id = @connection.insert_sql("insert into postgresql_partitioned_table_parent (number) VALUES (1)")
-        expect = @connection.query('select max(id) from postgresql_partitioned_table_parent').first.first
+        connection = connection_without_insert_returning
+        id = connection.insert_sql("insert into postgresql_partitioned_table_parent (number) VALUES (1)")
+        expect = connection.query('select max(id) from postgresql_partitioned_table_parent').first.first
         assert_equal expect, id
-      ensure
-        @connection.enable_insert_returning!
       end
 
       def test_exec_insert_with_returning_disabled
-        @connection.disable_insert_returning!
-        result = @connection.exec_insert("insert into postgresql_partitioned_table_parent (number) VALUES (1)", nil, [], 'id', 'postgresql_partitioned_table_parent_id_seq')
-        expect = @connection.query('select max(id) from postgresql_partitioned_table_parent').first.first
+        connection = connection_without_insert_returning
+        result = connection.exec_insert("insert into postgresql_partitioned_table_parent (number) VALUES (1)", nil, [], 'id', 'postgresql_partitioned_table_parent_id_seq')
+        expect = connection.query('select max(id) from postgresql_partitioned_table_parent').first.first
         assert_equal expect, result.rows.first.first
-      ensure
-        @connection.enable_insert_returning!
       end
 
       def test_exec_insert_with_returning_disabled_and_no_sequence_name_given
-        @connection.disable_insert_returning!
-        result = @connection.exec_insert("insert into postgresql_partitioned_table_parent (number) VALUES (1)", nil, [], 'id')
-        expect = @connection.query('select max(id) from postgresql_partitioned_table_parent').first.first
+        connection = connection_without_insert_returning
+        result = connection.exec_insert("insert into postgresql_partitioned_table_parent (number) VALUES (1)", nil, [], 'id')
+        expect = connection.query('select max(id) from postgresql_partitioned_table_parent').first.first
         assert_equal expect, result.rows.first.first
-      ensure
-        @connection.enable_insert_returning!
       end
 
       def test_sql_for_insert_with_returning_disabled
-        @connection.disable_insert_returning!
-        result = @connection.sql_for_insert('sql', nil, nil, nil, 'binds')
+        connection = connection_without_insert_returning
+        result = connection.sql_for_insert('sql', nil, nil, nil, 'binds')
         assert_equal ['sql', 'binds'], result
-      ensure
-        @connection.enable_insert_returning!
       end
 
       def test_serial_sequence
@@ -239,6 +231,10 @@ module ActiveRecord
 
         ctx.exec_insert(sql, 'SQL', binds)
       end
+
+      def connection_without_insert_returning
+        ActiveRecord::Base.postgresql_connection(ActiveRecord::Base.configurations['arunit'].merge(:insert_returning => false))
+      end
     end
   end
 end
-- 
cgit v1.2.3


From 6f6c2909dcf32fca71ccc645a36469864b97894a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rafael=20Mendon=C3=A7a=20Fran=C3=A7a?=
 <rafaelmfranca@gmail.com>
Date: Thu, 29 Mar 2012 00:42:24 -0300
Subject: Fix delete_all when chained with joins.

Closes #5202 and #919
---
 activerecord/test/cases/persistence_test.rb | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/persistence_test.rb b/activerecord/test/cases/persistence_test.rb
index adfd8e83a1..bb60aa0a66 100644
--- a/activerecord/test/cases/persistence_test.rb
+++ b/activerecord/test/cases/persistence_test.rb
@@ -13,12 +13,14 @@ require 'models/warehouse_thing'
 require 'models/parrot'
 require 'models/minivan'
 require 'models/person'
+require 'models/pet'
+require 'models/toy'
 require 'rexml/document'
 require 'active_support/core_ext/exception'
 
 class PersistencesTest < ActiveRecord::TestCase
 
-  fixtures :topics, :companies, :developers, :projects, :computers, :accounts, :minimalistics, 'warehouse-things', :authors, :categorizations, :categories, :posts, :minivans
+  fixtures :topics, :companies, :developers, :projects, :computers, :accounts, :minimalistics, 'warehouse-things', :authors, :categorizations, :categories, :posts, :minivans, :pets, :toys
 
   # Oracle UPDATE does not support ORDER BY
   unless current_adapter?(:OracleAdapter)
@@ -76,6 +78,22 @@ class PersistencesTest < ActiveRecord::TestCase
     assert_equal Topic.count, Topic.delete_all
   end
 
+  def test_delete_all_with_joins_and_where_part_is_hash
+    where_args = {:toys => {:name => 'Bone'}}
+    count = Pet.joins(:toys).where(where_args).count
+
+    assert_equal count, 1
+    assert_equal count, Pet.joins(:toys).where(where_args).delete_all
+  end
+
+  def test_delete_all_with_joins_and_where_part_is_not_hash
+    where_args = ['toys.name = ?', 'Bone']
+    count = Pet.joins(:toys).where(where_args).count
+
+    assert_equal count, 1
+    assert_equal count, Pet.joins(:toys).where(where_args).delete_all
+  end
+
   def test_update_by_condition
     Topic.update_all "content = 'bulk updated!'", ["approved = ?", true]
     assert_equal "Have a nice day", Topic.find(1).content
-- 
cgit v1.2.3


From 1a20683f0919680de4875c8097e7114a529aeb88 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Juanjo=20Baza=CC=81n?= <jjbazan@gmail.com>
Date: Wed, 11 Apr 2012 15:24:23 +0200
Subject: Override AR::Relation methods in NullRelation. So a NullRelation
 (Relation#none) is chainable with database methods.

---
 activerecord/test/cases/relations_test.rb | 33 +++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 25eb7c1672..5e938968a3 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -219,6 +219,7 @@ class RelationTest < ActiveRecord::TestCase
     assert_no_queries do
       assert_equal [], Developer.none
       assert_equal [], Developer.scoped.none
+      assert           Developer.none.is_a?(ActiveRecord::NullRelation)
     end
   end
 
@@ -228,6 +229,38 @@ class RelationTest < ActiveRecord::TestCase
     end
   end
 
+  def test_none_chained_to_methods_firing_queries_straight_to_db
+    assert_no_queries do
+      assert_equal [],    Developer.none.pluck(:id) # => uses select_all
+      assert_equal 0,     Developer.none.delete_all
+      assert_equal 0,     Developer.none.update_all(:name => 'David')
+      assert_equal 0,     Developer.none.delete(1)
+      assert_equal false, Developer.none.exists?(1)
+    end
+  end
+
+  def test_null_relation_content_size_methods
+    assert_no_queries do
+      assert_equal 0,     Developer.none.size
+      assert_equal 0,     Developer.none.count
+      assert_equal true,  Developer.none.empty?
+      assert_equal false, Developer.none.any?
+      assert_equal false, Developer.none.many?
+    end
+  end
+
+  def test_null_relation_calculations_methods
+    assert_no_queries do
+      assert_equal 0,     Developer.none.count
+      assert_equal nil,   Developer.none.calculate(:average, 'salary')
+    end
+  end
+  
+  def test_null_relation_metadata_methods
+    assert_equal "", Developer.none.to_sql
+    assert_equal({}, Developer.none.where_values_hash)
+  end
+
   def test_joins_with_nil_argument
     assert_nothing_raised { DependentFirm.joins(nil).first }
   end
-- 
cgit v1.2.3


From 8c2c60511beaad05a218e73c4918ab89fb1804f0 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Thu, 12 Apr 2012 17:55:39 +0100
Subject: Add bang versions of relation query methods.

The main reason for this is that I want to separate the code that does
the mutating from the code that does the cloning.
---
 activerecord/test/cases/relation_test.rb | 52 ++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index ac6dee3c6a..4b18c37d27 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -155,4 +155,56 @@ module ActiveRecord
       assert_equal ['foo'], relation.references_values
     end
   end
+
+  class RelationMutationTest < ActiveSupport::TestCase
+    def relation
+      @relation ||= Relation.new :a, :b
+    end
+
+    (Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS - [:references]).each do |method|
+      test "##{method}!" do
+        assert relation.public_send("#{method}!", :foo).equal?(relation)
+        assert_equal [:foo], relation.public_send("#{method}_values")
+      end
+    end
+
+    test '#references!' do
+      assert relation.references!(:foo).equal?(relation)
+      assert relation.references_values.include?('foo')
+    end
+
+    (Relation::SINGLE_VALUE_METHODS - [:lock, :reordering, :reverse_order]).each do |method|
+      test "##{method}!" do
+        assert relation.public_send("#{method}!", :foo).equal?(relation)
+        assert_equal :foo, relation.public_send("#{method}_value")
+      end
+    end
+
+    test '#lock!' do
+      assert relation.lock!('foo').equal?(relation)
+      assert_equal 'foo', relation.lock_value
+    end
+
+    test '#reorder!' do
+      relation = self.relation.order('foo')
+
+      assert relation.reorder!('bar').equal?(relation)
+      assert_equal ['bar'], relation.order_values
+      assert relation.reordering_value
+    end
+
+    test 'reverse_order!' do
+      assert relation.reverse_order!.equal?(relation)
+      assert relation.reverse_order_value
+      relation.reverse_order!
+      assert !relation.reverse_order_value
+    end
+
+    test 'extending!' do
+      mod = Module.new
+
+      assert relation.extending!(mod).equal?(relation)
+      assert relation.is_a?(mod)
+    end
+  end
 end
-- 
cgit v1.2.3


From 365b8b6db750151b786b0a7ef9e65a6824576f1b Mon Sep 17 00:00:00 2001
From: kennyj <kennyj@gmail.com>
Date: Fri, 30 Mar 2012 03:51:08 +0900
Subject: Fix #5563. Should reflect the most recent change to either of
 association / id.

---
 .../test/cases/associations/belongs_to_associations_test.rb   | 11 +++++++++++
 1 file changed, 11 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/associations/belongs_to_associations_test.rb b/activerecord/test/cases/associations/belongs_to_associations_test.rb
index 9dd041af81..e620b14f94 100644
--- a/activerecord/test/cases/associations/belongs_to_associations_test.rb
+++ b/activerecord/test/cases/associations/belongs_to_associations_test.rb
@@ -705,4 +705,15 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
     assert_equal toy, sponsor.reload.sponsorable
   end
+
+  def test_reflect_the_most_recent_change
+    author1, author2 = Author.limit(2)
+    post = Post.new(:title => "foo", :body=> "bar")
+
+    post.author    = author1
+    post.author_id = author2.id
+
+    assert post.save
+    assert_equal post.author_id, author2.id
+  end
 end
-- 
cgit v1.2.3


From 7d655857851dd055f047fd9491fb718d3456ccb8 Mon Sep 17 00:00:00 2001
From: Yasuo Honda <yasuo.honda@gmail.com>
Date: Fri, 13 Apr 2012 07:19:38 -0400
Subject: Fix ORA-00972 error at test_rename_table_with_prefix_and_suffix

---
 activerecord/test/cases/migration_test.rb | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/migration_test.rb b/activerecord/test/cases/migration_test.rb
index 92dc150104..e2936963d9 100644
--- a/activerecord/test/cases/migration_test.rb
+++ b/activerecord/test/cases/migration_test.rb
@@ -36,7 +36,7 @@ class MigrationTest < ActiveRecord::TestCase
     ActiveRecord::Base.connection.initialize_schema_migrations_table
     ActiveRecord::Base.connection.execute "DELETE FROM #{ActiveRecord::Migrator.schema_migrations_table_name}"
 
-    %w(things awesome_things prefix_things_suffix prefix_awesome_things_suffix).each do |table|
+    %w(things awesome_things prefix_things_suffix p_awesome_things_s ).each do |table|
       Thing.connection.drop_table(table) rescue nil
     end
     Thing.reset_column_information
@@ -278,8 +278,8 @@ class MigrationTest < ActiveRecord::TestCase
 
   def test_rename_table_with_prefix_and_suffix
     assert !Thing.table_exists?
-    ActiveRecord::Base.table_name_prefix = 'prefix_'
-    ActiveRecord::Base.table_name_suffix = '_suffix'
+    ActiveRecord::Base.table_name_prefix = 'p_'
+    ActiveRecord::Base.table_name_suffix = '_s'
     Thing.reset_table_name
     Thing.reset_sequence_name
     WeNeedThings.up
@@ -288,7 +288,7 @@ class MigrationTest < ActiveRecord::TestCase
     assert_equal "hello world", Thing.find(:first).content
 
     RenameThings.up
-    Thing.table_name = "prefix_awesome_things_suffix"
+    Thing.table_name = "p_awesome_things_s"
 
     assert_equal "hello world", Thing.find(:first).content
   ensure
-- 
cgit v1.2.3


From a258c27653c6a57b62b30d34791b8bb671248150 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 13 Apr 2012 10:35:24 +0100
Subject: we don't need to test that constant assignment works

---
 activerecord/test/cases/relation_test.rb | 15 ---------------
 1 file changed, 15 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index 4b18c37d27..9c8a88c3ed 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -19,11 +19,6 @@ module ActiveRecord
       assert !relation.loaded, 'relation is not loaded'
     end
 
-    def test_single_values
-      assert_equal [:limit, :offset, :lock, :readonly, :from, :reordering, :reverse_order, :uniq].map(&:to_s).sort,
-        Relation::SINGLE_VALUE_METHODS.map(&:to_s).sort
-    end
-
     def test_initialize_single_values
       relation = Relation.new :a, :b
       Relation::SINGLE_VALUE_METHODS.each do |method|
@@ -31,11 +26,6 @@ module ActiveRecord
       end
     end
 
-    def test_association_methods
-      assert_equal [:includes, :eager_load, :preload].map(&:to_s).sort,
-        Relation::ASSOCIATION_METHODS.map(&:to_s).sort
-    end
-
     def test_initialize_association_methods
       relation = Relation.new :a, :b
       Relation::ASSOCIATION_METHODS.each do |method|
@@ -43,11 +33,6 @@ module ActiveRecord
       end
     end
 
-    def test_multi_value_methods
-      assert_equal [:select, :group, :order, :joins, :where, :having, :bind, :references].map(&:to_s).sort,
-        Relation::MULTI_VALUE_METHODS.map(&:to_s).sort
-    end
-
     def test_multi_value_initialize
       relation = Relation.new :a, :b
       Relation::MULTI_VALUE_METHODS.each do |method|
-- 
cgit v1.2.3


From e4f0fbd994ab0c333e615be68a8d40593c7058e3 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 13 Apr 2012 10:43:12 +0100
Subject: we have no need for the ASSOCIATION_METHODS constant

---
 activerecord/test/cases/relation_test.rb | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index 9c8a88c3ed..5eca3e05c4 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -26,13 +26,6 @@ module ActiveRecord
       end
     end
 
-    def test_initialize_association_methods
-      relation = Relation.new :a, :b
-      Relation::ASSOCIATION_METHODS.each do |method|
-        assert_equal [], relation.send("#{method}_values"), method.to_s
-      end
-    end
-
     def test_multi_value_initialize
       relation = Relation.new :a, :b
       Relation::MULTI_VALUE_METHODS.each do |method|
@@ -146,7 +139,7 @@ module ActiveRecord
       @relation ||= Relation.new :a, :b
     end
 
-    (Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS - [:references]).each do |method|
+    (Relation::MULTI_VALUE_METHODS - [:references]).each do |method|
       test "##{method}!" do
         assert relation.public_send("#{method}!", :foo).equal?(relation)
         assert_equal [:foo], relation.public_send("#{method}_values")
-- 
cgit v1.2.3


From 0183193a6aecefb3b55a5abf20792aee6b57dcc1 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 13 Apr 2012 12:10:51 +0100
Subject: Allow Relation#merge to take a hash

---
 activerecord/test/cases/relation_test.rb | 22 ++++++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index 5eca3e05c4..a38255eda6 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -21,9 +21,10 @@ module ActiveRecord
 
     def test_initialize_single_values
       relation = Relation.new :a, :b
-      Relation::SINGLE_VALUE_METHODS.each do |method|
+      (Relation::SINGLE_VALUE_METHODS - [:create_with]).each do |method|
         assert_nil relation.send("#{method}_value"), method.to_s
       end
+      assert_equal({}, relation.create_with_value)
     end
 
     def test_multi_value_initialize
@@ -132,6 +133,18 @@ module ActiveRecord
       relation = relation.apply_finder_options(:references => :foo)
       assert_equal ['foo'], relation.references_values
     end
+
+    test 'merging a hash into a relation' do
+      relation = Relation.new :a, :b
+      relation = relation.merge where: ['lol'], readonly: true
+
+      assert_equal ['lol'], relation.where_values
+      assert_equal true, relation.readonly_value
+    end
+
+    test 'merging an empty hash into a relation' do
+      assert_equal [], Relation.new(:a, :b).merge({}).where_values
+    end
   end
 
   class RelationMutationTest < ActiveSupport::TestCase
@@ -151,7 +164,7 @@ module ActiveRecord
       assert relation.references_values.include?('foo')
     end
 
-    (Relation::SINGLE_VALUE_METHODS - [:lock, :reordering, :reverse_order]).each do |method|
+    (Relation::SINGLE_VALUE_METHODS - [:lock, :reordering, :reverse_order, :create_with]).each do |method|
       test "##{method}!" do
         assert relation.public_send("#{method}!", :foo).equal?(relation)
         assert_equal :foo, relation.public_send("#{method}_value")
@@ -184,5 +197,10 @@ module ActiveRecord
       assert relation.extending!(mod).equal?(relation)
       assert relation.is_a?(mod)
     end
+
+    test 'create_with!' do
+      assert relation.create_with!(foo: 'bar').equal?(relation)
+      assert_equal({foo: 'bar'}, relation.create_with_value)
+    end
   end
 end
-- 
cgit v1.2.3


From f52253cbebf0124bb74925e91bcca75325eaa502 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 13 Apr 2012 12:15:43 +0100
Subject: assert valid keys

---
 activerecord/test/cases/relation_test.rb | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index a38255eda6..31236cae15 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -145,6 +145,10 @@ module ActiveRecord
     test 'merging an empty hash into a relation' do
       assert_equal [], Relation.new(:a, :b).merge({}).where_values
     end
+
+    test 'merging a hash with unknown keys raises' do
+      assert_raises(ArgumentError) { Relation::HashMerger.new(nil, omg: 'lol') }
+    end
   end
 
   class RelationMutationTest < ActiveSupport::TestCase
-- 
cgit v1.2.3


From 55ee6ed7dd22a17499b68bee786da191ce68682c Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 13 Apr 2012 12:22:19 +0100
Subject: Add Relation#merge!

---
 activerecord/test/cases/relation_test.rb | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index 31236cae15..c1063698bd 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -206,5 +206,10 @@ module ActiveRecord
       assert relation.create_with!(foo: 'bar').equal?(relation)
       assert_equal({foo: 'bar'}, relation.create_with_value)
     end
+
+    test 'merge!' do
+      assert relation.merge!(where: ['foo']).equal?(relation)
+      assert_equal ['foo'], relation.where_values
+    end
   end
 end
-- 
cgit v1.2.3


From 8d5be98ad72939037f1be52aa4bb4672fff02abb Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 13 Apr 2012 12:58:13 +0100
Subject: Make Relation#extending work like other value methods

---
 activerecord/test/cases/relation_test.rb | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index c1063698bd..fdd8e2112e 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -156,7 +156,7 @@ module ActiveRecord
       @relation ||= Relation.new :a, :b
     end
 
-    (Relation::MULTI_VALUE_METHODS - [:references]).each do |method|
+    (Relation::MULTI_VALUE_METHODS - [:references, :extending]).each do |method|
       test "##{method}!" do
         assert relation.public_send("#{method}!", :foo).equal?(relation)
         assert_equal [:foo], relation.public_send("#{method}_values")
@@ -168,6 +168,14 @@ module ActiveRecord
       assert relation.references_values.include?('foo')
     end
 
+    test 'extending!' do
+      mod = Module.new
+
+      assert relation.extending!(mod).equal?(relation)
+      assert [mod], relation.extending_values
+      assert relation.is_a?(mod)
+    end
+
     (Relation::SINGLE_VALUE_METHODS - [:lock, :reordering, :reverse_order, :create_with]).each do |method|
       test "##{method}!" do
         assert relation.public_send("#{method}!", :foo).equal?(relation)
@@ -195,13 +203,6 @@ module ActiveRecord
       assert !relation.reverse_order_value
     end
 
-    test 'extending!' do
-      mod = Module.new
-
-      assert relation.extending!(mod).equal?(relation)
-      assert relation.is_a?(mod)
-    end
-
     test 'create_with!' do
       assert relation.create_with!(foo: 'bar').equal?(relation)
       assert_equal({foo: 'bar'}, relation.create_with_value)
-- 
cgit v1.2.3


From be89e9a35162b3015e2aee53300fdf04752652ce Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 13 Apr 2012 13:12:28 +0100
Subject: remove apply_finder_options call from AssociationScope

---
 activerecord/test/cases/relation_test.rb | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index fdd8e2112e..633654a961 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -176,6 +176,11 @@ module ActiveRecord
       assert relation.is_a?(mod)
     end
 
+    test 'extending! with empty args' do
+      relation.extending!
+      assert_equal [], relation.extending_values
+    end
+
     (Relation::SINGLE_VALUE_METHODS - [:lock, :reordering, :reverse_order, :create_with]).each do |method|
       test "##{method}!" do
         assert relation.public_send("#{method}!", :foo).equal?(relation)
-- 
cgit v1.2.3


From 6311975fb3c02f50730fd1e11b8dba8dd9c05306 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 13 Apr 2012 15:59:47 +0100
Subject: use a hash to store relation values

---
 activerecord/test/cases/relation_test.rb | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index 633654a961..c636284b8f 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -43,19 +43,19 @@ module ActiveRecord
       relation = Relation.new :a, :b
       assert_equal({}, relation.where_values_hash)
 
-      relation.where_values << :hello
+      relation.where! :hello
       assert_equal({}, relation.where_values_hash)
     end
 
     def test_has_values
       relation = Relation.new Post, Post.arel_table
-      relation.where_values << relation.table[:id].eq(10)
+      relation.where! relation.table[:id].eq(10)
       assert_equal({:id => 10}, relation.where_values_hash)
     end
 
     def test_values_wrong_table
       relation = Relation.new Post, Post.arel_table
-      relation.where_values << Comment.arel_table[:id].eq(10)
+      relation.where! Comment.arel_table[:id].eq(10)
       assert_equal({}, relation.where_values_hash)
     end
 
@@ -64,7 +64,7 @@ module ActiveRecord
       left     = relation.table[:id].eq(10)
       right    = relation.table[:id].eq(10)
       combine  = left.and right
-      relation.where_values << combine
+      relation.where! combine
       assert_equal({}, relation.where_values_hash)
     end
 
@@ -87,7 +87,7 @@ module ActiveRecord
 
     def test_create_with_value_with_wheres
       relation = Relation.new Post, Post.arel_table
-      relation.where_values << relation.table[:id].eq(10)
+      relation.where! relation.table[:id].eq(10)
       relation.create_with_value = {:hello => 'world'}
       assert_equal({:hello => 'world', :id => 10}, relation.scope_for_create)
     end
@@ -97,7 +97,7 @@ module ActiveRecord
       relation = Relation.new Post, Post.arel_table
       assert_equal({}, relation.scope_for_create)
 
-      relation.where_values << relation.table[:id].eq(10)
+      relation.where! relation.table[:id].eq(10)
       assert_equal({}, relation.scope_for_create)
 
       relation.create_with_value = {:hello => 'world'}
@@ -111,7 +111,7 @@ module ActiveRecord
 
     def test_eager_load_values
       relation = Relation.new :a, :b
-      relation.eager_load_values << :b
+      relation.eager_load! :b
       assert relation.eager_loading?
     end
 
-- 
cgit v1.2.3


From 60ac540053d5b5d32d7b349bae03f4d874a9826e Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 13 Apr 2012 16:17:28 +0100
Subject: now we can just manipulate the values hash in #only and #except

---
 activerecord/test/cases/relation_test.rb | 13 +++++++++++++
 1 file changed, 13 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index c636284b8f..719b96fa0f 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -149,6 +149,19 @@ module ActiveRecord
     test 'merging a hash with unknown keys raises' do
       assert_raises(ArgumentError) { Relation::HashMerger.new(nil, omg: 'lol') }
     end
+
+    test '#values returns a dup of the values' do
+      relation = Relation.new(:a, :b).where! :foo
+      values   = relation.values
+
+      values[:where] = nil
+      assert_not_nil relation.where_values
+    end
+
+    test 'relations can be created with a values hash' do
+      relation = Relation.new(:a, :b, where: [:foo])
+      assert_equal [:foo], relation.where_values
+    end
   end
 
   class RelationMutationTest < ActiveSupport::TestCase
-- 
cgit v1.2.3


From f49d76662ed130ca41806bb3d91666423a411074 Mon Sep 17 00:00:00 2001
From: kennyj <kennyj@gmail.com>
Date: Sat, 14 Apr 2012 00:33:25 +0900
Subject: Fix wrong return value from reset_sequence_name method.

---
 activerecord/test/cases/base_test.rb | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index 5fb49d540f..ef22936e18 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -1503,7 +1503,11 @@ class BasicsTest < ActiveRecord::TestCase
     after_seq     = Joke.sequence_name
 
     assert_not_equal before_columns, after_columns
-    assert_not_equal before_seq, after_seq unless before_seq.blank? && after_seq.blank?
+    unless before_seq.nil? && after_seq.nil?
+      assert_not_equal before_seq, after_seq
+      assert_equal "cold_jokes_id_seq", before_seq
+      assert_equal "funny_jokes_id_seq", after_seq
+    end
   end
 
   def test_dont_clear_sequence_name_when_setting_explicitly
@@ -1514,7 +1518,7 @@ class BasicsTest < ActiveRecord::TestCase
     Joke.table_name    = "funny_jokes"
     after_seq          = Joke.sequence_name
 
-    assert_equal before_seq, after_seq unless before_seq.blank? && after_seq.blank?
+    assert_equal before_seq, after_seq unless before_seq.nil? && after_seq.nil?
   end
 
   def test_dont_clear_inheritnce_column_when_setting_explicitly
-- 
cgit v1.2.3


From 1ad138cf4b5c164c830917e5d4ef25943373bd0b Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 13 Apr 2012 18:26:04 +0100
Subject: fix tests

---
 activerecord/test/cases/associations/eager_test.rb | 123 ++++++++++-----------
 .../has_and_belongs_to_many_associations_test.rb   |   8 +-
 .../test/cases/associations/join_model_test.rb     |   2 +-
 activerecord/test/cases/calculations_test.rb       |  10 +-
 activerecord/test/cases/finder_test.rb             |   4 +-
 activerecord/test/cases/modules_test.rb            |   2 +-
 activerecord/test/cases/relation_test.rb           |   6 -
 7 files changed, 74 insertions(+), 81 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index f7f44208b3..196de34094 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -61,8 +61,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_loading_conditions_with_or
-    posts = authors(:david).posts.find(
-      :all, :include => :comments, :references => :comments,
+    posts = authors(:david).posts.references(:comments).find(
+      :all, :include => :comments,
       :conditions => "comments.body like 'Normal%' OR comments.#{QUOTED_TYPE} = 'SpecialComment'"
     )
     assert_nil posts.detect { |p| p.author_id != authors(:david).id },
@@ -276,25 +276,25 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_nested_loading_through_has_one_association_with_conditions
-    aa = AuthorAddress.find(
+    aa = AuthorAddress.references(:author_addresses).find(
       author_addresses(:david_address).id, :include => {:author => :posts},
-      :conditions => "author_addresses.id > 0", :references => :author_addresses
+      :conditions => "author_addresses.id > 0"
     )
     assert_equal aa.author.posts.count, aa.author.posts.length
   end
 
   def test_nested_loading_through_has_one_association_with_conditions_on_association
-    aa = AuthorAddress.find(
+    aa = AuthorAddress.references(:authors).find(
       author_addresses(:david_address).id, :include => {:author => :posts},
-      :conditions => "authors.id > 0", :references => :authors
+      :conditions => "authors.id > 0"
     )
     assert_equal aa.author.posts.count, aa.author.posts.length
   end
 
   def test_nested_loading_through_has_one_association_with_conditions_on_nested_association
-    aa = AuthorAddress.find(
+    aa = AuthorAddress.references(:posts).find(
       author_addresses(:david_address).id, :include => {:author => :posts},
-      :conditions => "posts.id > 0", :references => :posts
+      :conditions => "posts.id > 0"
     )
     assert_equal aa.author.posts.count, aa.author.posts.length
   end
@@ -564,9 +564,9 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_with_has_many_and_limit_and_high_offset_and_multiple_array_conditions
     assert_queries(1) do
-      posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :offset => 10,
-        :conditions => [ "authors.name = ? and comments.body = ?", 'David', 'go crazy' ],
-        :references => [:authors, :comments])
+      posts = Post.references(:authors, :comments).
+        find(:all, :include => [ :author, :comments ], :limit => 2, :offset => 10,
+          :conditions => [ "authors.name = ? and comments.body = ?", 'David', 'go crazy' ])
       assert_equal 0, posts.size
     end
   end
@@ -592,7 +592,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_eager_count_performed_on_a_has_many_association_with_multi_table_conditional
     author = authors(:david)
     author_posts_without_comments = author.posts.select { |post| post.comments.blank? }
-    assert_equal author_posts_without_comments.size, author.posts.count(:all, :include => :comments, :conditions => 'comments.id is null', :references => :comments)
+    assert_equal author_posts_without_comments.size, author.posts.includes(:comments).where('comments.id is null').references(:comments).count
   end
 
   def test_eager_count_performed_on_a_has_many_through_association_with_multi_table_conditional
@@ -628,75 +628,75 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_has_many_and_limit_and_conditions_on_the_eagers
-    posts = authors(:david).posts.find(:all,
-      :include    => :comments,
-      :conditions => "comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment'",
-      :references => :comments,
-      :limit      => 2
-    )
+    posts =
+      authors(:david).posts
+        .includes(:comments)
+        .where("comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment'")
+        .references(:comments)
+        .limit(2)
+        .to_a
     assert_equal 2, posts.size
 
-    count = Post.count(
-      :include    => [ :comments, :author ],
-      :conditions => "authors.name = 'David' AND (comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment')",
-      :references => [:authors, :comments],
-      :limit      => 2
-    )
+    count =
+      Post.includes(:comments, :author)
+        .where("authors.name = 'David' AND (comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment')")
+        .references(:authors, :comments)
+        .limit(2)
+        .count
     assert_equal count, posts.size
   end
 
   def test_eager_with_has_many_and_limit_and_scoped_conditions_on_the_eagers
     posts = nil
-    Post.send(:with_scope, :find => {
-      :include    => :comments,
-      :conditions => "comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment'",
-      :references => :comments
-    }) do
-      posts = authors(:david).posts.find(:all, :limit => 2)
+    Post.includes(:comments)
+      .where("comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment'")
+      .references(:comments)
+      .scoping do
+
+      posts = authors(:david).posts.limit(2).to_a
       assert_equal 2, posts.size
     end
 
-    Post.send(:with_scope, :find => {
-      :include    => [ :comments, :author ],
-      :conditions => "authors.name = 'David' AND (comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment')",
-      :references => [:authors, :comments]
-    }) do
-      count = Post.count(:limit => 2)
+    Post.includes(:comments, :author)
+      .where("authors.name = 'David' AND (comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment')")
+      .references(:authors, :comments)
+      .scoping do
+
+      count = Post.limit(2).count
       assert_equal count, posts.size
     end
   end
 
   def test_eager_with_has_many_and_limit_and_scoped_and_explicit_conditions_on_the_eagers
     Post.send(:with_scope, :find => { :conditions => "1=1" }) do
-      posts = authors(:david).posts.find(:all,
-        :include    => :comments,
-        :conditions => "comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment'",
-        :references => :comments,
-        :limit      => 2
-      )
+      posts =
+        authors(:david).posts
+          .includes(:comments)
+          .where("comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment'")
+          .references(:comments)
+          .limit(2)
+          .to_a
       assert_equal 2, posts.size
 
-      count = Post.count(
-        :include    => [ :comments, :author ],
-        :conditions => "authors.name = 'David' AND (comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment')",
-        :references => [:authors, :comments],
-        :limit      => 2
-      )
+      count = Post.includes(:comments, :author)
+        .where("authors.name = 'David' AND (comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment')")
+        .references(:authors, :comments)
+        .limit(2)
+        .count
       assert_equal count, posts.size
     end
   end
 
   def test_eager_with_scoped_order_using_association_limiting_without_explicit_scope
-    posts_with_explicit_order = Post.find(
-      :all, :conditions => 'comments.id is not null', :references => :comments,
-      :include => :comments, :order => 'posts.id DESC', :limit => 2
-    )
-    posts_with_scoped_order = Post.send(:with_scope, :find => {:order => 'posts.id DESC'}) do
-      Post.find(
-        :all, :conditions => 'comments.id is not null',
-        :references => :comments, :include => :comments, :limit => 2
-      )
+    posts_with_explicit_order =
+      Post.where('comments.id is not null').references(:comments)
+        .includes(:comments).order('posts.id DESC').limit(2)
+
+    posts_with_scoped_order = Post.order('posts.id DESC').scoping do
+      Post.where('comments.id is not null').references(:comments)
+        .includes(:comments).limit(2)
     end
+
     assert_equal posts_with_explicit_order, posts_with_scoped_order
   end
 
@@ -844,10 +844,9 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_limited_eager_with_numeric_in_association
     assert_equal(
       people(:david, :susan),
-      Person.find(
+      Person.references(:number1_fans_people).find(
         :all, :include => [:readers, :primary_contact, :number1_fan],
         :conditions => "number1_fans_people.first_name like 'M%'",
-        :references => :number1_fans_people,
         :order => 'people.id', :limit => 2, :offset => 0
       )
     )
@@ -965,11 +964,11 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_count_with_include
     if current_adapter?(:SybaseAdapter)
-      assert_equal 3, authors(:david).posts_with_comments.count(:conditions => "len(comments.body) > 15", :references => :comments)
+      assert_equal 3, authors(:david).posts_with_comments.where("len(comments.body) > 15").references(:comments).count
     elsif current_adapter?(:OpenBaseAdapter)
-      assert_equal 3, authors(:david).posts_with_comments.count(:conditions => "length(FETCHBLOB(comments.body)) > 15", :references => :comments)
+      assert_equal 3, authors(:david).posts_with_comments.where("length(FETCHBLOB(comments.body)) > 15").references(:comments).count
     else
-      assert_equal 3, authors(:david).posts_with_comments.count(:conditions => "length(comments.body) > 15", :references => :comments)
+      assert_equal 3, authors(:david).posts_with_comments.where("length(comments.body) > 15").references(:comments).count
     end
   end
 
diff --git a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
index f457dfb9b3..f5f5b96aa7 100644
--- a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
@@ -681,8 +681,8 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_join_table_alias
     assert_equal(
       3,
-      Developer.find(
-        :all, :include => {:projects => :developers}, :references => :developers_projects_join,
+      Developer.references(:developers_projects_join).find(
+        :all, :include => {:projects => :developers},
         :conditions => 'developers_projects_join.joined_on IS NOT NULL'
       ).size
     )
@@ -697,9 +697,9 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
 
     assert_equal(
       3,
-      Developer.find(
+      Developer.references(:developers_projects_join).find(
         :all, :include => {:projects => :developers}, :conditions => 'developers_projects_join.joined_on IS NOT NULL',
-        :references => :developers_projects_join, :group => group.join(",")
+        :group => group.join(",")
       ).size
     )
   end
diff --git a/activerecord/test/cases/associations/join_model_test.rb b/activerecord/test/cases/associations/join_model_test.rb
index 301755249c..dde5b26a88 100644
--- a/activerecord/test/cases/associations/join_model_test.rb
+++ b/activerecord/test/cases/associations/join_model_test.rb
@@ -362,7 +362,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     end
 
     assert_raise ActiveRecord::EagerLoadPolymorphicError do
-      tags(:general).taggings.find(:all, :include => :taggable, :references => :bogus_table, :conditions => 'bogus_table.column = 1')
+      tags(:general).taggings.includes(:taggable).where('bogus_table.column = 1').references(:bogus_table).to_a
     end
   end
 
diff --git a/activerecord/test/cases/calculations_test.rb b/activerecord/test/cases/calculations_test.rb
index 0391319a00..48cb05e36e 100644
--- a/activerecord/test/cases/calculations_test.rb
+++ b/activerecord/test/cases/calculations_test.rb
@@ -49,12 +49,12 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_get_maximum_of_field_with_include
-    assert_equal 55, Account.maximum(:credit_limit, :include => :firm, :references => :companies, :conditions => "companies.name != 'Summit'")
+    assert_equal 55, Account.where("companies.name != 'Summit'").references(:companies).includes(:firm).maximum(:credit_limit)
   end
 
   def test_should_get_maximum_of_field_with_scoped_include
-    Account.send :with_scope, :find => { :include => :firm, :references => :companies, :conditions => "companies.name != 'Summit'" } do
-      assert_equal 55, Account.maximum(:credit_limit)
+    Account.send :with_scope, :find => { :include => :firm } do
+      assert_equal 55, Account.where("companies.name != 'Summit'").references(:companies).maximum(:credit_limit)
     end
   end
 
@@ -270,10 +270,10 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_not_modify_options_when_using_includes
-    options = {:conditions => 'companies.id > 1', :include => :firm, :references => :companies}
+    options = {:conditions => 'companies.id > 1', :include => :firm}
     options_copy = options.dup
 
-    Account.count(:all, options)
+    Account.references(:companies).count(:all, options)
     assert_equal options_copy, options
   end
 
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index 96c8eb6417..70f3c4bcc5 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -1182,9 +1182,9 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_with_limiting_with_custom_select
-    posts = Post.find(
+    posts = Post.references(:authors).find(
       :all, :include => :author, :select => ' posts.*, authors.id as "author_id"',
-      :references => :authors, :limit => 3, :order => 'posts.id'
+      :limit => 3, :order => 'posts.id'
     )
     assert_equal 3, posts.size
     assert_equal [0, 1, 1], posts.map(&:author_id).sort
diff --git a/activerecord/test/cases/modules_test.rb b/activerecord/test/cases/modules_test.rb
index f7a5d05582..e0fdd2871c 100644
--- a/activerecord/test/cases/modules_test.rb
+++ b/activerecord/test/cases/modules_test.rb
@@ -72,7 +72,7 @@ class ModulesTest < ActiveRecord::TestCase
     clients = []
 
     assert_nothing_raised NameError, "Should be able to resolve all class constants via reflection" do
-      clients << MyApplication::Business::Client.find(3, :include => {:firm => :account}, :conditions => 'accounts.id IS NOT NULL', :references => :accounts)
+      clients << MyApplication::Business::Client.references(:accounts).find(3, :include => {:firm => :account}, :conditions => 'accounts.id IS NOT NULL')
       clients << MyApplication::Business::Client.find(3, :include => {:firm => :account})
     end
 
diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index 719b96fa0f..9ef703fd9b 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -128,12 +128,6 @@ module ActiveRecord
       assert_equal ['foo'], relation.references_values
     end
 
-    def test_apply_finder_options_takes_references
-      relation = Relation.new :a, :b
-      relation = relation.apply_finder_options(:references => :foo)
-      assert_equal ['foo'], relation.references_values
-    end
-
     test 'merging a hash into a relation' do
       relation = Relation.new :a, :b
       relation = relation.merge where: ['lol'], readonly: true
-- 
cgit v1.2.3


From ca0af8221a3b704fa289afe7030a96dc8cec8a95 Mon Sep 17 00:00:00 2001
From: Joshua Wood <josh@hintmedia.com>
Date: Fri, 2 Mar 2012 17:59:23 -0800
Subject: Automatically create indexes for references/belongs_to statements in
 migrations.

---
 .../test/cases/migration/references_index_test.rb  | 99 ++++++++++++++++++++++
 activerecord/test/cases/migration_test.rb          |  1 +
 2 files changed, 100 insertions(+)
 create mode 100644 activerecord/test/cases/migration/references_index_test.rb

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/migration/references_index_test.rb b/activerecord/test/cases/migration/references_index_test.rb
new file mode 100644
index 0000000000..8ab1c59724
--- /dev/null
+++ b/activerecord/test/cases/migration/references_index_test.rb
@@ -0,0 +1,99 @@
+require 'cases/helper'
+
+module ActiveRecord
+  class Migration
+    class ReferencesIndexTest < ActiveRecord::TestCase
+      attr_reader :connection, :table_name
+
+      def setup
+        super
+        @connection = ActiveRecord::Base.connection
+        @table_name = :testings
+      end
+
+      def teardown
+        super
+        connection.drop_table :testings rescue nil
+      end
+
+      def test_creates_index
+        connection.create_table table_name do |t|
+          t.references :foo, :index => true
+        end
+
+        assert connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
+      end
+
+      def test_does_not_create_index
+        connection.create_table table_name do |t|
+          t.references :foo
+        end
+
+        refute connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
+      end
+
+      def test_does_not_create_index_explicit
+        connection.create_table table_name do |t|
+          t.references :foo, :index => false
+        end
+
+        refute connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
+      end
+
+      def test_creates_index_with_options
+        connection.create_table table_name do |t|
+          t.references :foo, :index => {:name => :index_testings_on_yo_momma}
+          t.references :bar, :index => {:unique => true}
+        end
+
+        assert connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_yo_momma)
+        assert connection.index_exists?(table_name, :bar_id, :name => :index_testings_on_bar_id, :unique => true)
+      end
+
+      def test_creates_polymorphic_index
+        connection.create_table table_name do |t|
+          t.references :foo, :polymorphic => true, :index => true
+        end
+
+        assert connection.index_exists?(table_name, [:foo_id, :foo_type], :name => :index_testings_on_foo_id_and_foo_type)
+      end
+
+      def test_creates_index_for_existing_table
+        connection.create_table table_name
+        connection.change_table table_name do |t|
+          t.references :foo, :index => true
+        end
+
+        assert connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
+      end
+
+      def test_does_not_create_index_for_existing_table
+        connection.create_table table_name
+        connection.change_table table_name do |t|
+          t.references :foo
+        end
+
+        refute connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
+      end
+
+      def test_does_not_create_index_for_existing_table_explicit
+        connection.create_table table_name
+        connection.change_table table_name do |t|
+          t.references :foo, :index => false
+        end
+
+        refute connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
+      end
+
+      def test_creates_polymorphic_index_for_existing_table
+        connection.create_table table_name
+        connection.change_table table_name do |t|
+          t.references :foo, :polymorphic => true, :index => true
+        end
+
+        assert connection.index_exists?(table_name, [:foo_id, :foo_type], :name => :index_testings_on_foo_id_and_foo_type)
+      end
+
+    end
+  end
+end
diff --git a/activerecord/test/cases/migration_test.rb b/activerecord/test/cases/migration_test.rb
index e2936963d9..e14c2d072c 100644
--- a/activerecord/test/cases/migration_test.rb
+++ b/activerecord/test/cases/migration_test.rb
@@ -404,6 +404,7 @@ end
 class ChangeTableMigrationsTest < ActiveRecord::TestCase
   def setup
     @connection = Person.connection
+    @connection.stubs(:add_index)
     @connection.create_table :delete_me, :force => true do |t|
     end
   end
-- 
cgit v1.2.3


From b8f748269584c1475f6e06aec48fce627f603880 Mon Sep 17 00:00:00 2001
From: Aaron Patterson <aaron.patterson@gmail.com>
Date: Sun, 15 Apr 2012 18:13:15 -0700
Subject: opening a connection will block if the pool is full

---
 activerecord/test/cases/connection_pool_test.rb | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/connection_pool_test.rb b/activerecord/test/cases/connection_pool_test.rb
index da93500ce3..8dc9f761c2 100644
--- a/activerecord/test/cases/connection_pool_test.rb
+++ b/activerecord/test/cases/connection_pool_test.rb
@@ -96,6 +96,30 @@ module ActiveRecord
         end
       end
 
+      def test_full_pool_blocks
+        cs = @pool.size.times.map { @pool.checkout }
+        t = Thread.new { @pool.checkout }
+
+        # make sure our thread is in the timeout section
+        Thread.pass until t.status == "sleep"
+
+        connection = cs.first
+        connection.close
+        assert_equal connection, t.join.value
+      end
+
+      def test_removing_releases_latch
+        cs = @pool.size.times.map { @pool.checkout }
+        t = Thread.new { @pool.checkout }
+
+        # make sure our thread is in the timeout section
+        Thread.pass until t.status == "sleep"
+
+        connection = cs.first
+        @pool.remove connection
+        assert_respond_to t.join.value, :execute
+      end
+
       def test_reap_and_active
         @pool.checkout
         @pool.checkout
-- 
cgit v1.2.3


From 851b816f56f6c918d88cbed56f50bffede4ed55a Mon Sep 17 00:00:00 2001
From: Akira Matsuda <ronnie@dio.jp>
Date: Thu, 19 Apr 2012 22:04:13 +0900
Subject: be sure to currectly fetch PK name from MySQL even if the PK has some
 custom option

---
 .../cases/adapters/mysql/mysql_adapter_test.rb     | 30 ++++++++++++++++++++++
 1 file changed, 30 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb b/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb
index 5aa4743e7b..475a292f85 100644
--- a/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb
+++ b/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb
@@ -56,6 +56,36 @@ module ActiveRecord
         end
       end
 
+      def test_pk_and_sequence_for
+        pk, seq = @conn.pk_and_sequence_for('ex')
+        assert_equal 'id', pk
+        assert_equal @conn.default_sequence_name('ex', 'id'), seq
+      end
+
+      def test_pk_and_sequence_for_with_non_standard_primary_key
+        @conn.exec_query('drop table if exists ex_with_non_standard_pk')
+        @conn.exec_query(<<-eosql)
+          CREATE TABLE `ex_with_non_standard_pk` (
+            `code` INT(11) DEFAULT NULL auto_increment,
+             PRIMARY KEY  (`code`))
+        eosql
+        pk, seq = @conn.pk_and_sequence_for('ex_with_non_standard_pk')
+        assert_equal 'code', pk
+        assert_equal @conn.default_sequence_name('ex_with_non_standard_pk', 'code'), seq
+      end
+
+      def test_pk_and_sequence_for_with_custom_index_type_pk
+        @conn.exec_query('drop table if exists ex_with_custom_index_type_pk')
+        @conn.exec_query(<<-eosql)
+          CREATE TABLE `ex_with_custom_index_type_pk` (
+            `id` INT(11) DEFAULT NULL auto_increment,
+             PRIMARY KEY  USING BTREE (`id`))
+        eosql
+        pk, seq = @conn.pk_and_sequence_for('ex_with_custom_index_type_pk')
+        assert_equal 'id', pk
+        assert_equal @conn.default_sequence_name('ex_with_custom_index_type_pk', 'id'), seq
+      end
+
       private
       def insert(ctx, data)
         binds   = data.map { |name, value|
-- 
cgit v1.2.3


From 2aa7c6d065802cd230a812b8331ee293e4aae0e8 Mon Sep 17 00:00:00 2001
From: kennyj <kennyj@gmail.com>
Date: Wed, 25 Apr 2012 01:31:26 +0900
Subject: Fix build. It seems that the Mocha's behavior were changed.

---
 activerecord/test/cases/autosave_association_test.rb | 8 ++++++--
 activerecord/test/cases/explain_test.rb              | 4 +++-
 2 files changed, 9 insertions(+), 3 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/autosave_association_test.rb b/activerecord/test/cases/autosave_association_test.rb
index d15487ab11..d555c1699e 100644
--- a/activerecord/test/cases/autosave_association_test.rb
+++ b/activerecord/test/cases/autosave_association_test.rb
@@ -627,7 +627,9 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
   def test_a_child_marked_for_destruction_should_not_be_destroyed_twice
     @pirate.ship.mark_for_destruction
     assert @pirate.save
-    @pirate.ship.expects(:destroy).never
+    class << @pirate.ship
+      def destroy; raise "Should not be called" end
+    end
     assert @pirate.save
   end
 
@@ -672,7 +674,9 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
   def test_a_parent_marked_for_destruction_should_not_be_destroyed_twice
     @ship.pirate.mark_for_destruction
     assert @ship.save
-    @ship.pirate.expects(:destroy).never
+    class << @ship.pirate
+      def destroy; raise "Should not be called" end
+    end
     assert @ship.save
   end
 
diff --git a/activerecord/test/cases/explain_test.rb b/activerecord/test/cases/explain_test.rb
index 83c9b6e107..cb7781f8e7 100644
--- a/activerecord/test/cases/explain_test.rb
+++ b/activerecord/test/cases/explain_test.rb
@@ -28,7 +28,9 @@ if ActiveRecord::Base.connection.supports_explain?
       original = base.logger
       base.logger = nil
 
-      base.logger.expects(:warn).never
+      class << base.logger
+        def warn; raise "Should not be called" end
+      end
 
       with_threshold(0) do
         car = Car.where(:name => 'honda').first
-- 
cgit v1.2.3


From 0c46dbbc4557acb1e0af1c8ce697305398070922 Mon Sep 17 00:00:00 2001
From: Ryan Fitzgerald <rwfitzge@gmail.com>
Date: Tue, 24 Apr 2012 20:43:10 -0700
Subject: Always quote hstore keys and values

escape_hstore uses quotation marks around keys and values only if it
seems necessary. However, it currently breaks in the presence of some
non-ASCII characters. Instead of trying to guess exactly which
characters are safe, it seems better to always use quotes.
---
 activerecord/test/cases/adapters/postgresql/hstore_test.rb | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/adapters/postgresql/hstore_test.rb b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
index 1644a58d92..05d38ec1f1 100644
--- a/activerecord/test/cases/adapters/postgresql/hstore_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require "cases/helper"
 require 'active_record/base'
 require 'active_record/connection_adapters/postgresql_adapter'
@@ -134,13 +136,19 @@ class PostgresqlHstoreTest < ActiveRecord::TestCase
     assert_cycle('a=>b' => 'bar', '1"foo' => '2')
   end
 
+  def test_quoting_special_characters
+    assert_cycle('ca' => 'cà', 'ac' => 'àc')
+  end
+
   private
   def assert_cycle hash
+    # test creation
     x = Hstore.create!(:tags => hash)
     x.reload
     assert_equal(hash, x.tags)
 
-    # make sure updates work
+    # test updating
+    x = Hstore.create!(:tags => {})
     x.tags = hash
     x.save!
     x.reload
-- 
cgit v1.2.3


From 408437334bcb5df8d8daf7b60c13d496222954d2 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Sun, 22 Apr 2012 08:58:13 +0200
Subject: giving a hash to default scope should not be deprecated (well, not
 for this reason)

---
 activerecord/test/cases/named_scope_test.rb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/named_scope_test.rb b/activerecord/test/cases/named_scope_test.rb
index 0d3c0b20a4..2f4eb489ab 100644
--- a/activerecord/test/cases/named_scope_test.rb
+++ b/activerecord/test/cases/named_scope_test.rb
@@ -470,11 +470,11 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert_equal [posts(:welcome).title], klass.welcome_2.map(&:title)
   end
 
-  def test_eager_default_scope_hashes_are_deprecated
+  def test_eager_default_scope_hashes_are_not_deprecated
     klass = Class.new(ActiveRecord::Base)
     klass.table_name = 'posts'
 
-    assert_deprecated do
+    assert_not_deprecated do
       klass.send(:default_scope, :conditions => { :id => posts(:welcome).id })
     end
     assert_equal [posts(:welcome).title], klass.all.map(&:title)
-- 
cgit v1.2.3


From e8cdb3d5e73c1be3d551f55602de7f5c34d43c42 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Sun, 22 Apr 2012 09:49:56 +0200
Subject: allow merging a single where value

---
 activerecord/test/cases/relation_test.rb | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index 9ef703fd9b..d1fb3e01d2 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -156,6 +156,12 @@ module ActiveRecord
       relation = Relation.new(:a, :b, where: [:foo])
       assert_equal [:foo], relation.where_values
     end
+
+    test 'merging a single where value' do
+      relation = Relation.new(:a, :b)
+      relation.merge!(where: :foo)
+      assert_equal [:foo], relation.where_values
+    end
   end
 
   class RelationMutationTest < ActiveSupport::TestCase
-- 
cgit v1.2.3


From ef1d1e1492e3c48884f7653103bc9313dd04cfad Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Sun, 22 Apr 2012 11:34:55 +0200
Subject: fix interpolation for hash merging

---
 activerecord/test/cases/relation_test.rb | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index d1fb3e01d2..8a7a2441d4 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -130,9 +130,9 @@ module ActiveRecord
 
     test 'merging a hash into a relation' do
       relation = Relation.new :a, :b
-      relation = relation.merge where: ['lol'], readonly: true
+      relation = relation.merge where: :lol, readonly: true
 
-      assert_equal ['lol'], relation.where_values
+      assert_equal [:lol], relation.where_values
       assert_equal true, relation.readonly_value
     end
 
@@ -162,6 +162,15 @@ module ActiveRecord
       relation.merge!(where: :foo)
       assert_equal [:foo], relation.where_values
     end
+
+    test 'merging a hash interpolates conditions' do
+      klass = stub
+      klass.stubs(:sanitize_sql).with(['foo = ?', 'bar']).returns('foo = bar')
+
+      relation = Relation.new(klass, :b)
+      relation.merge!(where: ['foo = ?', 'bar'])
+      assert_equal ['foo = bar'], relation.where_values
+    end
   end
 
   class RelationMutationTest < ActiveSupport::TestCase
@@ -227,8 +236,8 @@ module ActiveRecord
     end
 
     test 'merge!' do
-      assert relation.merge!(where: ['foo']).equal?(relation)
-      assert_equal ['foo'], relation.where_values
+      assert relation.merge!(where: :foo).equal?(relation)
+      assert_equal [:foo], relation.where_values
     end
   end
 end
-- 
cgit v1.2.3


From 618c5fc3c0f4d1d5bee8c8f8e517b6bfacd17dc2 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Sun, 22 Apr 2012 11:44:55 +0200
Subject: Extract deprecated code

---
 activerecord/test/cases/base_test.rb | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index ef22936e18..024225b813 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -2087,4 +2087,9 @@ class BasicsTest < ActiveRecord::TestCase
       assert_equal record, klass.public_send(meth, :foo, :bar)
     end
   end
+
+  test "scoped can take a values hash" do
+    klass = Class.new(ActiveRecord::Base)
+    assert_equal ['foo'], klass.scoped(select: 'foo').select_values
+  end
 end
-- 
cgit v1.2.3


From af27c8b0418fb41e51b6d096b0ab0228ff773e37 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Sun, 22 Apr 2012 12:28:26 +0200
Subject: extract deprecated code

---
 activerecord/test/cases/named_scope_test.rb | 5 -----
 activerecord/test/models/topic.rb           | 4 ++--
 2 files changed, 2 insertions(+), 7 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/named_scope_test.rb b/activerecord/test/cases/named_scope_test.rb
index 2f4eb489ab..06d076943e 100644
--- a/activerecord/test/cases/named_scope_test.rb
+++ b/activerecord/test/cases/named_scope_test.rb
@@ -459,11 +459,6 @@ class NamedScopeTest < ActiveRecord::TestCase
     klass = Class.new(ActiveRecord::Base)
     klass.table_name = 'posts'
 
-    assert_deprecated do
-      klass.scope :welcome, { :conditions => { :id => posts(:welcome).id } }
-    end
-    assert_equal [posts(:welcome).title], klass.welcome.map(&:title)
-
     assert_deprecated do
       klass.scope :welcome_2, klass.where(:id => posts(:welcome).id)
     end
diff --git a/activerecord/test/models/topic.rb b/activerecord/test/models/topic.rb
index 785839be75..0625b8d296 100644
--- a/activerecord/test/models/topic.rb
+++ b/activerecord/test/models/topic.rb
@@ -45,8 +45,8 @@ class Topic < ActiveRecord::Base
       2
     end
   end
-  scope :named_extension, -> { { :extend => NamedExtension } }
-  scope :multiple_extensions, -> { { :extend => [MultipleExtensionTwo, MultipleExtensionOne] } }
+  scope :named_extension, :extend => NamedExtension
+  scope :multiple_extensions, :extend => [MultipleExtensionTwo, MultipleExtensionOne]
 
   has_many :replies, :dependent => :destroy, :foreign_key => "parent_id"
   has_many :replies_with_primary_key, :class_name => "Reply", :dependent => :destroy, :primary_key => "title", :foreign_key => "parent_title"
-- 
cgit v1.2.3


From 98de70e2e12cff98acbc38727e709ff99db331b6 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Wed, 25 Apr 2012 16:04:57 +0100
Subject: add missing test

---
 .../test/cases/associations/belongs_to_associations_test.rb  | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/associations/belongs_to_associations_test.rb b/activerecord/test/cases/associations/belongs_to_associations_test.rb
index 9dd041af81..58808871de 100644
--- a/activerecord/test/cases/associations/belongs_to_associations_test.rb
+++ b/activerecord/test/cases/associations/belongs_to_associations_test.rb
@@ -705,4 +705,16 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
     assert_equal toy, sponsor.reload.sponsorable
   end
+
+  test "stale tracking doesn't care about the type" do
+    apple = Firm.create("name" => "Apple")
+    citibank = Account.create("credit_limit" => 10)
+
+    citibank.firm_id = apple.id
+    citibank.firm # load it
+
+    citibank.firm_id = apple.id.to_s
+
+    assert !citibank.association(:firm).stale_target?
+  end
 end
-- 
cgit v1.2.3


From 40a711ce29505e95d5033fe02c22ba7469206f06 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Wed, 25 Apr 2012 17:31:26 +0100
Subject: remove tests for #with_scope (it's now deprecated)

---
 activerecord/test/cases/associations/eager_test.rb |  33 --
 .../test/cases/associations/join_model_test.rb     |   8 -
 activerecord/test/cases/base_test.rb               |  78 ---
 activerecord/test/cases/calculations_test.rb       |   6 -
 activerecord/test/cases/finder_test.rb             |  14 -
 activerecord/test/cases/locking_test.rb            |  11 -
 activerecord/test/cases/method_scoping_test.rb     | 558 ---------------------
 activerecord/test/cases/readonly_test.rb           |   8 +-
 activerecord/test/cases/relation_scoping_test.rb   |  22 -
 activerecord/test/cases/relations_test.rb          |   1 -
 .../validations/uniqueness_validation_test.rb      |   4 +-
 activerecord/test/cases/validations_test.rb        |  24 -
 activerecord/test/models/developer.rb              |   6 -
 13 files changed, 6 insertions(+), 767 deletions(-)
 delete mode 100644 activerecord/test/cases/method_scoping_test.rb

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index 196de34094..d700554af7 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -667,39 +667,6 @@ class EagerAssociationTest < ActiveRecord::TestCase
     end
   end
 
-  def test_eager_with_has_many_and_limit_and_scoped_and_explicit_conditions_on_the_eagers
-    Post.send(:with_scope, :find => { :conditions => "1=1" }) do
-      posts =
-        authors(:david).posts
-          .includes(:comments)
-          .where("comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment'")
-          .references(:comments)
-          .limit(2)
-          .to_a
-      assert_equal 2, posts.size
-
-      count = Post.includes(:comments, :author)
-        .where("authors.name = 'David' AND (comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment')")
-        .references(:authors, :comments)
-        .limit(2)
-        .count
-      assert_equal count, posts.size
-    end
-  end
-
-  def test_eager_with_scoped_order_using_association_limiting_without_explicit_scope
-    posts_with_explicit_order =
-      Post.where('comments.id is not null').references(:comments)
-        .includes(:comments).order('posts.id DESC').limit(2)
-
-    posts_with_scoped_order = Post.order('posts.id DESC').scoping do
-      Post.where('comments.id is not null').references(:comments)
-        .includes(:comments).limit(2)
-    end
-
-    assert_equal posts_with_explicit_order, posts_with_scoped_order
-  end
-
   def test_eager_association_loading_with_habtm
     posts = Post.find(:all, :include => :categories, :order => "posts.id")
     assert_equal 2, posts[0].categories.size
diff --git a/activerecord/test/cases/associations/join_model_test.rb b/activerecord/test/cases/associations/join_model_test.rb
index dde5b26a88..d5d1d3405d 100644
--- a/activerecord/test/cases/associations/join_model_test.rb
+++ b/activerecord/test/cases/associations/join_model_test.rb
@@ -327,14 +327,6 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert_equal [authors(:david), authors(:bob)], posts(:thinking).authors_using_custom_pk.order('authors.id')
   end
 
-  def test_both_scoped_and_explicit_joins_should_be_respected
-    assert_nothing_raised do
-      Post.send(:with_scope, :find => {:joins => "left outer join comments on comments.id = posts.id"}) do
-        Post.find :all, :select => "comments.id, authors.id", :joins => "left outer join authors on authors.id = posts.author_id"
-      end
-    end
-  end
-
   def test_belongs_to_polymorphic_with_counter_cache
     assert_equal 1, posts(:welcome)[:taggings_count]
     tagging = posts(:welcome).taggings.create(:tag => tags(:general))
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index 024225b813..eadc7e1701 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -1599,83 +1599,12 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal res6, res7
   end
 
-  def test_scoped_find_conditions
-    scoped_developers = Developer.send(:with_scope, :find => { :conditions => 'salary > 90000' }) do
-      Developer.find(:all, :conditions => 'id < 5')
-    end
-    assert !scoped_developers.include?(developers(:david)) # David's salary is less than 90,000
-    assert_equal 3, scoped_developers.size
-  end
-
   def test_no_limit_offset
     assert_nothing_raised do
       Developer.find(:all, :offset => 2)
     end
   end
 
-  def test_scoped_find_limit_offset
-    scoped_developers = Developer.send(:with_scope, :find => { :limit => 3, :offset => 2 }) do
-      Developer.find(:all, :order => 'id')
-    end
-    assert !scoped_developers.include?(developers(:david))
-    assert !scoped_developers.include?(developers(:jamis))
-    assert_equal 3, scoped_developers.size
-
-    # Test without scoped find conditions to ensure we get the whole thing
-    developers = Developer.find(:all, :order => 'id')
-    assert_equal Developer.count, developers.size
-  end
-
-  def test_scoped_find_order
-    # Test order in scope
-    scoped_developers = Developer.send(:with_scope, :find => { :limit => 1, :order => 'salary DESC' }) do
-      Developer.find(:all)
-    end
-    assert_equal 'Jamis', scoped_developers.first.name
-    assert scoped_developers.include?(developers(:jamis))
-    # Test scope without order and order in find
-    scoped_developers = Developer.send(:with_scope, :find => { :limit => 1 }) do
-      Developer.find(:all, :order => 'salary DESC')
-    end
-    # Test scope order + find order, order has priority
-    scoped_developers = Developer.send(:with_scope, :find => { :limit => 3, :order => 'id DESC' }) do
-      Developer.find(:all, :order => 'salary ASC')
-    end
-    assert scoped_developers.include?(developers(:poor_jamis))
-    assert ! scoped_developers.include?(developers(:david))
-    assert ! scoped_developers.include?(developers(:jamis))
-    assert_equal 3, scoped_developers.size
-
-    # Test without scoped find conditions to ensure we get the right thing
-    assert ! scoped_developers.include?(Developer.find(1))
-    assert scoped_developers.include?(Developer.find(11))
-  end
-
-  def test_scoped_find_limit_offset_including_has_many_association
-    topics = Topic.send(:with_scope, :find => {:limit => 1, :offset => 1, :include => :replies}) do
-      Topic.find(:all, :order => "topics.id")
-    end
-    assert_equal 1, topics.size
-    assert_equal 2, topics.first.id
-  end
-
-  def test_scoped_find_order_including_has_many_association
-    developers = Developer.send(:with_scope, :find => { :order => 'developers.salary DESC', :include => :projects }) do
-      Developer.find(:all)
-    end
-    assert developers.size >= 2
-    (1...developers.size).each do |i|
-      assert developers[i-1].salary >= developers[i].salary
-    end
-  end
-
-  def test_scoped_find_with_group_and_having
-    developers = Developer.send(:with_scope, :find => { :group => 'developers.salary', :having => "SUM(salary) > 10000", :select => "SUM(salary) as salary" }) do
-      Developer.find(:all)
-    end
-    assert_equal 3, developers.size
-  end
-
   def test_find_last
     last  = Developer.find :last
     assert_equal last, Developer.find(:first, :order => 'id desc')
@@ -1725,13 +1654,6 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal last, Developer.find(:all, :order => :salary).last
   end
 
-  def test_find_scoped_ordered_last
-    last_developer = Developer.send(:with_scope, :find => { :order => 'developers.salary ASC' }) do
-      Developer.find(:last)
-    end
-    assert_equal last_developer, Developer.find(:all, :order => 'developers.salary ASC').last
-  end
-
   def test_abstract_class
     assert !ActiveRecord::Base.abstract_class?
     assert LoosePerson.abstract_class?
diff --git a/activerecord/test/cases/calculations_test.rb b/activerecord/test/cases/calculations_test.rb
index 48cb05e36e..af1e689eff 100644
--- a/activerecord/test/cases/calculations_test.rb
+++ b/activerecord/test/cases/calculations_test.rb
@@ -52,12 +52,6 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal 55, Account.where("companies.name != 'Summit'").references(:companies).includes(:firm).maximum(:credit_limit)
   end
 
-  def test_should_get_maximum_of_field_with_scoped_include
-    Account.send :with_scope, :find => { :include => :firm } do
-      assert_equal 55, Account.where("companies.name != 'Summit'").references(:companies).maximum(:credit_limit)
-    end
-  end
-
   def test_should_get_minimum_of_field
     assert_equal 50, Account.minimum(:credit_limit)
   end
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index 70f3c4bcc5..36ec459ca1 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -82,12 +82,6 @@ class FinderTest < ActiveRecord::TestCase
       Address.new(existing_address.street + "1", existing_address.city, existing_address.country))
   end
 
-  def test_exists_with_scoped_include
-    Developer.send(:with_scope, :find => { :include => :projects, :order => "projects.name" }) do
-      assert Developer.exists?
-    end
-  end
-
   def test_exists_does_not_instantiate_records
     Developer.expects(:instantiate).never
     Developer.exists?
@@ -1190,14 +1184,6 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal [0, 1, 1], posts.map(&:author_id).sort
   end
 
-  def test_finder_with_scoped_from
-    all_topics = Topic.find(:all)
-
-    Topic.send(:with_scope, :find => { :from => 'fake_topics' }) do
-      assert_equal all_topics, Topic.from('topics').to_a
-    end
-  end
-
   def test_find_one_message_with_custom_primary_key
     Toy.primary_key = :name
     begin
diff --git a/activerecord/test/cases/locking_test.rb b/activerecord/test/cases/locking_test.rb
index cc6baa6153..48ce7ea2d3 100644
--- a/activerecord/test/cases/locking_test.rb
+++ b/activerecord/test/cases/locking_test.rb
@@ -363,17 +363,6 @@ unless current_adapter?(:SybaseAdapter, :OpenBaseAdapter) || in_memory_db?
       end
     end
 
-    # Test scoped lock.
-    def test_sane_find_with_scoped_lock
-      assert_nothing_raised do
-        Person.transaction do
-          Person.send(:with_scope, :find => { :lock => true }) do
-            Person.find 1
-          end
-        end
-      end
-    end
-
     # PostgreSQL protests SELECT ... FOR UPDATE on an outer join.
     unless current_adapter?(:PostgreSQLAdapter)
       # Test locked eager find.
diff --git a/activerecord/test/cases/method_scoping_test.rb b/activerecord/test/cases/method_scoping_test.rb
deleted file mode 100644
index ebf6e26385..0000000000
--- a/activerecord/test/cases/method_scoping_test.rb
+++ /dev/null
@@ -1,558 +0,0 @@
-# This file can be removed once with_exclusive_scope and with_scope are removed.
-# All the tests were already ported to relation_scoping_test.rb when the new
-# relation scoping API was added.
-
-require "cases/helper"
-require 'models/post'
-require 'models/author'
-require 'models/developer'
-require 'models/project'
-require 'models/comment'
-
-class MethodScopingTest < ActiveRecord::TestCase
-  fixtures :authors, :developers, :projects, :comments, :posts, :developers_projects
-
-  def test_set_conditions
-    Developer.send(:with_scope, :find => { :conditions => 'just a test...' }) do
-      assert_match '(just a test...)', Developer.scoped.to_sql
-    end
-  end
-
-  def test_scoped_find
-    Developer.send(:with_scope, :find => { :conditions => "name = 'David'" }) do
-      assert_nothing_raised { Developer.find(1) }
-    end
-  end
-
-  def test_scoped_find_first
-    Developer.send(:with_scope, :find => { :conditions => "salary = 100000" }) do
-      assert_equal Developer.find(10), Developer.find(:first, :order => 'name')
-    end
-  end
-
-  def test_scoped_find_last
-    highest_salary = Developer.find(:first, :order => "salary DESC")
-
-    Developer.send(:with_scope, :find => { :order => "salary" }) do
-      assert_equal highest_salary, Developer.last
-    end
-  end
-
-  def test_scoped_find_last_preserves_scope
-    lowest_salary = Developer.find(:first, :order => "salary ASC")
-    highest_salary = Developer.find(:first, :order => "salary DESC")
-
-    Developer.send(:with_scope, :find => { :order => "salary" }) do
-      assert_equal highest_salary, Developer.last
-      assert_equal lowest_salary, Developer.first
-    end
-  end
-
-  def test_scoped_find_combines_conditions
-    Developer.send(:with_scope, :find => { :conditions => "salary = 9000" }) do
-      assert_equal developers(:poor_jamis), Developer.find(:first, :conditions => "name = 'Jamis'")
-    end
-  end
-
-  def test_scoped_find_sanitizes_conditions
-    Developer.send(:with_scope, :find => { :conditions => ['salary = ?', 9000] }) do
-      assert_equal developers(:poor_jamis), Developer.find(:first)
-    end
-  end
-
-  def test_scoped_find_combines_and_sanitizes_conditions
-    Developer.send(:with_scope, :find => { :conditions => ['salary = ?', 9000] }) do
-      assert_equal developers(:poor_jamis), Developer.find(:first, :conditions => ['name = ?', 'Jamis'])
-    end
-  end
-
-  def test_scoped_find_all
-    Developer.send(:with_scope, :find => { :conditions => "name = 'David'" }) do
-      assert_equal [developers(:david)], Developer.all
-    end
-  end
-
-  def test_scoped_find_select
-    Developer.send(:with_scope, :find => { :select => "id, name" }) do
-      developer = Developer.find(:first, :conditions => "name = 'David'")
-      assert_equal "David", developer.name
-      assert !developer.has_attribute?(:salary)
-    end
-  end
-
-  def test_scope_select_concatenates
-    Developer.send(:with_scope, :find => { :select => "name" }) do
-      developer = Developer.find(:first, :select => 'id, salary', :conditions => "name = 'David'")
-      assert_equal 80000, developer.salary
-      assert developer.has_attribute?(:id)
-      assert developer.has_attribute?(:name)
-      assert developer.has_attribute?(:salary)
-    end
-  end
-
-  def test_scoped_count
-    Developer.send(:with_scope, :find => { :conditions => "name = 'David'" }) do
-      assert_equal 1, Developer.count
-    end
-
-    Developer.send(:with_scope, :find => { :conditions => 'salary = 100000' }) do
-      assert_equal 8, Developer.count
-      assert_equal 1, Developer.count(:conditions => "name LIKE 'fixture_1%'")
-    end
-  end
-
-  def test_scoped_find_include
-    # with the include, will retrieve only developers for the given project
-    scoped_developers = Developer.send(:with_scope, :find => { :include => :projects }) do
-      Developer.find(:all, :conditions => { 'projects.id' => 2 })
-    end
-    assert scoped_developers.include?(developers(:david))
-    assert !scoped_developers.include?(developers(:jamis))
-    assert_equal 1, scoped_developers.size
-  end
-
-  def test_scoped_find_joins
-    scoped_developers = Developer.send(:with_scope, :find => { :joins => 'JOIN developers_projects ON id = developer_id' } ) do
-      Developer.find(:all, :conditions => 'developers_projects.project_id = 2')
-    end
-    assert scoped_developers.include?(developers(:david))
-    assert !scoped_developers.include?(developers(:jamis))
-    assert_equal 1, scoped_developers.size
-    assert_equal developers(:david).attributes, scoped_developers.first.attributes
-  end
-
-  def test_scoped_find_using_new_style_joins
-    scoped_developers = Developer.send(:with_scope, :find => { :joins => :projects }) do
-      Developer.find(:all, :conditions => 'projects.id = 2')
-    end
-    assert scoped_developers.include?(developers(:david))
-    assert !scoped_developers.include?(developers(:jamis))
-    assert_equal 1, scoped_developers.size
-    assert_equal developers(:david).attributes, scoped_developers.first.attributes
-  end
-
-  def test_scoped_find_merges_old_style_joins
-    scoped_authors = Author.send(:with_scope, :find => { :joins => 'INNER JOIN posts ON authors.id = posts.author_id ' }) do
-      Author.find(:all, :select => 'DISTINCT authors.*', :joins => 'INNER JOIN comments ON posts.id = comments.post_id', :conditions => 'comments.id = 1')
-    end
-    assert scoped_authors.include?(authors(:david))
-    assert !scoped_authors.include?(authors(:mary))
-    assert_equal 1, scoped_authors.size
-    assert_equal authors(:david).attributes, scoped_authors.first.attributes
-  end
-
-  def test_scoped_find_merges_new_style_joins
-    scoped_authors = Author.send(:with_scope, :find => { :joins => :posts }) do
-      Author.find(:all, :select => 'DISTINCT authors.*', :joins => :comments, :conditions => 'comments.id = 1')
-    end
-    assert scoped_authors.include?(authors(:david))
-    assert !scoped_authors.include?(authors(:mary))
-    assert_equal 1, scoped_authors.size
-    assert_equal authors(:david).attributes, scoped_authors.first.attributes
-  end
-
-  def test_scoped_find_merges_new_and_old_style_joins
-    scoped_authors = Author.send(:with_scope, :find => { :joins => :posts }) do
-      Author.find(:all, :select => 'DISTINCT authors.*', :joins => 'JOIN comments ON posts.id = comments.post_id', :conditions => 'comments.id = 1')
-    end
-    assert scoped_authors.include?(authors(:david))
-    assert !scoped_authors.include?(authors(:mary))
-    assert_equal 1, scoped_authors.size
-    assert_equal authors(:david).attributes, scoped_authors.first.attributes
-  end
-
-  def test_scoped_find_merges_string_array_style_and_string_style_joins
-    scoped_authors = Author.send(:with_scope, :find => { :joins => ["INNER JOIN posts ON posts.author_id = authors.id"]}) do
-      Author.find(:all, :select => 'DISTINCT authors.*', :joins => 'INNER JOIN comments ON posts.id = comments.post_id', :conditions => 'comments.id = 1')
-    end
-    assert scoped_authors.include?(authors(:david))
-    assert !scoped_authors.include?(authors(:mary))
-    assert_equal 1, scoped_authors.size
-    assert_equal authors(:david).attributes, scoped_authors.first.attributes
-  end
-
-  def test_scoped_find_merges_string_array_style_and_hash_style_joins
-    scoped_authors = Author.send(:with_scope, :find => { :joins => :posts}) do
-      Author.find(:all, :select => 'DISTINCT authors.*', :joins => ['INNER JOIN comments ON posts.id = comments.post_id'], :conditions => 'comments.id = 1')
-    end
-    assert scoped_authors.include?(authors(:david))
-    assert !scoped_authors.include?(authors(:mary))
-    assert_equal 1, scoped_authors.size
-    assert_equal authors(:david).attributes, scoped_authors.first.attributes
-  end
-
-  def test_scoped_find_merges_joins_and_eliminates_duplicate_string_joins
-    scoped_authors = Author.send(:with_scope, :find => { :joins => 'INNER JOIN posts ON posts.author_id = authors.id'}) do
-      Author.find(:all, :select => 'DISTINCT authors.*', :joins => ["INNER JOIN posts ON posts.author_id = authors.id", "INNER JOIN comments ON posts.id = comments.post_id"], :conditions => 'comments.id = 1')
-    end
-    assert scoped_authors.include?(authors(:david))
-    assert !scoped_authors.include?(authors(:mary))
-    assert_equal 1, scoped_authors.size
-    assert_equal authors(:david).attributes, scoped_authors.first.attributes
-  end
-
-  def test_scoped_find_strips_spaces_from_string_joins_and_eliminates_duplicate_string_joins
-    scoped_authors = Author.send(:with_scope, :find => { :joins => ' INNER JOIN posts ON posts.author_id = authors.id '}) do
-      Author.find(:all, :select => 'DISTINCT authors.*', :joins => ['INNER JOIN posts ON posts.author_id = authors.id'], :conditions => 'posts.id = 1')
-    end
-    assert scoped_authors.include?(authors(:david))
-    assert !scoped_authors.include?(authors(:mary))
-    assert_equal 1, scoped_authors.size
-    assert_equal authors(:david).attributes, scoped_authors.first.attributes
-  end
-
-  def test_scoped_count_include
-    # with the include, will retrieve only developers for the given project
-    Developer.send(:with_scope, :find => { :include => :projects }) do
-      assert_equal 1, Developer.count(:conditions => { 'projects.id' => 2 })
-    end
-  end
-
-  def test_scope_for_create_only_uses_equal
-    table = VerySpecialComment.arel_table
-    relation = VerySpecialComment.scoped
-    relation.where_values << table[:id].not_eq(1)
-    assert_equal({:type => "VerySpecialComment"}, relation.send(:scope_for_create))
-  end
-
-  def test_scoped_create
-    new_comment = nil
-
-    VerySpecialComment.send(:with_scope, :create => { :post_id => 1 }) do
-      assert_equal({:post_id => 1, :type => 'VerySpecialComment' }, VerySpecialComment.scoped.send(:scope_for_create))
-      new_comment = VerySpecialComment.create :body => "Wonderful world"
-    end
-
-    assert Post.find(1).comments.include?(new_comment)
-  end
-
-  def test_scoped_create_with_join_and_merge
-    Comment.where(:body => "but Who's Buying?").joins(:post).merge(Post.where(:body => 'Peace Sells...')).with_scope do
-      assert_equal({:body => "but Who's Buying?"}, Comment.scoped.scope_for_create)
-    end
-  end
-
-  def test_immutable_scope
-    options = { :conditions => "name = 'David'" }
-    Developer.send(:with_scope, :find => options) do
-      assert_equal %w(David), Developer.all.map(&:name)
-      options[:conditions] = "name != 'David'"
-      assert_equal %w(David), Developer.all.map(&:name)
-    end
-
-    scope = { :find => { :conditions => "name = 'David'" }}
-    Developer.send(:with_scope, scope) do
-      assert_equal %w(David), Developer.all.map(&:name)
-      scope[:find][:conditions] = "name != 'David'"
-      assert_equal %w(David), Developer.all.map(&:name)
-    end
-  end
-
-  def test_scoped_with_duck_typing
-    scoping = Struct.new(:current_scope).new(:find => { :conditions => ["name = ?", 'David'] })
-    Developer.send(:with_scope, scoping) do
-       assert_equal %w(David), Developer.all.map(&:name)
-    end
-  end
-
-  def test_ensure_that_method_scoping_is_correctly_restored
-    begin
-      Developer.send(:with_scope, :find => { :conditions => "name = 'Jamis'" }) do
-        raise "an exception"
-      end
-    rescue
-    end
-
-    assert !Developer.scoped.where_values.include?("name = 'Jamis'")
-  end
-end
-
-class NestedScopingTest < ActiveRecord::TestCase
-  fixtures :authors, :developers, :projects, :comments, :posts
-
-  def test_merge_options
-    Developer.send(:with_scope, :find => { :conditions => 'salary = 80000' }) do
-      Developer.send(:with_scope, :find => { :limit => 10 }) do
-        devs = Developer.scoped
-        assert_match '(salary = 80000)', devs.to_sql
-        assert_equal 10, devs.taken
-      end
-    end
-  end
-
-  def test_merge_inner_scope_has_priority
-    Developer.send(:with_scope, :find => { :limit => 5 }) do
-      Developer.send(:with_scope, :find => { :limit => 10 }) do
-        assert_equal 10, Developer.scoped.taken
-      end
-    end
-  end
-
-  def test_replace_options
-    Developer.send(:with_scope, :find => { :conditions => {:name => 'David'} }) do
-      Developer.send(:with_exclusive_scope, :find => { :conditions => {:name => 'Jamis'} }) do
-        assert_equal 'Jamis', Developer.scoped.send(:scope_for_create)[:name]
-      end
-
-      assert_equal 'David', Developer.scoped.send(:scope_for_create)[:name]
-    end
-  end
-
-  def test_with_exclusive_scope_with_relation
-    assert_raise(ArgumentError) do
-      Developer.all_johns
-    end
-  end
-
-  def test_append_conditions
-    Developer.send(:with_scope, :find => { :conditions => "name = 'David'" }) do
-      Developer.send(:with_scope, :find => { :conditions => 'salary = 80000' }) do
-        devs = Developer.scoped
-        assert_match "(name = 'David') AND (salary = 80000)", devs.to_sql
-        assert_equal(1, Developer.count)
-      end
-      Developer.send(:with_scope, :find => { :conditions => "name = 'Maiha'" }) do
-        assert_equal(0, Developer.count)
-      end
-    end
-  end
-
-  def test_merge_and_append_options
-    Developer.send(:with_scope, :find => { :conditions => 'salary = 80000', :limit => 10 }) do
-      Developer.send(:with_scope, :find => { :conditions => "name = 'David'" }) do
-        devs = Developer.scoped
-        assert_match "(salary = 80000) AND (name = 'David')", devs.to_sql
-        assert_equal 10, devs.taken
-      end
-    end
-  end
-
-  def test_nested_scoped_find
-    Developer.send(:with_scope, :find => { :conditions => "name = 'Jamis'" }) do
-      Developer.send(:with_exclusive_scope, :find => { :conditions => "name = 'David'" }) do
-        assert_nothing_raised { Developer.find(1) }
-        assert_equal('David', Developer.find(:first).name)
-      end
-      assert_equal('Jamis', Developer.find(:first).name)
-    end
-  end
-
-  def test_nested_scoped_find_include
-    Developer.send(:with_scope, :find => { :include => :projects }) do
-      Developer.send(:with_scope, :find => { :conditions => { 'projects.id' => 2 } }) do
-        assert_nothing_raised { Developer.find(1) }
-        assert_equal('David', Developer.find(:first).name)
-      end
-    end
-  end
-
-  def test_nested_scoped_find_merged_include
-    # :include's remain unique and don't "double up" when merging
-    Developer.send(:with_scope, :find => { :include => :projects, :conditions => { 'projects.id' => 2 } }) do
-      Developer.send(:with_scope, :find => { :include => :projects }) do
-        assert_equal 1, Developer.scoped.includes_values.uniq.length
-        assert_equal 'David', Developer.find(:first).name
-      end
-    end
-
-    # the nested scope doesn't remove the first :include
-    Developer.send(:with_scope, :find => { :include => :projects, :conditions => { 'projects.id' => 2 } }) do
-      Developer.send(:with_scope, :find => { :include => [] }) do
-        assert_equal 1, Developer.scoped.includes_values.uniq.length
-        assert_equal('David', Developer.find(:first).name)
-      end
-    end
-
-    # mixing array and symbol include's will merge correctly
-    Developer.send(:with_scope, :find => { :include => [:projects], :conditions => { 'projects.id' => 2 } }) do
-      Developer.send(:with_scope, :find => { :include => :projects }) do
-        assert_equal 1, Developer.scoped.includes_values.uniq.length
-        assert_equal('David', Developer.find(:first).name)
-      end
-    end
-  end
-
-  def test_nested_scoped_find_replace_include
-    Developer.send(:with_scope, :find => { :include => :projects }) do
-      Developer.send(:with_exclusive_scope, :find => { :include => [] }) do
-        assert_equal 0, Developer.scoped.includes_values.length
-      end
-    end
-  end
-
-  def test_three_level_nested_exclusive_scoped_find
-    Developer.send(:with_scope, :find => { :conditions => "name = 'Jamis'" }) do
-      assert_equal('Jamis', Developer.find(:first).name)
-
-      Developer.send(:with_exclusive_scope, :find => { :conditions => "name = 'David'" }) do
-        assert_equal('David', Developer.find(:first).name)
-
-        Developer.send(:with_exclusive_scope, :find => { :conditions => "name = 'Maiha'" }) do
-          assert_equal(nil, Developer.find(:first))
-        end
-
-        # ensure that scoping is restored
-        assert_equal('David', Developer.find(:first).name)
-      end
-
-      # ensure that scoping is restored
-      assert_equal('Jamis', Developer.find(:first).name)
-    end
-  end
-
-  def test_merged_scoped_find
-    poor_jamis = developers(:poor_jamis)
-    Developer.send(:with_scope, :find => { :conditions => "salary < 100000" }) do
-      Developer.send(:with_scope, :find => { :offset => 1, :order => 'id asc' }) do
-        # Oracle adapter does not generated space after asc therefore trailing space removed from regex
-        assert_sql(/ORDER BY\s+id asc/) do
-          assert_equal(poor_jamis, Developer.find(:first, :order => 'id asc'))
-        end
-      end
-    end
-  end
-
-  def test_merged_scoped_find_sanitizes_conditions
-    Developer.send(:with_scope, :find => { :conditions => ["name = ?", 'David'] }) do
-      Developer.send(:with_scope, :find => { :conditions => ['salary = ?', 9000] }) do
-        assert_raise(ActiveRecord::RecordNotFound) { developers(:poor_jamis) }
-      end
-    end
-  end
-
-  def test_nested_scoped_find_combines_and_sanitizes_conditions
-    Developer.send(:with_scope, :find => { :conditions => ["name = ?", 'David'] }) do
-      Developer.send(:with_exclusive_scope, :find => { :conditions => ['salary = ?', 9000] }) do
-        assert_equal developers(:poor_jamis), Developer.find(:first)
-        assert_equal developers(:poor_jamis), Developer.find(:first, :conditions => ['name = ?', 'Jamis'])
-      end
-    end
-  end
-
-  def test_merged_scoped_find_combines_and_sanitizes_conditions
-    Developer.send(:with_scope, :find => { :conditions => ["name = ?", 'David'] }) do
-      Developer.send(:with_scope, :find => { :conditions => ['salary > ?', 9000] }) do
-        assert_equal %w(David), Developer.all.map(&:name)
-      end
-    end
-  end
-
-  def test_nested_scoped_create
-    comment = nil
-    Comment.send(:with_scope, :create => { :post_id => 1}) do
-      Comment.send(:with_scope, :create => { :post_id => 2}) do
-        assert_equal({:post_id => 2}, Comment.scoped.send(:scope_for_create))
-        comment = Comment.create :body => "Hey guys, nested scopes are broken. Please fix!"
-      end
-    end
-    assert_equal 2, comment.post_id
-  end
-
-  def test_nested_exclusive_scope_for_create
-    comment = nil
-
-    Comment.send(:with_scope, :create => { :body => "Hey guys, nested scopes are broken. Please fix!" }) do
-      Comment.send(:with_exclusive_scope, :create => { :post_id => 1 }) do
-        assert_equal({:post_id => 1}, Comment.scoped.send(:scope_for_create))
-        assert_blank Comment.new.body
-        comment = Comment.create :body => "Hey guys"
-      end
-    end
-    assert_equal 1, comment.post_id
-    assert_equal 'Hey guys', comment.body
-  end
-
-  def test_merged_scoped_find_on_blank_conditions
-    [nil, " ", [], {}].each do |blank|
-      Developer.send(:with_scope, :find => {:conditions => blank}) do
-        Developer.send(:with_scope, :find => {:conditions => blank}) do
-          assert_nothing_raised { Developer.find(:first) }
-        end
-      end
-    end
-  end
-
-  def test_merged_scoped_find_on_blank_bind_conditions
-    [ [""], ["",{}] ].each do |blank|
-      Developer.send(:with_scope, :find => {:conditions => blank}) do
-        Developer.send(:with_scope, :find => {:conditions => blank}) do
-          assert_nothing_raised { Developer.find(:first) }
-        end
-      end
-    end
-  end
-
-  def test_immutable_nested_scope
-    options1 = { :conditions => "name = 'Jamis'" }
-    options2 = { :conditions => "name = 'David'" }
-    Developer.send(:with_scope, :find => options1) do
-      Developer.send(:with_exclusive_scope, :find => options2) do
-        assert_equal %w(David), Developer.all.map(&:name)
-        options1[:conditions] = options2[:conditions] = nil
-        assert_equal %w(David), Developer.all.map(&:name)
-      end
-    end
-  end
-
-  def test_immutable_merged_scope
-    options1 = { :conditions => "name = 'Jamis'" }
-    options2 = { :conditions => "salary > 10000" }
-    Developer.send(:with_scope, :find => options1) do
-      Developer.send(:with_scope, :find => options2) do
-        assert_equal %w(Jamis), Developer.all.map(&:name)
-        options1[:conditions] = options2[:conditions] = nil
-        assert_equal %w(Jamis), Developer.all.map(&:name)
-      end
-    end
-  end
-
-  def test_ensure_that_method_scoping_is_correctly_restored
-    Developer.send(:with_scope, :find => { :conditions => "name = 'David'" }) do
-      begin
-        Developer.send(:with_scope, :find => { :conditions => "name = 'Maiha'" }) do
-          raise "an exception"
-        end
-      rescue
-      end
-
-      assert Developer.scoped.where_values.include?("name = 'David'")
-      assert !Developer.scoped.where_values.include?("name = 'Maiha'")
-    end
-  end
-
-  def test_nested_scoped_find_merges_old_style_joins
-    scoped_authors = Author.send(:with_scope, :find => { :joins => 'INNER JOIN posts ON authors.id = posts.author_id' }) do
-      Author.send(:with_scope, :find => { :joins => 'INNER JOIN comments ON posts.id = comments.post_id' }) do
-        Author.find(:all, :select => 'DISTINCT authors.*', :conditions => 'comments.id = 1')
-      end
-    end
-    assert scoped_authors.include?(authors(:david))
-    assert !scoped_authors.include?(authors(:mary))
-    assert_equal 1, scoped_authors.size
-    assert_equal authors(:david).attributes, scoped_authors.first.attributes
-  end
-
-  def test_nested_scoped_find_merges_new_style_joins
-    scoped_authors = Author.send(:with_scope, :find => { :joins => :posts }) do
-      Author.send(:with_scope, :find => { :joins => :comments }) do
-        Author.find(:all, :select => 'DISTINCT authors.*', :conditions => 'comments.id = 1')
-      end
-    end
-    assert scoped_authors.include?(authors(:david))
-    assert !scoped_authors.include?(authors(:mary))
-    assert_equal 1, scoped_authors.size
-    assert_equal authors(:david).attributes, scoped_authors.first.attributes
-  end
-
-  def test_nested_scoped_find_merges_new_and_old_style_joins
-    scoped_authors = Author.send(:with_scope, :find => { :joins => :posts }) do
-      Author.send(:with_scope, :find => { :joins => 'INNER JOIN comments ON posts.id = comments.post_id' }) do
-        Author.find(:all, :select => 'DISTINCT authors.*', :joins => '', :conditions => 'comments.id = 1')
-      end
-    end
-    assert scoped_authors.include?(authors(:david))
-    assert !scoped_authors.include?(authors(:mary))
-    assert_equal 1, scoped_authors.size
-    assert_equal authors(:david).attributes, scoped_authors.first.attributes
-  end
-end
diff --git a/activerecord/test/cases/readonly_test.rb b/activerecord/test/cases/readonly_test.rb
index e21109baae..b72b72ecf2 100644
--- a/activerecord/test/cases/readonly_test.rb
+++ b/activerecord/test/cases/readonly_test.rb
@@ -70,13 +70,13 @@ class ReadOnlyTest < ActiveRecord::TestCase
   end
 
   def test_readonly_scoping
-    Post.send(:with_scope, :find => { :conditions => '1=1' }) do
+    Post.where('1=1').scoped do
       assert !Post.find(1).readonly?
       assert Post.readonly(true).find(1).readonly?
       assert !Post.readonly(false).find(1).readonly?
     end
 
-    Post.send(:with_scope, :find => { :joins => '   ' }) do
+    Post.joins('   ').scoped do
       assert !Post.find(1).readonly?
       assert Post.readonly.find(1).readonly?
       assert !Post.readonly(false).find(1).readonly?
@@ -85,14 +85,14 @@ class ReadOnlyTest < ActiveRecord::TestCase
     # Oracle barfs on this because the join includes unqualified and
     # conflicting column names
     unless current_adapter?(:OracleAdapter)
-      Post.send(:with_scope, :find => { :joins => ', developers' }) do
+      Post.joins(', developers').scoped do
         assert Post.find(1).readonly?
         assert Post.readonly.find(1).readonly?
         assert !Post.readonly(false).find(1).readonly?
       end
     end
 
-    Post.send(:with_scope, :find => { :readonly => true }) do
+    Post.readonly(true).scoped do
       assert Post.find(1).readonly?
       assert Post.readonly.find(1).readonly?
       assert !Post.readonly(false).find(1).readonly?
diff --git a/activerecord/test/cases/relation_scoping_test.rb b/activerecord/test/cases/relation_scoping_test.rb
index edf38cb7a3..7216282892 100644
--- a/activerecord/test/cases/relation_scoping_test.rb
+++ b/activerecord/test/cases/relation_scoping_test.rb
@@ -395,20 +395,6 @@ class DefaultScopingTest < ActiveRecord::TestCase
     assert_equal 50000,   wheres[:salary]
   end
 
-  def test_method_scope
-    expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.salary }
-    received = DeveloperOrderedBySalary.all_ordered_by_name.collect { |dev| dev.salary }
-    assert_equal expected, received
-  end
-
-  def test_nested_scope
-    expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.salary }
-    received = DeveloperOrderedBySalary.send(:with_scope, :find => { :order => 'name DESC'}) do
-      DeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
-    end
-    assert_equal expected, received
-  end
-
   def test_scope_overwrites_default
     expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.name }
     received = DeveloperOrderedBySalary.by_name.find(:all).collect { |dev| dev.name }
@@ -427,14 +413,6 @@ class DefaultScopingTest < ActiveRecord::TestCase
     assert_equal expected, received
   end
 
-  def test_nested_exclusive_scope
-    expected = Developer.find(:all, :limit => 100).collect { |dev| dev.salary }
-    received = DeveloperOrderedBySalary.send(:with_exclusive_scope, :find => { :limit => 100 }) do
-      DeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
-    end
-    assert_equal expected, received
-  end
-
   def test_order_in_default_scope_should_prevail
     expected = Developer.find(:all, :order => 'salary desc').collect { |dev| dev.salary }
     received = DeveloperOrderedBySalary.find(:all, :order => 'salary').collect { |dev| dev.salary }
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 5e938968a3..3fe3122fa1 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -330,7 +330,6 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_respond_to_class_methods_and_scopes
-    assert DeveloperOrderedBySalary.scoped.respond_to?(:all_ordered_by_name)
     assert Topic.scoped.respond_to?(:by_lifo)
   end
 
diff --git a/activerecord/test/cases/validations/uniqueness_validation_test.rb b/activerecord/test/cases/validations/uniqueness_validation_test.rb
index ec09479c95..2b1f34a2d0 100644
--- a/activerecord/test/cases/validations/uniqueness_validation_test.rb
+++ b/activerecord/test/cases/validations/uniqueness_validation_test.rb
@@ -261,10 +261,10 @@ class UniquenessValidationTest < ActiveRecord::TestCase
     assert i1.errors[:value].any?, "Should not be empty"
   end
 
-  def test_validates_uniqueness_inside_with_scope
+  def test_validates_uniqueness_inside_scoping
     Topic.validates_uniqueness_of(:title)
 
-    Topic.send(:with_scope, :find => { :conditions => { :author_name => "David" } }) do
+    Topic.where(:author_name => "David").scoping do
       t1 = Topic.new("title" => "I'm unique!", "author_name" => "Mary")
       assert t1.save
       t2 = Topic.new("title" => "I'm unique!", "author_name" => "David")
diff --git a/activerecord/test/cases/validations_test.rb b/activerecord/test/cases/validations_test.rb
index e575a98170..b11b330374 100644
--- a/activerecord/test/cases/validations_test.rb
+++ b/activerecord/test/cases/validations_test.rb
@@ -93,30 +93,6 @@ class ValidationsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_scoped_create_without_attributes
-    WrongReply.send(:with_scope, :create => {}) do
-      assert_raise(ActiveRecord::RecordInvalid) { WrongReply.create! }
-    end
-  end
-
-  def test_create_with_exceptions_using_scope_for_protected_attributes
-    assert_nothing_raised do
-      ProtectedPerson.send(:with_scope,  :create => { :first_name => "Mary" } ) do
-        person = ProtectedPerson.create! :addon => "Addon"
-        assert_equal person.first_name, "Mary", "scope should ignore attr_protected"
-      end
-    end
-  end
-
-  def test_create_with_exceptions_using_scope_and_empty_attributes
-    assert_nothing_raised do
-      ProtectedPerson.send(:with_scope,  :create => { :first_name => "Mary" } ) do
-        person = ProtectedPerson.create!
-        assert_equal person.first_name, "Mary", "should be ok when no attributes are passed to create!"
-      end
-    end
-  end
-
   def test_create_without_validation
     reply = WrongReply.new
     assert !reply.save
diff --git a/activerecord/test/models/developer.rb b/activerecord/test/models/developer.rb
index 4cc4947e3b..e6a468feca 100644
--- a/activerecord/test/models/developer.rb
+++ b/activerecord/test/models/developer.rb
@@ -102,12 +102,6 @@ class DeveloperOrderedBySalary < ActiveRecord::Base
   default_scope { order('salary DESC') }
 
   scope :by_name, -> { order('name DESC') }
-
-  def self.all_ordered_by_name
-    with_scope(:find => { :order => 'name DESC' }) do
-      find(:all)
-    end
-  end
 end
 
 class DeveloperCalledDavid < ActiveRecord::Base
-- 
cgit v1.2.3


From 3c100cfe8ed5a875b0bbdc8fa4e8f2b0cbf78676 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Wed, 25 Apr 2012 18:03:06 +0100
Subject: remove unused method

---
 activerecord/test/models/developer.rb | 6 ------
 1 file changed, 6 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/models/developer.rb b/activerecord/test/models/developer.rb
index e6a468feca..7133094f5d 100644
--- a/activerecord/test/models/developer.rb
+++ b/activerecord/test/models/developer.rb
@@ -57,12 +57,6 @@ class Developer < ActiveRecord::Base
   def log=(message)
     audit_logs.build :message => message
   end
-
-  def self.all_johns
-    self.with_exclusive_scope :find => where(:name => 'John') do
-      self.all
-    end
-  end
 end
 
 class AuditLog < ActiveRecord::Base
-- 
cgit v1.2.3


From 519001d94093f1907b1cca3f1f385a0a9d8fec9b Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Thu, 26 Apr 2012 10:20:57 +0100
Subject: default_scope with a hash is deprecated

---
 activerecord/test/cases/named_scope_test.rb | 10 ----------
 1 file changed, 10 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/named_scope_test.rb b/activerecord/test/cases/named_scope_test.rb
index 06d076943e..3a927aeddd 100644
--- a/activerecord/test/cases/named_scope_test.rb
+++ b/activerecord/test/cases/named_scope_test.rb
@@ -465,16 +465,6 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert_equal [posts(:welcome).title], klass.welcome_2.map(&:title)
   end
 
-  def test_eager_default_scope_hashes_are_not_deprecated
-    klass = Class.new(ActiveRecord::Base)
-    klass.table_name = 'posts'
-
-    assert_not_deprecated do
-      klass.send(:default_scope, :conditions => { :id => posts(:welcome).id })
-    end
-    assert_equal [posts(:welcome).title], klass.all.map(&:title)
-  end
-
   def test_eager_default_scope_relations_are_deprecated
     klass = Class.new(ActiveRecord::Base)
     klass.table_name = 'posts'
-- 
cgit v1.2.3


From e1a83690da3dc8e72638a71cf6751986338b4596 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Thu, 26 Apr 2012 12:03:25 +0100
Subject: remove deprecated scope stuff

---
 activerecord/test/cases/named_scope_test.rb | 19 -------------------
 activerecord/test/cases/relations_test.rb   | 13 -------------
 activerecord/test/models/car.rb             |  1 -
 activerecord/test/models/post.rb            |  9 +--------
 activerecord/test/models/topic.rb           | 14 +-------------
 5 files changed, 2 insertions(+), 54 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/named_scope_test.rb b/activerecord/test/cases/named_scope_test.rb
index 3a927aeddd..c17c2a126a 100644
--- a/activerecord/test/cases/named_scope_test.rb
+++ b/activerecord/test/cases/named_scope_test.rb
@@ -98,25 +98,6 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert_equal all_topics, Topic.written_before(nil)
   end
 
-  def test_scopes_with_joins
-    address = author_addresses(:david_address)
-    posts_with_authors_at_address = Post.find(
-      :all, :joins => 'JOIN authors ON authors.id = posts.author_id',
-      :conditions => [ 'authors.author_address_id = ?', address.id ]
-    )
-    assert_equal posts_with_authors_at_address, Post.with_authors_at_address(address)
-  end
-
-  def test_scopes_with_joins_respects_custom_select
-    address = author_addresses(:david_address)
-    posts_with_authors_at_address_titles = Post.find(:all,
-      :select => 'title',
-      :joins => 'JOIN authors ON authors.id = posts.author_id',
-      :conditions => [ 'authors.author_address_id = ?', address.id ]
-    )
-    assert_equal posts_with_authors_at_address_titles.map(&:title), Post.with_authors_at_address(address).find(:all, :select => 'title').map(&:title)
-  end
-
   def test_scope_with_object
     objects = Topic.with_object
     assert_operator objects.length, :>, 0
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 3fe3122fa1..1329a92e07 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -1059,10 +1059,6 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal Post.all, all_posts.all
   end
 
-  def test_extensions_with_except
-    assert_equal 2, Topic.named_extension.order(:author_name).except(:order).two
-  end
-
   def test_only
     relation = Post.where(:author_id => 1).order('id ASC').limit(1)
     assert_equal [posts(:welcome)], relation.all
@@ -1074,10 +1070,6 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal Post.limit(1).all.first, all_posts.first
   end
 
-  def test_extensions_with_only
-    assert_equal 2, Topic.named_extension.order(:author_name).only(:order).two
-  end
-
   def test_anonymous_extension
     relation = Post.where(:author_id => 1).order('id ASC').extending do
       def author
@@ -1106,9 +1098,7 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_default_scope_order_with_scope_order
     assert_equal 'zyke', CoolCar.order_using_new_style.limit(1).first.name
-    assert_equal 'zyke', CoolCar.order_using_old_style.limit(1).first.name
     assert_equal 'zyke', FastCar.order_using_new_style.limit(1).first.name
-    assert_equal 'zyke', FastCar.order_using_old_style.limit(1).first.name
   end
 
   def test_order_using_scoping
@@ -1125,10 +1115,7 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_unscoped_block_style
     assert_equal 'honda', CoolCar.unscoped { CoolCar.order_using_new_style.limit(1).first.name}
-    assert_equal 'honda', CoolCar.unscoped { CoolCar.order_using_old_style.limit(1).first.name}
-
     assert_equal 'honda', FastCar.unscoped { FastCar.order_using_new_style.limit(1).first.name}
-    assert_equal 'honda', FastCar.unscoped { FastCar.order_using_old_style.limit(1).first.name}
   end
 
   def test_intersection_with_array
diff --git a/activerecord/test/models/car.rb b/activerecord/test/models/car.rb
index 42ac81690f..b4bc0ad5fa 100644
--- a/activerecord/test/models/car.rb
+++ b/activerecord/test/models/car.rb
@@ -15,7 +15,6 @@ class Car < ActiveRecord::Base
   scope :incl_engines, -> { includes(:engines) }
 
   scope :order_using_new_style,  -> { order('name asc') }
-  scope :order_using_old_style,  -> { { :order => 'name asc' } }
 
 end
 
diff --git a/activerecord/test/models/post.rb b/activerecord/test/models/post.rb
index 5002ab9ff8..18810f2de8 100644
--- a/activerecord/test/models/post.rb
+++ b/activerecord/test/models/post.rb
@@ -9,11 +9,6 @@ class Post < ActiveRecord::Base
   scope :ranked_by_comments,      -> { order("comments_count DESC") }
 
   scope :limit_by, lambda {|l| limit(l) }
-  scope :with_authors_at_address, lambda { |address| {
-      :conditions => [ 'authors.author_address_id = ?', address.id ],
-      :joins => 'JOIN authors ON authors.id = posts.author_id'
-    }
-  }
 
   belongs_to :author do
     def greeting
@@ -32,9 +27,7 @@ class Post < ActiveRecord::Base
 
   scope :with_special_comments, -> { joins(:comments).where(:comments => {:type => 'SpecialComment'}) }
   scope :with_very_special_comments, -> { joins(:comments).where(:comments => {:type => 'VerySpecialComment'}) }
-  scope :with_post, lambda {|post_id|
-    { :joins => :comments, :conditions => {:comments => {:post_id => post_id} } }
-  }
+  scope :with_post, ->(post_id) { joins(:comments).where(:comments => { :post_id => post_id }) }
 
   has_many   :comments do
     def find_most_recent
diff --git a/activerecord/test/models/topic.rb b/activerecord/test/models/topic.rb
index 0625b8d296..ef9de9669c 100644
--- a/activerecord/test/models/topic.rb
+++ b/activerecord/test/models/topic.rb
@@ -2,7 +2,7 @@ class Topic < ActiveRecord::Base
   scope :base, -> { scoped }
   scope :written_before, lambda { |time|
     if time
-      { :conditions => ['written_on < ?', time] }
+      where 'written_on < ?', time
     end
   }
   scope :approved, -> { where(:approved => true) }
@@ -35,18 +35,6 @@ class Topic < ActiveRecord::Base
       2
     end
   end
-  module MultipleExtensionOne
-    def extension_one
-      1
-    end
-  end
-  module MultipleExtensionTwo
-    def extension_two
-      2
-    end
-  end
-  scope :named_extension, :extend => NamedExtension
-  scope :multiple_extensions, :extend => [MultipleExtensionTwo, MultipleExtensionOne]
 
   has_many :replies, :dependent => :destroy, :foreign_key => "parent_id"
   has_many :replies_with_primary_key, :class_name => "Reply", :dependent => :destroy, :primary_key => "title", :foreign_key => "parent_title"
-- 
cgit v1.2.3


From 1606bee64ade812af1ef5b231e41b44bebddd67f Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Thu, 26 Apr 2012 12:44:20 +0100
Subject: fix #scoped deprecations

---
 .../associations/eager_load_includes_full_sti_class_test.rb   |  4 ++--
 activerecord/test/cases/associations/join_model_test.rb       |  6 +++---
 activerecord/test/cases/finder_test.rb                        | 10 +++++-----
 activerecord/test/cases/named_scope_test.rb                   | 11 ++++++-----
 4 files changed, 16 insertions(+), 15 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb b/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb
index 3044a8c312..75a6295350 100644
--- a/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb
+++ b/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb
@@ -24,11 +24,11 @@ class EagerLoadIncludeFullStiClassNamesTest < ActiveRecord::TestCase
     old = ActiveRecord::Base.store_full_sti_class
 
     ActiveRecord::Base.store_full_sti_class = false
-    post = Namespaced::Post.find_by_title( 'Great stuff', :include => :tagging )
+    post = Namespaced::Post.includes(:tagging).find_by_title('Great stuff')
     assert_nil post.tagging
 
     ActiveRecord::Base.store_full_sti_class = true
-    post = Namespaced::Post.find_by_title( 'Great stuff', :include => :tagging )
+    post = Namespaced::Post.includes(:tagging).find_by_title('Great stuff')
     assert_instance_of Tagging, post.tagging
   ensure
     ActiveRecord::Base.store_full_sti_class = old
diff --git a/activerecord/test/cases/associations/join_model_test.rb b/activerecord/test/cases/associations/join_model_test.rb
index d5d1d3405d..d805ad6de7 100644
--- a/activerecord/test/cases/associations/join_model_test.rb
+++ b/activerecord/test/cases/associations/join_model_test.rb
@@ -246,7 +246,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_include_polymorphic_has_one
-    post    = Post.find_by_id(posts(:welcome).id, :include => :tagging)
+    post    = Post.includes(:tagging).find posts(:welcome).id
     tagging = taggings(:welcome_general)
     assert_no_queries do
       assert_equal tagging, post.tagging
@@ -254,7 +254,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_include_polymorphic_has_one_defined_in_abstract_parent
-    item    = Item.find_by_id(items(:dvd).id, :include => :tagging)
+    item    = Item.includes(:tagging).find items(:dvd).id
     tagging = taggings(:godfather)
     assert_no_queries do
       assert_equal tagging, item.tagging
@@ -403,7 +403,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_include_has_many_through_polymorphic_has_many
-    author            = Author.find_by_id(authors(:david).id, :include => :taggings)
+    author            = Author.includes(:taggings).find authors(:david).id
     expected_taggings = taggings(:welcome_general, :thinking_general)
     assert_no_queries do
       assert_equal expected_taggings, author.taggings.uniq.sort_by { |t| t.id }
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index 36ec459ca1..ed1a61e489 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -640,7 +640,7 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_by_one_attribute_with_conditions
-    assert_equal accounts(:rails_core_account), Account.find_by_credit_limit(50, :conditions => ['firm_id = ?', 6])
+    assert_equal accounts(:rails_core_account), Account.where('firm_id = ?', 6).find_by_credit_limit(50)
   end
 
   def test_find_by_one_attribute_that_is_an_aggregate
@@ -680,12 +680,12 @@ class FinderTest < ActiveRecord::TestCase
   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.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
+    a = Account.where('firm_id = ?', 6).find_by_credit_limit(50)
+    assert_equal a, Account.where('firm_id = ?', 6).find_by_credit_limit(50) # find_by_credit_limit has been cached
   end
 
   def test_find_by_one_attribute_with_several_options
-    assert_equal accounts(:unknown), Account.find_by_credit_limit(50, :order => 'id DESC', :conditions => ['id != ?', 3])
+    assert_equal accounts(:unknown), Account.order('id DESC').where('id != ?', 3).find_by_credit_limit(50)
   end
 
   def test_find_by_one_missing_attribute
@@ -719,7 +719,7 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_last_by_one_attribute_with_several_options
-    assert_equal accounts(:signals37), Account.find_last_by_credit_limit(50, :order => 'id DESC', :conditions => ['id != ?', 3])
+    assert_equal accounts(:signals37), Account.order('id DESC').where('id != ?', 3).find_last_by_credit_limit(50)
   end
 
   def test_find_last_by_one_missing_attribute
diff --git a/activerecord/test/cases/named_scope_test.rb b/activerecord/test/cases/named_scope_test.rb
index c17c2a126a..31e66c738e 100644
--- a/activerecord/test/cases/named_scope_test.rb
+++ b/activerecord/test/cases/named_scope_test.rb
@@ -140,9 +140,10 @@ class NamedScopeTest < ActiveRecord::TestCase
   end
 
   def test_active_records_have_scope_named__scoped__
-    assert !Topic.find(:all, scope = {:conditions => "content LIKE '%Have%'"}).empty?
+    scope = Topic.where("content LIKE '%Have%'")
+    assert !scope.empty?
 
-    assert_equal Topic.find(:all, scope), Topic.scoped(scope)
+    assert_equal scope, Topic.scoped(where: "content LIKE '%Have%'")
   end
 
   def test_first_and_last_should_support_find_options
@@ -235,9 +236,9 @@ class NamedScopeTest < ActiveRecord::TestCase
   end
 
   def test_many_should_return_false_if_none_or_one
-    topics = Topic.base.scoped(:conditions => {:id => 0})
+    topics = Topic.base.where(:id => 0)
     assert !topics.many?
-    topics = Topic.base.scoped(:conditions => {:id => 1})
+    topics = Topic.base.where(:id => 1)
     assert !topics.many?
   end
 
@@ -315,7 +316,7 @@ class NamedScopeTest < ActiveRecord::TestCase
   def test_chaining_with_duplicate_joins
     join = "INNER JOIN comments ON comments.post_id = posts.id"
     post = Post.find(1)
-    assert_equal post.comments.size, Post.scoped(:joins => join).scoped(:joins => join, :conditions => "posts.id = #{post.id}").size
+    assert_equal post.comments.size, Post.joins(join).joins(join).where("posts.id = #{post.id}").size
   end
 
   def test_chaining_should_use_latest_conditions_when_creating
-- 
cgit v1.2.3


From 2f0c8c52e66f1a2a3d1c00efc207f227124e96c2 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Thu, 26 Apr 2012 13:29:10 +0100
Subject: remove deprecate #update_all usage

---
 activerecord/test/cases/dirty_test.rb       | 4 ++--
 activerecord/test/cases/persistence_test.rb | 8 +-------
 2 files changed, 3 insertions(+), 9 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/dirty_test.rb b/activerecord/test/cases/dirty_test.rb
index 54e0b40b4f..2650040a80 100644
--- a/activerecord/test/cases/dirty_test.rb
+++ b/activerecord/test/cases/dirty_test.rb
@@ -288,7 +288,7 @@ class DirtyTest < ActiveRecord::TestCase
 
     with_partial_updates Pirate, false do
       assert_queries(2) { 2.times { pirate.save! } }
-      Pirate.update_all({ :updated_on => old_updated_on }, :id => pirate.id)
+      Pirate.where(id: pirate.id).update_all(:updated_on => old_updated_on)
     end
 
     with_partial_updates Pirate, true do
@@ -306,7 +306,7 @@ class DirtyTest < ActiveRecord::TestCase
 
     with_partial_updates Person, false do
       assert_queries(2) { 2.times { person.save! } }
-      Person.update_all({ :first_name => 'baz' }, :id => person.id)
+      Person.where(id: person.id).update_all(:first_name => 'baz')
     end
 
     with_partial_updates Person, true do
diff --git a/activerecord/test/cases/persistence_test.rb b/activerecord/test/cases/persistence_test.rb
index bb60aa0a66..15d14c7a8b 100644
--- a/activerecord/test/cases/persistence_test.rb
+++ b/activerecord/test/cases/persistence_test.rb
@@ -94,12 +94,6 @@ class PersistencesTest < ActiveRecord::TestCase
     assert_equal count, Pet.joins(:toys).where(where_args).delete_all
   end
 
-  def test_update_by_condition
-    Topic.update_all "content = 'bulk updated!'", ["approved = ?", true]
-    assert_equal "Have a nice day", Topic.find(1).content
-    assert_equal "bulk updated!", Topic.find(2).content
-  end
-
   def test_increment_attribute
     assert_equal 50, accounts(:signals37).credit_limit
     accounts(:signals37).increment! :credit_limit
@@ -338,7 +332,7 @@ class PersistencesTest < ActiveRecord::TestCase
   end
 
   def test_update_all_with_non_standard_table_name
-    assert_equal 1, WarehouseThing.update_all(['value = ?', 0], ['id = ?', 1])
+    assert_equal 1, WarehouseThing.where(id: 1).update_all(['value = ?', 0])
     assert_equal 0, WarehouseThing.find(1).value
   end
 
-- 
cgit v1.2.3


From f6ddb13113ac5cb4e75a7d041a1ff15a036fa0f3 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Thu, 26 Apr 2012 15:51:23 +0100
Subject: remove deprecated #find_in_batches calls

---
 .../cases/associations/has_many_associations_test.rb     |  2 +-
 activerecord/test/cases/batches_test.rb                  | 16 ++--------------
 2 files changed, 3 insertions(+), 15 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index 6a4f972356..af730202c4 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -465,7 +465,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     firm = companies(:first_firm)
 
     assert_queries(2) do
-      firm.clients.find_each(:batch_size => 1, :conditions => {:name => "Microsoft"}) do |c|
+      firm.clients.where(name: 'Microsoft').find_each(batch_size: 1) do |c|
         assert_equal firm.id, c.firm_id
         assert_equal "Microsoft", c.name
       end
diff --git a/activerecord/test/cases/batches_test.rb b/activerecord/test/cases/batches_test.rb
index 660098b9ad..cdd4b49042 100644
--- a/activerecord/test/cases/batches_test.rb
+++ b/activerecord/test/cases/batches_test.rb
@@ -27,30 +27,18 @@ class EachTest < ActiveRecord::TestCase
 
   def test_each_should_raise_if_select_is_set_without_id
     assert_raise(RuntimeError) do
-      Post.find_each(:select => :title, :batch_size => 1) { |post| post }
+      Post.select(:title).find_each(:batch_size => 1) { |post| post }
     end
   end
 
   def test_each_should_execute_if_id_is_in_select
     assert_queries(6) do
-      Post.find_each(:select => "id, title, type", :batch_size => 2) do |post|
+      Post.select("id, title, type").find_each(:batch_size => 2) do |post|
         assert_kind_of Post, post
       end
     end
   end
 
-  def test_each_should_raise_if_the_order_is_set
-    assert_raise(RuntimeError) do
-      Post.find_each(:order => "title") { |post| post }
-    end
-  end
-
-  def test_each_should_raise_if_the_limit_is_set
-    assert_raise(RuntimeError) do
-      Post.find_each(:limit => 1) { |post| post }
-    end
-  end
-
   def test_warn_if_limit_scope_is_set
     ActiveRecord::Base.logger.expects(:warn)
     Post.limit(1).find_each { |post| post }
-- 
cgit v1.2.3


From 759d302db851754a73ec4c74e951f8a5faf2bee1 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Thu, 26 Apr 2012 17:29:22 +0100
Subject: remove deprecate #calculate calls

---
 activerecord/test/cases/associations/eager_test.rb |   4 +-
 .../has_and_belongs_to_many_associations_test.rb   |   7 --
 .../associations/has_many_associations_test.rb     |  10 +-
 .../has_many_through_associations_test.rb          |   2 +-
 .../associations/inner_join_association_test.rb    |   6 +-
 .../test/cases/associations/join_model_test.rb     |   2 +-
 activerecord/test/cases/base_test.rb               |  14 +--
 activerecord/test/cases/calculations_test.rb       | 135 +++++++++------------
 activerecord/test/cases/deprecated_finder_test.rb  |  30 -----
 activerecord/test/cases/finder_test.rb             |   6 -
 activerecord/test/cases/named_scope_test.rb        |   2 +-
 11 files changed, 72 insertions(+), 146 deletions(-)
 delete mode 100644 activerecord/test/cases/deprecated_finder_test.rb

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index d700554af7..c3eda9431c 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -580,12 +580,12 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_count_eager_with_has_many_and_limit_and_high_offset
-    posts = Post.count(:all, :include => [ :author, :comments ], :limit => 2, :offset => 10, :conditions => { 'authors.name' => 'David' })
+    posts = Post.scoped(:includes => [ :author, :comments ], :limit => 2, :offset => 10, :where => { 'authors.name' => 'David' }).count(:all)
     assert_equal 0, posts
   end
 
   def test_eager_with_has_many_and_limit_with_no_results
-    posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :conditions => "posts.title = 'magic forest'")
+    posts = Post.scoped(:includes => [ :author, :comments ], :limit => 2, :where => "posts.title = 'magic forest'").find(:all)
     assert_equal 0, posts.size
   end
 
diff --git a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
index f5f5b96aa7..3c36761385 100644
--- a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
@@ -798,13 +798,6 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert Category.find(1).posts_with_authors_sorted_by_author_id.find_by_title('Welcome to the weblog')
   end
 
-  def test_counting_on_habtm_association_and_not_array
-    david = Developer.find(1)
-    # Extra parameter just to make sure we aren't falling back to
-    # Array#count in Ruby >=1.8.7, which would raise an ArgumentError
-    assert_nothing_raised { david.projects.count(:all, :conditions => '1=1') }
-  end
-
   def test_count
     david = Developer.find(1)
     assert_equal 2, david.projects.count
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index af730202c4..321dae4143 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -249,16 +249,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal 2, Firm.find(:first, :order => "id").plain_clients.count
   end
 
-  def test_counting_with_empty_hash_conditions
-    assert_equal 2, Firm.find(:first, :order => "id").plain_clients.count(:conditions => {})
-  end
-
-  def test_counting_with_single_conditions
-    assert_equal 1, Firm.find(:first, :order => "id").plain_clients.count(:conditions => ['name=?', "Microsoft"])
-  end
-
   def test_counting_with_single_hash
-    assert_equal 1, Firm.find(:first, :order => "id").plain_clients.count(:conditions => {:name => "Microsoft"})
+    assert_equal 1, Firm.find(:first, :order => "id").plain_clients.where(:name => "Microsoft").count
   end
 
   def test_counting_with_column_name_and_hash
diff --git a/activerecord/test/cases/associations/has_many_through_associations_test.rb b/activerecord/test/cases/associations/has_many_through_associations_test.rb
index e9b930204f..641194877b 100644
--- a/activerecord/test/cases/associations/has_many_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_through_associations_test.rb
@@ -533,7 +533,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_count_with_include_should_alias_join_table
-    assert_equal 2, people(:michael).posts.count(:include => :readers)
+    assert_equal 2, people(:michael).posts.includes(:readers).count
   end
 
   def test_inner_join_with_quoted_table_name
diff --git a/activerecord/test/cases/associations/inner_join_association_test.rb b/activerecord/test/cases/associations/inner_join_association_test.rb
index 68a1e62328..1d61d5c474 100644
--- a/activerecord/test/cases/associations/inner_join_association_test.rb
+++ b/activerecord/test/cases/associations/inner_join_association_test.rb
@@ -72,17 +72,17 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
 
   def test_count_honors_implicit_inner_joins
     real_count = Author.scoped.to_a.sum{|a| a.posts.count }
-    assert_equal real_count, Author.count(:joins => :posts), "plain inner join count should match the number of referenced posts records"
+    assert_equal real_count, Author.joins(:posts).count, "plain inner join count should match the number of referenced posts records"
   end
 
   def test_calculate_honors_implicit_inner_joins
     real_count = Author.scoped.to_a.sum{|a| a.posts.count }
-    assert_equal real_count, Author.calculate(:count, 'authors.id', :joins => :posts), "plain inner join count should match the number of referenced posts records"
+    assert_equal real_count, Author.joins(:posts).calculate(:count, 'authors.id'), "plain inner join count should match the number of referenced posts records"
   end
 
   def test_calculate_honors_implicit_inner_joins_and_distinct_and_conditions
     real_count = Author.scoped.to_a.select {|a| a.posts.any? {|p| p.title =~ /^Welcome/} }.length
-    authors_with_welcoming_post_titles = Author.calculate(:count, 'authors.id', :joins => :posts, :distinct => true, :conditions => "posts.title like 'Welcome%'")
+    authors_with_welcoming_post_titles = Author.scoped(:joins => :posts, :where => "posts.title like 'Welcome%'").calculate(:count, 'authors.id', :distinct => true)
     assert_equal real_count, authors_with_welcoming_post_titles, "inner join and conditions should have only returned authors posting titles starting with 'Welcome'"
   end
 
diff --git a/activerecord/test/cases/associations/join_model_test.rb b/activerecord/test/cases/associations/join_model_test.rb
index d805ad6de7..95f03fc95a 100644
--- a/activerecord/test/cases/associations/join_model_test.rb
+++ b/activerecord/test/cases/associations/join_model_test.rb
@@ -46,7 +46,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert !authors(:mary).unique_categorized_posts.loaded?
     assert_queries(1) { assert_equal 1, author.unique_categorized_posts.count }
     assert_queries(1) { assert_equal 1, author.unique_categorized_posts.count(:title) }
-    assert_queries(1) { assert_equal 0, author.unique_categorized_posts.count(:title, :conditions => "title is NULL") }
+    assert_queries(1) { assert_equal 0, author.unique_categorized_posts.where(title: nil).count(:title) }
     assert !authors(:mary).unique_categorized_posts.loaded?
   end
 
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index eadc7e1701..127d5d0cae 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -1568,22 +1568,19 @@ class BasicsTest < ActiveRecord::TestCase
   def test_count_with_join
     res = Post.count_by_sql "SELECT COUNT(*) FROM posts LEFT JOIN comments ON posts.id=comments.post_id WHERE posts.#{QUOTED_TYPE} = 'Post'"
 
-    res2 = Post.count(:conditions => "posts.#{QUOTED_TYPE} = 'Post'", :joins => "LEFT JOIN comments ON posts.id=comments.post_id")
+    res2 = Post.where("posts.#{QUOTED_TYPE} = 'Post'").joins("LEFT JOIN comments ON posts.id=comments.post_id").count
     assert_equal res, res2
 
     res3 = nil
     assert_nothing_raised do
-      res3 = Post.count(:conditions => "posts.#{QUOTED_TYPE} = 'Post'",
-                        :joins => "LEFT JOIN comments ON posts.id=comments.post_id")
+      res3 = Post.where("posts.#{QUOTED_TYPE} = 'Post'").joins("LEFT JOIN comments ON posts.id=comments.post_id").count
     end
     assert_equal res, res3
 
     res4 = Post.count_by_sql "SELECT COUNT(p.id) FROM posts p, comments co WHERE p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id"
     res5 = nil
     assert_nothing_raised do
-      res5 = Post.count(:conditions => "p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id",
-                        :joins => "p, comments co",
-                        :select => "p.id")
+      res5 = Post.where("p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id").joins("p, comments co").select("p.id").count
     end
 
     assert_equal res4, res5
@@ -1591,10 +1588,7 @@ class BasicsTest < ActiveRecord::TestCase
     res6 = Post.count_by_sql "SELECT COUNT(DISTINCT p.id) FROM posts p, comments co WHERE p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id"
     res7 = nil
     assert_nothing_raised do
-      res7 = Post.count(:conditions => "p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id",
-                        :joins => "p, comments co",
-                        :select => "p.id",
-                        :distinct => true)
+      res7 = Post.where("p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id").joins("p, comments co").select("p.id").count(distinct: true)
     end
     assert_equal res6, res7
   end
diff --git a/activerecord/test/cases/calculations_test.rb b/activerecord/test/cases/calculations_test.rb
index af1e689eff..2e566ff873 100644
--- a/activerecord/test/cases/calculations_test.rb
+++ b/activerecord/test/cases/calculations_test.rb
@@ -57,12 +57,12 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_group_by_field
-    c = Account.sum(:credit_limit, :group => :firm_id)
+    c = Account.group(:firm_id).sum(:credit_limit)
     [1,6,2].each { |firm_id| assert c.keys.include?(firm_id) }
   end
 
   def test_should_group_by_multiple_fields
-    c = Account.count(:all, :group => ['firm_id', :credit_limit])
+    c = Account.group('firm_id', :credit_limit).count(:all)
     [ [nil, 50], [1, 50], [6, 50], [6, 55], [9, 53], [2, 60] ].each { |firm_and_limit| assert c.keys.include?(firm_and_limit) }
   end
 
@@ -75,32 +75,32 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_group_by_summed_field
-    c = Account.sum(:credit_limit, :group => :firm_id)
+    c = Account.group(:firm_id).sum(:credit_limit)
     assert_equal 50,   c[1]
     assert_equal 105,  c[6]
     assert_equal 60,   c[2]
   end
 
   def test_should_order_by_grouped_field
-    c = Account.sum(:credit_limit, :group => :firm_id, :order => "firm_id")
+    c = Account.scoped(:group => :firm_id, :order => "firm_id").sum(:credit_limit)
     assert_equal [1, 2, 6, 9], c.keys.compact
   end
 
   def test_should_order_by_calculation
-    c = Account.sum(:credit_limit, :group => :firm_id, :order => "sum_credit_limit desc, firm_id")
+    c = Account.scoped(:group => :firm_id, :order => "sum_credit_limit desc, firm_id").sum(:credit_limit)
     assert_equal [105, 60, 53, 50, 50], c.keys.collect { |k| c[k] }
     assert_equal [6, 2, 9, 1], c.keys.compact
   end
 
   def test_should_limit_calculation
-    c = Account.sum(:credit_limit, :conditions => "firm_id IS NOT NULL",
-                    :group => :firm_id, :order => "firm_id", :limit => 2)
+    c = Account.scoped(:where => "firm_id IS NOT NULL",
+                       :group => :firm_id, :order => "firm_id", :limit => 2).sum(:credit_limit)
     assert_equal [1, 2], c.keys.compact
   end
 
   def test_should_limit_calculation_with_offset
-    c = Account.sum(:credit_limit, :conditions => "firm_id IS NOT NULL",
-                    :group => :firm_id, :order => "firm_id", :limit => 2, :offset => 1)
+    c = Account.scoped(:where => "firm_id IS NOT NULL", :group => :firm_id,
+                       :order => "firm_id", :limit => 2, :offset => 1).sum(:credit_limit)
     assert_equal [2, 6], c.keys.compact
   end
 
@@ -150,16 +150,8 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_group_by_summed_field_having_condition
-    c = Account.sum(:credit_limit, :group => :firm_id,
-                                   :having => 'sum(credit_limit) > 50')
-    assert_nil        c[1]
-    assert_equal 105, c[6]
-    assert_equal 60,  c[2]
-  end
-
-  def test_should_group_by_summed_field_having_sanitized_condition
-    c = Account.sum(:credit_limit, :group => :firm_id,
-                                   :having => ['sum(credit_limit) > ?', 50])
+    c = Account.scoped(:group => :firm_id,
+                       :having => 'sum(credit_limit) > 50').sum(:credit_limit)
     assert_nil        c[1]
     assert_equal 105, c[6]
     assert_equal 60,  c[2]
@@ -173,19 +165,19 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_group_by_summed_association
-    c = Account.sum(:credit_limit, :group => :firm)
+    c = Account.group(:firm).sum(:credit_limit)
     assert_equal 50,   c[companies(:first_firm)]
     assert_equal 105,  c[companies(:rails_core)]
     assert_equal 60,   c[companies(:first_client)]
   end
 
   def test_should_sum_field_with_conditions
-    assert_equal 105, Account.sum(:credit_limit, :conditions => 'firm_id = 6')
+    assert_equal 105, Account.where('firm_id = 6').sum(:credit_limit)
   end
 
   def test_should_return_zero_if_sum_conditions_return_nothing
-    assert_equal 0, Account.sum(:credit_limit, :conditions => '1 = 2')
-    assert_equal 0, companies(:rails_core).companies.sum(:id, :conditions => '1 = 2')
+    assert_equal 0, Account.where('1 = 2').sum(:credit_limit)
+    assert_equal 0, companies(:rails_core).companies.where('1 = 2').sum(:id)
   end
 
   def test_sum_should_return_valid_values_for_decimals
@@ -194,24 +186,24 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_group_by_summed_field_with_conditions
-    c = Account.sum(:credit_limit, :conditions => 'firm_id > 1',
-                                   :group => :firm_id)
+    c = Account.scoped(:where => 'firm_id > 1',
+                       :group => :firm_id).sum(:credit_limit)
     assert_nil        c[1]
     assert_equal 105, c[6]
     assert_equal 60,  c[2]
   end
 
   def test_should_group_by_summed_field_with_conditions_and_having
-    c = Account.sum(:credit_limit, :conditions => 'firm_id > 1',
-                                   :group => :firm_id,
-                                   :having => 'sum(credit_limit) > 60')
+    c = Account.scoped(:where => 'firm_id > 1',
+                       :group => :firm_id,
+                       :having => 'sum(credit_limit) > 60').sum(:credit_limit)
     assert_nil        c[1]
     assert_equal 105, c[6]
     assert_nil        c[2]
   end
 
   def test_should_group_by_fields_with_table_alias
-    c = Account.sum(:credit_limit, :group => 'accounts.firm_id')
+    c = Account.group('accounts.firm_id').sum(:credit_limit)
     assert_equal 50,  c[1]
     assert_equal 105, c[6]
     assert_equal 60,  c[2]
@@ -223,14 +215,14 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_calculate_grouped_with_invalid_field
-    c = Account.count(:all, :group => 'accounts.firm_id')
+    c = Account.group('accounts.firm_id').count(:all)
     assert_equal 1, c[1]
     assert_equal 2, c[6]
     assert_equal 1, c[2]
   end
 
   def test_should_calculate_grouped_association_with_invalid_field
-    c = Account.count(:all, :group => :firm)
+    c = Account.group(:firm).count(:all)
     assert_equal 1, c[companies(:first_firm)]
     assert_equal 2, c[companies(:rails_core)]
     assert_equal 1, c[companies(:first_client)]
@@ -249,7 +241,7 @@ class CalculationsTest < ActiveRecord::TestCase
     column.expects(:type_cast).with("ABC").returns("ABC")
     Account.expects(:columns).at_least_once.returns([column])
 
-    c = Account.count(:all, :group => :firm)
+    c = Account.group(:firm).count(:all)
     first_key = c.keys.first
     assert_equal Firm, first_key.class
     assert_equal 1, c[first_key]
@@ -257,22 +249,14 @@ class CalculationsTest < ActiveRecord::TestCase
 
   def test_should_calculate_grouped_association_with_foreign_key_option
     Account.belongs_to :another_firm, :class_name => 'Firm', :foreign_key => 'firm_id'
-    c = Account.count(:all, :group => :another_firm)
+    c = Account.group(:another_firm).count(:all)
     assert_equal 1, c[companies(:first_firm)]
     assert_equal 2, c[companies(:rails_core)]
     assert_equal 1, c[companies(:first_client)]
   end
 
-  def test_should_not_modify_options_when_using_includes
-    options = {:conditions => 'companies.id > 1', :include => :firm}
-    options_copy = options.dup
-
-    Account.references(:companies).count(:all, options)
-    assert_equal options_copy, options
-  end
-
   def test_should_calculate_grouped_by_function
-    c = Company.count(:all, :group => "UPPER(#{QUOTED_TYPE})")
+    c = Company.group("UPPER(#{QUOTED_TYPE})").count(:all)
     assert_equal 2, c[nil]
     assert_equal 1, c['DEPENDENTFIRM']
     assert_equal 4, c['CLIENT']
@@ -280,7 +264,7 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_calculate_grouped_by_function_with_table_alias
-    c = Company.count(:all, :group => "UPPER(companies.#{QUOTED_TYPE})")
+    c = Company.group("UPPER(companies.#{QUOTED_TYPE})").count(:all)
     assert_equal 2, c[nil]
     assert_equal 1, c['DEPENDENTFIRM']
     assert_equal 4, c['CLIENT']
@@ -300,25 +284,24 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_sum_scoped_field_with_conditions
-    assert_equal 8,  companies(:rails_core).companies.sum(:id, :conditions => 'id > 7')
+    assert_equal 8,  companies(:rails_core).companies.where('id > 7').sum(:id)
   end
 
   def test_should_group_by_scoped_field
-    c = companies(:rails_core).companies.sum(:id, :group => :name)
+    c = companies(:rails_core).companies.group(:name).sum(:id)
     assert_equal 7, c['Leetsoft']
     assert_equal 8, c['Jadedpixel']
   end
 
   def test_should_group_by_summed_field_through_association_and_having
-    c = companies(:rails_core).companies.sum(:id, :group => :name,
-                                                  :having => 'sum(id) > 7')
+    c = companies(:rails_core).companies.group(:name).having('sum(id) > 7').sum(:id)
     assert_nil      c['Leetsoft']
     assert_equal 8, c['Jadedpixel']
   end
 
   def test_should_count_selected_field_with_include
-    assert_equal 6, Account.count(:distinct => true, :include => :firm)
-    assert_equal 4, Account.count(:distinct => true, :include => :firm, :select => :credit_limit)
+    assert_equal 6, Account.includes(:firm).count(:distinct => true)
+    assert_equal 4, Account.includes(:firm).select(:credit_limit).count(:distinct => true)
   end
 
   def test_should_not_perform_joined_include_by_default
@@ -342,11 +325,11 @@ class CalculationsTest < ActiveRecord::TestCase
     Account.last.update_column('credit_limit', 49)
     Account.first.update_column('credit_limit', 51)
 
-    assert_equal 1, Account.scoped(:select => "credit_limit").count(:conditions => ['credit_limit >= 50'])
+    assert_equal 1, Account.scoped(:select => "credit_limit").where('credit_limit >= 50').count
   end
 
   def test_should_count_manual_select_with_include
-    assert_equal 6, Account.count(:select => "DISTINCT accounts.id", :include => :firm)
+    assert_equal 6, Account.scoped(:select => "DISTINCT accounts.id", :includes => :firm).count
   end
 
   def test_count_with_column_parameter
@@ -354,16 +337,16 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_count_with_column_and_options_parameter
-    assert_equal 2, Account.count(:firm_id, :conditions => "credit_limit = 50 AND firm_id IS NOT NULL")
+    assert_equal 2, Account.where("credit_limit = 50 AND firm_id IS NOT NULL").count(:firm_id)
   end
 
   def test_should_count_field_in_joined_table
-    assert_equal 5, Account.count('companies.id', :joins => :firm)
-    assert_equal 4, Account.count('companies.id', :joins => :firm, :distinct => true)
+    assert_equal 5, Account.joins(:firm).count('companies.id')
+    assert_equal 4, Account.joins(:firm).count('companies.id', :distinct => true)
   end
 
   def test_should_count_field_in_joined_table_with_group_by
-    c = Account.count('companies.id', :group => 'accounts.firm_id', :joins => :firm)
+    c = Account.scoped(:group => 'accounts.firm_id', :joins => :firm).count('companies.id')
 
     [1,6,2,9].each { |firm_id| assert c.keys.include?(firm_id) }
   end
@@ -386,17 +369,17 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_count_with_from_option
-    assert_equal Company.count(:all), Company.count(:all, :from => 'companies')
-    assert_equal Account.count(:all, :conditions => "credit_limit = 50"),
-        Account.count(:all, :from => 'accounts', :conditions => "credit_limit = 50")
-    assert_equal Company.count(:type, :conditions => {:type => "Firm"}),
-        Company.count(:type, :conditions => {:type => "Firm"}, :from => 'companies')
+    assert_equal Company.count(:all), Company.from('companies').count(:all)
+    assert_equal Account.where("credit_limit = 50").count(:all),
+        Account.from('accounts').where("credit_limit = 50").count(:all)
+    assert_equal Company.where(:type => "Firm").count(:type),
+        Company.where(:type => "Firm").from('companies').count(:type)
   end
 
   def test_sum_with_from_option
-    assert_equal Account.sum(:credit_limit), Account.sum(:credit_limit, :from => 'accounts')
-    assert_equal Account.sum(:credit_limit, :conditions => "credit_limit > 50"),
-        Account.sum(:credit_limit, :from => 'accounts', :conditions => "credit_limit > 50")
+    assert_equal Account.sum(:credit_limit), Account.from('accounts').sum(:credit_limit)
+    assert_equal Account.where("credit_limit > 50").sum(:credit_limit),
+        Account.where("credit_limit > 50").from('accounts').sum(:credit_limit)
   end
 
   def test_sum_array_compatibility
@@ -404,33 +387,33 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_average_with_from_option
-    assert_equal Account.average(:credit_limit), Account.average(:credit_limit, :from => 'accounts')
-    assert_equal Account.average(:credit_limit, :conditions => "credit_limit > 50"),
-        Account.average(:credit_limit, :from => 'accounts', :conditions => "credit_limit > 50")
+    assert_equal Account.average(:credit_limit), Account.from('accounts').average(:credit_limit)
+    assert_equal Account.where("credit_limit > 50").average(:credit_limit),
+        Account.where("credit_limit > 50").from('accounts').average(:credit_limit)
   end
 
   def test_minimum_with_from_option
-    assert_equal Account.minimum(:credit_limit), Account.minimum(:credit_limit, :from => 'accounts')
-    assert_equal Account.minimum(:credit_limit, :conditions => "credit_limit > 50"),
-        Account.minimum(:credit_limit, :from => 'accounts', :conditions => "credit_limit > 50")
+    assert_equal Account.minimum(:credit_limit), Account.from('accounts').minimum(:credit_limit)
+    assert_equal Account.where("credit_limit > 50").minimum(:credit_limit),
+        Account.where("credit_limit > 50").from('accounts').minimum(:credit_limit)
   end
 
   def test_maximum_with_from_option
-    assert_equal Account.maximum(:credit_limit), Account.maximum(:credit_limit, :from => 'accounts')
-    assert_equal Account.maximum(:credit_limit, :conditions => "credit_limit > 50"),
-        Account.maximum(:credit_limit, :from => 'accounts', :conditions => "credit_limit > 50")
+    assert_equal Account.maximum(:credit_limit), Account.from('accounts').maximum(:credit_limit)
+    assert_equal Account.where("credit_limit > 50").maximum(:credit_limit),
+        Account.where("credit_limit > 50").from('accounts').maximum(:credit_limit)
   end
 
   def test_from_option_with_specified_index
     if Edge.connection.adapter_name == 'MySQL' or Edge.connection.adapter_name == 'Mysql2'
-      assert_equal Edge.count(:all), Edge.count(:all, :from => 'edges USE INDEX(unique_edge_index)')
-      assert_equal Edge.count(:all, :conditions => 'sink_id < 5'),
-          Edge.count(:all, :from => 'edges USE INDEX(unique_edge_index)', :conditions => 'sink_id < 5')
+      assert_equal Edge.count(:all), Edge.from('edges USE INDEX(unique_edge_index)').count(:all)
+      assert_equal Edge.where('sink_id < 5').count(:all),
+          Edge.from('edges USE INDEX(unique_edge_index)').where('sink_id < 5').count(:all)
     end
   end
 
   def test_from_option_with_table_different_than_class
-    assert_equal Account.count(:all), Company.count(:all, :from => 'accounts')
+    assert_equal Account.count(:all), Company.from('accounts').count(:all)
   end
 
   def test_distinct_is_honored_when_used_with_count_operation_after_group
diff --git a/activerecord/test/cases/deprecated_finder_test.rb b/activerecord/test/cases/deprecated_finder_test.rb
deleted file mode 100644
index 2afc91b769..0000000000
--- a/activerecord/test/cases/deprecated_finder_test.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-require "cases/helper"
-require 'models/entrant'
-
-class DeprecatedFinderTest < ActiveRecord::TestCase
-  fixtures :entrants
-
-  def test_deprecated_find_all_was_removed
-    assert_raise(NoMethodError) { Entrant.find_all }
-  end
-
-  def test_deprecated_find_first_was_removed
-    assert_raise(NoMethodError) { Entrant.find_first }
-  end
-
-  def test_deprecated_find_on_conditions_was_removed
-    assert_raise(NoMethodError) { Entrant.find_on_conditions }
-  end
-
-  def test_count
-    assert_equal(0, Entrant.count(:conditions => "id > 3"))
-    assert_equal(1, Entrant.count(:conditions => ["id > ?", 2]))
-    assert_equal(2, Entrant.count(:conditions => ["id > ?", 1]))
-  end
-
-  def test_count_by_sql
-    assert_equal(0, Entrant.count_by_sql("SELECT COUNT(*) FROM entrants WHERE id > 3"))
-    assert_equal(1, Entrant.count_by_sql(["SELECT COUNT(*) FROM entrants WHERE id > ?", 2]))
-    assert_equal(2, Entrant.count_by_sql(["SELECT COUNT(*) FROM entrants WHERE id > ?", 1]))
-  end
-end
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index ed1a61e489..152f811ff9 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -612,12 +612,6 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal "'something; select table'", ActiveRecord::Base.sanitize("something; select table")
   end
 
-  def test_count
-    assert_equal(0, Entrant.count(:conditions => "id > 3"))
-    assert_equal(1, Entrant.count(:conditions => ["id > ?", 2]))
-    assert_equal(2, Entrant.count(:conditions => ["id > ?", 1]))
-  end
-
   def test_count_by_sql
     assert_equal(0, Entrant.count_by_sql("SELECT COUNT(*) FROM entrants WHERE id > 3"))
     assert_equal(1, Entrant.count_by_sql(["SELECT COUNT(*) FROM entrants WHERE id > ?", 2]))
diff --git a/activerecord/test/cases/named_scope_test.rb b/activerecord/test/cases/named_scope_test.rb
index 31e66c738e..d4a495487d 100644
--- a/activerecord/test/cases/named_scope_test.rb
+++ b/activerecord/test/cases/named_scope_test.rb
@@ -61,7 +61,7 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert !Topic.find(:all, :conditions => {:approved => true}).empty?
 
     assert_equal Topic.find(:all, :conditions => {:approved => true}), Topic.approved
-    assert_equal Topic.count(:conditions => {:approved => true}), Topic.approved.count
+    assert_equal Topic.where(:approved => true).count, Topic.approved.count
   end
 
   def test_scopes_with_string_name_can_be_composed
-- 
cgit v1.2.3


From 58663218e8025c0d7ab691228fc278bc35e092a7 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Thu, 26 Apr 2012 17:46:04 +0100
Subject: remove deprecated #first calls

---
 .../test/cases/associations/has_many_associations_test.rb  | 13 +------------
 activerecord/test/cases/named_scope_test.rb                | 14 --------------
 activerecord/test/cases/relation_scoping_test.rb           |  4 ++--
 3 files changed, 3 insertions(+), 28 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index 321dae4143..43251a12e3 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -805,7 +805,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_deleting_updates_counter_cache
-    topic = Topic.first(:order => "id ASC")
+    topic = Topic.order("id ASC").first
     assert_equal topic.replies.to_a.size, topic.replies_count
 
     topic.replies.delete(topic.replies.first)
@@ -1491,17 +1491,6 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_calling_first_or_last_with_find_options_on_loaded_association_should_fetch_with_query
-    firm = companies(:first_firm)
-    firm.clients.class # force load target
-
-    assert_queries 2 do
-      assert firm.clients.loaded?
-      firm.clients.first(:order => 'name')
-      firm.clients.last(:order => 'name')
-    end
-  end
-
   def test_calling_first_or_last_with_integer_on_association_should_load_association
     firm = companies(:first_firm)
 
diff --git a/activerecord/test/cases/named_scope_test.rb b/activerecord/test/cases/named_scope_test.rb
index d4a495487d..1aa0c7ec25 100644
--- a/activerecord/test/cases/named_scope_test.rb
+++ b/activerecord/test/cases/named_scope_test.rb
@@ -146,11 +146,6 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert_equal scope, Topic.scoped(where: "content LIKE '%Have%'")
   end
 
-  def test_first_and_last_should_support_find_options
-    assert_equal Topic.base.first(:order => 'title'), Topic.base.find(:first, :order => 'title')
-    assert_equal Topic.base.last(:order => 'title'), Topic.base.find(:last, :order => 'title')
-  end
-
   def test_first_and_last_should_allow_integers_for_limit
     assert_equal Topic.base.first(2), Topic.base.to_a.first(2)
     assert_equal Topic.base.last(2), Topic.base.order("id").to_a.last(2)
@@ -165,15 +160,6 @@ class NamedScopeTest < ActiveRecord::TestCase
     end
   end
 
-  def test_first_and_last_find_options_should_use_query_when_results_are_loaded
-    topics = Topic.base
-    topics.reload # force load
-    assert_queries(2) do
-      topics.first(:order => 'title')
-      topics.last(:order => 'title')
-    end
-  end
-
   def test_empty_should_not_load_results
     topics = Topic.base
     assert_queries(2) do
diff --git a/activerecord/test/cases/relation_scoping_test.rb b/activerecord/test/cases/relation_scoping_test.rb
index 7216282892..187ff3457e 100644
--- a/activerecord/test/cases/relation_scoping_test.rb
+++ b/activerecord/test/cases/relation_scoping_test.rb
@@ -53,8 +53,8 @@ class RelationScopingTest < ActiveRecord::TestCase
   end
 
   def test_scoped_find_last_preserves_scope
-    lowest_salary  = Developer.first :order => "salary ASC"
-    highest_salary = Developer.first :order => "salary DESC"
+    lowest_salary  = Developer.order("salary ASC").first
+    highest_salary = Developer.order("salary DESC").first
 
     Developer.order("salary").scoping do
       assert_equal highest_salary, Developer.last
-- 
cgit v1.2.3


From b30996307d3b8d0d519c7ddcfa28fdeed428b602 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Thu, 26 Apr 2012 17:59:30 +0100
Subject: remove deprecate #all usage

---
 .../test/cases/associations/eager_load_nested_include_test.rb         | 2 +-
 activerecord/test/cases/finder_test.rb                                | 2 +-
 activerecord/test/cases/persistence_test.rb                           | 2 +-
 activerecord/test/cases/relations_test.rb                             | 4 ----
 4 files changed, 3 insertions(+), 7 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/associations/eager_load_nested_include_test.rb b/activerecord/test/cases/associations/eager_load_nested_include_test.rb
index 1e1958410c..74e23c5765 100644
--- a/activerecord/test/cases/associations/eager_load_nested_include_test.rb
+++ b/activerecord/test/cases/associations/eager_load_nested_include_test.rb
@@ -123,7 +123,7 @@ class EagerLoadNestedIncludeWithMissingDataTest < ActiveRecord::TestCase
     assert_nothing_raised do
       # @davey_mcdave doesn't have any author_favorites
       includes = {:posts => :comments, :categorizations => :category, :author_favorites => :favorite_author }
-      Author.all :include => includes, :conditions => {:authors => {:name => @davey_mcdave.name}}, :order => 'categories.name'
+      Author.scoped(:includes => includes, :where => {:authors => {:name => @davey_mcdave.name}}, :order => 'categories.name').to_a
     end
   end
 end
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index 152f811ff9..0df3abacda 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -335,7 +335,7 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_with_hash_conditions_on_joined_table_and_with_range
-    firms = DependentFirm.all :joins => :account, :conditions => {:name => 'RailsCore', :accounts => { :credit_limit => 55..60 }}
+    firms = DependentFirm.scoped :joins => :account, :where => {:name => 'RailsCore', :accounts => { :credit_limit => 55..60 }}
     assert_equal 1, firms.size
     assert_equal companies(:rails_core), firms.first
   end
diff --git a/activerecord/test/cases/persistence_test.rb b/activerecord/test/cases/persistence_test.rb
index 15d14c7a8b..5a47d3ed9f 100644
--- a/activerecord/test/cases/persistence_test.rb
+++ b/activerecord/test/cases/persistence_test.rb
@@ -120,7 +120,7 @@ class PersistencesTest < ActiveRecord::TestCase
 
   def test_destroy_all
     conditions = "author_name = 'Mary'"
-    topics_by_mary = Topic.all(:conditions => conditions, :order => 'id')
+    topics_by_mary = Topic.scoped(:where => conditions, :order => 'id').to_a
     assert ! topics_by_mary.empty?
 
     assert_difference('Topic.count', -topics_by_mary.size) do
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 1329a92e07..63b31c33b8 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -1126,10 +1126,6 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal [rails_author], relation & [rails_author]
   end
 
-  def test_removing_limit_with_options
-    assert_not_equal 1, Post.limit(1).all(:limit => nil).count
-  end
-
   def test_primary_key
     assert_equal "id", Post.scoped.primary_key
   end
-- 
cgit v1.2.3


From 75f03eca753f1e835409a80db1f54f716ef48d18 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Thu, 26 Apr 2012 18:32:55 +0100
Subject: remove calls to find(:first), find(:last) and find(:all)

---
 .../test/cases/adapters/mysql/schema_test.rb       |  2 +-
 .../test/cases/adapters/mysql2/schema_test.rb      |  2 +-
 .../associations/belongs_to_associations_test.rb   |  2 +-
 activerecord/test/cases/associations/eager_test.rb |  4 +--
 .../has_and_belongs_to_many_associations_test.rb   | 16 +++++-----
 .../associations/has_many_associations_test.rb     | 17 ++++------
 .../has_many_through_associations_test.rb          |  6 ++--
 .../associations/has_one_associations_test.rb      |  4 +--
 .../associations/inverse_associations_test.rb      | 36 +++++++++++-----------
 .../test/cases/associations/join_model_test.rb     | 14 ++++-----
 activerecord/test/cases/attribute_methods_test.rb  |  2 +-
 .../test/cases/autosave_association_test.rb        | 24 +++++++--------
 activerecord/test/cases/base_test.rb               | 10 +++---
 activerecord/test/cases/finder_test.rb             |  2 +-
 activerecord/test/cases/fixtures_test.rb           |  2 +-
 activerecord/test/cases/inheritance_test.rb        |  8 ++---
 activerecord/test/cases/locking_test.rb            |  2 +-
 .../test/cases/migration/column_attributes_test.rb |  6 ++--
 .../test/cases/migration/rename_column_test.rb     |  6 ++--
 activerecord/test/cases/migration_test.rb          | 16 +++++-----
 activerecord/test/cases/modules_test.rb            |  8 ++---
 activerecord/test/cases/named_scope_test.rb        | 22 ++++++-------
 activerecord/test/cases/query_cache_test.rb        |  6 ++--
 activerecord/test/cases/readonly_test.rb           |  4 +--
 activerecord/test/cases/reflection_test.rb         |  2 +-
 activerecord/test/cases/relation_scoping_test.rb   |  8 ++---
 .../validations/association_validation_test.rb     |  2 +-
 27 files changed, 114 insertions(+), 119 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/adapters/mysql/schema_test.rb b/activerecord/test/cases/adapters/mysql/schema_test.rb
index 29f885c6e7..d94bb629a7 100644
--- a/activerecord/test/cases/adapters/mysql/schema_test.rb
+++ b/activerecord/test/cases/adapters/mysql/schema_test.rb
@@ -20,7 +20,7 @@ module ActiveRecord
       end
 
       def test_schema
-        assert @omgpost.find(:first)
+        assert @omgpost.first
       end
 
       def test_primary_key
diff --git a/activerecord/test/cases/adapters/mysql2/schema_test.rb b/activerecord/test/cases/adapters/mysql2/schema_test.rb
index de4d9c2b33..2c0ed73c92 100644
--- a/activerecord/test/cases/adapters/mysql2/schema_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/schema_test.rb
@@ -20,7 +20,7 @@ module ActiveRecord
       end
 
       def test_schema
-        assert @omgpost.find(:first)
+        assert @omgpost.first
       end
 
       def test_primary_key
diff --git a/activerecord/test/cases/associations/belongs_to_associations_test.rb b/activerecord/test/cases/associations/belongs_to_associations_test.rb
index 05ab86105c..0dd6b798d3 100644
--- a/activerecord/test/cases/associations/belongs_to_associations_test.rb
+++ b/activerecord/test/cases/associations/belongs_to_associations_test.rb
@@ -394,7 +394,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_association_assignment_sticks
-    post = Post.find(:first)
+    post = Post.first
 
     author1, author2 = Author.find(:all, :limit => 2)
     assert_not_nil author1
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index c3eda9431c..95ae158c93 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -585,7 +585,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_has_many_and_limit_with_no_results
-    posts = Post.scoped(:includes => [ :author, :comments ], :limit => 2, :where => "posts.title = 'magic forest'").find(:all)
+    posts = Post.scoped(:includes => [ :author, :comments ], :limit => 2, :where => "posts.title = 'magic forest'").all
     assert_equal 0, posts.size
   end
 
@@ -1036,7 +1036,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_preload_has_many_using_primary_key
-    expected = Firm.find(:first).clients_using_primary_key.to_a
+    expected = Firm.first.clients_using_primary_key.to_a
     firm = Firm.find :first, :include => :clients_using_primary_key
     assert_no_queries do
       assert_equal expected, firm.clients_using_primary_key
diff --git a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
index 3c36761385..63799a7224 100644
--- a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
@@ -355,7 +355,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_deleting_array
     david = Developer.find(1)
     david.projects.reload
-    david.projects.delete(Project.find(:all))
+    david.projects.delete(Project.all)
     assert_equal 0, david.projects.size
     assert_equal 0, david.projects(true).size
   end
@@ -375,7 +375,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     active_record.developers.reload
     assert_equal 3, active_record.developers_by_sql.size
 
-    active_record.developers_by_sql.delete(Developer.find(:all))
+    active_record.developers_by_sql.delete(Developer.all)
     assert_equal 0, active_record.developers_by_sql(true).size
   end
 
@@ -548,7 +548,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
 
   def test_find_with_merged_options
     assert_equal 1, projects(:active_record).limited_developers.size
-    assert_equal 1, projects(:active_record).limited_developers.find(:all).size
+    assert_equal 1, projects(:active_record).limited_developers.all.size
     assert_equal 3, projects(:active_record).limited_developers.find(:all, :limit => nil).size
   end
 
@@ -632,7 +632,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_consider_type
-    developer = Developer.find(:first)
+    developer = Developer.first
     special_project = SpecialProject.create("name" => "Special Project")
 
     other_project = developer.projects.first
@@ -667,7 +667,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     categories(:technology).select_testing_posts(true).each do |o|
       assert_respond_to o, :correctness_marker
     end
-    assert_respond_to categories(:technology).select_testing_posts.find(:first), :correctness_marker
+    assert_respond_to categories(:technology).select_testing_posts.first, :correctness_marker
   end
 
   def test_habtm_selects_all_columns_by_default
@@ -780,8 +780,8 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
 
     assert_equal 1, project.developers.size
     assert_equal 1, developer.projects.size
-    assert_equal developer, project.developers.find(:first)
-    assert_equal project, developer.projects.find(:first)
+    assert_equal developer, project.developers.first
+    assert_equal project, developer.projects.first
   end
 
   def test_self_referential_habtm_without_foreign_key_set_should_raise_exception
@@ -820,7 +820,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
 
   def test_association_proxy_transaction_method_starts_transaction_in_association_class
     Post.expects(:transaction)
-    Category.find(:first).posts.transaction do
+    Category.first.posts.transaction do
       # nothing
     end
   end
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index 43251a12e3..8267e0e18c 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -279,7 +279,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_find_many_with_merged_options
     assert_equal 1, companies(:first_firm).limited_clients.size
-    assert_equal 1, companies(:first_firm).limited_clients.find(:all).size
+    assert_equal 1, companies(:first_firm).limited_clients.all.size
     assert_equal 2, companies(:first_firm).limited_clients.find(:all, :limit => nil).size
   end
 
@@ -312,11 +312,6 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal 2, companies(:first_firm).limited_clients.find_all_by_type('Client', :limit => 9_000).length
   end
 
-  def test_dynamic_find_all_should_respect_readonly_access
-    companies(:first_firm).readonly_clients.find(:all).each { |c| assert_raise(ActiveRecord::ReadOnlyRecord) { c.save!  } }
-    companies(:first_firm).readonly_clients.find(:all).each { |c| assert c.readonly? }
-  end
-
   def test_dynamic_find_or_create_from_two_attributes_using_an_association
     author = authors(:david)
     number_of_posts = Post.count
@@ -1000,14 +995,14 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_delete_all_association_with_primary_key_deletes_correct_records
-    firm = Firm.find(:first)
+    firm = Firm.first
     # break the vanilla firm_id foreign key
     assert_equal 2, firm.clients.count
     firm.clients.first.update_column(:firm_id, nil)
     assert_equal 1, firm.clients(true).count
     assert_equal 1, firm.clients_using_primary_key_with_delete_all.count
     old_record = firm.clients_using_primary_key_with_delete_all.first
-    firm = Firm.find(:first)
+    firm = Firm.first
     firm.destroy
     assert_nil Client.find_by_id(old_record.id)
   end
@@ -1216,12 +1211,12 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_adding_array_and_collection
-    assert_nothing_raised { Firm.find(:first).clients + Firm.find(:all).last.clients }
+    assert_nothing_raised { Firm.first.clients + Firm.all.last.clients }
   end
 
   def test_find_all_without_conditions
     firm = companies(:first_firm)
-    assert_equal 2, firm.clients.find(:all).length
+    assert_equal 2, firm.clients.all.length
   end
 
   def test_replace_with_less
@@ -1561,7 +1556,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_association_proxy_transaction_method_starts_transaction_in_association_class
     Comment.expects(:transaction)
-    Post.find(:first).comments.transaction do
+    Post.first.comments.transaction do
       # nothing
     end
   end
diff --git a/activerecord/test/cases/associations/has_many_through_associations_test.rb b/activerecord/test/cases/associations/has_many_through_associations_test.rb
index 641194877b..1c06007d86 100644
--- a/activerecord/test/cases/associations/has_many_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_through_associations_test.rb
@@ -568,7 +568,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_association_proxy_transaction_method_starts_transaction_in_association_class
     Tag.expects(:transaction)
-    Post.find(:first).tags.transaction do
+    Post.first.tags.transaction do
       # nothing
     end
   end
@@ -651,7 +651,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_collection_singular_ids_setter
     company = companies(:rails_core)
-    dev = Developer.find(:first)
+    dev = Developer.first
 
     company.developer_ids = [dev.id]
     assert_equal [dev], company.developers
@@ -671,7 +671,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_collection_singular_ids_setter_raises_exception_when_invalid_ids_set
     company = companies(:rails_core)
-    ids =  [Developer.find(:first).id, -9999]
+    ids =  [Developer.first.id, -9999]
     assert_raises(ActiveRecord::RecordNotFound) {company.developer_ids= ids}
   end
 
diff --git a/activerecord/test/cases/associations/has_one_associations_test.rb b/activerecord/test/cases/associations/has_one_associations_test.rb
index 9c05b36426..35c5d765a7 100644
--- a/activerecord/test/cases/associations/has_one_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_associations_test.rb
@@ -294,13 +294,13 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
   def test_dependence_with_missing_association_and_nullify
     Account.destroy_all
-    firm = DependentFirm.find(:first)
+    firm = DependentFirm.first
     assert_nil firm.account
     firm.destroy
   end
 
   def test_finding_with_interpolated_condition
-    firm = Firm.find(:first)
+    firm = Firm.first
     superior = firm.clients.create(:name => 'SuperiorCo')
     superior.rating = 10
     superior.save
diff --git a/activerecord/test/cases/associations/inverse_associations_test.rb b/activerecord/test/cases/associations/inverse_associations_test.rb
index 76282213d8..2cf902de75 100644
--- a/activerecord/test/cases/associations/inverse_associations_test.rb
+++ b/activerecord/test/cases/associations/inverse_associations_test.rb
@@ -114,7 +114,7 @@ class InverseHasOneTests < ActiveRecord::TestCase
   end
 
   def test_parent_instance_should_be_shared_with_newly_built_child
-    m = Man.find(:first)
+    m = Man.first
     f = m.build_face(:description => 'haunted')
     assert_not_nil f.man
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
@@ -125,7 +125,7 @@ class InverseHasOneTests < ActiveRecord::TestCase
   end
 
   def test_parent_instance_should_be_shared_with_newly_created_child
-    m = Man.find(:first)
+    m = Man.first
     f = m.create_face(:description => 'haunted')
     assert_not_nil f.man
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
@@ -136,7 +136,7 @@ class InverseHasOneTests < ActiveRecord::TestCase
   end
 
   def test_parent_instance_should_be_shared_with_newly_created_child_via_bang_method
-    m = Man.find(:first)
+    m = Man.first
     f = m.create_face!(:description => 'haunted')
     assert_not_nil f.man
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
@@ -147,7 +147,7 @@ class InverseHasOneTests < ActiveRecord::TestCase
   end
 
   def test_parent_instance_should_be_shared_with_replaced_via_accessor_child
-    m = Man.find(:first)
+    m = Man.first
     f = Face.new(:description => 'haunted')
     m.face = f
     assert_not_nil f.man
@@ -159,7 +159,7 @@ class InverseHasOneTests < ActiveRecord::TestCase
   end
 
   def test_trying_to_use_inverses_that_dont_exist_should_raise_an_error
-    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Man.find(:first).dirty_face }
+    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Man.first.dirty_face }
   end
 end
 
@@ -201,7 +201,7 @@ class InverseHasManyTests < ActiveRecord::TestCase
   end
 
   def test_parent_instance_should_be_shared_with_newly_block_style_built_child
-    m = Man.find(:first)
+    m = Man.first
     i = m.interests.build {|ii| ii.topic = 'Industrial Revolution Re-enactment'}
     assert_not_nil i.topic, "Child attributes supplied to build via blocks should be populated"
     assert_not_nil i.man
@@ -213,7 +213,7 @@ class InverseHasManyTests < ActiveRecord::TestCase
   end
 
   def test_parent_instance_should_be_shared_with_newly_created_via_bang_method_child
-    m = Man.find(:first)
+    m = Man.first
     i = m.interests.create!(:topic => 'Industrial Revolution Re-enactment')
     assert_not_nil i.man
     assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
@@ -224,7 +224,7 @@ class InverseHasManyTests < ActiveRecord::TestCase
   end
 
   def test_parent_instance_should_be_shared_with_newly_block_style_created_child
-    m = Man.find(:first)
+    m = Man.first
     i = m.interests.create {|ii| ii.topic = 'Industrial Revolution Re-enactment'}
     assert_not_nil i.topic, "Child attributes supplied to create via blocks should be populated"
     assert_not_nil i.man
@@ -248,7 +248,7 @@ class InverseHasManyTests < ActiveRecord::TestCase
   end
 
   def test_parent_instance_should_be_shared_with_replaced_via_accessor_children
-    m = Man.find(:first)
+    m = Man.first
     i = Interest.new(:topic => 'Industrial Revolution Re-enactment')
     m.interests = [i]
     assert_not_nil i.man
@@ -260,7 +260,7 @@ class InverseHasManyTests < ActiveRecord::TestCase
   end
 
   def test_trying_to_use_inverses_that_dont_exist_should_raise_an_error
-    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Man.find(:first).secret_interests }
+    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Man.first.secret_interests }
   end
 end
 
@@ -331,7 +331,7 @@ class InverseBelongsToTests < ActiveRecord::TestCase
   end
 
   def test_child_instance_should_be_shared_with_replaced_via_accessor_parent
-    f = Face.find(:first)
+    f = Face.first
     m = Man.new(:name => 'Charles')
     f.man = m
     assert_not_nil m.face
@@ -343,7 +343,7 @@ class InverseBelongsToTests < ActiveRecord::TestCase
   end
 
   def test_trying_to_use_inverses_that_dont_exist_should_raise_an_error
-    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.find(:first).horrible_man }
+    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.horrible_man }
   end
 end
 
@@ -421,19 +421,19 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
 
   def test_trying_to_access_inverses_that_dont_exist_shouldnt_raise_an_error
     # Ideally this would, if only for symmetry's sake with other association types
-    assert_nothing_raised(ActiveRecord::InverseOfAssociationNotFoundError) { Face.find(:first).horrible_polymorphic_man }
+    assert_nothing_raised(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.horrible_polymorphic_man }
   end
 
   def test_trying_to_set_polymorphic_inverses_that_dont_exist_at_all_should_raise_an_error
     # fails because no class has the correct inverse_of for horrible_polymorphic_man
-    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.find(:first).horrible_polymorphic_man = Man.first }
+    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.horrible_polymorphic_man = Man.first }
   end
 
   def test_trying_to_set_polymorphic_inverses_that_dont_exist_on_the_instance_being_set_should_raise_an_error
     # passes because Man does have the correct inverse_of
-    assert_nothing_raised(ActiveRecord::InverseOfAssociationNotFoundError) { Face.find(:first).polymorphic_man = Man.first }
+    assert_nothing_raised(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.polymorphic_man = Man.first }
     # fails because Interest does have the correct inverse_of
-    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.find(:first).polymorphic_man = Interest.first }
+    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.polymorphic_man = Interest.first }
   end
 end
 
@@ -444,7 +444,7 @@ class InverseMultipleHasManyInversesForSameModel < ActiveRecord::TestCase
 
   def test_that_we_can_load_associations_that_have_the_same_reciprocal_name_from_different_models
     assert_nothing_raised(ActiveRecord::AssociationTypeMismatch) do
-      i = Interest.find(:first)
+      i = Interest.first
       i.zine
       i.man
     end
@@ -452,7 +452,7 @@ class InverseMultipleHasManyInversesForSameModel < ActiveRecord::TestCase
 
   def test_that_we_can_create_associations_that_have_the_same_reciprocal_name_from_different_models
     assert_nothing_raised(ActiveRecord::AssociationTypeMismatch) do
-      i = Interest.find(:first)
+      i = Interest.first
       i.build_zine(:title => 'Get Some in Winter! 2008')
       i.build_man(:name => 'Gordon')
       i.save!
diff --git a/activerecord/test/cases/associations/join_model_test.rb b/activerecord/test/cases/associations/join_model_test.rb
index 95f03fc95a..d3451bdb79 100644
--- a/activerecord/test/cases/associations/join_model_test.rb
+++ b/activerecord/test/cases/associations/join_model_test.rb
@@ -51,7 +51,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_uniq_through_find
-    assert_equal 1, authors(:mary).unique_categorized_posts.find(:all).size
+    assert_equal 1, authors(:mary).unique_categorized_posts.all.size
   end
 
   def test_has_many_uniq_through_dynamic_find
@@ -71,7 +71,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_polymorphic_has_many_going_through_join_model_with_find
-    assert_equal tags(:general), tag = posts(:welcome).tags.find(:first)
+    assert_equal tags(:general), tag = posts(:welcome).tags.first
     assert_no_queries do
       tag.tagging
     end
@@ -85,7 +85,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_polymorphic_has_many_going_through_join_model_with_include_on_source_reflection_with_find
-    assert_equal tags(:general), tag = posts(:welcome).funky_tags.find(:first)
+    assert_equal tags(:general), tag = posts(:welcome).funky_tags.first
     assert_no_queries do
       tag.tagging
     end
@@ -280,15 +280,15 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_find_all
-    assert_equal [categories(:general)], authors(:david).categories.find(:all)
+    assert_equal [categories(:general)], authors(:david).categories.all
   end
 
   def test_has_many_find_first
-    assert_equal categories(:general), authors(:david).categories.find(:first)
+    assert_equal categories(:general), authors(:david).categories.first
   end
 
   def test_has_many_with_hash_conditions
-    assert_equal categories(:general), authors(:david).categories_like_general.find(:first)
+    assert_equal categories(:general), authors(:david).categories_like_general.first
   end
 
   def test_has_many_find_conditions
@@ -444,7 +444,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_through_uses_conditions_specified_on_the_has_many_association
-    author = Author.find(:first)
+    author = Author.first
     assert_present author.comments
     assert_blank author.nonexistant_comments
   end
diff --git a/activerecord/test/cases/attribute_methods_test.rb b/activerecord/test/cases/attribute_methods_test.rb
index ef01476ae4..7ed61243e5 100644
--- a/activerecord/test/cases/attribute_methods_test.rb
+++ b/activerecord/test/cases/attribute_methods_test.rb
@@ -244,7 +244,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     # DB2 is not case-sensitive
     return true if current_adapter?(:DB2Adapter)
 
-    assert_equal @loaded_fixtures['computers']['workstation'].to_hash, Computer.find(:first).attributes
+    assert_equal @loaded_fixtures['computers']['workstation'].to_hash, Computer.first.attributes
   end
 
   def test_hashes_not_mangled
diff --git a/activerecord/test/cases/autosave_association_test.rb b/activerecord/test/cases/autosave_association_test.rb
index d555c1699e..84a3f658a8 100644
--- a/activerecord/test/cases/autosave_association_test.rb
+++ b/activerecord/test/cases/autosave_association_test.rb
@@ -87,7 +87,7 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
   end
 
   def test_save_fails_for_invalid_has_one
-    firm = Firm.find(:first)
+    firm = Firm.first
     assert firm.valid?
 
     firm.build_account
@@ -99,7 +99,7 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
   end
 
   def test_save_succeeds_for_invalid_has_one_with_validate_false
-    firm = Firm.find(:first)
+    firm = Firm.first
     assert firm.valid?
 
     firm.build_unvalidated_account
@@ -159,16 +159,16 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
     firm.name += '-changed'
     assert_queries(1) { firm.save! }
 
-    firm = Firm.find(:first)
-    firm.account = Account.find(:first)
+    firm = Firm.first
+    firm.account = Account.first
     assert_queries(Firm.partial_updates? ? 0 : 1) { firm.save! }
 
-    firm = Firm.find(:first).dup
-    firm.account = Account.find(:first)
+    firm = Firm.first.dup
+    firm.account = Account.first
     assert_queries(2) { firm.save! }
 
-    firm = Firm.find(:first).dup
-    firm.account = Account.find(:first).dup
+    firm = Firm.first.dup
+    firm.account = Account.first.dup
     assert_queries(2) { firm.save! }
   end
 
@@ -228,7 +228,7 @@ class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::Test
   end
 
   def test_assignment_before_parent_saved
-    client = Client.find(:first)
+    client = Client.first
     apple = Firm.new("name" => "Apple")
     client.firm = apple
     assert_equal apple, client.firm
@@ -342,7 +342,7 @@ class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::Test
   end
 
   def test_build_and_then_save_parent_should_not_reload_target
-    client = Client.find(:first)
+    client = Client.first
     apple = client.build_firm(:name => "Apple")
     client.save!
     assert_no_queries { assert_equal apple, client.firm }
@@ -384,7 +384,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
   end
 
   def test_invalid_adding_with_validate_false
-    firm = Firm.find(:first)
+    firm = Firm.first
     client = Client.new
     firm.unvalidated_clients_of_firm << client
 
@@ -397,7 +397,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
   def test_valid_adding_with_validate_false
     no_of_clients = Client.count
 
-    firm = Firm.find(:first)
+    firm = Firm.first
     client = Client.new("name" => "Apple")
 
     assert firm.valid?
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index 127d5d0cae..da7d99e2c5 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -192,7 +192,7 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_previously_changed
-    topic = Topic.find :first
+    topic = Topic.first
     topic.title = '<3<3<3'
     assert_equal({}, topic.previous_changes)
 
@@ -202,7 +202,7 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_previously_changed_dup
-    topic = Topic.find :first
+    topic = Topic.first
     topic.title = '<3<3<3'
     topic.save!
 
@@ -1600,7 +1600,7 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_find_last
-    last  = Developer.find :last
+    last  = Developer.last
     assert_equal last, Developer.find(:first, :order => 'id desc')
   end
 
@@ -1611,7 +1611,7 @@ class BasicsTest < ActiveRecord::TestCase
   def test_all
     developers = Developer.all
     assert_kind_of Array, developers
-    assert_equal Developer.find(:all), developers
+    assert_equal Developer.all, developers
   end
 
   def test_all_with_conditions
@@ -1720,7 +1720,7 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_to_param_should_return_string
-    assert_kind_of String, Client.find(:first).to_param
+    assert_kind_of String, Client.first.to_param
   end
 
   def test_inspect_class
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index 0df3abacda..4599666cd0 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -104,7 +104,7 @@ class FinderTest < ActiveRecord::TestCase
     # Also test an edge case: If you have 11 results, and you set a
     #   limit of 3 and offset of 9, then you should find that there
     #   will be only 2 results, regardless of the limit.
-    devs = Developer.find :all
+    devs = Developer.all
     last_devs = Developer.find devs.map(&:id), :limit => 3, :offset => 9
     assert_equal 2, last_devs.size
   end
diff --git a/activerecord/test/cases/fixtures_test.rb b/activerecord/test/cases/fixtures_test.rb
index e660b2ca35..c28f8de682 100644
--- a/activerecord/test/cases/fixtures_test.rb
+++ b/activerecord/test/cases/fixtures_test.rb
@@ -716,7 +716,7 @@ class FoxyFixturesTest < ActiveRecord::TestCase
   end
 
   def test_only_generates_a_pk_if_necessary
-    m = Matey.find(:first)
+    m = Matey.first
     m.pirate = pirates(:blackbeard)
     m.target = pirates(:redbeard)
   end
diff --git a/activerecord/test/cases/inheritance_test.rb b/activerecord/test/cases/inheritance_test.rb
index 02df464469..c84448041d 100644
--- a/activerecord/test/cases/inheritance_test.rb
+++ b/activerecord/test/cases/inheritance_test.rb
@@ -15,7 +15,7 @@ class InheritanceTest < ActiveRecord::TestCase
   end
 
   def test_class_with_blank_sti_name
-    company = Company.find(:first)
+    company = Company.first
     company = company.dup
     company.extend(Module.new {
       def read_attribute(name)
@@ -24,7 +24,7 @@ class InheritanceTest < ActiveRecord::TestCase
       end
     })
     company.save!
-    company = Company.find(:all).find { |x| x.id == company.id }
+    company = Company.all.find { |x| x.id == company.id }
     assert_equal '  ', company.type
   end
 
@@ -149,7 +149,7 @@ class InheritanceTest < ActiveRecord::TestCase
 
   def test_update_all_within_inheritance
     Client.update_all "name = 'I am a client'"
-    assert_equal "I am a client", Client.find(:all).first.name
+    assert_equal "I am a client", Client.all.first.name
     # Order by added as otherwise Oracle tests were failing because of different order of results
     assert_equal "37signals", Firm.find(:all, :order => "id").first.name
   end
@@ -259,7 +259,7 @@ class InheritanceComputeTypeTest < ActiveRecord::TestCase
 
   def test_instantiation_doesnt_try_to_require_corresponding_file
     ActiveRecord::Base.store_full_sti_class = false
-    foo = Firm.find(:first).clone
+    foo = Firm.first.clone
     foo.ruby_type = foo.type = 'FirmOnTheFly'
     foo.save!
 
diff --git a/activerecord/test/cases/locking_test.rb b/activerecord/test/cases/locking_test.rb
index 48ce7ea2d3..ee180e4154 100644
--- a/activerecord/test/cases/locking_test.rb
+++ b/activerecord/test/cases/locking_test.rb
@@ -323,7 +323,7 @@ class OptimisticLockingWithSchemaChangeTest < ActiveRecord::TestCase
 
     def counter_test(model, expected_count)
       add_counter_column_to(model)
-      object = model.find(:first)
+      object = model.first
       assert_equal 0, object.test_count
       assert_equal 0, object.send(model.locking_column)
       yield object.id
diff --git a/activerecord/test/cases/migration/column_attributes_test.rb b/activerecord/test/cases/migration/column_attributes_test.rb
index 040445ef12..409a558f5c 100644
--- a/activerecord/test/cases/migration/column_attributes_test.rb
+++ b/activerecord/test/cases/migration/column_attributes_test.rb
@@ -64,7 +64,7 @@ module ActiveRecord
         end
 
         # SELECT
-        row = TestModel.find(:first)
+        row = TestModel.first
         assert_kind_of BigDecimal, row.wealth
 
         # If this assert fails, that means the SELECT is broken!
@@ -79,7 +79,7 @@ module ActiveRecord
         TestModel.create :wealth => BigDecimal.new("12345678901234567890.0123456789")
 
         # SELECT
-        row = TestModel.find(:first)
+        row = TestModel.first
         assert_kind_of BigDecimal, row.wealth
 
         # If these asserts fail, that means the INSERT (create function, or cast to SQL) is broken!
@@ -132,7 +132,7 @@ module ActiveRecord
           :birthday => 18.years.ago, :favorite_day => 10.days.ago,
           :moment_of_truth => "1782-10-10 21:40:18", :male => true
 
-        bob = TestModel.find(:first)
+        bob = TestModel.first
         assert_equal 'bob', bob.first_name
         assert_equal 'bobsen', bob.last_name
         assert_equal "I was born ....", bob.bio
diff --git a/activerecord/test/cases/migration/rename_column_test.rb b/activerecord/test/cases/migration/rename_column_test.rb
index 16e09fd80e..d1a85ee5e4 100644
--- a/activerecord/test/cases/migration/rename_column_test.rb
+++ b/activerecord/test/cases/migration/rename_column_test.rb
@@ -18,7 +18,7 @@ module ActiveRecord
         rename_column "test_models", "girlfriend", "exgirlfriend"
 
         TestModel.reset_column_information
-        bob = TestModel.find(:first)
+        bob = TestModel.first
 
         assert_equal "bobette", bob.exgirlfriend
       end
@@ -33,7 +33,7 @@ module ActiveRecord
         rename_column :test_models, :first_name, :nick_name
         TestModel.reset_column_information
         assert TestModel.column_names.include?("nick_name")
-        assert_equal ['foo'], TestModel.find(:all).map(&:nick_name)
+        assert_equal ['foo'], TestModel.all.map(&:nick_name)
       end
 
       # FIXME: another integration test.  We should decouple this from the
@@ -46,7 +46,7 @@ module ActiveRecord
         rename_column "test_models", "first_name", "nick_name"
         TestModel.reset_column_information
         assert TestModel.column_names.include?("nick_name")
-        assert_equal ['foo'], TestModel.find(:all).map(&:nick_name)
+        assert_equal ['foo'], TestModel.all.map(&:nick_name)
       end
 
       def test_rename_column_preserves_default_value_not_null
diff --git a/activerecord/test/cases/migration_test.rb b/activerecord/test/cases/migration_test.rb
index e14c2d072c..e71b84a3a5 100644
--- a/activerecord/test/cases/migration_test.rb
+++ b/activerecord/test/cases/migration_test.rb
@@ -109,7 +109,7 @@ class MigrationTest < ActiveRecord::TestCase
       :value_of_e => BigDecimal("2.7182818284590452353602875")
     )
 
-    b = BigNumber.find(:first)
+    b = BigNumber.first
     assert_not_nil b
 
     assert_not_nil b.bank_balance
@@ -153,7 +153,7 @@ class MigrationTest < ActiveRecord::TestCase
     end
 
     GiveMeBigNumbers.down
-    assert_raise(ActiveRecord::StatementInvalid) { BigNumber.find(:first) }
+    assert_raise(ActiveRecord::StatementInvalid) { BigNumber.first }
   end
 
   def test_filtering_migrations
@@ -165,13 +165,13 @@ class MigrationTest < ActiveRecord::TestCase
 
     Person.reset_column_information
     assert Person.column_methods_hash.include?(:last_name)
-    assert_raise(ActiveRecord::StatementInvalid) { Reminder.find(:first) }
+    assert_raise(ActiveRecord::StatementInvalid) { Reminder.first }
 
     ActiveRecord::Migrator.down(MIGRATIONS_ROOT + "/valid", &name_filter)
 
     Person.reset_column_information
     assert !Person.column_methods_hash.include?(:last_name)
-    assert_raise(ActiveRecord::StatementInvalid) { Reminder.find(:first) }
+    assert_raise(ActiveRecord::StatementInvalid) { Reminder.first }
   end
 
   class MockMigration < ActiveRecord::Migration
@@ -285,12 +285,12 @@ class MigrationTest < ActiveRecord::TestCase
     WeNeedThings.up
 
     assert Thing.create("content" => "hello world")
-    assert_equal "hello world", Thing.find(:first).content
+    assert_equal "hello world", Thing.first.content
 
     RenameThings.up
     Thing.table_name = "p_awesome_things_s"
 
-    assert_equal "hello world", Thing.find(:first).content
+    assert_equal "hello world", Thing.first.content
   ensure
     ActiveRecord::Base.table_name_prefix = ''
     ActiveRecord::Base.table_name_suffix = ''
@@ -306,10 +306,10 @@ class MigrationTest < ActiveRecord::TestCase
     Reminder.reset_sequence_name
     WeNeedReminders.up
     assert Reminder.create("content" => "hello world", "remind_at" => Time.now)
-    assert_equal "hello world", Reminder.find(:first).content
+    assert_equal "hello world", Reminder.first.content
 
     WeNeedReminders.down
-    assert_raise(ActiveRecord::StatementInvalid) { Reminder.find(:first) }
+    assert_raise(ActiveRecord::StatementInvalid) { Reminder.first }
   ensure
     ActiveRecord::Base.table_name_prefix = ''
     ActiveRecord::Base.table_name_suffix = ''
diff --git a/activerecord/test/cases/modules_test.rb b/activerecord/test/cases/modules_test.rb
index e0fdd2871c..aee8a42e91 100644
--- a/activerecord/test/cases/modules_test.rb
+++ b/activerecord/test/cases/modules_test.rb
@@ -27,13 +27,13 @@ class ModulesTest < ActiveRecord::TestCase
   end
 
   def test_module_spanning_associations
-    firm = MyApplication::Business::Firm.find(:first)
+    firm = MyApplication::Business::Firm.first
     assert !firm.clients.empty?, "Firm should have clients"
     assert_nil firm.class.table_name.match('::'), "Firm shouldn't have the module appear in its table name"
   end
 
   def test_module_spanning_has_and_belongs_to_many_associations
-    project = MyApplication::Business::Project.find(:first)
+    project = MyApplication::Business::Project.first
     project.developers << MyApplication::Business::Developer.create("name" => "John")
     assert_equal "John", project.developers.last.name
   end
@@ -123,7 +123,7 @@ class ModulesTest < ActiveRecord::TestCase
     old = ActiveRecord::Base.store_full_sti_class
     ActiveRecord::Base.store_full_sti_class = true
 
-    collection = Shop::Collection.find(:first)
+    collection = Shop::Collection.first
     assert !collection.products.empty?, "Collection should have products"
     assert_nothing_raised { collection.destroy }
   ensure
@@ -134,7 +134,7 @@ class ModulesTest < ActiveRecord::TestCase
     old = ActiveRecord::Base.store_full_sti_class
     ActiveRecord::Base.store_full_sti_class = true
 
-    product = Shop::Product.find(:first)
+    product = Shop::Product.first
     assert !product.variants.empty?, "Product should have variants"
     assert_nothing_raised { product.destroy }
   ensure
diff --git a/activerecord/test/cases/named_scope_test.rb b/activerecord/test/cases/named_scope_test.rb
index 1aa0c7ec25..cc64afaa71 100644
--- a/activerecord/test/cases/named_scope_test.rb
+++ b/activerecord/test/cases/named_scope_test.rb
@@ -10,12 +10,12 @@ class NamedScopeTest < ActiveRecord::TestCase
   fixtures :posts, :authors, :topics, :comments, :author_addresses
 
   def test_implements_enumerable
-    assert !Topic.find(:all).empty?
+    assert !Topic.all.empty?
 
-    assert_equal Topic.find(:all),   Topic.base
-    assert_equal Topic.find(:all),   Topic.base.to_a
-    assert_equal Topic.find(:first), Topic.base.first
-    assert_equal Topic.find(:all),   Topic.base.map { |i| i }
+    assert_equal Topic.all,   Topic.base
+    assert_equal Topic.all,   Topic.base.to_a
+    assert_equal Topic.first, Topic.base.first
+    assert_equal Topic.all,   Topic.base.map { |i| i }
   end
 
   def test_found_items_are_cached
@@ -38,10 +38,10 @@ class NamedScopeTest < ActiveRecord::TestCase
   end
 
   def test_delegates_finds_and_calculations_to_the_base_class
-    assert !Topic.find(:all).empty?
+    assert !Topic.all.empty?
 
-    assert_equal Topic.find(:all),               Topic.base.find(:all)
-    assert_equal Topic.find(:first),             Topic.base.find(:first)
+    assert_equal Topic.all,               Topic.base.all
+    assert_equal Topic.first,             Topic.base.first
     assert_equal Topic.count,                    Topic.base.count
     assert_equal Topic.average(:replies_count), Topic.base.average(:replies_count)
   end
@@ -93,7 +93,7 @@ class NamedScopeTest < ActiveRecord::TestCase
   end
 
   def test_procedural_scopes_returning_nil
-    all_topics = Topic.find(:all)
+    all_topics = Topic.all
 
     assert_equal all_topics, Topic.written_before(nil)
   end
@@ -134,9 +134,9 @@ class NamedScopeTest < ActiveRecord::TestCase
   end
 
   def test_active_records_have_scope_named__all__
-    assert !Topic.find(:all).empty?
+    assert !Topic.all.empty?
 
-    assert_equal Topic.find(:all), Topic.base
+    assert_equal Topic.all, Topic.base
   end
 
   def test_active_records_have_scope_named__scoped__
diff --git a/activerecord/test/cases/query_cache_test.rb b/activerecord/test/cases/query_cache_test.rb
index d93478513b..a712e5f689 100644
--- a/activerecord/test/cases/query_cache_test.rb
+++ b/activerecord/test/cases/query_cache_test.rb
@@ -96,7 +96,7 @@ class QueryCacheTest < ActiveRecord::TestCase
 
   def test_cache_clear_after_close
     mw = ActiveRecord::QueryCache.new lambda { |env|
-      Post.find(:first)
+      Post.first
       [200, {}, nil]
     }
     body = mw.call({}).last
@@ -233,8 +233,8 @@ class QueryCacheExpiryTest < ActiveRecord::TestCase
   def test_cache_is_expired_by_habtm_update
     ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
     ActiveRecord::Base.cache do
-      c = Category.find(:first)
-      p = Post.find(:first)
+      c = Category.first
+      p = Post.first
       p.categories << c
     end
   end
diff --git a/activerecord/test/cases/readonly_test.rb b/activerecord/test/cases/readonly_test.rb
index b72b72ecf2..39b66b3399 100644
--- a/activerecord/test/cases/readonly_test.rb
+++ b/activerecord/test/cases/readonly_test.rb
@@ -27,7 +27,7 @@ class ReadOnlyTest < ActiveRecord::TestCase
 
 
   def test_find_with_readonly_option
-    Developer.find(:all).each { |d| assert !d.readonly? }
+    Developer.all.each { |d| assert !d.readonly? }
     Developer.readonly(false).each { |d| assert !d.readonly? }
     Developer.readonly(true).each { |d| assert d.readonly? }
     Developer.readonly.each { |d| assert d.readonly? }
@@ -48,7 +48,7 @@ class ReadOnlyTest < ActiveRecord::TestCase
     post = Post.find(1)
     assert !post.comments.empty?
     assert !post.comments.any?(&:readonly?)
-    assert !post.comments.find(:all).any?(&:readonly?)
+    assert !post.comments.all.any?(&:readonly?)
     assert post.comments.readonly(true).all?(&:readonly?)
   end
 
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index 16f05f2198..7dd5698dcf 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -63,7 +63,7 @@ class ReflectionTest < ActiveRecord::TestCase
   end
 
   def test_column_null_not_null
-    subscriber = Subscriber.find(:first)
+    subscriber = Subscriber.first
     assert subscriber.column_for_attribute("name").null
     assert !subscriber.column_for_attribute("nick").null
   end
diff --git a/activerecord/test/cases/relation_scoping_test.rb b/activerecord/test/cases/relation_scoping_test.rb
index 187ff3457e..c695dc1839 100644
--- a/activerecord/test/cases/relation_scoping_test.rb
+++ b/activerecord/test/cases/relation_scoping_test.rb
@@ -324,7 +324,7 @@ class DefaultScopingTest < ActiveRecord::TestCase
 
   def test_default_scope
     expected = Developer.find(:all, :order => 'salary DESC').collect { |dev| dev.salary }
-    received = DeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
+    received = DeveloperOrderedBySalary.all.collect { |dev| dev.salary }
     assert_equal expected, received
   end
 
@@ -362,12 +362,12 @@ class DefaultScopingTest < ActiveRecord::TestCase
   end
 
   def test_default_scope_with_conditions_string
-    assert_equal Developer.find_all_by_name('David').map(&:id).sort, DeveloperCalledDavid.find(:all).map(&:id).sort
+    assert_equal Developer.find_all_by_name('David').map(&:id).sort, DeveloperCalledDavid.all.map(&:id).sort
     assert_equal nil, DeveloperCalledDavid.create!.name
   end
 
   def test_default_scope_with_conditions_hash
-    assert_equal Developer.find_all_by_name('Jamis').map(&:id).sort, DeveloperCalledJamis.find(:all).map(&:id).sort
+    assert_equal Developer.find_all_by_name('Jamis').map(&:id).sort, DeveloperCalledJamis.all.map(&:id).sort
     assert_equal 'Jamis', DeveloperCalledJamis.create!.name
   end
 
@@ -397,7 +397,7 @@ class DefaultScopingTest < ActiveRecord::TestCase
 
   def test_scope_overwrites_default
     expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.name }
-    received = DeveloperOrderedBySalary.by_name.find(:all).collect { |dev| dev.name }
+    received = DeveloperOrderedBySalary.by_name.all.collect { |dev| dev.name }
     assert_equal expected, received
   end
 
diff --git a/activerecord/test/cases/validations/association_validation_test.rb b/activerecord/test/cases/validations/association_validation_test.rb
index c72b7b35cd..7ac34bc71e 100644
--- a/activerecord/test/cases/validations/association_validation_test.rb
+++ b/activerecord/test/cases/validations/association_validation_test.rb
@@ -86,7 +86,7 @@ class AssociationValidationTest < ActiveRecord::TestCase
     assert !r.valid?
     assert r.errors[:topic].any?
 
-    r.topic = Topic.find :first
+    r.topic = Topic.first
     assert r.valid?
   end
 
-- 
cgit v1.2.3


From cf1a83c8816edeacd209725ae6c90846e9c6b4fc Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Thu, 26 Apr 2012 19:05:24 +0100
Subject: don't need this test

---
 activerecord/test/cases/associations/has_many_associations_test.rb | 5 -----
 1 file changed, 5 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index 8267e0e18c..f10d3b2889 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -1214,11 +1214,6 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_nothing_raised { Firm.first.clients + Firm.all.last.clients }
   end
 
-  def test_find_all_without_conditions
-    firm = companies(:first_firm)
-    assert_equal 2, firm.clients.all.length
-  end
-
   def test_replace_with_less
     firm = Firm.find(:first, :order => "id")
     firm.clients = [companies(:first_client)]
-- 
cgit v1.2.3


From 27dea760f8f08927fd9c370f0f565b6ad1b2c0fe Mon Sep 17 00:00:00 2001
From: Andrey Deryabin <deriabin@gmail.com>
Date: Fri, 27 Apr 2012 13:09:12 +0700
Subject: fix tests for sqlite3

---
 activerecord/test/cases/adapters/sqlite3/statement_pool_test.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/adapters/sqlite3/statement_pool_test.rb b/activerecord/test/cases/adapters/sqlite3/statement_pool_test.rb
index ae272e2c4b..2f04c60a9a 100644
--- a/activerecord/test/cases/adapters/sqlite3/statement_pool_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/statement_pool_test.rb
@@ -1,7 +1,7 @@
 require 'cases/helper'
 
 module ActiveRecord::ConnectionAdapters
-  class SQLiteAdapter
+  class SQLite3Adapter
     class StatementPoolTest < ActiveRecord::TestCase
       def test_cache_is_per_pid
         return skip('must support fork') unless Process.respond_to?(:fork)
-- 
cgit v1.2.3


From d42b60a411c09dd9b69942dabbcdba6a05f259e8 Mon Sep 17 00:00:00 2001
From: Andrey Deryabin <deriabin@gmail.com>
Date: Fri, 27 Apr 2012 13:31:37 +0700
Subject: fix tests for SQLite3Adapter

---
 activerecord/test/cases/adapters/sqlite3/quoting_test.rb | 2 +-
 activerecord/test/cases/base_test.rb                     | 2 +-
 activerecord/test/cases/helper.rb                        | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/adapters/sqlite3/quoting_test.rb b/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
index 1dbeb66af6..2ba9143cd5 100644
--- a/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
@@ -5,7 +5,7 @@ require 'securerandom'
 
 module ActiveRecord
   module ConnectionAdapters
-    class SQLiteAdapter
+    class SQLite3Adapter
       class QuotingTest < ActiveRecord::TestCase
         def setup
           @conn = Base.sqlite3_connection :database => ':memory:',
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index da7d99e2c5..19ef2f592d 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -228,7 +228,7 @@ class BasicsTest < ActiveRecord::TestCase
     )
 
     # For adapters which support microsecond resolution.
-    if current_adapter?(:PostgreSQLAdapter) || current_adapter?(:SQLiteAdapter)
+    if current_adapter?(:PostgreSQLAdapter) || current_adapter?(:SQLite3Adapter)
       assert_equal 11, Topic.find(1).written_on.sec
       assert_equal 223300, Topic.find(1).written_on.usec
       assert_equal 9900, Topic.find(2).written_on.usec
diff --git a/activerecord/test/cases/helper.rb b/activerecord/test/cases/helper.rb
index 5c3560a33b..345ae0b582 100644
--- a/activerecord/test/cases/helper.rb
+++ b/activerecord/test/cases/helper.rb
@@ -36,7 +36,7 @@ def current_adapter?(*types)
 end
 
 def in_memory_db?
-  current_adapter?(:SQLiteAdapter) &&
+  current_adapter?(:SQLite3Adapter) &&
   ActiveRecord::Base.connection_pool.spec.config[:database] == ":memory:"
 end
 
-- 
cgit v1.2.3


From a57b7842d0fcdcbcc567532d3a5c1f2628057a0d Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 27 Apr 2012 10:30:52 +0100
Subject: remove unnecessary test code

---
 activerecord/test/cases/named_scope_test.rb | 4 ----
 activerecord/test/models/topic.rb           | 6 +-----
 2 files changed, 1 insertion(+), 9 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/named_scope_test.rb b/activerecord/test/cases/named_scope_test.rb
index cc64afaa71..aa36a02982 100644
--- a/activerecord/test/cases/named_scope_test.rb
+++ b/activerecord/test/cases/named_scope_test.rb
@@ -70,10 +70,6 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert_equal Topic.replied.approved, Topic.replied.approved_as_string
   end
 
-  def test_scopes_can_be_specified_with_deep_hash_conditions
-    assert_equal Topic.replied.approved, Topic.replied.approved_as_hash_condition
-  end
-
   def test_scopes_are_composable
     assert_equal((approved = Topic.find(:all, :conditions => {:approved => true})), Topic.approved)
     assert_equal((replied = Topic.find(:all, :conditions => 'replies_count > 0')), Topic.replied)
diff --git a/activerecord/test/models/topic.rb b/activerecord/test/models/topic.rb
index ef9de9669c..079e403444 100644
--- a/activerecord/test/models/topic.rb
+++ b/activerecord/test/models/topic.rb
@@ -11,11 +11,7 @@ class Topic < ActiveRecord::Base
   scope :scope_with_lambda, lambda { scoped }
 
   scope :by_lifo, -> { where(:author_name => 'lifo') }
-
-  ActiveSupport::Deprecation.silence do
-    scope :approved_as_hash_condition, :conditions => {:topics => {:approved => true}}
-    scope :replied, :conditions => ['replies_count > 0']
-  end
+  scope :replied, -> { where 'replies_count > 0' }
 
   scope 'approved_as_string', -> { where(:approved => true) }
   scope :anonymous_extension, -> { scoped } do
-- 
cgit v1.2.3


From df6f971e3aedf8bb1ec318de95d7ce849e2c9c9e Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 27 Apr 2012 11:42:22 +0100
Subject: %s/find(:\(first\|last\|all\), \([^()]*\))/scoped(\2).\1/gcI amongst
 other things

---
 .../cases/adapters/mysql/reserved_word_test.rb     |   2 +-
 .../cases/adapters/mysql2/bind_parameter_test.rb   |   4 +-
 .../cases/adapters/mysql2/reserved_word_test.rb    |   2 +-
 .../test/cases/adapters/postgresql/hstore_test.rb  |   6 +-
 .../associations/belongs_to_associations_test.rb   |   8 +-
 .../associations/cascaded_eager_loading_test.rb    |  28 ++--
 .../associations/eager_load_nested_include_test.rb |   2 +-
 .../associations/eager_singularization_test.rb     |  14 +-
 activerecord/test/cases/associations/eager_test.rb | 158 +++++++++---------
 .../has_and_belongs_to_many_associations_test.rb   |  14 +-
 .../associations/has_many_associations_test.rb     | 114 ++++++-------
 .../associations/has_one_associations_test.rb      |   2 +-
 .../has_one_through_associations_test.rb           |  14 +-
 .../associations/inverse_associations_test.rb      |  18 +-
 .../test/cases/associations/join_model_test.rb     |  46 +++---
 activerecord/test/cases/associations_test.rb       |   4 +-
 activerecord/test/cases/attribute_methods_test.rb  |   8 +-
 .../test/cases/autosave_association_test.rb        |   2 +-
 activerecord/test/cases/base_test.rb               |  44 ++---
 activerecord/test/cases/finder_test.rb             | 183 ++++++---------------
 activerecord/test/cases/inheritance_test.rb        |  20 +--
 activerecord/test/cases/modules_test.rb            |   2 +-
 activerecord/test/cases/named_scope_test.rb        |  14 +-
 activerecord/test/cases/persistence_test.rb        |   2 +-
 activerecord/test/cases/relation_scoping_test.rb   |   8 +-
 activerecord/test/cases/relations_test.rb          |  11 +-
 activerecord/test/models/comment.rb                |   2 +-
 activerecord/test/models/developer.rb              |   8 +-
 activerecord/test/models/post.rb                   |   6 +-
 29 files changed, 332 insertions(+), 414 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/adapters/mysql/reserved_word_test.rb b/activerecord/test/cases/adapters/mysql/reserved_word_test.rb
index 292c7efebb..67a4112fc8 100644
--- a/activerecord/test/cases/adapters/mysql/reserved_word_test.rb
+++ b/activerecord/test/cases/adapters/mysql/reserved_word_test.rb
@@ -130,7 +130,7 @@ class MysqlReservedWordTest < ActiveRecord::TestCase
   end
 
   def test_associations_work_with_reserved_words
-    assert_nothing_raised { Select.find(:all, :include => [:groups]) }
+    assert_nothing_raised { Select.scoped(:include => [:groups]).all }
   end
 
   #the following functions were added to DRY test cases
diff --git a/activerecord/test/cases/adapters/mysql2/bind_parameter_test.rb b/activerecord/test/cases/adapters/mysql2/bind_parameter_test.rb
index cd9c1041dc..5e8065d80d 100644
--- a/activerecord/test/cases/adapters/mysql2/bind_parameter_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/bind_parameter_test.rb
@@ -9,7 +9,7 @@ module ActiveRecord
 
         def test_update_question_marks
           str       = "foo?bar"
-          x         = Topic.find :first
+          x         = Topic.first
           x.title   = str
           x.content = str
           x.save!
@@ -28,7 +28,7 @@ module ActiveRecord
 
         def test_update_null_bytes
           str       = "foo\0bar"
-          x         = Topic.find :first
+          x         = Topic.first
           x.title   = str
           x.content = str
           x.save!
diff --git a/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb b/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
index 3a9744e78f..7c3af5874b 100644
--- a/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
@@ -130,7 +130,7 @@ class MysqlReservedWordTest < ActiveRecord::TestCase
   end
 
   def test_associations_work_with_reserved_words
-    assert_nothing_raised { Select.find(:all, :include => [:groups]) }
+    assert_nothing_raised { Select.scoped(:include => [:groups]).all }
   end
 
   #the following functions were added to DRY test cases
diff --git a/activerecord/test/cases/adapters/postgresql/hstore_test.rb b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
index 05d38ec1f1..23bafde17b 100644
--- a/activerecord/test/cases/adapters/postgresql/hstore_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
@@ -90,7 +90,7 @@ class PostgresqlHstoreTest < ActiveRecord::TestCase
 
   def test_rewrite
     @connection.execute "insert into hstores (tags) VALUES ('1=>2')"
-    x = Hstore.find :first
+    x = Hstore.first
     x.tags = { '"a\'' => 'b' }
     assert x.save!
   end
@@ -98,13 +98,13 @@ class PostgresqlHstoreTest < ActiveRecord::TestCase
 
   def test_select
     @connection.execute "insert into hstores (tags) VALUES ('1=>2')"
-    x = Hstore.find :first
+    x = Hstore.first
     assert_equal({'1' => '2'}, x.tags)
   end
 
   def test_select_multikey
     @connection.execute "insert into hstores (tags) VALUES ('1=>2,2=>3')"
-    x = Hstore.find :first
+    x = Hstore.first
     assert_equal({'1' => '2', '2' => '3'}, x.tags)
   end
 
diff --git a/activerecord/test/cases/associations/belongs_to_associations_test.rb b/activerecord/test/cases/associations/belongs_to_associations_test.rb
index 0dd6b798d3..65a353fdaf 100644
--- a/activerecord/test/cases/associations/belongs_to_associations_test.rb
+++ b/activerecord/test/cases/associations/belongs_to_associations_test.rb
@@ -73,14 +73,14 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   def test_eager_loading_with_primary_key
     Firm.create("name" => "Apple")
     Client.create("name" => "Citibank", :firm_name => "Apple")
-    citibank_result = Client.find(:first, :conditions => {:name => "Citibank"}, :include => :firm_with_primary_key)
+    citibank_result = Client.scoped(:conditions => {:name => "Citibank"}, :include => :firm_with_primary_key).first
     assert citibank_result.association_cache.key?(:firm_with_primary_key)
   end
 
   def test_eager_loading_with_primary_key_as_symbol
     Firm.create("name" => "Apple")
     Client.create("name" => "Citibank", :firm_name => "Apple")
-    citibank_result = Client.find(:first, :conditions => {:name => "Citibank"}, :include => :firm_with_primary_key_symbols)
+    citibank_result = Client.scoped(:conditions => {:name => "Citibank"}, :include => :firm_with_primary_key_symbols).first
     assert citibank_result.association_cache.key?(:firm_with_primary_key_symbols)
   end
 
@@ -334,7 +334,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   def test_new_record_with_foreign_key_but_no_object
     c = Client.new("firm_id" => 1)
     # sometimes tests on Oracle fail if ORDER BY is not provided therefore add always :order with :first
-    assert_equal Firm.find(:first, :order => "id"), c.firm_with_basic_id
+    assert_equal Firm.scoped(:order => "id").first, c.firm_with_basic_id
   end
 
   def test_setting_foreign_key_after_nil_target_loaded
@@ -396,7 +396,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   def test_association_assignment_sticks
     post = Post.first
 
-    author1, author2 = Author.find(:all, :limit => 2)
+    author1, author2 = Author.scoped(:limit => 2).all
     assert_not_nil author1
     assert_not_nil author2
 
diff --git a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
index 6733f3e889..6ffb8cd2d2 100644
--- a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
+++ b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
@@ -16,7 +16,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
            :categorizations, :people, :categories, :edges, :vertices
 
   def test_eager_association_loading_with_cascaded_two_levels
-    authors = Author.find(:all, :include=>{:posts=>:comments}, :order=>"authors.id")
+    authors = Author.scoped(:include=>{:posts=>:comments}, :order=>"authors.id").all
     assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal 3, authors[1].posts.size
@@ -24,7 +24,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_and_one_level
-    authors = Author.find(:all, :include=>[{:posts=>:comments}, :categorizations], :order=>"authors.id")
+    authors = Author.scoped(:include=>[{:posts=>:comments}, :categorizations], :order=>"authors.id").all
     assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal 3, authors[1].posts.size
@@ -84,7 +84,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_with_two_has_many_associations
-    authors = Author.find(:all, :include=>{:posts=>[:comments, :categorizations]}, :order=>"authors.id")
+    authors = Author.scoped(:include=>{:posts=>[:comments, :categorizations]}, :order=>"authors.id").all
     assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal 3, authors[1].posts.size
@@ -92,7 +92,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_and_self_table_reference
-    authors = Author.find(:all, :include=>{:posts=>[:comments, :author]}, :order=>"authors.id")
+    authors = Author.scoped(:include=>{:posts=>[:comments, :author]}, :order=>"authors.id").all
     assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal authors(:david).name, authors[0].name
@@ -100,13 +100,13 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_with_condition
-    authors = Author.find(:all, :include=>{:posts=>:comments}, :conditions=>"authors.id=1", :order=>"authors.id")
+    authors = Author.scoped(:include=>{:posts=>:comments}, :conditions=>"authors.id=1", :order=>"authors.id").all
     assert_equal 1, authors.size
     assert_equal 5, authors[0].posts.size
   end
 
   def test_eager_association_loading_with_cascaded_three_levels_by_ping_pong
-    firms = Firm.find(:all, :include=>{:account=>{:firm=>:account}}, :order=>"companies.id")
+    firms = Firm.scoped(:include=>{:account=>{:firm=>:account}}, :order=>"companies.id").all
     assert_equal 2, firms.size
     assert_equal firms.first.account, firms.first.account.firm.account
     assert_equal companies(:first_firm).account, assert_no_queries { firms.first.account.firm.account }
@@ -114,7 +114,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_has_many_sti
-    topics = Topic.find(:all, :include => :replies, :order => 'topics.id')
+    topics = Topic.scoped(:include => :replies, :order => 'topics.id').all
     first, second, = topics(:first).replies.size, topics(:second).replies.size
     assert_no_queries do
       assert_equal first, topics[0].replies.size
@@ -127,7 +127,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
     silly.parent_id = 1
     assert silly.save
 
-    topics = Topic.find(:all, :include => :replies, :order => ['topics.id', 'replies_topics.id'])
+    topics = Topic.scoped(:include => :replies, :order => ['topics.id', 'replies_topics.id']).all
     assert_no_queries do
       assert_equal 2, topics[0].replies.size
       assert_equal 0, topics[1].replies.size
@@ -135,14 +135,14 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_belongs_to_sti
-    replies = Reply.find(:all, :include => :topic, :order => 'topics.id')
+    replies = Reply.scoped(:include => :topic, :order => 'topics.id').all
     assert replies.include?(topics(:second))
     assert !replies.include?(topics(:first))
     assert_equal topics(:first), assert_no_queries { replies.first.topic }
   end
 
   def test_eager_association_loading_with_multiple_stis_and_order
-    author = Author.find(:first, :include => { :posts => [ :special_comments , :very_special_comment ] }, :order => ['authors.name', 'comments.body', 'very_special_comments_posts.body'], :conditions => 'posts.id = 4')
+    author = Author.scoped(:include => { :posts => [ :special_comments , :very_special_comment ] }, :order => ['authors.name', 'comments.body', 'very_special_comments_posts.body'], :conditions => 'posts.id = 4').first
     assert_equal authors(:david), author
     assert_no_queries do
       author.posts.first.special_comments
@@ -151,7 +151,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_of_stis_with_multiple_references
-    authors = Author.find(:all, :include => { :posts => { :special_comments => { :post => [ :special_comments, :very_special_comment ] } } }, :order => 'comments.body, very_special_comments_posts.body', :conditions => 'posts.id = 4')
+    authors = Author.scoped(:include => { :posts => { :special_comments => { :post => [ :special_comments, :very_special_comment ] } } }, :order => 'comments.body, very_special_comments_posts.body', :conditions => 'posts.id = 4').all
     assert_equal [authors(:david)], authors
     assert_no_queries do
       authors.first.posts.first.special_comments.first.post.special_comments
@@ -160,7 +160,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_where_first_level_returns_nil
-    authors = Author.find(:all, :include => {:post_about_thinking => :comments}, :order => 'authors.id DESC')
+    authors = Author.scoped(:include => {:post_about_thinking => :comments}, :order => 'authors.id DESC').all
     assert_equal [authors(:bob), authors(:mary), authors(:david)], authors
     assert_no_queries do
       authors[2].post_about_thinking.comments.first
@@ -168,12 +168,12 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_recursive_cascading_four_levels_has_many_through
-    source = Vertex.find(:first, :include=>{:sinks=>{:sinks=>{:sinks=>:sinks}}}, :order => 'vertices.id')
+    source = Vertex.scoped(:include=>{:sinks=>{:sinks=>{:sinks=>:sinks}}}, :order => 'vertices.id').first
     assert_equal vertices(:vertex_4), assert_no_queries { source.sinks.first.sinks.first.sinks.first }
   end
 
   def test_eager_association_loading_with_recursive_cascading_four_levels_has_and_belongs_to_many
-    sink = Vertex.find(:first, :include=>{:sources=>{:sources=>{:sources=>:sources}}}, :order => 'vertices.id DESC')
+    sink = Vertex.scoped(:include=>{:sources=>{:sources=>{:sources=>:sources}}}, :order => 'vertices.id DESC').first
     assert_equal vertices(:vertex_1), assert_no_queries { sink.sources.first.sources.first.sources.first.sources.first }
   end
 end
diff --git a/activerecord/test/cases/associations/eager_load_nested_include_test.rb b/activerecord/test/cases/associations/eager_load_nested_include_test.rb
index 74e23c5765..b034f0fe56 100644
--- a/activerecord/test/cases/associations/eager_load_nested_include_test.rb
+++ b/activerecord/test/cases/associations/eager_load_nested_include_test.rb
@@ -93,7 +93,7 @@ class EagerLoadPolyAssocsTest < ActiveRecord::TestCase
 
   def test_include_query
     res = 0
-    res = ShapeExpression.find :all, :include => [ :shape, { :paint => :non_poly } ]
+    res = ShapeExpression.scoped(:include => [ :shape, { :paint => :non_poly } ]).all
     assert_equal NUM_SHAPE_EXPRESSIONS, res.size
     assert_queries(0) do
       res.each do |se|
diff --git a/activerecord/test/cases/associations/eager_singularization_test.rb b/activerecord/test/cases/associations/eager_singularization_test.rb
index 07d0b24613..1c635fcd96 100644
--- a/activerecord/test/cases/associations/eager_singularization_test.rb
+++ b/activerecord/test/cases/associations/eager_singularization_test.rb
@@ -103,43 +103,43 @@ class EagerSingularizationTest < ActiveRecord::TestCase
   def test_eager_no_extra_singularization_belongs_to
     return unless @have_tables
     assert_nothing_raised do
-      Virus.find(:all, :include => :octopus)
+      Virus.scoped(:include => :octopus).all
     end
   end
 
   def test_eager_no_extra_singularization_has_one
     return unless @have_tables
     assert_nothing_raised do
-      Octopus.find(:all, :include => :virus)
+      Octopus.scoped(:include => :virus).all
     end
   end
 
   def test_eager_no_extra_singularization_has_many
     return unless @have_tables
     assert_nothing_raised do
-      Bus.find(:all, :include => :passes)
+      Bus.scoped(:include => :passes).all
     end
   end
 
   def test_eager_no_extra_singularization_has_and_belongs_to_many
     return unless @have_tables
     assert_nothing_raised do
-      Crisis.find(:all, :include => :messes)
-      Mess.find(:all, :include => :crises)
+      Crisis.scoped(:include => :messes).all
+      Mess.scoped(:include => :crises).all
     end
   end
 
   def test_eager_no_extra_singularization_has_many_through_belongs_to
     return unless @have_tables
     assert_nothing_raised do
-      Crisis.find(:all, :include => :successes)
+      Crisis.scoped(:include => :successes).all
     end
   end
 
   def test_eager_no_extra_singularization_has_many_through_has_many
     return unless @have_tables
     assert_nothing_raised do
-      Crisis.find(:all, :include => :compresses)
+      Crisis.scoped(:include => :compresses).all
     end
   end
 end
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index 95ae158c93..172182e5bf 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -40,22 +40,22 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_loading_with_one_association
-    posts = Post.find(:all, :include => :comments)
+    posts = Post.scoped(:include => :comments).all
     post = posts.find { |p| p.id == 1 }
     assert_equal 2, post.comments.size
     assert post.comments.include?(comments(:greetings))
 
-    post = Post.find(:first, :include => :comments, :conditions => "posts.title = 'Welcome to the weblog'")
+    post = Post.scoped(:include => :comments, :conditions => "posts.title = 'Welcome to the weblog'").first
     assert_equal 2, post.comments.size
     assert post.comments.include?(comments(:greetings))
 
-    posts = Post.find(:all, :include => :last_comment)
+    posts = Post.scoped(:include => :last_comment).all
     post = posts.find { |p| p.id == 1 }
     assert_equal Post.find(1).last_comment, post.last_comment
   end
 
   def test_loading_with_one_association_with_non_preload
-    posts = Post.find(:all, :include => :last_comment, :order => 'comments.id DESC')
+    posts = Post.scoped(:include => :last_comment, :order => 'comments.id DESC').all
     post = posts.find { |p| p.id == 1 }
     assert_equal Post.find(1).last_comment, post.last_comment
   end
@@ -70,7 +70,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_with_ordering
-    list = Post.find(:all, :include => :comments, :order => "posts.id DESC")
+    list = Post.scoped(:include => :comments, :order => "posts.id DESC").all
     [:other_by_mary, :other_by_bob, :misc_by_mary, :misc_by_bob, :eager_other,
      :sti_habtm, :sti_post_and_comments, :sti_comments, :authorless, :thinking, :welcome
     ].each_with_index do |post, index|
@@ -84,14 +84,14 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_loading_with_multiple_associations
-    posts = Post.find(:all, :include => [ :comments, :author, :categories ], :order => "posts.id")
+    posts = Post.scoped(:include => [ :comments, :author, :categories ], :order => "posts.id").all
     assert_equal 2, posts.first.comments.size
     assert_equal 2, posts.first.categories.size
     assert posts.first.comments.include?(comments(:greetings))
   end
 
   def test_duplicate_middle_objects
-    comments = Comment.find :all, :conditions => 'post_id = 1', :include => [:post => :author]
+    comments = Comment.scoped(:conditions => 'post_id = 1', :include => [:post => :author]).all
     assert_no_queries do
       comments.each {|comment| comment.post.author.name}
     end
@@ -99,25 +99,25 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_preloading_has_many_in_multiple_queries_with_more_ids_than_database_can_handle
     Post.connection.expects(:in_clause_length).at_least_once.returns(5)
-    posts = Post.find(:all, :include=>:comments)
+    posts = Post.scoped(:include=>:comments).all
     assert_equal 11, posts.size
   end
 
   def test_preloading_has_many_in_one_queries_when_database_has_no_limit_on_ids_it_can_handle
     Post.connection.expects(:in_clause_length).at_least_once.returns(nil)
-    posts = Post.find(:all, :include=>:comments)
+    posts = Post.scoped(:include=>:comments).all
     assert_equal 11, posts.size
   end
 
   def test_preloading_habtm_in_multiple_queries_with_more_ids_than_database_can_handle
     Post.connection.expects(:in_clause_length).at_least_once.returns(5)
-    posts = Post.find(:all, :include=>:categories)
+    posts = Post.scoped(:include=>:categories).all
     assert_equal 11, posts.size
   end
 
   def test_preloading_habtm_in_one_queries_when_database_has_no_limit_on_ids_it_can_handle
     Post.connection.expects(:in_clause_length).at_least_once.returns(nil)
-    posts = Post.find(:all, :include=>:categories)
+    posts = Post.scoped(:include=>:categories).all
     assert_equal 11, posts.size
   end
 
@@ -154,8 +154,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
     popular_post.readers.create!(:person => people(:michael))
     popular_post.readers.create!(:person => people(:david))
 
-    readers = Reader.find(:all, :conditions => ["post_id = ?", popular_post.id],
-                                :include => {:post => :comments})
+    readers = Reader.scoped(:conditions => ["post_id = ?", popular_post.id],
+                                :include => {:post => :comments}).all
     readers.each do |reader|
       assert_equal [comment], reader.post.comments
     end
@@ -167,8 +167,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
     car_post.categories << categories(:technology)
 
     comment = car_post.comments.create!(:body => "hmm")
-    categories = Category.find(:all, :conditions => { 'posts.id' => car_post.id },
-                                 :include => {:posts => :comments})
+    categories = Category.scoped(:conditions => { 'posts.id' => car_post.id },
+                                 :include => {:posts => :comments}).all
     categories.each do |category|
       assert_equal [comment], category.posts[0].comments
     end
@@ -234,13 +234,13 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_loading_from_an_association
-    posts = authors(:david).posts.find(:all, :include => :comments, :order => "posts.id")
+    posts = authors(:david).posts.scoped(:include => :comments, :order => "posts.id").all
     assert_equal 2, posts.first.comments.size
   end
 
   def test_loading_from_an_association_that_has_a_hash_of_conditions
     assert_nothing_raised do
-      Author.find(:all, :include => :hello_posts_with_hash_conditions)
+      Author.scoped(:include => :hello_posts_with_hash_conditions).all
     end
     assert !Author.find(authors(:david).id, :include => :hello_posts_with_hash_conditions).hello_posts.empty?
   end
@@ -300,12 +300,12 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_belongs_to_and_foreign_keys
-    pets = Pet.find(:all, :include => :owner)
+    pets = Pet.scoped(:include => :owner).all
     assert_equal 3, pets.length
   end
 
   def test_eager_association_loading_with_belongs_to
-    comments = Comment.find(:all, :include => :post)
+    comments = Comment.scoped(:include => :post).all
     assert_equal 11, comments.length
     titles = comments.map { |c| c.post.title }
     assert titles.include?(posts(:welcome).title)
@@ -313,31 +313,31 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit
-    comments = Comment.find(:all, :include => :post, :limit => 5, :order => 'comments.id')
+    comments = Comment.scoped(:include => :post, :limit => 5, :order => 'comments.id').all
     assert_equal 5, comments.length
     assert_equal [1,2,3,5,6], comments.collect { |c| c.id }
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_conditions
-    comments = Comment.find(:all, :include => :post, :conditions => 'post_id = 4', :limit => 3, :order => 'comments.id')
+    comments = Comment.scoped(:include => :post, :conditions => 'post_id = 4', :limit => 3, :order => 'comments.id').all
     assert_equal 3, comments.length
     assert_equal [5,6,7], comments.collect { |c| c.id }
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_offset
-    comments = Comment.find(:all, :include => :post, :limit => 3, :offset => 2, :order => 'comments.id')
+    comments = Comment.scoped(:include => :post, :limit => 3, :offset => 2, :order => 'comments.id').all
     assert_equal 3, comments.length
     assert_equal [3,5,6], comments.collect { |c| c.id }
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_conditions
-    comments = Comment.find(:all, :include => :post, :conditions => 'post_id = 4', :limit => 3, :offset => 1, :order => 'comments.id')
+    comments = Comment.scoped(:include => :post, :conditions => 'post_id = 4', :limit => 3, :offset => 1, :order => 'comments.id').all
     assert_equal 3, comments.length
     assert_equal [6,7,8], comments.collect { |c| c.id }
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_conditions_array
-    comments = Comment.find(:all, :include => :post, :conditions => ['post_id = ?',4], :limit => 3, :offset => 1, :order => 'comments.id')
+    comments = Comment.scoped(:include => :post, :conditions => ['post_id = ?',4], :limit => 3, :offset => 1, :order => 'comments.id').all
     assert_equal 3, comments.length
     assert_equal [6,7,8], comments.collect { |c| c.id }
   end
@@ -345,7 +345,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_eager_association_loading_with_belongs_to_and_conditions_string_with_unquoted_table_name
     assert_nothing_raised do
       ActiveSupport::Deprecation.silence do
-        Comment.find(:all, :include => :post, :conditions => ['posts.id = ?',4])
+        Comment.scoped(:include => :post, :conditions => ['posts.id = ?',4]).all
       end
     end
   end
@@ -353,7 +353,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_eager_association_loading_with_belongs_to_and_conditions_hash
     comments = []
     assert_nothing_raised do
-      comments = Comment.find(:all, :include => :post, :conditions => {:posts => {:id => 4}}, :limit => 3, :order => 'comments.id')
+      comments = Comment.scoped(:include => :post, :conditions => {:posts => {:id => 4}}, :limit => 3, :order => 'comments.id').all
     end
     assert_equal 3, comments.length
     assert_equal [5,6,7], comments.collect { |c| c.id }
@@ -366,14 +366,14 @@ class EagerAssociationTest < ActiveRecord::TestCase
     quoted_posts_id= Comment.connection.quote_table_name('posts') + '.' + Comment.connection.quote_column_name('id')
     assert_nothing_raised do
       ActiveSupport::Deprecation.silence do
-        Comment.find(:all, :include => :post, :conditions => ["#{quoted_posts_id} = ?",4])
+        Comment.scoped(:include => :post, :conditions => ["#{quoted_posts_id} = ?",4]).all
       end
     end
   end
 
   def test_eager_association_loading_with_belongs_to_and_order_string_with_unquoted_table_name
     assert_nothing_raised do
-      Comment.find(:all, :include => :post, :order => 'posts.id')
+      Comment.scoped(:include => :post, :order => 'posts.id').all
     end
   end
 
@@ -381,25 +381,25 @@ class EagerAssociationTest < ActiveRecord::TestCase
     quoted_posts_id= Comment.connection.quote_table_name('posts') + '.' + Comment.connection.quote_column_name('id')
     assert_nothing_raised do
       ActiveSupport::Deprecation.silence do
-        Comment.find(:all, :include => :post, :order => quoted_posts_id)
+        Comment.scoped(:include => :post, :order => quoted_posts_id).all
       end
     end
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_multiple_associations
-    posts = Post.find(:all, :include => [:author, :very_special_comment], :limit => 1, :order => 'posts.id')
+    posts = Post.scoped(:include => [:author, :very_special_comment], :limit => 1, :order => 'posts.id').all
     assert_equal 1, posts.length
     assert_equal [1], posts.collect { |p| p.id }
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_multiple_associations
-    posts = Post.find(:all, :include => [:author, :very_special_comment], :limit => 1, :offset => 1, :order => 'posts.id')
+    posts = Post.scoped(:include => [:author, :very_special_comment], :limit => 1, :offset => 1, :order => 'posts.id').all
     assert_equal 1, posts.length
     assert_equal [2], posts.collect { |p| p.id }
   end
 
   def test_eager_association_loading_with_belongs_to_inferred_foreign_key_from_association_name
-    author_favorite = AuthorFavorite.find(:first, :include => :favorite_author)
+    author_favorite = AuthorFavorite.scoped(:include => :favorite_author).first
     assert_equal authors(:mary), assert_no_queries { author_favorite.favorite_author }
   end
 
@@ -458,14 +458,14 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_explicit_join
-    posts = Post.find(:all, :include => :comments, :joins => "INNER JOIN authors ON posts.author_id = authors.id AND authors.name = 'Mary'", :limit => 1, :order => 'author_id')
+    posts = Post.scoped(:include => :comments, :joins => "INNER JOIN authors ON posts.author_id = authors.id AND authors.name = 'Mary'", :limit => 1, :order => 'author_id').all
     assert_equal 1, posts.length
   end
 
   def test_eager_with_has_many_through
-    posts_with_comments = people(:michael).posts.find(:all, :include => :comments, :order => 'posts.id')
-    posts_with_author = people(:michael).posts.find(:all, :include => :author, :order => 'posts.id')
-    posts_with_comments_and_author = people(:michael).posts.find(:all, :include => [ :comments, :author ], :order => 'posts.id')
+    posts_with_comments = people(:michael).posts.scoped(:include => :comments, :order => 'posts.id').all
+    posts_with_author = people(:michael).posts.scoped(:include => :author, :order => 'posts.id').all
+    posts_with_comments_and_author = people(:michael).posts.scoped(:include => [ :comments, :author ], :order => 'posts.id').all
     assert_equal 2, posts_with_comments.inject(0) { |sum, post| sum += post.comments.size }
     assert_equal authors(:david), assert_no_queries { posts_with_author.first.author }
     assert_equal authors(:david), assert_no_queries { posts_with_comments_and_author.first.author }
@@ -476,24 +476,24 @@ class EagerAssociationTest < ActiveRecord::TestCase
     Post.create!(:author => author, :title => "TITLE", :body => "BODY")
     author.author_favorites.create(:favorite_author_id => 1)
     author.author_favorites.create(:favorite_author_id => 2)
-    posts_with_author_favorites = author.posts.find(:all, :include => :author_favorites)
+    posts_with_author_favorites = author.posts.scoped(:include => :author_favorites).all
     assert_no_queries { posts_with_author_favorites.first.author_favorites.first.author_id }
   end
 
   def test_eager_with_has_many_through_an_sti_join_model
-    author = Author.find(:first, :include => :special_post_comments, :order => 'authors.id')
+    author = Author.scoped(:include => :special_post_comments, :order => 'authors.id').first
     assert_equal [comments(:does_it_hurt)], assert_no_queries { author.special_post_comments }
   end
 
   def test_eager_with_has_many_through_an_sti_join_model_with_conditions_on_both
-    author = Author.find(:first, :include => :special_nonexistant_post_comments, :order => 'authors.id')
+    author = Author.scoped(:include => :special_nonexistant_post_comments, :order => 'authors.id').first
     assert_equal [], author.special_nonexistant_post_comments
   end
 
   def test_eager_with_has_many_through_join_model_with_conditions
-    assert_equal Author.find(:first, :include => :hello_post_comments,
-                             :order => 'authors.id').hello_post_comments.sort_by(&:id),
-                 Author.find(:first, :order => 'authors.id').hello_post_comments.sort_by(&:id)
+    assert_equal Author.scoped(:include => :hello_post_comments,
+                             :order => 'authors.id').first.hello_post_comments.sort_by(&:id),
+                 Author.scoped(:order => 'authors.id').first.hello_post_comments.sort_by(&:id)
   end
 
   def test_eager_with_has_many_through_join_model_with_conditions_on_top_level
@@ -520,16 +520,16 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_has_many_and_limit
-    posts = Post.find(:all, :order => 'posts.id asc', :include => [ :author, :comments ], :limit => 2)
+    posts = Post.scoped(:order => 'posts.id asc', :include => [ :author, :comments ], :limit => 2).all
     assert_equal 2, posts.size
     assert_equal 3, posts.inject(0) { |sum, post| sum += post.comments.size }
   end
 
   def test_eager_with_has_many_and_limit_and_conditions
     if current_adapter?(:OpenBaseAdapter)
-      posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :conditions => "FETCHBLOB(posts.body) = 'hello'", :order => "posts.id")
+      posts = Post.scoped(:include => [ :author, :comments ], :limit => 2, :conditions => "FETCHBLOB(posts.body) = 'hello'", :order => "posts.id").all
     else
-      posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :conditions => "posts.body = 'hello'", :order => "posts.id")
+      posts = Post.scoped(:include => [ :author, :comments ], :limit => 2, :conditions => "posts.body = 'hello'", :order => "posts.id").all
     end
     assert_equal 2, posts.size
     assert_equal [4,5], posts.collect { |p| p.id }
@@ -537,9 +537,9 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_with_has_many_and_limit_and_conditions_array
     if current_adapter?(:OpenBaseAdapter)
-      posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :conditions => [ "FETCHBLOB(posts.body) = ?", 'hello' ], :order => "posts.id")
+      posts = Post.scoped(:include => [ :author, :comments ], :limit => 2, :conditions => [ "FETCHBLOB(posts.body) = ?", 'hello' ], :order => "posts.id").all
     else
-      posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :conditions => [ "posts.body = ?", 'hello' ], :order => "posts.id")
+      posts = Post.scoped(:include => [ :author, :comments ], :limit => 2, :conditions => [ "posts.body = ?", 'hello' ], :order => "posts.id").all
     end
     assert_equal 2, posts.size
     assert_equal [4,5], posts.collect { |p| p.id }
@@ -547,7 +547,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_with_has_many_and_limit_and_conditions_array_on_the_eagers
     posts = ActiveSupport::Deprecation.silence do
-      Post.find(:all, :include => [ :author, :comments ], :limit => 2, :conditions => [ "authors.name = ?", 'David' ])
+      Post.scoped(:include => [ :author, :comments ], :limit => 2, :conditions => [ "authors.name = ?", 'David' ]).all
     end
     assert_equal 2, posts.size
 
@@ -558,23 +558,23 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_has_many_and_limit_and_high_offset
-    posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :offset => 10, :conditions => { 'authors.name' => 'David' })
+    posts = Post.scoped(:include => [ :author, :comments ], :limit => 2, :offset => 10, :conditions => { 'authors.name' => 'David' }).all
     assert_equal 0, posts.size
   end
 
   def test_eager_with_has_many_and_limit_and_high_offset_and_multiple_array_conditions
     assert_queries(1) do
       posts = Post.references(:authors, :comments).
-        find(:all, :include => [ :author, :comments ], :limit => 2, :offset => 10,
-          :conditions => [ "authors.name = ? and comments.body = ?", 'David', 'go crazy' ])
+        scoped(:include => [ :author, :comments ], :limit => 2, :offset => 10,
+          :conditions => [ "authors.name = ? and comments.body = ?", 'David', 'go crazy' ]).all
       assert_equal 0, posts.size
     end
   end
 
   def test_eager_with_has_many_and_limit_and_high_offset_and_multiple_hash_conditions
     assert_queries(1) do
-      posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :offset => 10,
-        :conditions => { 'authors.name' => 'David', 'comments.body' => 'go crazy' })
+      posts = Post.scoped(:include => [ :author, :comments ], :limit => 2, :offset => 10,
+        :conditions => { 'authors.name' => 'David', 'comments.body' => 'go crazy' }).all
       assert_equal 0, posts.size
     end
   end
@@ -602,7 +602,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_has_and_belongs_to_many_and_limit
-    posts = Post.find(:all, :include => :categories, :order => "posts.id", :limit => 3)
+    posts = Post.scoped(:include => :categories, :order => "posts.id", :limit => 3).all
     assert_equal 3, posts.size
     assert_equal 2, posts[0].categories.size
     assert_equal 1, posts[1].categories.size
@@ -668,7 +668,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_habtm
-    posts = Post.find(:all, :include => :categories, :order => "posts.id")
+    posts = Post.scoped(:include => :categories, :order => "posts.id").all
     assert_equal 2, posts[0].categories.size
     assert_equal 1, posts[1].categories.size
     assert_equal 0, posts[2].categories.size
@@ -677,7 +677,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_inheritance
-    SpecialPost.find(:all, :include => [ :comments ])
+    SpecialPost.scoped(:include => [ :comments ]).all
   end
 
   def test_eager_has_one_with_association_inheritance
@@ -702,8 +702,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_with_has_one_dependent_does_not_destroy_dependent
     assert_not_nil companies(:first_firm).account
-    f = Firm.find(:first, :include => :account,
-            :conditions => ["companies.name = ?", "37signals"])
+    f = Firm.scoped(:include => :account,
+            :conditions => ["companies.name = ?", "37signals"]).first
     assert_not_nil f.account
     assert_equal companies(:first_firm, :reload).account, f.account
   end
@@ -771,7 +771,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def find_all_ordered(className, include=nil)
-    className.find(:all, :order=>"#{className.table_name}.#{className.primary_key}", :include=>include)
+    className.scoped(:order=>"#{className.table_name}.#{className.primary_key}", :include=>include).all
   end
 
   def test_limited_eager_with_order
@@ -881,13 +881,13 @@ class EagerAssociationTest < ActiveRecord::TestCase
     end
   end
   def test_eager_with_valid_association_as_string_not_symbol
-    assert_nothing_raised { Post.find(:all, :include => 'comments') }
+    assert_nothing_raised { Post.scoped(:include => 'comments').all }
   end
 
   def test_eager_with_floating_point_numbers
     assert_queries(2) do
       # Before changes, the floating point numbers will be interpreted as table names and will cause this to run in one query
-      Comment.find :all, :conditions => "123.456 = 123.456", :include => :post
+      Comment.scoped(:conditions => "123.456 = 123.456", :include => :post).all
     end
   end
 
@@ -941,21 +941,21 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_load_with_sti_sharing_association
     assert_queries(2) do #should not do 1 query per subclass
-      Comment.find :all, :include => :post
+      Comment.includes(:post).all
     end
   end
 
   def test_conditions_on_join_table_with_include_and_limit
-    assert_equal 3, Developer.find(:all, :include => 'projects', :conditions => { 'developers_projects.access_level' => 1 }, :limit => 5).size
+    assert_equal 3, Developer.scoped(:include => 'projects', :conditions => { 'developers_projects.access_level' => 1 }, :limit => 5).all.size
   end
 
   def test_order_on_join_table_with_include_and_limit
-    assert_equal 5, Developer.find(:all, :include => 'projects', :order => 'developers_projects.joined_on DESC', :limit => 5).size
+    assert_equal 5, Developer.scoped(:include => 'projects', :order => 'developers_projects.joined_on DESC', :limit => 5).all.size
   end
 
   def test_eager_loading_with_order_on_joined_table_preloads
     posts = assert_queries(2) do
-      Post.find(:all, :joins => :comments, :include => :author, :order => 'comments.id DESC')
+      Post.scoped(:joins => :comments, :include => :author, :order => 'comments.id DESC').all
     end
     assert_equal posts(:eager_other), posts[1]
     assert_equal authors(:mary), assert_no_queries { posts[1].author}
@@ -963,24 +963,24 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_loading_with_conditions_on_joined_table_preloads
     posts = assert_queries(2) do
-      Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => [:comments], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
+      Post.scoped(:select => 'distinct posts.*', :include => :author, :joins => [:comments], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id').all
     end
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author}
 
     posts = assert_queries(2) do
-      Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => [:comments], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
+      Post.scoped(:select => 'distinct posts.*', :include => :author, :joins => [:comments], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id').all
     end
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author}
 
     posts = assert_queries(2) do
-      Post.find(:all, :include => :author, :joins => {:taggings => :tag}, :conditions => "tags.name = 'General'", :order => 'posts.id')
+      Post.scoped(:include => :author, :joins => {:taggings => :tag}, :conditions => "tags.name = 'General'", :order => 'posts.id').all
     end
     assert_equal posts(:welcome, :thinking), posts
 
     posts = assert_queries(2) do
-      Post.find(:all, :include => :author, :joins => {:taggings => {:tag => :taggings}}, :conditions => "taggings_tags.super_tag_id=2", :order => 'posts.id')
+      Post.scoped(:include => :author, :joins => {:taggings => {:tag => :taggings}}, :conditions => "taggings_tags.super_tag_id=2", :order => 'posts.id').all
     end
     assert_equal posts(:welcome, :thinking), posts
 
@@ -988,13 +988,13 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_loading_with_conditions_on_string_joined_table_preloads
     posts = assert_queries(2) do
-      Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => "INNER JOIN comments on comments.post_id = posts.id", :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
+      Post.scoped(:select => 'distinct posts.*', :include => :author, :joins => "INNER JOIN comments on comments.post_id = posts.id", :conditions => "comments.body like 'Thank you%'", :order => 'posts.id').all
     end
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author}
 
     posts = assert_queries(2) do
-      Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => ["INNER JOIN comments on comments.post_id = posts.id"], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
+      Post.scoped(:select => 'distinct posts.*', :include => :author, :joins => ["INNER JOIN comments on comments.post_id = posts.id"], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id').all
     end
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author}
@@ -1003,7 +1003,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_loading_with_select_on_joined_table_preloads
     posts = assert_queries(2) do
-      Post.find(:all, :select => 'posts.*, authors.name as author_name', :include => :comments, :joins => :author, :order => 'posts.id')
+      Post.scoped(:select => 'posts.*, authors.name as author_name', :include => :comments, :joins => :author, :order => 'posts.id').all
     end
     assert_equal 'David', posts[0].author_name
     assert_equal posts(:welcome).comments, assert_no_queries { posts[0].comments}
@@ -1013,14 +1013,14 @@ class EagerAssociationTest < ActiveRecord::TestCase
     Author.columns
 
     authors = assert_queries(2) do
-      Author.find(:all, :include => :author_address, :joins => :comments, :conditions => "posts.title like 'Welcome%'")
+      Author.scoped(:include => :author_address, :joins => :comments, :conditions => "posts.title like 'Welcome%'").all
     end
     assert_equal authors(:david), authors[0]
     assert_equal author_addresses(:david_address), authors[0].author_address
   end
 
   def test_preload_belongs_to_uses_exclusive_scope
-    people = Person.males.find(:all, :include => :primary_contact)
+    people = Person.males.scoped(:include => :primary_contact).all
     assert_not_equal people.length, 0
     people.each do |person|
       assert_no_queries {assert_not_nil person.primary_contact}
@@ -1029,7 +1029,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_preload_has_many_uses_exclusive_scope
-    people = Person.males.find :all, :include => :agents
+    people = Person.males.includes(:agents).all
     people.each do |person|
       assert_equal Person.find(person.id).agents, person.agents
     end
@@ -1037,7 +1037,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_preload_has_many_using_primary_key
     expected = Firm.first.clients_using_primary_key.to_a
-    firm = Firm.find :first, :include => :clients_using_primary_key
+    firm = Firm.includes(:clients_using_primary_key).first
     assert_no_queries do
       assert_equal expected, firm.clients_using_primary_key
     end
@@ -1058,7 +1058,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_preload_has_one_using_primary_key
     expected = accounts(:signals37)
-    firm = Firm.find :first, :include => :account_using_primary_key, :order => 'companies.id'
+    firm = Firm.scoped(:include => :account_using_primary_key, :order => 'companies.id').first
     assert_no_queries do
       assert_equal expected, firm.account_using_primary_key
     end
@@ -1066,7 +1066,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_include_has_one_using_primary_key
     expected = accounts(:signals37)
-    firm = Firm.find(:all, :include => :account_using_primary_key, :order => 'accounts.id').detect {|f| f.id == 1}
+    firm = Firm.scoped(:include => :account_using_primary_key, :order => 'accounts.id').all.detect {|f| f.id == 1}
     assert_no_queries do
       assert_equal expected, firm.account_using_primary_key
     end
@@ -1130,7 +1130,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_deep_including_through_habtm
-    posts = Post.find(:all, :include => {:categories => :categorizations}, :order => "posts.id")
+    posts = Post.scoped(:include => {:categories => :categorizations}, :order => "posts.id").all
     assert_no_queries { assert_equal 2, posts[0].categories[0].categorizations.length }
     assert_no_queries { assert_equal 1, posts[0].categories[1].categorizations.length }
     assert_no_queries { assert_equal 2, posts[1].categories[0].categorizations.length }
diff --git a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
index 63799a7224..15f10285d1 100644
--- a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
@@ -549,14 +549,14 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_find_with_merged_options
     assert_equal 1, projects(:active_record).limited_developers.size
     assert_equal 1, projects(:active_record).limited_developers.all.size
-    assert_equal 3, projects(:active_record).limited_developers.find(:all, :limit => nil).size
+    assert_equal 3, projects(:active_record).limited_developers.scoped(:limit => nil).all.size
   end
 
   def test_dynamic_find_should_respect_association_order
     # Developers are ordered 'name DESC, id DESC'
     high_id_jamis = projects(:active_record).developers.create(:name => 'Jamis')
 
-    assert_equal high_id_jamis, projects(:active_record).developers.find(:first, :conditions => "name = 'Jamis'")
+    assert_equal high_id_jamis, projects(:active_record).developers.scoped(:conditions => "name = 'Jamis'").first
     assert_equal high_id_jamis, projects(:active_record).developers.find_by_name('Jamis')
   end
 
@@ -566,7 +566,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     middle_id_jamis = developers(:poor_jamis)
     high_id_jamis = projects(:active_record).developers.create(:name => 'Jamis')
 
-    assert_equal [high_id_jamis, middle_id_jamis, low_id_jamis], projects(:active_record).developers.find(:all, :conditions => "name = 'Jamis'")
+    assert_equal [high_id_jamis, middle_id_jamis, low_id_jamis], projects(:active_record).developers.scoped(:conditions => "name = 'Jamis'").all
     assert_equal [high_id_jamis, middle_id_jamis, low_id_jamis], projects(:active_record).developers.find_all_by_name('Jamis')
   end
 
@@ -576,12 +576,12 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_dynamic_find_all_should_respect_association_limit
-    assert_equal 1, projects(:active_record).limited_developers.find(:all, :conditions => "name = 'Jamis'").length
+    assert_equal 1, projects(:active_record).limited_developers.scoped(:conditions => "name = 'Jamis'").all.length
     assert_equal 1, projects(:active_record).limited_developers.find_all_by_name('Jamis').length
   end
 
   def test_dynamic_find_all_order_should_override_association_limit
-    assert_equal 2, projects(:active_record).limited_developers.find(:all, :conditions => "name = 'Jamis'", :limit => 9_000).length
+    assert_equal 2, projects(:active_record).limited_developers.scoped(:conditions => "name = 'Jamis'", :limit => 9_000).all.length
     assert_equal 2, projects(:active_record).limited_developers.find_all_by_name('Jamis', :limit => 9_000).length
   end
 
@@ -705,8 +705,8 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_find_grouped
-    all_posts_from_category1 = Post.find(:all, :conditions => "category_id = 1", :joins => :categories)
-    grouped_posts_of_category1 = Post.find(:all, :conditions => "category_id = 1", :group => "author_id", :select => 'count(posts.id) as posts_count', :joins => :categories)
+    all_posts_from_category1 = Post.scoped(:conditions => "category_id = 1", :joins => :categories).all
+    grouped_posts_of_category1 = Post.scoped(:conditions => "category_id = 1", :group => "author_id", :select => 'count(posts.id) as posts_count', :joins => :categories).all
     assert_equal 5, all_posts_from_category1.size
     assert_equal 2, grouped_posts_of_category1.size
   end
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index f10d3b2889..4b22746430 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -242,19 +242,19 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   # sometimes tests on Oracle fail if ORDER BY is not provided therefore add always :order with :first
   def test_counting_with_counter_sql
-    assert_equal 2, Firm.find(:first, :order => "id").clients.count
+    assert_equal 2, Firm.scoped(:order => "id").first.clients.count
   end
 
   def test_counting
-    assert_equal 2, Firm.find(:first, :order => "id").plain_clients.count
+    assert_equal 2, Firm.scoped(:order => "id").first.plain_clients.count
   end
 
   def test_counting_with_single_hash
-    assert_equal 1, Firm.find(:first, :order => "id").plain_clients.where(:name => "Microsoft").count
+    assert_equal 1, Firm.scoped(:order => "id").first.plain_clients.where(:name => "Microsoft").count
   end
 
   def test_counting_with_column_name_and_hash
-    assert_equal 2, Firm.find(:first, :order => "id").plain_clients.count(:name)
+    assert_equal 2, Firm.scoped(:order => "id").first.plain_clients.count(:name)
   end
 
   def test_counting_with_association_limit
@@ -264,7 +264,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_finding
-    assert_equal 2, Firm.find(:first, :order => "id").clients.length
+    assert_equal 2, Firm.scoped(:order => "id").first.clients.length
   end
 
   def test_finding_array_compatibility
@@ -273,14 +273,14 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_find_with_blank_conditions
     [[], {}, nil, ""].each do |blank|
-      assert_equal 2, Firm.find(:first, :order => "id").clients.find(:all, :conditions => blank).size
+      assert_equal 2, Firm.scoped(:order => "id").first.clients.scoped(:conditions => blank).all.size
     end
   end
 
   def test_find_many_with_merged_options
     assert_equal 1, companies(:first_firm).limited_clients.size
     assert_equal 1, companies(:first_firm).limited_clients.all.size
-    assert_equal 2, companies(:first_firm).limited_clients.find(:all, :limit => nil).size
+    assert_equal 2, companies(:first_firm).limited_clients.scoped(:limit => nil).all.size
   end
 
   def test_find_should_append_to_association_order
@@ -293,22 +293,22 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_dynamic_find_should_respect_association_order
-    assert_equal companies(:second_client), companies(:first_firm).clients_sorted_desc.find(:first, :conditions => "type = 'Client'")
+    assert_equal companies(:second_client), companies(:first_firm).clients_sorted_desc.scoped(:conditions => "type = 'Client'").first
     assert_equal companies(:second_client), companies(:first_firm).clients_sorted_desc.find_by_type('Client')
   end
 
   def test_dynamic_find_all_should_respect_association_order
-    assert_equal [companies(:second_client), companies(:first_client)], companies(:first_firm).clients_sorted_desc.find(:all, :conditions => "type = 'Client'")
+    assert_equal [companies(:second_client), companies(:first_client)], companies(:first_firm).clients_sorted_desc.scoped(:conditions => "type = 'Client'").all
     assert_equal [companies(:second_client), companies(:first_client)], companies(:first_firm).clients_sorted_desc.find_all_by_type('Client')
   end
 
   def test_dynamic_find_all_should_respect_association_limit
-    assert_equal 1, companies(:first_firm).limited_clients.find(:all, :conditions => "type = 'Client'").length
+    assert_equal 1, companies(:first_firm).limited_clients.scoped(:conditions => "type = 'Client'").all.length
     assert_equal 1, companies(:first_firm).limited_clients.find_all_by_type('Client').length
   end
 
   def test_dynamic_find_all_limit_should_override_association_limit
-    assert_equal 2, companies(:first_firm).limited_clients.find(:all, :conditions => "type = 'Client'", :limit => 9_000).length
+    assert_equal 2, companies(:first_firm).limited_clients.scoped(:conditions => "type = 'Client'", :limit => 9_000).all.length
     assert_equal 2, companies(:first_firm).limited_clients.find_all_by_type('Client', :limit => 9_000).length
   end
 
@@ -328,59 +328,59 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_triple_equality
     # sometimes tests on Oracle fail if ORDER BY is not provided therefore add always :order with :first
-    assert !(Array === Firm.find(:first, :order => "id").clients)
-    assert Firm.find(:first, :order => "id").clients === Array
+    assert !(Array === Firm.scoped(:order => "id").first.clients)
+    assert Firm.scoped(:order => "id").first.clients === Array
   end
 
   def test_finding_default_orders
-    assert_equal "Summit", Firm.find(:first, :order => "id").clients.first.name
+    assert_equal "Summit", Firm.scoped(:order => "id").first.clients.first.name
   end
 
   def test_finding_with_different_class_name_and_order
-    assert_equal "Microsoft", Firm.find(:first, :order => "id").clients_sorted_desc.first.name
+    assert_equal "Microsoft", Firm.scoped(:order => "id").first.clients_sorted_desc.first.name
   end
 
   def test_finding_with_foreign_key
-    assert_equal "Microsoft", Firm.find(:first, :order => "id").clients_of_firm.first.name
+    assert_equal "Microsoft", Firm.scoped(:order => "id").first.clients_of_firm.first.name
   end
 
   def test_finding_with_condition
-    assert_equal "Microsoft", Firm.find(:first, :order => "id").clients_like_ms.first.name
+    assert_equal "Microsoft", Firm.scoped(:order => "id").first.clients_like_ms.first.name
   end
 
   def test_finding_with_condition_hash
-    assert_equal "Microsoft", Firm.find(:first, :order => "id").clients_like_ms_with_hash_conditions.first.name
+    assert_equal "Microsoft", Firm.scoped(:order => "id").first.clients_like_ms_with_hash_conditions.first.name
   end
 
   def test_finding_using_primary_key
-    assert_equal "Summit", Firm.find(:first, :order => "id").clients_using_primary_key.first.name
+    assert_equal "Summit", Firm.scoped(:order => "id").first.clients_using_primary_key.first.name
   end
 
   def test_finding_using_sql
-    firm = Firm.find(:first, :order => "id")
+    firm = Firm.scoped(:order => "id").first
     first_client = firm.clients_using_sql.first
     assert_not_nil first_client
     assert_equal "Microsoft", first_client.name
     assert_equal 1, firm.clients_using_sql.size
-    assert_equal 1, Firm.find(:first, :order => "id").clients_using_sql.size
+    assert_equal 1, Firm.scoped(:order => "id").first.clients_using_sql.size
   end
 
   def test_finding_using_sql_take_into_account_only_uniq_ids
-    firm = Firm.find(:first, :order => "id")
+    firm = Firm.scoped(:order => "id").first
     client = firm.clients_using_sql.first
     assert_equal client, firm.clients_using_sql.find(client.id, client.id)
     assert_equal client, firm.clients_using_sql.find(client.id, client.id.to_s)
   end
 
   def test_counting_using_sql
-    assert_equal 1, Firm.find(:first, :order => "id").clients_using_counter_sql.size
-    assert Firm.find(:first, :order => "id").clients_using_counter_sql.any?
-    assert_equal 0, Firm.find(:first, :order => "id").clients_using_zero_counter_sql.size
-    assert !Firm.find(:first, :order => "id").clients_using_zero_counter_sql.any?
+    assert_equal 1, Firm.scoped(:order => "id").first.clients_using_counter_sql.size
+    assert Firm.scoped(:order => "id").first.clients_using_counter_sql.any?
+    assert_equal 0, Firm.scoped(:order => "id").first.clients_using_zero_counter_sql.size
+    assert !Firm.scoped(:order => "id").first.clients_using_zero_counter_sql.any?
   end
 
   def test_counting_non_existant_items_using_sql
-    assert_equal 0, Firm.find(:first, :order => "id").no_clients_using_counter_sql.size
+    assert_equal 0, Firm.scoped(:order => "id").first.no_clients_using_counter_sql.size
   end
 
   def test_counting_using_finder_sql
@@ -395,7 +395,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_find_ids
-    firm = Firm.find(:first, :order => "id")
+    firm = Firm.scoped(:order => "id").first
 
     assert_raise(ActiveRecord::RecordNotFound) { firm.clients.find }
 
@@ -415,7 +415,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_find_string_ids_when_using_finder_sql
-    firm = Firm.find(:first, :order => "id")
+    firm = Firm.scoped(:order => "id").first
 
     client = firm.clients_using_finder_sql.find("2")
     assert_kind_of Client, client
@@ -431,9 +431,9 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_find_all
-    firm = Firm.find(:first, :order => "id")
-    assert_equal 2, firm.clients.find(:all, :conditions => "#{QUOTED_TYPE} = 'Client'").length
-    assert_equal 1, firm.clients.find(:all, :conditions => "name = 'Summit'").length
+    firm = Firm.scoped(:order => "id").first
+    assert_equal 2, firm.clients.scoped(:conditions => "#{QUOTED_TYPE} = 'Client'").all.length
+    assert_equal 1, firm.clients.scoped(:conditions => "name = 'Summit'").all.length
   end
 
   def test_find_each
@@ -477,29 +477,29 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_find_all_sanitized
     # sometimes tests on Oracle fail if ORDER BY is not provided therefore add always :order with :first
-    firm = Firm.find(:first, :order => "id")
-    summit = firm.clients.find(:all, :conditions => "name = 'Summit'")
-    assert_equal summit, firm.clients.find(:all, :conditions => ["name = ?", "Summit"])
-    assert_equal summit, firm.clients.find(:all, :conditions => ["name = :name", { :name => "Summit" }])
+    firm = Firm.scoped(:order => "id").first
+    summit = firm.clients.scoped(:conditions => "name = 'Summit'").all
+    assert_equal summit, firm.clients.scoped(:conditions => ["name = ?", "Summit"]).all
+    assert_equal summit, firm.clients.scoped(:conditions => ["name = :name", { :name => "Summit" }]).all
   end
 
   def test_find_first
-    firm = Firm.find(:first, :order => "id")
+    firm = Firm.scoped(:order => "id").first
     client2 = Client.find(2)
-    assert_equal firm.clients.first, firm.clients.find(:first, :order => "id")
-    assert_equal client2, firm.clients.find(:first, :conditions => "#{QUOTED_TYPE} = 'Client'", :order => "id")
+    assert_equal firm.clients.first, firm.clients.scoped(:order => "id").first
+    assert_equal client2, firm.clients.scoped(:conditions => "#{QUOTED_TYPE} = 'Client'", :order => "id").first
   end
 
   def test_find_first_sanitized
-    firm = Firm.find(:first, :order => "id")
+    firm = Firm.scoped(:order => "id").first
     client2 = Client.find(2)
-    assert_equal client2, firm.clients.find(:first, :conditions => ["#{QUOTED_TYPE} = ?", 'Client'], :order => "id")
-    assert_equal client2, firm.clients.find(:first, :conditions => ["#{QUOTED_TYPE} = :type", { :type => 'Client' }], :order => "id")
+    assert_equal client2, firm.clients.scoped(:conditions => ["#{QUOTED_TYPE} = ?", 'Client'], :order => "id").first
+    assert_equal client2, firm.clients.scoped(:conditions => ["#{QUOTED_TYPE} = :type", { :type => 'Client' }], :order => "id").first
   end
 
   def test_find_all_with_include_and_conditions
     assert_nothing_raised do
-      Developer.find(:all, :joins => :audit_logs, :conditions => {'audit_logs.message' => nil, :name => 'Smith'})
+      Developer.scoped(:joins => :audit_logs, :conditions => {'audit_logs.message' => nil, :name => 'Smith'}).all
     end
   end
 
@@ -509,8 +509,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_find_grouped
-    all_clients_of_firm1 = Client.find(:all, :conditions => "firm_id = 1")
-    grouped_clients_of_firm1 = Client.find(:all, :conditions => "firm_id = 1", :group => "firm_id", :select => 'firm_id, count(id) as clients_count')
+    all_clients_of_firm1 = Client.scoped(:conditions => "firm_id = 1").all
+    grouped_clients_of_firm1 = Client.scoped(:conditions => "firm_id = 1", :group => "firm_id", :select => 'firm_id, count(id) as clients_count').all
     assert_equal 2, all_clients_of_firm1.size
     assert_equal 1, grouped_clients_of_firm1.size
   end
@@ -568,7 +568,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_create_with_bang_on_has_many_raises_when_record_not_saved
     assert_raise(ActiveRecord::RecordInvalid) do
-      firm = Firm.find(:first, :order => "id")
+      firm = Firm.scoped(:order => "id").first
       firm.plain_clients.create!
     end
   end
@@ -1110,7 +1110,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     firm = companies(:first_firm)
     assert_equal 2, firm.clients.size
     firm.destroy
-    assert Client.find(:all, :conditions => "firm_id=#{firm.id}").empty?
+    assert Client.scoped(:conditions => "firm_id=#{firm.id}").all.empty?
   end
 
   def test_dependence_for_associations_with_hash_condition
@@ -1120,7 +1120,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_destroy_dependent_when_deleted_from_association
     # sometimes tests on Oracle fail if ORDER BY is not provided therefore add always :order with :first
-    firm = Firm.find(:first, :order => "id")
+    firm = Firm.scoped(:order => "id").first
     assert_equal 2, firm.clients.size
 
     client = firm.clients.first
@@ -1148,7 +1148,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
     firm.destroy rescue "do nothing"
 
-    assert_equal 2, Client.find(:all, :conditions => "firm_id=#{firm.id}").size
+    assert_equal 2, Client.scoped(:conditions => "firm_id=#{firm.id}").all.size
   end
 
   def test_dependence_on_account
@@ -1215,7 +1215,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_replace_with_less
-    firm = Firm.find(:first, :order => "id")
+    firm = Firm.scoped(:order => "id").first
     firm.clients = [companies(:first_client)]
     assert firm.save, "Could not save firm"
     firm.reload
@@ -1229,7 +1229,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_replace_with_new
-    firm = Firm.find(:first, :order => "id")
+    firm = Firm.scoped(:order => "id").first
     firm.clients = [companies(:second_client), Client.new("name" => "New Client")]
     firm.save
     firm.reload
@@ -1329,27 +1329,27 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_dynamic_find_should_respect_association_order_for_through
-    assert_equal Comment.find(10), authors(:david).comments_desc.find(:first, :conditions => "comments.type = 'SpecialComment'")
+    assert_equal Comment.find(10), authors(:david).comments_desc.scoped(:conditions => "comments.type = 'SpecialComment'").first
     assert_equal Comment.find(10), authors(:david).comments_desc.find_by_type('SpecialComment')
   end
 
   def test_dynamic_find_all_should_respect_association_order_for_through
-    assert_equal [Comment.find(10), Comment.find(7), Comment.find(6), Comment.find(3)], authors(:david).comments_desc.find(:all, :conditions => "comments.type = 'SpecialComment'")
+    assert_equal [Comment.find(10), Comment.find(7), Comment.find(6), Comment.find(3)], authors(:david).comments_desc.scoped(:conditions => "comments.type = 'SpecialComment'").all
     assert_equal [Comment.find(10), Comment.find(7), Comment.find(6), Comment.find(3)], authors(:david).comments_desc.find_all_by_type('SpecialComment')
   end
 
   def test_dynamic_find_all_should_respect_association_limit_for_through
-    assert_equal 1, authors(:david).limited_comments.find(:all, :conditions => "comments.type = 'SpecialComment'").length
+    assert_equal 1, authors(:david).limited_comments.scoped(:conditions => "comments.type = 'SpecialComment'").all.length
     assert_equal 1, authors(:david).limited_comments.find_all_by_type('SpecialComment').length
   end
 
   def test_dynamic_find_all_order_should_override_association_limit_for_through
-    assert_equal 4, authors(:david).limited_comments.find(:all, :conditions => "comments.type = 'SpecialComment'", :limit => 9_000).length
+    assert_equal 4, authors(:david).limited_comments.scoped(:conditions => "comments.type = 'SpecialComment'", :limit => 9_000).all.length
     assert_equal 4, authors(:david).limited_comments.find_all_by_type('SpecialComment', :limit => 9_000).length
   end
 
   def test_find_all_include_over_the_same_table_for_through
-    assert_equal 2, people(:michael).posts.find(:all, :include => :people).length
+    assert_equal 2, people(:michael).posts.scoped(:include => :people).all.length
   end
 
   def test_has_many_through_respects_hash_conditions
@@ -1568,7 +1568,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_creating_using_primary_key
-    firm = Firm.find(:first, :order => "id")
+    firm = Firm.scoped(:order => "id").first
     client = firm.clients_using_primary_key.create!(:name => 'test')
     assert_equal firm.name, client.firm_name
   end
diff --git a/activerecord/test/cases/associations/has_one_associations_test.rb b/activerecord/test/cases/associations/has_one_associations_test.rb
index 35c5d765a7..9a5719c298 100644
--- a/activerecord/test/cases/associations/has_one_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_associations_test.rb
@@ -25,7 +25,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     assert_queries(1) { assert_nil firm.account }
     assert_queries(0) { assert_nil firm.account }
 
-    firms = Firm.find(:all, :include => :account)
+    firms = Firm.scoped(:include => :account).all
     assert_queries(0) { firms.each(&:account) }
   end
 
diff --git a/activerecord/test/cases/associations/has_one_through_associations_test.rb b/activerecord/test/cases/associations/has_one_through_associations_test.rb
index 2503349c08..fd95178d54 100644
--- a/activerecord/test/cases/associations/has_one_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_through_associations_test.rb
@@ -73,7 +73,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_one_through_eager_loading
     members = assert_queries(3) do #base table, through table, clubs table
-      Member.find(:all, :include => :club, :conditions => ["name = ?", "Groucho Marx"])
+      Member.scoped(:include => :club, :conditions => ["name = ?", "Groucho Marx"]).all
     end
     assert_equal 1, members.size
     assert_not_nil assert_no_queries {members[0].club}
@@ -81,7 +81,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_one_through_eager_loading_through_polymorphic
     members = assert_queries(3) do #base table, through table, clubs table
-      Member.find(:all, :include => :sponsor_club, :conditions => ["name = ?", "Groucho Marx"])
+      Member.scoped(:include => :sponsor_club, :conditions => ["name = ?", "Groucho Marx"]).all
     end
     assert_equal 1, members.size
     assert_not_nil assert_no_queries {members[0].sponsor_club}
@@ -104,14 +104,14 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_eager_has_one_through_polymorphic_with_source_type
-    clubs = Club.find(:all, :include => :sponsored_member, :conditions => ["name = ?","Moustache and Eyebrow Fancier Club"])
+    clubs = Club.scoped(:include => :sponsored_member, :conditions => ["name = ?","Moustache and Eyebrow Fancier Club"]).all
     # Only the eyebrow fanciers club has a sponsored_member
     assert_not_nil assert_no_queries {clubs[0].sponsored_member}
   end
 
   def test_has_one_through_nonpreload_eagerloading
     members = assert_queries(1) do
-      Member.find(:all, :include => :club, :conditions => ["members.name = ?", "Groucho Marx"], :order => 'clubs.name') #force fallback
+      Member.scoped(:include => :club, :conditions => ["members.name = ?", "Groucho Marx"], :order => 'clubs.name').all #force fallback
     end
     assert_equal 1, members.size
     assert_not_nil assert_no_queries {members[0].club}
@@ -119,7 +119,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_one_through_nonpreload_eager_loading_through_polymorphic
     members = assert_queries(1) do
-      Member.find(:all, :include => :sponsor_club, :conditions => ["members.name = ?", "Groucho Marx"], :order => 'clubs.name') #force fallback
+      Member.scoped(:include => :sponsor_club, :conditions => ["members.name = ?", "Groucho Marx"], :order => 'clubs.name').all #force fallback
     end
     assert_equal 1, members.size
     assert_not_nil assert_no_queries {members[0].sponsor_club}
@@ -128,7 +128,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   def test_has_one_through_nonpreload_eager_loading_through_polymorphic_with_more_than_one_through_record
     Sponsor.new(:sponsor_club => clubs(:crazy_club), :sponsorable => members(:groucho)).save!
     members = assert_queries(1) do
-      Member.find(:all, :include => :sponsor_club, :conditions => ["members.name = ?", "Groucho Marx"], :order => 'clubs.name DESC') #force fallback
+      Member.scoped(:include => :sponsor_club, :conditions => ["members.name = ?", "Groucho Marx"], :order => 'clubs.name DESC').all #force fallback
     end
     assert_equal 1, members.size
     assert_not_nil assert_no_queries { members[0].sponsor_club }
@@ -197,7 +197,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
     @member.member_detail = @member_detail
     @member.organization = @organization
     @member_details = assert_queries(3) do
-      MemberDetail.find(:all, :include => :member_type)
+      MemberDetail.scoped(:include => :member_type).all
     end
     @new_detail = @member_details[0]
     assert @new_detail.send(:association, :member_type).loaded?
diff --git a/activerecord/test/cases/associations/inverse_associations_test.rb b/activerecord/test/cases/associations/inverse_associations_test.rb
index 2cf902de75..563f38d023 100644
--- a/activerecord/test/cases/associations/inverse_associations_test.rb
+++ b/activerecord/test/cases/associations/inverse_associations_test.rb
@@ -96,7 +96,7 @@ class InverseHasOneTests < ActiveRecord::TestCase
 
 
   def test_parent_instance_should_be_shared_with_eager_loaded_child_on_find
-    m = Man.find(:first, :conditions => {:name => 'Gordon'}, :include => :face)
+    m = Man.scoped(:conditions => {:name => 'Gordon'}, :include => :face).first
     f = m.face
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
     m.name = 'Bongo'
@@ -104,7 +104,7 @@ class InverseHasOneTests < ActiveRecord::TestCase
     f.man.name = 'Mungo'
     assert_equal m.name, f.man.name, "Name of man should be the same after changes to child-owned instance"
 
-    m = Man.find(:first, :conditions => {:name => 'Gordon'}, :include => :face, :order => 'faces.id')
+    m = Man.scoped(:conditions => {:name => 'Gordon'}, :include => :face, :order => 'faces.id').first
     f = m.face
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
     m.name = 'Bongo'
@@ -179,7 +179,7 @@ class InverseHasManyTests < ActiveRecord::TestCase
   end
 
   def test_parent_instance_should_be_shared_with_eager_loaded_children
-    m = Man.find(:first, :conditions => {:name => 'Gordon'}, :include => :interests)
+    m = Man.scoped(:conditions => {:name => 'Gordon'}, :include => :interests).first
     is = m.interests
     is.each do |i|
       assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
@@ -189,7 +189,7 @@ class InverseHasManyTests < ActiveRecord::TestCase
       assert_equal m.name, i.man.name, "Name of man should be the same after changes to child-owned instance"
     end
 
-    m = Man.find(:first, :conditions => {:name => 'Gordon'}, :include => :interests, :order => 'interests.id')
+    m = Man.scoped(:conditions => {:name => 'Gordon'}, :include => :interests, :order => 'interests.id').first
     is = m.interests
     is.each do |i|
       assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
@@ -278,7 +278,7 @@ class InverseBelongsToTests < ActiveRecord::TestCase
   end
 
   def test_eager_loaded_child_instance_should_be_shared_with_parent_on_find
-    f = Face.find(:first, :include => :man, :conditions => {:description => 'trusting'})
+    f = Face.scoped(:include => :man, :conditions => {:description => 'trusting'}).first
     m = f.man
     assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
     f.description = 'gormless'
@@ -286,7 +286,7 @@ class InverseBelongsToTests < ActiveRecord::TestCase
     m.face.description = 'pleasing'
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to parent-owned instance"
 
-    f = Face.find(:first, :include => :man, :order => 'men.id', :conditions => {:description => 'trusting'})
+    f = Face.scoped(:include => :man, :order => 'men.id', :conditions => {:description => 'trusting'}).first
     m = f.man
     assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
     f.description = 'gormless'
@@ -351,7 +351,7 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
   fixtures :men, :faces, :interests
 
   def test_child_instance_should_be_shared_with_parent_on_find
-    f = Face.find(:first, :conditions => {:description => 'confused'})
+    f = Face.scoped(:conditions => {:description => 'confused'}).first
     m = f.polymorphic_man
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same before changes to child instance"
     f.description = 'gormless'
@@ -361,7 +361,7 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
   end
 
   def test_eager_loaded_child_instance_should_be_shared_with_parent_on_find
-    f = Face.find(:first, :conditions => {:description => 'confused'}, :include => :man)
+    f = Face.scoped(:conditions => {:description => 'confused'}, :include => :man).first
     m = f.polymorphic_man
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same before changes to child instance"
     f.description = 'gormless'
@@ -369,7 +369,7 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
     m.polymorphic_face.description = 'pleasing'
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same after changes to parent-owned instance"
 
-    f = Face.find(:first, :conditions => {:description => 'confused'}, :include => :man, :order => 'men.id')
+    f = Face.scoped(:conditions => {:description => 'confused'}, :include => :man, :order => 'men.id').first
     m = f.polymorphic_man
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same before changes to child instance"
     f.description = 'gormless'
diff --git a/activerecord/test/cases/associations/join_model_test.rb b/activerecord/test/cases/associations/join_model_test.rb
index d3451bdb79..63b7acfc7a 100644
--- a/activerecord/test/cases/associations/join_model_test.rb
+++ b/activerecord/test/cases/associations/join_model_test.rb
@@ -237,8 +237,8 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_include_has_many_through
-    posts              = Post.find(:all, :order => 'posts.id')
-    posts_with_authors = Post.find(:all, :include => :authors, :order => 'posts.id')
+    posts              = Post.scoped(:order => 'posts.id').all
+    posts_with_authors = Post.scoped(:include => :authors, :order => 'posts.id').all
     assert_equal posts.length, posts_with_authors.length
     posts.length.times do |i|
       assert_equal posts[i].authors.length, assert_no_queries { posts_with_authors[i].authors.length }
@@ -262,8 +262,8 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_include_polymorphic_has_many_through
-    posts           = Post.find(:all, :order => 'posts.id')
-    posts_with_tags = Post.find(:all, :include => :tags, :order => 'posts.id')
+    posts           = Post.scoped(:order => 'posts.id').all
+    posts_with_tags = Post.scoped(:include => :tags, :order => 'posts.id').all
     assert_equal posts.length, posts_with_tags.length
     posts.length.times do |i|
       assert_equal posts[i].tags.length, assert_no_queries { posts_with_tags[i].tags.length }
@@ -271,8 +271,8 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_include_polymorphic_has_many
-    posts               = Post.find(:all, :order => 'posts.id')
-    posts_with_taggings = Post.find(:all, :include => :taggings, :order => 'posts.id')
+    posts               = Post.scoped(:order => 'posts.id').all
+    posts_with_taggings = Post.scoped(:include => :taggings, :order => 'posts.id').all
     assert_equal posts.length, posts_with_taggings.length
     posts.length.times do |i|
       assert_equal posts[i].taggings.length, assert_no_queries { posts_with_taggings[i].taggings.length }
@@ -292,8 +292,8 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_find_conditions
-    assert_equal categories(:general), authors(:david).categories.find(:first, :conditions => "categories.name = 'General'")
-    assert_nil authors(:david).categories.find(:first, :conditions => "categories.name = 'Technology'")
+    assert_equal categories(:general), authors(:david).categories.scoped(:conditions => "categories.name = 'General'").first
+    assert_nil authors(:david).categories.scoped(:conditions => "categories.name = 'Technology'").first
   end
 
   def test_has_many_class_methods_called_by_method_missing
@@ -374,20 +374,20 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_through_has_many_find_all
-    assert_equal comments(:greetings), authors(:david).comments.find(:all, :order => 'comments.id').first
+    assert_equal comments(:greetings), authors(:david).comments.scoped(:order => 'comments.id').all.first
   end
 
   def test_has_many_through_has_many_find_all_with_custom_class
-    assert_equal comments(:greetings), authors(:david).funky_comments.find(:all, :order => 'comments.id').first
+    assert_equal comments(:greetings), authors(:david).funky_comments.scoped(:order => 'comments.id').all.first
   end
 
   def test_has_many_through_has_many_find_first
-    assert_equal comments(:greetings), authors(:david).comments.find(:first, :order => 'comments.id')
+    assert_equal comments(:greetings), authors(:david).comments.scoped(:order => 'comments.id').first
   end
 
   def test_has_many_through_has_many_find_conditions
     options = { :conditions => "comments.#{QUOTED_TYPE}='SpecialComment'", :order => 'comments.id' }
-    assert_equal comments(:does_it_hurt), authors(:david).comments.find(:first, options)
+    assert_equal comments(:does_it_hurt), authors(:david).comments.scoped(options).first
   end
 
   def test_has_many_through_has_many_find_by_id
@@ -411,7 +411,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_eager_load_has_many_through_has_many
-    author = Author.find :first, :conditions => ['name = ?', 'David'], :include => :comments, :order => 'comments.id'
+    author = Author.scoped(:conditions => ['name = ?', 'David'], :include => :comments, :order => 'comments.id').first
     SpecialComment.new; VerySpecialComment.new
     assert_no_queries do
       assert_equal [1,2,3,5,6,7,8,9,10,12], author.comments.collect(&:id)
@@ -419,7 +419,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_eager_load_has_many_through_has_many_with_conditions
-    post = Post.find(:first, :include => :invalid_tags)
+    post = Post.scoped(:include => :invalid_tags).first
     assert_no_queries do
       post.invalid_tags
     end
@@ -427,8 +427,8 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_eager_belongs_to_and_has_one_not_singularized
     assert_nothing_raised do
-      Author.find(:first, :include => :author_address)
-      AuthorAddress.find(:first, :include => :author)
+      Author.scoped(:include => :author_address).first
+      AuthorAddress.scoped(:include => :author).first
     end
   end
 
@@ -632,8 +632,8 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_preload_polymorphic_has_many_through
-    posts           = Post.find(:all, :order => 'posts.id')
-    posts_with_tags = Post.find(:all, :include => :tags, :order => 'posts.id')
+    posts           = Post.scoped(:order => 'posts.id').all
+    posts_with_tags = Post.scoped(:include => :tags, :order => 'posts.id').all
     assert_equal posts.length, posts_with_tags.length
     posts.length.times do |i|
       assert_equal posts[i].tags.length, assert_no_queries { posts_with_tags[i].tags.length }
@@ -641,7 +641,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_preload_polymorph_many_types
-    taggings = Tagging.find :all, :include => :taggable, :conditions => ['taggable_type != ?', 'FakeModel']
+    taggings = Tagging.scoped(:include => :taggable, :conditions => ['taggable_type != ?', 'FakeModel']).all
     assert_no_queries do
       taggings.first.taggable.id
       taggings[1].taggable.id
@@ -654,13 +654,13 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_preload_nil_polymorphic_belongs_to
     assert_nothing_raised do
-      Tagging.find(:all, :include => :taggable, :conditions => ['taggable_type IS NULL'])
+      Tagging.scoped(:include => :taggable, :conditions => ['taggable_type IS NULL']).all
     end
   end
 
   def test_preload_polymorphic_has_many
-    posts               = Post.find(:all, :order => 'posts.id')
-    posts_with_taggings = Post.find(:all, :include => :taggings, :order => 'posts.id')
+    posts               = Post.scoped(:order => 'posts.id').all
+    posts_with_taggings = Post.scoped(:include => :taggings, :order => 'posts.id').all
     assert_equal posts.length, posts_with_taggings.length
     posts.length.times do |i|
       assert_equal posts[i].taggings.length, assert_no_queries { posts_with_taggings[i].taggings.length }
@@ -668,7 +668,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_belongs_to_shared_parent
-    comments = Comment.find(:all, :include => :post, :conditions => 'post_id = 1')
+    comments = Comment.scoped(:include => :post, :conditions => 'post_id = 1').all
     assert_no_queries do
       assert_equal comments.first.post, comments[1].post
     end
diff --git a/activerecord/test/cases/associations_test.rb b/activerecord/test/cases/associations_test.rb
index 017905e0ac..4d3751bba5 100644
--- a/activerecord/test/cases/associations_test.rb
+++ b/activerecord/test/cases/associations_test.rb
@@ -74,8 +74,8 @@ class AssociationsTest < ActiveRecord::TestCase
 
 
   def test_include_with_order_works
-    assert_nothing_raised {Account.find(:first, :order => 'id', :include => :firm)}
-    assert_nothing_raised {Account.find(:first, :order => :id, :include => :firm)}
+    assert_nothing_raised {Account.scoped(:order => 'id', :include => :firm).first}
+    assert_nothing_raised {Account.scoped(:order => :id, :include => :firm).first}
   end
 
   def test_bad_collection_keys
diff --git a/activerecord/test/cases/attribute_methods_test.rb b/activerecord/test/cases/attribute_methods_test.rb
index 7ed61243e5..ab44dc8811 100644
--- a/activerecord/test/cases/attribute_methods_test.rb
+++ b/activerecord/test/cases/attribute_methods_test.rb
@@ -484,9 +484,9 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     topic = Topic.create(:title => 'Budget')
     # Oracle does not support boolean expressions in SELECT
     if current_adapter?(:OracleAdapter)
-      topic = Topic.find(:first, :select => "topics.*, 0 as is_test")
+      topic = Topic.scoped(:select => "topics.*, 0 as is_test").first
     else
-      topic = Topic.find(:first, :select => "topics.*, 1=2 as is_test")
+      topic = Topic.scoped(:select => "topics.*, 1=2 as is_test").first
     end
     assert !topic.is_test?
   end
@@ -495,9 +495,9 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     topic = Topic.create(:title => 'Budget')
     # Oracle does not support boolean expressions in SELECT
     if current_adapter?(:OracleAdapter)
-      topic = Topic.find(:first, :select => "topics.*, 1 as is_test")
+      topic = Topic.scoped(:select => "topics.*, 1 as is_test").first
     else
-      topic = Topic.find(:first, :select => "topics.*, 2=2 as is_test")
+      topic = Topic.scoped(:select => "topics.*, 2=2 as is_test").first
     end
     assert topic.is_test?
   end
diff --git a/activerecord/test/cases/autosave_association_test.rb b/activerecord/test/cases/autosave_association_test.rb
index 84a3f658a8..fb19bdf435 100644
--- a/activerecord/test/cases/autosave_association_test.rb
+++ b/activerecord/test/cases/autosave_association_test.rb
@@ -155,7 +155,7 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
   end
 
   def test_not_resaved_when_unchanged
-    firm = Firm.find(:first, :include => :account)
+    firm = Firm.scoped(:include => :account).first
     firm.name += '-changed'
     assert_queries(1) { firm.save! }
 
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index 19ef2f592d..9ebc136252 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -350,13 +350,13 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_load
-    topics = Topic.find(:all, :order => 'id')
+    topics = Topic.scoped(:order => 'id').all
     assert_equal(4, topics.size)
     assert_equal(topics(:first).title, topics.first.title)
   end
 
   def test_load_with_condition
-    topics = Topic.find(:all, :conditions => "author_name = 'Mary'")
+    topics = Topic.scoped(:conditions => "author_name = 'Mary'").all
 
     assert_equal(1, topics.size)
     assert_equal(topics(:second).title, topics.first.title)
@@ -1264,10 +1264,10 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_quoting_arrays
-    replies = Reply.find(:all, :conditions => [ "id IN (?)", topics(:first).replies.collect(&:id) ])
+    replies = Reply.scoped(:conditions => [ "id IN (?)", topics(:first).replies.collect(&:id) ]).all
     assert_equal topics(:first).replies.size, replies.size
 
-    replies = Reply.find(:all, :conditions => [ "id IN (?)", [] ])
+    replies = Reply.scoped(:conditions => [ "id IN (?)", [] ]).all
     assert_equal 0, replies.size
   end
 
@@ -1595,17 +1595,17 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_no_limit_offset
     assert_nothing_raised do
-      Developer.find(:all, :offset => 2)
+      Developer.scoped(:offset => 2).all
     end
   end
 
   def test_find_last
     last  = Developer.last
-    assert_equal last, Developer.find(:first, :order => 'id desc')
+    assert_equal last, Developer.scoped(:order => 'id desc').first
   end
 
   def test_last
-    assert_equal Developer.find(:first, :order => 'id desc'), Developer.last
+    assert_equal Developer.scoped(:order => 'id desc').first, Developer.last
   end
 
   def test_all
@@ -1615,37 +1615,37 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_all_with_conditions
-    assert_equal Developer.find(:all, :order => 'id desc'), Developer.order('id desc').all
+    assert_equal Developer.scoped(:order => 'id desc').all, Developer.order('id desc').all
   end
 
   def test_find_ordered_last
-    last  = Developer.find :last, :order => 'developers.salary ASC'
-    assert_equal last, Developer.find(:all, :order => 'developers.salary ASC').last
+    last  = Developer.scoped(:order => 'developers.salary ASC').last
+    assert_equal last, Developer.scoped(:order => 'developers.salary ASC').all.last
   end
 
   def test_find_reverse_ordered_last
-    last  = Developer.find :last, :order => 'developers.salary DESC'
-    assert_equal last, Developer.find(:all, :order => 'developers.salary DESC').last
+    last  = Developer.scoped(:order => 'developers.salary DESC').last
+    assert_equal last, Developer.scoped(:order => 'developers.salary DESC').all.last
   end
 
   def test_find_multiple_ordered_last
-    last  = Developer.find :last, :order => 'developers.name, developers.salary DESC'
-    assert_equal last, Developer.find(:all, :order => 'developers.name, developers.salary DESC').last
+    last  = Developer.scoped(:order => 'developers.name, developers.salary DESC').last
+    assert_equal last, Developer.scoped(:order => 'developers.name, developers.salary DESC').all.last
   end
 
   def test_find_keeps_multiple_order_values
-    combined = Developer.find(:all, :order => 'developers.name, developers.salary')
-    assert_equal combined, Developer.find(:all, :order => ['developers.name', 'developers.salary'])
+    combined = Developer.scoped(:order => 'developers.name, developers.salary').all
+    assert_equal combined, Developer.scoped(:order => ['developers.name', 'developers.salary']).all
   end
 
   def test_find_keeps_multiple_group_values
-    combined = Developer.find(:all, :group => 'developers.name, developers.salary, developers.id, developers.created_at, developers.updated_at')
-    assert_equal combined, Developer.find(:all, :group => ['developers.name', 'developers.salary', 'developers.id', 'developers.created_at', 'developers.updated_at'])
+    combined = Developer.scoped(:group => 'developers.name, developers.salary, developers.id, developers.created_at, developers.updated_at').all
+    assert_equal combined, Developer.scoped(:group => ['developers.name', 'developers.salary', 'developers.id', 'developers.created_at', 'developers.updated_at']).all
   end
 
   def test_find_symbol_ordered_last
-    last  = Developer.find :last, :order => :salary
-    assert_equal last, Developer.find(:all, :order => :salary).last
+    last  = Developer.scoped(:order => :salary).last
+    assert_equal last, Developer.scoped(:order => :salary).all.last
   end
 
   def test_abstract_class
@@ -1739,8 +1739,8 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_inspect_limited_select_instance
-    assert_equal %(#<Topic id: 1>), Topic.find(:first, :select => 'id', :conditions => 'id = 1').inspect
-    assert_equal %(#<Topic id: 1, title: "The First Topic">), Topic.find(:first, :select => 'id, title', :conditions => 'id = 1').inspect
+    assert_equal %(#<Topic id: 1>), Topic.scoped(:select => 'id', :conditions => 'id = 1').first.inspect
+    assert_equal %(#<Topic id: 1, title: "The First Topic">), Topic.scoped(:select => 'id, title', :conditions => 'id = 1').first.inspect
   end
 
   def test_inspect_class_without_table
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index 4599666cd0..aa0f1f7a15 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -117,56 +117,6 @@ class FinderTest < ActiveRecord::TestCase
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1, 2, 45) }
   end
 
-  def test_find_all_with_limit
-    assert_equal(2, Entrant.find(:all, :limit => 2).size)
-    assert_equal(0, Entrant.find(:all, :limit => 0).size)
-  end
-
-  def test_find_all_with_prepared_limit_and_offset
-    entrants = Entrant.find(:all, :order => "id ASC", :limit => 2, :offset => 1)
-
-    assert_equal(2, entrants.size)
-    assert_equal(entrants(:second).name, entrants.first.name)
-
-    assert_equal 3, Entrant.count
-    entrants = Entrant.find(:all, :order => "id ASC", :limit => 2, :offset => 2)
-    assert_equal(1, entrants.size)
-    assert_equal(entrants(:third).name, entrants.first.name)
-  end
-
-  def test_find_all_with_limit_and_offset_and_multiple_order_clauses
-    first_three_posts = Post.find :all, :order => 'author_id, id', :limit => 3, :offset => 0
-    second_three_posts = Post.find :all, :order => ' author_id,id ', :limit => 3, :offset => 3
-    third_three_posts = Post.find :all, :order => ' author_id, id  ', :limit => 3, :offset => 6
-    last_posts = Post.find :all, :order => ' author_id, id  ', :limit => 3, :offset => 9
-
-    assert_equal [[0,3],[1,1],[1,2]], first_three_posts.map { |p| [p.author_id, p.id] }
-    assert_equal [[1,4],[1,5],[1,6]], second_three_posts.map { |p| [p.author_id, p.id] }
-    assert_equal [[2,7],[2,9],[2,11]], third_three_posts.map { |p| [p.author_id, p.id] }
-    assert_equal [[3,8],[3,10]], last_posts.map { |p| [p.author_id, p.id] }
-  end
-
-
-  def test_find_with_group
-    developers = Developer.find(:all, :group => "salary", :select => "salary")
-    assert_equal 4, developers.size
-    assert_equal 4, developers.map(&:salary).uniq.size
-  end
-
-  def test_find_with_group_and_having
-    developers = Developer.find(:all, :group => "salary", :having => "sum(salary) > 10000", :select => "salary")
-    assert_equal 3, developers.size
-    assert_equal 3, developers.map(&:salary).uniq.size
-    assert developers.all? { |developer| developer.salary > 10000 }
-  end
-
-  def test_find_with_group_and_sanitized_having
-    developers = Developer.find(:all, :group => "salary", :having => ["sum(salary) > ?", 10000], :select => "salary")
-    assert_equal 3, developers.size
-    assert_equal 3, developers.map(&:salary).uniq.size
-    assert developers.all? { |developer| developer.salary > 10000 }
-  end
-
   def test_find_with_group_and_sanitized_having_method
     developers = Developer.group(:salary).having("sum(salary) > ?", 10000).select('salary').all
     assert_equal 3, developers.size
@@ -193,16 +143,6 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal [Account], accounts.collect(&:class).uniq
   end
 
-  def test_find_first
-    first = Topic.find(:first, :conditions => "title = 'The First Topic'")
-    assert_equal(topics(:first).title, first.title)
-  end
-
-  def test_find_first_failing
-    first = Topic.find(:first, :conditions => "title = 'The First Topic!'")
-    assert_nil(first)
-  end
-
   def test_first
     assert_equal topics(:second).title, Topic.where("title = 'The Second Topic of the day'").first.title
   end
@@ -296,18 +236,6 @@ class FinderTest < ActiveRecord::TestCase
     assert_respond_to topic, "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) }
-    end
-  end
-
   def test_find_on_array_conditions
     assert Topic.find(1, :conditions => ["approved = ?", false])
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1, :conditions => ["approved = ?", true]) }
@@ -353,23 +281,23 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_on_hash_conditions_with_range
-    assert_equal [1,2], Topic.find(:all, :conditions => { :id => 1..2 }).map(&:id).sort
+    assert_equal [1,2], Topic.scoped(:conditions => { :id => 1..2 }).all.map(&:id).sort
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1, :conditions => { :id => 2..3 }) }
   end
 
   def test_find_on_hash_conditions_with_end_exclusive_range
-    assert_equal [1,2,3], Topic.find(:all, :conditions => { :id => 1..3 }).map(&:id).sort
-    assert_equal [1,2], Topic.find(:all, :conditions => { :id => 1...3 }).map(&:id).sort
+    assert_equal [1,2,3], Topic.scoped(:conditions => { :id => 1..3 }).all.map(&:id).sort
+    assert_equal [1,2], Topic.scoped(:conditions => { :id => 1...3 }).all.map(&:id).sort
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(3, :conditions => { :id => 2...3 }) }
   end
 
   def test_find_on_hash_conditions_with_multiple_ranges
-    assert_equal [1,2,3], Comment.find(:all, :conditions => { :id => 1..3, :post_id => 1..2 }).map(&:id).sort
-    assert_equal [1], Comment.find(:all, :conditions => { :id => 1..1, :post_id => 1..10 }).map(&:id).sort
+    assert_equal [1,2,3], Comment.scoped(:conditions => { :id => 1..3, :post_id => 1..2 }).all.map(&:id).sort
+    assert_equal [1], Comment.scoped(:conditions => { :id => 1..1, :post_id => 1..10 }).all.map(&:id).sort
   end
 
   def test_find_on_hash_conditions_with_array_of_integers_and_ranges
-    assert_equal [1,2,3,5,6,7,8,9], Comment.find(:all, :conditions => {:id => [1..2, 3, 5, 6..8, 9]}).map(&:id).sort
+    assert_equal [1,2,3,5,6,7,8,9], Comment.scoped(:conditions => {:id => [1..2, 3, 5, 6..8, 9]}).all.map(&:id).sort
   end
 
   def test_find_on_multiple_hash_conditions
@@ -380,44 +308,44 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_condition_interpolation
-    assert_kind_of Firm, Company.find(:first, :conditions => ["name = '%s'", "37signals"])
-    assert_nil Company.find(:first, :conditions => ["name = '%s'", "37signals!"])
-    assert_nil Company.find(:first, :conditions => ["name = '%s'", "37signals!' OR 1=1"])
-    assert_kind_of Time, Topic.find(:first, :conditions => ["id = %d", 1]).written_on
+    assert_kind_of Firm, Company.where("name = '%s'", "37signals").first
+    assert_nil Company.scoped(:conditions => ["name = '%s'", "37signals!"]).first
+    assert_nil Company.scoped(:conditions => ["name = '%s'", "37signals!' OR 1=1"]).first
+    assert_kind_of Time, Topic.scoped(:conditions => ["id = %d", 1]).first.written_on
   end
 
   def test_condition_array_interpolation
-    assert_kind_of Firm, Company.find(:first, :conditions => ["name = '%s'", "37signals"])
-    assert_nil Company.find(:first, :conditions => ["name = '%s'", "37signals!"])
-    assert_nil Company.find(:first, :conditions => ["name = '%s'", "37signals!' OR 1=1"])
-    assert_kind_of Time, Topic.find(:first, :conditions => ["id = %d", 1]).written_on
+    assert_kind_of Firm, Company.scoped(:conditions => ["name = '%s'", "37signals"]).first
+    assert_nil Company.scoped(:conditions => ["name = '%s'", "37signals!"]).first
+    assert_nil Company.scoped(:conditions => ["name = '%s'", "37signals!' OR 1=1"]).first
+    assert_kind_of Time, Topic.scoped(:conditions => ["id = %d", 1]).first.written_on
   end
 
   def test_condition_hash_interpolation
-    assert_kind_of Firm, Company.find(:first, :conditions => { :name => "37signals"})
-    assert_nil Company.find(:first, :conditions => { :name => "37signals!"})
-    assert_kind_of Time, Topic.find(:first, :conditions => {:id => 1}).written_on
+    assert_kind_of Firm, Company.scoped(:conditions => { :name => "37signals"}).first
+    assert_nil Company.scoped(:conditions => { :name => "37signals!"}).first
+    assert_kind_of Time, Topic.scoped(:conditions => {:id => 1}).first.written_on
   end
 
   def test_hash_condition_find_malformed
     assert_raise(ActiveRecord::StatementInvalid) {
-      Company.find(:first, :conditions => { :id => 2, :dhh => true })
+      Company.scoped(:conditions => { :id => 2, :dhh => true }).first
     }
   end
 
   def test_hash_condition_find_with_escaped_characters
     Company.create("name" => "Ain't noth'n like' \#stuff")
-    assert Company.find(:first, :conditions => { :name => "Ain't noth'n like' \#stuff" })
+    assert Company.scoped(:conditions => { :name => "Ain't noth'n like' \#stuff" }).first
   end
 
   def test_hash_condition_find_with_array
-    p1, p2 = Post.find(:all, :limit => 2, :order => 'id asc')
-    assert_equal [p1, p2], Post.find(:all, :conditions => { :id => [p1, p2] }, :order => 'id asc')
-    assert_equal [p1, p2], Post.find(:all, :conditions => { :id => [p1, p2.id] }, :order => 'id asc')
+    p1, p2 = Post.scoped(:limit => 2, :order => 'id asc').all
+    assert_equal [p1, p2], Post.scoped(:conditions => { :id => [p1, p2] }, :order => 'id asc').all
+    assert_equal [p1, p2], Post.scoped(:conditions => { :id => [p1, p2.id] }, :order => 'id asc').all
   end
 
   def test_hash_condition_find_with_nil
-    topic = Topic.find(:first, :conditions => { :last_read => nil } )
+    topic = Topic.scoped(:conditions => { :last_read => nil } ).first
     assert_not_nil topic
     assert_nil topic.last_read
   end
@@ -425,42 +353,42 @@ class FinderTest < ActiveRecord::TestCase
   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})
+    found_customer = Customer.scoped(:conditions => {:balance => balance}).first
     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})
+    found_customer = Customer.scoped(:conditions => {:gps_location => gps_location}).first
     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})
+    found_customer = Customer.scoped(:conditions => {:balance => balance.amount}).first
     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})
+    found_customer = Customer.scoped(:conditions => {:gps_location => gps_location.gps_location}).first
     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})
+    found_customer = Customer.scoped(:conditions => {:address => address}).first
     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})
+    found_customer = Customer.scoped(:conditions => {:address => address, :name => customers(:david).name}).first
     assert_equal customers(:david), found_customer
   end
 
@@ -468,7 +396,7 @@ class FinderTest < ActiveRecord::TestCase
     with_env_tz 'America/New_York' do
       with_active_record_default_timezone :local do
         topic = Topic.first
-        assert_equal topic, Topic.find(:first, :conditions => ['written_on = ?', topic.written_on.getutc])
+        assert_equal topic, Topic.scoped(:conditions => ['written_on = ?', topic.written_on.getutc]).first
       end
     end
   end
@@ -477,7 +405,7 @@ class FinderTest < ActiveRecord::TestCase
     with_env_tz 'America/New_York' do
       with_active_record_default_timezone :local do
         topic = Topic.first
-        assert_equal topic, Topic.find(:first, :conditions => {:written_on => topic.written_on.getutc})
+        assert_equal topic, Topic.scoped(:conditions => {:written_on => topic.written_on.getutc}).first
       end
     end
   end
@@ -486,7 +414,7 @@ class FinderTest < ActiveRecord::TestCase
     with_env_tz 'America/New_York' do
       with_active_record_default_timezone :utc do
         topic = Topic.first
-        assert_equal topic, Topic.find(:first, :conditions => ['written_on = ?', topic.written_on.getlocal])
+        assert_equal topic, Topic.scoped(:conditions => ['written_on = ?', topic.written_on.getlocal]).first
       end
     end
   end
@@ -495,32 +423,32 @@ class FinderTest < ActiveRecord::TestCase
     with_env_tz 'America/New_York' do
       with_active_record_default_timezone :utc do
         topic = Topic.first
-        assert_equal topic, Topic.find(:first, :conditions => {:written_on => topic.written_on.getlocal})
+        assert_equal topic, Topic.scoped(:conditions => {:written_on => topic.written_on.getlocal}).first
       end
     end
   end
 
   def test_bind_variables
-    assert_kind_of Firm, Company.find(:first, :conditions => ["name = ?", "37signals"])
-    assert_nil Company.find(:first, :conditions => ["name = ?", "37signals!"])
-    assert_nil Company.find(:first, :conditions => ["name = ?", "37signals!' OR 1=1"])
-    assert_kind_of Time, Topic.find(:first, :conditions => ["id = ?", 1]).written_on
+    assert_kind_of Firm, Company.scoped(:conditions => ["name = ?", "37signals"]).first
+    assert_nil Company.scoped(:conditions => ["name = ?", "37signals!"]).first
+    assert_nil Company.scoped(:conditions => ["name = ?", "37signals!' OR 1=1"]).first
+    assert_kind_of Time, Topic.scoped(:conditions => ["id = ?", 1]).first.written_on
     assert_raise(ActiveRecord::PreparedStatementInvalid) {
-      Company.find(:first, :conditions => ["id=? AND name = ?", 2])
+      Company.scoped(:conditions => ["id=? AND name = ?", 2]).first
     }
     assert_raise(ActiveRecord::PreparedStatementInvalid) {
-     Company.find(:first, :conditions => ["id=?", 2, 3, 4])
+     Company.scoped(:conditions => ["id=?", 2, 3, 4]).first
     }
   end
 
   def test_bind_variables_with_quotes
     Company.create("name" => "37signals' go'es agains")
-    assert Company.find(:first, :conditions => ["name = ?", "37signals' go'es agains"])
+    assert Company.scoped(:conditions => ["name = ?", "37signals' go'es agains"]).first
   end
 
   def test_named_bind_variables_with_quotes
     Company.create("name" => "37signals' go'es agains")
-    assert Company.find(:first, :conditions => ["name = :name", {:name => "37signals' go'es agains"}])
+    assert Company.scoped(:conditions => ["name = :name", {:name => "37signals' go'es agains"}]).first
   end
 
   def test_bind_arity
@@ -538,10 +466,10 @@ class FinderTest < ActiveRecord::TestCase
 
     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!" }])
-    assert_nil Company.find(:first, :conditions => ["name = :name", { :name => "37signals!' OR 1=1" }])
-    assert_kind_of Time, Topic.find(:first, :conditions => ["id = :id", { :id => 1 }]).written_on
+    assert_kind_of Firm, Company.scoped(:conditions => ["name = :name", { :name => "37signals" }]).first
+    assert_nil Company.scoped(:conditions => ["name = :name", { :name => "37signals!" }]).first
+    assert_nil Company.scoped(:conditions => ["name = :name", { :name => "37signals!' OR 1=1" }]).first
+    assert_kind_of Time, Topic.scoped(:conditions => ["id = :id", { :id => 1 }]).first.written_on
   end
 
   class SimpleEnumerable
@@ -1048,11 +976,6 @@ class FinderTest < ActiveRecord::TestCase
     assert_raise(ActiveRecord::StatementInvalid) { Topic.find_by_sql "select 1 from badtable" }
   end
 
-  def test_find_with_invalid_params
-    assert_raise(ArgumentError) { Topic.find :first, :join => "It should be `joins'" }
-    assert_raise(ArgumentError) { Topic.find :first, :conditions => '1 = 1', :join => "It should be `joins'" }
-  end
-
   def test_dynamic_finder_with_invalid_params
     assert_raise(ArgumentError) { Topic.find_by_title 'No Title', :join => "It should be `joins'" }
   end
@@ -1107,13 +1030,13 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_by_empty_in_condition
-    assert_equal [], Post.find(:all, :conditions => ['id in (?)', []])
+    assert_equal [], Post.where('id in (?)', [])
   end
 
   def test_find_by_records
-    p1, p2 = Post.find(:all, :limit => 2, :order => 'id asc')
-    assert_equal [p1, p2], Post.find(:all, :conditions => ['id in (?)', [p1, p2]], :order => 'id asc')
-    assert_equal [p1, p2], Post.find(:all, :conditions => ['id in (?)', [p1, p2.id]], :order => 'id asc')
+    p1, p2 = Post.scoped(:limit => 2, :order => 'id asc').all
+    assert_equal [p1, p2], Post.scoped(:conditions => ['id in (?)', [p1, p2]], :order => 'id asc')
+    assert_equal [p1, p2], Post.scoped(:conditions => ['id in (?)', [p1, p2.id]], :order => 'id asc')
   end
 
   def test_select_value
@@ -1140,10 +1063,10 @@ class FinderTest < ActiveRecord::TestCase
   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 2, Post.scoped(:include => { :authors => :author_address }, :order => 'author_addresses.id DESC ', :limit => 2).all.size
 
-    assert_equal 3, Post.find(:all, :include => { :author => :author_address, :authors => :author_address},
-                              :order => 'author_addresses_authors.id DESC ', :limit => 3).size
+    assert_equal 3, Post.scoped(:include => { :author => :author_address, :authors => :author_address},
+                              :order => 'author_addresses_authors.id DESC ', :limit => 3).all.size
   end
 
   def test_find_with_nil_inside_set_passed_for_one_attribute
@@ -1188,7 +1111,7 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_finder_with_offset_string
-    assert_nothing_raised(ActiveRecord::StatementInvalid) { Topic.find(:all, :offset => "3") }
+    assert_nothing_raised(ActiveRecord::StatementInvalid) { Topic.scoped(:offset => "3").all }
   end
 
   protected
diff --git a/activerecord/test/cases/inheritance_test.rb b/activerecord/test/cases/inheritance_test.rb
index c84448041d..f355d7a1e9 100644
--- a/activerecord/test/cases/inheritance_test.rb
+++ b/activerecord/test/cases/inheritance_test.rb
@@ -98,7 +98,7 @@ class InheritanceTest < ActiveRecord::TestCase
   end
 
   def test_inheritance_find_all
-    companies = Company.find(:all, :order => 'id')
+    companies = Company.scoped(:order => 'id').all
     assert_kind_of Firm, companies[0], "37signals should be a firm"
     assert_kind_of Client, companies[1], "Summit should be a client"
   end
@@ -151,7 +151,7 @@ class InheritanceTest < ActiveRecord::TestCase
     Client.update_all "name = 'I am a client'"
     assert_equal "I am a client", Client.all.first.name
     # Order by added as otherwise Oracle tests were failing because of different order of results
-    assert_equal "37signals", Firm.find(:all, :order => "id").first.name
+    assert_equal "37signals", Firm.scoped(:order => "id").all.first.name
   end
 
   def test_alt_update_all_within_inheritance
@@ -173,9 +173,9 @@ class InheritanceTest < ActiveRecord::TestCase
   end
 
   def test_find_first_within_inheritance
-    assert_kind_of Firm, Company.find(:first, :conditions => "name = '37signals'")
-    assert_kind_of Firm, Firm.find(:first, :conditions => "name = '37signals'")
-    assert_nil Client.find(:first, :conditions => "name = '37signals'")
+    assert_kind_of Firm, Company.scoped(:conditions => "name = '37signals'").first
+    assert_kind_of Firm, Firm.scoped(:conditions => "name = '37signals'").first
+    assert_nil Client.scoped(:conditions => "name = '37signals'").first
   end
 
   def test_alt_find_first_within_inheritance
@@ -187,10 +187,10 @@ class InheritanceTest < ActiveRecord::TestCase
   def test_complex_inheritance
     very_special_client = VerySpecialClient.create("name" => "veryspecial")
     assert_equal very_special_client, VerySpecialClient.where("name = 'veryspecial'").first
-    assert_equal very_special_client, SpecialClient.find(:first, :conditions => "name = 'veryspecial'")
-    assert_equal very_special_client, Company.find(:first, :conditions => "name = 'veryspecial'")
-    assert_equal very_special_client, Client.find(:first, :conditions => "name = 'veryspecial'")
-    assert_equal 1, Client.find(:all, :conditions => "name = 'Summit'").size
+    assert_equal very_special_client, SpecialClient.scoped(:conditions => "name = 'veryspecial'").first
+    assert_equal very_special_client, Company.scoped(:conditions => "name = 'veryspecial'").first
+    assert_equal very_special_client, Client.scoped(:conditions => "name = 'veryspecial'").first
+    assert_equal 1, Client.scoped(:conditions => "name = 'Summit'").all.size
     assert_equal very_special_client, Client.find(very_special_client.id)
   end
 
@@ -230,7 +230,7 @@ class InheritanceTest < ActiveRecord::TestCase
   private
     def switch_to_alt_inheritance_column
       # we don't want misleading test results, so get rid of the values in the type column
-      Company.find(:all, :order => 'id').each do |c|
+      Company.scoped(:order => 'id').all.each do |c|
         c['type'] = nil
         c.save
       end
diff --git a/activerecord/test/cases/modules_test.rb b/activerecord/test/cases/modules_test.rb
index aee8a42e91..76fc975a27 100644
--- a/activerecord/test/cases/modules_test.rb
+++ b/activerecord/test/cases/modules_test.rb
@@ -39,7 +39,7 @@ class ModulesTest < ActiveRecord::TestCase
   end
 
   def test_associations_spanning_cross_modules
-    account = MyApplication::Billing::Account.find(:first, :order => 'id')
+    account = MyApplication::Billing::Account.scoped(:order => 'id').first
     assert_kind_of MyApplication::Business::Firm, account.firm
     assert_kind_of MyApplication::Billing::Firm, account.qualified_billing_firm
     assert_kind_of MyApplication::Billing::Firm, account.unqualified_billing_firm
diff --git a/activerecord/test/cases/named_scope_test.rb b/activerecord/test/cases/named_scope_test.rb
index aa36a02982..6b9a684327 100644
--- a/activerecord/test/cases/named_scope_test.rb
+++ b/activerecord/test/cases/named_scope_test.rb
@@ -58,9 +58,9 @@ class NamedScopeTest < ActiveRecord::TestCase
   end
 
   def test_scopes_with_options_limit_finds_to_those_matching_the_criteria_specified
-    assert !Topic.find(:all, :conditions => {:approved => true}).empty?
+    assert !Topic.scoped(:conditions => {:approved => true}).all.empty?
 
-    assert_equal Topic.find(:all, :conditions => {:approved => true}), Topic.approved
+    assert_equal Topic.scoped(:conditions => {:approved => true}).all, Topic.approved
     assert_equal Topic.where(:approved => true).count, Topic.approved.count
   end
 
@@ -71,8 +71,8 @@ class NamedScopeTest < ActiveRecord::TestCase
   end
 
   def test_scopes_are_composable
-    assert_equal((approved = Topic.find(:all, :conditions => {:approved => true})), Topic.approved)
-    assert_equal((replied = Topic.find(:all, :conditions => 'replies_count > 0')), Topic.replied)
+    assert_equal((approved = Topic.scoped(:conditions => {:approved => true}).all), Topic.approved)
+    assert_equal((replied = Topic.scoped(:conditions => 'replies_count > 0').all), Topic.replied)
     assert !(approved == replied)
     assert !(approved & replied).empty?
 
@@ -80,8 +80,8 @@ class NamedScopeTest < ActiveRecord::TestCase
   end
 
   def test_procedural_scopes
-    topics_written_before_the_third = Topic.find(:all, :conditions => ['written_on < ?', topics(:third).written_on])
-    topics_written_before_the_second = Topic.find(:all, :conditions => ['written_on < ?', topics(:second).written_on])
+    topics_written_before_the_third = Topic.where('written_on < ?', topics(:third).written_on)
+    topics_written_before_the_second = Topic.where('written_on < ?', topics(:second).written_on)
     assert_not_equal topics_written_before_the_second, topics_written_before_the_third
 
     assert_equal topics_written_before_the_third, Topic.written_before(topics(:third).written_on)
@@ -464,7 +464,7 @@ class DynamicScopeTest < ActiveRecord::TestCase
 
   def test_dynamic_scope
     assert_equal @test_klass.scoped_by_author_id(1).find(1), @test_klass.find(1)
-    assert_equal @test_klass.scoped_by_author_id_and_title(1, "Welcome to the weblog").first, @test_klass.find(:first, :conditions => { :author_id => 1, :title => "Welcome to the weblog"})
+    assert_equal @test_klass.scoped_by_author_id_and_title(1, "Welcome to the weblog").first, @test_klass.scoped(:conditions => { :author_id => 1, :title => "Welcome to the weblog"}).first
   end
 
   def test_dynamic_scope_should_create_methods_after_hitting_method_missing
diff --git a/activerecord/test/cases/persistence_test.rb b/activerecord/test/cases/persistence_test.rb
index 5a47d3ed9f..26181311a5 100644
--- a/activerecord/test/cases/persistence_test.rb
+++ b/activerecord/test/cases/persistence_test.rb
@@ -55,7 +55,7 @@ class PersistencesTest < ActiveRecord::TestCase
       author = authors(:david)
       assert_nothing_raised do
         assert_equal 1, author.posts_sorted_by_id_limited.size
-        assert_equal 2, author.posts_sorted_by_id_limited.find(:all, :limit => 2).size
+        assert_equal 2, author.posts_sorted_by_id_limited.scoped(:limit => 2).all.size
         assert_equal 1, author.posts_sorted_by_id_limited.update_all([ "body = ?", "bulk update!" ])
         assert_equal "bulk update!", posts(:welcome).body
         assert_not_equal "bulk update!", posts(:thinking).body
diff --git a/activerecord/test/cases/relation_scoping_test.rb b/activerecord/test/cases/relation_scoping_test.rb
index c695dc1839..342f7a86fa 100644
--- a/activerecord/test/cases/relation_scoping_test.rb
+++ b/activerecord/test/cases/relation_scoping_test.rb
@@ -323,7 +323,7 @@ class DefaultScopingTest < ActiveRecord::TestCase
   fixtures :developers, :posts
 
   def test_default_scope
-    expected = Developer.find(:all, :order => 'salary DESC').collect { |dev| dev.salary }
+    expected = Developer.scoped(:order => 'salary DESC').all.collect { |dev| dev.salary }
     received = DeveloperOrderedBySalary.all.collect { |dev| dev.salary }
     assert_equal expected, received
   end
@@ -396,7 +396,7 @@ class DefaultScopingTest < ActiveRecord::TestCase
   end
 
   def test_scope_overwrites_default
-    expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.name }
+    expected = Developer.scoped(:order => 'salary DESC, name DESC').all.collect { |dev| dev.name }
     received = DeveloperOrderedBySalary.by_name.all.collect { |dev| dev.name }
     assert_equal expected, received
   end
@@ -414,8 +414,8 @@ class DefaultScopingTest < ActiveRecord::TestCase
   end
 
   def test_order_in_default_scope_should_prevail
-    expected = Developer.find(:all, :order => 'salary desc').collect { |dev| dev.salary }
-    received = DeveloperOrderedBySalary.find(:all, :order => 'salary').collect { |dev| dev.salary }
+    expected = Developer.scoped(:order => 'salary desc').all.collect { |dev| dev.salary }
+    received = DeveloperOrderedBySalary.scoped(:order => 'salary').all.collect { |dev| dev.salary }
     assert_equal expected, received
   end
 
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 63b31c33b8..ae9e4dea1b 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -282,7 +282,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_find_on_hash_conditions
-    assert_equal Topic.find(:all, :conditions => {:approved => false}), Topic.where({ :approved => false }).to_a
+    assert_equal Topic.scoped(:conditions => {:approved => false}).all, Topic.where({ :approved => false }).to_a
   end
 
   def test_joins_with_string_array
@@ -1091,11 +1091,6 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal Post.order(Post.arel_table[:title]).all, Post.order("title").all
   end
 
-  def test_order_with_find_with_order
-    assert_equal 'zyke', CoolCar.order('name desc').find(:first, :order => 'id').name
-    assert_equal 'zyke', FastCar.order('name desc').find(:first, :order => 'id').name
-  end
-
   def test_default_scope_order_with_scope_order
     assert_equal 'zyke', CoolCar.order_using_new_style.limit(1).first.name
     assert_equal 'zyke', FastCar.order_using_new_style.limit(1).first.name
@@ -1103,12 +1098,12 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_order_using_scoping
     car1 = CoolCar.order('id DESC').scoping do
-      CoolCar.find(:first, :order => 'id asc')
+      CoolCar.scoped(:order => 'id asc').first
     end
     assert_equal 'zyke', car1.name
 
     car2 = FastCar.order('id DESC').scoping do
-      FastCar.find(:first, :order => 'id asc')
+      FastCar.scoped(:order => 'id asc').first
     end
     assert_equal 'zyke', car2.name
   end
diff --git a/activerecord/test/models/comment.rb b/activerecord/test/models/comment.rb
index cf73c28ded..8ab4149ff7 100644
--- a/activerecord/test/models/comment.rb
+++ b/activerecord/test/models/comment.rb
@@ -19,7 +19,7 @@ class Comment < ActiveRecord::Base
   end
 
   def self.search_by_type(q)
-    self.find(:all, :conditions => ["#{QUOTED_TYPE} = ?", q])
+    self.scoped(:conditions => ["#{QUOTED_TYPE} = ?", q]).all
   end
 
   def self.all_as_method
diff --git a/activerecord/test/models/developer.rb b/activerecord/test/models/developer.rb
index 7133094f5d..83482f4d07 100644
--- a/activerecord/test/models/developer.rb
+++ b/activerecord/test/models/developer.rb
@@ -2,20 +2,20 @@ require 'ostruct'
 
 module DeveloperProjectsAssociationExtension
   def find_most_recent
-    find(:first, :order => "id DESC")
+    scoped(:order => "id DESC").first
   end
 end
 
 module DeveloperProjectsAssociationExtension2
   def find_least_recent
-    find(:first, :order => "id ASC")
+    scoped(:order => "id ASC").first
   end
 end
 
 class Developer < ActiveRecord::Base
   has_and_belongs_to_many :projects do
     def find_most_recent
-      find(:first, :order => "id DESC")
+      scoped(:order => "id DESC").first
     end
   end
 
@@ -37,7 +37,7 @@ class Developer < ActiveRecord::Base
       :association_foreign_key => "project_id",
       :extend => DeveloperProjectsAssociationExtension do
         def find_least_recent
-          find(:first, :order => "id ASC")
+          scoped(:order => "id ASC").first
         end
       end
 
diff --git a/activerecord/test/models/post.rb b/activerecord/test/models/post.rb
index 18810f2de8..1aaf9a1b82 100644
--- a/activerecord/test/models/post.rb
+++ b/activerecord/test/models/post.rb
@@ -31,7 +31,7 @@ class Post < ActiveRecord::Base
 
   has_many   :comments do
     def find_most_recent
-      find(:first, :order => "id DESC")
+      scoped(:order => "id DESC").first
     end
 
     def newest
@@ -64,8 +64,8 @@ class Post < ActiveRecord::Base
   has_many :taggings, :as => :taggable
   has_many :tags, :through => :taggings do
     def add_joins_and_select
-      find :all, :select => 'tags.*, authors.id as author_id',
-        :joins => 'left outer join posts on taggings.taggable_id = posts.id left outer join authors on posts.author_id = authors.id'
+      scoped(:select => 'tags.*, authors.id as author_id',
+        :joins => 'left outer join posts on taggings.taggable_id = posts.id left outer join authors on posts.author_id = authors.id').all
     end
   end
 
-- 
cgit v1.2.3


From 61555a0df11f535d46a0a631fbb0d0773613d08e Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 27 Apr 2012 11:52:34 +0100
Subject: allow AssociationProxy#scoped to take options so that API is the same
 as Base#scoped

---
 activerecord/test/cases/associations_test.rb | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/associations_test.rb b/activerecord/test/cases/associations_test.rb
index 4d3751bba5..6412ec0599 100644
--- a/activerecord/test/cases/associations_test.rb
+++ b/activerecord/test/cases/associations_test.rb
@@ -214,6 +214,10 @@ class AssociationProxyTest < ActiveRecord::TestCase
     david = developers(:david)
     assert_equal david.association(:projects), david.projects.proxy_association
   end
+
+  def test_scoped_allows_conditions
+    assert developers(:david).projects.scoped(where: 'foo').where_values.include?('foo')
+  end
 end
 
 class OverridingAssociationsTest < ActiveRecord::TestCase
-- 
cgit v1.2.3


From 0ed05b0e7379e0a6aa47c5677b90383b9f0132b2 Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 27 Apr 2012 12:37:21 +0100
Subject: find and replace deprecated keys

---
 .../cases/adapters/mysql/reserved_word_test.rb     |   2 +-
 .../cases/adapters/mysql2/reserved_word_test.rb    |   2 +-
 .../associations/belongs_to_associations_test.rb   |   4 +-
 .../associations/cascaded_eager_loading_test.rb    |  28 ++---
 .../associations/eager_load_nested_include_test.rb |   2 +-
 .../associations/eager_singularization_test.rb     |  14 +--
 activerecord/test/cases/associations/eager_test.rb | 126 ++++++++++-----------
 .../has_and_belongs_to_many_associations_test.rb   |  14 +--
 .../associations/has_many_associations_test.rb     |  48 ++++----
 .../associations/has_one_associations_test.rb      |   2 +-
 .../has_one_through_associations_test.rb           |  14 +--
 .../associations/inverse_associations_test.rb      |  18 +--
 .../test/cases/associations/join_model_test.rb     |  30 ++---
 activerecord/test/cases/associations_test.rb       |   4 +-
 .../test/cases/autosave_association_test.rb        |   2 +-
 activerecord/test/cases/base_test.rb               |  10 +-
 activerecord/test/cases/finder_test.rb             |  92 +++++++--------
 activerecord/test/cases/inheritance_test.rb        |  14 +--
 activerecord/test/cases/named_scope_test.rb        |  10 +-
 activerecord/test/cases/relations_test.rb          |   2 +-
 activerecord/test/models/comment.rb                |   2 +-
 21 files changed, 220 insertions(+), 220 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/adapters/mysql/reserved_word_test.rb b/activerecord/test/cases/adapters/mysql/reserved_word_test.rb
index 67a4112fc8..6faceaf7c0 100644
--- a/activerecord/test/cases/adapters/mysql/reserved_word_test.rb
+++ b/activerecord/test/cases/adapters/mysql/reserved_word_test.rb
@@ -130,7 +130,7 @@ class MysqlReservedWordTest < ActiveRecord::TestCase
   end
 
   def test_associations_work_with_reserved_words
-    assert_nothing_raised { Select.scoped(:include => [:groups]).all }
+    assert_nothing_raised { Select.scoped(:includes => [:groups]).all }
   end
 
   #the following functions were added to DRY test cases
diff --git a/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb b/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
index 7c3af5874b..32d4282623 100644
--- a/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
@@ -130,7 +130,7 @@ class MysqlReservedWordTest < ActiveRecord::TestCase
   end
 
   def test_associations_work_with_reserved_words
-    assert_nothing_raised { Select.scoped(:include => [:groups]).all }
+    assert_nothing_raised { Select.scoped(:includes => [:groups]).all }
   end
 
   #the following functions were added to DRY test cases
diff --git a/activerecord/test/cases/associations/belongs_to_associations_test.rb b/activerecord/test/cases/associations/belongs_to_associations_test.rb
index 65a353fdaf..0d6ba9dab1 100644
--- a/activerecord/test/cases/associations/belongs_to_associations_test.rb
+++ b/activerecord/test/cases/associations/belongs_to_associations_test.rb
@@ -73,14 +73,14 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   def test_eager_loading_with_primary_key
     Firm.create("name" => "Apple")
     Client.create("name" => "Citibank", :firm_name => "Apple")
-    citibank_result = Client.scoped(:conditions => {:name => "Citibank"}, :include => :firm_with_primary_key).first
+    citibank_result = Client.scoped(:where => {:name => "Citibank"}, :includes => :firm_with_primary_key).first
     assert citibank_result.association_cache.key?(:firm_with_primary_key)
   end
 
   def test_eager_loading_with_primary_key_as_symbol
     Firm.create("name" => "Apple")
     Client.create("name" => "Citibank", :firm_name => "Apple")
-    citibank_result = Client.scoped(:conditions => {:name => "Citibank"}, :include => :firm_with_primary_key_symbols).first
+    citibank_result = Client.scoped(:where => {:name => "Citibank"}, :includes => :firm_with_primary_key_symbols).first
     assert citibank_result.association_cache.key?(:firm_with_primary_key_symbols)
   end
 
diff --git a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
index 6ffb8cd2d2..01f7f18397 100644
--- a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
+++ b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
@@ -16,7 +16,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
            :categorizations, :people, :categories, :edges, :vertices
 
   def test_eager_association_loading_with_cascaded_two_levels
-    authors = Author.scoped(:include=>{:posts=>:comments}, :order=>"authors.id").all
+    authors = Author.scoped(:includes=>{:posts=>:comments}, :order=>"authors.id").all
     assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal 3, authors[1].posts.size
@@ -24,7 +24,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_and_one_level
-    authors = Author.scoped(:include=>[{:posts=>:comments}, :categorizations], :order=>"authors.id").all
+    authors = Author.scoped(:includes=>[{:posts=>:comments}, :categorizations], :order=>"authors.id").all
     assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal 3, authors[1].posts.size
@@ -84,7 +84,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_with_two_has_many_associations
-    authors = Author.scoped(:include=>{:posts=>[:comments, :categorizations]}, :order=>"authors.id").all
+    authors = Author.scoped(:includes=>{:posts=>[:comments, :categorizations]}, :order=>"authors.id").all
     assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal 3, authors[1].posts.size
@@ -92,7 +92,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_and_self_table_reference
-    authors = Author.scoped(:include=>{:posts=>[:comments, :author]}, :order=>"authors.id").all
+    authors = Author.scoped(:includes=>{:posts=>[:comments, :author]}, :order=>"authors.id").all
     assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal authors(:david).name, authors[0].name
@@ -100,13 +100,13 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_with_condition
-    authors = Author.scoped(:include=>{:posts=>:comments}, :conditions=>"authors.id=1", :order=>"authors.id").all
+    authors = Author.scoped(:includes=>{:posts=>:comments}, :where=>"authors.id=1", :order=>"authors.id").all
     assert_equal 1, authors.size
     assert_equal 5, authors[0].posts.size
   end
 
   def test_eager_association_loading_with_cascaded_three_levels_by_ping_pong
-    firms = Firm.scoped(:include=>{:account=>{:firm=>:account}}, :order=>"companies.id").all
+    firms = Firm.scoped(:includes=>{:account=>{:firm=>:account}}, :order=>"companies.id").all
     assert_equal 2, firms.size
     assert_equal firms.first.account, firms.first.account.firm.account
     assert_equal companies(:first_firm).account, assert_no_queries { firms.first.account.firm.account }
@@ -114,7 +114,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_has_many_sti
-    topics = Topic.scoped(:include => :replies, :order => 'topics.id').all
+    topics = Topic.scoped(:includes => :replies, :order => 'topics.id').all
     first, second, = topics(:first).replies.size, topics(:second).replies.size
     assert_no_queries do
       assert_equal first, topics[0].replies.size
@@ -127,7 +127,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
     silly.parent_id = 1
     assert silly.save
 
-    topics = Topic.scoped(:include => :replies, :order => ['topics.id', 'replies_topics.id']).all
+    topics = Topic.scoped(:includes => :replies, :order => ['topics.id', 'replies_topics.id']).all
     assert_no_queries do
       assert_equal 2, topics[0].replies.size
       assert_equal 0, topics[1].replies.size
@@ -135,14 +135,14 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_belongs_to_sti
-    replies = Reply.scoped(:include => :topic, :order => 'topics.id').all
+    replies = Reply.scoped(:includes => :topic, :order => 'topics.id').all
     assert replies.include?(topics(:second))
     assert !replies.include?(topics(:first))
     assert_equal topics(:first), assert_no_queries { replies.first.topic }
   end
 
   def test_eager_association_loading_with_multiple_stis_and_order
-    author = Author.scoped(:include => { :posts => [ :special_comments , :very_special_comment ] }, :order => ['authors.name', 'comments.body', 'very_special_comments_posts.body'], :conditions => 'posts.id = 4').first
+    author = Author.scoped(:includes => { :posts => [ :special_comments , :very_special_comment ] }, :order => ['authors.name', 'comments.body', 'very_special_comments_posts.body'], :where => 'posts.id = 4').first
     assert_equal authors(:david), author
     assert_no_queries do
       author.posts.first.special_comments
@@ -151,7 +151,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_of_stis_with_multiple_references
-    authors = Author.scoped(:include => { :posts => { :special_comments => { :post => [ :special_comments, :very_special_comment ] } } }, :order => 'comments.body, very_special_comments_posts.body', :conditions => 'posts.id = 4').all
+    authors = Author.scoped(:includes => { :posts => { :special_comments => { :post => [ :special_comments, :very_special_comment ] } } }, :order => 'comments.body, very_special_comments_posts.body', :where => 'posts.id = 4').all
     assert_equal [authors(:david)], authors
     assert_no_queries do
       authors.first.posts.first.special_comments.first.post.special_comments
@@ -160,7 +160,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_where_first_level_returns_nil
-    authors = Author.scoped(:include => {:post_about_thinking => :comments}, :order => 'authors.id DESC').all
+    authors = Author.scoped(:includes => {:post_about_thinking => :comments}, :order => 'authors.id DESC').all
     assert_equal [authors(:bob), authors(:mary), authors(:david)], authors
     assert_no_queries do
       authors[2].post_about_thinking.comments.first
@@ -168,12 +168,12 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_recursive_cascading_four_levels_has_many_through
-    source = Vertex.scoped(:include=>{:sinks=>{:sinks=>{:sinks=>:sinks}}}, :order => 'vertices.id').first
+    source = Vertex.scoped(:includes=>{:sinks=>{:sinks=>{:sinks=>:sinks}}}, :order => 'vertices.id').first
     assert_equal vertices(:vertex_4), assert_no_queries { source.sinks.first.sinks.first.sinks.first }
   end
 
   def test_eager_association_loading_with_recursive_cascading_four_levels_has_and_belongs_to_many
-    sink = Vertex.scoped(:include=>{:sources=>{:sources=>{:sources=>:sources}}}, :order => 'vertices.id DESC').first
+    sink = Vertex.scoped(:includes=>{:sources=>{:sources=>{:sources=>:sources}}}, :order => 'vertices.id DESC').first
     assert_equal vertices(:vertex_1), assert_no_queries { sink.sources.first.sources.first.sources.first.sources.first }
   end
 end
diff --git a/activerecord/test/cases/associations/eager_load_nested_include_test.rb b/activerecord/test/cases/associations/eager_load_nested_include_test.rb
index b034f0fe56..861a395c58 100644
--- a/activerecord/test/cases/associations/eager_load_nested_include_test.rb
+++ b/activerecord/test/cases/associations/eager_load_nested_include_test.rb
@@ -93,7 +93,7 @@ class EagerLoadPolyAssocsTest < ActiveRecord::TestCase
 
   def test_include_query
     res = 0
-    res = ShapeExpression.scoped(:include => [ :shape, { :paint => :non_poly } ]).all
+    res = ShapeExpression.scoped(:includes => [ :shape, { :paint => :non_poly } ]).all
     assert_equal NUM_SHAPE_EXPRESSIONS, res.size
     assert_queries(0) do
       res.each do |se|
diff --git a/activerecord/test/cases/associations/eager_singularization_test.rb b/activerecord/test/cases/associations/eager_singularization_test.rb
index 1c635fcd96..5805e71249 100644
--- a/activerecord/test/cases/associations/eager_singularization_test.rb
+++ b/activerecord/test/cases/associations/eager_singularization_test.rb
@@ -103,43 +103,43 @@ class EagerSingularizationTest < ActiveRecord::TestCase
   def test_eager_no_extra_singularization_belongs_to
     return unless @have_tables
     assert_nothing_raised do
-      Virus.scoped(:include => :octopus).all
+      Virus.scoped(:includes => :octopus).all
     end
   end
 
   def test_eager_no_extra_singularization_has_one
     return unless @have_tables
     assert_nothing_raised do
-      Octopus.scoped(:include => :virus).all
+      Octopus.scoped(:includes => :virus).all
     end
   end
 
   def test_eager_no_extra_singularization_has_many
     return unless @have_tables
     assert_nothing_raised do
-      Bus.scoped(:include => :passes).all
+      Bus.scoped(:includes => :passes).all
     end
   end
 
   def test_eager_no_extra_singularization_has_and_belongs_to_many
     return unless @have_tables
     assert_nothing_raised do
-      Crisis.scoped(:include => :messes).all
-      Mess.scoped(:include => :crises).all
+      Crisis.scoped(:includes => :messes).all
+      Mess.scoped(:includes => :crises).all
     end
   end
 
   def test_eager_no_extra_singularization_has_many_through_belongs_to
     return unless @have_tables
     assert_nothing_raised do
-      Crisis.scoped(:include => :successes).all
+      Crisis.scoped(:includes => :successes).all
     end
   end
 
   def test_eager_no_extra_singularization_has_many_through_has_many
     return unless @have_tables
     assert_nothing_raised do
-      Crisis.scoped(:include => :compresses).all
+      Crisis.scoped(:includes => :compresses).all
     end
   end
 end
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index 172182e5bf..781d244bf7 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -40,22 +40,22 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_loading_with_one_association
-    posts = Post.scoped(:include => :comments).all
+    posts = Post.scoped(:includes => :comments).all
     post = posts.find { |p| p.id == 1 }
     assert_equal 2, post.comments.size
     assert post.comments.include?(comments(:greetings))
 
-    post = Post.scoped(:include => :comments, :conditions => "posts.title = 'Welcome to the weblog'").first
+    post = Post.scoped(:includes => :comments, :where => "posts.title = 'Welcome to the weblog'").first
     assert_equal 2, post.comments.size
     assert post.comments.include?(comments(:greetings))
 
-    posts = Post.scoped(:include => :last_comment).all
+    posts = Post.scoped(:includes => :last_comment).all
     post = posts.find { |p| p.id == 1 }
     assert_equal Post.find(1).last_comment, post.last_comment
   end
 
   def test_loading_with_one_association_with_non_preload
-    posts = Post.scoped(:include => :last_comment, :order => 'comments.id DESC').all
+    posts = Post.scoped(:includes => :last_comment, :order => 'comments.id DESC').all
     post = posts.find { |p| p.id == 1 }
     assert_equal Post.find(1).last_comment, post.last_comment
   end
@@ -70,7 +70,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_with_ordering
-    list = Post.scoped(:include => :comments, :order => "posts.id DESC").all
+    list = Post.scoped(:includes => :comments, :order => "posts.id DESC").all
     [:other_by_mary, :other_by_bob, :misc_by_mary, :misc_by_bob, :eager_other,
      :sti_habtm, :sti_post_and_comments, :sti_comments, :authorless, :thinking, :welcome
     ].each_with_index do |post, index|
@@ -84,14 +84,14 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_loading_with_multiple_associations
-    posts = Post.scoped(:include => [ :comments, :author, :categories ], :order => "posts.id").all
+    posts = Post.scoped(:includes => [ :comments, :author, :categories ], :order => "posts.id").all
     assert_equal 2, posts.first.comments.size
     assert_equal 2, posts.first.categories.size
     assert posts.first.comments.include?(comments(:greetings))
   end
 
   def test_duplicate_middle_objects
-    comments = Comment.scoped(:conditions => 'post_id = 1', :include => [:post => :author]).all
+    comments = Comment.scoped(:where => 'post_id = 1', :includes => [:post => :author]).all
     assert_no_queries do
       comments.each {|comment| comment.post.author.name}
     end
@@ -99,25 +99,25 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_preloading_has_many_in_multiple_queries_with_more_ids_than_database_can_handle
     Post.connection.expects(:in_clause_length).at_least_once.returns(5)
-    posts = Post.scoped(:include=>:comments).all
+    posts = Post.scoped(:includes=>:comments).all
     assert_equal 11, posts.size
   end
 
   def test_preloading_has_many_in_one_queries_when_database_has_no_limit_on_ids_it_can_handle
     Post.connection.expects(:in_clause_length).at_least_once.returns(nil)
-    posts = Post.scoped(:include=>:comments).all
+    posts = Post.scoped(:includes=>:comments).all
     assert_equal 11, posts.size
   end
 
   def test_preloading_habtm_in_multiple_queries_with_more_ids_than_database_can_handle
     Post.connection.expects(:in_clause_length).at_least_once.returns(5)
-    posts = Post.scoped(:include=>:categories).all
+    posts = Post.scoped(:includes=>:categories).all
     assert_equal 11, posts.size
   end
 
   def test_preloading_habtm_in_one_queries_when_database_has_no_limit_on_ids_it_can_handle
     Post.connection.expects(:in_clause_length).at_least_once.returns(nil)
-    posts = Post.scoped(:include=>:categories).all
+    posts = Post.scoped(:includes=>:categories).all
     assert_equal 11, posts.size
   end
 
@@ -234,13 +234,13 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_loading_from_an_association
-    posts = authors(:david).posts.scoped(:include => :comments, :order => "posts.id").all
+    posts = authors(:david).posts.scoped(:includes => :comments, :order => "posts.id").all
     assert_equal 2, posts.first.comments.size
   end
 
   def test_loading_from_an_association_that_has_a_hash_of_conditions
     assert_nothing_raised do
-      Author.scoped(:include => :hello_posts_with_hash_conditions).all
+      Author.scoped(:includes => :hello_posts_with_hash_conditions).all
     end
     assert !Author.find(authors(:david).id, :include => :hello_posts_with_hash_conditions).hello_posts.empty?
   end
@@ -300,12 +300,12 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_belongs_to_and_foreign_keys
-    pets = Pet.scoped(:include => :owner).all
+    pets = Pet.scoped(:includes => :owner).all
     assert_equal 3, pets.length
   end
 
   def test_eager_association_loading_with_belongs_to
-    comments = Comment.scoped(:include => :post).all
+    comments = Comment.scoped(:includes => :post).all
     assert_equal 11, comments.length
     titles = comments.map { |c| c.post.title }
     assert titles.include?(posts(:welcome).title)
@@ -313,31 +313,31 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit
-    comments = Comment.scoped(:include => :post, :limit => 5, :order => 'comments.id').all
+    comments = Comment.scoped(:includes => :post, :limit => 5, :order => 'comments.id').all
     assert_equal 5, comments.length
     assert_equal [1,2,3,5,6], comments.collect { |c| c.id }
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_conditions
-    comments = Comment.scoped(:include => :post, :conditions => 'post_id = 4', :limit => 3, :order => 'comments.id').all
+    comments = Comment.scoped(:includes => :post, :where => 'post_id = 4', :limit => 3, :order => 'comments.id').all
     assert_equal 3, comments.length
     assert_equal [5,6,7], comments.collect { |c| c.id }
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_offset
-    comments = Comment.scoped(:include => :post, :limit => 3, :offset => 2, :order => 'comments.id').all
+    comments = Comment.scoped(:includes => :post, :limit => 3, :offset => 2, :order => 'comments.id').all
     assert_equal 3, comments.length
     assert_equal [3,5,6], comments.collect { |c| c.id }
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_conditions
-    comments = Comment.scoped(:include => :post, :conditions => 'post_id = 4', :limit => 3, :offset => 1, :order => 'comments.id').all
+    comments = Comment.scoped(:includes => :post, :where => 'post_id = 4', :limit => 3, :offset => 1, :order => 'comments.id').all
     assert_equal 3, comments.length
     assert_equal [6,7,8], comments.collect { |c| c.id }
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_conditions_array
-    comments = Comment.scoped(:include => :post, :conditions => ['post_id = ?',4], :limit => 3, :offset => 1, :order => 'comments.id').all
+    comments = Comment.scoped(:includes => :post, :where => ['post_id = ?',4], :limit => 3, :offset => 1, :order => 'comments.id').all
     assert_equal 3, comments.length
     assert_equal [6,7,8], comments.collect { |c| c.id }
   end
@@ -345,7 +345,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_eager_association_loading_with_belongs_to_and_conditions_string_with_unquoted_table_name
     assert_nothing_raised do
       ActiveSupport::Deprecation.silence do
-        Comment.scoped(:include => :post, :conditions => ['posts.id = ?',4]).all
+        Comment.scoped(:includes => :post, :where => ['posts.id = ?',4]).all
       end
     end
   end
@@ -353,7 +353,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_eager_association_loading_with_belongs_to_and_conditions_hash
     comments = []
     assert_nothing_raised do
-      comments = Comment.scoped(:include => :post, :conditions => {:posts => {:id => 4}}, :limit => 3, :order => 'comments.id').all
+      comments = Comment.scoped(:includes => :post, :where => {:posts => {:id => 4}}, :limit => 3, :order => 'comments.id').all
     end
     assert_equal 3, comments.length
     assert_equal [5,6,7], comments.collect { |c| c.id }
@@ -366,14 +366,14 @@ class EagerAssociationTest < ActiveRecord::TestCase
     quoted_posts_id= Comment.connection.quote_table_name('posts') + '.' + Comment.connection.quote_column_name('id')
     assert_nothing_raised do
       ActiveSupport::Deprecation.silence do
-        Comment.scoped(:include => :post, :conditions => ["#{quoted_posts_id} = ?",4]).all
+        Comment.scoped(:includes => :post, :where => ["#{quoted_posts_id} = ?",4]).all
       end
     end
   end
 
   def test_eager_association_loading_with_belongs_to_and_order_string_with_unquoted_table_name
     assert_nothing_raised do
-      Comment.scoped(:include => :post, :order => 'posts.id').all
+      Comment.scoped(:includes => :post, :order => 'posts.id').all
     end
   end
 
@@ -381,25 +381,25 @@ class EagerAssociationTest < ActiveRecord::TestCase
     quoted_posts_id= Comment.connection.quote_table_name('posts') + '.' + Comment.connection.quote_column_name('id')
     assert_nothing_raised do
       ActiveSupport::Deprecation.silence do
-        Comment.scoped(:include => :post, :order => quoted_posts_id).all
+        Comment.scoped(:includes => :post, :order => quoted_posts_id).all
       end
     end
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_multiple_associations
-    posts = Post.scoped(:include => [:author, :very_special_comment], :limit => 1, :order => 'posts.id').all
+    posts = Post.scoped(:includes => [:author, :very_special_comment], :limit => 1, :order => 'posts.id').all
     assert_equal 1, posts.length
     assert_equal [1], posts.collect { |p| p.id }
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_multiple_associations
-    posts = Post.scoped(:include => [:author, :very_special_comment], :limit => 1, :offset => 1, :order => 'posts.id').all
+    posts = Post.scoped(:includes => [:author, :very_special_comment], :limit => 1, :offset => 1, :order => 'posts.id').all
     assert_equal 1, posts.length
     assert_equal [2], posts.collect { |p| p.id }
   end
 
   def test_eager_association_loading_with_belongs_to_inferred_foreign_key_from_association_name
-    author_favorite = AuthorFavorite.scoped(:include => :favorite_author).first
+    author_favorite = AuthorFavorite.scoped(:includes => :favorite_author).first
     assert_equal authors(:mary), assert_no_queries { author_favorite.favorite_author }
   end
 
@@ -458,14 +458,14 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_explicit_join
-    posts = Post.scoped(:include => :comments, :joins => "INNER JOIN authors ON posts.author_id = authors.id AND authors.name = 'Mary'", :limit => 1, :order => 'author_id').all
+    posts = Post.scoped(:includes => :comments, :joins => "INNER JOIN authors ON posts.author_id = authors.id AND authors.name = 'Mary'", :limit => 1, :order => 'author_id').all
     assert_equal 1, posts.length
   end
 
   def test_eager_with_has_many_through
-    posts_with_comments = people(:michael).posts.scoped(:include => :comments, :order => 'posts.id').all
-    posts_with_author = people(:michael).posts.scoped(:include => :author, :order => 'posts.id').all
-    posts_with_comments_and_author = people(:michael).posts.scoped(:include => [ :comments, :author ], :order => 'posts.id').all
+    posts_with_comments = people(:michael).posts.scoped(:includes => :comments, :order => 'posts.id').all
+    posts_with_author = people(:michael).posts.scoped(:includes => :author, :order => 'posts.id').all
+    posts_with_comments_and_author = people(:michael).posts.scoped(:includes => [ :comments, :author ], :order => 'posts.id').all
     assert_equal 2, posts_with_comments.inject(0) { |sum, post| sum += post.comments.size }
     assert_equal authors(:david), assert_no_queries { posts_with_author.first.author }
     assert_equal authors(:david), assert_no_queries { posts_with_comments_and_author.first.author }
@@ -476,17 +476,17 @@ class EagerAssociationTest < ActiveRecord::TestCase
     Post.create!(:author => author, :title => "TITLE", :body => "BODY")
     author.author_favorites.create(:favorite_author_id => 1)
     author.author_favorites.create(:favorite_author_id => 2)
-    posts_with_author_favorites = author.posts.scoped(:include => :author_favorites).all
+    posts_with_author_favorites = author.posts.scoped(:includes => :author_favorites).all
     assert_no_queries { posts_with_author_favorites.first.author_favorites.first.author_id }
   end
 
   def test_eager_with_has_many_through_an_sti_join_model
-    author = Author.scoped(:include => :special_post_comments, :order => 'authors.id').first
+    author = Author.scoped(:includes => :special_post_comments, :order => 'authors.id').first
     assert_equal [comments(:does_it_hurt)], assert_no_queries { author.special_post_comments }
   end
 
   def test_eager_with_has_many_through_an_sti_join_model_with_conditions_on_both
-    author = Author.scoped(:include => :special_nonexistant_post_comments, :order => 'authors.id').first
+    author = Author.scoped(:includes => :special_nonexistant_post_comments, :order => 'authors.id').first
     assert_equal [], author.special_nonexistant_post_comments
   end
 
@@ -520,16 +520,16 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_has_many_and_limit
-    posts = Post.scoped(:order => 'posts.id asc', :include => [ :author, :comments ], :limit => 2).all
+    posts = Post.scoped(:order => 'posts.id asc', :includes => [ :author, :comments ], :limit => 2).all
     assert_equal 2, posts.size
     assert_equal 3, posts.inject(0) { |sum, post| sum += post.comments.size }
   end
 
   def test_eager_with_has_many_and_limit_and_conditions
     if current_adapter?(:OpenBaseAdapter)
-      posts = Post.scoped(:include => [ :author, :comments ], :limit => 2, :conditions => "FETCHBLOB(posts.body) = 'hello'", :order => "posts.id").all
+      posts = Post.scoped(:includes => [ :author, :comments ], :limit => 2, :where => "FETCHBLOB(posts.body) = 'hello'", :order => "posts.id").all
     else
-      posts = Post.scoped(:include => [ :author, :comments ], :limit => 2, :conditions => "posts.body = 'hello'", :order => "posts.id").all
+      posts = Post.scoped(:includes => [ :author, :comments ], :limit => 2, :where => "posts.body = 'hello'", :order => "posts.id").all
     end
     assert_equal 2, posts.size
     assert_equal [4,5], posts.collect { |p| p.id }
@@ -537,9 +537,9 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_with_has_many_and_limit_and_conditions_array
     if current_adapter?(:OpenBaseAdapter)
-      posts = Post.scoped(:include => [ :author, :comments ], :limit => 2, :conditions => [ "FETCHBLOB(posts.body) = ?", 'hello' ], :order => "posts.id").all
+      posts = Post.scoped(:includes => [ :author, :comments ], :limit => 2, :where => [ "FETCHBLOB(posts.body) = ?", 'hello' ], :order => "posts.id").all
     else
-      posts = Post.scoped(:include => [ :author, :comments ], :limit => 2, :conditions => [ "posts.body = ?", 'hello' ], :order => "posts.id").all
+      posts = Post.scoped(:includes => [ :author, :comments ], :limit => 2, :where => [ "posts.body = ?", 'hello' ], :order => "posts.id").all
     end
     assert_equal 2, posts.size
     assert_equal [4,5], posts.collect { |p| p.id }
@@ -547,7 +547,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_with_has_many_and_limit_and_conditions_array_on_the_eagers
     posts = ActiveSupport::Deprecation.silence do
-      Post.scoped(:include => [ :author, :comments ], :limit => 2, :conditions => [ "authors.name = ?", 'David' ]).all
+      Post.scoped(:includes => [ :author, :comments ], :limit => 2, :where => [ "authors.name = ?", 'David' ]).all
     end
     assert_equal 2, posts.size
 
@@ -558,7 +558,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_has_many_and_limit_and_high_offset
-    posts = Post.scoped(:include => [ :author, :comments ], :limit => 2, :offset => 10, :conditions => { 'authors.name' => 'David' }).all
+    posts = Post.scoped(:includes => [ :author, :comments ], :limit => 2, :offset => 10, :where => { 'authors.name' => 'David' }).all
     assert_equal 0, posts.size
   end
 
@@ -602,7 +602,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_has_and_belongs_to_many_and_limit
-    posts = Post.scoped(:include => :categories, :order => "posts.id", :limit => 3).all
+    posts = Post.scoped(:includes => :categories, :order => "posts.id", :limit => 3).all
     assert_equal 3, posts.size
     assert_equal 2, posts[0].categories.size
     assert_equal 1, posts[1].categories.size
@@ -668,7 +668,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_habtm
-    posts = Post.scoped(:include => :categories, :order => "posts.id").all
+    posts = Post.scoped(:includes => :categories, :order => "posts.id").all
     assert_equal 2, posts[0].categories.size
     assert_equal 1, posts[1].categories.size
     assert_equal 0, posts[2].categories.size
@@ -677,7 +677,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_inheritance
-    SpecialPost.scoped(:include => [ :comments ]).all
+    SpecialPost.scoped(:includes => [ :comments ]).all
   end
 
   def test_eager_has_one_with_association_inheritance
@@ -771,7 +771,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def find_all_ordered(className, include=nil)
-    className.scoped(:order=>"#{className.table_name}.#{className.primary_key}", :include=>include).all
+    className.scoped(:order=>"#{className.table_name}.#{className.primary_key}", :includes=>include).all
   end
 
   def test_limited_eager_with_order
@@ -881,13 +881,13 @@ class EagerAssociationTest < ActiveRecord::TestCase
     end
   end
   def test_eager_with_valid_association_as_string_not_symbol
-    assert_nothing_raised { Post.scoped(:include => 'comments').all }
+    assert_nothing_raised { Post.scoped(:includes => 'comments').all }
   end
 
   def test_eager_with_floating_point_numbers
     assert_queries(2) do
       # Before changes, the floating point numbers will be interpreted as table names and will cause this to run in one query
-      Comment.scoped(:conditions => "123.456 = 123.456", :include => :post).all
+      Comment.scoped(:where => "123.456 = 123.456", :includes => :post).all
     end
   end
 
@@ -946,16 +946,16 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_conditions_on_join_table_with_include_and_limit
-    assert_equal 3, Developer.scoped(:include => 'projects', :conditions => { 'developers_projects.access_level' => 1 }, :limit => 5).all.size
+    assert_equal 3, Developer.scoped(:includes => 'projects', :where => { 'developers_projects.access_level' => 1 }, :limit => 5).all.size
   end
 
   def test_order_on_join_table_with_include_and_limit
-    assert_equal 5, Developer.scoped(:include => 'projects', :order => 'developers_projects.joined_on DESC', :limit => 5).all.size
+    assert_equal 5, Developer.scoped(:includes => 'projects', :order => 'developers_projects.joined_on DESC', :limit => 5).all.size
   end
 
   def test_eager_loading_with_order_on_joined_table_preloads
     posts = assert_queries(2) do
-      Post.scoped(:joins => :comments, :include => :author, :order => 'comments.id DESC').all
+      Post.scoped(:joins => :comments, :includes => :author, :order => 'comments.id DESC').all
     end
     assert_equal posts(:eager_other), posts[1]
     assert_equal authors(:mary), assert_no_queries { posts[1].author}
@@ -963,24 +963,24 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_loading_with_conditions_on_joined_table_preloads
     posts = assert_queries(2) do
-      Post.scoped(:select => 'distinct posts.*', :include => :author, :joins => [:comments], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id').all
+      Post.scoped(:select => 'distinct posts.*', :includes => :author, :joins => [:comments], :where => "comments.body like 'Thank you%'", :order => 'posts.id').all
     end
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author}
 
     posts = assert_queries(2) do
-      Post.scoped(:select => 'distinct posts.*', :include => :author, :joins => [:comments], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id').all
+      Post.scoped(:select => 'distinct posts.*', :includes => :author, :joins => [:comments], :where => "comments.body like 'Thank you%'", :order => 'posts.id').all
     end
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author}
 
     posts = assert_queries(2) do
-      Post.scoped(:include => :author, :joins => {:taggings => :tag}, :conditions => "tags.name = 'General'", :order => 'posts.id').all
+      Post.scoped(:includes => :author, :joins => {:taggings => :tag}, :where => "tags.name = 'General'", :order => 'posts.id').all
     end
     assert_equal posts(:welcome, :thinking), posts
 
     posts = assert_queries(2) do
-      Post.scoped(:include => :author, :joins => {:taggings => {:tag => :taggings}}, :conditions => "taggings_tags.super_tag_id=2", :order => 'posts.id').all
+      Post.scoped(:includes => :author, :joins => {:taggings => {:tag => :taggings}}, :where => "taggings_tags.super_tag_id=2", :order => 'posts.id').all
     end
     assert_equal posts(:welcome, :thinking), posts
 
@@ -988,13 +988,13 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_loading_with_conditions_on_string_joined_table_preloads
     posts = assert_queries(2) do
-      Post.scoped(:select => 'distinct posts.*', :include => :author, :joins => "INNER JOIN comments on comments.post_id = posts.id", :conditions => "comments.body like 'Thank you%'", :order => 'posts.id').all
+      Post.scoped(:select => 'distinct posts.*', :includes => :author, :joins => "INNER JOIN comments on comments.post_id = posts.id", :where => "comments.body like 'Thank you%'", :order => 'posts.id').all
     end
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author}
 
     posts = assert_queries(2) do
-      Post.scoped(:select => 'distinct posts.*', :include => :author, :joins => ["INNER JOIN comments on comments.post_id = posts.id"], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id').all
+      Post.scoped(:select => 'distinct posts.*', :includes => :author, :joins => ["INNER JOIN comments on comments.post_id = posts.id"], :where => "comments.body like 'Thank you%'", :order => 'posts.id').all
     end
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author}
@@ -1003,7 +1003,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_loading_with_select_on_joined_table_preloads
     posts = assert_queries(2) do
-      Post.scoped(:select => 'posts.*, authors.name as author_name', :include => :comments, :joins => :author, :order => 'posts.id').all
+      Post.scoped(:select => 'posts.*, authors.name as author_name', :includes => :comments, :joins => :author, :order => 'posts.id').all
     end
     assert_equal 'David', posts[0].author_name
     assert_equal posts(:welcome).comments, assert_no_queries { posts[0].comments}
@@ -1013,14 +1013,14 @@ class EagerAssociationTest < ActiveRecord::TestCase
     Author.columns
 
     authors = assert_queries(2) do
-      Author.scoped(:include => :author_address, :joins => :comments, :conditions => "posts.title like 'Welcome%'").all
+      Author.scoped(:includes => :author_address, :joins => :comments, :where => "posts.title like 'Welcome%'").all
     end
     assert_equal authors(:david), authors[0]
     assert_equal author_addresses(:david_address), authors[0].author_address
   end
 
   def test_preload_belongs_to_uses_exclusive_scope
-    people = Person.males.scoped(:include => :primary_contact).all
+    people = Person.males.scoped(:includes => :primary_contact).all
     assert_not_equal people.length, 0
     people.each do |person|
       assert_no_queries {assert_not_nil person.primary_contact}
@@ -1058,7 +1058,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_preload_has_one_using_primary_key
     expected = accounts(:signals37)
-    firm = Firm.scoped(:include => :account_using_primary_key, :order => 'companies.id').first
+    firm = Firm.scoped(:includes => :account_using_primary_key, :order => 'companies.id').first
     assert_no_queries do
       assert_equal expected, firm.account_using_primary_key
     end
@@ -1066,7 +1066,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_include_has_one_using_primary_key
     expected = accounts(:signals37)
-    firm = Firm.scoped(:include => :account_using_primary_key, :order => 'accounts.id').all.detect {|f| f.id == 1}
+    firm = Firm.scoped(:includes => :account_using_primary_key, :order => 'accounts.id').all.detect {|f| f.id == 1}
     assert_no_queries do
       assert_equal expected, firm.account_using_primary_key
     end
@@ -1130,7 +1130,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_deep_including_through_habtm
-    posts = Post.scoped(:include => {:categories => :categorizations}, :order => "posts.id").all
+    posts = Post.scoped(:includes => {:categories => :categorizations}, :order => "posts.id").all
     assert_no_queries { assert_equal 2, posts[0].categories[0].categorizations.length }
     assert_no_queries { assert_equal 1, posts[0].categories[1].categorizations.length }
     assert_no_queries { assert_equal 2, posts[1].categories[0].categorizations.length }
diff --git a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
index 15f10285d1..7ddaf78848 100644
--- a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
@@ -549,14 +549,14 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_find_with_merged_options
     assert_equal 1, projects(:active_record).limited_developers.size
     assert_equal 1, projects(:active_record).limited_developers.all.size
-    assert_equal 3, projects(:active_record).limited_developers.scoped(:limit => nil).all.size
+    assert_equal 3, projects(:active_record).limited_developers.limit(nil).all.size
   end
 
   def test_dynamic_find_should_respect_association_order
     # Developers are ordered 'name DESC, id DESC'
     high_id_jamis = projects(:active_record).developers.create(:name => 'Jamis')
 
-    assert_equal high_id_jamis, projects(:active_record).developers.scoped(:conditions => "name = 'Jamis'").first
+    assert_equal high_id_jamis, projects(:active_record).developers.scoped(:where => "name = 'Jamis'").first
     assert_equal high_id_jamis, projects(:active_record).developers.find_by_name('Jamis')
   end
 
@@ -566,7 +566,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     middle_id_jamis = developers(:poor_jamis)
     high_id_jamis = projects(:active_record).developers.create(:name => 'Jamis')
 
-    assert_equal [high_id_jamis, middle_id_jamis, low_id_jamis], projects(:active_record).developers.scoped(:conditions => "name = 'Jamis'").all
+    assert_equal [high_id_jamis, middle_id_jamis, low_id_jamis], projects(:active_record).developers.scoped(:where => "name = 'Jamis'").all
     assert_equal [high_id_jamis, middle_id_jamis, low_id_jamis], projects(:active_record).developers.find_all_by_name('Jamis')
   end
 
@@ -576,12 +576,12 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_dynamic_find_all_should_respect_association_limit
-    assert_equal 1, projects(:active_record).limited_developers.scoped(:conditions => "name = 'Jamis'").all.length
+    assert_equal 1, projects(:active_record).limited_developers.scoped(:where => "name = 'Jamis'").all.length
     assert_equal 1, projects(:active_record).limited_developers.find_all_by_name('Jamis').length
   end
 
   def test_dynamic_find_all_order_should_override_association_limit
-    assert_equal 2, projects(:active_record).limited_developers.scoped(:conditions => "name = 'Jamis'", :limit => 9_000).all.length
+    assert_equal 2, projects(:active_record).limited_developers.scoped(:where => "name = 'Jamis'", :limit => 9_000).all.length
     assert_equal 2, projects(:active_record).limited_developers.find_all_by_name('Jamis', :limit => 9_000).length
   end
 
@@ -705,8 +705,8 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_find_grouped
-    all_posts_from_category1 = Post.scoped(:conditions => "category_id = 1", :joins => :categories).all
-    grouped_posts_of_category1 = Post.scoped(:conditions => "category_id = 1", :group => "author_id", :select => 'count(posts.id) as posts_count', :joins => :categories).all
+    all_posts_from_category1 = Post.scoped(:where => "category_id = 1", :joins => :categories).all
+    grouped_posts_of_category1 = Post.scoped(:where => "category_id = 1", :group => "author_id", :select => 'count(posts.id) as posts_count', :joins => :categories).all
     assert_equal 5, all_posts_from_category1.size
     assert_equal 2, grouped_posts_of_category1.size
   end
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index 4b22746430..fb8f45f0ce 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -273,14 +273,14 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_find_with_blank_conditions
     [[], {}, nil, ""].each do |blank|
-      assert_equal 2, Firm.scoped(:order => "id").first.clients.scoped(:conditions => blank).all.size
+      assert_equal 2, Firm.scoped(:order => "id").first.clients.where(blank).all.size
     end
   end
 
   def test_find_many_with_merged_options
     assert_equal 1, companies(:first_firm).limited_clients.size
     assert_equal 1, companies(:first_firm).limited_clients.all.size
-    assert_equal 2, companies(:first_firm).limited_clients.scoped(:limit => nil).all.size
+    assert_equal 2, companies(:first_firm).limited_clients.limit(nil).all.size
   end
 
   def test_find_should_append_to_association_order
@@ -293,22 +293,22 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_dynamic_find_should_respect_association_order
-    assert_equal companies(:second_client), companies(:first_firm).clients_sorted_desc.scoped(:conditions => "type = 'Client'").first
+    assert_equal companies(:second_client), companies(:first_firm).clients_sorted_desc.scoped(:where => "type = 'Client'").first
     assert_equal companies(:second_client), companies(:first_firm).clients_sorted_desc.find_by_type('Client')
   end
 
   def test_dynamic_find_all_should_respect_association_order
-    assert_equal [companies(:second_client), companies(:first_client)], companies(:first_firm).clients_sorted_desc.scoped(:conditions => "type = 'Client'").all
+    assert_equal [companies(:second_client), companies(:first_client)], companies(:first_firm).clients_sorted_desc.scoped(:where => "type = 'Client'").all
     assert_equal [companies(:second_client), companies(:first_client)], companies(:first_firm).clients_sorted_desc.find_all_by_type('Client')
   end
 
   def test_dynamic_find_all_should_respect_association_limit
-    assert_equal 1, companies(:first_firm).limited_clients.scoped(:conditions => "type = 'Client'").all.length
+    assert_equal 1, companies(:first_firm).limited_clients.scoped(:where => "type = 'Client'").all.length
     assert_equal 1, companies(:first_firm).limited_clients.find_all_by_type('Client').length
   end
 
   def test_dynamic_find_all_limit_should_override_association_limit
-    assert_equal 2, companies(:first_firm).limited_clients.scoped(:conditions => "type = 'Client'", :limit => 9_000).all.length
+    assert_equal 2, companies(:first_firm).limited_clients.scoped(:where => "type = 'Client'", :limit => 9_000).all.length
     assert_equal 2, companies(:first_firm).limited_clients.find_all_by_type('Client', :limit => 9_000).length
   end
 
@@ -432,8 +432,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_find_all
     firm = Firm.scoped(:order => "id").first
-    assert_equal 2, firm.clients.scoped(:conditions => "#{QUOTED_TYPE} = 'Client'").all.length
-    assert_equal 1, firm.clients.scoped(:conditions => "name = 'Summit'").all.length
+    assert_equal 2, firm.clients.scoped(:where => "#{QUOTED_TYPE} = 'Client'").all.length
+    assert_equal 1, firm.clients.scoped(:where => "name = 'Summit'").all.length
   end
 
   def test_find_each
@@ -478,28 +478,28 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_find_all_sanitized
     # sometimes tests on Oracle fail if ORDER BY is not provided therefore add always :order with :first
     firm = Firm.scoped(:order => "id").first
-    summit = firm.clients.scoped(:conditions => "name = 'Summit'").all
-    assert_equal summit, firm.clients.scoped(:conditions => ["name = ?", "Summit"]).all
-    assert_equal summit, firm.clients.scoped(:conditions => ["name = :name", { :name => "Summit" }]).all
+    summit = firm.clients.scoped(:where => "name = 'Summit'").all
+    assert_equal summit, firm.clients.scoped(:where => ["name = ?", "Summit"]).all
+    assert_equal summit, firm.clients.scoped(:where => ["name = :name", { :name => "Summit" }]).all
   end
 
   def test_find_first
     firm = Firm.scoped(:order => "id").first
     client2 = Client.find(2)
     assert_equal firm.clients.first, firm.clients.scoped(:order => "id").first
-    assert_equal client2, firm.clients.scoped(:conditions => "#{QUOTED_TYPE} = 'Client'", :order => "id").first
+    assert_equal client2, firm.clients.scoped(:where => "#{QUOTED_TYPE} = 'Client'", :order => "id").first
   end
 
   def test_find_first_sanitized
     firm = Firm.scoped(:order => "id").first
     client2 = Client.find(2)
-    assert_equal client2, firm.clients.scoped(:conditions => ["#{QUOTED_TYPE} = ?", 'Client'], :order => "id").first
-    assert_equal client2, firm.clients.scoped(:conditions => ["#{QUOTED_TYPE} = :type", { :type => 'Client' }], :order => "id").first
+    assert_equal client2, firm.clients.scoped(:where => ["#{QUOTED_TYPE} = ?", 'Client'], :order => "id").first
+    assert_equal client2, firm.clients.scoped(:where => ["#{QUOTED_TYPE} = :type", { :type => 'Client' }], :order => "id").first
   end
 
   def test_find_all_with_include_and_conditions
     assert_nothing_raised do
-      Developer.scoped(:joins => :audit_logs, :conditions => {'audit_logs.message' => nil, :name => 'Smith'}).all
+      Developer.scoped(:joins => :audit_logs, :where => {'audit_logs.message' => nil, :name => 'Smith'}).all
     end
   end
 
@@ -509,8 +509,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_find_grouped
-    all_clients_of_firm1 = Client.scoped(:conditions => "firm_id = 1").all
-    grouped_clients_of_firm1 = Client.scoped(:conditions => "firm_id = 1", :group => "firm_id", :select => 'firm_id, count(id) as clients_count').all
+    all_clients_of_firm1 = Client.scoped(:where => "firm_id = 1").all
+    grouped_clients_of_firm1 = Client.scoped(:where => "firm_id = 1", :group => "firm_id", :select => 'firm_id, count(id) as clients_count').all
     assert_equal 2, all_clients_of_firm1.size
     assert_equal 1, grouped_clients_of_firm1.size
   end
@@ -1110,7 +1110,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     firm = companies(:first_firm)
     assert_equal 2, firm.clients.size
     firm.destroy
-    assert Client.scoped(:conditions => "firm_id=#{firm.id}").all.empty?
+    assert Client.scoped(:where => "firm_id=#{firm.id}").all.empty?
   end
 
   def test_dependence_for_associations_with_hash_condition
@@ -1148,7 +1148,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
     firm.destroy rescue "do nothing"
 
-    assert_equal 2, Client.scoped(:conditions => "firm_id=#{firm.id}").all.size
+    assert_equal 2, Client.scoped(:where => "firm_id=#{firm.id}").all.size
   end
 
   def test_dependence_on_account
@@ -1329,27 +1329,27 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_dynamic_find_should_respect_association_order_for_through
-    assert_equal Comment.find(10), authors(:david).comments_desc.scoped(:conditions => "comments.type = 'SpecialComment'").first
+    assert_equal Comment.find(10), authors(:david).comments_desc.scoped(:where => "comments.type = 'SpecialComment'").first
     assert_equal Comment.find(10), authors(:david).comments_desc.find_by_type('SpecialComment')
   end
 
   def test_dynamic_find_all_should_respect_association_order_for_through
-    assert_equal [Comment.find(10), Comment.find(7), Comment.find(6), Comment.find(3)], authors(:david).comments_desc.scoped(:conditions => "comments.type = 'SpecialComment'").all
+    assert_equal [Comment.find(10), Comment.find(7), Comment.find(6), Comment.find(3)], authors(:david).comments_desc.scoped(:where => "comments.type = 'SpecialComment'").all
     assert_equal [Comment.find(10), Comment.find(7), Comment.find(6), Comment.find(3)], authors(:david).comments_desc.find_all_by_type('SpecialComment')
   end
 
   def test_dynamic_find_all_should_respect_association_limit_for_through
-    assert_equal 1, authors(:david).limited_comments.scoped(:conditions => "comments.type = 'SpecialComment'").all.length
+    assert_equal 1, authors(:david).limited_comments.scoped(:where => "comments.type = 'SpecialComment'").all.length
     assert_equal 1, authors(:david).limited_comments.find_all_by_type('SpecialComment').length
   end
 
   def test_dynamic_find_all_order_should_override_association_limit_for_through
-    assert_equal 4, authors(:david).limited_comments.scoped(:conditions => "comments.type = 'SpecialComment'", :limit => 9_000).all.length
+    assert_equal 4, authors(:david).limited_comments.scoped(:where => "comments.type = 'SpecialComment'", :limit => 9_000).all.length
     assert_equal 4, authors(:david).limited_comments.find_all_by_type('SpecialComment', :limit => 9_000).length
   end
 
   def test_find_all_include_over_the_same_table_for_through
-    assert_equal 2, people(:michael).posts.scoped(:include => :people).all.length
+    assert_equal 2, people(:michael).posts.scoped(:includes => :people).all.length
   end
 
   def test_has_many_through_respects_hash_conditions
diff --git a/activerecord/test/cases/associations/has_one_associations_test.rb b/activerecord/test/cases/associations/has_one_associations_test.rb
index 9a5719c298..57d2f3ee06 100644
--- a/activerecord/test/cases/associations/has_one_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_associations_test.rb
@@ -25,7 +25,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     assert_queries(1) { assert_nil firm.account }
     assert_queries(0) { assert_nil firm.account }
 
-    firms = Firm.scoped(:include => :account).all
+    firms = Firm.scoped(:includes => :account).all
     assert_queries(0) { firms.each(&:account) }
   end
 
diff --git a/activerecord/test/cases/associations/has_one_through_associations_test.rb b/activerecord/test/cases/associations/has_one_through_associations_test.rb
index fd95178d54..00c7a78e82 100644
--- a/activerecord/test/cases/associations/has_one_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_through_associations_test.rb
@@ -73,7 +73,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_one_through_eager_loading
     members = assert_queries(3) do #base table, through table, clubs table
-      Member.scoped(:include => :club, :conditions => ["name = ?", "Groucho Marx"]).all
+      Member.scoped(:includes => :club, :where => ["name = ?", "Groucho Marx"]).all
     end
     assert_equal 1, members.size
     assert_not_nil assert_no_queries {members[0].club}
@@ -81,7 +81,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_one_through_eager_loading_through_polymorphic
     members = assert_queries(3) do #base table, through table, clubs table
-      Member.scoped(:include => :sponsor_club, :conditions => ["name = ?", "Groucho Marx"]).all
+      Member.scoped(:includes => :sponsor_club, :where => ["name = ?", "Groucho Marx"]).all
     end
     assert_equal 1, members.size
     assert_not_nil assert_no_queries {members[0].sponsor_club}
@@ -104,14 +104,14 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_eager_has_one_through_polymorphic_with_source_type
-    clubs = Club.scoped(:include => :sponsored_member, :conditions => ["name = ?","Moustache and Eyebrow Fancier Club"]).all
+    clubs = Club.scoped(:includes => :sponsored_member, :where => ["name = ?","Moustache and Eyebrow Fancier Club"]).all
     # Only the eyebrow fanciers club has a sponsored_member
     assert_not_nil assert_no_queries {clubs[0].sponsored_member}
   end
 
   def test_has_one_through_nonpreload_eagerloading
     members = assert_queries(1) do
-      Member.scoped(:include => :club, :conditions => ["members.name = ?", "Groucho Marx"], :order => 'clubs.name').all #force fallback
+      Member.scoped(:includes => :club, :where => ["members.name = ?", "Groucho Marx"], :order => 'clubs.name').all #force fallback
     end
     assert_equal 1, members.size
     assert_not_nil assert_no_queries {members[0].club}
@@ -119,7 +119,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_one_through_nonpreload_eager_loading_through_polymorphic
     members = assert_queries(1) do
-      Member.scoped(:include => :sponsor_club, :conditions => ["members.name = ?", "Groucho Marx"], :order => 'clubs.name').all #force fallback
+      Member.scoped(:includes => :sponsor_club, :where => ["members.name = ?", "Groucho Marx"], :order => 'clubs.name').all #force fallback
     end
     assert_equal 1, members.size
     assert_not_nil assert_no_queries {members[0].sponsor_club}
@@ -128,7 +128,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   def test_has_one_through_nonpreload_eager_loading_through_polymorphic_with_more_than_one_through_record
     Sponsor.new(:sponsor_club => clubs(:crazy_club), :sponsorable => members(:groucho)).save!
     members = assert_queries(1) do
-      Member.scoped(:include => :sponsor_club, :conditions => ["members.name = ?", "Groucho Marx"], :order => 'clubs.name DESC').all #force fallback
+      Member.scoped(:includes => :sponsor_club, :where => ["members.name = ?", "Groucho Marx"], :order => 'clubs.name DESC').all #force fallback
     end
     assert_equal 1, members.size
     assert_not_nil assert_no_queries { members[0].sponsor_club }
@@ -197,7 +197,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
     @member.member_detail = @member_detail
     @member.organization = @organization
     @member_details = assert_queries(3) do
-      MemberDetail.scoped(:include => :member_type).all
+      MemberDetail.scoped(:includes => :member_type).all
     end
     @new_detail = @member_details[0]
     assert @new_detail.send(:association, :member_type).loaded?
diff --git a/activerecord/test/cases/associations/inverse_associations_test.rb b/activerecord/test/cases/associations/inverse_associations_test.rb
index 563f38d023..f35ffb2994 100644
--- a/activerecord/test/cases/associations/inverse_associations_test.rb
+++ b/activerecord/test/cases/associations/inverse_associations_test.rb
@@ -96,7 +96,7 @@ class InverseHasOneTests < ActiveRecord::TestCase
 
 
   def test_parent_instance_should_be_shared_with_eager_loaded_child_on_find
-    m = Man.scoped(:conditions => {:name => 'Gordon'}, :include => :face).first
+    m = Man.scoped(:where => {:name => 'Gordon'}, :includes => :face).first
     f = m.face
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
     m.name = 'Bongo'
@@ -104,7 +104,7 @@ class InverseHasOneTests < ActiveRecord::TestCase
     f.man.name = 'Mungo'
     assert_equal m.name, f.man.name, "Name of man should be the same after changes to child-owned instance"
 
-    m = Man.scoped(:conditions => {:name => 'Gordon'}, :include => :face, :order => 'faces.id').first
+    m = Man.scoped(:where => {:name => 'Gordon'}, :includes => :face, :order => 'faces.id').first
     f = m.face
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
     m.name = 'Bongo'
@@ -179,7 +179,7 @@ class InverseHasManyTests < ActiveRecord::TestCase
   end
 
   def test_parent_instance_should_be_shared_with_eager_loaded_children
-    m = Man.scoped(:conditions => {:name => 'Gordon'}, :include => :interests).first
+    m = Man.scoped(:where => {:name => 'Gordon'}, :includes => :interests).first
     is = m.interests
     is.each do |i|
       assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
@@ -189,7 +189,7 @@ class InverseHasManyTests < ActiveRecord::TestCase
       assert_equal m.name, i.man.name, "Name of man should be the same after changes to child-owned instance"
     end
 
-    m = Man.scoped(:conditions => {:name => 'Gordon'}, :include => :interests, :order => 'interests.id').first
+    m = Man.scoped(:where => {:name => 'Gordon'}, :includes => :interests, :order => 'interests.id').first
     is = m.interests
     is.each do |i|
       assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
@@ -278,7 +278,7 @@ class InverseBelongsToTests < ActiveRecord::TestCase
   end
 
   def test_eager_loaded_child_instance_should_be_shared_with_parent_on_find
-    f = Face.scoped(:include => :man, :conditions => {:description => 'trusting'}).first
+    f = Face.scoped(:includes => :man, :where => {:description => 'trusting'}).first
     m = f.man
     assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
     f.description = 'gormless'
@@ -286,7 +286,7 @@ class InverseBelongsToTests < ActiveRecord::TestCase
     m.face.description = 'pleasing'
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to parent-owned instance"
 
-    f = Face.scoped(:include => :man, :order => 'men.id', :conditions => {:description => 'trusting'}).first
+    f = Face.scoped(:includes => :man, :order => 'men.id', :where => {:description => 'trusting'}).first
     m = f.man
     assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
     f.description = 'gormless'
@@ -351,7 +351,7 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
   fixtures :men, :faces, :interests
 
   def test_child_instance_should_be_shared_with_parent_on_find
-    f = Face.scoped(:conditions => {:description => 'confused'}).first
+    f = Face.scoped(:where => {:description => 'confused'}).first
     m = f.polymorphic_man
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same before changes to child instance"
     f.description = 'gormless'
@@ -361,7 +361,7 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
   end
 
   def test_eager_loaded_child_instance_should_be_shared_with_parent_on_find
-    f = Face.scoped(:conditions => {:description => 'confused'}, :include => :man).first
+    f = Face.scoped(:where => {:description => 'confused'}, :includes => :man).first
     m = f.polymorphic_man
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same before changes to child instance"
     f.description = 'gormless'
@@ -369,7 +369,7 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
     m.polymorphic_face.description = 'pleasing'
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same after changes to parent-owned instance"
 
-    f = Face.scoped(:conditions => {:description => 'confused'}, :include => :man, :order => 'men.id').first
+    f = Face.scoped(:where => {:description => 'confused'}, :includes => :man, :order => 'men.id').first
     m = f.polymorphic_man
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same before changes to child instance"
     f.description = 'gormless'
diff --git a/activerecord/test/cases/associations/join_model_test.rb b/activerecord/test/cases/associations/join_model_test.rb
index 63b7acfc7a..5d25cc20f7 100644
--- a/activerecord/test/cases/associations/join_model_test.rb
+++ b/activerecord/test/cases/associations/join_model_test.rb
@@ -238,7 +238,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_include_has_many_through
     posts              = Post.scoped(:order => 'posts.id').all
-    posts_with_authors = Post.scoped(:include => :authors, :order => 'posts.id').all
+    posts_with_authors = Post.scoped(:includes => :authors, :order => 'posts.id').all
     assert_equal posts.length, posts_with_authors.length
     posts.length.times do |i|
       assert_equal posts[i].authors.length, assert_no_queries { posts_with_authors[i].authors.length }
@@ -263,7 +263,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_include_polymorphic_has_many_through
     posts           = Post.scoped(:order => 'posts.id').all
-    posts_with_tags = Post.scoped(:include => :tags, :order => 'posts.id').all
+    posts_with_tags = Post.scoped(:includes => :tags, :order => 'posts.id').all
     assert_equal posts.length, posts_with_tags.length
     posts.length.times do |i|
       assert_equal posts[i].tags.length, assert_no_queries { posts_with_tags[i].tags.length }
@@ -272,7 +272,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_include_polymorphic_has_many
     posts               = Post.scoped(:order => 'posts.id').all
-    posts_with_taggings = Post.scoped(:include => :taggings, :order => 'posts.id').all
+    posts_with_taggings = Post.scoped(:includes => :taggings, :order => 'posts.id').all
     assert_equal posts.length, posts_with_taggings.length
     posts.length.times do |i|
       assert_equal posts[i].taggings.length, assert_no_queries { posts_with_taggings[i].taggings.length }
@@ -292,8 +292,8 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_find_conditions
-    assert_equal categories(:general), authors(:david).categories.scoped(:conditions => "categories.name = 'General'").first
-    assert_nil authors(:david).categories.scoped(:conditions => "categories.name = 'Technology'").first
+    assert_equal categories(:general), authors(:david).categories.scoped(:where => "categories.name = 'General'").first
+    assert_nil authors(:david).categories.scoped(:where => "categories.name = 'Technology'").first
   end
 
   def test_has_many_class_methods_called_by_method_missing
@@ -386,7 +386,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_through_has_many_find_conditions
-    options = { :conditions => "comments.#{QUOTED_TYPE}='SpecialComment'", :order => 'comments.id' }
+    options = { :where => "comments.#{QUOTED_TYPE}='SpecialComment'", :order => 'comments.id' }
     assert_equal comments(:does_it_hurt), authors(:david).comments.scoped(options).first
   end
 
@@ -411,7 +411,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_eager_load_has_many_through_has_many
-    author = Author.scoped(:conditions => ['name = ?', 'David'], :include => :comments, :order => 'comments.id').first
+    author = Author.scoped(:where => ['name = ?', 'David'], :includes => :comments, :order => 'comments.id').first
     SpecialComment.new; VerySpecialComment.new
     assert_no_queries do
       assert_equal [1,2,3,5,6,7,8,9,10,12], author.comments.collect(&:id)
@@ -419,7 +419,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_eager_load_has_many_through_has_many_with_conditions
-    post = Post.scoped(:include => :invalid_tags).first
+    post = Post.scoped(:includes => :invalid_tags).first
     assert_no_queries do
       post.invalid_tags
     end
@@ -427,8 +427,8 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_eager_belongs_to_and_has_one_not_singularized
     assert_nothing_raised do
-      Author.scoped(:include => :author_address).first
-      AuthorAddress.scoped(:include => :author).first
+      Author.scoped(:includes => :author_address).first
+      AuthorAddress.scoped(:includes => :author).first
     end
   end
 
@@ -633,7 +633,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_preload_polymorphic_has_many_through
     posts           = Post.scoped(:order => 'posts.id').all
-    posts_with_tags = Post.scoped(:include => :tags, :order => 'posts.id').all
+    posts_with_tags = Post.scoped(:includes => :tags, :order => 'posts.id').all
     assert_equal posts.length, posts_with_tags.length
     posts.length.times do |i|
       assert_equal posts[i].tags.length, assert_no_queries { posts_with_tags[i].tags.length }
@@ -641,7 +641,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_preload_polymorph_many_types
-    taggings = Tagging.scoped(:include => :taggable, :conditions => ['taggable_type != ?', 'FakeModel']).all
+    taggings = Tagging.scoped(:includes => :taggable, :where => ['taggable_type != ?', 'FakeModel']).all
     assert_no_queries do
       taggings.first.taggable.id
       taggings[1].taggable.id
@@ -654,13 +654,13 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_preload_nil_polymorphic_belongs_to
     assert_nothing_raised do
-      Tagging.scoped(:include => :taggable, :conditions => ['taggable_type IS NULL']).all
+      Tagging.scoped(:includes => :taggable, :where => ['taggable_type IS NULL']).all
     end
   end
 
   def test_preload_polymorphic_has_many
     posts               = Post.scoped(:order => 'posts.id').all
-    posts_with_taggings = Post.scoped(:include => :taggings, :order => 'posts.id').all
+    posts_with_taggings = Post.scoped(:includes => :taggings, :order => 'posts.id').all
     assert_equal posts.length, posts_with_taggings.length
     posts.length.times do |i|
       assert_equal posts[i].taggings.length, assert_no_queries { posts_with_taggings[i].taggings.length }
@@ -668,7 +668,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_belongs_to_shared_parent
-    comments = Comment.scoped(:include => :post, :conditions => 'post_id = 1').all
+    comments = Comment.scoped(:includes => :post, :where => 'post_id = 1').all
     assert_no_queries do
       assert_equal comments.first.post, comments[1].post
     end
diff --git a/activerecord/test/cases/associations_test.rb b/activerecord/test/cases/associations_test.rb
index 6412ec0599..1d0550afaf 100644
--- a/activerecord/test/cases/associations_test.rb
+++ b/activerecord/test/cases/associations_test.rb
@@ -74,8 +74,8 @@ class AssociationsTest < ActiveRecord::TestCase
 
 
   def test_include_with_order_works
-    assert_nothing_raised {Account.scoped(:order => 'id', :include => :firm).first}
-    assert_nothing_raised {Account.scoped(:order => :id, :include => :firm).first}
+    assert_nothing_raised {Account.scoped(:order => 'id', :includes => :firm).first}
+    assert_nothing_raised {Account.scoped(:order => :id, :includes => :firm).first}
   end
 
   def test_bad_collection_keys
diff --git a/activerecord/test/cases/autosave_association_test.rb b/activerecord/test/cases/autosave_association_test.rb
index fb19bdf435..c93c91803e 100644
--- a/activerecord/test/cases/autosave_association_test.rb
+++ b/activerecord/test/cases/autosave_association_test.rb
@@ -155,7 +155,7 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
   end
 
   def test_not_resaved_when_unchanged
-    firm = Firm.scoped(:include => :account).first
+    firm = Firm.scoped(:includes => :account).first
     firm.name += '-changed'
     assert_queries(1) { firm.save! }
 
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index 9ebc136252..5887782cad 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -356,7 +356,7 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_load_with_condition
-    topics = Topic.scoped(:conditions => "author_name = 'Mary'").all
+    topics = Topic.scoped(:where => "author_name = 'Mary'").all
 
     assert_equal(1, topics.size)
     assert_equal(topics(:second).title, topics.first.title)
@@ -1264,10 +1264,10 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_quoting_arrays
-    replies = Reply.scoped(:conditions => [ "id IN (?)", topics(:first).replies.collect(&:id) ]).all
+    replies = Reply.scoped(:where => [ "id IN (?)", topics(:first).replies.collect(&:id) ]).all
     assert_equal topics(:first).replies.size, replies.size
 
-    replies = Reply.scoped(:conditions => [ "id IN (?)", [] ]).all
+    replies = Reply.scoped(:where => [ "id IN (?)", [] ]).all
     assert_equal 0, replies.size
   end
 
@@ -1739,8 +1739,8 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_inspect_limited_select_instance
-    assert_equal %(#<Topic id: 1>), Topic.scoped(:select => 'id', :conditions => 'id = 1').first.inspect
-    assert_equal %(#<Topic id: 1, title: "The First Topic">), Topic.scoped(:select => 'id, title', :conditions => 'id = 1').first.inspect
+    assert_equal %(#<Topic id: 1>), Topic.scoped(:select => 'id', :where => 'id = 1').first.inspect
+    assert_equal %(#<Topic id: 1, title: "The First Topic">), Topic.scoped(:select => 'id, title', :where => 'id = 1').first.inspect
   end
 
   def test_inspect_class_without_table
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index aa0f1f7a15..e2fcee1070 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -281,23 +281,23 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_on_hash_conditions_with_range
-    assert_equal [1,2], Topic.scoped(:conditions => { :id => 1..2 }).all.map(&:id).sort
+    assert_equal [1,2], Topic.scoped(:where => { :id => 1..2 }).all.map(&:id).sort
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1, :conditions => { :id => 2..3 }) }
   end
 
   def test_find_on_hash_conditions_with_end_exclusive_range
-    assert_equal [1,2,3], Topic.scoped(:conditions => { :id => 1..3 }).all.map(&:id).sort
-    assert_equal [1,2], Topic.scoped(:conditions => { :id => 1...3 }).all.map(&:id).sort
+    assert_equal [1,2,3], Topic.scoped(:where => { :id => 1..3 }).all.map(&:id).sort
+    assert_equal [1,2], Topic.scoped(:where => { :id => 1...3 }).all.map(&:id).sort
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(3, :conditions => { :id => 2...3 }) }
   end
 
   def test_find_on_hash_conditions_with_multiple_ranges
-    assert_equal [1,2,3], Comment.scoped(:conditions => { :id => 1..3, :post_id => 1..2 }).all.map(&:id).sort
-    assert_equal [1], Comment.scoped(:conditions => { :id => 1..1, :post_id => 1..10 }).all.map(&:id).sort
+    assert_equal [1,2,3], Comment.scoped(:where => { :id => 1..3, :post_id => 1..2 }).all.map(&:id).sort
+    assert_equal [1], Comment.scoped(:where => { :id => 1..1, :post_id => 1..10 }).all.map(&:id).sort
   end
 
   def test_find_on_hash_conditions_with_array_of_integers_and_ranges
-    assert_equal [1,2,3,5,6,7,8,9], Comment.scoped(:conditions => {:id => [1..2, 3, 5, 6..8, 9]}).all.map(&:id).sort
+    assert_equal [1,2,3,5,6,7,8,9], Comment.scoped(:where => {:id => [1..2, 3, 5, 6..8, 9]}).all.map(&:id).sort
   end
 
   def test_find_on_multiple_hash_conditions
@@ -309,43 +309,43 @@ class FinderTest < ActiveRecord::TestCase
 
   def test_condition_interpolation
     assert_kind_of Firm, Company.where("name = '%s'", "37signals").first
-    assert_nil Company.scoped(:conditions => ["name = '%s'", "37signals!"]).first
-    assert_nil Company.scoped(:conditions => ["name = '%s'", "37signals!' OR 1=1"]).first
-    assert_kind_of Time, Topic.scoped(:conditions => ["id = %d", 1]).first.written_on
+    assert_nil Company.scoped(:where => ["name = '%s'", "37signals!"]).first
+    assert_nil Company.scoped(:where => ["name = '%s'", "37signals!' OR 1=1"]).first
+    assert_kind_of Time, Topic.scoped(:where => ["id = %d", 1]).first.written_on
   end
 
   def test_condition_array_interpolation
-    assert_kind_of Firm, Company.scoped(:conditions => ["name = '%s'", "37signals"]).first
-    assert_nil Company.scoped(:conditions => ["name = '%s'", "37signals!"]).first
-    assert_nil Company.scoped(:conditions => ["name = '%s'", "37signals!' OR 1=1"]).first
-    assert_kind_of Time, Topic.scoped(:conditions => ["id = %d", 1]).first.written_on
+    assert_kind_of Firm, Company.scoped(:where => ["name = '%s'", "37signals"]).first
+    assert_nil Company.scoped(:where => ["name = '%s'", "37signals!"]).first
+    assert_nil Company.scoped(:where => ["name = '%s'", "37signals!' OR 1=1"]).first
+    assert_kind_of Time, Topic.scoped(:where => ["id = %d", 1]).first.written_on
   end
 
   def test_condition_hash_interpolation
-    assert_kind_of Firm, Company.scoped(:conditions => { :name => "37signals"}).first
-    assert_nil Company.scoped(:conditions => { :name => "37signals!"}).first
-    assert_kind_of Time, Topic.scoped(:conditions => {:id => 1}).first.written_on
+    assert_kind_of Firm, Company.scoped(:where => { :name => "37signals"}).first
+    assert_nil Company.scoped(:where => { :name => "37signals!"}).first
+    assert_kind_of Time, Topic.scoped(:where => {:id => 1}).first.written_on
   end
 
   def test_hash_condition_find_malformed
     assert_raise(ActiveRecord::StatementInvalid) {
-      Company.scoped(:conditions => { :id => 2, :dhh => true }).first
+      Company.scoped(:where => { :id => 2, :dhh => true }).first
     }
   end
 
   def test_hash_condition_find_with_escaped_characters
     Company.create("name" => "Ain't noth'n like' \#stuff")
-    assert Company.scoped(:conditions => { :name => "Ain't noth'n like' \#stuff" }).first
+    assert Company.scoped(:where => { :name => "Ain't noth'n like' \#stuff" }).first
   end
 
   def test_hash_condition_find_with_array
     p1, p2 = Post.scoped(:limit => 2, :order => 'id asc').all
-    assert_equal [p1, p2], Post.scoped(:conditions => { :id => [p1, p2] }, :order => 'id asc').all
-    assert_equal [p1, p2], Post.scoped(:conditions => { :id => [p1, p2.id] }, :order => 'id asc').all
+    assert_equal [p1, p2], Post.scoped(:where => { :id => [p1, p2] }, :order => 'id asc').all
+    assert_equal [p1, p2], Post.scoped(:where => { :id => [p1, p2.id] }, :order => 'id asc').all
   end
 
   def test_hash_condition_find_with_nil
-    topic = Topic.scoped(:conditions => { :last_read => nil } ).first
+    topic = Topic.scoped(:where => { :last_read => nil } ).first
     assert_not_nil topic
     assert_nil topic.last_read
   end
@@ -353,42 +353,42 @@ class FinderTest < ActiveRecord::TestCase
   def test_hash_condition_find_with_aggregate_having_one_mapping
     balance = customers(:david).balance
     assert_kind_of Money, balance
-    found_customer = Customer.scoped(:conditions => {:balance => balance}).first
+    found_customer = Customer.scoped(:where => {:balance => balance}).first
     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.scoped(:conditions => {:gps_location => gps_location}).first
+    found_customer = Customer.scoped(:where => {:gps_location => gps_location}).first
     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.scoped(:conditions => {:balance => balance.amount}).first
+    found_customer = Customer.scoped(:where => {:balance => balance.amount}).first
     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.scoped(:conditions => {:gps_location => gps_location.gps_location}).first
+    found_customer = Customer.scoped(:where => {:gps_location => gps_location.gps_location}).first
     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.scoped(:conditions => {:address => address}).first
+    found_customer = Customer.scoped(:where => {:address => address}).first
     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.scoped(:conditions => {:address => address, :name => customers(:david).name}).first
+    found_customer = Customer.scoped(:where => {:address => address, :name => customers(:david).name}).first
     assert_equal customers(:david), found_customer
   end
 
@@ -396,7 +396,7 @@ class FinderTest < ActiveRecord::TestCase
     with_env_tz 'America/New_York' do
       with_active_record_default_timezone :local do
         topic = Topic.first
-        assert_equal topic, Topic.scoped(:conditions => ['written_on = ?', topic.written_on.getutc]).first
+        assert_equal topic, Topic.scoped(:where => ['written_on = ?', topic.written_on.getutc]).first
       end
     end
   end
@@ -405,7 +405,7 @@ class FinderTest < ActiveRecord::TestCase
     with_env_tz 'America/New_York' do
       with_active_record_default_timezone :local do
         topic = Topic.first
-        assert_equal topic, Topic.scoped(:conditions => {:written_on => topic.written_on.getutc}).first
+        assert_equal topic, Topic.scoped(:where => {:written_on => topic.written_on.getutc}).first
       end
     end
   end
@@ -414,7 +414,7 @@ class FinderTest < ActiveRecord::TestCase
     with_env_tz 'America/New_York' do
       with_active_record_default_timezone :utc do
         topic = Topic.first
-        assert_equal topic, Topic.scoped(:conditions => ['written_on = ?', topic.written_on.getlocal]).first
+        assert_equal topic, Topic.scoped(:where => ['written_on = ?', topic.written_on.getlocal]).first
       end
     end
   end
@@ -423,32 +423,32 @@ class FinderTest < ActiveRecord::TestCase
     with_env_tz 'America/New_York' do
       with_active_record_default_timezone :utc do
         topic = Topic.first
-        assert_equal topic, Topic.scoped(:conditions => {:written_on => topic.written_on.getlocal}).first
+        assert_equal topic, Topic.scoped(:where => {:written_on => topic.written_on.getlocal}).first
       end
     end
   end
 
   def test_bind_variables
-    assert_kind_of Firm, Company.scoped(:conditions => ["name = ?", "37signals"]).first
-    assert_nil Company.scoped(:conditions => ["name = ?", "37signals!"]).first
-    assert_nil Company.scoped(:conditions => ["name = ?", "37signals!' OR 1=1"]).first
-    assert_kind_of Time, Topic.scoped(:conditions => ["id = ?", 1]).first.written_on
+    assert_kind_of Firm, Company.scoped(:where => ["name = ?", "37signals"]).first
+    assert_nil Company.scoped(:where => ["name = ?", "37signals!"]).first
+    assert_nil Company.scoped(:where => ["name = ?", "37signals!' OR 1=1"]).first
+    assert_kind_of Time, Topic.scoped(:where => ["id = ?", 1]).first.written_on
     assert_raise(ActiveRecord::PreparedStatementInvalid) {
-      Company.scoped(:conditions => ["id=? AND name = ?", 2]).first
+      Company.scoped(:where => ["id=? AND name = ?", 2]).first
     }
     assert_raise(ActiveRecord::PreparedStatementInvalid) {
-     Company.scoped(:conditions => ["id=?", 2, 3, 4]).first
+     Company.scoped(:where => ["id=?", 2, 3, 4]).first
     }
   end
 
   def test_bind_variables_with_quotes
     Company.create("name" => "37signals' go'es agains")
-    assert Company.scoped(:conditions => ["name = ?", "37signals' go'es agains"]).first
+    assert Company.scoped(:where => ["name = ?", "37signals' go'es agains"]).first
   end
 
   def test_named_bind_variables_with_quotes
     Company.create("name" => "37signals' go'es agains")
-    assert Company.scoped(:conditions => ["name = :name", {:name => "37signals' go'es agains"}]).first
+    assert Company.scoped(:where => ["name = :name", {:name => "37signals' go'es agains"}]).first
   end
 
   def test_bind_arity
@@ -466,10 +466,10 @@ class FinderTest < ActiveRecord::TestCase
 
     assert_nothing_raised { bind("'+00:00'", :foo => "bar") }
 
-    assert_kind_of Firm, Company.scoped(:conditions => ["name = :name", { :name => "37signals" }]).first
-    assert_nil Company.scoped(:conditions => ["name = :name", { :name => "37signals!" }]).first
-    assert_nil Company.scoped(:conditions => ["name = :name", { :name => "37signals!' OR 1=1" }]).first
-    assert_kind_of Time, Topic.scoped(:conditions => ["id = :id", { :id => 1 }]).first.written_on
+    assert_kind_of Firm, Company.scoped(:where => ["name = :name", { :name => "37signals" }]).first
+    assert_nil Company.scoped(:where => ["name = :name", { :name => "37signals!" }]).first
+    assert_nil Company.scoped(:where => ["name = :name", { :name => "37signals!' OR 1=1" }]).first
+    assert_kind_of Time, Topic.scoped(:where => ["id = :id", { :id => 1 }]).first.written_on
   end
 
   class SimpleEnumerable
@@ -1035,8 +1035,8 @@ class FinderTest < ActiveRecord::TestCase
 
   def test_find_by_records
     p1, p2 = Post.scoped(:limit => 2, :order => 'id asc').all
-    assert_equal [p1, p2], Post.scoped(:conditions => ['id in (?)', [p1, p2]], :order => 'id asc')
-    assert_equal [p1, p2], Post.scoped(:conditions => ['id in (?)', [p1, p2.id]], :order => 'id asc')
+    assert_equal [p1, p2], Post.scoped(:where => ['id in (?)', [p1, p2]], :order => 'id asc')
+    assert_equal [p1, p2], Post.scoped(:where => ['id in (?)', [p1, p2.id]], :order => 'id asc')
   end
 
   def test_select_value
@@ -1063,7 +1063,7 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_with_order_on_included_associations_with_construct_finder_sql_for_association_limiting_and_is_distinct
-    assert_equal 2, Post.scoped(:include => { :authors => :author_address }, :order => 'author_addresses.id DESC ', :limit => 2).all.size
+    assert_equal 2, Post.scoped(:includes => { :authors => :author_address }, :order => 'author_addresses.id DESC ', :limit => 2).all.size
 
     assert_equal 3, Post.scoped(:include => { :author => :author_address, :authors => :author_address},
                               :order => 'author_addresses_authors.id DESC ', :limit => 3).all.size
diff --git a/activerecord/test/cases/inheritance_test.rb b/activerecord/test/cases/inheritance_test.rb
index f355d7a1e9..453cae2ca2 100644
--- a/activerecord/test/cases/inheritance_test.rb
+++ b/activerecord/test/cases/inheritance_test.rb
@@ -173,9 +173,9 @@ class InheritanceTest < ActiveRecord::TestCase
   end
 
   def test_find_first_within_inheritance
-    assert_kind_of Firm, Company.scoped(:conditions => "name = '37signals'").first
-    assert_kind_of Firm, Firm.scoped(:conditions => "name = '37signals'").first
-    assert_nil Client.scoped(:conditions => "name = '37signals'").first
+    assert_kind_of Firm, Company.scoped(:where => "name = '37signals'").first
+    assert_kind_of Firm, Firm.scoped(:where => "name = '37signals'").first
+    assert_nil Client.scoped(:where => "name = '37signals'").first
   end
 
   def test_alt_find_first_within_inheritance
@@ -187,10 +187,10 @@ class InheritanceTest < ActiveRecord::TestCase
   def test_complex_inheritance
     very_special_client = VerySpecialClient.create("name" => "veryspecial")
     assert_equal very_special_client, VerySpecialClient.where("name = 'veryspecial'").first
-    assert_equal very_special_client, SpecialClient.scoped(:conditions => "name = 'veryspecial'").first
-    assert_equal very_special_client, Company.scoped(:conditions => "name = 'veryspecial'").first
-    assert_equal very_special_client, Client.scoped(:conditions => "name = 'veryspecial'").first
-    assert_equal 1, Client.scoped(:conditions => "name = 'Summit'").all.size
+    assert_equal very_special_client, SpecialClient.scoped(:where => "name = 'veryspecial'").first
+    assert_equal very_special_client, Company.scoped(:where => "name = 'veryspecial'").first
+    assert_equal very_special_client, Client.scoped(:where => "name = 'veryspecial'").first
+    assert_equal 1, Client.scoped(:where => "name = 'Summit'").all.size
     assert_equal very_special_client, Client.find(very_special_client.id)
   end
 
diff --git a/activerecord/test/cases/named_scope_test.rb b/activerecord/test/cases/named_scope_test.rb
index 6b9a684327..f8557259fb 100644
--- a/activerecord/test/cases/named_scope_test.rb
+++ b/activerecord/test/cases/named_scope_test.rb
@@ -58,9 +58,9 @@ class NamedScopeTest < ActiveRecord::TestCase
   end
 
   def test_scopes_with_options_limit_finds_to_those_matching_the_criteria_specified
-    assert !Topic.scoped(:conditions => {:approved => true}).all.empty?
+    assert !Topic.scoped(:where => {:approved => true}).all.empty?
 
-    assert_equal Topic.scoped(:conditions => {:approved => true}).all, Topic.approved
+    assert_equal Topic.scoped(:where => {:approved => true}).all, Topic.approved
     assert_equal Topic.where(:approved => true).count, Topic.approved.count
   end
 
@@ -71,8 +71,8 @@ class NamedScopeTest < ActiveRecord::TestCase
   end
 
   def test_scopes_are_composable
-    assert_equal((approved = Topic.scoped(:conditions => {:approved => true}).all), Topic.approved)
-    assert_equal((replied = Topic.scoped(:conditions => 'replies_count > 0').all), Topic.replied)
+    assert_equal((approved = Topic.scoped(:where => {:approved => true}).all), Topic.approved)
+    assert_equal((replied = Topic.scoped(:where => 'replies_count > 0').all), Topic.replied)
     assert !(approved == replied)
     assert !(approved & replied).empty?
 
@@ -464,7 +464,7 @@ class DynamicScopeTest < ActiveRecord::TestCase
 
   def test_dynamic_scope
     assert_equal @test_klass.scoped_by_author_id(1).find(1), @test_klass.find(1)
-    assert_equal @test_klass.scoped_by_author_id_and_title(1, "Welcome to the weblog").first, @test_klass.scoped(:conditions => { :author_id => 1, :title => "Welcome to the weblog"}).first
+    assert_equal @test_klass.scoped_by_author_id_and_title(1, "Welcome to the weblog").first, @test_klass.scoped(:where => { :author_id => 1, :title => "Welcome to the weblog"}).first
   end
 
   def test_dynamic_scope_should_create_methods_after_hitting_method_missing
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index ae9e4dea1b..4b8b57bac2 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -282,7 +282,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_find_on_hash_conditions
-    assert_equal Topic.scoped(:conditions => {:approved => false}).all, Topic.where({ :approved => false }).to_a
+    assert_equal Topic.scoped(:where => {:approved => false}).all, Topic.where({ :approved => false }).to_a
   end
 
   def test_joins_with_string_array
diff --git a/activerecord/test/models/comment.rb b/activerecord/test/models/comment.rb
index 8ab4149ff7..3e9f1b0635 100644
--- a/activerecord/test/models/comment.rb
+++ b/activerecord/test/models/comment.rb
@@ -19,7 +19,7 @@ class Comment < ActiveRecord::Base
   end
 
   def self.search_by_type(q)
-    self.scoped(:conditions => ["#{QUOTED_TYPE} = ?", q]).all
+    self.scoped(:where => ["#{QUOTED_TYPE} = ?", q]).all
   end
 
   def self.all_as_method
-- 
cgit v1.2.3


From 20ea8df6b5ba430cb4947a583faa22543cc9f20a Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 27 Apr 2012 13:11:13 +0100
Subject: more deprecations manually fixed

---
 activerecord/test/cases/associations/eager_test.rb | 62 +++++++++++-----------
 .../has_and_belongs_to_many_associations_test.rb   | 14 ++---
 activerecord/test/cases/finder_test.rb             | 35 ++++++------
 3 files changed, 53 insertions(+), 58 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index 781d244bf7..2d8b566c1d 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -61,10 +61,10 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_loading_conditions_with_or
-    posts = authors(:david).posts.references(:comments).find(
-      :all, :include => :comments,
-      :conditions => "comments.body like 'Normal%' OR comments.#{QUOTED_TYPE} = 'SpecialComment'"
-    )
+    posts = authors(:david).posts.references(:comments).scoped(
+      :includes => :comments,
+      :where => "comments.body like 'Normal%' OR comments.#{QUOTED_TYPE} = 'SpecialComment'"
+    ).all
     assert_nil posts.detect { |p| p.author_id != authors(:david).id },
       "expected to find only david's posts"
   end
@@ -154,8 +154,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
     popular_post.readers.create!(:person => people(:michael))
     popular_post.readers.create!(:person => people(:david))
 
-    readers = Reader.scoped(:conditions => ["post_id = ?", popular_post.id],
-                                :include => {:post => :comments}).all
+    readers = Reader.scoped(:where => ["post_id = ?", popular_post.id],
+                                :includes => {:post => :comments}).all
     readers.each do |reader|
       assert_equal [comment], reader.post.comments
     end
@@ -167,8 +167,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
     car_post.categories << categories(:technology)
 
     comment = car_post.comments.create!(:body => "hmm")
-    categories = Category.scoped(:conditions => { 'posts.id' => car_post.id },
-                                 :include => {:posts => :comments}).all
+    categories = Category.scoped(:where => { 'posts.id' => car_post.id },
+                                 :includes => {:posts => :comments}).all
     categories.each do |category|
       assert_equal [comment], category.posts[0].comments
     end
@@ -491,7 +491,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_has_many_through_join_model_with_conditions
-    assert_equal Author.scoped(:include => :hello_post_comments,
+    assert_equal Author.scoped(:includes => :hello_post_comments,
                              :order => 'authors.id').first.hello_post_comments.sort_by(&:id),
                  Author.scoped(:order => 'authors.id').first.hello_post_comments.sort_by(&:id)
   end
@@ -565,16 +565,16 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_eager_with_has_many_and_limit_and_high_offset_and_multiple_array_conditions
     assert_queries(1) do
       posts = Post.references(:authors, :comments).
-        scoped(:include => [ :author, :comments ], :limit => 2, :offset => 10,
-          :conditions => [ "authors.name = ? and comments.body = ?", 'David', 'go crazy' ]).all
+        scoped(:includes => [ :author, :comments ], :limit => 2, :offset => 10,
+          :where => [ "authors.name = ? and comments.body = ?", 'David', 'go crazy' ]).all
       assert_equal 0, posts.size
     end
   end
 
   def test_eager_with_has_many_and_limit_and_high_offset_and_multiple_hash_conditions
     assert_queries(1) do
-      posts = Post.scoped(:include => [ :author, :comments ], :limit => 2, :offset => 10,
-        :conditions => { 'authors.name' => 'David', 'comments.body' => 'go crazy' }).all
+      posts = Post.scoped(:includes => [ :author, :comments ], :limit => 2, :offset => 10,
+        :where => { 'authors.name' => 'David', 'comments.body' => 'go crazy' }).all
       assert_equal 0, posts.size
     end
   end
@@ -702,8 +702,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_with_has_one_dependent_does_not_destroy_dependent
     assert_not_nil companies(:first_firm).account
-    f = Firm.scoped(:include => :account,
-            :conditions => ["companies.name = ?", "37signals"]).first
+    f = Firm.scoped(:includes => :account,
+            :where => ["companies.name = ?", "37signals"]).first
     assert_not_nil f.account
     assert_equal companies(:first_firm, :reload).account, f.account
   end
@@ -777,45 +777,45 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_limited_eager_with_order
     assert_equal(
       posts(:thinking, :sti_comments),
-      Post.find(
-        :all, :include => [:author, :comments], :conditions => { 'authors.name' => 'David' },
+      Post.scoped(
+        :includes => [:author, :comments], :where => { 'authors.name' => 'David' },
         :order => 'UPPER(posts.title)', :limit => 2, :offset => 1
-      )
+      ).all
     )
     assert_equal(
       posts(:sti_post_and_comments, :sti_comments),
-      Post.find(
-        :all, :include => [:author, :comments], :conditions => { 'authors.name' => 'David' },
+      Post.scoped(
+        :includes => [:author, :comments], :where => { 'authors.name' => 'David' },
         :order => 'UPPER(posts.title) DESC', :limit => 2, :offset => 1
-      )
+      ).all
     )
   end
 
   def test_limited_eager_with_multiple_order_columns
     assert_equal(
       posts(:thinking, :sti_comments),
-      Post.find(
-        :all, :include => [:author, :comments], :conditions => { 'authors.name' => 'David' },
+      Post.scoped(
+        :includes => [:author, :comments], :where => { 'authors.name' => 'David' },
         :order => ['UPPER(posts.title)', 'posts.id'], :limit => 2, :offset => 1
-      )
+      ).all
     )
     assert_equal(
       posts(:sti_post_and_comments, :sti_comments),
-      Post.find(
-        :all, :include => [:author, :comments], :conditions => { 'authors.name' => 'David' },
+      Post.scoped(
+        :includes => [:author, :comments], :where => { 'authors.name' => 'David' },
         :order => ['UPPER(posts.title) DESC', 'posts.id'], :limit => 2, :offset => 1
-      )
+      ).all
     )
   end
 
   def test_limited_eager_with_numeric_in_association
     assert_equal(
       people(:david, :susan),
-      Person.references(:number1_fans_people).find(
-        :all, :include => [:readers, :primary_contact, :number1_fan],
-        :conditions => "number1_fans_people.first_name like 'M%'",
+      Person.references(:number1_fans_people).scoped(
+        :includes => [:readers, :primary_contact, :number1_fan],
+        :where => "number1_fans_people.first_name like 'M%'",
         :order => 'people.id', :limit => 2, :offset => 0
-      )
+      ).all
     )
   end
 
diff --git a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
index 7ddaf78848..22fd80df28 100644
--- a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
@@ -681,10 +681,10 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_join_table_alias
     assert_equal(
       3,
-      Developer.references(:developers_projects_join).find(
-        :all, :include => {:projects => :developers},
-        :conditions => 'developers_projects_join.joined_on IS NOT NULL'
-      ).size
+      Developer.references(:developers_projects_join).scoped(
+        :includes => {:projects => :developers},
+        :where => 'developers_projects_join.joined_on IS NOT NULL'
+      ).to_a.size
     )
   end
 
@@ -697,10 +697,10 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
 
     assert_equal(
       3,
-      Developer.references(:developers_projects_join).find(
-        :all, :include => {:projects => :developers}, :conditions => 'developers_projects_join.joined_on IS NOT NULL',
+      Developer.references(:developers_projects_join).scoped(
+        :includes => {:projects => :developers}, :where => 'developers_projects_join.joined_on IS NOT NULL',
         :group => group.join(",")
-      ).size
+      ).to_a.size
     )
   end
 
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index e2fcee1070..9dfc8a6025 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -981,11 +981,10 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_all_with_join
-    developers_on_project_one = Developer.find(
-      :all,
+    developers_on_project_one = Developer.scoped(
       :joins => 'LEFT JOIN developers_projects ON developers.id = developers_projects.developer_id',
-      :conditions => 'project_id=1'
-    )
+      :where => 'project_id=1'
+    ).all
     assert_equal 3, developers_on_project_one.length
     developer_names = developers_on_project_one.map { |d| d.name }
     assert developer_names.include?('David')
@@ -993,17 +992,15 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_joins_dont_clobber_id
-    first = Firm.find(
-      :first,
+    first = Firm.scoped(
       :joins => 'INNER JOIN companies clients ON clients.firm_id = companies.id',
-      :conditions => 'companies.id = 1'
-    )
+      :where => 'companies.id = 1'
+    ).first
     assert_equal 1, first.id
   end
 
   def test_joins_with_string_array
-    person_with_reader_and_post = Post.find(
-      :all,
+    person_with_reader_and_post = Post.scoped(
       :joins => [
         "INNER JOIN categorizations ON categorizations.post_id = posts.id",
         "INNER JOIN categories ON categories.id = categorizations.category_id AND categories.type = 'SpecialCategory'"
@@ -1065,14 +1062,13 @@ class FinderTest < ActiveRecord::TestCase
   def test_find_with_order_on_included_associations_with_construct_finder_sql_for_association_limiting_and_is_distinct
     assert_equal 2, Post.scoped(:includes => { :authors => :author_address }, :order => 'author_addresses.id DESC ', :limit => 2).all.size
 
-    assert_equal 3, Post.scoped(:include => { :author => :author_address, :authors => :author_address},
+    assert_equal 3, Post.scoped(:includes => { :author => :author_address, :authors => :author_address},
                               :order => 'author_addresses_authors.id DESC ', :limit => 3).all.size
   end
 
   def test_find_with_nil_inside_set_passed_for_one_attribute
-    client_of = Company.find(
-      :all,
-      :conditions => {
+    client_of = Company.scoped(
+      :where => {
         :client_of => [2, 1, nil],
         :name => ['37signals', 'Summit', 'Microsoft'] },
       :order => 'client_of DESC'
@@ -1083,9 +1079,8 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_with_nil_inside_set_passed_for_attribute
-    client_of = Company.find(
-      :all,
-      :conditions => { :client_of => [nil] },
+    client_of = Company.scoped(
+      :where => { :client_of => [nil] },
       :order => 'client_of DESC'
     ).map { |x| x.client_of }
 
@@ -1093,10 +1088,10 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_with_limiting_with_custom_select
-    posts = Post.references(:authors).find(
-      :all, :include => :author, :select => ' posts.*, authors.id as "author_id"',
+    posts = Post.references(:authors).scoped(
+      :includes => :author, :select => ' posts.*, authors.id as "author_id"',
       :limit => 3, :order => 'posts.id'
-    )
+    ).all
     assert_equal 3, posts.size
     assert_equal [0, 1, 1], posts.map(&:author_id).sort
   end
-- 
cgit v1.2.3


From 3981a687f949f7b7b2c36d9dd15aa00e1542116d Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Fri, 27 Apr 2012 14:17:28 +0100
Subject: remove deprecated calls

---
 .../associations/belongs_to_associations_test.rb   |  6 +-
 activerecord/test/cases/associations/eager_test.rb | 92 +++++++++++-----------
 .../associations/has_many_associations_test.rb     |  4 +-
 .../associations/has_one_associations_test.rb      |  6 +-
 .../has_one_through_associations_test.rb           | 12 +--
 .../test/cases/associations/join_model_test.rb     |  8 +-
 activerecord/test/cases/custom_locking_test.rb     |  2 +-
 activerecord/test/cases/finder_test.rb             | 43 +++++-----
 activerecord/test/cases/inheritance_test.rb        |  4 +-
 activerecord/test/cases/modules_test.rb            |  6 +-
 activerecord/test/cases/persistence_test.rb        |  2 +-
 .../validations/uniqueness_validation_test.rb      |  2 +-
 12 files changed, 93 insertions(+), 94 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/associations/belongs_to_associations_test.rb b/activerecord/test/cases/associations/belongs_to_associations_test.rb
index 0d6ba9dab1..b351196fbd 100644
--- a/activerecord/test/cases/associations/belongs_to_associations_test.rb
+++ b/activerecord/test/cases/associations/belongs_to_associations_test.rb
@@ -182,7 +182,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
   def test_with_select
     assert_equal Company.find(2).firm_with_select.attributes.size, 1
-    assert_equal Company.find(2, :include => :firm_with_select ).firm_with_select.attributes.size, 1
+    assert_equal Company.scoped(:includes => :firm_with_select ).find(2).firm_with_select.attributes.size, 1
   end
 
   def test_belongs_to_counter
@@ -498,14 +498,14 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
     assert_nothing_raised do
       Account.find(@account.id).save!
-      Account.find(@account.id, :include => :firm).save!
+      Account.scoped(:includes => :firm).find(@account.id).save!
     end
 
     @account.firm.delete
 
     assert_nothing_raised do
       Account.find(@account.id).save!
-      Account.find(@account.id, :include => :firm).save!
+      Account.scoped(:includes => :firm).find(@account.id).save!
     end
   end
 
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index 2d8b566c1d..2e44005847 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -35,7 +35,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_has_one_through_join_model_with_conditions_on_the_through
-    member = Member.find(members(:some_other_guy).id, :include => :favourite_club)
+    member = Member.scoped(:includes => :favourite_club).find(members(:some_other_guy).id)
     assert_nil member.favourite_club
   end
 
@@ -186,7 +186,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_finding_with_includes_on_has_many_association_with_same_include_includes_only_once
     author_id = authors(:david).id
-    author = assert_queries(3) { Author.find(author_id, :include => {:posts_with_comments => :comments}) } # find the author, then find the posts, then find the comments
+    author = assert_queries(3) { Author.scoped(:includes => {:posts_with_comments => :comments}).find(author_id) } # find the author, then find the posts, then find the comments
     author.posts_with_comments.each do |post_with_comments|
       assert_equal post_with_comments.comments.length, post_with_comments.comments.count
       assert_nil post_with_comments.comments.uniq!
@@ -197,7 +197,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     author = authors(:david)
     post = author.post_about_thinking_with_last_comment
     last_comment = post.last_comment
-    author = assert_queries(3) { Author.find(author.id, :include => {:post_about_thinking_with_last_comment => :last_comment})} # find the author, then find the posts, then find the comments
+    author = assert_queries(3) { Author.scoped(:includes => {:post_about_thinking_with_last_comment => :last_comment}).find(author.id)} # find the author, then find the posts, then find the comments
     assert_no_queries do
       assert_equal post, author.post_about_thinking_with_last_comment
       assert_equal last_comment, author.post_about_thinking_with_last_comment.last_comment
@@ -208,7 +208,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     post = posts(:welcome)
     author = post.author
     author_address = author.author_address
-    post = assert_queries(3) { Post.find(post.id, :include => {:author_with_address => :author_address}) } # find the post, then find the author, then find the address
+    post = assert_queries(3) { Post.scoped(:includes => {:author_with_address => :author_address}).find(post.id) } # find the post, then find the author, then find the address
     assert_no_queries do
       assert_equal author, post.author_with_address
       assert_equal author_address, post.author_with_address.author_address
@@ -218,7 +218,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_finding_with_includes_on_null_belongs_to_association_with_same_include_includes_only_once
     post = posts(:welcome)
     post.update_attributes!(:author => nil)
-    post = assert_queries(1) { Post.find(post.id, :include => {:author_with_address => :author_address}) } # find the post, then find the author which is null so no query for the author or address
+    post = assert_queries(1) { Post.scoped(:includes => {:author_with_address => :author_address}).find(post.id) } # find the post, then find the author which is null so no query for the author or address
     assert_no_queries do
       assert_equal nil, post.author_with_address
     end
@@ -227,7 +227,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_finding_with_includes_on_null_belongs_to_polymorphic_association
     sponsor = sponsors(:moustache_club_sponsor_for_groucho)
     sponsor.update_attributes!(:sponsorable => nil)
-    sponsor = assert_queries(1) { Sponsor.find(sponsor.id, :include => :sponsorable) }
+    sponsor = assert_queries(1) { Sponsor.scoped(:includes => :sponsorable).find(sponsor.id) }
     assert_no_queries do
       assert_equal nil, sponsor.sponsorable
     end
@@ -242,60 +242,60 @@ class EagerAssociationTest < ActiveRecord::TestCase
     assert_nothing_raised do
       Author.scoped(:includes => :hello_posts_with_hash_conditions).all
     end
-    assert !Author.find(authors(:david).id, :include => :hello_posts_with_hash_conditions).hello_posts.empty?
+    assert !Author.scoped(:includes => :hello_posts_with_hash_conditions).find(authors(:david).id).hello_posts.empty?
   end
 
   def test_loading_with_no_associations
-    assert_nil Post.find(posts(:authorless).id, :include => :author).author
+    assert_nil Post.scoped(:includes => :author).find(posts(:authorless).id).author
   end
 
   def test_nested_loading_with_no_associations
     assert_nothing_raised do
-      Post.find(posts(:authorless).id, :include => {:author => :author_addresss})
+      Post.scoped(:includes => {:author => :author_addresss}).find(posts(:authorless).id)
     end
   end
 
   def test_nested_loading_through_has_one_association
-    aa = AuthorAddress.find(author_addresses(:david_address).id, :include => {:author => :posts})
+    aa = AuthorAddress.scoped(:includes => {:author => :posts}).find(author_addresses(:david_address).id)
     assert_equal aa.author.posts.count, aa.author.posts.length
   end
 
   def test_nested_loading_through_has_one_association_with_order
-    aa = AuthorAddress.find(author_addresses(:david_address).id, :include => {:author => :posts}, :order => 'author_addresses.id')
+    aa = AuthorAddress.scoped(:includes => {:author => :posts}, :order => 'author_addresses.id').find(author_addresses(:david_address).id)
     assert_equal aa.author.posts.count, aa.author.posts.length
   end
 
   def test_nested_loading_through_has_one_association_with_order_on_association
-    aa = AuthorAddress.find(author_addresses(:david_address).id, :include => {:author => :posts}, :order => 'authors.id')
+    aa = AuthorAddress.scoped(:includes => {:author => :posts}, :order => 'authors.id').find(author_addresses(:david_address).id)
     assert_equal aa.author.posts.count, aa.author.posts.length
   end
 
   def test_nested_loading_through_has_one_association_with_order_on_nested_association
-    aa = AuthorAddress.find(author_addresses(:david_address).id, :include => {:author => :posts}, :order => 'posts.id')
+    aa = AuthorAddress.scoped(:includes => {:author => :posts}, :order => 'posts.id').find(author_addresses(:david_address).id)
     assert_equal aa.author.posts.count, aa.author.posts.length
   end
 
   def test_nested_loading_through_has_one_association_with_conditions
-    aa = AuthorAddress.references(:author_addresses).find(
-      author_addresses(:david_address).id, :include => {:author => :posts},
-      :conditions => "author_addresses.id > 0"
-    )
+    aa = AuthorAddress.references(:author_addresses).scoped(
+      :includes => {:author => :posts},
+      :where => "author_addresses.id > 0"
+    ).find author_addresses(:david_address).id
     assert_equal aa.author.posts.count, aa.author.posts.length
   end
 
   def test_nested_loading_through_has_one_association_with_conditions_on_association
-    aa = AuthorAddress.references(:authors).find(
-      author_addresses(:david_address).id, :include => {:author => :posts},
-      :conditions => "authors.id > 0"
-    )
+    aa = AuthorAddress.references(:authors).scoped(
+      :includes => {:author => :posts},
+      :where => "authors.id > 0"
+    ).find author_addresses(:david_address).id
     assert_equal aa.author.posts.count, aa.author.posts.length
   end
 
   def test_nested_loading_through_has_one_association_with_conditions_on_nested_association
-    aa = AuthorAddress.references(:posts).find(
-      author_addresses(:david_address).id, :include => {:author => :posts},
-      :conditions => "posts.id > 0"
-    )
+    aa = AuthorAddress.references(:posts).scoped(
+      :includes => {:author => :posts},
+      :where => "posts.id > 0"
+    ).find author_addresses(:david_address).id
     assert_equal aa.author.posts.count, aa.author.posts.length
   end
 
@@ -404,32 +404,32 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_load_belongs_to_quotes_table_and_column_names
-    job = Job.find jobs(:unicyclist).id, :include => :ideal_reference
+    job = Job.includes(:ideal_reference).find jobs(:unicyclist).id
     references(:michael_unicyclist)
     assert_no_queries{ assert_equal references(:michael_unicyclist), job.ideal_reference}
   end
 
   def test_eager_load_has_one_quotes_table_and_column_names
-    michael = Person.find(people(:michael), :include => :favourite_reference)
+    michael = Person.scoped(:includes => :favourite_reference).find(people(:michael))
     references(:michael_unicyclist)
     assert_no_queries{ assert_equal references(:michael_unicyclist), michael.favourite_reference}
   end
 
   def test_eager_load_has_many_quotes_table_and_column_names
-    michael = Person.find(people(:michael), :include => :references)
+    michael = Person.scoped(:includes => :references).find(people(:michael))
     references(:michael_magician,:michael_unicyclist)
     assert_no_queries{ assert_equal references(:michael_magician,:michael_unicyclist), michael.references.sort_by(&:id) }
   end
 
   def test_eager_load_has_many_through_quotes_table_and_column_names
-    michael = Person.find(people(:michael), :include => :jobs)
+    michael = Person.scoped(:includes => :jobs).find(people(:michael))
     jobs(:magician, :unicyclist)
     assert_no_queries{ assert_equal jobs(:unicyclist, :magician), michael.jobs.sort_by(&:id) }
   end
 
   def test_eager_load_has_many_with_string_keys
     subscriptions = subscriptions(:webster_awdr, :webster_rfr)
-    subscriber =Subscriber.find(subscribers(:second).id, :include => :subscriptions)
+    subscriber =Subscriber.scoped(:includes => :subscriptions).find(subscribers(:second).id)
     assert_equal subscriptions, subscriber.subscriptions.sort_by(&:id)
   end
 
@@ -447,13 +447,13 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_load_has_many_through_with_string_keys
     books = books(:awdr, :rfr)
-    subscriber = Subscriber.find(subscribers(:second).id, :include => :books)
+    subscriber = Subscriber.scoped(:includes => :books).find(subscribers(:second).id)
     assert_equal books, subscriber.books.sort_by(&:id)
   end
 
   def test_eager_load_belongs_to_with_string_keys
     subscriber = subscribers(:second)
-    subscription = Subscription.find(subscriptions(:webster_awdr).id, :include => :subscriber)
+    subscription = Subscription.scoped(:includes => :subscriber).find(subscriptions(:webster_awdr).id)
     assert_equal subscriber, subscription.subscriber
   end
 
@@ -497,11 +497,11 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_has_many_through_join_model_with_conditions_on_top_level
-    assert_equal comments(:more_greetings), Author.find(authors(:david).id, :include => :comments_with_order_and_conditions).comments_with_order_and_conditions.first
+    assert_equal comments(:more_greetings), Author.scoped(:includes => :comments_with_order_and_conditions).find(authors(:david).id).comments_with_order_and_conditions.first
   end
 
   def test_eager_with_has_many_through_join_model_with_include
-    author_comments = Author.find(authors(:david).id, :include => :comments_with_include).comments_with_include.to_a
+    author_comments = Author.scoped(:includes => :comments_with_include).find(authors(:david).id).comments_with_include.to_a
     assert_no_queries do
       author_comments.first.post.title
     end
@@ -509,7 +509,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_with_has_many_through_with_conditions_join_model_with_include
     post_tags = Post.find(posts(:welcome).id).misc_tags
-    eager_post_tags = Post.find(1, :include => :misc_tags).misc_tags
+    eager_post_tags = Post.scoped(:includes => :misc_tags).find(1).misc_tags
     assert_equal post_tags, eager_post_tags
   end
 
@@ -681,19 +681,19 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_has_one_with_association_inheritance
-    post = Post.find(4, :include => [ :very_special_comment ])
+    post = Post.scoped(:includes => [ :very_special_comment ]).find(4)
     assert_equal "VerySpecialComment", post.very_special_comment.class.to_s
   end
 
   def test_eager_has_many_with_association_inheritance
-    post = Post.find(4, :include => [ :special_comments ])
+    post = Post.scoped(:includes => [ :special_comments ]).find(4)
     post.special_comments.each do |special_comment|
       assert special_comment.is_a?(SpecialComment)
     end
   end
 
   def test_eager_habtm_with_association_inheritance
-    post = Post.find(6, :include => [ :special_categories ])
+    post = Post.scoped(:includes => [ :special_categories ]).find(6)
     assert_equal 1, post.special_categories.size
     post.special_categories.each do |special_category|
       assert_equal "SpecialCategory", special_category.class.to_s
@@ -717,16 +717,16 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_with_invalid_association_reference
     assert_raise(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
-      Post.find(6, :include=> :monkeys )
+      Post.scoped(:includes=> :monkeys ).find(6)
     }
     assert_raise(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
-      Post.find(6, :include=>[ :monkeys ])
+      Post.scoped(:includes=>[ :monkeys ]).find(6)
     }
     assert_raise(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
-      Post.find(6, :include=>[ 'monkeys' ])
+      Post.scoped(:includes=>[ 'monkeys' ]).find(6)
     }
     assert_raise(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys, :elephants") {
-      Post.find(6, :include=>[ :monkeys, :elephants ])
+      Post.scoped(:includes=>[ :monkeys, :elephants ]).find(6)
     }
   end
 
@@ -828,9 +828,9 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_polymorphic_type_condition
-    post = Post.find(posts(:thinking).id, :include => :taggings)
+    post = Post.scoped(:includes => :taggings).find(posts(:thinking).id)
     assert post.taggings.include?(taggings(:thinking_general))
-    post = SpecialPost.find(posts(:thinking).id, :include => :taggings)
+    post = SpecialPost.scoped(:includes => :taggings).find(posts(:thinking).id)
     assert post.taggings.include?(taggings(:thinking_general))
   end
 
@@ -1047,9 +1047,9 @@ class EagerAssociationTest < ActiveRecord::TestCase
     expected = Firm.find(1).clients_using_primary_key.sort_by(&:name)
     # Oracle adapter truncates alias to 30 characters
     if current_adapter?(:OracleAdapter)
-      firm = Firm.find 1, :include => :clients_using_primary_key, :order => 'clients_using_primary_keys_companies'[0,30]+'.name'
+      firm = Firm.scoped(:includes => :clients_using_primary_key, :order => 'clients_using_primary_keys_companies'[0,30]+'.name').find(1)
     else
-      firm = Firm.find 1, :include => :clients_using_primary_key, :order => 'clients_using_primary_keys_companies.name'
+      firm = Firm.scoped(:includes => :clients_using_primary_key, :order => 'clients_using_primary_keys_companies.name').find(1)
     end
     assert_no_queries do
       assert_equal expected, firm.clients_using_primary_key
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index fb8f45f0ce..a98e5b115c 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -1538,11 +1538,11 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     firm = Namespaced::Firm.create({ :name => 'Some Company' })
     firm.clients.create({ :name => 'Some Client' })
 
-    stats = Namespaced::Firm.find(firm.id, {
+    stats = Namespaced::Firm.scoped(
       :select => "#{Namespaced::Firm.table_name}.id, COUNT(#{Namespaced::Client.table_name}.id) AS num_clients",
       :joins  => :clients,
       :group  => "#{Namespaced::Firm.table_name}.id"
-    })
+    ).find firm.id
     assert_equal 1, stats.num_clients.to_i
 
   ensure
diff --git a/activerecord/test/cases/associations/has_one_associations_test.rb b/activerecord/test/cases/associations/has_one_associations_test.rb
index 57d2f3ee06..88ec65706c 100644
--- a/activerecord/test/cases/associations/has_one_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_associations_test.rb
@@ -31,7 +31,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
   def test_with_select
     assert_equal Firm.find(1).account_with_select.attributes.size, 2
-    assert_equal Firm.find(1, :include => :account_with_select).account_with_select.attributes.size, 2
+    assert_equal Firm.scoped(:includes => :account_with_select).find(1).account_with_select.attributes.size, 2
   end
 
   def test_finding_using_primary_key
@@ -346,14 +346,14 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
     assert_nothing_raised do
       Firm.find(@firm.id).save!
-      Firm.find(@firm.id, :include => :account).save!
+      Firm.scoped(:includes => :account).find(@firm.id).save!
     end
 
     @firm.account.destroy
 
     assert_nothing_raised do
       Firm.find(@firm.id).save!
-      Firm.find(@firm.id, :include => :account).save!
+      Firm.scoped(:includes => :account).find(@firm.id).save!
     end
   end
 
diff --git a/activerecord/test/cases/associations/has_one_through_associations_test.rb b/activerecord/test/cases/associations/has_one_through_associations_test.rb
index 00c7a78e82..94b9639e57 100644
--- a/activerecord/test/cases/associations/has_one_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_through_associations_test.rb
@@ -89,14 +89,14 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_one_through_with_conditions_eager_loading
     # conditions on the through table
-    assert_equal clubs(:moustache_club), Member.find(@member.id, :include => :favourite_club).favourite_club
+    assert_equal clubs(:moustache_club), Member.scoped(:includes => :favourite_club).find(@member.id).favourite_club
     memberships(:membership_of_favourite_club).update_column(:favourite, false)
-    assert_equal nil,                    Member.find(@member.id, :include => :favourite_club).reload.favourite_club
+    assert_equal nil,                    Member.scoped(:includes => :favourite_club).find(@member.id).reload.favourite_club
 
     # conditions on the source table
-    assert_equal clubs(:moustache_club), Member.find(@member.id, :include => :hairy_club).hairy_club
+    assert_equal clubs(:moustache_club), Member.scoped(:includes => :hairy_club).find(@member.id).hairy_club
     clubs(:moustache_club).update_column(:name, "Association of Clean-Shaven Persons")
-    assert_equal nil,                    Member.find(@member.id, :include => :hairy_club).reload.hairy_club
+    assert_equal nil,                    Member.scoped(:includes => :hairy_club).find(@member.id).reload.hairy_club
   end
 
   def test_has_one_through_polymorphic_with_source_type
@@ -210,14 +210,14 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
 
     assert_nothing_raised do
       Club.find(@club.id).save!
-      Club.find(@club.id, :include => :sponsored_member).save!
+      Club.scoped(:includes => :sponsored_member).find(@club.id).save!
     end
 
     @club.sponsor.destroy
 
     assert_nothing_raised do
       Club.find(@club.id).save!
-      Club.find(@club.id, :include => :sponsored_member).save!
+      Club.scoped(:includes => :sponsored_member).find(@club.id).save!
     end
   end
 
diff --git a/activerecord/test/cases/associations/join_model_test.rb b/activerecord/test/cases/associations/join_model_test.rb
index 5d25cc20f7..3606ce691c 100644
--- a/activerecord/test/cases/associations/join_model_test.rb
+++ b/activerecord/test/cases/associations/join_model_test.rb
@@ -364,7 +364,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_eager_has_many_polymorphic_with_source_type
-    tag_with_include = Tag.find(tags(:general).id, :include => :tagged_posts)
+    tag_with_include = Tag.scoped(:includes => :tagged_posts).find(tags(:general).id)
     desired = posts(:welcome, :thinking)
     assert_no_queries do
       # added sort by ID as otherwise test using JRuby was failing as array elements were in different order
@@ -614,7 +614,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_polymorphic_has_many
     expected = taggings(:welcome_general)
-    p = Post.find(posts(:welcome).id, :include => :taggings)
+    p = Post.scoped(:includes => :taggings).find(posts(:welcome).id)
     assert_no_queries {assert p.taggings.include?(expected)}
     assert posts(:welcome).taggings.include?(taggings(:welcome_general))
   end
@@ -622,12 +622,12 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   def test_polymorphic_has_one
     expected = posts(:welcome)
 
-    tagging  = Tagging.find(taggings(:welcome_general).id, :include => :taggable)
+    tagging  = Tagging.scoped(:includes => :taggable).find(taggings(:welcome_general).id)
     assert_no_queries { assert_equal expected, tagging.taggable}
   end
 
   def test_polymorphic_belongs_to
-    p = Post.find(posts(:welcome).id, :include => {:taggings => :taggable})
+    p = Post.scoped(:includes => {:taggings => :taggable}).find(posts(:welcome).id)
     assert_no_queries {assert_equal posts(:welcome), p.taggings.first.taggable}
   end
 
diff --git a/activerecord/test/cases/custom_locking_test.rb b/activerecord/test/cases/custom_locking_test.rb
index d63ecdbcc5..42ef51ef3e 100644
--- a/activerecord/test/cases/custom_locking_test.rb
+++ b/activerecord/test/cases/custom_locking_test.rb
@@ -9,7 +9,7 @@ module ActiveRecord
       if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
         assert_match 'SHARE MODE', Person.lock('LOCK IN SHARE MODE').to_sql
         assert_sql(/LOCK IN SHARE MODE/) do
-          Person.find(1, :lock => 'LOCK IN SHARE MODE')
+          Person.scoped(:lock => 'LOCK IN SHARE MODE').find(1)
         end
       end
     end
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index 9dfc8a6025..29469c42ed 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -98,14 +98,14 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_by_ids_with_limit_and_offset
-    assert_equal 2, Entrant.find([1,3,2], :limit => 2).size
-    assert_equal 1, Entrant.find([1,3,2], :limit => 3, :offset => 2).size
+    assert_equal 2, Entrant.scoped(:limit => 2).find([1,3,2]).size
+    assert_equal 1, Entrant.scoped(:limit => 3, :offset => 2).find([1,3,2]).size
 
     # Also test an edge case: If you have 11 results, and you set a
     #   limit of 3 and offset of 9, then you should find that there
     #   will be only 2 results, regardless of the limit.
     devs = Developer.all
-    last_devs = Developer.find devs.map(&:id), :limit => 3, :offset => 9
+    last_devs = Developer.scoped(:limit => 3, :offset => 9).find devs.map(&:id)
     assert_equal 2, last_devs.size
   end
 
@@ -226,7 +226,7 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_only_some_columns
-    topic = Topic.find(1, :select => "author_name")
+    topic = Topic.scoped(:select => "author_name").find(1)
     assert_raise(ActiveModel::MissingAttributeError) {topic.title}
     assert_nil topic.read_attribute("title")
     assert_equal "David", topic.author_name
@@ -237,23 +237,23 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_on_array_conditions
-    assert Topic.find(1, :conditions => ["approved = ?", false])
-    assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1, :conditions => ["approved = ?", true]) }
+    assert Topic.scoped(:where => ["approved = ?", false]).find(1)
+    assert_raise(ActiveRecord::RecordNotFound) { Topic.scoped(:where => ["approved = ?", true]).find(1) }
   end
 
   def test_find_on_hash_conditions
-    assert Topic.find(1, :conditions => { :approved => false })
-    assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1, :conditions => { :approved => true }) }
+    assert Topic.scoped(:where => { :approved => false }).find(1)
+    assert_raise(ActiveRecord::RecordNotFound) { Topic.scoped(:where => { :approved => true }).find(1) }
   end
 
   def test_find_on_hash_conditions_with_explicit_table_name
-    assert Topic.find(1, :conditions => { 'topics.approved' => false })
-    assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1, :conditions => { 'topics.approved' => true }) }
+    assert Topic.scoped(:where => { 'topics.approved' => false }).find(1)
+    assert_raise(ActiveRecord::RecordNotFound) { Topic.scoped(:where => { 'topics.approved' => true }).find(1) }
   end
 
   def test_find_on_hash_conditions_with_hashed_table_name
-    assert Topic.find(1, :conditions => {:topics => { :approved => false }})
-    assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1, :conditions => {:topics => { :approved => true }}) }
+    assert Topic.scoped(:where => {:topics => { :approved => false }}).find(1)
+    assert_raise(ActiveRecord::RecordNotFound) { Topic.scoped(:where => {:topics => { :approved => true }}).find(1) }
   end
 
   def test_find_with_hash_conditions_on_joined_table
@@ -270,9 +270,9 @@ class FinderTest < ActiveRecord::TestCase
 
   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 Customer.scoped(:where => { 'customers.name' => david.name, :address => david.address }).find(david.id)
     assert_raise(ActiveRecord::RecordNotFound) {
-      Customer.find(david.id, :conditions => { 'customers.name' => david.name + "1", :address => david.address })
+      Customer.scoped(:where => { 'customers.name' => david.name + "1", :address => david.address }).find(david.id)
     }
   end
 
@@ -282,13 +282,13 @@ class FinderTest < ActiveRecord::TestCase
 
   def test_find_on_hash_conditions_with_range
     assert_equal [1,2], Topic.scoped(:where => { :id => 1..2 }).all.map(&:id).sort
-    assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1, :conditions => { :id => 2..3 }) }
+    assert_raise(ActiveRecord::RecordNotFound) { Topic.scoped(:where => { :id => 2..3 }).find(1) }
   end
 
   def test_find_on_hash_conditions_with_end_exclusive_range
     assert_equal [1,2,3], Topic.scoped(:where => { :id => 1..3 }).all.map(&:id).sort
     assert_equal [1,2], Topic.scoped(:where => { :id => 1...3 }).all.map(&:id).sort
-    assert_raise(ActiveRecord::RecordNotFound) { Topic.find(3, :conditions => { :id => 2...3 }) }
+    assert_raise(ActiveRecord::RecordNotFound) { Topic.scoped(:where => { :id => 2...3 }).find(3) }
   end
 
   def test_find_on_hash_conditions_with_multiple_ranges
@@ -301,10 +301,10 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_on_multiple_hash_conditions
-    assert Topic.find(1, :conditions => { :author_name => "David", :title => "The First Topic", :replies_count => 1, :approved => false })
-    assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1, :conditions => { :author_name => "David", :title => "The First Topic", :replies_count => 1, :approved => true }) }
-    assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1, :conditions => { :author_name => "David", :title => "HHC", :replies_count => 1, :approved => false }) }
-    assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1, :conditions => { :author_name => "David", :title => "The First Topic", :replies_count => 1, :approved => true }) }
+    assert Topic.scoped(:where => { :author_name => "David", :title => "The First Topic", :replies_count => 1, :approved => false }).find(1)
+    assert_raise(ActiveRecord::RecordNotFound) { Topic.scoped(:where => { :author_name => "David", :title => "The First Topic", :replies_count => 1, :approved => true }).find(1) }
+    assert_raise(ActiveRecord::RecordNotFound) { Topic.scoped(:where => { :author_name => "David", :title => "HHC", :replies_count => 1, :approved => false }).find(1) }
+    assert_raise(ActiveRecord::RecordNotFound) { Topic.scoped(:where => { :author_name => "David", :title => "The First Topic", :replies_count => 1, :approved => true }).find(1) }
   end
 
   def test_condition_interpolation
@@ -1011,8 +1011,7 @@ class FinderTest < ActiveRecord::TestCase
 
   def test_find_by_id_with_conditions_with_or
     assert_nothing_raised do
-      Post.find([1,2,3],
-        :conditions => "posts.id <= 3 OR posts.#{QUOTED_TYPE} = 'Post'")
+      Post.where("posts.id <= 3 OR posts.#{QUOTED_TYPE} = 'Post'").find([1,2,3])
     end
   end
 
diff --git a/activerecord/test/cases/inheritance_test.rb b/activerecord/test/cases/inheritance_test.rb
index 453cae2ca2..06de51f5cd 100644
--- a/activerecord/test/cases/inheritance_test.rb
+++ b/activerecord/test/cases/inheritance_test.rb
@@ -201,14 +201,14 @@ class InheritanceTest < ActiveRecord::TestCase
   end
 
   def test_eager_load_belongs_to_something_inherited
-    account = Account.find(1, :include => :firm)
+    account = Account.scoped(:includes => :firm).find(1)
     assert account.association_cache.key?(:firm), "nil proves eager load failed"
   end
 
   def test_eager_load_belongs_to_primary_key_quoting
     con = Account.connection
     assert_sql(/#{con.quote_table_name('companies')}.#{con.quote_column_name('id')} IN \(1\)/) do
-      Account.find(1, :include => :firm)
+      Account.scoped(:includes => :firm).find(1)
     end
   end
 
diff --git a/activerecord/test/cases/modules_test.rb b/activerecord/test/cases/modules_test.rb
index 76fc975a27..a03c4f552e 100644
--- a/activerecord/test/cases/modules_test.rb
+++ b/activerecord/test/cases/modules_test.rb
@@ -48,7 +48,7 @@ class ModulesTest < ActiveRecord::TestCase
   end
 
   def test_find_account_and_include_company
-    account = MyApplication::Billing::Account.find(1, :include => :firm)
+    account = MyApplication::Billing::Account.scoped(:includes => :firm).find(1)
     assert_kind_of MyApplication::Business::Firm, account.firm
   end
 
@@ -72,8 +72,8 @@ class ModulesTest < ActiveRecord::TestCase
     clients = []
 
     assert_nothing_raised NameError, "Should be able to resolve all class constants via reflection" do
-      clients << MyApplication::Business::Client.references(:accounts).find(3, :include => {:firm => :account}, :conditions => 'accounts.id IS NOT NULL')
-      clients << MyApplication::Business::Client.find(3, :include => {:firm => :account})
+      clients << MyApplication::Business::Client.references(:accounts).scoped(:includes => {:firm => :account}, :where => 'accounts.id IS NOT NULL').find(3)
+      clients << MyApplication::Business::Client.scoped(:includes => {:firm => :account}).find(3)
     end
 
     clients.each do |client|
diff --git a/activerecord/test/cases/persistence_test.rb b/activerecord/test/cases/persistence_test.rb
index 26181311a5..3bc59560f0 100644
--- a/activerecord/test/cases/persistence_test.rb
+++ b/activerecord/test/cases/persistence_test.rb
@@ -131,7 +131,7 @@ class PersistencesTest < ActiveRecord::TestCase
   end
 
   def test_destroy_many
-    clients = Client.find([2, 3], :order => 'id')
+    clients = Client.scoped(:order => 'id').find([2, 3])
 
     assert_difference('Client.count', -2) do
       destroyed = Client.destroy([2, 3]).sort_by(&:id)
diff --git a/activerecord/test/cases/validations/uniqueness_validation_test.rb b/activerecord/test/cases/validations/uniqueness_validation_test.rb
index 2b1f34a2d0..c173ee9a15 100644
--- a/activerecord/test/cases/validations/uniqueness_validation_test.rb
+++ b/activerecord/test/cases/validations/uniqueness_validation_test.rb
@@ -189,7 +189,7 @@ class UniquenessValidationTest < ActiveRecord::TestCase
     assert t_utf8.save, "Should save t_utf8 as unique"
 
     # If database hasn't UTF-8 character set, this test fails
-    if Topic.find(t_utf8, :select => 'LOWER(title) AS title').title == "я тоже уникальный!"
+    if Topic.scoped(:select => 'LOWER(title) AS title').find(t_utf8).title == "я тоже уникальный!"
       t2_utf8 = Topic.new("title" => "я тоже УНИКАЛЬНЫЙ!")
       assert !t2_utf8.valid?, "Shouldn't be valid"
       assert !t2_utf8.save, "Shouldn't save t2_utf8 as unique"
-- 
cgit v1.2.3