remove deprecated calls

12 files changed, 93 insertions, 94 deletions

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"