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.

3 files changed, 139 insertions, 139 deletions

diff --git a/activerecord/test/cases/scoping/default_scoping_test.rb b/activerecord/test/cases/scoping/default_scoping_test.rb
index 6679f9415b..dc938f779c 100644
--- a/activerecord/test/cases/scoping/default_scoping_test.rb
+++ b/activerecord/test/cases/scoping/default_scoping_test.rb
@@ -1,17 +1,17 @@
-require 'cases/helper'
-require 'models/post'
-require 'models/comment'
-require 'models/developer'
-require 'models/computer'
-require 'models/vehicle'
-require 'models/cat'
-require 'active_support/core_ext/regexp'
+require "cases/helper"
+require "models/post"
+require "models/comment"
+require "models/developer"
+require "models/computer"
+require "models/vehicle"
+require "models/cat"
+require "active_support/core_ext/regexp"
 
 class DefaultScopingTest < ActiveRecord::TestCase
   fixtures :developers, :posts, :comments
 
   def test_default_scope
-    expected = Developer.all.merge!(:order => 'salary DESC').to_a.collect(&:salary)
+    expected = Developer.all.merge!(:order => "salary DESC").to_a.collect(&:salary)
     received = DeveloperOrderedBySalary.all.collect(&:salary)
     assert_equal expected, received
   end
@@ -50,20 +50,20 @@ class DefaultScopingTest < ActiveRecord::TestCase
   end
 
   def test_default_scope_with_conditions_string
-    assert_equal Developer.where(name: 'David').map(&:id).sort, DeveloperCalledDavid.all.map(&:id).sort
+    assert_equal Developer.where(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.where(name: 'Jamis').map(&:id).sort, DeveloperCalledJamis.all.map(&:id).sort
-    assert_equal 'Jamis', DeveloperCalledJamis.create!.name
+    assert_equal Developer.where(name: "Jamis").map(&:id).sort, DeveloperCalledJamis.all.map(&:id).sort
+    assert_equal "Jamis", DeveloperCalledJamis.create!.name
   end
 
   unless in_memory_db?
     def test_default_scoping_with_threads
       2.times do
         Thread.new {
-          assert DeveloperOrderedBySalary.all.to_sql.include?('salary DESC')
+          assert DeveloperOrderedBySalary.all.to_sql.include?("salary DESC")
           DeveloperOrderedBySalary.connection.close
         }.join
       end
@@ -72,37 +72,37 @@ class DefaultScopingTest < ActiveRecord::TestCase
 
   def test_default_scope_with_inheritance
     wheres = InheritedPoorDeveloperCalledJamis.all.where_values_hash
-    assert_equal "Jamis", wheres['name']
-    assert_equal 50000,   wheres['salary']
+    assert_equal "Jamis", wheres["name"]
+    assert_equal 50000,   wheres["salary"]
   end
 
   def test_default_scope_with_module_includes
     wheres = ModuleIncludedPoorDeveloperCalledJamis.all.where_values_hash
-    assert_equal "Jamis", wheres['name']
-    assert_equal 50000,   wheres['salary']
+    assert_equal "Jamis", wheres["name"]
+    assert_equal 50000,   wheres["salary"]
   end
 
   def test_default_scope_with_multiple_calls
     wheres = MultiplePoorDeveloperCalledJamis.all.where_values_hash
-    assert_equal "Jamis", wheres['name']
-    assert_equal 50000,   wheres['salary']
+    assert_equal "Jamis", wheres["name"]
+    assert_equal 50000,   wheres["salary"]
   end
 
   def test_scope_overwrites_default
-    expected = Developer.all.merge!(order: 'salary DESC, name DESC').to_a.collect(&:name)
+    expected = Developer.all.merge!(order: "salary DESC, name DESC").to_a.collect(&:name)
     received = DeveloperOrderedBySalary.by_name.to_a.collect(&:name)
     assert_equal expected, received
   end
 
   def test_reorder_overrides_default_scope_order
-    expected = Developer.order('name DESC').collect(&:name)
-    received = DeveloperOrderedBySalary.reorder('name DESC').collect(&:name)
+    expected = Developer.order("name DESC").collect(&:name)
+    received = DeveloperOrderedBySalary.reorder("name DESC").collect(&:name)
     assert_equal expected, received
   end
 
   def test_order_after_reorder_combines_orders
-    expected = Developer.order('name DESC, id DESC').collect { |dev| [dev.name, dev.id] }
-    received = Developer.order('name ASC').reorder('name DESC').order('id DESC').collect { |dev| [dev.name, dev.id] }
+    expected = Developer.order("name DESC, id DESC").collect { |dev| [dev.name, dev.id] }
+    received = Developer.order("name ASC").reorder("name DESC").order("id DESC").collect { |dev| [dev.name, dev.id] }
     assert_equal expected, received
   end
 
@@ -113,107 +113,107 @@ class DefaultScopingTest < ActiveRecord::TestCase
   end
 
   def test_unscope_after_reordering_and_combining
-    expected = Developer.order('id DESC, name DESC').collect { |dev| [dev.name, dev.id] }
-    received = DeveloperOrderedBySalary.reorder('name DESC').unscope(:order).order('id DESC, name DESC').collect { |dev| [dev.name, dev.id] }
+    expected = Developer.order("id DESC, name DESC").collect { |dev| [dev.name, dev.id] }
+    received = DeveloperOrderedBySalary.reorder("name DESC").unscope(:order).order("id DESC, name DESC").collect { |dev| [dev.name, dev.id] }
     assert_equal expected, received
 
     expected_2 = Developer.all.collect { |dev| [dev.name, dev.id] }
-    received_2 = Developer.order('id DESC, name DESC').unscope(:order).collect { |dev| [dev.name, dev.id] }
+    received_2 = Developer.order("id DESC, name DESC").unscope(:order).collect { |dev| [dev.name, dev.id] }
     assert_equal expected_2, received_2
 
     expected_3 = Developer.all.collect { |dev| [dev.name, dev.id] }
-    received_3 = Developer.reorder('name DESC').unscope(:order).collect { |dev| [dev.name, dev.id] }
+    received_3 = Developer.reorder("name DESC").unscope(:order).collect { |dev| [dev.name, dev.id] }
     assert_equal expected_3, received_3
   end
 
   def test_unscope_with_where_attributes
-    expected = Developer.order('salary DESC').collect(&:name)
-    received = DeveloperOrderedBySalary.where(name: 'David').unscope(where: :name).collect(&:name)
+    expected = Developer.order("salary DESC").collect(&:name)
+    received = DeveloperOrderedBySalary.where(name: "David").unscope(where: :name).collect(&:name)
     assert_equal expected, received
 
-    expected_2 = Developer.order('salary DESC').collect(&:name)
+    expected_2 = Developer.order("salary DESC").collect(&:name)
     received_2 = DeveloperOrderedBySalary.select("id").where("name" => "Jamis").unscope({:where => :name}, :select).collect(&:name)
     assert_equal expected_2, received_2
 
-    expected_3 = Developer.order('salary DESC').collect(&:name)
+    expected_3 = Developer.order("salary DESC").collect(&:name)
     received_3 = DeveloperOrderedBySalary.select("id").where("name" => "Jamis").unscope(:select, :where).collect(&:name)
     assert_equal expected_3, received_3
 
-    expected_4 = Developer.order('salary DESC').collect(&:name)
+    expected_4 = Developer.order("salary DESC").collect(&:name)
     received_4 = DeveloperOrderedBySalary.where.not("name" => "Jamis").unscope(where: :name).collect(&:name)
     assert_equal expected_4, received_4
 
-    expected_5 = Developer.order('salary DESC').collect(&:name)
+    expected_5 = Developer.order("salary DESC").collect(&:name)
     received_5 = DeveloperOrderedBySalary.where.not("name" => ["Jamis", "David"]).unscope(where: :name).collect(&:name)
     assert_equal expected_5, received_5
 
-    expected_6 = Developer.order('salary DESC').collect(&:name)
-    received_6 = DeveloperOrderedBySalary.where(Developer.arel_table['name'].eq('David')).unscope(where: :name).collect(&:name)
+    expected_6 = Developer.order("salary DESC").collect(&:name)
+    received_6 = DeveloperOrderedBySalary.where(Developer.arel_table["name"].eq("David")).unscope(where: :name).collect(&:name)
     assert_equal expected_6, received_6
 
-    expected_7 = Developer.order('salary DESC').collect(&:name)
-    received_7 = DeveloperOrderedBySalary.where(Developer.arel_table[:name].eq('David')).unscope(where: :name).collect(&:name)
+    expected_7 = Developer.order("salary DESC").collect(&:name)
+    received_7 = DeveloperOrderedBySalary.where(Developer.arel_table[:name].eq("David")).unscope(where: :name).collect(&:name)
     assert_equal expected_7, received_7
   end
 
   def test_unscope_comparison_where_clauses
     # unscoped for WHERE (`developers`.`id` <= 2)
-    expected = Developer.order('salary DESC').collect(&:name)
+    expected = Developer.order("salary DESC").collect(&:name)
     received = DeveloperOrderedBySalary.where(id: -Float::INFINITY..2).unscope(where: :id).collect { |dev| dev.name }
     assert_equal expected, received
 
     # unscoped for WHERE (`developers`.`id` < 2)
-    expected = Developer.order('salary DESC').collect(&:name)
+    expected = Developer.order("salary DESC").collect(&:name)
     received = DeveloperOrderedBySalary.where(id: -Float::INFINITY...2).unscope(where: :id).collect { |dev| dev.name }
     assert_equal expected, received
   end
 
   def test_unscope_multiple_where_clauses
-    expected = Developer.order('salary DESC').collect(&:name)
-    received = DeveloperOrderedBySalary.where(name: 'Jamis').where(id: 1).unscope(where: [:name, :id]).collect(&:name)
+    expected = Developer.order("salary DESC").collect(&:name)
+    received = DeveloperOrderedBySalary.where(name: "Jamis").where(id: 1).unscope(where: [:name, :id]).collect(&:name)
     assert_equal expected, received
   end
 
   def test_unscope_string_where_clauses_involved
-    dev_relation = Developer.order('salary DESC').where("created_at > ?", 1.year.ago)
+    dev_relation = Developer.order("salary DESC").where("created_at > ?", 1.year.ago)
     expected = dev_relation.collect(&:name)
 
-    dev_ordered_relation = DeveloperOrderedBySalary.where(name: 'Jamis').where("created_at > ?", 1.year.ago)
+    dev_ordered_relation = DeveloperOrderedBySalary.where(name: "Jamis").where("created_at > ?", 1.year.ago)
     received = dev_ordered_relation.unscope(where: [:name]).collect(&:name)
 
     assert_equal expected, received
   end
 
   def test_unscope_with_grouping_attributes
-    expected = Developer.order('salary DESC').collect(&:name)
+    expected = Developer.order("salary DESC").collect(&:name)
     received = DeveloperOrderedBySalary.group(:name).unscope(:group).collect(&:name)
     assert_equal expected, received
 
-    expected_2 = Developer.order('salary DESC').collect(&:name)
+    expected_2 = Developer.order("salary DESC").collect(&:name)
     received_2 = DeveloperOrderedBySalary.group("name").unscope(:group).collect(&:name)
     assert_equal expected_2, received_2
   end
 
   def test_unscope_with_limit_in_query
-    expected = Developer.order('salary DESC').collect(&:name)
+    expected = Developer.order("salary DESC").collect(&:name)
     received = DeveloperOrderedBySalary.limit(1).unscope(:limit).collect(&:name)
     assert_equal expected, received
   end
 
   def test_order_to_unscope_reordering
-    scope = DeveloperOrderedBySalary.order('salary DESC, name ASC').reverse_order.unscope(:order)
+    scope = DeveloperOrderedBySalary.order("salary DESC, name ASC").reverse_order.unscope(:order)
     assert !/order/i.match?(scope.to_sql)
   end
 
   def test_unscope_reverse_order
     expected = Developer.all.collect(&:name)
-    received = Developer.order('salary DESC').reverse_order.unscope(:order).collect(&:name)
+    received = Developer.order("salary DESC").reverse_order.unscope(:order).collect(&:name)
     assert_equal expected, received
   end
 
   def test_unscope_select
-    expected = Developer.order('salary ASC').collect(&:name)
-    received = Developer.order('salary DESC').reverse_order.select(:name).unscope(:select).collect(&:name)
+    expected = Developer.order("salary ASC").collect(&:name)
+    received = Developer.order("salary DESC").reverse_order.select(:name).unscope(:select).collect(&:name)
     assert_equal expected, received
 
     expected_2 = Developer.all.collect(&:id)
@@ -229,7 +229,7 @@ class DefaultScopingTest < ActiveRecord::TestCase
 
   def test_unscope_joins_and_select_on_developers_projects
     expected = Developer.all.collect(&:name)
-    received = Developer.joins('JOIN developers_projects ON id = developer_id').select(:id).unscope(:joins, :select).collect(&:name)
+    received = Developer.joins("JOIN developers_projects ON id = developer_id").select(:id).unscope(:joins, :select).collect(&:name)
     assert_equal expected, received
   end
 
@@ -250,8 +250,8 @@ class DefaultScopingTest < ActiveRecord::TestCase
       scope :by_name, -> name { unscope(where: :name).where(name: name) }
     end
 
-    expected = developer_klass.where(name: 'Jamis').collect { |dev| [dev.name, dev.id] }
-    received = developer_klass.where(name: 'David').by_name('Jamis').collect { |dev| [dev.name, dev.id] }
+    expected = developer_klass.where(name: "Jamis").collect { |dev| [dev.name, dev.id] }
+    received = developer_klass.where(name: "David").by_name("Jamis").collect { |dev| [dev.name, dev.id] }
     assert_equal expected, received
   end
 
@@ -265,11 +265,11 @@ class DefaultScopingTest < ActiveRecord::TestCase
     end
 
     assert_raises(ArgumentError) do
-      Developer.order('name DESC').reverse_order.unscope(:reverse_order)
+      Developer.order("name DESC").reverse_order.unscope(:reverse_order)
     end
 
     assert_raises(ArgumentError) do
-      Developer.order('name DESC').where(name: "Jamis").unscope()
+      Developer.order("name DESC").where(name: "Jamis").unscope()
     end
   end
 
@@ -304,35 +304,35 @@ class DefaultScopingTest < ActiveRecord::TestCase
   end
 
   def test_order_in_default_scope_should_not_prevail
-    expected = Developer.all.merge!(order: 'salary desc').to_a.collect(&:salary)
-    received = DeveloperOrderedBySalary.all.merge!(order: 'salary').to_a.collect(&:salary)
+    expected = Developer.all.merge!(order: "salary desc").to_a.collect(&:salary)
+    received = DeveloperOrderedBySalary.all.merge!(order: "salary").to_a.collect(&:salary)
     assert_equal expected, received
   end
 
   def test_create_attribute_overwrites_default_scoping
-    assert_equal 'David', PoorDeveloperCalledJamis.create!(:name => 'David').name
-    assert_equal 200000, PoorDeveloperCalledJamis.create!(:name => 'David', :salary => 200000).salary
+    assert_equal "David", PoorDeveloperCalledJamis.create!(:name => "David").name
+    assert_equal 200000, PoorDeveloperCalledJamis.create!(:name => "David", :salary => 200000).salary
   end
 
   def test_create_attribute_overwrites_default_values
     assert_equal nil, PoorDeveloperCalledJamis.create!(:salary => nil).salary
-    assert_equal 50000, PoorDeveloperCalledJamis.create!(:name => 'David').salary
+    assert_equal 50000, PoorDeveloperCalledJamis.create!(:name => "David").salary
   end
 
   def test_default_scope_attribute
-    jamis = PoorDeveloperCalledJamis.new(:name => 'David')
+    jamis = PoorDeveloperCalledJamis.new(:name => "David")
     assert_equal 50000, jamis.salary
   end
 
   def test_where_attribute
-    aaron = PoorDeveloperCalledJamis.where(:salary => 20).new(:name => 'Aaron')
+    aaron = PoorDeveloperCalledJamis.where(:salary => 20).new(:name => "Aaron")
     assert_equal 20, aaron.salary
-    assert_equal 'Aaron', aaron.name
+    assert_equal "Aaron", aaron.name
   end
 
   def test_where_attribute_merge
-    aaron = PoorDeveloperCalledJamis.where(:name => 'foo').new(:name => 'Aaron')
-    assert_equal 'Aaron', aaron.name
+    aaron = PoorDeveloperCalledJamis.where(:name => "foo").new(:name => "Aaron")
+    assert_equal "Aaron", aaron.name
   end
 
   def test_scope_composed_by_limit_and_then_offset_is_equal_to_scope_composed_by_offset_and_then_limit
@@ -342,27 +342,27 @@ class DefaultScopingTest < ActiveRecord::TestCase
   end
 
   def test_create_with_merge
-    aaron = PoorDeveloperCalledJamis.create_with(:name => 'foo', :salary => 20).merge(
-              PoorDeveloperCalledJamis.create_with(:name => 'Aaron')).new
+    aaron = PoorDeveloperCalledJamis.create_with(:name => "foo", :salary => 20).merge(
+              PoorDeveloperCalledJamis.create_with(:name => "Aaron")).new
     assert_equal 20, aaron.salary
-    assert_equal 'Aaron', aaron.name
+    assert_equal "Aaron", aaron.name
 
-    aaron = PoorDeveloperCalledJamis.create_with(:name => 'foo', :salary => 20).
-                                     create_with(:name => 'Aaron').new
+    aaron = PoorDeveloperCalledJamis.create_with(:name => "foo", :salary => 20).
+                                     create_with(:name => "Aaron").new
     assert_equal 20, aaron.salary
-    assert_equal 'Aaron', aaron.name
+    assert_equal "Aaron", aaron.name
   end
 
   def test_create_with_reset
-    jamis = PoorDeveloperCalledJamis.create_with(:name => 'Aaron').create_with(nil).new
-    assert_equal 'Jamis', jamis.name
+    jamis = PoorDeveloperCalledJamis.create_with(:name => "Aaron").create_with(nil).new
+    assert_equal "Jamis", jamis.name
   end
 
   # FIXME: I don't know if this is *desired* behavior, but it is *today's*
   # behavior.
   def test_create_with_empty_hash_will_not_reset
-    jamis = PoorDeveloperCalledJamis.create_with(:name => 'Aaron').create_with({}).new
-    assert_equal 'Aaron', jamis.name
+    jamis = PoorDeveloperCalledJamis.create_with(:name => "Aaron").create_with({}).new
+    assert_equal "Aaron", jamis.name
   end
 
   def test_unscoped_with_named_scope_should_not_have_default_scope
@@ -410,9 +410,9 @@ class DefaultScopingTest < ActiveRecord::TestCase
 
   def test_default_scope_include_with_count
     d = DeveloperWithIncludes.create!
-    d.audit_logs.create! :message => 'foo'
+    d.audit_logs.create! :message => "foo"
 
-    assert_equal 1, DeveloperWithIncludes.where(:audit_logs => { :message => 'foo' }).count
+    assert_equal 1, DeveloperWithIncludes.where(:audit_logs => { :message => "foo" }).count
   end
 
   def test_default_scope_with_references_works_through_collection_association
@@ -475,9 +475,9 @@ class DefaultScopingTest < ActiveRecord::TestCase
   end
 
   def test_sti_conditions_are_not_carried_in_default_scope
-    ConditionalStiPost.create! body: ''
-    SubConditionalStiPost.create! body: ''
-    SubConditionalStiPost.create! title: 'Hello world', body: ''
+    ConditionalStiPost.create! body: ""
+    SubConditionalStiPost.create! body: ""
+    SubConditionalStiPost.create! title: "Hello world", body: ""
 
     assert_equal 2, ConditionalStiPost.count
     assert_equal 2, ConditionalStiPost.all.to_a.size
diff --git a/activerecord/test/cases/scoping/named_scoping_test.rb b/activerecord/test/cases/scoping/named_scoping_test.rb
index f0dac07acc..1327bf3253 100644
--- a/activerecord/test/cases/scoping/named_scoping_test.rb
+++ b/activerecord/test/cases/scoping/named_scoping_test.rb
@@ -1,11 +1,11 @@
 require "cases/helper"
-require 'models/post'
-require 'models/topic'
-require 'models/comment'
-require 'models/reply'
-require 'models/author'
-require 'models/developer'
-require 'models/computer'
+require "models/post"
+require "models/topic"
+require "models/comment"
+require "models/reply"
+require "models/author"
+require "models/developer"
+require "models/computer"
 
 class NamedScopingTest < ActiveRecord::TestCase
   fixtures :posts, :authors, :topics, :comments, :author_addresses
@@ -56,8 +56,8 @@ class NamedScopingTest < ActiveRecord::TestCase
   def test_method_missing_priority_when_delegating
     klazz = Class.new(ActiveRecord::Base) do
       self.table_name = "topics"
-      scope :since, Proc.new { where('written_on >= ?', Time.now - 1.day) }
-      scope :to,    Proc.new { where('written_on <= ?', Time.now) }
+      scope :since, Proc.new { where("written_on >= ?", Time.now - 1.day) }
+      scope :to,    Proc.new { where("written_on <= ?", Time.now) }
     end
     assert_equal klazz.to.since.to_a, klazz.since.to.to_a
   end
@@ -83,7 +83,7 @@ class NamedScopingTest < ActiveRecord::TestCase
 
   def test_scopes_are_composable
     assert_equal((approved = Topic.all.merge!(:where => {:approved => true}).to_a), Topic.approved)
-    assert_equal((replied = Topic.all.merge!(:where => 'replies_count > 0').to_a), Topic.replied)
+    assert_equal((replied = Topic.all.merge!(:where => "replies_count > 0").to_a), Topic.replied)
     assert !(approved == replied)
     assert !(approved & replied).empty?
 
@@ -91,8 +91,8 @@ class NamedScopingTest < ActiveRecord::TestCase
   end
 
   def test_procedural_scopes
-    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)
+    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)
@@ -108,7 +108,7 @@ class NamedScopingTest < ActiveRecord::TestCase
   def test_scope_with_object
     objects = Topic.with_object
     assert_operator objects.length, :>, 0
-    assert objects.all?(&:approved?), 'all objects should be approved'
+    assert objects.all?(&:approved?), "all objects should be approved"
   end
 
   def test_has_many_associations_have_access_to_scopes
@@ -280,7 +280,7 @@ class NamedScopingTest < ActiveRecord::TestCase
   def test_should_build_on_top_of_chained_scopes
     topic = Topic.approved.by_lifo.build({})
     assert topic.approved
-    assert_equal 'lifo', topic.author_name
+    assert_equal "lifo", topic.author_name
   end
 
   def test_reserved_scope_names
@@ -372,7 +372,7 @@ class NamedScopingTest < ActiveRecord::TestCase
   end
 
   def test_should_use_where_in_query_for_scope
-    assert_equal Developer.where(name: 'Jamis').to_set, Developer.where(id: Developer.jamises).to_set
+    assert_equal Developer.where(name: "Jamis").to_set, Developer.where(id: Developer.jamises).to_set
   end
 
   def test_size_should_use_count_when_results_are_not_loaded
@@ -468,7 +468,7 @@ class NamedScopingTest < ActiveRecord::TestCase
 
   def test_scopes_on_relations
     # Topic.replied
-    approved_topics = Topic.all.approved.order('id DESC')
+    approved_topics = Topic.all.approved.order("id DESC")
     assert_equal topics(:fifth), approved_topics.first
 
     replied_approved_topics = approved_topics.replied
@@ -476,7 +476,7 @@ class NamedScopingTest < ActiveRecord::TestCase
   end
 
   def test_index_on_scope
-    approved = Topic.approved.order('id ASC')
+    approved = Topic.approved.order("id ASC")
     assert_equal topics(:second), approved[0]
     assert approved.loaded?
   end
@@ -540,7 +540,7 @@ class NamedScopingTest < ActiveRecord::TestCase
 
   def test_eager_default_scope_relations_are_remove
     klass = Class.new(ActiveRecord::Base)
-    klass.table_name = 'posts'
+    klass.table_name = "posts"
 
     assert_raises(ArgumentError) do
       klass.send(:default_scope, klass.where(:id => posts(:welcome).id))
@@ -548,7 +548,7 @@ class NamedScopingTest < ActiveRecord::TestCase
   end
 
   def test_subclass_merges_scopes_properly
-    assert_equal 1, SpecialComment.where(body: 'go crazy').created.count
+    assert_equal 1, SpecialComment.where(body: "go crazy").created.count
   end
 
   def test_model_class_should_respond_to_none
diff --git a/activerecord/test/cases/scoping/relation_scoping_test.rb b/activerecord/test/cases/scoping/relation_scoping_test.rb
index ef46fd5d9a..253c4195df 100644
--- a/activerecord/test/cases/scoping/relation_scoping_test.rb
+++ b/activerecord/test/cases/scoping/relation_scoping_test.rb
@@ -1,13 +1,13 @@
 require "cases/helper"
-require 'models/post'
-require 'models/author'
-require 'models/developer'
-require 'models/computer'
-require 'models/project'
-require 'models/comment'
-require 'models/category'
-require 'models/person'
-require 'models/reference'
+require "models/post"
+require "models/author"
+require "models/developer"
+require "models/computer"
+require "models/project"
+require "models/comment"
+require "models/category"
+require "models/person"
+require "models/reference"
 
 class RelationScopingTest < ActiveRecord::TestCase
   fixtures :authors, :developers, :projects, :comments, :posts, :developers_projects
@@ -109,7 +109,7 @@ class RelationScopingTest < ActiveRecord::TestCase
 
   def test_scope_select_concatenates
     Developer.select("id, name").scoping do
-      developer = Developer.select('salary').where("name = 'David'").first
+      developer = Developer.select("salary").where("name = 'David'").first
       assert_equal 80000, developer.salary
       assert developer.has_attribute?(:id)
       assert developer.has_attribute?(:name)
@@ -122,7 +122,7 @@ class RelationScopingTest < ActiveRecord::TestCase
       assert_equal 1, Developer.count
     end
 
-    Developer.where('salary = 100000').scoping do
+    Developer.where("salary = 100000").scoping do
       assert_equal 8, Developer.count
       assert_equal 1, Developer.where("name LIKE 'fixture_1%'").count
     end
@@ -131,7 +131,7 @@ class RelationScopingTest < ActiveRecord::TestCase
   def test_scoped_find_include
     # with the include, will retrieve only developers for the given project
     scoped_developers = Developer.includes(:projects).scoping do
-      Developer.where('projects.id' => 2).to_a
+      Developer.where("projects.id" => 2).to_a
     end
     assert scoped_developers.include?(developers(:david))
     assert !scoped_developers.include?(developers(:jamis))
@@ -139,8 +139,8 @@ class RelationScopingTest < ActiveRecord::TestCase
   end
 
   def test_scoped_find_joins
-    scoped_developers = Developer.joins('JOIN developers_projects ON id = developer_id').scoping do
-      Developer.where('developers_projects.project_id = 2').to_a
+    scoped_developers = Developer.joins("JOIN developers_projects ON id = developer_id").scoping do
+      Developer.where("developers_projects.project_id = 2").to_a
     end
 
     assert scoped_developers.include?(developers(:david))
@@ -241,12 +241,12 @@ class NestedRelationScopingTest < ActiveRecord::TestCase
   fixtures :authors, :developers, :projects, :comments, :posts
 
   def test_merge_options
-    Developer.where('salary = 80000').scoping do
+    Developer.where("salary = 80000").scoping do
       Developer.limit(10).scoping do
         devs = Developer.all
         sql = devs.to_sql
-        assert_match '(salary = 80000)', sql
-        assert_match 'LIMIT 10', sql
+        assert_match "(salary = 80000)", sql
+        assert_match "LIMIT 10", sql
       end
     end
   end
@@ -260,32 +260,32 @@ class NestedRelationScopingTest < ActiveRecord::TestCase
   end
 
   def test_replace_options
-    Developer.where(:name => 'David').scoping do
+    Developer.where(:name => "David").scoping do
       Developer.unscoped do
-        assert_equal 'Jamis', Developer.where(:name => 'Jamis').first[:name]
+        assert_equal "Jamis", Developer.where(:name => "Jamis").first[:name]
       end
 
-      assert_equal 'David', Developer.first[:name]
+      assert_equal "David", Developer.first[:name]
     end
   end
 
   def test_three_level_nested_exclusive_scoped_find
     Developer.where("name = 'Jamis'").scoping do
-      assert_equal 'Jamis', Developer.first.name
+      assert_equal "Jamis", Developer.first.name
 
       Developer.unscoped.where("name = 'David'") do
-        assert_equal 'David', Developer.first.name
+        assert_equal "David", Developer.first.name
 
         Developer.unscoped.where("name = 'Maiha'") do
           assert_equal nil, Developer.first
         end
 
         # ensure that scoping is restored
-        assert_equal 'David', Developer.first.name
+        assert_equal "David", Developer.first.name
       end
 
       # ensure that scoping is restored
-      assert_equal 'Jamis', Developer.first.name
+      assert_equal "Jamis", Developer.first.name
     end
   end
 
@@ -308,7 +308,7 @@ class NestedRelationScopingTest < ActiveRecord::TestCase
     end
 
     assert_equal 1, comment.post_id
-    assert_equal 'Hey guys', comment.body
+    assert_equal "Hey guys", comment.body
   end
 end
 
@@ -320,24 +320,24 @@ class HasManyScopingTest < ActiveRecord::TestCase
   end
 
   def test_forwarding_of_static_methods
-    assert_equal 'a comment...', Comment.what_are_you
-    assert_equal 'a comment...', @welcome.comments.what_are_you
+    assert_equal "a comment...", Comment.what_are_you
+    assert_equal "a comment...", @welcome.comments.what_are_you
   end
 
   def test_forwarding_to_scoped
-    assert_equal 4, Comment.search_by_type('Comment').size
-    assert_equal 2, @welcome.comments.search_by_type('Comment').size
+    assert_equal 4, Comment.search_by_type("Comment").size
+    assert_equal 2, @welcome.comments.search_by_type("Comment").size
   end
 
   def test_nested_scope_finder
-    Comment.where('1=0').scoping do
+    Comment.where("1=0").scoping do
       assert_equal 0, @welcome.comments.count
-      assert_equal 'a comment...', @welcome.comments.what_are_you
+      assert_equal "a comment...", @welcome.comments.what_are_you
     end
 
-    Comment.where('1=1').scoping do
+    Comment.where("1=1").scoping do
       assert_equal 2, @welcome.comments.count
-      assert_equal 'a comment...', @welcome.comments.what_are_you
+      assert_equal "a comment...", @welcome.comments.what_are_you
     end
   end
 
@@ -366,19 +366,19 @@ class HasAndBelongsToManyScopingTest < ActiveRecord::TestCase
   end
 
   def test_forwarding_of_static_methods
-    assert_equal 'a category...', Category.what_are_you
-    assert_equal 'a category...', @welcome.categories.what_are_you
+    assert_equal "a category...", Category.what_are_you
+    assert_equal "a category...", @welcome.categories.what_are_you
   end
 
   def test_nested_scope_finder
-    Category.where('1=0').scoping do
+    Category.where("1=0").scoping do
       assert_equal 0, @welcome.categories.count
-      assert_equal 'a category...', @welcome.categories.what_are_you
+      assert_equal "a category...", @welcome.categories.what_are_you
     end
 
-    Category.where('1=1').scoping do
+    Category.where("1=1").scoping do
       assert_equal 2, @welcome.categories.count
-      assert_equal 'a category...', @welcome.categories.what_are_you
+      assert_equal "a category...", @welcome.categories.what_are_you
     end
   end
 end