applies new string literal convention in activerecord/test

The current code base is not uniform. After some discussion,
we have chosen to go with double quotes by default.

1 files changed, 128 insertions, 128 deletions

diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index 80d9a6083b..4da30ea3b6 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -1,31 +1,31 @@
 require "cases/helper"
-require 'models/post'
-require 'models/tagging'
-require 'models/tag'
-require 'models/comment'
-require 'models/author'
-require 'models/essay'
-require 'models/category'
-require 'models/company'
-require 'models/person'
-require 'models/reader'
-require 'models/owner'
-require 'models/pet'
-require 'models/reference'
-require 'models/job'
-require 'models/subscriber'
-require 'models/subscription'
-require 'models/book'
-require 'models/developer'
-require 'models/computer'
-require 'models/project'
-require 'models/member'
-require 'models/membership'
-require 'models/club'
-require 'models/categorization'
-require 'models/sponsor'
-require 'models/mentor'
-require 'models/contract'
+require "models/post"
+require "models/tagging"
+require "models/tag"
+require "models/comment"
+require "models/author"
+require "models/essay"
+require "models/category"
+require "models/company"
+require "models/person"
+require "models/reader"
+require "models/owner"
+require "models/pet"
+require "models/reference"
+require "models/job"
+require "models/subscriber"
+require "models/subscription"
+require "models/book"
+require "models/developer"
+require "models/computer"
+require "models/project"
+require "models/member"
+require "models/membership"
+require "models/club"
+require "models/categorization"
+require "models/sponsor"
+require "models/mentor"
+require "models/contract"
 
 class EagerAssociationTest < ActiveRecord::TestCase
   fixtures :posts, :comments, :authors, :essays, :author_addresses, :categories, :categories_posts,
@@ -54,7 +54,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_loading_with_one_association_with_non_preload
-    posts = Post.all.merge!(:includes => :last_comment, :order => 'comments.id DESC').to_a
+    posts = Post.all.merge!(:includes => :last_comment, :order => "comments.id DESC").to_a
     post = posts.find { |p| p.id == 1 }
     assert_equal Post.find(1).last_comment, post.last_comment
   end
@@ -107,7 +107,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_duplicate_middle_objects
-    comments = Comment.all.merge!(:where => 'post_id = 1', :includes => [:post => :author]).to_a
+    comments = Comment.all.merge!(:where => "post_id = 1", :includes => [:post => :author]).to_a
     assert_no_queries do
       comments.each {|comment| comment.post.author.name}
     end
@@ -169,7 +169,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_including_duplicate_objects_from_belongs_to
-    popular_post = Post.create!(:title => 'foo', :body => "I like cars!")
+    popular_post = Post.create!(:title => "foo", :body => "I like cars!")
     comment = popular_post.comments.create!(:body => "lol")
     popular_post.readers.create!(:person => people(:michael))
     popular_post.readers.create!(:person => people(:david))
@@ -182,12 +182,12 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_including_duplicate_objects_from_has_many
-    car_post = Post.create!(:title => 'foo', :body => "I like cars!")
+    car_post = Post.create!(:title => "foo", :body => "I like cars!")
     car_post.categories << categories(:general)
     car_post.categories << categories(:technology)
 
     comment = car_post.comments.create!(:body => "hmm")
-    categories = Category.all.merge!(:where => { 'posts.id' => car_post.id },
+    categories = Category.all.merge!(:where => { "posts.id" => car_post.id },
                                  :includes => {:posts => :comments}).to_a
     categories.each do |category|
       assert_equal [comment], category.posts[0].comments
@@ -195,10 +195,10 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_associations_loaded_for_all_records
-    post = Post.create!(:title => 'foo', :body => "I like cars!")
-    SpecialComment.create!(:body => 'Come on!', :post => post)
-    first_category = Category.create! :name => 'First!', :posts => [post]
-    second_category = Category.create! :name => 'Second!', :posts => [post]
+    post = Post.create!(:title => "foo", :body => "I like cars!")
+    SpecialComment.create!(:body => "Come on!", :post => post)
+    first_category = Category.create! :name => "First!", :posts => [post]
+    second_category = Category.create! :name => "Second!", :posts => [post]
 
     categories = Category.where(:id => [first_category.id, second_category.id]).includes(:posts => :special_comments)
     assert_equal categories.map { |category| category.posts.first.special_comments.loaded? }, [true, true]
@@ -256,7 +256,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_finding_with_includes_on_empty_polymorphic_type_column
     sponsor = sponsors(:moustache_club_sponsor_for_groucho)
-    sponsor.update!(sponsorable_type: '', sponsorable_id: nil) # sponsorable_type column might be declared NOT NULL
+    sponsor.update!(sponsorable_type: "", sponsorable_id: nil) # sponsorable_type column might be declared NOT NULL
     sponsor = assert_queries(1) do
       assert_nothing_raised { Sponsor.all.merge!(:includes => :sponsorable).find(sponsor.id) }
     end
@@ -302,17 +302,17 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_nested_loading_through_has_one_association_with_order
-    aa = AuthorAddress.all.merge!(:includes => {:author => :posts}, :order => 'author_addresses.id').find(author_addresses(:david_address).id)
+    aa = AuthorAddress.all.merge!(: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.all.merge!(:includes => {:author => :posts}, :order => 'authors.id').find(author_addresses(:david_address).id)
+    aa = AuthorAddress.all.merge!(: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.all.merge!(:includes => {:author => :posts}, :order => 'posts.id').find(author_addresses(:david_address).id)
+    aa = AuthorAddress.all.merge!(:includes => {:author => :posts}, :order => "posts.id").find(author_addresses(:david_address).id)
     assert_equal aa.author.posts.count, aa.author.posts.length
   end
 
@@ -354,45 +354,45 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit
-    comments = Comment.all.merge!(:includes => :post, :limit => 5, :order => 'comments.id').to_a
+    comments = Comment.all.merge!(:includes => :post, :limit => 5, :order => "comments.id").to_a
     assert_equal 5, comments.length
     assert_equal [1,2,3,5,6], comments.collect(&:id)
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_conditions
-    comments = Comment.all.merge!(:includes => :post, :where => 'post_id = 4', :limit => 3, :order => 'comments.id').to_a
+    comments = Comment.all.merge!(:includes => :post, :where => "post_id = 4", :limit => 3, :order => "comments.id").to_a
     assert_equal 3, comments.length
     assert_equal [5,6,7], comments.collect(&:id)
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_offset
-    comments = Comment.all.merge!(:includes => :post, :limit => 3, :offset => 2, :order => 'comments.id').to_a
+    comments = Comment.all.merge!(:includes => :post, :limit => 3, :offset => 2, :order => "comments.id").to_a
     assert_equal 3, comments.length
     assert_equal [3,5,6], comments.collect(&:id)
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_conditions
-    comments = Comment.all.merge!(:includes => :post, :where => 'post_id = 4', :limit => 3, :offset => 1, :order => 'comments.id').to_a
+    comments = Comment.all.merge!(:includes => :post, :where => "post_id = 4", :limit => 3, :offset => 1, :order => "comments.id").to_a
     assert_equal 3, comments.length
     assert_equal [6,7,8], comments.collect(&:id)
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_conditions_array
-    comments = Comment.all.merge!(:includes => :post, :where => ['post_id = ?',4], :limit => 3, :offset => 1, :order => 'comments.id').to_a
+    comments = Comment.all.merge!(:includes => :post, :where => ["post_id = ?",4], :limit => 3, :offset => 1, :order => "comments.id").to_a
     assert_equal 3, comments.length
     assert_equal [6,7,8], comments.collect(&:id)
   end
 
   def test_eager_association_loading_with_belongs_to_and_conditions_string_with_unquoted_table_name
     assert_nothing_raised do
-      Comment.includes(:post).references(:posts).where('posts.id = ?', 4)
+      Comment.includes(:post).references(:posts).where("posts.id = ?", 4)
     end
   end
 
   def test_eager_association_loading_with_belongs_to_and_conditions_hash
     comments = []
     assert_nothing_raised do
-      comments = Comment.all.merge!(:includes => :post, :where => {:posts => {:id => 4}}, :limit => 3, :order => 'comments.id').to_a
+      comments = Comment.all.merge!(:includes => :post, :where => {:posts => {:id => 4}}, :limit => 3, :order => "comments.id").to_a
     end
     assert_equal 3, comments.length
     assert_equal [5,6,7], comments.collect(&:id)
@@ -402,7 +402,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_belongs_to_and_conditions_string_with_quoted_table_name
-    quoted_posts_id= Comment.connection.quote_table_name('posts') + '.' + Comment.connection.quote_column_name('id')
+    quoted_posts_id= Comment.connection.quote_table_name("posts") + "." + Comment.connection.quote_column_name("id")
     assert_nothing_raised do
       Comment.includes(:post).references(:posts).where("#{quoted_posts_id} = ?", 4)
     end
@@ -410,25 +410,25 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_association_loading_with_belongs_to_and_order_string_with_unquoted_table_name
     assert_nothing_raised do
-      Comment.all.merge!(:includes => :post, :order => 'posts.id').to_a
+      Comment.all.merge!(:includes => :post, :order => "posts.id").to_a
     end
   end
 
   def test_eager_association_loading_with_belongs_to_and_order_string_with_quoted_table_name
-    quoted_posts_id= Comment.connection.quote_table_name('posts') + '.' + Comment.connection.quote_column_name('id')
+    quoted_posts_id= Comment.connection.quote_table_name("posts") + "." + Comment.connection.quote_column_name("id")
     assert_nothing_raised do
       Comment.includes(:post).references(:posts).order(quoted_posts_id)
     end
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_multiple_associations
-    posts = Post.all.merge!(:includes => [:author, :very_special_comment], :limit => 1, :order => 'posts.id').to_a
+    posts = Post.all.merge!(:includes => [:author, :very_special_comment], :limit => 1, :order => "posts.id").to_a
     assert_equal 1, posts.length
     assert_equal [1], posts.collect(&:id)
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_multiple_associations
-    posts = Post.all.merge!(:includes => [:author, :very_special_comment], :limit => 1, :offset => 1, :order => 'posts.id').to_a
+    posts = Post.all.merge!(:includes => [:author, :very_special_comment], :limit => 1, :offset => 1, :order => "posts.id").to_a
     assert_equal 1, posts.length
     assert_equal [2], posts.collect(&:id)
   end
@@ -493,14 +493,14 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_explicit_join
-    posts = Post.all.merge!(:includes => :comments, :joins => "INNER JOIN authors ON posts.author_id = authors.id AND authors.name = 'Mary'", :limit => 1, :order => 'author_id').to_a
+    posts = Post.all.merge!(:includes => :comments, :joins => "INNER JOIN authors ON posts.author_id = authors.id AND authors.name = 'Mary'", :limit => 1, :order => "author_id").to_a
     assert_equal 1, posts.length
   end
 
   def test_eager_with_has_many_through
-    posts_with_comments = people(:michael).posts.merge(:includes => :comments, :order => 'posts.id').to_a
-    posts_with_author = people(:michael).posts.merge(:includes => :author, :order => 'posts.id').to_a
-    posts_with_comments_and_author = people(:michael).posts.merge(:includes => [ :comments, :author ], :order => 'posts.id').to_a
+    posts_with_comments = people(:michael).posts.merge(:includes => :comments, :order => "posts.id").to_a
+    posts_with_author = people(:michael).posts.merge(:includes => :author, :order => "posts.id").to_a
+    posts_with_comments_and_author = people(:michael).posts.merge(:includes => [ :comments, :author ], :order => "posts.id").to_a
     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 }
@@ -516,19 +516,19 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_has_many_through_an_sti_join_model
-    author = Author.all.merge!(:includes => :special_post_comments, :order => 'authors.id').first
+    author = Author.all.merge!(: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.all.merge!(:includes => :special_nonexistent_post_comments, :order => 'authors.id').first
+    author = Author.all.merge!(:includes => :special_nonexistent_post_comments, :order => "authors.id").first
     assert_equal [], author.special_nonexistent_post_comments
   end
 
   def test_eager_with_has_many_through_join_model_with_conditions
     assert_equal Author.all.merge!(:includes => :hello_post_comments,
-                             :order => 'authors.id').first.hello_post_comments.sort_by(&:id),
-                 Author.all.merge!(:order => 'authors.id').first.hello_post_comments.sort_by(&:id)
+                             :order => "authors.id").first.hello_post_comments.sort_by(&:id),
+                 Author.all.merge!(: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
@@ -555,7 +555,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_has_many_and_limit
-    posts = Post.all.merge!(:order => 'posts.id asc', :includes => [ :author, :comments ], :limit => 2).to_a
+    posts = Post.all.merge!(:order => "posts.id asc", :includes => [ :author, :comments ], :limit => 2).to_a
     assert_equal 2, posts.size
     assert_equal 3, posts.inject(0) { |sum, post| sum + post.comments.size }
   end
@@ -567,21 +567,21 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_has_many_and_limit_and_conditions_array
-    posts = Post.all.merge!(:includes => [ :author, :comments ], :limit => 2, :where => [ "posts.body = ?", 'hello' ], :order => "posts.id").to_a
+    posts = Post.all.merge!(:includes => [ :author, :comments ], :limit => 2, :where => [ "posts.body = ?", "hello" ], :order => "posts.id").to_a
     assert_equal 2, posts.size
     assert_equal [4,5], posts.collect(&:id)
   end
 
   def test_eager_with_has_many_and_limit_and_conditions_array_on_the_eagers
-    posts = Post.includes(:author, :comments).limit(2).references(:author).where("authors.name = ?", 'David')
+    posts = Post.includes(:author, :comments).limit(2).references(:author).where("authors.name = ?", "David")
     assert_equal 2, posts.size
 
-    count = Post.includes(:author, :comments).limit(2).references(:author).where("authors.name = ?", 'David').count
+    count = Post.includes(:author, :comments).limit(2).references(:author).where("authors.name = ?", "David").count
     assert_equal posts.size, count
   end
 
   def test_eager_with_has_many_and_limit_and_high_offset
-    posts = Post.all.merge!(:includes => [ :author, :comments ], :limit => 2, :offset => 10, :where => { 'authors.name' => 'David' }).to_a
+    posts = Post.all.merge!(:includes => [ :author, :comments ], :limit => 2, :offset => 10, :where => { "authors.name" => "David" }).to_a
     assert_equal 0, posts.size
   end
 
@@ -589,7 +589,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     assert_queries(1) do
       posts = Post.references(:authors, :comments).
         merge(:includes => [ :author, :comments ], :limit => 2, :offset => 10,
-          :where => [ "authors.name = ? and comments.body = ?", 'David', 'go crazy' ]).to_a
+          :where => [ "authors.name = ? and comments.body = ?", "David", "go crazy" ]).to_a
       assert_equal 0, posts.size
     end
   end
@@ -597,13 +597,13 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_eager_with_has_many_and_limit_and_high_offset_and_multiple_hash_conditions
     assert_queries(1) do
       posts = Post.all.merge!(:includes => [ :author, :comments ], :limit => 2, :offset => 10,
-        :where => { 'authors.name' => 'David', 'comments.body' => 'go crazy' }).to_a
+        :where => { "authors.name" => "David", "comments.body" => "go crazy" }).to_a
       assert_equal 0, posts.size
     end
   end
 
   def test_count_eager_with_has_many_and_limit_and_high_offset
-    posts = Post.all.merge!(:includes => [ :author, :comments ], :limit => 2, :offset => 10, :where => { 'authors.name' => 'David' }).count(:all)
+    posts = Post.all.merge!(:includes => [ :author, :comments ], :limit => 2, :offset => 10, :where => { "authors.name" => "David" }).count(:all)
     assert_equal 0, posts
   end
 
@@ -615,7 +615,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.includes(:comments).where('comments.id is null').references(:comments).count
+    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
@@ -746,7 +746,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
       Post.all.merge!(:includes=>[ :monkeys ]).find(6)
     }
     assert_raise(ActiveRecord::AssociationNotFoundError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
-      Post.all.merge!(:includes=>[ 'monkeys' ]).find(6)
+      Post.all.merge!(:includes=>[ "monkeys" ]).find(6)
     }
     assert_raise(ActiveRecord::AssociationNotFoundError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys, :elephants") {
       Post.all.merge!(:includes=>[ :monkeys, :elephants ]).find(6)
@@ -754,23 +754,23 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_has_many_through_with_order
-    tag = OrderedTag.create(name: 'Foo')
-    post1 = Post.create!(title: 'Beaches', body: "I like beaches!")
-    post2 = Post.create!(title: 'Pools', body: "I like pools!")
+    tag = OrderedTag.create(name: "Foo")
+    post1 = Post.create!(title: "Beaches", body: "I like beaches!")
+    post2 = Post.create!(title: "Pools", body: "I like pools!")
 
-    Tagging.create!(taggable_type: 'Post', taggable_id: post1.id, tag: tag)
-    Tagging.create!(taggable_type: 'Post', taggable_id: post2.id, tag: tag)
+    Tagging.create!(taggable_type: "Post", taggable_id: post1.id, tag: tag)
+    Tagging.create!(taggable_type: "Post", taggable_id: post2.id, tag: tag)
 
     tag_with_includes = OrderedTag.includes(:tagged_posts).find(tag.id)
     assert_equal(tag_with_includes.taggings.map(&:taggable).map(&:title), tag_with_includes.tagged_posts.map(&:title))
   end
 
   def test_eager_has_many_through_multiple_with_order
-    tag1 = OrderedTag.create!(name: 'Bar')
-    tag2 = OrderedTag.create!(name: 'Foo')
+    tag1 = OrderedTag.create!(name: "Bar")
+    tag2 = OrderedTag.create!(name: "Foo")
 
-    post1 = Post.create!(title: 'Beaches', body: "I like beaches!")
-    post2 = Post.create!(title: 'Pools', body: "I like pools!")
+    post1 = Post.create!(title: "Beaches", body: "I like beaches!")
+    post2 = Post.create!(title: "Pools", body: "I like pools!")
 
     Tagging.create!(taggable: post1, tag: tag1)
     Tagging.create!(taggable: post2, tag: tag1)
@@ -786,7 +786,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_default_scope
-    developer = EagerDeveloperWithDefaultScope.where(:name => 'David').first
+    developer = EagerDeveloperWithDefaultScope.where(:name => "David").first
     projects = Project.order(:id).to_a
     assert_no_queries do
       assert_equal(projects, developer.projects)
@@ -794,7 +794,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_default_scope_as_class_method
-    developer = EagerDeveloperWithClassMethodDefaultScope.where(:name => 'David').first
+    developer = EagerDeveloperWithClassMethodDefaultScope.where(:name => "David").first
     projects = Project.order(:id).to_a
     assert_no_queries do
       assert_equal(projects, developer.projects)
@@ -811,7 +811,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_default_scope_as_class_method_using_find_by_method
-    developer = EagerDeveloperWithClassMethodDefaultScope.find_by(name: 'David')
+    developer = EagerDeveloperWithClassMethodDefaultScope.find_by(name: "David")
     projects = Project.order(:id).to_a
     assert_no_queries do
       assert_equal(projects, developer.projects)
@@ -819,7 +819,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_default_scope_as_lambda
-    developer = EagerDeveloperWithLambdaDefaultScope.where(:name => 'David').first
+    developer = EagerDeveloperWithLambdaDefaultScope.where(:name => "David").first
     projects = Project.order(:id).to_a
     assert_no_queries do
       assert_equal(projects, developer.projects)
@@ -828,8 +828,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_with_default_scope_as_block
     # warm up the habtm cache
-    EagerDeveloperWithBlockDefaultScope.where(:name => 'David').first.projects
-    developer = EagerDeveloperWithBlockDefaultScope.where(:name => 'David').first
+    EagerDeveloperWithBlockDefaultScope.where(:name => "David").first.projects
+    developer = EagerDeveloperWithBlockDefaultScope.where(:name => "David").first
     projects = Project.order(:id).to_a
     assert_no_queries do
       assert_equal(projects, developer.projects)
@@ -837,7 +837,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_default_scope_as_callable
-    developer = EagerDeveloperWithCallableDefaultScope.where(:name => 'David').first
+    developer = EagerDeveloperWithCallableDefaultScope.where(:name => "David").first
     projects = Project.order(:id).to_a
     assert_no_queries do
       assert_equal(projects, developer.projects)
@@ -852,15 +852,15 @@ class EagerAssociationTest < ActiveRecord::TestCase
     assert_equal(
       posts(:thinking, :sti_comments),
       Post.all.merge!(
-        :includes => [:author, :comments], :where => { 'authors.name' => 'David' },
-        :order => 'UPPER(posts.title)', :limit => 2, :offset => 1
+        :includes => [:author, :comments], :where => { "authors.name" => "David" },
+        :order => "UPPER(posts.title)", :limit => 2, :offset => 1
       ).to_a
     )
     assert_equal(
       posts(:sti_post_and_comments, :sti_comments),
       Post.all.merge!(
-        :includes => [:author, :comments], :where => { 'authors.name' => 'David' },
-        :order => 'UPPER(posts.title) DESC', :limit => 2, :offset => 1
+        :includes => [:author, :comments], :where => { "authors.name" => "David" },
+        :order => "UPPER(posts.title) DESC", :limit => 2, :offset => 1
       ).to_a
     )
   end
@@ -869,15 +869,15 @@ class EagerAssociationTest < ActiveRecord::TestCase
     assert_equal(
       posts(:thinking, :sti_comments),
       Post.all.merge!(
-        :includes => [:author, :comments], :where => { 'authors.name' => 'David' },
-        :order => ['UPPER(posts.title)', 'posts.id'], :limit => 2, :offset => 1
+        :includes => [:author, :comments], :where => { "authors.name" => "David" },
+        :order => ["UPPER(posts.title)", "posts.id"], :limit => 2, :offset => 1
       ).to_a
     )
     assert_equal(
       posts(:sti_post_and_comments, :sti_comments),
       Post.all.merge!(
-        :includes => [:author, :comments], :where => { 'authors.name' => 'David' },
-        :order => ['UPPER(posts.title) DESC', 'posts.id'], :limit => 2, :offset => 1
+        :includes => [:author, :comments], :where => { "authors.name" => "David" },
+        :order => ["UPPER(posts.title) DESC", "posts.id"], :limit => 2, :offset => 1
       ).to_a
     )
   end
@@ -888,7 +888,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
       Person.references(:number1_fans_people).merge(
         :includes => [:readers, :primary_contact, :number1_fan],
         :where => "number1_fans_people.first_name like 'M%'",
-        :order => 'people.id', :limit => 2, :offset => 0
+        :order => "people.id", :limit => 2, :offset => 0
       ).to_a
     )
   end
@@ -947,7 +947,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     end
   end
   def test_eager_with_valid_association_as_string_not_symbol
-    assert_nothing_raised { Post.all.merge!(:includes => 'comments').to_a }
+    assert_nothing_raised { Post.all.merge!(:includes => "comments").to_a }
   end
 
   def test_eager_with_floating_point_numbers
@@ -1006,13 +1006,13 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_association_loading_notification
-    notifications = messages_for('instantiation.active_record') do
-      Developer.all.merge!(:includes => 'projects', :where => { 'developers_projects.access_level' => 1 }, :limit => 5).to_a.size
+    notifications = messages_for("instantiation.active_record") do
+      Developer.all.merge!(:includes => "projects", :where => { "developers_projects.access_level" => 1 }, :limit => 5).to_a.size
     end
 
     message = notifications.first
     payload = message.last
-    count = Developer.all.merge!(:includes => 'projects', :where => { 'developers_projects.access_level' => 1 }, :limit => 5).to_a.size
+    count = Developer.all.merge!(:includes => "projects", :where => { "developers_projects.access_level" => 1 }, :limit => 5).to_a.size
 
     # eagerloaded row count should be greater than just developer count
     assert_operator payload[:record_count], :>, count
@@ -1020,7 +1020,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_base_messages
-    notifications = messages_for('instantiation.active_record') do
+    notifications = messages_for("instantiation.active_record") do
       Developer.all.to_a
     end
     message = notifications.first
@@ -1048,22 +1048,22 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_conditions_on_join_table_with_include_and_limit
-    assert_equal 3, Developer.all.merge!(:includes => 'projects', :where => { 'developers_projects.access_level' => 1 }, :limit => 5).to_a.size
+    assert_equal 3, Developer.all.merge!(:includes => "projects", :where => { "developers_projects.access_level" => 1 }, :limit => 5).to_a.size
   end
 
   def test_dont_create_temporary_active_record_instances
     Developer.instance_count = 0
-    developers = Developer.all.merge!(:includes => 'projects', :where => { 'developers_projects.access_level' => 1 }, :limit => 5).to_a
+    developers = Developer.all.merge!(:includes => "projects", :where => { "developers_projects.access_level" => 1 }, :limit => 5).to_a
     assert_equal developers.count, Developer.instance_count
   end
 
   def test_order_on_join_table_with_include_and_limit
-    assert_equal 5, Developer.all.merge!(:includes => 'projects', :order => 'developers_projects.joined_on DESC', :limit => 5).to_a.size
+    assert_equal 5, Developer.all.merge!(:includes => "projects", :order => "developers_projects.joined_on DESC", :limit => 5).to_a.size
   end
 
   def test_eager_loading_with_order_on_joined_table_preloads
     posts = assert_queries(2) do
-      Post.all.merge!(:joins => :comments, :includes => :author, :order => 'comments.id DESC').to_a
+      Post.all.merge!(:joins => :comments, :includes => :author, :order => "comments.id DESC").to_a
     end
     assert_equal posts(:eager_other), posts[1]
     assert_equal authors(:mary), assert_no_queries { posts[1].author}
@@ -1071,30 +1071,30 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_loading_with_conditions_on_joined_table_preloads
     posts = assert_queries(2) do
-      Post.all.merge!(:select => 'distinct posts.*', :includes => :author, :joins => [:comments], :where => "comments.body like 'Thank you%'", :order => 'posts.id').to_a
+      Post.all.merge!(:select => "distinct posts.*", :includes => :author, :joins => [:comments], :where => "comments.body like 'Thank you%'", :order => "posts.id").to_a
     end
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author}
 
     posts = assert_queries(2) do
-      Post.all.merge!(:select => 'distinct posts.*', :includes => :author, :joins => [:comments], :where => "comments.body like 'Thank you%'", :order => 'posts.id').to_a
+      Post.all.merge!(:select => "distinct posts.*", :includes => :author, :joins => [:comments], :where => "comments.body like 'Thank you%'", :order => "posts.id").to_a
     end
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author}
 
     posts = assert_queries(2) do
-      Post.all.merge!(:includes => :author, :joins => {:taggings => :tag}, :where => "tags.name = 'General'", :order => 'posts.id').to_a
+      Post.all.merge!(:includes => :author, :joins => {:taggings => :tag}, :where => "tags.name = 'General'", :order => "posts.id").to_a
     end
     assert_equal posts(:welcome, :thinking), posts
 
     posts = assert_queries(2) do
-      Post.all.merge!(:includes => :author, :joins => {:taggings => {:tag => :taggings}}, :where => "taggings_tags.super_tag_id=2", :order => 'posts.id').to_a
+      Post.all.merge!(:includes => :author, :joins => {:taggings => {:tag => :taggings}}, :where => "taggings_tags.super_tag_id=2", :order => "posts.id").to_a
     end
     assert_equal posts(:welcome, :thinking), posts
   end
 
   def test_preload_has_many_with_association_condition_and_default_scope
-    post = Post.create!(:title => 'Beaches', :body => "I like beaches!")
+    post = Post.create!(:title => "Beaches", :body => "I like beaches!")
     Reader.create! :person => people(:david), :post => post
     LazyReader.create! :person => people(:susan), :post => post
 
@@ -1107,13 +1107,13 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_loading_with_conditions_on_string_joined_table_preloads
     posts = assert_queries(2) do
-      Post.all.merge!(:select => 'distinct posts.*', :includes => :author, :joins => "INNER JOIN comments on comments.post_id = posts.id", :where => "comments.body like 'Thank you%'", :order => 'posts.id').to_a
+      Post.all.merge!(:select => "distinct posts.*", :includes => :author, :joins => "INNER JOIN comments on comments.post_id = posts.id", :where => "comments.body like 'Thank you%'", :order => "posts.id").to_a
     end
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author}
 
     posts = assert_queries(2) do
-      Post.all.merge!(:select => 'distinct posts.*', :includes => :author, :joins => ["INNER JOIN comments on comments.post_id = posts.id"], :where => "comments.body like 'Thank you%'", :order => 'posts.id').to_a
+      Post.all.merge!(:select => "distinct posts.*", :includes => :author, :joins => ["INNER JOIN comments on comments.post_id = posts.id"], :where => "comments.body like 'Thank you%'", :order => "posts.id").to_a
     end
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author}
@@ -1121,9 +1121,9 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_loading_with_select_on_joined_table_preloads
     posts = assert_queries(2) do
-      Post.all.merge!(:select => 'posts.*, authors.name as author_name', :includes => :comments, :joins => :author, :order => 'posts.id').to_a
+      Post.all.merge!(:select => "posts.*, authors.name as author_name", :includes => :comments, :joins => :author, :order => "posts.id").to_a
     end
-    assert_equal 'David', posts[0].author_name
+    assert_equal "David", posts[0].author_name
     assert_equal posts(:welcome).comments, assert_no_queries { posts[0].comments}
   end
 
@@ -1163,9 +1163,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.all.merge!(:includes => :clients_using_primary_key, :order => 'clients_using_primary_keys_companies'[0,30]+'.name').find(1)
+      firm = Firm.all.merge!(:includes => :clients_using_primary_key, :order => "clients_using_primary_keys_companies"[0,30]+".name").find(1)
     else
-      firm = Firm.all.merge!(:includes => :clients_using_primary_key, :order => 'clients_using_primary_keys_companies.name').find(1)
+      firm = Firm.all.merge!(: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
@@ -1174,7 +1174,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_preload_has_one_using_primary_key
     expected = accounts(:signals37)
-    firm = Firm.all.merge!(:includes => :account_using_primary_key, :order => 'companies.id').first
+    firm = Firm.all.merge!(:includes => :account_using_primary_key, :order => "companies.id").first
     assert_no_queries do
       assert_equal expected, firm.account_using_primary_key
     end
@@ -1182,28 +1182,28 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_include_has_one_using_primary_key
     expected = accounts(:signals37)
-    firm = Firm.all.merge!(:includes => :account_using_primary_key, :order => 'accounts.id').to_a.detect {|f| f.id == 1}
+    firm = Firm.all.merge!(:includes => :account_using_primary_key, :order => "accounts.id").to_a.detect {|f| f.id == 1}
     assert_no_queries do
       assert_equal expected, firm.account_using_primary_key
     end
   end
 
   def test_preloading_empty_belongs_to
-    c = Client.create!(:name => 'Foo', :client_of => Company.maximum(:id) + 1)
+    c = Client.create!(:name => "Foo", :client_of => Company.maximum(:id) + 1)
 
     client = assert_queries(2) { Client.preload(:firm).find(c.id) }
     assert_no_queries { assert_nil client.firm }
   end
 
   def test_preloading_empty_belongs_to_polymorphic
-    t = Tagging.create!(:taggable_type => 'Post', :taggable_id => Post.maximum(:id) + 1, :tag => tags(:general))
+    t = Tagging.create!(:taggable_type => "Post", :taggable_id => Post.maximum(:id) + 1, :tag => tags(:general))
 
     tagging = assert_queries(2) { Tagging.preload(:taggable).find(t.id) }
     assert_no_queries { assert_nil tagging.taggable }
   end
 
   def test_preloading_through_empty_belongs_to
-    c = Client.create!(:name => 'Foo', :client_of => Company.maximum(:id) + 1)
+    c = Client.create!(:name => "Foo", :client_of => Company.maximum(:id) + 1)
 
     client = assert_queries(2) { Client.preload(:accounts).find(c.id) }
     assert_no_queries { assert client.accounts.empty? }
@@ -1244,7 +1244,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_joins_with_includes_should_preload_via_joins
-    post = assert_queries(1) { Post.includes(:comments).joins(:comments).order('posts.id desc').to_a.first }
+    post = assert_queries(1) { Post.includes(:comments).joins(:comments).order("posts.id desc").to_a.first }
 
     assert_queries(0) do
       assert_not_equal 0, post.comments.to_a.count
@@ -1291,7 +1291,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   test "preload ignores the scoping" do
     assert_equal(
       Comment.find(1).post,
-      Post.where('1 = 0').scoping { Comment.preload(:post).find(1).post }
+      Post.where("1 = 0").scoping { Comment.preload(:post).find(1).post }
     )
   end
 
@@ -1316,10 +1316,10 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   test "works in combination with order(:symbol) and reorder(:symbol)" do
-    author = Author.includes(:posts).references(:posts).order(:name).find_by('posts.title IS NOT NULL')
+    author = Author.includes(:posts).references(:posts).order(:name).find_by("posts.title IS NOT NULL")
     assert_equal authors(:bob), author
 
-    author = Author.includes(:posts).references(:posts).reorder(:name).find_by('posts.title IS NOT NULL')
+    author = Author.includes(:posts).references(:posts).reorder(:name).find_by("posts.title IS NOT NULL")
     assert_equal authors(:bob), author
   end
 
@@ -1360,7 +1360,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   test "including associations with where.not adds implicit references" do
     author = assert_queries(2) {
-      Author.includes(:posts).where.not(posts: { title: 'Welcome to the weblog'} ).last
+      Author.includes(:posts).where.not(posts: { title: "Welcome to the weblog"} ).last
     }
 
     assert_no_queries {
@@ -1394,7 +1394,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     exception = assert_raises(ArgumentError) do
       Author.preload(10).to_a
     end
-    assert_equal('10 was not recognized for preload', exception.message)
+    assert_equal("10 was not recognized for preload", exception.message)
   end
 
   test "associations with extensions are not instance dependent" do
@@ -1443,12 +1443,12 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   test "preloading a polymorphic association with references to the associated table" do
-    post = Post.includes(:tags).references(:tags).where('tags.name = ?', 'General').first
+    post = Post.includes(:tags).references(:tags).where("tags.name = ?", "General").first
     assert_equal posts(:welcome), post
   end
 
   test "eager-loading a polymorphic association with references to the associated table" do
-    post = Post.eager_load(:tags).where('tags.name = ?', 'General').first
+    post = Post.eager_load(:tags).where("tags.name = ?", "General").first
     assert_equal posts(:welcome), post
   end