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.

280 files changed, 5678 insertions, 5678 deletions

diff --git a/activerecord/test/cases/adapter_test.rb b/activerecord/test/cases/adapter_test.rb
index 34e3bc9d66..a923358f63 100644
--- a/activerecord/test/cases/adapter_test.rb
+++ b/activerecord/test/cases/adapter_test.rb
@@ -100,31 +100,31 @@ module ActiveRecord
 
     def test_current_database
       if @connection.respond_to?(:current_database)
-        assert_equal ARTest.connection_config['arunit']['database'], @connection.current_database
+        assert_equal ARTest.connection_config["arunit"]["database"], @connection.current_database
       end
     end
 
     if current_adapter?(:Mysql2Adapter)
       def test_charset
         assert_not_nil @connection.charset
-        assert_not_equal 'character_set_database', @connection.charset
-        assert_equal @connection.show_variable('character_set_database'), @connection.charset
+        assert_not_equal "character_set_database", @connection.charset
+        assert_equal @connection.show_variable("character_set_database"), @connection.charset
       end
 
       def test_collation
         assert_not_nil @connection.collation
-        assert_not_equal 'collation_database', @connection.collation
-        assert_equal @connection.show_variable('collation_database'), @connection.collation
+        assert_not_equal "collation_database", @connection.collation
+        assert_equal @connection.show_variable("collation_database"), @connection.collation
       end
 
       def test_show_nonexistent_variable_returns_nil
-        assert_nil @connection.show_variable('foo_bar_baz')
+        assert_nil @connection.show_variable("foo_bar_baz")
       end
 
       def test_not_specifying_database_name_for_cross_database_selects
         begin
           assert_nothing_raised do
-            ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['arunit'].except(:database))
+            ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations["arunit"].except(:database))
 
             config = ARTest.connection_config
             ActiveRecord::Base.connection.execute(
@@ -145,9 +145,9 @@ module ActiveRecord
         alias_method :table_alias_length,     :test_table_alias_length
       end
 
-      assert_equal 'posts',      @connection.table_alias_for('posts')
-      assert_equal 'posts_comm', @connection.table_alias_for('posts_comments')
-      assert_equal 'dbo_posts',  @connection.table_alias_for('dbo.posts')
+      assert_equal "posts",      @connection.table_alias_for("posts")
+      assert_equal "posts_comm", @connection.table_alias_for("posts_comments")
+      assert_equal "dbo_posts",  @connection.table_alias_for("dbo.posts")
 
       class << @connection
         remove_method :table_alias_length
@@ -157,20 +157,20 @@ module ActiveRecord
 
     # test resetting sequences in odd tables in PostgreSQL
     if ActiveRecord::Base.connection.respond_to?(:reset_pk_sequence!)
-      require 'models/movie'
-      require 'models/subscriber'
+      require "models/movie"
+      require "models/subscriber"
 
       def test_reset_empty_table_with_custom_pk
         Movie.delete_all
-        Movie.connection.reset_pk_sequence! 'movies'
-        assert_equal 1, Movie.create(:name => 'fight club').id
+        Movie.connection.reset_pk_sequence! "movies"
+        assert_equal 1, Movie.create(:name => "fight club").id
       end
 
       def test_reset_table_with_non_integer_pk
         Subscriber.delete_all
-        Subscriber.connection.reset_pk_sequence! 'subscribers'
-        sub = Subscriber.new(:name => 'robert drake')
-        sub.id = 'bob drake'
+        Subscriber.connection.reset_pk_sequence! "subscribers"
+        sub = Subscriber.new(:name => "robert drake")
+        sub.id = "bob drake"
         assert_nothing_raised { sub.save! }
       end
     end
@@ -201,7 +201,7 @@ module ActiveRecord
 
       def test_foreign_key_violations_are_translated_to_specific_exception_with_validate_false
         klass_has_fk = Class.new(ActiveRecord::Base) do
-          self.table_name = 'fk_test_has_fk'
+          self.table_name = "fk_test_has_fk"
         end
 
         error = assert_raises(ActiveRecord::InvalidForeignKey) do
@@ -215,7 +215,7 @@ module ActiveRecord
 
       def test_value_limit_violations_are_translated_to_specific_exception
         error = assert_raises(ActiveRecord::ValueTooLong) do
-          Event.create(title: 'abcdefgh')
+          Event.create(title: "abcdefgh")
         end
 
         assert_not_nil error.cause
@@ -245,9 +245,9 @@ module ActiveRecord
     end
 
     def test_select_methods_passing_a_association_relation
-      author = Author.create!(name: 'john')
-      Post.create!(author: author, title: 'foo', body: 'bar')
-      query = author.posts.where(title: 'foo').select(:title)
+      author = Author.create!(name: "john")
+      Post.create!(author: author, title: "foo", body: "bar")
+      query = author.posts.where(title: "foo").select(:title)
       assert_equal({"title" => "foo"}, @connection.select_one(query.arel, nil, query.bound_attributes))
       assert_equal({"title" => "foo"}, @connection.select_one(query))
       assert @connection.select_all(query).is_a?(ActiveRecord::Result)
@@ -256,8 +256,8 @@ module ActiveRecord
     end
 
     def test_select_methods_passing_a_relation
-      Post.create!(title: 'foo', body: 'bar')
-      query = Post.where(title: 'foo').select(:title)
+      Post.create!(title: "foo", body: "bar")
+      query = Post.where(title: "foo").select(:title)
       assert_equal({"title" => "foo"}, @connection.select_one(query.arel, nil, query.bound_attributes))
       assert_equal({"title" => "foo"}, @connection.select_one(query))
       assert @connection.select_all(query).is_a?(ActiveRecord::Result)
@@ -273,7 +273,7 @@ module ActiveRecord
       def test_log_invalid_encoding
         error = assert_raise ActiveRecord::StatementInvalid do
           @connection.send :log, "SELECT 'ы' FROM DUAL" do
-            raise 'ы'.force_encoding(Encoding::ASCII_8BIT)
+            raise "ы".force_encoding(Encoding::ASCII_8BIT)
           end
         end
 
diff --git a/activerecord/test/cases/adapters/mysql2/active_schema_test.rb b/activerecord/test/cases/adapters/mysql2/active_schema_test.rb
index 95d1f6b8a3..429919a395 100644
--- a/activerecord/test/cases/adapters/mysql2/active_schema_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/active_schema_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'support/connection_helper'
+require "support/connection_helper"
 
 class Mysql2ActiveSchemaTest < ActiveRecord::Mysql2TestCase
   include ConnectionHelper
@@ -102,13 +102,13 @@ class Mysql2ActiveSchemaTest < ActiveRecord::Mysql2TestCase
 
   def test_create_mysql_database_with_encoding
     assert_equal "CREATE DATABASE `matt` DEFAULT CHARACTER SET `utf8`", create_database(:matt)
-    assert_equal "CREATE DATABASE `aimonetti` DEFAULT CHARACTER SET `latin1`", create_database(:aimonetti, {:charset => 'latin1'})
+    assert_equal "CREATE DATABASE `aimonetti` DEFAULT CHARACTER SET `latin1`", create_database(:aimonetti, {:charset => "latin1"})
     assert_equal "CREATE DATABASE `matt_aimonetti` DEFAULT CHARACTER SET `big5` COLLATE `big5_chinese_ci`", create_database(:matt_aimonetti, {:charset => :big5, :collation => :big5_chinese_ci})
   end
 
   def test_recreate_mysql_database_with_encoding
-    create_database(:luca, {:charset => 'latin1'})
-    assert_equal "CREATE DATABASE `luca` DEFAULT CHARACTER SET `latin1`", recreate_database(:luca, {:charset => 'latin1'})
+    create_database(:luca, {:charset => "latin1"})
+    assert_equal "CREATE DATABASE `luca` DEFAULT CHARACTER SET `latin1`", recreate_database(:luca, {:charset => "latin1"})
   end
 
   def test_add_column
@@ -120,7 +120,7 @@ class Mysql2ActiveSchemaTest < ActiveRecord::Mysql2TestCase
   end
 
   def test_drop_table_with_specific_database
-    assert_equal "DROP TABLE `otherdb`.`people`", drop_table('otherdb.people')
+    assert_equal "DROP TABLE `otherdb`.`people`", drop_table("otherdb.people")
   end
 
   def test_add_timestamps
@@ -128,8 +128,8 @@ class Mysql2ActiveSchemaTest < ActiveRecord::Mysql2TestCase
       begin
         ActiveRecord::Base.connection.create_table :delete_me
         ActiveRecord::Base.connection.add_timestamps :delete_me, null: true
-        assert column_present?('delete_me', 'updated_at', 'datetime')
-        assert column_present?('delete_me', 'created_at', 'datetime')
+        assert column_present?("delete_me", "updated_at", "datetime")
+        assert column_present?("delete_me", "created_at", "datetime")
       ensure
         ActiveRecord::Base.connection.drop_table :delete_me rescue nil
       end
@@ -143,8 +143,8 @@ class Mysql2ActiveSchemaTest < ActiveRecord::Mysql2TestCase
           t.timestamps null: true
         end
         ActiveRecord::Base.connection.remove_timestamps :delete_me, { null: true }
-        assert !column_present?('delete_me', 'updated_at', 'datetime')
-        assert !column_present?('delete_me', 'created_at', 'datetime')
+        assert !column_present?("delete_me", "updated_at", "datetime")
+        assert !column_present?("delete_me", "created_at", "datetime")
       ensure
         ActiveRecord::Base.connection.drop_table :delete_me rescue nil
       end
@@ -185,6 +185,6 @@ class Mysql2ActiveSchemaTest < ActiveRecord::Mysql2TestCase
 
     def column_present?(table_name, column_name, type)
       results = ActiveRecord::Base.connection.select_all("SHOW FIELDS FROM #{table_name} LIKE '#{column_name}'")
-      results.first && results.first['Type'] == type
+      results.first && results.first["Type"] == type
     end
 end
diff --git a/activerecord/test/cases/adapters/mysql2/bind_parameter_test.rb b/activerecord/test/cases/adapters/mysql2/bind_parameter_test.rb
index abdf3dbf5b..f75cea70a7 100644
--- a/activerecord/test/cases/adapters/mysql2/bind_parameter_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/bind_parameter_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'models/topic'
+require "models/topic"
 
 module ActiveRecord
   module ConnectionAdapters
diff --git a/activerecord/test/cases/adapters/mysql2/boolean_test.rb b/activerecord/test/cases/adapters/mysql2/boolean_test.rb
index 739bb275ce..2fa39282fb 100644
--- a/activerecord/test/cases/adapters/mysql2/boolean_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/boolean_test.rb
@@ -86,11 +86,11 @@ class Mysql2BooleanTest < ActiveRecord::Mysql2TestCase
   end
 
   def boolean_column
-    BooleanType.columns.find { |c| c.name == 'archived' }
+    BooleanType.columns.find { |c| c.name == "archived" }
   end
 
   def string_column
-    BooleanType.columns.find { |c| c.name == 'published' }
+    BooleanType.columns.find { |c| c.name == "published" }
   end
 
   def emulate_booleans(value)
diff --git a/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb b/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb
index 9cb05119a2..5f677626b0 100644
--- a/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb
@@ -7,19 +7,19 @@ class Mysql2CaseSensitivityTest < ActiveRecord::Mysql2TestCase
   repair_validations(CollationTest)
 
   def test_columns_include_collation_different_from_table
-    assert_equal 'utf8_bin', CollationTest.columns_hash['string_cs_column'].collation
-    assert_equal 'utf8_general_ci', CollationTest.columns_hash['string_ci_column'].collation
+    assert_equal "utf8_bin", CollationTest.columns_hash["string_cs_column"].collation
+    assert_equal "utf8_general_ci", CollationTest.columns_hash["string_ci_column"].collation
   end
 
   def test_case_sensitive
-    assert !CollationTest.columns_hash['string_ci_column'].case_sensitive?
-    assert CollationTest.columns_hash['string_cs_column'].case_sensitive?
+    assert !CollationTest.columns_hash["string_ci_column"].case_sensitive?
+    assert CollationTest.columns_hash["string_cs_column"].case_sensitive?
   end
 
   def test_case_insensitive_comparison_for_ci_column
     CollationTest.validates_uniqueness_of(:string_ci_column, :case_sensitive => false)
-    CollationTest.create!(:string_ci_column => 'A')
-    invalid = CollationTest.new(:string_ci_column => 'a')
+    CollationTest.create!(:string_ci_column => "A")
+    invalid = CollationTest.new(:string_ci_column => "a")
     queries = assert_sql { invalid.save }
     ci_uniqueness_query = queries.detect { |q| q.match(/string_ci_column/) }
     assert_no_match(/lower/i, ci_uniqueness_query)
@@ -27,8 +27,8 @@ class Mysql2CaseSensitivityTest < ActiveRecord::Mysql2TestCase
 
   def test_case_insensitive_comparison_for_cs_column
     CollationTest.validates_uniqueness_of(:string_cs_column, :case_sensitive => false)
-    CollationTest.create!(:string_cs_column => 'A')
-    invalid = CollationTest.new(:string_cs_column => 'a')
+    CollationTest.create!(:string_cs_column => "A")
+    invalid = CollationTest.new(:string_cs_column => "a")
     queries = assert_sql { invalid.save }
     cs_uniqueness_query = queries.detect { |q| q.match(/string_cs_column/)}
     assert_match(/lower/i, cs_uniqueness_query)
@@ -36,8 +36,8 @@ class Mysql2CaseSensitivityTest < ActiveRecord::Mysql2TestCase
 
   def test_case_sensitive_comparison_for_ci_column
     CollationTest.validates_uniqueness_of(:string_ci_column, :case_sensitive => true)
-    CollationTest.create!(:string_ci_column => 'A')
-    invalid = CollationTest.new(:string_ci_column => 'A')
+    CollationTest.create!(:string_ci_column => "A")
+    invalid = CollationTest.new(:string_ci_column => "A")
     queries = assert_sql { invalid.save }
     ci_uniqueness_query = queries.detect { |q| q.match(/string_ci_column/) }
     assert_match(/binary/i, ci_uniqueness_query)
@@ -45,8 +45,8 @@ class Mysql2CaseSensitivityTest < ActiveRecord::Mysql2TestCase
 
   def test_case_sensitive_comparison_for_cs_column
     CollationTest.validates_uniqueness_of(:string_cs_column, :case_sensitive => true)
-    CollationTest.create!(:string_cs_column => 'A')
-    invalid = CollationTest.new(:string_cs_column => 'A')
+    CollationTest.create!(:string_cs_column => "A")
+    invalid = CollationTest.new(:string_cs_column => "A")
     queries = assert_sql { invalid.save }
     cs_uniqueness_query = queries.detect { |q| q.match(/string_cs_column/) }
     assert_no_match(/binary/i, cs_uniqueness_query)
@@ -54,8 +54,8 @@ class Mysql2CaseSensitivityTest < ActiveRecord::Mysql2TestCase
 
   def test_case_sensitive_comparison_for_binary_column
     CollationTest.validates_uniqueness_of(:binary_column, case_sensitive: true)
-    CollationTest.create!(binary_column: 'A')
-    invalid = CollationTest.new(binary_column: 'A')
+    CollationTest.create!(binary_column: "A")
+    invalid = CollationTest.new(binary_column: "A")
     queries = assert_sql { invalid.save }
     bin_uniqueness_query = queries.detect { |q| q.match(/binary_column/) }
     assert_no_match(/\bBINARY\b/, bin_uniqueness_query)
diff --git a/activerecord/test/cases/adapters/mysql2/charset_collation_test.rb b/activerecord/test/cases/adapters/mysql2/charset_collation_test.rb
index c8028b6b36..8826ad7fd1 100644
--- a/activerecord/test/cases/adapters/mysql2/charset_collation_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/charset_collation_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 class Mysql2CharsetCollationTest < ActiveRecord::Mysql2TestCase
   include SchemaDumpingHelper
@@ -8,8 +8,8 @@ class Mysql2CharsetCollationTest < ActiveRecord::Mysql2TestCase
   setup do
     @connection = ActiveRecord::Base.connection
     @connection.create_table :charset_collations, force: true do |t|
-      t.string :string_ascii_bin, charset: 'ascii', collation: 'ascii_bin'
-      t.text :text_ucs2_unicode_ci, charset: 'ucs2', collation: 'ucs2_unicode_ci'
+      t.string :string_ascii_bin, charset: "ascii", collation: "ascii_bin"
+      t.text :text_ucs2_unicode_ci, charset: "ucs2", collation: "ucs2_unicode_ci"
     end
   end
 
@@ -18,32 +18,32 @@ class Mysql2CharsetCollationTest < ActiveRecord::Mysql2TestCase
   end
 
   test "string column with charset and collation" do
-    column = @connection.columns(:charset_collations).find { |c| c.name == 'string_ascii_bin' }
+    column = @connection.columns(:charset_collations).find { |c| c.name == "string_ascii_bin" }
     assert_equal :string, column.type
-    assert_equal 'ascii_bin', column.collation
+    assert_equal "ascii_bin", column.collation
   end
 
   test "text column with charset and collation" do
-    column = @connection.columns(:charset_collations).find { |c| c.name == 'text_ucs2_unicode_ci' }
+    column = @connection.columns(:charset_collations).find { |c| c.name == "text_ucs2_unicode_ci" }
     assert_equal :text, column.type
-    assert_equal 'ucs2_unicode_ci', column.collation
+    assert_equal "ucs2_unicode_ci", column.collation
   end
 
   test "add column with charset and collation" do
-    @connection.add_column :charset_collations, :title, :string, charset: 'utf8', collation: 'utf8_bin'
+    @connection.add_column :charset_collations, :title, :string, charset: "utf8", collation: "utf8_bin"
 
-    column = @connection.columns(:charset_collations).find { |c| c.name == 'title' }
+    column = @connection.columns(:charset_collations).find { |c| c.name == "title" }
     assert_equal :string, column.type
-    assert_equal 'utf8_bin', column.collation
+    assert_equal "utf8_bin", column.collation
   end
 
   test "change column with charset and collation" do
-    @connection.add_column :charset_collations, :description, :string, charset: 'utf8', collation: 'utf8_unicode_ci'
-    @connection.change_column :charset_collations, :description, :text, charset: 'utf8', collation: 'utf8_general_ci'
+    @connection.add_column :charset_collations, :description, :string, charset: "utf8", collation: "utf8_unicode_ci"
+    @connection.change_column :charset_collations, :description, :text, charset: "utf8", collation: "utf8_general_ci"
 
-    column = @connection.columns(:charset_collations).find { |c| c.name == 'description' }
+    column = @connection.columns(:charset_collations).find { |c| c.name == "description" }
     assert_equal :text, column.type
-    assert_equal 'utf8_general_ci', column.collation
+    assert_equal "utf8_general_ci", column.collation
   end
 
   test "schema dump includes collation" do
diff --git a/activerecord/test/cases/adapters/mysql2/connection_test.rb b/activerecord/test/cases/adapters/mysql2/connection_test.rb
index fe610ae951..3fb2b15783 100644
--- a/activerecord/test/cases/adapters/mysql2/connection_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/connection_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'support/connection_helper'
+require "support/connection_helper"
 
 class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
   include ConnectionHelper
@@ -9,7 +9,7 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
   def setup
     super
     @subscriber = SQLSubscriber.new
-    @subscription = ActiveSupport::Notifications.subscribe('sql.active_record', @subscriber)
+    @subscription = ActiveSupport::Notifications.subscribe("sql.active_record", @subscriber)
     @connection = ActiveRecord::Base.connection
   end
 
@@ -20,9 +20,9 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
 
   def test_bad_connection
     assert_raise ActiveRecord::NoDatabaseError do
-      configuration = ActiveRecord::Base.configurations['arunit'].merge(database: 'inexistent_activerecord_unittest')
+      configuration = ActiveRecord::Base.configurations["arunit"].merge(database: "inexistent_activerecord_unittest")
       connection = ActiveRecord::Base.mysql2_connection(configuration)
-      connection.drop_table 'ex', if_exists: true
+      connection.drop_table "ex", if_exists: true
     end
   end
 
@@ -39,7 +39,7 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
 
   def test_no_automatic_reconnection_after_timeout
     assert @connection.active?
-    @connection.update('set @@wait_timeout=1')
+    @connection.update("set @@wait_timeout=1")
     sleep 2
     assert !@connection.active?
 
@@ -49,7 +49,7 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
 
   def test_successful_reconnection_after_timeout_with_manual_reconnect
     assert @connection.active?
-    @connection.update('set @@wait_timeout=1')
+    @connection.update("set @@wait_timeout=1")
     sleep 2
     @connection.reconnect!
     assert @connection.active?
@@ -57,15 +57,15 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
 
   def test_successful_reconnection_after_timeout_with_verify
     assert @connection.active?
-    @connection.update('set @@wait_timeout=1')
+    @connection.update("set @@wait_timeout=1")
     sleep 2
     @connection.verify!
     assert @connection.active?
   end
 
   def test_mysql_connection_collation_is_configured
-    assert_equal 'utf8_unicode_ci', @connection.show_variable('collation_connection')
-    assert_equal 'utf8_general_ci', ARUnit2Model.connection.show_variable('collation_connection')
+    assert_equal "utf8_unicode_ci", @connection.show_variable("collation_connection")
+    assert_equal "utf8_general_ci", ARUnit2Model.connection.show_variable("collation_connection")
   end
 
   def test_mysql_default_in_strict_mode
@@ -92,8 +92,8 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
 
   def test_mysql_sql_mode_variable_overrides_strict_mode
     run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { 'sql_mode' => 'ansi' }))
-      result = ActiveRecord::Base.connection.select_value('SELECT @@SESSION.sql_mode')
+      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { "sql_mode" => "ansi" }))
+      result = ActiveRecord::Base.connection.select_value("SELECT @@SESSION.sql_mode")
       assert_no_match %r(STRICT_ALL_TABLES), result
     end
   end
@@ -107,7 +107,7 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
 
   def test_passing_flags_by_array_to_adapter
     run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.merge({flags: ['COMPRESS'] }))
+      ActiveRecord::Base.establish_connection(orig_connection.merge({flags: ["COMPRESS"] }))
       assert_equal ["COMPRESS", "FOUND_ROWS"], ActiveRecord::Base.connection.raw_connection.query_options[:flags]
     end
   end
@@ -130,14 +130,14 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
   end
 
   def test_logs_name_show_variable
-    @connection.show_variable 'foo'
+    @connection.show_variable "foo"
     assert_equal "SCHEMA", @subscriber.logged[0][1]
   end
 
   def test_logs_name_rename_column_sql
     @connection.execute "CREATE TABLE `bar_baz` (`foo` varchar(255))"
     @subscriber.logged.clear
-    @connection.send(:rename_column_sql, 'bar_baz', 'foo', 'foo2')
+    @connection.send(:rename_column_sql, "bar_baz", "foo", "foo2")
     assert_equal "SCHEMA", @subscriber.logged[0][1]
   ensure
     @connection.execute "DROP TABLE `bar_baz`"
@@ -155,14 +155,14 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
     released_lock = @connection.release_advisory_lock(lock_name)
     assert released_lock, "expected release_advisory_lock to return true but it didn't"
 
-    assert test_lock_free(lock_name), 'expected the test lock to be available after releasing'
+    assert test_lock_free(lock_name), "expected the test lock to be available after releasing"
   end
 
   def test_release_non_existent_advisory_lock
     lock_name = "fake lock'n'name"
     released_non_existent_lock = @connection.release_advisory_lock(lock_name)
     assert_equal released_non_existent_lock, false,
-      'expected release_advisory_lock to return false when there was no lock to release'
+      "expected release_advisory_lock to return false when there was no lock to release"
   end
 
   protected
diff --git a/activerecord/test/cases/adapters/mysql2/datetime_precision_quoting_test.rb b/activerecord/test/cases/adapters/mysql2/datetime_precision_quoting_test.rb
index e349c67c93..135789a57d 100644
--- a/activerecord/test/cases/adapters/mysql2/datetime_precision_quoting_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/datetime_precision_quoting_test.rb
@@ -5,23 +5,23 @@ class Mysql2DatetimePrecisionQuotingTest < ActiveRecord::Mysql2TestCase
     @connection = ActiveRecord::Base.connection
   end
 
-  test 'microsecond precision for MySQL gte 5.6.4' do
-    stub_version '5.6.4'
+  test "microsecond precision for MySQL gte 5.6.4" do
+    stub_version "5.6.4"
     assert_microsecond_precision
   end
 
-  test 'no microsecond precision for MySQL lt 5.6.4' do
-    stub_version '5.6.3'
+  test "no microsecond precision for MySQL lt 5.6.4" do
+    stub_version "5.6.3"
     assert_no_microsecond_precision
   end
 
-  test 'microsecond precision for MariaDB gte 5.3.0' do
-    stub_version '5.5.5-10.1.8-MariaDB-log'
+  test "microsecond precision for MariaDB gte 5.3.0" do
+    stub_version "5.5.5-10.1.8-MariaDB-log"
     assert_microsecond_precision
   end
 
-  test 'no microsecond precision for MariaDB lt 5.3.0' do
-    stub_version '5.2.9-MariaDB'
+  test "no microsecond precision for MariaDB lt 5.3.0" do
+    stub_version "5.2.9-MariaDB"
     assert_no_microsecond_precision
   end
 
diff --git a/activerecord/test/cases/adapters/mysql2/enum_test.rb b/activerecord/test/cases/adapters/mysql2/enum_test.rb
index 35dbc76d1b..9f51223d58 100644
--- a/activerecord/test/cases/adapters/mysql2/enum_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/enum_test.rb
@@ -5,22 +5,22 @@ class Mysql2EnumTest < ActiveRecord::Mysql2TestCase
   end
 
   def test_enum_limit
-    column = EnumTest.columns_hash['enum_column']
+    column = EnumTest.columns_hash["enum_column"]
     assert_equal 8, column.limit
   end
 
   def test_should_not_be_blob_or_text_column
-    column = EnumTest.columns_hash['enum_column']
+    column = EnumTest.columns_hash["enum_column"]
     assert_not column.blob_or_text_column?
   end
 
   def test_should_not_be_unsigned
-    column = EnumTest.columns_hash['enum_column']
+    column = EnumTest.columns_hash["enum_column"]
     assert_not column.unsigned?
   end
 
   def test_should_not_be_bigint
-    column = EnumTest.columns_hash['enum_column']
+    column = EnumTest.columns_hash["enum_column"]
     assert_not column.bigint?
   end
 end
diff --git a/activerecord/test/cases/adapters/mysql2/explain_test.rb b/activerecord/test/cases/adapters/mysql2/explain_test.rb
index b783b5fcd9..7916921e5a 100644
--- a/activerecord/test/cases/adapters/mysql2/explain_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/explain_test.rb
@@ -1,6 +1,6 @@
 require "cases/helper"
-require 'models/developer'
-require 'models/computer'
+require "models/developer"
+require "models/computer"
 
 class Mysql2ExplainTest < ActiveRecord::Mysql2TestCase
   fixtures :developers
diff --git a/activerecord/test/cases/adapters/mysql2/json_test.rb b/activerecord/test/cases/adapters/mysql2/json_test.rb
index 9c3fef1b59..87b6a07f65 100644
--- a/activerecord/test/cases/adapters/mysql2/json_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/json_test.rb
@@ -1,5 +1,5 @@
-require 'cases/helper'
-require 'support/schema_dumping_helper'
+require "cases/helper"
+require "support/schema_dumping_helper"
 
 if ActiveRecord::Base.connection.supports_json?
 class Mysql2JSONTest < ActiveRecord::Mysql2TestCase
@@ -7,7 +7,7 @@ class Mysql2JSONTest < ActiveRecord::Mysql2TestCase
   self.use_transactional_tests = false
 
   class JsonDataType < ActiveRecord::Base
-    self.table_name = 'json_data_type'
+    self.table_name = "json_data_type"
 
     store_accessor :settings, :resolution
   end
@@ -15,9 +15,9 @@ class Mysql2JSONTest < ActiveRecord::Mysql2TestCase
   def setup
     @connection = ActiveRecord::Base.connection
     begin
-      @connection.create_table('json_data_type') do |t|
-        t.json 'payload'
-        t.json 'settings'
+      @connection.create_table("json_data_type") do |t|
+        t.json "payload"
+        t.json "settings"
       end
     end
   end
@@ -30,18 +30,18 @@ class Mysql2JSONTest < ActiveRecord::Mysql2TestCase
   def test_column
     column = JsonDataType.columns_hash["payload"]
     assert_equal :json, column.type
-    assert_equal 'json', column.sql_type
+    assert_equal "json", column.sql_type
 
     type = JsonDataType.type_for_attribute("payload")
     assert_not type.binary?
   end
 
   def test_change_table_supports_json
-    @connection.change_table('json_data_type') do |t|
-      t.json 'users'
+    @connection.change_table("json_data_type") do |t|
+      t.json "users"
     end
     JsonDataType.reset_column_information
-    column = JsonDataType.columns_hash['users']
+    column = JsonDataType.columns_hash["users"]
     assert_equal :json, column.type
   end
 
@@ -63,31 +63,31 @@ class Mysql2JSONTest < ActiveRecord::Mysql2TestCase
 
     data = "{\"a_key\":\"a_value\"}"
     hash = type.deserialize(data)
-    assert_equal({'a_key' => 'a_value'}, hash)
-    assert_equal({'a_key' => 'a_value'}, type.deserialize(data))
+    assert_equal({"a_key" => "a_value"}, hash)
+    assert_equal({"a_key" => "a_value"}, type.deserialize(data))
 
     assert_equal({}, type.deserialize("{}"))
-    assert_equal({'key'=>nil}, type.deserialize('{"key": null}'))
-    assert_equal({'c'=>'}','"a"'=>'b "a b'}, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
+    assert_equal({"key"=>nil}, type.deserialize('{"key": null}'))
+    assert_equal({"c"=>"}",'"a"'=>'b "a b'}, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
   end
 
   def test_rewrite
     @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
     x = JsonDataType.first
-    x.payload = { '"a\'' => 'b' }
+    x.payload = { '"a\'' => "b" }
     assert x.save!
   end
 
   def test_select
     @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
     x = JsonDataType.first
-    assert_equal({'k' => 'v'}, x.payload)
+    assert_equal({"k" => "v"}, x.payload)
   end
 
   def test_select_multikey
     @connection.execute %q|insert into json_data_type (payload) VALUES ('{"k1":"v1", "k2":"v2", "k3":[1,2,3]}')|
     x = JsonDataType.first
-    assert_equal({'k1' => 'v1', 'k2' => 'v2', 'k3' => [1,2,3]}, x.payload)
+    assert_equal({"k1" => "v1", "k2" => "v2", "k3" => [1,2,3]}, x.payload)
   end
 
   def test_null_json
@@ -99,13 +99,13 @@ class Mysql2JSONTest < ActiveRecord::Mysql2TestCase
   def test_select_array_json_value
     @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
     x = JsonDataType.first
-    assert_equal(['v0', {'k1' => 'v1'}], x.payload)
+    assert_equal(["v0", {"k1" => "v1"}], x.payload)
   end
 
   def test_rewrite_array_json_value
     @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
     x = JsonDataType.first
-    x.payload = ['v1', {'k2' => 'v2'}, 'v3']
+    x.payload = ["v1", {"k2" => "v2"}, "v3"]
     assert x.save!
   end
 
@@ -144,20 +144,20 @@ class Mysql2JSONTest < ActiveRecord::Mysql2TestCase
     json = JsonDataType.new
     assert_not json.changed?
 
-    json.payload = { 'one' => 'two' }
+    json.payload = { "one" => "two" }
     assert json.changed?
     assert json.payload_changed?
 
     json.save!
     assert_not json.changed?
 
-    json.payload['three'] = 'four'
+    json.payload["three"] = "four"
     assert json.payload_changed?
 
     json.save!
     json.reload
 
-    assert_equal({ 'one' => 'two', 'three' => 'four' }, json.payload)
+    assert_equal({ "one" => "two", "three" => "four" }, json.payload)
     assert_not json.changed?
   end
 
diff --git a/activerecord/test/cases/adapters/mysql2/mysql2_adapter_test.rb b/activerecord/test/cases/adapters/mysql2/mysql2_adapter_test.rb
index 61dd0828d0..ac74b7f80f 100644
--- a/activerecord/test/cases/adapters/mysql2/mysql2_adapter_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/mysql2_adapter_test.rb
@@ -11,15 +11,15 @@ class Mysql2AdapterTest < ActiveRecord::Mysql2TestCase
   def test_exec_query_nothing_raises_with_no_result_queries
     assert_nothing_raised do
       with_example_table do
-        @conn.exec_query('INSERT INTO ex (number) VALUES (1)')
-        @conn.exec_query('DELETE FROM ex WHERE number = 1')
+        @conn.exec_query("INSERT INTO ex (number) VALUES (1)")
+        @conn.exec_query("DELETE FROM ex WHERE number = 1")
       end
     end
   end
 
   def test_valid_column
     with_example_table do
-      column = @conn.columns('ex').find { |col| col.name == 'id' }
+      column = @conn.columns("ex").find { |col| col.name == "id" }
       assert @conn.valid_type?(column.type)
     end
   end
@@ -45,8 +45,8 @@ class Mysql2AdapterTest < ActiveRecord::Mysql2TestCase
 
   def test_columns_for_distinct_with_case
     assert_equal(
-      'posts.id, CASE WHEN author.is_active THEN UPPER(author.name) ELSE UPPER(author.email) END AS alias_0',
-      @conn.columns_for_distinct('posts.id',
+      "posts.id, CASE WHEN author.is_active THEN UPPER(author.name) ELSE UPPER(author.email) END AS alias_0",
+      @conn.columns_for_distinct("posts.id",
         ["CASE WHEN author.is_active THEN UPPER(author.name) ELSE UPPER(author.email) END"])
     )
   end
@@ -67,7 +67,7 @@ class Mysql2AdapterTest < ActiveRecord::Mysql2TestCase
 
   private
 
-  def with_example_table(definition = 'id int auto_increment primary key, number int, data varchar(255)', &block)
-    super(@conn, 'ex', definition, &block)
+  def with_example_table(definition = "id int auto_increment primary key, number int, data varchar(255)", &block)
+    super(@conn, "ex", definition, &block)
   end
 end
diff --git a/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb b/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
index ffb4e2c5cf..28df7fab98 100644
--- a/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
@@ -4,22 +4,22 @@ require "cases/helper"
 # reserved word names (ie: group, order, values, etc...)
 class Mysql2ReservedWordTest < ActiveRecord::Mysql2TestCase
   class Group < ActiveRecord::Base
-    Group.table_name = 'group'
+    Group.table_name = "group"
     belongs_to :select
     has_one :values
   end
 
   class Select < ActiveRecord::Base
-    Select.table_name = 'select'
+    Select.table_name = "select"
     has_many :groups
   end
 
   class Values < ActiveRecord::Base
-    Values.table_name = 'values'
+    Values.table_name = "values"
   end
 
   class Distinct < ActiveRecord::Base
-    Distinct.table_name = 'distinct'
+    Distinct.table_name = "distinct"
     has_and_belongs_to_many :selects
     has_many :values, :through => :groups
   end
@@ -30,15 +30,15 @@ class Mysql2ReservedWordTest < ActiveRecord::Mysql2TestCase
     # we call execute directly here (and do similar below) because ActiveRecord::Base#create_table()
     # will fail with these table names if these test cases fail
 
-    create_tables_directly 'group'=>'id int auto_increment primary key, `order` varchar(255), select_id int',
-      'select'=>'id int auto_increment primary key',
-      'values'=>'id int auto_increment primary key, group_id int',
-      'distinct'=>'id int auto_increment primary key',
-      'distinct_select'=>'distinct_id int, select_id int'
+    create_tables_directly "group"=>"id int auto_increment primary key, `order` varchar(255), select_id int",
+      "select"=>"id int auto_increment primary key",
+      "values"=>"id int auto_increment primary key, group_id int",
+      "distinct"=>"id int auto_increment primary key",
+      "distinct_select"=>"distinct_id int, select_id int"
   end
 
   teardown do
-    drop_tables_directly ['group', 'select', 'values', 'distinct', 'distinct_select', 'order']
+    drop_tables_directly ["group", "select", "values", "distinct", "distinct_select", "order"]
   end
 
   # create tables with reserved-word names and columns
@@ -57,9 +57,9 @@ class Mysql2ReservedWordTest < ActiveRecord::Mysql2TestCase
 
   # alter column with a reserved-word name in a table with a reserved-word name
   def test_change_columns
-    assert_nothing_raised { @connection.change_column_default(:group, :order, 'whatever') }
+    assert_nothing_raised { @connection.change_column_default(:group, :order, "whatever") }
     #the quoting here will reveal any double quoting issues in change_column's interaction with the column method in the adapter
-    assert_nothing_raised { @connection.change_column('group', 'order', :Int, :default => 0) }
+    assert_nothing_raised { @connection.change_column("group", "order", :Int, :default => 0) }
     assert_nothing_raised { @connection.rename_column(:group, :order, :values) }
   end
 
@@ -78,11 +78,11 @@ class Mysql2ReservedWordTest < ActiveRecord::Mysql2TestCase
     create_test_fixtures :select, :distinct, :group, :values, :distinct_select
     x = nil
     assert_nothing_raised { x = Group.new }
-    x.order = 'x'
+    x.order = "x"
     assert_nothing_raised { x.save }
-    x.order = 'y'
+    x.order = "y"
     assert_nothing_raised { x.save }
-    assert_nothing_raised { Group.find_by_order('y') }
+    assert_nothing_raised { Group.find_by_order("y") }
     assert_nothing_raised { Group.find(1) }
   end
 
diff --git a/activerecord/test/cases/adapters/mysql2/schema_migrations_test.rb b/activerecord/test/cases/adapters/mysql2/schema_migrations_test.rb
index 7c89fda582..cdd8f06801 100644
--- a/activerecord/test/cases/adapters/mysql2/schema_migrations_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/schema_migrations_test.rb
@@ -18,7 +18,7 @@ class SchemaMigrationsTest < ActiveRecord::Mysql2TestCase
 
       connection.initialize_schema_migrations_table
 
-      assert connection.column_exists?(table_name, :version, :string, collation: 'utf8_general_ci')
+      assert connection.column_exists?(table_name, :version, :string, collation: "utf8_general_ci")
     end
   end
 
@@ -29,7 +29,7 @@ class SchemaMigrationsTest < ActiveRecord::Mysql2TestCase
 
       connection.initialize_internal_metadata_table
 
-      assert connection.column_exists?(table_name, :key, :string, collation: 'utf8_general_ci')
+      assert connection.column_exists?(table_name, :key, :string, collation: "utf8_general_ci")
     end
   end
 
diff --git a/activerecord/test/cases/adapters/mysql2/schema_test.rb b/activerecord/test/cases/adapters/mysql2/schema_test.rb
index 57ea8258d1..3c08a4ed1f 100644
--- a/activerecord/test/cases/adapters/mysql2/schema_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/schema_test.rb
@@ -1,6 +1,6 @@
 require "cases/helper"
-require 'models/post'
-require 'models/comment'
+require "models/post"
+require "models/comment"
 
 module ActiveRecord
   module ConnectionAdapters
@@ -16,7 +16,7 @@ module ActiveRecord
         @omgpost = Class.new(ActiveRecord::Base) do
           self.inheritance_column = :disabled
           self.table_name = "#{db}.#{table}"
-          def self.name; 'Post'; end
+          def self.name; "Post"; end
         end
       end
 
@@ -31,13 +31,13 @@ module ActiveRecord
           t.float :float_25, limit: 25
         end
 
-        column_no_limit = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_no_limit' }
-        column_short = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_short' }
-        column_long = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_long' }
+        column_no_limit = @connection.columns(:mysql_doubles).find { |c| c.name == "float_no_limit" }
+        column_short = @connection.columns(:mysql_doubles).find { |c| c.name == "float_short" }
+        column_long = @connection.columns(:mysql_doubles).find { |c| c.name == "float_long" }
 
-        column_23 = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_23' }
-        column_24 = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_24' }
-        column_25 = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_25' }
+        column_23 = @connection.columns(:mysql_doubles).find { |c| c.name == "float_23" }
+        column_24 = @connection.columns(:mysql_doubles).find { |c| c.name == "float_24" }
+        column_25 = @connection.columns(:mysql_doubles).find { |c| c.name == "float_25" }
 
         # Mysql floats are precision 0..24, Mysql doubles are precision 25..53
         assert_equal 24, column_no_limit.limit
@@ -56,7 +56,7 @@ module ActiveRecord
       end
 
       def test_primary_key
-        assert_equal 'id', @omgpost.primary_key
+        assert_equal "id", @omgpost.primary_key
       end
 
       def test_data_source_exists?
@@ -69,11 +69,11 @@ module ActiveRecord
       end
 
       def test_dump_indexes
-        index_a_name = 'index_key_tests_on_snack'
-        index_b_name = 'index_key_tests_on_pizza'
-        index_c_name = 'index_key_tests_on_awesome'
+        index_a_name = "index_key_tests_on_snack"
+        index_b_name = "index_key_tests_on_pizza"
+        index_c_name = "index_key_tests_on_awesome"
 
-        table = 'key_tests'
+        table = "key_tests"
 
         indexes = @connection.indexes(table).sort_by(&:name)
         assert_equal 3,indexes.size
diff --git a/activerecord/test/cases/adapters/mysql2/sp_test.rb b/activerecord/test/cases/adapters/mysql2/sp_test.rb
index 4197ba45f1..4182532535 100644
--- a/activerecord/test/cases/adapters/mysql2/sp_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/sp_test.rb
@@ -1,13 +1,13 @@
 require "cases/helper"
-require 'models/topic'
-require 'models/reply'
+require "models/topic"
+require "models/reply"
 
 class Mysql2StoredProcedureTest < ActiveRecord::Mysql2TestCase
   fixtures :topics
 
   def setup
     @connection = ActiveRecord::Base.connection
-    unless ActiveRecord::Base.connection.version >= '5.6.0'
+    unless ActiveRecord::Base.connection.version >= "5.6.0"
       skip("no stored procedure support")
     end
   end
@@ -17,19 +17,19 @@ class Mysql2StoredProcedureTest < ActiveRecord::Mysql2TestCase
   # In MySQL 5.6, CLIENT_MULTI_RESULTS is enabled by default.
   # http://dev.mysql.com/doc/refman/5.6/en/call.html
   def test_multi_results
-    rows = @connection.select_rows('CALL ten();')
+    rows = @connection.select_rows("CALL ten();")
     assert_equal 10, rows[0][0].to_i, "ten() did not return 10 as expected: #{rows.inspect}"
     assert @connection.active?, "Bad connection use by 'Mysql2Adapter.select_rows'"
   end
 
   def test_multi_results_from_select_one
-    row = @connection.select_one('CALL topics(1);')
-    assert_equal 'David', row['author_name']
+    row = @connection.select_one("CALL topics(1);")
+    assert_equal "David", row["author_name"]
     assert @connection.active?, "Bad connection use by 'Mysql2Adapter.select_one'"
   end
 
   def test_multi_results_from_find_by_sql
-    topics = Topic.find_by_sql 'CALL topics(3);'
+    topics = Topic.find_by_sql "CALL topics(3);"
     assert_equal 3, topics.size
     assert @connection.active?, "Bad connection use by 'Mysql2Adapter.select'"
   end
diff --git a/activerecord/test/cases/adapters/mysql2/sql_types_test.rb b/activerecord/test/cases/adapters/mysql2/sql_types_test.rb
index 4926bc2267..bee42d48f1 100644
--- a/activerecord/test/cases/adapters/mysql2/sql_types_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/sql_types_test.rb
@@ -2,10 +2,10 @@ require "cases/helper"
 
 class Mysql2SqlTypesTest < ActiveRecord::Mysql2TestCase
   def test_binary_types
-    assert_equal 'varbinary(64)', type_to_sql(:binary, 64)
-    assert_equal 'varbinary(4095)', type_to_sql(:binary, 4095)
-    assert_equal 'blob', type_to_sql(:binary, 4096)
-    assert_equal 'blob', type_to_sql(:binary)
+    assert_equal "varbinary(64)", type_to_sql(:binary, 64)
+    assert_equal "varbinary(4095)", type_to_sql(:binary, 4095)
+    assert_equal "blob", type_to_sql(:binary, 4096)
+    assert_equal "blob", type_to_sql(:binary)
   end
 
   def type_to_sql(*args)
diff --git a/activerecord/test/cases/adapters/mysql2/table_options_test.rb b/activerecord/test/cases/adapters/mysql2/table_options_test.rb
index af121ee7d9..61a8ce9bc0 100644
--- a/activerecord/test/cases/adapters/mysql2/table_options_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/table_options_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 class Mysql2TableOptionsTest < ActiveRecord::Mysql2TestCase
   include SchemaDumpingHelper
diff --git a/activerecord/test/cases/adapters/mysql2/transaction_test.rb b/activerecord/test/cases/adapters/mysql2/transaction_test.rb
index 5d8765d63a..edd5353ee3 100644
--- a/activerecord/test/cases/adapters/mysql2/transaction_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/transaction_test.rb
@@ -1,12 +1,12 @@
 require "cases/helper"
-require 'support/connection_helper'
+require "support/connection_helper"
 
 module ActiveRecord
   class Mysql2TransactionTest < ActiveRecord::Mysql2TestCase
     self.use_transactional_tests = false
 
     class Sample < ActiveRecord::Base
-      self.table_name = 'samples'
+      self.table_name = "samples"
     end
 
     setup do
@@ -14,9 +14,9 @@ module ActiveRecord
       @connection.clear_cache!
 
       @connection.transaction do
-        @connection.drop_table 'samples', if_exists: true
-        @connection.create_table('samples') do |t|
-          t.integer 'value'
+        @connection.drop_table "samples", if_exists: true
+        @connection.create_table("samples") do |t|
+          t.integer "value"
         end
       end
 
@@ -24,7 +24,7 @@ module ActiveRecord
     end
 
     teardown do
-      @connection.drop_table 'samples', if_exists: true
+      @connection.drop_table "samples", if_exists: true
     end
 
     test "raises Deadlocked when a deadlock is encountered" do
diff --git a/activerecord/test/cases/adapters/postgresql/active_schema_test.rb b/activerecord/test/cases/adapters/postgresql/active_schema_test.rb
index 439e2ce6f7..3d805bdbdc 100644
--- a/activerecord/test/cases/adapters/postgresql/active_schema_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/active_schema_test.rb
@@ -1,4 +1,4 @@
-require 'cases/helper'
+require "cases/helper"
 
 class PostgresqlActiveSchemaTest < ActiveRecord::PostgreSQLTestCase
   def setup
@@ -16,7 +16,7 @@ class PostgresqlActiveSchemaTest < ActiveRecord::PostgreSQLTestCase
   def test_create_database_with_encoding
     assert_equal %(CREATE DATABASE "matt" ENCODING = 'utf8'), create_database(:matt)
     assert_equal %(CREATE DATABASE "aimonetti" ENCODING = 'latin1'), create_database(:aimonetti, :encoding => :latin1)
-    assert_equal %(CREATE DATABASE "aimonetti" ENCODING = 'latin1'), create_database(:aimonetti, 'encoding' => :latin1)
+    assert_equal %(CREATE DATABASE "aimonetti" ENCODING = 'latin1'), create_database(:aimonetti, "encoding" => :latin1)
   end
 
   def test_create_database_with_collation_and_ctype
@@ -31,10 +31,10 @@ class PostgresqlActiveSchemaTest < ActiveRecord::PostgreSQLTestCase
     assert_equal expected, add_index(:people, :last_name, unique: true, where: "state = 'active'")
 
     expected = %(CREATE UNIQUE INDEX  "index_people_on_lower_last_name" ON "people"  (lower(last_name)))
-    assert_equal expected, add_index(:people, 'lower(last_name)', unique: true)
+    assert_equal expected, add_index(:people, "lower(last_name)", unique: true)
 
     expected = %(CREATE UNIQUE INDEX  "index_people_on_last_name_varchar_pattern_ops" ON "people"  (last_name varchar_pattern_ops))
-    assert_equal expected, add_index(:people, 'last_name varchar_pattern_ops', unique: true)
+    assert_equal expected, add_index(:people, "last_name varchar_pattern_ops", unique: true)
 
     expected = %(CREATE  INDEX CONCURRENTLY "index_people_on_last_name" ON "people"  ("last_name"))
     assert_equal expected, add_index(:people, :last_name, algorithm: :concurrently)
@@ -50,7 +50,7 @@ class PostgresqlActiveSchemaTest < ActiveRecord::PostgreSQLTestCase
       assert_equal expected, add_index(:people, :last_name, using: type, unique: true, where: "state = 'active'")
 
       expected = %(CREATE UNIQUE INDEX  "index_people_on_lower_last_name" ON "people" USING #{type} (lower(last_name)))
-      assert_equal expected, add_index(:people, 'lower(last_name)', using: type, unique: true)
+      assert_equal expected, add_index(:people, "lower(last_name)", using: type, unique: true)
     end
 
     assert_raise ArgumentError do
@@ -63,7 +63,7 @@ class PostgresqlActiveSchemaTest < ActiveRecord::PostgreSQLTestCase
   def test_remove_index
     # remove_index calls index_name_for_remove which can't work since execute is stubbed
     ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:define_method, :index_name_for_remove) do |*|
-      'index_people_on_last_name'
+      "index_people_on_last_name"
     end
 
     expected = %(DROP INDEX CONCURRENTLY "index_people_on_last_name")
diff --git a/activerecord/test/cases/adapters/postgresql/array_test.rb b/activerecord/test/cases/adapters/postgresql/array_test.rb
index 70792e937c..a26547b8f1 100644
--- a/activerecord/test/cases/adapters/postgresql/array_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/array_test.rb
@@ -1,35 +1,35 @@
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
   include InTimeZone
 
   class PgArray < ActiveRecord::Base
-    self.table_name = 'pg_arrays'
+    self.table_name = "pg_arrays"
   end
 
   def setup
     @connection = ActiveRecord::Base.connection
 
-    enable_extension!('hstore', @connection)
+    enable_extension!("hstore", @connection)
 
     @connection.transaction do
-      @connection.create_table('pg_arrays') do |t|
-        t.string 'tags', array: true
-        t.integer 'ratings', array: true
+      @connection.create_table("pg_arrays") do |t|
+        t.string "tags", array: true
+        t.integer "ratings", array: true
         t.datetime :datetimes, array: true
         t.hstore :hstores, array: true
       end
     end
     PgArray.reset_column_information
-    @column = PgArray.columns_hash['tags']
+    @column = PgArray.columns_hash["tags"]
     @type = PgArray.type_for_attribute("tags")
   end
 
   teardown do
-    @connection.drop_table 'pg_arrays', if_exists: true
-    disable_extension!('hstore', @connection)
+    @connection.drop_table "pg_arrays", if_exists: true
+    disable_extension!("hstore", @connection)
   end
 
   def test_column
@@ -38,26 +38,26 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
     assert @column.array?
     assert_not @type.binary?
 
-    ratings_column = PgArray.columns_hash['ratings']
+    ratings_column = PgArray.columns_hash["ratings"]
     assert_equal :integer, ratings_column.type
     assert ratings_column.array?
   end
 
   def test_default
-    @connection.add_column 'pg_arrays', 'score', :integer, array: true, default: [4, 4, 2]
+    @connection.add_column "pg_arrays", "score", :integer, array: true, default: [4, 4, 2]
     PgArray.reset_column_information
 
-    assert_equal([4, 4, 2], PgArray.column_defaults['score'])
+    assert_equal([4, 4, 2], PgArray.column_defaults["score"])
     assert_equal([4, 4, 2], PgArray.new.score)
   ensure
     PgArray.reset_column_information
   end
 
   def test_default_strings
-    @connection.add_column 'pg_arrays', 'names', :string, array: true, default: ["foo", "bar"]
+    @connection.add_column "pg_arrays", "names", :string, array: true, default: ["foo", "bar"]
     PgArray.reset_column_information
 
-    assert_equal(["foo", "bar"], PgArray.column_defaults['names'])
+    assert_equal(["foo", "bar"], PgArray.column_defaults["names"])
     assert_equal(["foo", "bar"], PgArray.new.names)
   ensure
     PgArray.reset_column_information
@@ -68,10 +68,10 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
     @connection.change_column :pg_arrays, :snippets, :text, array: true, default: []
 
     PgArray.reset_column_information
-    column = PgArray.columns_hash['snippets']
+    column = PgArray.columns_hash["snippets"]
 
     assert_equal :text, column.type
-    assert_equal [], PgArray.column_defaults['snippets']
+    assert_equal [], PgArray.column_defaults["snippets"]
     assert column.array?
   end
 
@@ -88,17 +88,17 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
     @connection.change_column_default :pg_arrays, :tags, []
 
     PgArray.reset_column_information
-    assert_equal [], PgArray.column_defaults['tags']
+    assert_equal [], PgArray.column_defaults["tags"]
   end
 
   def test_type_cast_array
-    assert_equal(['1', '2', '3'], @type.deserialize('{1,2,3}'))
-    assert_equal([], @type.deserialize('{}'))
-    assert_equal([nil], @type.deserialize('{NULL}'))
+    assert_equal(["1", "2", "3"], @type.deserialize("{1,2,3}"))
+    assert_equal([], @type.deserialize("{}"))
+    assert_equal([nil], @type.deserialize("{NULL}"))
   end
 
   def test_type_cast_integers
-    x = PgArray.new(ratings: ['1', '2'])
+    x = PgArray.new(ratings: ["1", "2"])
 
     assert_equal([1, 2], x.ratings)
 
@@ -117,15 +117,15 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
   def test_select_with_strings
     @connection.execute "insert into pg_arrays (tags) VALUES ('{1,2,3}')"
     x = PgArray.first
-    assert_equal(['1','2','3'], x.tags)
+    assert_equal(["1","2","3"], x.tags)
   end
 
   def test_rewrite_with_strings
     @connection.execute "insert into pg_arrays (tags) VALUES ('{1,2,3}')"
     x = PgArray.first
-    x.tags = ['1','2','3','4']
+    x.tags = ["1","2","3","4"]
     x.save!
-    assert_equal ['1','2','3','4'], x.reload.tags
+    assert_equal ["1","2","3","4"], x.reload.tags
   end
 
   def test_select_with_integers
@@ -137,25 +137,25 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
   def test_rewrite_with_integers
     @connection.execute "insert into pg_arrays (ratings) VALUES ('{1,2,3}')"
     x = PgArray.first
-    x.ratings = [2, '3', 4]
+    x.ratings = [2, "3", 4]
     x.save!
     assert_equal [2, 3, 4], x.reload.ratings
   end
 
   def test_multi_dimensional_with_strings
-    assert_cycle(:tags, [[['1'], ['2']], [['2'], ['3']]])
+    assert_cycle(:tags, [[["1"], ["2"]], [["2"], ["3"]]])
   end
 
   def test_with_empty_strings
-    assert_cycle(:tags, [ '1', '2', '', '4', '', '5' ])
+    assert_cycle(:tags, [ "1", "2", "", "4", "", "5" ])
   end
 
   def test_with_multi_dimensional_empty_strings
-    assert_cycle(:tags, [[['1', '2'], ['', '4'], ['', '5']]])
+    assert_cycle(:tags, [[["1", "2"], ["", "4"], ["", "5"]]])
   end
 
   def test_with_arbitrary_whitespace
-    assert_cycle(:tags, [[['1', '2'], ['    ', '4'], ['    ', '5']]])
+    assert_cycle(:tags, [[["1", "2"], ["    ", "4"], ["    ", "5"]]])
   end
 
   def test_multi_dimensional_with_integers
@@ -163,23 +163,23 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_strings_with_quotes
-    assert_cycle(:tags, ['this has','some "s that need to be escaped"'])
+    assert_cycle(:tags, ["this has",'some "s that need to be escaped"'])
   end
 
   def test_strings_with_commas
-    assert_cycle(:tags, ['this,has','many,values'])
+    assert_cycle(:tags, ["this,has","many,values"])
   end
 
   def test_strings_with_array_delimiters
-    assert_cycle(:tags, ['{','}'])
+    assert_cycle(:tags, ["{","}"])
   end
 
   def test_strings_with_null_strings
-    assert_cycle(:tags, ['NULL','NULL'])
+    assert_cycle(:tags, ["NULL","NULL"])
   end
 
   def test_contains_nils
-    assert_cycle(:tags, ['1',nil,nil])
+    assert_cycle(:tags, ["1",nil,nil])
   end
 
   def test_insert_fixture
@@ -211,14 +211,14 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
     x = PgArray.create!(tags: tags)
     x.reload
 
-    assert_equal x.tags_before_type_cast, PgArray.type_for_attribute('tags').serialize(tags)
+    assert_equal x.tags_before_type_cast, PgArray.type_for_attribute("tags").serialize(tags)
   end
 
   def test_quoting_non_standard_delimiters
     strings = ["hello,", "world;"]
     oid = ActiveRecord::ConnectionAdapters::PostgreSQL::OID
-    comma_delim = oid::Array.new(ActiveRecord::Type::String.new, ',')
-    semicolon_delim = oid::Array.new(ActiveRecord::Type::String.new, ';')
+    comma_delim = oid::Array.new(ActiveRecord::Type::String.new, ",")
+    semicolon_delim = oid::Array.new(ActiveRecord::Type::String.new, ";")
 
     assert_equal %({"hello,",world;}), comma_delim.serialize(strings)
     assert_equal %({hello,;"world;"}), semicolon_delim.serialize(strings)
@@ -236,13 +236,13 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_mutate_value_in_array
-    x = PgArray.create!(hstores: [{ a: 'a' }, { b: 'b' }])
+    x = PgArray.create!(hstores: [{ a: "a" }, { b: "b" }])
 
-    x.hstores.first['a'] = 'c'
+    x.hstores.first["a"] = "c"
     x.save!
     x.reload
 
-    assert_equal [{ 'a' => 'c' }, { 'b' => 'b' }], x.hstores
+    assert_equal [{ "a" => "c" }, { "b" => "b" }], x.hstores
     assert_not x.changed?
   end
 
diff --git a/activerecord/test/cases/adapters/postgresql/bit_string_test.rb b/activerecord/test/cases/adapters/postgresql/bit_string_test.rb
index cec6081aec..7f36a6b457 100644
--- a/activerecord/test/cases/adapters/postgresql/bit_string_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/bit_string_test.rb
@@ -1,6 +1,6 @@
 require "cases/helper"
-require 'support/connection_helper'
-require 'support/schema_dumping_helper'
+require "support/connection_helper"
+require "support/schema_dumping_helper"
 
 class PostgresqlBitStringTest < ActiveRecord::PostgreSQLTestCase
   include ConnectionHelper
@@ -10,7 +10,7 @@ class PostgresqlBitStringTest < ActiveRecord::PostgreSQLTestCase
 
   def setup
     @connection = ActiveRecord::Base.connection
-    @connection.create_table('postgresql_bit_strings', :force => true) do |t|
+    @connection.create_table("postgresql_bit_strings", :force => true) do |t|
       t.bit :a_bit, default: "00000011", limit: 8
       t.bit_varying :a_bit_varying, default: "0011", limit: 4
       t.bit :another_bit
@@ -20,7 +20,7 @@ class PostgresqlBitStringTest < ActiveRecord::PostgreSQLTestCase
 
   def teardown
     return unless @connection
-    @connection.drop_table 'postgresql_bit_strings', if_exists: true
+    @connection.drop_table "postgresql_bit_strings", if_exists: true
   end
 
   def test_bit_string_column
@@ -44,10 +44,10 @@ class PostgresqlBitStringTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_default
-    assert_equal "00000011", PostgresqlBitString.column_defaults['a_bit']
+    assert_equal "00000011", PostgresqlBitString.column_defaults["a_bit"]
     assert_equal "00000011", PostgresqlBitString.new.a_bit
 
-    assert_equal "0011", PostgresqlBitString.column_defaults['a_bit_varying']
+    assert_equal "0011", PostgresqlBitString.column_defaults["a_bit_varying"]
     assert_equal "0011", PostgresqlBitString.new.a_bit_varying
   end
 
diff --git a/activerecord/test/cases/adapters/postgresql/bytea_test.rb b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
index 7adc070430..dc0df8715a 100644
--- a/activerecord/test/cases/adapters/postgresql/bytea_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
@@ -1,29 +1,29 @@
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 class PostgresqlByteaTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
 
   class ByteaDataType < ActiveRecord::Base
-    self.table_name = 'bytea_data_type'
+    self.table_name = "bytea_data_type"
   end
 
   def setup
     @connection = ActiveRecord::Base.connection
     begin
       @connection.transaction do
-        @connection.create_table('bytea_data_type') do |t|
-          t.binary 'payload'
-          t.binary 'serialized'
+        @connection.create_table("bytea_data_type") do |t|
+          t.binary "payload"
+          t.binary "serialized"
         end
       end
     end
-    @column = ByteaDataType.columns_hash['payload']
+    @column = ByteaDataType.columns_hash["payload"]
     @type = ByteaDataType.type_for_attribute("payload")
   end
 
   teardown do
-    @connection.drop_table 'bytea_data_type', if_exists: true
+    @connection.drop_table "bytea_data_type", if_exists: true
   end
 
   def test_column
@@ -32,7 +32,7 @@ class PostgresqlByteaTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_binary_columns_are_limitless_the_upper_limit_is_one_GB
-    assert_equal 'bytea', @connection.type_to_sql(:binary, 100_000)
+    assert_equal "bytea", @connection.type_to_sql(:binary, 100_000)
     assert_raise ActiveRecord::ActiveRecordError do
       @connection.type_to_sql :binary, 4294967295
     end
@@ -42,8 +42,8 @@ class PostgresqlByteaTest < ActiveRecord::PostgreSQLTestCase
     assert @column
 
     data = "\u001F\x8B"
-    assert_equal('UTF-8', data.encoding.name)
-    assert_equal('ASCII-8BIT', @type.deserialize(data).encoding.name)
+    assert_equal("UTF-8", data.encoding.name)
+    assert_equal("ASCII-8BIT", @type.deserialize(data).encoding.name)
   end
 
   def test_type_cast_binary_value
@@ -88,14 +88,14 @@ class PostgresqlByteaTest < ActiveRecord::PostgreSQLTestCase
   def test_via_to_sql_with_complicating_connection
     Thread.new do
       other_conn = ActiveRecord::Base.connection
-      other_conn.execute('SET standard_conforming_strings = off')
+      other_conn.execute("SET standard_conforming_strings = off")
     end.join
 
     test_via_to_sql
   end
 
   def test_write_binary
-    data = File.read(File.join(File.dirname(__FILE__), '..', '..', '..', 'assets', 'example.log'))
+    data = File.read(File.join(File.dirname(__FILE__), "..", "..", "..", "assets", "example.log"))
     assert(data.size > 1)
     record = ByteaDataType.create(payload: data)
     assert_not record.new_record?
diff --git a/activerecord/test/cases/adapters/postgresql/change_schema_test.rb b/activerecord/test/cases/adapters/postgresql/change_schema_test.rb
index bc12df668d..ea642069d2 100644
--- a/activerecord/test/cases/adapters/postgresql/change_schema_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/change_schema_test.rb
@@ -1,4 +1,4 @@
-require 'cases/helper'
+require "cases/helper"
 
 module ActiveRecord
   class Migration
@@ -19,17 +19,17 @@ module ActiveRecord
 
       def test_change_string_to_date
         connection.change_column :strings, :somedate, :timestamp, using: 'CAST("somedate" AS timestamp)'
-        assert_equal :datetime, connection.columns(:strings).find { |c| c.name == 'somedate' }.type
+        assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
       end
 
       def test_change_type_with_symbol
         connection.change_column :strings, :somedate, :timestamp, cast_as: :timestamp
-        assert_equal :datetime, connection.columns(:strings).find { |c| c.name == 'somedate' }.type
+        assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
       end
 
       def test_change_type_with_array
         connection.change_column :strings, :somedate, :timestamp, array: true, cast_as: :timestamp
-        column = connection.columns(:strings).find { |c| c.name == 'somedate' }
+        column = connection.columns(:strings).find { |c| c.name == "somedate" }
         assert_equal :datetime, column.type
         assert column.array?
       end
diff --git a/activerecord/test/cases/adapters/postgresql/citext_test.rb b/activerecord/test/cases/adapters/postgresql/citext_test.rb
index bd62041e79..ca95e4b626 100644
--- a/activerecord/test/cases/adapters/postgresql/citext_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/citext_test.rb
@@ -1,49 +1,49 @@
-require 'cases/helper'
-require 'support/schema_dumping_helper'
+require "cases/helper"
+require "support/schema_dumping_helper"
 
 if ActiveRecord::Base.connection.supports_extensions?
   class PostgresqlCitextTest < ActiveRecord::PostgreSQLTestCase
     include SchemaDumpingHelper
     class Citext < ActiveRecord::Base
-      self.table_name = 'citexts'
+      self.table_name = "citexts"
     end
 
     def setup
       @connection = ActiveRecord::Base.connection
 
-      enable_extension!('citext', @connection)
+      enable_extension!("citext", @connection)
 
-      @connection.create_table('citexts') do |t|
-        t.citext 'cival'
+      @connection.create_table("citexts") do |t|
+        t.citext "cival"
       end
     end
 
     teardown do
-      @connection.drop_table 'citexts', if_exists: true
-      disable_extension!('citext', @connection)
+      @connection.drop_table "citexts", if_exists: true
+      disable_extension!("citext", @connection)
     end
 
     def test_citext_enabled
-      assert @connection.extension_enabled?('citext')
+      assert @connection.extension_enabled?("citext")
     end
 
     def test_column
-      column = Citext.columns_hash['cival']
+      column = Citext.columns_hash["cival"]
       assert_equal :citext, column.type
-      assert_equal 'citext', column.sql_type
+      assert_equal "citext", column.sql_type
       assert_not column.array?
 
-      type = Citext.type_for_attribute('cival')
+      type = Citext.type_for_attribute("cival")
       assert_not type.binary?
     end
 
     def test_change_table_supports_json
       @connection.transaction do
-        @connection.change_table('citexts') do |t|
-          t.citext 'username'
+        @connection.change_table("citexts") do |t|
+          t.citext "username"
         end
         Citext.reset_column_information
-        column = Citext.columns_hash['username']
+        column = Citext.columns_hash["username"]
         assert_equal :citext, column.type
 
         raise ActiveRecord::Rollback # reset the schema change
@@ -53,7 +53,7 @@ if ActiveRecord::Base.connection.supports_extensions?
     end
 
     def test_write
-      x = Citext.new(cival: 'Some CI Text')
+      x = Citext.new(cival: "Some CI Text")
       x.save!
       citext = Citext.first
       assert_equal "Some CI Text", citext.cival
@@ -66,8 +66,8 @@ if ActiveRecord::Base.connection.supports_extensions?
 
     def test_select_case_insensitive
       @connection.execute "insert into citexts (cival) values('Cased Text')"
-      x = Citext.where(cival: 'cased text').first
-      assert_equal 'Cased Text', x.cival
+      x = Citext.where(cival: "cased text").first
+      assert_equal "Cased Text", x.cival
     end
 
     def test_schema_dump_with_shorthand
diff --git a/activerecord/test/cases/adapters/postgresql/collation_test.rb b/activerecord/test/cases/adapters/postgresql/collation_test.rb
index 8470329c35..b39e298a5d 100644
--- a/activerecord/test/cases/adapters/postgresql/collation_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/collation_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 class PostgresqlCollationTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
@@ -7,8 +7,8 @@ class PostgresqlCollationTest < ActiveRecord::PostgreSQLTestCase
   def setup
     @connection = ActiveRecord::Base.connection
     @connection.create_table :postgresql_collations, force: true do |t|
-      t.string :string_c, collation: 'C'
-      t.text :text_posix, collation: 'POSIX'
+      t.string :string_c, collation: "C"
+      t.text :text_posix, collation: "POSIX"
     end
   end
 
@@ -17,32 +17,32 @@ class PostgresqlCollationTest < ActiveRecord::PostgreSQLTestCase
   end
 
   test "string column with collation" do
-    column = @connection.columns(:postgresql_collations).find { |c| c.name == 'string_c' }
+    column = @connection.columns(:postgresql_collations).find { |c| c.name == "string_c" }
     assert_equal :string, column.type
-    assert_equal 'C', column.collation
+    assert_equal "C", column.collation
   end
 
   test "text column with collation" do
-    column = @connection.columns(:postgresql_collations).find { |c| c.name == 'text_posix' }
+    column = @connection.columns(:postgresql_collations).find { |c| c.name == "text_posix" }
     assert_equal :text, column.type
-    assert_equal 'POSIX', column.collation
+    assert_equal "POSIX", column.collation
   end
 
   test "add column with collation" do
-    @connection.add_column :postgresql_collations, :title, :string, collation: 'C'
+    @connection.add_column :postgresql_collations, :title, :string, collation: "C"
 
-    column = @connection.columns(:postgresql_collations).find { |c| c.name == 'title' }
+    column = @connection.columns(:postgresql_collations).find { |c| c.name == "title" }
     assert_equal :string, column.type
-    assert_equal 'C', column.collation
+    assert_equal "C", column.collation
   end
 
   test "change column with collation" do
     @connection.add_column :postgresql_collations, :description, :string
-    @connection.change_column :postgresql_collations, :description, :text, collation: 'POSIX'
+    @connection.change_column :postgresql_collations, :description, :text, collation: "POSIX"
 
-    column = @connection.columns(:postgresql_collations).find { |c| c.name == 'description' }
+    column = @connection.columns(:postgresql_collations).find { |c| c.name == "description" }
     assert_equal :text, column.type
-    assert_equal 'POSIX', column.collation
+    assert_equal "POSIX", column.collation
   end
 
   test "schema dump includes collation" do
diff --git a/activerecord/test/cases/adapters/postgresql/composite_test.rb b/activerecord/test/cases/adapters/postgresql/composite_test.rb
index 1de87e5f01..9377837810 100644
--- a/activerecord/test/cases/adapters/postgresql/composite_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/composite_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'support/connection_helper'
+require "support/connection_helper"
 
 module PostgresqlCompositeBehavior
   include ConnectionHelper
@@ -20,7 +20,7 @@ module PostgresqlCompositeBehavior
              street VARCHAR(90)
          );
         SQL
-      @connection.create_table('postgresql_composites') do |t|
+      @connection.create_table("postgresql_composites") do |t|
         t.column :address, :full_address
       end
     end
@@ -29,8 +29,8 @@ module PostgresqlCompositeBehavior
   def teardown
     super
 
-    @connection.drop_table 'postgresql_composites', if_exists: true
-    @connection.execute 'DROP TYPE IF EXISTS full_address'
+    @connection.drop_table "postgresql_composites", if_exists: true
+    @connection.execute "DROP TYPE IF EXISTS full_address"
     reset_connection
     PostgresqlComposite.reset_column_information
   end
@@ -126,7 +126,7 @@ class PostgresqlCompositeWithCustomOIDTest < ActiveRecord::PostgreSQLTestCase
     composite.address = FullAddress.new("Paris", "Rue Basse")
     composite.save!
 
-    assert_equal 'Paris', composite.reload.address.city
-    assert_equal 'Rue Basse', composite.reload.address.street
+    assert_equal "Paris", composite.reload.address.city
+    assert_equal "Rue Basse", composite.reload.address.street
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/connection_test.rb b/activerecord/test/cases/adapters/postgresql/connection_test.rb
index f8403bfe1a..436ab3ffa1 100644
--- a/activerecord/test/cases/adapters/postgresql/connection_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/connection_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'support/connection_helper'
+require "support/connection_helper"
 
 module ActiveRecord
   class PostgresqlConnectionTest < ActiveRecord::PostgreSQLTestCase
@@ -13,7 +13,7 @@ module ActiveRecord
     def setup
       super
       @subscriber = SQLSubscriber.new
-      @subscription = ActiveSupport::Notifications.subscribe('sql.active_record', @subscriber)
+      @subscription = ActiveSupport::Notifications.subscribe("sql.active_record", @subscriber)
       @connection = ActiveRecord::Base.connection
     end
 
@@ -23,10 +23,10 @@ module ActiveRecord
     end
 
     def test_truncate
-      count = ActiveRecord::Base.connection.execute("select count(*) from comments").first['count'].to_i
+      count = ActiveRecord::Base.connection.execute("select count(*) from comments").first["count"].to_i
       assert_operator count, :>, 0
       ActiveRecord::Base.connection.truncate("comments")
-      count = ActiveRecord::Base.connection.execute("select count(*) from comments").first['count'].to_i
+      count = ActiveRecord::Base.connection.execute("select count(*) from comments").first["count"].to_i
       assert_equal 0, count
     end
 
@@ -54,85 +54,85 @@ module ActiveRecord
       NonExistentTable.establish_connection(params)
 
       # Verify the connection param has been applied.
-      expect = NonExistentTable.connection.query('show geqo').first.first
-      assert_equal 'off', expect
+      expect = NonExistentTable.connection.query("show geqo").first.first
+      assert_equal "off", expect
     end
 
     def test_reset
-      @connection.query('ROLLBACK')
-      @connection.query('SET geqo TO off')
+      @connection.query("ROLLBACK")
+      @connection.query("SET geqo TO off")
 
       # Verify the setting has been applied.
-      expect = @connection.query('show geqo').first.first
-      assert_equal 'off', expect
+      expect = @connection.query("show geqo").first.first
+      assert_equal "off", expect
 
       @connection.reset!
 
       # Verify the setting has been cleared.
-      expect = @connection.query('show geqo').first.first
-      assert_equal 'on', expect
+      expect = @connection.query("show geqo").first.first
+      assert_equal "on", expect
     end
 
     def test_reset_with_transaction
-      @connection.query('ROLLBACK')
-      @connection.query('SET geqo TO off')
+      @connection.query("ROLLBACK")
+      @connection.query("SET geqo TO off")
 
       # Verify the setting has been applied.
-      expect = @connection.query('show geqo').first.first
-      assert_equal 'off', expect
+      expect = @connection.query("show geqo").first.first
+      assert_equal "off", expect
 
-      @connection.query('BEGIN')
+      @connection.query("BEGIN")
       @connection.reset!
 
       # Verify the setting has been cleared.
-      expect = @connection.query('show geqo').first.first
-      assert_equal 'on', expect
+      expect = @connection.query("show geqo").first.first
+      assert_equal "on", expect
     end
 
     def test_tables_logs_name
-      ActiveSupport::Deprecation.silence { @connection.tables('hello') }
-      assert_equal 'SCHEMA', @subscriber.logged[0][1]
+      ActiveSupport::Deprecation.silence { @connection.tables("hello") }
+      assert_equal "SCHEMA", @subscriber.logged[0][1]
     end
 
     def test_indexes_logs_name
-      @connection.indexes('items', 'hello')
-      assert_equal 'SCHEMA', @subscriber.logged[0][1]
+      @connection.indexes("items", "hello")
+      assert_equal "SCHEMA", @subscriber.logged[0][1]
     end
 
     def test_table_exists_logs_name
-      ActiveSupport::Deprecation.silence { @connection.table_exists?('items') }
-      assert_equal 'SCHEMA', @subscriber.logged[0][1]
+      ActiveSupport::Deprecation.silence { @connection.table_exists?("items") }
+      assert_equal "SCHEMA", @subscriber.logged[0][1]
     end
 
     def test_table_alias_length_logs_name
       @connection.instance_variable_set("@table_alias_length", nil)
       @connection.table_alias_length
-      assert_equal 'SCHEMA', @subscriber.logged[0][1]
+      assert_equal "SCHEMA", @subscriber.logged[0][1]
     end
 
     def test_current_database_logs_name
       @connection.current_database
-      assert_equal 'SCHEMA', @subscriber.logged[0][1]
+      assert_equal "SCHEMA", @subscriber.logged[0][1]
     end
 
     def test_encoding_logs_name
       @connection.encoding
-      assert_equal 'SCHEMA', @subscriber.logged[0][1]
+      assert_equal "SCHEMA", @subscriber.logged[0][1]
     end
 
     def test_schema_names_logs_name
       @connection.schema_names
-      assert_equal 'SCHEMA', @subscriber.logged[0][1]
+      assert_equal "SCHEMA", @subscriber.logged[0][1]
     end
 
     if ActiveRecord::Base.connection.prepared_statements
       def test_statement_key_is_logged
         bind = Relation::QueryAttribute.new(nil, 1, Type::Value.new)
-        @connection.exec_query('SELECT $1::integer', 'SQL', [bind], prepare: true)
+        @connection.exec_query("SELECT $1::integer", "SQL", [bind], prepare: true)
         name = @subscriber.payloads.last[:statement_name]
         assert name
         res = @connection.exec_query("EXPLAIN (FORMAT JSON) EXECUTE #{name}(1)")
-        plan = res.column_types['QUERY PLAN'].deserialize res.rows.first.first
+        plan = res.column_types["QUERY PLAN"].deserialize res.rows.first.first
         assert_operator plan.length, :>, 0
       end
     end
@@ -146,7 +146,7 @@ module ActiveRecord
     # To restart PostgreSQL 9.1 on OS X, installed via MacPorts, ...
     # sudo su postgres -c "pg_ctl restart -D /opt/local/var/db/postgresql91/defaultdb/ -m fast"
     def test_reconnection_after_actual_disconnection_with_verify
-      original_connection_pid = @connection.query('select pg_backend_pid()')
+      original_connection_pid = @connection.query("select pg_backend_pid()")
 
       # Sanity check.
       assert @connection.active?
@@ -155,8 +155,8 @@ module ActiveRecord
         secondary_connection = ActiveRecord::Base.connection_pool.checkout
         secondary_connection.query("select pg_terminate_backend(#{original_connection_pid.first.first})")
         ActiveRecord::Base.connection_pool.checkin(secondary_connection)
-      elsif ARTest.config['with_manual_interventions']
-        puts 'Kill the connection now (e.g. by restarting the PostgreSQL ' +
+      elsif ARTest.config["with_manual_interventions"]
+        puts "Kill the connection now (e.g. by restarting the PostgreSQL " +
           'server with the "-m fast" option) and then press enter.'
         $stdin.gets
       else
@@ -172,7 +172,7 @@ module ActiveRecord
 
       # If we get no exception here, then either we re-connected successfully, or
       # we never actually got disconnected.
-      new_connection_pid = @connection.query('select pg_backend_pid()')
+      new_connection_pid = @connection.query("select pg_backend_pid()")
 
       assert_not_equal original_connection_pid, new_connection_pid,
         "umm -- looks like you didn't break the connection, because we're still " +
@@ -241,7 +241,7 @@ module ActiveRecord
       with_warning_suppression do
         released_non_existent_lock = @connection.release_advisory_lock(fake_lock_id)
         assert_equal released_non_existent_lock, false,
-          'expected release_advisory_lock to return false when there was no lock to release'
+          "expected release_advisory_lock to return false when there was no lock to release"
       end
     end
 
@@ -249,7 +249,7 @@ module ActiveRecord
 
     def with_warning_suppression
       log_level = @connection.client_min_messages
-      @connection.client_min_messages = 'error'
+      @connection.client_min_messages = "error"
       yield
       @connection.client_min_messages = log_level
     end
diff --git a/activerecord/test/cases/adapters/postgresql/datatype_test.rb b/activerecord/test/cases/adapters/postgresql/datatype_test.rb
index 232c25cb3b..aa077b59a0 100644
--- a/activerecord/test/cases/adapters/postgresql/datatype_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/datatype_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'support/ddl_helper'
+require "support/ddl_helper"
 
 
 class PostgresqlTime < ActiveRecord::Base
@@ -38,8 +38,8 @@ class PostgresqlDataTypeTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_time_values
-    assert_equal '-1 years -2 days', @first_time.time_interval
-    assert_equal '-21 days', @first_time.scaled_time_interval
+    assert_equal "-1 years -2 days", @first_time.time_interval
+    assert_equal "-21 days", @first_time.scaled_time_interval
   end
 
   def test_oid_values
@@ -47,10 +47,10 @@ class PostgresqlDataTypeTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_update_time
-    @first_time.time_interval = '2 years 3 minutes'
+    @first_time.time_interval = "2 years 3 minutes"
     assert @first_time.save
     assert @first_time.reload
-    assert_equal '2 years 00:03:00', @first_time.time_interval
+    assert_equal "2 years 00:03:00", @first_time.time_interval
   end
 
   def test_update_oid
@@ -62,7 +62,7 @@ class PostgresqlDataTypeTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_text_columns_are_limitless_the_upper_limit_is_one_GB
-    assert_equal 'text', @connection.type_to_sql(:text, 100_000)
+    assert_equal "text", @connection.type_to_sql(:text, 100_000)
     assert_raise ActiveRecord::ActiveRecordError do
       @connection.type_to_sql :text, 4294967295
     end
@@ -77,15 +77,15 @@ class PostgresqlInternalDataTypeTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_name_column_type
-    with_example_table @connection, 'ex', 'data name' do
-      column = @connection.columns('ex').find { |col| col.name == 'data' }
+    with_example_table @connection, "ex", "data name" do
+      column = @connection.columns("ex").find { |col| col.name == "data" }
       assert_equal :string, column.type
     end
   end
 
   def test_char_column_type
-    with_example_table @connection, 'ex', 'data "char"' do
-      column = @connection.columns('ex').find { |col| col.name == 'data' }
+    with_example_table @connection, "ex", 'data "char"' do
+      column = @connection.columns("ex").find { |col| col.name == "data" }
       assert_equal :string, column.type
     end
   end
diff --git a/activerecord/test/cases/adapters/postgresql/domain_test.rb b/activerecord/test/cases/adapters/postgresql/domain_test.rb
index 6102ddacd1..f1eb8adb15 100644
--- a/activerecord/test/cases/adapters/postgresql/domain_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/domain_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'support/connection_helper'
+require "support/connection_helper"
 
 class PostgresqlDomainTest < ActiveRecord::PostgreSQLTestCase
   include ConnectionHelper
@@ -12,15 +12,15 @@ class PostgresqlDomainTest < ActiveRecord::PostgreSQLTestCase
     @connection = ActiveRecord::Base.connection
     @connection.transaction do
       @connection.execute "CREATE DOMAIN custom_money as numeric(8,2)"
-      @connection.create_table('postgresql_domains') do |t|
+      @connection.create_table("postgresql_domains") do |t|
         t.column :price, :custom_money
       end
     end
   end
 
   teardown do
-    @connection.drop_table 'postgresql_domains', if_exists: true
-    @connection.execute 'DROP DOMAIN IF EXISTS custom_money'
+    @connection.drop_table "postgresql_domains", if_exists: true
+    @connection.execute "DROP DOMAIN IF EXISTS custom_money"
     reset_connection
   end
 
diff --git a/activerecord/test/cases/adapters/postgresql/enum_test.rb b/activerecord/test/cases/adapters/postgresql/enum_test.rb
index 6816a6514b..5e5a3158ba 100644
--- a/activerecord/test/cases/adapters/postgresql/enum_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/enum_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'support/connection_helper'
+require "support/connection_helper"
 
 class PostgresqlEnumTest < ActiveRecord::PostgreSQLTestCase
   include ConnectionHelper
@@ -14,15 +14,15 @@ class PostgresqlEnumTest < ActiveRecord::PostgreSQLTestCase
       @connection.execute <<-SQL
         CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy');
       SQL
-      @connection.create_table('postgresql_enums') do |t|
+      @connection.create_table("postgresql_enums") do |t|
         t.column :current_mood, :mood
       end
     end
   end
 
   teardown do
-    @connection.drop_table 'postgresql_enums', if_exists: true
-    @connection.execute 'DROP TYPE IF EXISTS mood'
+    @connection.drop_table "postgresql_enums", if_exists: true
+    @connection.execute "DROP TYPE IF EXISTS mood"
     reset_connection
   end
 
@@ -37,10 +37,10 @@ class PostgresqlEnumTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_enum_defaults
-    @connection.add_column 'postgresql_enums', 'good_mood', :mood, default: 'happy'
+    @connection.add_column "postgresql_enums", "good_mood", :mood, default: "happy"
     PostgresqlEnum.reset_column_information
 
-    assert_equal "happy", PostgresqlEnum.column_defaults['good_mood']
+    assert_equal "happy", PostgresqlEnum.column_defaults["good_mood"]
     assert_equal "happy", PostgresqlEnum.new.good_mood
   ensure
     PostgresqlEnum.reset_column_information
diff --git a/activerecord/test/cases/adapters/postgresql/explain_test.rb b/activerecord/test/cases/adapters/postgresql/explain_test.rb
index b00f8f5706..7493bce4fb 100644
--- a/activerecord/test/cases/adapters/postgresql/explain_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/explain_test.rb
@@ -1,6 +1,6 @@
 require "cases/helper"
-require 'models/developer'
-require 'models/computer'
+require "models/developer"
+require "models/computer"
 
 class PostgreSQLExplainTest < ActiveRecord::PostgreSQLTestCase
   fixtures :developers
diff --git a/activerecord/test/cases/adapters/postgresql/full_text_test.rb b/activerecord/test/cases/adapters/postgresql/full_text_test.rb
index bde7513339..5ddfe32007 100644
--- a/activerecord/test/cases/adapters/postgresql/full_text_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/full_text_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 class PostgresqlFullTextTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
@@ -7,13 +7,13 @@ class PostgresqlFullTextTest < ActiveRecord::PostgreSQLTestCase
 
   setup do
     @connection = ActiveRecord::Base.connection
-    @connection.create_table('tsvectors') do |t|
-      t.tsvector 'text_vector'
+    @connection.create_table("tsvectors") do |t|
+      t.tsvector "text_vector"
     end
   end
 
   teardown do
-    @connection.drop_table 'tsvectors', if_exists: true
+    @connection.drop_table "tsvectors", if_exists: true
   end
 
   def test_tsvector_column
diff --git a/activerecord/test/cases/adapters/postgresql/geometric_test.rb b/activerecord/test/cases/adapters/postgresql/geometric_test.rb
index 66f0a70394..1b7d0cf4f0 100644
--- a/activerecord/test/cases/adapters/postgresql/geometric_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/geometric_test.rb
@@ -1,6 +1,6 @@
 require "cases/helper"
-require 'support/connection_helper'
-require 'support/schema_dumping_helper'
+require "support/connection_helper"
+require "support/schema_dumping_helper"
 
 class PostgresqlPointTest < ActiveRecord::PostgreSQLTestCase
   include ConnectionHelper
@@ -18,7 +18,7 @@ class PostgresqlPointTest < ActiveRecord::PostgreSQLTestCase
 
   def setup
     @connection = ActiveRecord::Base.connection
-    @connection.create_table('postgresql_points') do |t|
+    @connection.create_table("postgresql_points") do |t|
       t.point :x
       t.point :y, default: [12.2, 13.3]
       t.point :z, default: "(14.4,15.5)"
@@ -27,14 +27,14 @@ class PostgresqlPointTest < ActiveRecord::PostgreSQLTestCase
       t.point :legacy_y, default: [12.2, 13.3]
       t.point :legacy_z, default: "(14.4,15.5)"
     end
-    @connection.create_table('deprecated_points') do |t|
+    @connection.create_table("deprecated_points") do |t|
       t.point :x
     end
   end
 
   teardown do
-    @connection.drop_table 'postgresql_points', if_exists: true
-    @connection.drop_table 'deprecated_points', if_exists: true
+    @connection.drop_table "postgresql_points", if_exists: true
+    @connection.drop_table "deprecated_points", if_exists: true
   end
 
   class DeprecatedPoint < ActiveRecord::Base; end
@@ -56,10 +56,10 @@ class PostgresqlPointTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_default
-    assert_equal ActiveRecord::Point.new(12.2, 13.3), PostgresqlPoint.column_defaults['y']
+    assert_equal ActiveRecord::Point.new(12.2, 13.3), PostgresqlPoint.column_defaults["y"]
     assert_equal ActiveRecord::Point.new(12.2, 13.3), PostgresqlPoint.new.y
 
-    assert_equal ActiveRecord::Point.new(14.4, 15.5), PostgresqlPoint.column_defaults['z']
+    assert_equal ActiveRecord::Point.new(14.4, 15.5), PostgresqlPoint.column_defaults["z"]
     assert_equal ActiveRecord::Point.new(14.4, 15.5), PostgresqlPoint.new.z
   end
 
@@ -136,10 +136,10 @@ class PostgresqlPointTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_legacy_default
-    assert_equal [12.2, 13.3], PostgresqlPoint.column_defaults['legacy_y']
+    assert_equal [12.2, 13.3], PostgresqlPoint.column_defaults["legacy_y"]
     assert_equal [12.2, 13.3], PostgresqlPoint.new.legacy_y
 
-    assert_equal [14.4, 15.5], PostgresqlPoint.column_defaults['legacy_z']
+    assert_equal [14.4, 15.5], PostgresqlPoint.column_defaults["legacy_z"]
     assert_equal [14.4, 15.5], PostgresqlPoint.new.legacy_z
   end
 
@@ -190,51 +190,51 @@ class PostgresqlGeometricTest < ActiveRecord::PostgreSQLTestCase
   end
 
   teardown do
-    @connection.drop_table 'postgresql_geometrics', if_exists: true
+    @connection.drop_table "postgresql_geometrics", if_exists: true
   end
 
   def test_geometric_types
     g = PostgresqlGeometric.new(
-      :a_line_segment => '(2.0, 3), (5.5, 7.0)',
-      :a_box          => '2.0, 3, 5.5, 7.0',
-      :a_path         => '[(2.0, 3), (5.5, 7.0), (8.5, 11.0)]',
-      :a_polygon      => '((2.0, 3), (5.5, 7.0), (8.5, 11.0))',
-      :a_circle       => '<(5.3, 10.4), 2>'
+      :a_line_segment => "(2.0, 3), (5.5, 7.0)",
+      :a_box          => "2.0, 3, 5.5, 7.0",
+      :a_path         => "[(2.0, 3), (5.5, 7.0), (8.5, 11.0)]",
+      :a_polygon      => "((2.0, 3), (5.5, 7.0), (8.5, 11.0))",
+      :a_circle       => "<(5.3, 10.4), 2>"
     )
 
     g.save!
 
     h = PostgresqlGeometric.find(g.id)
 
-    assert_equal '[(2,3),(5.5,7)]', h.a_line_segment
-    assert_equal '(5.5,7),(2,3)', h.a_box # reordered to store upper right corner then bottom left corner
-    assert_equal '[(2,3),(5.5,7),(8.5,11)]', h.a_path
-    assert_equal '((2,3),(5.5,7),(8.5,11))', h.a_polygon
-    assert_equal '<(5.3,10.4),2>', h.a_circle
+    assert_equal "[(2,3),(5.5,7)]", h.a_line_segment
+    assert_equal "(5.5,7),(2,3)", h.a_box # reordered to store upper right corner then bottom left corner
+    assert_equal "[(2,3),(5.5,7),(8.5,11)]", h.a_path
+    assert_equal "((2,3),(5.5,7),(8.5,11))", h.a_polygon
+    assert_equal "<(5.3,10.4),2>", h.a_circle
   end
 
   def test_alternative_format
     g = PostgresqlGeometric.new(
-      :a_line_segment => '((2.0, 3), (5.5, 7.0))',
-      :a_box          => '(2.0, 3), (5.5, 7.0)',
-      :a_path         => '((2.0, 3), (5.5, 7.0), (8.5, 11.0))',
-      :a_polygon      => '2.0, 3, 5.5, 7.0, 8.5, 11.0',
-      :a_circle       => '((5.3, 10.4), 2)'
+      :a_line_segment => "((2.0, 3), (5.5, 7.0))",
+      :a_box          => "(2.0, 3), (5.5, 7.0)",
+      :a_path         => "((2.0, 3), (5.5, 7.0), (8.5, 11.0))",
+      :a_polygon      => "2.0, 3, 5.5, 7.0, 8.5, 11.0",
+      :a_circle       => "((5.3, 10.4), 2)"
     )
 
     g.save!
 
     h = PostgresqlGeometric.find(g.id)
-    assert_equal '[(2,3),(5.5,7)]', h.a_line_segment
-    assert_equal '(5.5,7),(2,3)', h.a_box   # reordered to store upper right corner then bottom left corner
-    assert_equal '((2,3),(5.5,7),(8.5,11))', h.a_path
-    assert_equal '((2,3),(5.5,7),(8.5,11))', h.a_polygon
-    assert_equal '<(5.3,10.4),2>', h.a_circle
+    assert_equal "[(2,3),(5.5,7)]", h.a_line_segment
+    assert_equal "(5.5,7),(2,3)", h.a_box   # reordered to store upper right corner then bottom left corner
+    assert_equal "((2,3),(5.5,7),(8.5,11))", h.a_path
+    assert_equal "((2,3),(5.5,7),(8.5,11))", h.a_polygon
+    assert_equal "<(5.3,10.4),2>", h.a_circle
   end
 
   def test_geometric_function
-    PostgresqlGeometric.create! a_path: '[(2.0, 3), (5.5, 7.0), (8.5, 11.0)]'  # [ ] is an open path
-    PostgresqlGeometric.create! a_path: '((2.0, 3), (5.5, 7.0), (8.5, 11.0))'  # ( ) is a closed path
+    PostgresqlGeometric.create! a_path: "[(2.0, 3), (5.5, 7.0), (8.5, 11.0)]"  # [ ] is an open path
+    PostgresqlGeometric.create! a_path: "((2.0, 3), (5.5, 7.0), (8.5, 11.0))"  # ( ) is a closed path
 
     objs = PostgresqlGeometric.find_by_sql "SELECT isopen(a_path) FROM postgresql_geometrics ORDER BY id ASC"
     assert_equal [true, false], objs.map(&:isopen)
@@ -270,28 +270,28 @@ class PostgreSQLGeometricLineTest < ActiveRecord::PostgreSQLTestCase
 
   teardown do
     if defined?(@connection)
-      @connection.drop_table 'postgresql_lines', if_exists: true
+      @connection.drop_table "postgresql_lines", if_exists: true
     end
   end
 
   def test_geometric_line_type
     g = PostgresqlLine.new(
-      a_line: '{2.0, 3, 5.5}'
+      a_line: "{2.0, 3, 5.5}"
     )
     g.save!
 
     h = PostgresqlLine.find(g.id)
-    assert_equal '{2,3,5.5}', h.a_line
+    assert_equal "{2,3,5.5}", h.a_line
   end
 
   def test_alternative_format_line_type
     g = PostgresqlLine.new(
-      a_line: '(2.0, 3), (4.0, 6.0)'
+      a_line: "(2.0, 3), (4.0, 6.0)"
     )
     g.save!
 
     h = PostgresqlLine.find(g.id)
-    assert_equal '{1.5,-1,0}', h.a_line
+    assert_equal "{1.5,-1,0}", h.a_line
   end
 
   def test_schema_dumping_for_line_type
diff --git a/activerecord/test/cases/adapters/postgresql/hstore_test.rb b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
index 27cc65a643..b31aba39d9 100644
--- a/activerecord/test/cases/adapters/postgresql/hstore_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
@@ -1,11 +1,11 @@
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 if ActiveRecord::Base.connection.supports_extensions?
   class PostgresqlHstoreTest < ActiveRecord::PostgreSQLTestCase
     include SchemaDumpingHelper
     class Hstore < ActiveRecord::Base
-      self.table_name = 'hstores'
+      self.table_name = "hstores"
 
       store_accessor :settings, :language, :timezone
     end
@@ -13,40 +13,40 @@ if ActiveRecord::Base.connection.supports_extensions?
     def setup
       @connection = ActiveRecord::Base.connection
 
-      unless @connection.extension_enabled?('hstore')
-        @connection.enable_extension 'hstore'
+      unless @connection.extension_enabled?("hstore")
+        @connection.enable_extension "hstore"
         @connection.commit_db_transaction
       end
 
       @connection.reconnect!
 
       @connection.transaction do
-        @connection.create_table('hstores') do |t|
-          t.hstore 'tags', :default => ''
-          t.hstore 'payload', array: true
-          t.hstore 'settings'
+        @connection.create_table("hstores") do |t|
+          t.hstore "tags", :default => ""
+          t.hstore "payload", array: true
+          t.hstore "settings"
         end
       end
       Hstore.reset_column_information
-      @column = Hstore.columns_hash['tags']
+      @column = Hstore.columns_hash["tags"]
       @type = Hstore.type_for_attribute("tags")
     end
 
     teardown do
-      @connection.drop_table 'hstores', if_exists: true
+      @connection.drop_table "hstores", if_exists: true
     end
 
     def test_hstore_included_in_extensions
       assert @connection.respond_to?(:extensions), "connection should have a list of extensions"
-      assert @connection.extensions.include?('hstore'), "extension list should include hstore"
+      assert @connection.extensions.include?("hstore"), "extension list should include hstore"
     end
 
     def test_disable_enable_hstore
-      assert @connection.extension_enabled?('hstore')
-      @connection.disable_extension 'hstore'
-      assert_not @connection.extension_enabled?('hstore')
-      @connection.enable_extension 'hstore'
-      assert @connection.extension_enabled?('hstore')
+      assert @connection.extension_enabled?("hstore")
+      @connection.disable_extension "hstore"
+      assert_not @connection.extension_enabled?("hstore")
+      @connection.enable_extension "hstore"
+      assert @connection.extension_enabled?("hstore")
     ensure
       # Restore column(s) dropped by `drop extension hstore cascade;`
       load_schema
@@ -61,10 +61,10 @@ if ActiveRecord::Base.connection.supports_extensions?
     end
 
     def test_default
-      @connection.add_column 'hstores', 'permissions', :hstore, default: '"users"=>"read", "articles"=>"write"'
+      @connection.add_column "hstores", "permissions", :hstore, default: '"users"=>"read", "articles"=>"write"'
       Hstore.reset_column_information
 
-      assert_equal({"users"=>"read", "articles"=>"write"}, Hstore.column_defaults['permissions'])
+      assert_equal({"users"=>"read", "articles"=>"write"}, Hstore.column_defaults["permissions"])
       assert_equal({"users"=>"read", "articles"=>"write"}, Hstore.new.permissions)
     ensure
       Hstore.reset_column_information
@@ -72,11 +72,11 @@ if ActiveRecord::Base.connection.supports_extensions?
 
     def test_change_table_supports_hstore
       @connection.transaction do
-        @connection.change_table('hstores') do |t|
-          t.hstore 'users', default: ''
+        @connection.change_table("hstores") do |t|
+          t.hstore "users", default: ""
         end
         Hstore.reset_column_information
-        column = Hstore.columns_hash['users']
+        column = Hstore.columns_hash["users"]
         assert_equal :hstore, column.type
 
         raise ActiveRecord::Rollback # reset the schema change
@@ -111,10 +111,10 @@ if ActiveRecord::Base.connection.supports_extensions?
     end
 
     def test_type_cast_hstore
-      assert_equal({'1' => '2'}, @type.deserialize("\"1\"=>\"2\""))
+      assert_equal({"1" => "2"}, @type.deserialize("\"1\"=>\"2\""))
       assert_equal({}, @type.deserialize(""))
-      assert_equal({'key'=>nil}, @type.deserialize('key => NULL'))
-      assert_equal({'c'=>'}','"a"'=>'b "a b'}, @type.deserialize(%q(c=>"}", "\"a\""=>"b \"a b")))
+      assert_equal({"key"=>nil}, @type.deserialize("key => NULL"))
+      assert_equal({"c"=>"}",'"a"'=>'b "a b'}, @type.deserialize(%q(c=>"}", "\"a\""=>"b \"a b")))
     end
 
     def test_with_store_accessors
@@ -156,33 +156,33 @@ if ActiveRecord::Base.connection.supports_extensions?
     end
 
     def test_changes_in_place
-      hstore = Hstore.create!(settings: { 'one' => 'two' })
-      hstore.settings['three'] = 'four'
+      hstore = Hstore.create!(settings: { "one" => "two" })
+      hstore.settings["three"] = "four"
       hstore.save!
       hstore.reload
 
-      assert_equal 'four', hstore.settings['three']
+      assert_equal "four", hstore.settings["three"]
       assert_not hstore.changed?
     end
 
     def test_gen1
-      assert_equal(%q(" "=>""), @type.serialize({' '=>''}))
+      assert_equal(%q(" "=>""), @type.serialize({" "=>""}))
     end
 
     def test_gen2
-      assert_equal(%q(","=>""), @type.serialize({','=>''}))
+      assert_equal(%q(","=>""), @type.serialize({","=>""}))
     end
 
     def test_gen3
-      assert_equal(%q("="=>""), @type.serialize({'='=>''}))
+      assert_equal(%q("="=>""), @type.serialize({"="=>""}))
     end
 
     def test_gen4
-      assert_equal(%q(">"=>""), @type.serialize({'>'=>''}))
+      assert_equal(%q(">"=>""), @type.serialize({">"=>""}))
     end
 
     def test_parse1
-      assert_equal({'a'=>nil,'b'=>nil,'c'=>'NuLl','null'=>'c'}, @type.deserialize('a=>null,b=>NuLl,c=>"NuLl",null=>c'))
+      assert_equal({"a"=>nil,"b"=>nil,"c"=>"NuLl","null"=>"c"}, @type.deserialize('a=>null,b=>NuLl,c=>"NuLl",null=>c'))
     end
 
     def test_parse2
@@ -212,14 +212,14 @@ if ActiveRecord::Base.connection.supports_extensions?
     def test_rewrite
       @connection.execute "insert into hstores (tags) VALUES ('1=>2')"
       x = Hstore.first
-      x.tags = { '"a\'' => 'b' }
+      x.tags = { '"a\'' => "b" }
       assert x.save!
     end
 
     def test_select
       @connection.execute "insert into hstores (tags) VALUES ('1=>2')"
       x = Hstore.first
-      assert_equal({'1' => '2'}, x.tags)
+      assert_equal({"1" => "2"}, x.tags)
     end
 
     def test_array_cycle
@@ -227,61 +227,61 @@ if ActiveRecord::Base.connection.supports_extensions?
     end
 
     def test_array_strings_with_quotes
-      assert_array_cycle([{'this has' => 'some "s that need to be escaped"'}])
+      assert_array_cycle([{"this has" => 'some "s that need to be escaped"'}])
     end
 
     def test_array_strings_with_commas
-      assert_array_cycle([{'this,has' => 'many,values'}])
+      assert_array_cycle([{"this,has" => "many,values"}])
     end
 
     def test_array_strings_with_array_delimiters
-      assert_array_cycle(['{' => '}'])
+      assert_array_cycle(["{" => "}"])
     end
 
     def test_array_strings_with_null_strings
-      assert_array_cycle([{'NULL' => 'NULL'}])
+      assert_array_cycle([{"NULL" => "NULL"}])
     end
 
     def test_contains_nils
-      assert_array_cycle([{'NULL' => nil}])
+      assert_array_cycle([{"NULL" => nil}])
     end
 
     def test_select_multikey
       @connection.execute "insert into hstores (tags) VALUES ('1=>2,2=>3')"
       x = Hstore.first
-      assert_equal({'1' => '2', '2' => '3'}, x.tags)
+      assert_equal({"1" => "2", "2" => "3"}, x.tags)
     end
 
     def test_create
-      assert_cycle('a' => 'b', '1' => '2')
+      assert_cycle("a" => "b", "1" => "2")
     end
 
     def test_nil
-      assert_cycle('a' => nil)
+      assert_cycle("a" => nil)
     end
 
     def test_quotes
-      assert_cycle('a' => 'b"ar', '1"foo' => '2')
+      assert_cycle("a" => 'b"ar', '1"foo' => "2")
     end
 
     def test_whitespace
-      assert_cycle('a b' => 'b ar', '1"foo' => '2')
+      assert_cycle("a b" => "b ar", '1"foo' => "2")
     end
 
     def test_backslash
-      assert_cycle('a\\b' => 'b\\ar', '1"foo' => '2')
+      assert_cycle('a\\b' => 'b\\ar', '1"foo' => "2")
     end
 
     def test_comma
-      assert_cycle('a, b' => 'bar', '1"foo' => '2')
+      assert_cycle("a, b" => "bar", '1"foo' => "2")
     end
 
     def test_arrow
-      assert_cycle('a=>b' => 'bar', '1"foo' => '2')
+      assert_cycle("a=>b" => "bar", '1"foo' => "2")
     end
 
     def test_quoting_special_characters
-      assert_cycle('ca' => 'cà', 'ac' => 'àc')
+      assert_cycle("ca" => "cà", "ac" => "àc")
     end
 
     def test_multiline
diff --git a/activerecord/test/cases/adapters/postgresql/infinity_test.rb b/activerecord/test/cases/adapters/postgresql/infinity_test.rb
index bfda933fa4..19b00258b6 100644
--- a/activerecord/test/cases/adapters/postgresql/infinity_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/infinity_test.rb
@@ -15,7 +15,7 @@ class PostgresqlInfinityTest < ActiveRecord::PostgreSQLTestCase
   end
 
   teardown do
-    @connection.drop_table 'postgresql_infinities', if_exists: true
+    @connection.drop_table "postgresql_infinities", if_exists: true
   end
 
   test "type casting infinity on a float column" do
@@ -25,11 +25,11 @@ class PostgresqlInfinityTest < ActiveRecord::PostgreSQLTestCase
   end
 
   test "type casting string on a float column" do
-    record = PostgresqlInfinity.new(float: 'Infinity')
+    record = PostgresqlInfinity.new(float: "Infinity")
     assert_equal Float::INFINITY, record.float
-    record = PostgresqlInfinity.new(float: '-Infinity')
+    record = PostgresqlInfinity.new(float: "-Infinity")
     assert_equal(-Float::INFINITY, record.float)
-    record = PostgresqlInfinity.new(float: 'NaN')
+    record = PostgresqlInfinity.new(float: "NaN")
     assert_send [record.float, :nan?]
   end
 
diff --git a/activerecord/test/cases/adapters/postgresql/json_test.rb b/activerecord/test/cases/adapters/postgresql/json_test.rb
index 663de680b5..8b5a5f1bab 100644
--- a/activerecord/test/cases/adapters/postgresql/json_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/json_test.rb
@@ -1,11 +1,11 @@
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 module PostgresqlJSONSharedTestCases
   include SchemaDumpingHelper
 
   class JsonDataType < ActiveRecord::Base
-    self.table_name = 'json_data_type'
+    self.table_name = "json_data_type"
 
     store_accessor :settings, :resolution
   end
@@ -13,9 +13,9 @@ module PostgresqlJSONSharedTestCases
   def setup
     @connection = ActiveRecord::Base.connection
     begin
-      @connection.create_table('json_data_type') do |t|
-        t.public_send column_type, 'payload', default: {} # t.json 'payload', default: {}
-        t.public_send column_type, 'settings'             # t.json 'settings'
+      @connection.create_table("json_data_type") do |t|
+        t.public_send column_type, "payload", default: {} # t.json 'payload', default: {}
+        t.public_send column_type, "settings"             # t.json 'settings'
       end
     rescue ActiveRecord::StatementInvalid
       skip "do not test on PostgreSQL without #{column_type} type."
@@ -38,10 +38,10 @@ module PostgresqlJSONSharedTestCases
   end
 
   def test_default
-    @connection.add_column 'json_data_type', 'permissions', column_type, default: {"users": "read", "posts": ["read", "write"]}
+    @connection.add_column "json_data_type", "permissions", column_type, default: {"users": "read", "posts": ["read", "write"]}
     JsonDataType.reset_column_information
 
-    assert_equal({"users"=>"read", "posts"=>["read", "write"]}, JsonDataType.column_defaults['permissions'])
+    assert_equal({"users"=>"read", "posts"=>["read", "write"]}, JsonDataType.column_defaults["permissions"])
     assert_equal({"users"=>"read", "posts"=>["read", "write"]}, JsonDataType.new.permissions)
   ensure
     JsonDataType.reset_column_information
@@ -49,11 +49,11 @@ module PostgresqlJSONSharedTestCases
 
   def test_change_table_supports_json
     @connection.transaction do
-      @connection.change_table('json_data_type') do |t|
-        t.public_send column_type, 'users', default: '{}' # t.json 'users', default: '{}'
+      @connection.change_table("json_data_type") do |t|
+        t.public_send column_type, "users", default: "{}" # t.json 'users', default: '{}'
       end
       JsonDataType.reset_column_information
-      column = JsonDataType.columns_hash['users']
+      column = JsonDataType.columns_hash["users"]
       assert_equal column_type, column.type
 
       raise ActiveRecord::Rollback # reset the schema change
@@ -80,31 +80,31 @@ module PostgresqlJSONSharedTestCases
 
     data = "{\"a_key\":\"a_value\"}"
     hash = type.deserialize(data)
-    assert_equal({'a_key' => 'a_value'}, hash)
-    assert_equal({'a_key' => 'a_value'}, type.deserialize(data))
+    assert_equal({"a_key" => "a_value"}, hash)
+    assert_equal({"a_key" => "a_value"}, type.deserialize(data))
 
     assert_equal({}, type.deserialize("{}"))
-    assert_equal({'key'=>nil}, type.deserialize('{"key": null}'))
-    assert_equal({'c'=>'}','"a"'=>'b "a b'}, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
+    assert_equal({"key"=>nil}, type.deserialize('{"key": null}'))
+    assert_equal({"c"=>"}",'"a"'=>'b "a b'}, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
   end
 
   def test_rewrite
     @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
     x = JsonDataType.first
-    x.payload = { '"a\'' => 'b' }
+    x.payload = { '"a\'' => "b" }
     assert x.save!
   end
 
   def test_select
     @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
     x = JsonDataType.first
-    assert_equal({'k' => 'v'}, x.payload)
+    assert_equal({"k" => "v"}, x.payload)
   end
 
   def test_select_multikey
     @connection.execute %q|insert into json_data_type (payload) VALUES ('{"k1":"v1", "k2":"v2", "k3":[1,2,3]}')|
     x = JsonDataType.first
-    assert_equal({'k1' => 'v1', 'k2' => 'v2', 'k3' => [1,2,3]}, x.payload)
+    assert_equal({"k1" => "v1", "k2" => "v2", "k3" => [1,2,3]}, x.payload)
   end
 
   def test_null_json
@@ -116,13 +116,13 @@ module PostgresqlJSONSharedTestCases
   def test_select_array_json_value
     @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
     x = JsonDataType.first
-    assert_equal(['v0', {'k1' => 'v1'}], x.payload)
+    assert_equal(["v0", {"k1" => "v1"}], x.payload)
   end
 
   def test_rewrite_array_json_value
     @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
     x = JsonDataType.first
-    x.payload = ['v1', {'k2' => 'v2'}, 'v3']
+    x.payload = ["v1", {"k2" => "v2"}, "v3"]
     assert x.save!
   end
 
@@ -161,20 +161,20 @@ module PostgresqlJSONSharedTestCases
     json = JsonDataType.new
     assert_not json.changed?
 
-    json.payload = { 'one' => 'two' }
+    json.payload = { "one" => "two" }
     assert json.changed?
     assert json.payload_changed?
 
     json.save!
     assert_not json.changed?
 
-    json.payload['three'] = 'four'
+    json.payload["three"] = "four"
     assert json.payload_changed?
 
     json.save!
     json.reload
 
-    assert_equal({ 'one' => 'two', 'three' => 'four' }, json.payload)
+    assert_equal({ "one" => "two", "three" => "four" }, json.payload)
     assert_not json.changed?
   end
 
diff --git a/activerecord/test/cases/adapters/postgresql/ltree_test.rb b/activerecord/test/cases/adapters/postgresql/ltree_test.rb
index 56516c82b4..2b5ac1cac6 100644
--- a/activerecord/test/cases/adapters/postgresql/ltree_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/ltree_test.rb
@@ -1,20 +1,20 @@
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 class PostgresqlLtreeTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
   class Ltree < ActiveRecord::Base
-    self.table_name = 'ltrees'
+    self.table_name = "ltrees"
   end
 
   def setup
     @connection = ActiveRecord::Base.connection
 
-    enable_extension!('ltree', @connection)
+    enable_extension!("ltree", @connection)
 
     @connection.transaction do
-      @connection.create_table('ltrees') do |t|
-        t.ltree 'path'
+      @connection.create_table("ltrees") do |t|
+        t.ltree "path"
       end
     end
   rescue ActiveRecord::StatementInvalid
@@ -22,28 +22,28 @@ class PostgresqlLtreeTest < ActiveRecord::PostgreSQLTestCase
   end
 
   teardown do
-    @connection.drop_table 'ltrees', if_exists: true
+    @connection.drop_table "ltrees", if_exists: true
   end
 
   def test_column
-    column = Ltree.columns_hash['path']
+    column = Ltree.columns_hash["path"]
     assert_equal :ltree, column.type
     assert_equal "ltree", column.sql_type
     assert_not column.array?
 
-    type = Ltree.type_for_attribute('path')
+    type = Ltree.type_for_attribute("path")
     assert_not type.binary?
   end
 
   def test_write
-    ltree = Ltree.new(path: '1.2.3.4')
+    ltree = Ltree.new(path: "1.2.3.4")
     assert ltree.save!
   end
 
   def test_select
     @connection.execute "insert into ltrees (path) VALUES ('1.2.3')"
     ltree = Ltree.first
-    assert_equal '1.2.3', ltree.path
+    assert_equal "1.2.3", ltree.path
   end
 
   def test_schema_dump_with_shorthand
diff --git a/activerecord/test/cases/adapters/postgresql/money_test.rb b/activerecord/test/cases/adapters/postgresql/money_test.rb
index c031178479..1b5d8362af 100644
--- a/activerecord/test/cases/adapters/postgresql/money_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/money_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 class PostgresqlMoneyTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
@@ -9,14 +9,14 @@ class PostgresqlMoneyTest < ActiveRecord::PostgreSQLTestCase
   setup do
     @connection = ActiveRecord::Base.connection
     @connection.execute("set lc_monetary = 'C'")
-    @connection.create_table('postgresql_moneys', force: true) do |t|
+    @connection.create_table("postgresql_moneys", force: true) do |t|
       t.money "wealth"
       t.money "depth", default: "150.55"
     end
   end
 
   teardown do
-    @connection.drop_table 'postgresql_moneys', if_exists: true
+    @connection.drop_table "postgresql_moneys", if_exists: true
   end
 
   def test_column
@@ -31,7 +31,7 @@ class PostgresqlMoneyTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_default
-    assert_equal BigDecimal.new("150.55"), PostgresqlMoney.column_defaults['depth']
+    assert_equal BigDecimal.new("150.55"), PostgresqlMoney.column_defaults["depth"]
     assert_equal BigDecimal.new("150.55"), PostgresqlMoney.new.depth
   end
 
@@ -46,7 +46,7 @@ class PostgresqlMoneyTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_money_type_cast
-    type = PostgresqlMoney.type_for_attribute('wealth')
+    type = PostgresqlMoney.type_for_attribute("wealth")
     assert_equal(12345678.12, type.cast("$12,345,678.12"))
     assert_equal(12345678.12, type.cast("$12.345.678,12"))
     assert_equal(-1.15, type.cast("-$1.15"))
@@ -63,7 +63,7 @@ class PostgresqlMoneyTest < ActiveRecord::PostgreSQLTestCase
     money = PostgresqlMoney.create(wealth: "987.65")
     assert_equal 987.65, money.wealth
 
-    new_value = BigDecimal.new('123.45')
+    new_value = BigDecimal.new("123.45")
     money.wealth = new_value
     money.save!
     money.reload
@@ -80,7 +80,7 @@ class PostgresqlMoneyTest < ActiveRecord::PostgreSQLTestCase
 
   def test_update_all_with_money_big_decimal
     money = PostgresqlMoney.create!
-    PostgresqlMoney.update_all(wealth: '123.45'.to_d)
+    PostgresqlMoney.update_all(wealth: "123.45".to_d)
     money.reload
 
     assert_equal 123.45, money.wealth
diff --git a/activerecord/test/cases/adapters/postgresql/network_test.rb b/activerecord/test/cases/adapters/postgresql/network_test.rb
index fe6ee4e2d9..a33b0ef8a7 100644
--- a/activerecord/test/cases/adapters/postgresql/network_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/network_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 class PostgresqlNetworkTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
@@ -7,15 +7,15 @@ class PostgresqlNetworkTest < ActiveRecord::PostgreSQLTestCase
 
   setup do
     @connection = ActiveRecord::Base.connection
-    @connection.create_table('postgresql_network_addresses', force: true) do |t|
-      t.inet 'inet_address', default: "192.168.1.1"
-      t.cidr 'cidr_address', default: "192.168.1.0/24"
-      t.macaddr 'mac_address', default: "ff:ff:ff:ff:ff:ff"
+    @connection.create_table("postgresql_network_addresses", force: true) do |t|
+      t.inet "inet_address", default: "192.168.1.1"
+      t.cidr "cidr_address", default: "192.168.1.0/24"
+      t.macaddr "mac_address", default: "ff:ff:ff:ff:ff:ff"
     end
   end
 
   teardown do
-    @connection.drop_table 'postgresql_network_addresses', if_exists: true
+    @connection.drop_table "postgresql_network_addresses", if_exists: true
   end
 
   def test_cidr_column
@@ -49,33 +49,33 @@ class PostgresqlNetworkTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_network_types
-    PostgresqlNetworkAddress.create(cidr_address: '192.168.0.0/24',
-                                    inet_address: '172.16.1.254/32',
-                                    mac_address: '01:23:45:67:89:0a')
+    PostgresqlNetworkAddress.create(cidr_address: "192.168.0.0/24",
+                                    inet_address: "172.16.1.254/32",
+                                    mac_address: "01:23:45:67:89:0a")
 
     address = PostgresqlNetworkAddress.first
-    assert_equal IPAddr.new('192.168.0.0/24'), address.cidr_address
-    assert_equal IPAddr.new('172.16.1.254'), address.inet_address
-    assert_equal '01:23:45:67:89:0a', address.mac_address
+    assert_equal IPAddr.new("192.168.0.0/24"), address.cidr_address
+    assert_equal IPAddr.new("172.16.1.254"), address.inet_address
+    assert_equal "01:23:45:67:89:0a", address.mac_address
 
-    address.cidr_address = '10.1.2.3/32'
-    address.inet_address = '10.0.0.0/8'
-    address.mac_address = 'bc:de:f0:12:34:56'
+    address.cidr_address = "10.1.2.3/32"
+    address.inet_address = "10.0.0.0/8"
+    address.mac_address = "bc:de:f0:12:34:56"
 
     address.save!
     assert address.reload
-    assert_equal IPAddr.new('10.1.2.3/32'), address.cidr_address
-    assert_equal IPAddr.new('10.0.0.0/8'), address.inet_address
-    assert_equal 'bc:de:f0:12:34:56', address.mac_address
+    assert_equal IPAddr.new("10.1.2.3/32"), address.cidr_address
+    assert_equal IPAddr.new("10.0.0.0/8"), address.inet_address
+    assert_equal "bc:de:f0:12:34:56", address.mac_address
   end
 
   def test_invalid_network_address
-    invalid_address = PostgresqlNetworkAddress.new(cidr_address: 'invalid addr',
-                                                   inet_address: 'invalid addr')
+    invalid_address = PostgresqlNetworkAddress.new(cidr_address: "invalid addr",
+                                                   inet_address: "invalid addr")
     assert_nil invalid_address.cidr_address
     assert_nil invalid_address.inet_address
-    assert_equal 'invalid addr', invalid_address.cidr_address_before_type_cast
-    assert_equal 'invalid addr', invalid_address.inet_address_before_type_cast
+    assert_equal "invalid addr", invalid_address.cidr_address_before_type_cast
+    assert_equal "invalid addr", invalid_address.inet_address_before_type_cast
     assert invalid_address.save
 
     invalid_address.reload
diff --git a/activerecord/test/cases/adapters/postgresql/numbers_test.rb b/activerecord/test/cases/adapters/postgresql/numbers_test.rb
index ba7e7dc9a3..834354dcc9 100644
--- a/activerecord/test/cases/adapters/postgresql/numbers_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/numbers_test.rb
@@ -5,14 +5,14 @@ class PostgresqlNumberTest < ActiveRecord::PostgreSQLTestCase
 
   setup do
     @connection = ActiveRecord::Base.connection
-    @connection.create_table('postgresql_numbers', force: true) do |t|
-      t.column 'single', 'REAL'
-      t.column 'double', 'DOUBLE PRECISION'
+    @connection.create_table("postgresql_numbers", force: true) do |t|
+      t.column "single", "REAL"
+      t.column "double", "DOUBLE PRECISION"
     end
   end
 
   teardown do
-    @connection.drop_table 'postgresql_numbers', if_exists: true
+    @connection.drop_table "postgresql_numbers", if_exists: true
   end
 
   def test_data_type
diff --git a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
index 9832df7839..cd2b2d5bc9 100644
--- a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
@@ -1,6 +1,6 @@
 require "cases/helper"
-require 'support/ddl_helper'
-require 'support/connection_helper'
+require "support/ddl_helper"
+require "support/connection_helper"
 
 module ActiveRecord
   module ConnectionAdapters
@@ -15,15 +15,15 @@ module ActiveRecord
 
       def test_bad_connection
         assert_raise ActiveRecord::NoDatabaseError do
-          configuration = ActiveRecord::Base.configurations['arunit'].merge(database: 'should_not_exist-cinco-dog-db')
+          configuration = ActiveRecord::Base.configurations["arunit"].merge(database: "should_not_exist-cinco-dog-db")
           connection = ActiveRecord::Base.postgresql_connection(configuration)
-          connection.exec_query('SELECT 1')
+          connection.exec_query("SELECT 1")
         end
       end
 
       def test_valid_column
         with_example_table do
-          column = @connection.columns('ex').find { |col| col.name == 'id' }
+          column = @connection.columns("ex").find { |col| col.name == "id" }
           assert @connection.valid_type?(column.type)
         end
       end
@@ -34,144 +34,144 @@ module ActiveRecord
 
       def test_primary_key
         with_example_table do
-          assert_equal 'id', @connection.primary_key('ex')
+          assert_equal "id", @connection.primary_key("ex")
         end
       end
 
       def test_primary_key_works_tables_containing_capital_letters
-        assert_equal 'id', @connection.primary_key('CamelCase')
+        assert_equal "id", @connection.primary_key("CamelCase")
       end
 
       def test_non_standard_primary_key
-        with_example_table 'data character varying(255) primary key' do
-          assert_equal 'data', @connection.primary_key('ex')
+        with_example_table "data character varying(255) primary key" do
+          assert_equal "data", @connection.primary_key("ex")
         end
       end
 
       def test_primary_key_returns_nil_for_no_pk
-        with_example_table 'id integer' do
-          assert_nil @connection.primary_key('ex')
+        with_example_table "id integer" do
+          assert_nil @connection.primary_key("ex")
         end
       end
 
       def test_primary_key_raises_error_if_table_not_found
         assert_raises(ActiveRecord::StatementInvalid) do
-          @connection.primary_key('unobtainium')
+          @connection.primary_key("unobtainium")
         end
       end
 
       def test_exec_insert_with_returning_disabled
         connection = connection_without_insert_returning
-        result = connection.exec_insert("insert into postgresql_partitioned_table_parent (number) VALUES (1)", nil, [], 'id', 'postgresql_partitioned_table_parent_id_seq')
-        expect = connection.query('select max(id) from postgresql_partitioned_table_parent').first.first
+        result = connection.exec_insert("insert into postgresql_partitioned_table_parent (number) VALUES (1)", nil, [], "id", "postgresql_partitioned_table_parent_id_seq")
+        expect = connection.query("select max(id) from postgresql_partitioned_table_parent").first.first
         assert_equal expect.to_i, result.rows.first.first
       end
 
       def test_exec_insert_with_returning_disabled_and_no_sequence_name_given
         connection = connection_without_insert_returning
-        result = connection.exec_insert("insert into postgresql_partitioned_table_parent (number) VALUES (1)", nil, [], 'id')
-        expect = connection.query('select max(id) from postgresql_partitioned_table_parent').first.first
+        result = connection.exec_insert("insert into postgresql_partitioned_table_parent (number) VALUES (1)", nil, [], "id")
+        expect = connection.query("select max(id) from postgresql_partitioned_table_parent").first.first
         assert_equal expect.to_i, result.rows.first.first
       end
 
       def test_exec_insert_default_values_with_returning_disabled_and_no_sequence_name_given
         connection = connection_without_insert_returning
-        result = connection.exec_insert("insert into postgresql_partitioned_table_parent DEFAULT VALUES", nil, [], 'id')
-        expect = connection.query('select max(id) from postgresql_partitioned_table_parent').first.first
+        result = connection.exec_insert("insert into postgresql_partitioned_table_parent DEFAULT VALUES", nil, [], "id")
+        expect = connection.query("select max(id) from postgresql_partitioned_table_parent").first.first
         assert_equal expect.to_i, result.rows.first.first
       end
 
       def test_exec_insert_default_values_quoted_schema_with_returning_disabled_and_no_sequence_name_given
         connection = connection_without_insert_returning
-        result = connection.exec_insert('insert into "public"."postgresql_partitioned_table_parent" DEFAULT VALUES', nil, [], 'id')
-        expect = connection.query('select max(id) from postgresql_partitioned_table_parent').first.first
+        result = connection.exec_insert('insert into "public"."postgresql_partitioned_table_parent" DEFAULT VALUES', nil, [], "id")
+        expect = connection.query("select max(id) from postgresql_partitioned_table_parent").first.first
         assert_equal expect.to_i, result.rows.first.first
       end
 
       def test_sql_for_insert_with_returning_disabled
         connection = connection_without_insert_returning
-        sql, binds = connection.sql_for_insert('sql', nil, nil, nil, 'binds')
-        assert_equal ['sql', 'binds'], [sql, binds]
+        sql, binds = connection.sql_for_insert("sql", nil, nil, nil, "binds")
+        assert_equal ["sql", "binds"], [sql, binds]
       end
 
       def test_serial_sequence
-        assert_equal 'public.accounts_id_seq',
-          @connection.serial_sequence('accounts', 'id')
+        assert_equal "public.accounts_id_seq",
+          @connection.serial_sequence("accounts", "id")
 
         assert_raises(ActiveRecord::StatementInvalid) do
-          @connection.serial_sequence('zomg', 'id')
+          @connection.serial_sequence("zomg", "id")
         end
       end
 
       def test_default_sequence_name
-        assert_equal 'public.accounts_id_seq',
-          @connection.default_sequence_name('accounts', 'id')
+        assert_equal "public.accounts_id_seq",
+          @connection.default_sequence_name("accounts", "id")
 
-        assert_equal 'public.accounts_id_seq',
-          @connection.default_sequence_name('accounts')
+        assert_equal "public.accounts_id_seq",
+          @connection.default_sequence_name("accounts")
       end
 
       def test_default_sequence_name_bad_table
-        assert_equal 'zomg_id_seq',
-          @connection.default_sequence_name('zomg', 'id')
+        assert_equal "zomg_id_seq",
+          @connection.default_sequence_name("zomg", "id")
 
-        assert_equal 'zomg_id_seq',
-          @connection.default_sequence_name('zomg')
+        assert_equal "zomg_id_seq",
+          @connection.default_sequence_name("zomg")
       end
 
       def test_pk_and_sequence_for
         with_example_table do
-          pk, seq = @connection.pk_and_sequence_for('ex')
-          assert_equal 'id', pk
-          assert_equal @connection.default_sequence_name('ex', 'id'), seq.to_s
+          pk, seq = @connection.pk_and_sequence_for("ex")
+          assert_equal "id", pk
+          assert_equal @connection.default_sequence_name("ex", "id"), seq.to_s
         end
       end
 
       def test_pk_and_sequence_for_with_non_standard_primary_key
-        with_example_table 'code serial primary key' do
-          pk, seq = @connection.pk_and_sequence_for('ex')
-          assert_equal 'code', pk
-          assert_equal @connection.default_sequence_name('ex', 'code'), seq.to_s
+        with_example_table "code serial primary key" do
+          pk, seq = @connection.pk_and_sequence_for("ex")
+          assert_equal "code", pk
+          assert_equal @connection.default_sequence_name("ex", "code"), seq.to_s
         end
       end
 
       def test_pk_and_sequence_for_returns_nil_if_no_seq
-        with_example_table 'id integer primary key' do
-          assert_nil @connection.pk_and_sequence_for('ex')
+        with_example_table "id integer primary key" do
+          assert_nil @connection.pk_and_sequence_for("ex")
         end
       end
 
       def test_pk_and_sequence_for_returns_nil_if_no_pk
-        with_example_table 'id integer' do
-          assert_nil @connection.pk_and_sequence_for('ex')
+        with_example_table "id integer" do
+          assert_nil @connection.pk_and_sequence_for("ex")
         end
       end
 
       def test_pk_and_sequence_for_returns_nil_if_table_not_found
-        assert_nil @connection.pk_and_sequence_for('unobtainium')
+        assert_nil @connection.pk_and_sequence_for("unobtainium")
       end
 
       def test_pk_and_sequence_for_with_collision_pg_class_oid
-        @connection.exec_query('create table ex(id serial primary key)')
-        @connection.exec_query('create table ex2(id serial primary key)')
+        @connection.exec_query("create table ex(id serial primary key)")
+        @connection.exec_query("create table ex2(id serial primary key)")
 
         correct_depend_record = [
           "'pg_class'::regclass",
           "'ex_id_seq'::regclass",
-          '0',
+          "0",
           "'pg_class'::regclass",
           "'ex'::regclass",
-          '1',
+          "1",
           "'a'"
         ]
 
         collision_depend_record = [
           "'pg_attrdef'::regclass",
           "'ex2_id_seq'::regclass",
-          '0',
+          "0",
           "'pg_class'::regclass",
           "'ex'::regclass",
-          '1',
+          "1",
           "'a'"
         ]
 
@@ -185,15 +185,15 @@ module ActiveRecord
           "INSERT INTO pg_depend VALUES(#{correct_depend_record.join(',')})"
         )
 
-        seq = @connection.pk_and_sequence_for('ex').last
+        seq = @connection.pk_and_sequence_for("ex").last
         assert_equal PostgreSQL::Name.new("public", "ex_id_seq"), seq
 
         @connection.exec_query(
           "DELETE FROM pg_depend WHERE objid = 'ex2_id_seq'::regclass AND refobjid = 'ex'::regclass AND deptype = 'a'"
         )
       ensure
-        @connection.drop_table 'ex', if_exists: true
-        @connection.drop_table 'ex2', if_exists: true
+        @connection.drop_table "ex", if_exists: true
+        @connection.drop_table "ex2", if_exists: true
       end
 
       def test_table_alias_length
@@ -204,74 +204,74 @@ module ActiveRecord
 
       def test_exec_no_binds
         with_example_table do
-          result = @connection.exec_query('SELECT id, data FROM ex')
+          result = @connection.exec_query("SELECT id, data FROM ex")
           assert_equal 0, result.rows.length
           assert_equal 2, result.columns.length
           assert_equal %w{ id data }, result.columns
 
-          string = @connection.quote('foo')
+          string = @connection.quote("foo")
           @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
-          result = @connection.exec_query('SELECT id, data FROM ex')
+          result = @connection.exec_query("SELECT id, data FROM ex")
           assert_equal 1, result.rows.length
           assert_equal 2, result.columns.length
 
-          assert_equal [[1, 'foo']], result.rows
+          assert_equal [[1, "foo"]], result.rows
         end
       end
 
       if ActiveRecord::Base.connection.prepared_statements
         def test_exec_with_binds
           with_example_table do
-            string = @connection.quote('foo')
+            string = @connection.quote("foo")
             @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
 
             bind = Relation::QueryAttribute.new("id", 1, Type::Value.new)
-            result = @connection.exec_query('SELECT id, data FROM ex WHERE id = $1', nil, [bind])
+            result = @connection.exec_query("SELECT id, data FROM ex WHERE id = $1", nil, [bind])
 
             assert_equal 1, result.rows.length
             assert_equal 2, result.columns.length
 
-            assert_equal [[1, 'foo']], result.rows
+            assert_equal [[1, "foo"]], result.rows
           end
         end
 
         def test_exec_typecasts_bind_vals
           with_example_table do
-            string = @connection.quote('foo')
+            string = @connection.quote("foo")
             @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
 
             bind = Relation::QueryAttribute.new("id", "1-fuu", Type::Integer.new)
-            result = @connection.exec_query('SELECT id, data FROM ex WHERE id = $1', nil, [bind])
+            result = @connection.exec_query("SELECT id, data FROM ex WHERE id = $1", nil, [bind])
 
             assert_equal 1, result.rows.length
             assert_equal 2, result.columns.length
 
-            assert_equal [[1, 'foo']], result.rows
+            assert_equal [[1, "foo"]], result.rows
           end
         end
       end
 
       def test_partial_index
         with_example_table do
-          @connection.add_index 'ex', %w{ id number }, :name => 'partial', :where => "number > 100"
-          index = @connection.indexes('ex').find { |idx| idx.name == 'partial' }
+          @connection.add_index "ex", %w{ id number }, :name => "partial", :where => "number > 100"
+          index = @connection.indexes("ex").find { |idx| idx.name == "partial" }
           assert_equal "(number > 100)", index.where
         end
       end
 
       def test_expression_index
         with_example_table do
-          @connection.add_index 'ex', 'mod(id, 10), abs(number)', name: 'expression'
-          index = @connection.indexes('ex').find { |idx| idx.name == 'expression' }
-          assert_equal 'mod(id, 10), abs(number)', index.columns
+          @connection.add_index "ex", "mod(id, 10), abs(number)", name: "expression"
+          index = @connection.indexes("ex").find { |idx| idx.name == "expression" }
+          assert_equal "mod(id, 10), abs(number)", index.columns
         end
       end
 
       def test_index_with_opclass
         with_example_table do
-          @connection.add_index 'ex', 'data varchar_pattern_ops', name: 'with_opclass'
-          index = @connection.indexes('ex').find { |idx| idx.name == 'with_opclass' }
-          assert_equal 'data varchar_pattern_ops', index.columns
+          @connection.add_index "ex", "data varchar_pattern_ops", name: "with_opclass"
+          index = @connection.indexes("ex").find { |idx| idx.name == "with_opclass" }
+          assert_equal "data varchar_pattern_ops", index.columns
         end
       end
 
@@ -292,8 +292,8 @@ module ActiveRecord
 
       def test_columns_for_distinct_with_case
         assert_equal(
-          'posts.id, CASE WHEN author.is_active THEN UPPER(author.name) ELSE UPPER(author.email) END AS alias_0',
-          @connection.columns_for_distinct('posts.id',
+          "posts.id, CASE WHEN author.is_active THEN UPPER(author.name) ELSE UPPER(author.email) END AS alias_0",
+          @connection.columns_for_distinct("posts.id",
             ["CASE WHEN author.is_active THEN UPPER(author.name) ELSE UPPER(author.email) END"])
         )
       end
@@ -374,7 +374,7 @@ module ActiveRecord
       def test_unparsed_defaults_are_at_least_set_when_saving
         with_example_table "id SERIAL PRIMARY KEY, number INTEGER NOT NULL DEFAULT (4 + 4) * 2 / 4" do
           number_klass = Class.new(ActiveRecord::Base) do
-            self.table_name = 'ex'
+            self.table_name = "ex"
           end
           column = number_klass.columns_hash["number"]
           assert_nil column.default
@@ -390,12 +390,12 @@ module ActiveRecord
 
       private
 
-      def with_example_table(definition = 'id serial primary key, number integer, data character varying(255)', &block)
-        super(@connection, 'ex', definition, &block)
+      def with_example_table(definition = "id serial primary key, number integer, data character varying(255)", &block)
+        super(@connection, "ex", definition, &block)
       end
 
       def connection_without_insert_returning
-        ActiveRecord::Base.postgresql_connection(ActiveRecord::Base.configurations['arunit'].merge(:insert_returning => false))
+        ActiveRecord::Base.postgresql_connection(ActiveRecord::Base.configurations["arunit"].merge(:insert_returning => false))
       end
     end
   end
diff --git a/activerecord/test/cases/adapters/postgresql/quoting_test.rb b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
index 5e6f4dbbb8..865a3a5098 100644
--- a/activerecord/test/cases/adapters/postgresql/quoting_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'ipaddr'
+require "ipaddr"
 
 module ActiveRecord
   module ConnectionAdapters
@@ -10,11 +10,11 @@ module ActiveRecord
         end
 
         def test_type_cast_true
-          assert_equal 't', @conn.type_cast(true)
+          assert_equal "t", @conn.type_cast(true)
         end
 
         def test_type_cast_false
-          assert_equal 'f', @conn.type_cast(false)
+          assert_equal "f", @conn.type_cast(false)
         end
 
         def test_quote_float_nan
diff --git a/activerecord/test/cases/adapters/postgresql/range_test.rb b/activerecord/test/cases/adapters/postgresql/range_test.rb
index 0edfa4ed9d..3f819f7bd5 100644
--- a/activerecord/test/cases/adapters/postgresql/range_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/range_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'support/connection_helper'
+require "support/connection_helper"
 
 if ActiveRecord::Base.connection.respond_to?(:supports_ranges?) && ActiveRecord::Base.connection.supports_ranges?
   class PostgresqlRange < ActiveRecord::Base
@@ -23,7 +23,7 @@ if ActiveRecord::Base.connection.respond_to?(:supports_ranges?) && ActiveRecord:
             );
 _SQL
 
-          @connection.create_table('postgresql_ranges') do |t|
+          @connection.create_table("postgresql_ranges") do |t|
             t.daterange :date_range
             t.numrange :num_range
             t.tsrange :ts_range
@@ -32,7 +32,7 @@ _SQL
             t.int8range :int8_range
           end
 
-          @connection.add_column 'postgresql_ranges', 'float_range', 'floatrange'
+          @connection.add_column "postgresql_ranges", "float_range", "floatrange"
         end
         PostgresqlRange.reset_column_information
       rescue ActiveRecord::StatementInvalid
@@ -93,8 +93,8 @@ _SQL
     end
 
     teardown do
-      @connection.drop_table 'postgresql_ranges', if_exists: true
-      @connection.execute 'DROP TYPE IF EXISTS floatrange'
+      @connection.drop_table "postgresql_ranges", if_exists: true
+      @connection.execute "DROP TYPE IF EXISTS floatrange"
       reset_connection
     end
 
@@ -132,10 +132,10 @@ _SQL
     end
 
     def test_numrange_values
-      assert_equal BigDecimal.new('0.1')..BigDecimal.new('0.2'), @first_range.num_range
-      assert_equal BigDecimal.new('0.1')...BigDecimal.new('0.2'), @second_range.num_range
-      assert_equal BigDecimal.new('0.1')...BigDecimal.new('Infinity'), @third_range.num_range
-      assert_equal BigDecimal.new('-Infinity')...BigDecimal.new('Infinity'), @fourth_range.num_range
+      assert_equal BigDecimal.new("0.1")..BigDecimal.new("0.2"), @first_range.num_range
+      assert_equal BigDecimal.new("0.1")...BigDecimal.new("0.2"), @second_range.num_range
+      assert_equal BigDecimal.new("0.1")...BigDecimal.new("Infinity"), @third_range.num_range
+      assert_equal BigDecimal.new("-Infinity")...BigDecimal.new("Infinity"), @fourth_range.num_range
       assert_nil @empty_range.num_range
     end
 
@@ -148,8 +148,8 @@ _SQL
     end
 
     def test_tstzrange_values
-      assert_equal Time.parse('2010-01-01 09:30:00 UTC')..Time.parse('2011-01-01 17:30:00 UTC'), @first_range.tstz_range
-      assert_equal Time.parse('2010-01-01 09:30:00 UTC')...Time.parse('2011-01-01 17:30:00 UTC'), @second_range.tstz_range
+      assert_equal Time.parse("2010-01-01 09:30:00 UTC")..Time.parse("2011-01-01 17:30:00 UTC"), @first_range.tstz_range
+      assert_equal Time.parse("2010-01-01 09:30:00 UTC")...Time.parse("2011-01-01 17:30:00 UTC"), @second_range.tstz_range
       assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.tstz_range)
       assert_nil @empty_range.tstz_range
     end
@@ -183,17 +183,17 @@ _SQL
     end
 
     def test_create_tstzrange
-      tstzrange = Time.parse('2010-01-01 14:30:00 +0100')...Time.parse('2011-02-02 14:30:00 CDT')
+      tstzrange = Time.parse("2010-01-01 14:30:00 +0100")...Time.parse("2011-02-02 14:30:00 CDT")
       round_trip(@new_range, :tstz_range, tstzrange)
       assert_equal @new_range.tstz_range, tstzrange
-      assert_equal @new_range.tstz_range, Time.parse('2010-01-01 13:30:00 UTC')...Time.parse('2011-02-02 19:30:00 UTC')
+      assert_equal @new_range.tstz_range, Time.parse("2010-01-01 13:30:00 UTC")...Time.parse("2011-02-02 19:30:00 UTC")
     end
 
     def test_update_tstzrange
       assert_equal_round_trip(@first_range, :tstz_range,
-                              Time.parse('2010-01-01 14:30:00 CDT')...Time.parse('2011-02-02 14:30:00 CET'))
+                              Time.parse("2010-01-01 14:30:00 CDT")...Time.parse("2011-02-02 14:30:00 CET"))
       assert_nil_round_trip(@first_range, :tstz_range,
-                            Time.parse('2010-01-01 14:30:00 +0100')...Time.parse('2010-01-01 13:30:00 +0000'))
+                            Time.parse("2010-01-01 14:30:00 +0100")...Time.parse("2010-01-01 13:30:00 +0000"))
     end
 
     def test_create_tsrange
@@ -232,14 +232,14 @@ _SQL
 
     def test_create_numrange
       assert_equal_round_trip(@new_range, :num_range,
-                              BigDecimal.new('0.5')...BigDecimal.new('1'))
+                              BigDecimal.new("0.5")...BigDecimal.new("1"))
     end
 
     def test_update_numrange
       assert_equal_round_trip(@first_range, :num_range,
-                              BigDecimal.new('0.5')...BigDecimal.new('1'))
+                              BigDecimal.new("0.5")...BigDecimal.new("1"))
       assert_nil_round_trip(@first_range, :num_range,
-                            BigDecimal.new('0.5')...BigDecimal.new('0.5'))
+                            BigDecimal.new("0.5")...BigDecimal.new("0.5"))
     end
 
     def test_create_daterange
diff --git a/activerecord/test/cases/adapters/postgresql/referential_integrity_test.rb b/activerecord/test/cases/adapters/postgresql/referential_integrity_test.rb
index c895ab9db5..6997044d81 100644
--- a/activerecord/test/cases/adapters/postgresql/referential_integrity_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/referential_integrity_test.rb
@@ -1,5 +1,5 @@
-require 'cases/helper'
-require 'support/connection_helper'
+require "cases/helper"
+require "support/connection_helper"
 
 class PostgreSQLReferentialIntegrityTest < ActiveRecord::PostgreSQLTestCase
   self.use_transactional_tests = false
@@ -14,7 +14,7 @@ class PostgreSQLReferentialIntegrityTest < ActiveRecord::PostgreSQLTestCase
     def execute(sql)
       if IS_REFERENTIAL_INTEGRITY_SQL.call(sql)
         super "BROKEN;" rescue nil # put transaction in broken state
-        raise ActiveRecord::StatementInvalid, 'PG::InsufficientPrivilege'
+        raise ActiveRecord::StatementInvalid, "PG::InsufficientPrivilege"
       else
         super
       end
@@ -24,7 +24,7 @@ class PostgreSQLReferentialIntegrityTest < ActiveRecord::PostgreSQLTestCase
   module ProgrammerMistake
     def execute(sql)
       if IS_REFERENTIAL_INTEGRITY_SQL.call(sql)
-        raise ArgumentError, 'something is not right.'
+        raise ArgumentError, "something is not right."
       else
         super
       end
@@ -48,10 +48,10 @@ class PostgreSQLReferentialIntegrityTest < ActiveRecord::PostgreSQLTestCase
     warning = capture(:stderr) do
       e = assert_raises(ActiveRecord::InvalidForeignKey) do
         @connection.disable_referential_integrity do
-          raise ActiveRecord::InvalidForeignKey, 'Should be re-raised'
+          raise ActiveRecord::InvalidForeignKey, "Should be re-raised"
         end
       end
-      assert_equal 'Should be re-raised', e.message
+      assert_equal "Should be re-raised", e.message
     end
     assert_match (/WARNING: Rails was not able to disable referential integrity/), warning
     assert_match (/cause: PG::InsufficientPrivilege/), warning
@@ -63,10 +63,10 @@ class PostgreSQLReferentialIntegrityTest < ActiveRecord::PostgreSQLTestCase
     warning = capture(:stderr) do
       e = assert_raises(ActiveRecord::StatementInvalid) do
         @connection.disable_referential_integrity do
-          raise ActiveRecord::StatementInvalid, 'Should be re-raised'
+          raise ActiveRecord::StatementInvalid, "Should be re-raised"
         end
       end
-      assert_equal 'Should be re-raised', e.message
+      assert_equal "Should be re-raised", e.message
     end
     assert warning.blank?, "expected no warnings but got:\n#{warning}"
   end
diff --git a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
index 285a92f60e..7b565b348e 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
@@ -6,12 +6,12 @@ end
 class SchemaAuthorizationTest < ActiveRecord::PostgreSQLTestCase
   self.use_transactional_tests = false
 
-  TABLE_NAME = 'schema_things'
+  TABLE_NAME = "schema_things"
   COLUMNS = [
-    'id serial primary key',
-    'name character varying(50)'
+    "id serial primary key",
+    "name character varying(50)"
   ]
-  USERS = ['rails_pg_schema_user1', 'rails_pg_schema_user2']
+  USERS = ["rails_pg_schema_user1", "rails_pg_schema_user2"]
 
   def setup
     @connection = ActiveRecord::Base.connection
@@ -45,7 +45,7 @@ class SchemaAuthorizationTest < ActiveRecord::PostgreSQLTestCase
 
   def test_session_auth=
     assert_raise(ActiveRecord::StatementInvalid) do
-      @connection.session_auth = 'DEFAULT'
+      @connection.session_auth = "DEFAULT"
       @connection.execute "SELECT * FROM #{TABLE_NAME}"
     end
   end
@@ -68,7 +68,7 @@ class SchemaAuthorizationTest < ActiveRecord::PostgreSQLTestCase
         USERS.each do |u|
           @connection.clear_cache!
           set_session_auth u
-          assert_equal u, @connection.select_value("SELECT name FROM #{TABLE_NAME} WHERE id = $1", 'SQL', [bind_param(1)])
+          assert_equal u, @connection.select_value("SELECT name FROM #{TABLE_NAME} WHERE id = $1", "SQL", [bind_param(1)])
           set_session_auth
         end
       end
@@ -90,9 +90,9 @@ class SchemaAuthorizationTest < ActiveRecord::PostgreSQLTestCase
     assert_nothing_raised do
       USERS.each do |u|
         set_session_auth u
-        st = SchemaThing.new :name => 'TEST1'
+        st = SchemaThing.new :name => "TEST1"
         st.save!
-        st = SchemaThing.new :id => 5, :name => 'TEST2'
+        st = SchemaThing.new :id => 5, :name => "TEST2"
         st.save!
         set_session_auth
       end
@@ -110,7 +110,7 @@ class SchemaAuthorizationTest < ActiveRecord::PostgreSQLTestCase
 
   private
     def set_session_auth auth = nil
-       @connection.session_auth =  auth || 'default'
+       @connection.session_auth =  auth || "default"
     end
 
     def bind_param(value)
diff --git a/activerecord/test/cases/adapters/postgresql/schema_test.rb b/activerecord/test/cases/adapters/postgresql/schema_test.rb
index 52ef07f654..029314874e 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_test.rb
@@ -1,6 +1,6 @@
 require "cases/helper"
-require 'models/default'
-require 'support/schema_dumping_helper'
+require "models/default"
+require "support/schema_dumping_helper"
 
 module PGSchemaHelper
   def with_schema_search_path(schema_search_path)
@@ -17,32 +17,32 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
   include PGSchemaHelper
   self.use_transactional_tests = false
 
-  SCHEMA_NAME = 'test_schema'
-  SCHEMA2_NAME = 'test_schema2'
-  TABLE_NAME = 'things'
-  CAPITALIZED_TABLE_NAME = 'Things'
-  INDEX_A_NAME = 'a_index_things_on_name'
-  INDEX_B_NAME = 'b_index_things_on_different_columns_in_each_schema'
-  INDEX_C_NAME = 'c_index_full_text_search'
-  INDEX_D_NAME = 'd_index_things_on_description_desc'
-  INDEX_E_NAME = 'e_index_things_on_name_vector'
-  INDEX_A_COLUMN = 'name'
-  INDEX_B_COLUMN_S1 = 'email'
-  INDEX_B_COLUMN_S2 = 'moment'
+  SCHEMA_NAME = "test_schema"
+  SCHEMA2_NAME = "test_schema2"
+  TABLE_NAME = "things"
+  CAPITALIZED_TABLE_NAME = "Things"
+  INDEX_A_NAME = "a_index_things_on_name"
+  INDEX_B_NAME = "b_index_things_on_different_columns_in_each_schema"
+  INDEX_C_NAME = "c_index_full_text_search"
+  INDEX_D_NAME = "d_index_things_on_description_desc"
+  INDEX_E_NAME = "e_index_things_on_name_vector"
+  INDEX_A_COLUMN = "name"
+  INDEX_B_COLUMN_S1 = "email"
+  INDEX_B_COLUMN_S2 = "moment"
   INDEX_C_COLUMN = %q{(to_tsvector('english', coalesce(things.name, '')))}
-  INDEX_D_COLUMN = 'description'
-  INDEX_E_COLUMN = 'name_vector'
+  INDEX_D_COLUMN = "description"
+  INDEX_E_COLUMN = "name_vector"
   COLUMNS = [
-    'id integer',
-    'name character varying(50)',
-    'email character varying(50)',
-    'description character varying(100)',
-    'name_vector tsvector',
-    'moment timestamp without time zone default now()'
+    "id integer",
+    "name character varying(50)",
+    "email character varying(50)",
+    "description character varying(100)",
+    "name_vector tsvector",
+    "moment timestamp without time zone default now()"
   ]
-  PK_TABLE_NAME = 'table_with_pk'
-  UNMATCHED_SEQUENCE_NAME = 'unmatched_primary_key_default_value_seq'
-  UNMATCHED_PK_TABLE_NAME = 'table_with_unmatched_sequence_for_pk'
+  PK_TABLE_NAME = "table_with_pk"
+  UNMATCHED_SEQUENCE_NAME = "unmatched_primary_key_default_value_seq"
+  UNMATCHED_PK_TABLE_NAME = "table_with_unmatched_sequence_for_pk"
 
   class Thing1 < ActiveRecord::Base
     self.table_name = "test_schema.things"
@@ -61,7 +61,7 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
   end
 
   class Thing5 < ActiveRecord::Base
-    self.table_name = 'things'
+    self.table_name = "things"
   end
 
   class Song < ActiveRecord::Base
@@ -168,21 +168,21 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
 
   def test_raise_wrapped_exception_on_bad_prepare
     assert_raises(ActiveRecord::StatementInvalid) do
-      @connection.exec_query "select * from developers where id = ?", 'sql', [bind_param(1)]
+      @connection.exec_query "select * from developers where id = ?", "sql", [bind_param(1)]
     end
   end
 
   if ActiveRecord::Base.connection.prepared_statements
     def test_schema_change_with_prepared_stmt
       altered = false
-      @connection.exec_query "select * from developers where id = $1", 'sql', [bind_param(1)]
-      @connection.exec_query "alter table developers add column zomg int", 'sql', []
+      @connection.exec_query "select * from developers where id = $1", "sql", [bind_param(1)]
+      @connection.exec_query "alter table developers add column zomg int", "sql", []
       altered = true
-      @connection.exec_query "select * from developers where id = $1", 'sql', [bind_param(1)]
+      @connection.exec_query "select * from developers where id = $1", "sql", [bind_param(1)]
     ensure
       # We are not using DROP COLUMN IF EXISTS because that syntax is only
       # supported by pg 9.X
-      @connection.exec_query("alter table developers drop column zomg", 'sql', []) if altered
+      @connection.exec_query("alter table developers drop column zomg", "sql", []) if altered
     end
   end
 
@@ -200,7 +200,7 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_data_source_exists_when_not_on_schema_search_path
-    with_schema_search_path('PUBLIC') do
+    with_schema_search_path("PUBLIC") do
       assert(!@connection.data_source_exists?(TABLE_NAME), "data_source exists but should not be found")
     end
   end
@@ -246,9 +246,9 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_proper_encoding_of_table_name
-    assert_equal '"table_name"', @connection.quote_table_name('table_name')
+    assert_equal '"table_name"', @connection.quote_table_name("table_name")
     assert_equal '"table.name"', @connection.quote_table_name('"table.name"')
-    assert_equal '"schema_name"."table_name"', @connection.quote_table_name('schema_name.table_name')
+    assert_equal '"schema_name"."table_name"', @connection.quote_table_name("schema_name.table_name")
     assert_equal '"schema_name"."table.name"', @connection.quote_table_name('schema_name."table.name"')
     assert_equal '"schema.name"."table_name"', @connection.quote_table_name('"schema.name".table_name')
     assert_equal '"schema.name"."table.name"', @connection.quote_table_name('"schema.name"."table.name"')
@@ -287,7 +287,7 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
 
   def test_raise_on_unquoted_schema_name
     assert_raises(ActiveRecord::StatementInvalid) do
-      with_schema_search_path '$user,public'
+      with_schema_search_path "$user,public"
     end
   end
 
@@ -307,7 +307,7 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
       assert @connection.index_name_exists?(TABLE_NAME, INDEX_D_NAME, true)
       assert @connection.index_name_exists?(TABLE_NAME, INDEX_E_NAME, true)
       assert @connection.index_name_exists?(TABLE_NAME, INDEX_E_NAME, true)
-      assert_not @connection.index_name_exists?(TABLE_NAME, 'missing_index', true)
+      assert_not @connection.index_name_exists?(TABLE_NAME, "missing_index", true)
     end
   end
 
@@ -356,13 +356,13 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
       %(#{SCHEMA_NAME}."#{PK_TABLE_NAME}"),
       %(#{SCHEMA_NAME}.#{PK_TABLE_NAME})
     ].each do |given|
-      assert_equal 'id', @connection.primary_key(given), "primary key should be found when table referenced as #{given}"
+      assert_equal "id", @connection.primary_key(given), "primary key should be found when table referenced as #{given}"
     end
   end
 
   def test_primary_key_assuming_schema_search_path
     with_schema_search_path(SCHEMA_NAME) do
-      assert_equal 'id', @connection.primary_key(PK_TABLE_NAME), "primary key should be found"
+      assert_equal "id", @connection.primary_key(PK_TABLE_NAME), "primary key should be found"
     end
   end
 
@@ -381,7 +381,7 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
       %("#{SCHEMA_NAME}"."#{UNMATCHED_PK_TABLE_NAME}")
     ].each do |given|
       pk, seq = @connection.pk_and_sequence_for(given)
-      assert_equal 'id', pk, "primary key should be found when table referenced as #{given}"
+      assert_equal "id", pk, "primary key should be found when table referenced as #{given}"
       assert_equal pg_name.new(SCHEMA_NAME, "#{PK_TABLE_NAME}_id_seq"), seq, "sequence name should be found when table referenced as #{given}" if given == %("#{SCHEMA_NAME}"."#{PK_TABLE_NAME}")
       assert_equal pg_name.new(SCHEMA_NAME, UNMATCHED_SEQUENCE_NAME), seq, "sequence name should be found when table referenced as #{given}" if given ==  %("#{SCHEMA_NAME}"."#{UNMATCHED_PK_TABLE_NAME}")
     end
@@ -389,10 +389,10 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
 
   def test_current_schema
     {
-      %('$user',public)                        => 'public',
+      %('$user',public)                        => "public",
       SCHEMA_NAME                              => SCHEMA_NAME,
       %(#{SCHEMA2_NAME},#{SCHEMA_NAME},public) => SCHEMA2_NAME,
-      %(public,#{SCHEMA2_NAME},#{SCHEMA_NAME}) => 'public'
+      %(public,#{SCHEMA2_NAME},#{SCHEMA_NAME}) => "public"
     }.each do |given,expect|
       with_schema_search_path(given) { assert_equal expect, @connection.current_schema }
     end
@@ -414,10 +414,10 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
 
   def test_schema_exists?
     {
-      'public'     => true,
+      "public"     => true,
       SCHEMA_NAME  => true,
       SCHEMA2_NAME => true,
-      'darkside'   => false
+      "darkside"   => false
     }.each do |given,expect|
       assert_equal expect, @connection.schema_exists?(given)
     end
@@ -442,7 +442,7 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
   private
     def columns(table_name)
       @connection.send(:column_definitions, table_name).map do |name, type, default|
-        "#{name} #{type}" + (default ? " default #{default}" : '')
+        "#{name} #{type}" + (default ? " default #{default}" : "")
       end
     end
 
diff --git a/activerecord/test/cases/adapters/postgresql/serial_test.rb b/activerecord/test/cases/adapters/postgresql/serial_test.rb
index 8abe064bf1..d711b3b729 100644
--- a/activerecord/test/cases/adapters/postgresql/serial_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/serial_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 class PostgresqlSerialTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
diff --git a/activerecord/test/cases/adapters/postgresql/statement_pool_test.rb b/activerecord/test/cases/adapters/postgresql/statement_pool_test.rb
index 5aab246c99..eb9978a898 100644
--- a/activerecord/test/cases/adapters/postgresql/statement_pool_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/statement_pool_test.rb
@@ -1,4 +1,4 @@
-require 'cases/helper'
+require "cases/helper"
 
 module ActiveRecord
   module ConnectionAdapters
@@ -17,22 +17,22 @@ module ActiveRecord
         if Process.respond_to?(:fork)
           def test_cache_is_per_pid
             cache = StatementPool.new nil, 10
-            cache['foo'] = 'bar'
-            assert_equal 'bar', cache['foo']
+            cache["foo"] = "bar"
+            assert_equal "bar", cache["foo"]
 
             pid = fork {
-              lookup = cache['foo'];
+              lookup = cache["foo"];
               exit!(!lookup)
             }
 
             Process.waitpid pid
-            assert $?.success?, 'process should exit successfully'
+            assert $?.success?, "process should exit successfully"
           end
         end
 
         def test_dealloc_does_not_raise_on_inactive_connection
           cache = StatementPool.new InactivePGconn.new, 10
-          cache['foo'] = 'bar'
+          cache["foo"] = "bar"
           assert_nothing_raised { cache.clear }
         end
       end
diff --git a/activerecord/test/cases/adapters/postgresql/timestamp_test.rb b/activerecord/test/cases/adapters/postgresql/timestamp_test.rb
index 4c4866b46b..ad290626ee 100644
--- a/activerecord/test/cases/adapters/postgresql/timestamp_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/timestamp_test.rb
@@ -1,6 +1,6 @@
-require 'cases/helper'
-require 'models/developer'
-require 'models/topic'
+require "cases/helper"
+require "models/developer"
+require "models/topic"
 
 class PostgresqlTimestampTest < ActiveRecord::PostgreSQLTestCase
   class PostgresqlTimestampWithZone < ActiveRecord::Base; end
@@ -32,7 +32,7 @@ class PostgresqlTimestampTest < ActiveRecord::PostgreSQLTestCase
     with_timezone_config default: :local, aware_attributes: false do
       @connection.reconnect!
       # make sure to use a non-UTC time zone
-      @connection.execute("SET time zone 'America/Jamaica'", 'SCHEMA')
+      @connection.execute("SET time zone 'America/Jamaica'", "SCHEMA")
 
       timestamp = PostgresqlTimestampWithZone.find(1)
       assert_equal Time.utc(2010,1,1, 11,0,0), timestamp.time
@@ -54,19 +54,19 @@ class PostgresqlTimestampFixtureTest < ActiveRecord::PostgreSQLTestCase
 
   def test_load_infinity_and_beyond
     d = Developer.find_by_sql("select 'infinity'::timestamp as updated_at")
-    assert d.first.updated_at.infinite?, 'timestamp should be infinite'
+    assert d.first.updated_at.infinite?, "timestamp should be infinite"
 
     d = Developer.find_by_sql("select '-infinity'::timestamp as updated_at")
     time = d.first.updated_at
-    assert time.infinite?, 'timestamp should be infinite'
+    assert time.infinite?, "timestamp should be infinite"
     assert_operator time, :<, 0
   end
 
   def test_save_infinity_and_beyond
-    d = Developer.create!(:name => 'aaron', :updated_at => 1.0 / 0.0)
+    d = Developer.create!(:name => "aaron", :updated_at => 1.0 / 0.0)
     assert_equal(1.0 / 0.0, d.updated_at)
 
-    d = Developer.create!(:name => 'aaron', :updated_at => -1.0 / 0.0)
+    d = Developer.create!(:name => "aaron", :updated_at => -1.0 / 0.0)
     assert_equal(-1.0 / 0.0, d.updated_at)
   end
 
diff --git a/activerecord/test/cases/adapters/postgresql/transaction_test.rb b/activerecord/test/cases/adapters/postgresql/transaction_test.rb
index 8dea92c785..c5164fc1f8 100644
--- a/activerecord/test/cases/adapters/postgresql/transaction_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/transaction_test.rb
@@ -1,21 +1,21 @@
 require "cases/helper"
-require 'support/connection_helper'
+require "support/connection_helper"
 
 module ActiveRecord
   class PostgresqlTransactionTest < ActiveRecord::PostgreSQLTestCase
     self.use_transactional_tests = false
 
     class Sample < ActiveRecord::Base
-      self.table_name = 'samples'
+      self.table_name = "samples"
     end
 
     setup do
       @connection = ActiveRecord::Base.connection
 
       @connection.transaction do
-        @connection.drop_table 'samples', if_exists: true
-        @connection.create_table('samples') do |t|
-          t.integer 'value'
+        @connection.drop_table "samples", if_exists: true
+        @connection.create_table("samples") do |t|
+          t.integer "value"
         end
       end
 
@@ -23,7 +23,7 @@ module ActiveRecord
     end
 
     teardown do
-      @connection.drop_table 'samples', if_exists: true
+      @connection.drop_table "samples", if_exists: true
     end
 
     test "raises SerializationFailure when a serialization failure occurs" do
@@ -89,7 +89,7 @@ module ActiveRecord
 
     def with_warning_suppression
       log_level = @connection.client_min_messages
-      @connection.client_min_messages = 'error'
+      @connection.client_min_messages = "error"
       yield
       @connection.client_min_messages = log_level
     end
diff --git a/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb b/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb
index ea0f0b8fa5..bd45a9daa0 100644
--- a/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb
@@ -1,4 +1,4 @@
-require 'cases/helper'
+require "cases/helper"
 
 class PostgresqlTypeLookupTest < ActiveRecord::PostgreSQLTestCase
   setup do
@@ -9,8 +9,8 @@ class PostgresqlTypeLookupTest < ActiveRecord::PostgreSQLTestCase
     box_array = @connection.type_map.lookup(1020)
     int_array = @connection.type_map.lookup(1007)
 
-    assert_equal ';', box_array.delimiter
-    assert_equal ',', int_array.delimiter
+    assert_equal ";", box_array.delimiter
+    assert_equal ",", int_array.delimiter
   end
 
   test "array types correctly respect registration of subtypes" do
diff --git a/activerecord/test/cases/adapters/postgresql/utils_test.rb b/activerecord/test/cases/adapters/postgresql/utils_test.rb
index 095c1826e5..70f72dd929 100644
--- a/activerecord/test/cases/adapters/postgresql/utils_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/utils_test.rb
@@ -1,5 +1,5 @@
-require 'cases/helper'
-require 'active_record/connection_adapters/postgresql/utils'
+require "cases/helper"
+require "active_record/connection_adapters/postgresql/utils"
 
 class PostgreSQLUtilsTest < ActiveRecord::PostgreSQLTestCase
   Name = ActiveRecord::ConnectionAdapters::PostgreSQL::Name
@@ -7,14 +7,14 @@ class PostgreSQLUtilsTest < ActiveRecord::PostgreSQLTestCase
 
   def test_extract_schema_qualified_name
     {
-      %(table_name)            => [nil,'table_name'],
-      %("table.name")          => [nil,'table.name'],
+      %(table_name)            => [nil,"table_name"],
+      %("table.name")          => [nil,"table.name"],
       %(schema.table_name)     => %w{schema table_name},
       %("schema".table_name)   => %w{schema table_name},
       %(schema."table_name")   => %w{schema table_name},
       %("schema"."table_name") => %w{schema table_name},
-      %("even spaces".table)   => ['even spaces','table'],
-      %(schema."table.name")   => ['schema', 'table.name']
+      %("even spaces".table)   => ["even spaces","table"],
+      %(schema."table.name")   => ["schema", "table.name"]
     }.each do |given, expect|
       assert_equal Name.new(*expect), extract_schema_qualified_name(given)
     end
diff --git a/activerecord/test/cases/adapters/postgresql/uuid_test.rb b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
index 7628075ad2..2052d3851d 100644
--- a/activerecord/test/cases/adapters/postgresql/uuid_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 module PostgresqlUUIDHelper
   def connection
@@ -20,10 +20,10 @@ class PostgresqlUUIDTest < ActiveRecord::PostgreSQLTestCase
   end
 
   setup do
-    enable_extension!('uuid-ossp', connection)
+    enable_extension!("uuid-ossp", connection)
 
     connection.create_table "uuid_data_type" do |t|
-      t.uuid 'guid'
+      t.uuid "guid"
     end
   end
 
@@ -34,13 +34,13 @@ class PostgresqlUUIDTest < ActiveRecord::PostgreSQLTestCase
   def test_change_column_default
     @connection.add_column :uuid_data_type, :thingy, :uuid, null: false, default: "uuid_generate_v1()"
     UUIDType.reset_column_information
-    column = UUIDType.columns_hash['thingy']
+    column = UUIDType.columns_hash["thingy"]
     assert_equal "uuid_generate_v1()", column.default_function
 
     @connection.change_column :uuid_data_type, :thingy, :uuid, null: false, default: "uuid_generate_v4()"
 
     UUIDType.reset_column_information
-    column = UUIDType.columns_hash['thingy']
+    column = UUIDType.columns_hash["thingy"]
     assert_equal "uuid_generate_v4()", column.default_function
   ensure
     UUIDType.reset_column_information
@@ -57,46 +57,46 @@ class PostgresqlUUIDTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_treat_blank_uuid_as_nil
-    UUIDType.create! guid: ''
+    UUIDType.create! guid: ""
     assert_equal(nil, UUIDType.last.guid)
   end
 
   def test_treat_invalid_uuid_as_nil
-    uuid = UUIDType.create! guid: 'foobar'
+    uuid = UUIDType.create! guid: "foobar"
     assert_equal(nil, uuid.guid)
   end
 
   def test_invalid_uuid_dont_modify_before_type_cast
-    uuid = UUIDType.new guid: 'foobar'
-    assert_equal 'foobar', uuid.guid_before_type_cast
+    uuid = UUIDType.new guid: "foobar"
+    assert_equal "foobar", uuid.guid_before_type_cast
   end
 
   def test_acceptable_uuid_regex
     # Valid uuids
-    ['A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11',
-     '{a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11}',
-     'a0eebc999c0b4ef8bb6d6bb9bd380a11',
-     'a0ee-bc99-9c0b-4ef8-bb6d-6bb9-bd38-0a11',
-     '{a0eebc99-9c0b4ef8-bb6d6bb9-bd380a11}',
+    ["A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11",
+     "{a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11}",
+     "a0eebc999c0b4ef8bb6d6bb9bd380a11",
+     "a0ee-bc99-9c0b-4ef8-bb6d-6bb9-bd38-0a11",
+     "{a0eebc99-9c0b4ef8-bb6d6bb9-bd380a11}",
      # The following is not a valid RFC 4122 UUID, but PG doesn't seem to care,
      # so we shouldn't block it either. (Pay attention to "fb6d" – the "f" here
      # is invalid – it must be one of 8, 9, A, B, a, b according to the spec.)
-     '{a0eebc99-9c0b-4ef8-fb6d-6bb9bd380a11}',
+     "{a0eebc99-9c0b-4ef8-fb6d-6bb9bd380a11}",
     ].each do |valid_uuid|
       uuid = UUIDType.new guid: valid_uuid
       assert_not_nil uuid.guid
     end
 
     # Invalid uuids
-    [['A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11'],
+    [["A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11"],
      Hash.new,
      0,
      0.0,
      true,
-     'Z0000C99-9C0B-4EF8-BB6D-6BB9BD380A11',
-     'a0eebc999r0b4ef8ab6d6bb9bd380a11',
-     'a0ee-bc99------4ef8-bb6d-6bb9-bd38-0a11',
-     '{a0eebc99-bb6d6bb9-bd380a11}'].each do |invalid_uuid|
+     "Z0000C99-9C0B-4EF8-BB6D-6BB9BD380A11",
+     "a0eebc999r0b4ef8ab6d6bb9bd380a11",
+     "a0ee-bc99------4ef8-bb6d-6bb9-bd38-0a11",
+     "{a0eebc99-bb6d6bb9-bd380a11}"].each do |invalid_uuid|
       uuid = UUIDType.new guid: invalid_uuid
       assert_nil uuid.guid
     end
@@ -142,13 +142,13 @@ class PostgresqlUUIDGenerationTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
 
   class UUID < ActiveRecord::Base
-    self.table_name = 'pg_uuids'
+    self.table_name = "pg_uuids"
   end
 
   setup do
-    connection.create_table('pg_uuids', id: :uuid, default: 'uuid_generate_v1()') do |t|
-      t.string 'name'
-      t.uuid 'other_uuid', default: 'uuid_generate_v4()'
+    connection.create_table("pg_uuids", id: :uuid, default: "uuid_generate_v1()") do |t|
+      t.string "name"
+      t.uuid "other_uuid", default: "uuid_generate_v4()"
     end
 
     # Create custom PostgreSQL function to generate UUIDs
@@ -160,21 +160,21 @@ class PostgresqlUUIDGenerationTest < ActiveRecord::PostgreSQLTestCase
     SQL
 
     # Create such a table with custom function as default value generator
-    connection.create_table('pg_uuids_2', id: :uuid, default: 'my_uuid_generator()') do |t|
-      t.string 'name'
-      t.uuid 'other_uuid_2', default: 'my_uuid_generator()'
+    connection.create_table("pg_uuids_2", id: :uuid, default: "my_uuid_generator()") do |t|
+      t.string "name"
+      t.uuid "other_uuid_2", default: "my_uuid_generator()"
     end
   end
 
   teardown do
     drop_table "pg_uuids"
-    drop_table 'pg_uuids_2'
-    connection.execute 'DROP FUNCTION IF EXISTS my_uuid_generator();'
+    drop_table "pg_uuids_2"
+    connection.execute "DROP FUNCTION IF EXISTS my_uuid_generator();"
   end
 
   if ActiveRecord::Base.connection.supports_extensions?
     def test_id_is_uuid
-      assert_equal :uuid, UUID.columns_hash['id'].type
+      assert_equal :uuid, UUID.columns_hash["id"].type
       assert UUID.primary_key
     end
 
@@ -190,8 +190,8 @@ class PostgresqlUUIDGenerationTest < ActiveRecord::PostgreSQLTestCase
     end
 
     def test_pk_and_sequence_for_uuid_primary_key
-      pk, seq = connection.pk_and_sequence_for('pg_uuids')
-      assert_equal 'id', pk
+      pk, seq = connection.pk_and_sequence_for("pg_uuids")
+      assert_equal "id", pk
       assert_equal nil, seq
     end
 
@@ -214,9 +214,9 @@ class PostgresqlUUIDTestNilDefault < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
 
   setup do
-    connection.create_table('pg_uuids', id: false) do |t|
+    connection.create_table("pg_uuids", id: false) do |t|
       t.primary_key :id, :uuid, default: nil
-      t.string 'name'
+      t.string "name"
     end
   end
 
@@ -244,23 +244,23 @@ class PostgresqlUUIDTestInverseOf < ActiveRecord::PostgreSQLTestCase
   include PostgresqlUUIDHelper
 
   class UuidPost < ActiveRecord::Base
-    self.table_name = 'pg_uuid_posts'
+    self.table_name = "pg_uuid_posts"
     has_many :uuid_comments, inverse_of: :uuid_post
   end
 
   class UuidComment < ActiveRecord::Base
-    self.table_name = 'pg_uuid_comments'
+    self.table_name = "pg_uuid_comments"
     belongs_to :uuid_post
   end
 
   setup do
     connection.transaction do
-      connection.create_table('pg_uuid_posts', id: :uuid) do |t|
-        t.string 'title'
+      connection.create_table("pg_uuid_posts", id: :uuid) do |t|
+        t.string "title"
       end
-      connection.create_table('pg_uuid_comments', id: :uuid) do |t|
+      connection.create_table("pg_uuid_comments", id: :uuid) do |t|
         t.references :uuid_post, type: :uuid
-        t.string 'content'
+        t.string "content"
       end
     end
   end
diff --git a/activerecord/test/cases/adapters/postgresql/xml_test.rb b/activerecord/test/cases/adapters/postgresql/xml_test.rb
index add32699fa..dc80834b21 100644
--- a/activerecord/test/cases/adapters/postgresql/xml_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/xml_test.rb
@@ -1,28 +1,28 @@
-require 'cases/helper'
-require 'support/schema_dumping_helper'
+require "cases/helper"
+require "support/schema_dumping_helper"
 
 class PostgresqlXMLTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
   class XmlDataType < ActiveRecord::Base
-    self.table_name = 'xml_data_type'
+    self.table_name = "xml_data_type"
   end
 
   def setup
     @connection = ActiveRecord::Base.connection
     begin
       @connection.transaction do
-        @connection.create_table('xml_data_type') do |t|
-          t.xml 'payload'
+        @connection.create_table("xml_data_type") do |t|
+          t.xml "payload"
         end
       end
     rescue ActiveRecord::StatementInvalid
       skip "do not test on PG without xml"
     end
-    @column = XmlDataType.columns_hash['payload']
+    @column = XmlDataType.columns_hash["payload"]
   end
 
   teardown do
-    @connection.drop_table 'xml_data_type', if_exists: true
+    @connection.drop_table "xml_data_type", if_exists: true
   end
 
   def test_column
diff --git a/activerecord/test/cases/adapters/sqlite3/collation_test.rb b/activerecord/test/cases/adapters/sqlite3/collation_test.rb
index 58a9469ce5..28e8f12c18 100644
--- a/activerecord/test/cases/adapters/sqlite3/collation_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/collation_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 class SQLite3CollationTest < ActiveRecord::SQLite3TestCase
   include SchemaDumpingHelper
@@ -7,8 +7,8 @@ class SQLite3CollationTest < ActiveRecord::SQLite3TestCase
   def setup
     @connection = ActiveRecord::Base.connection
     @connection.create_table :collation_table_sqlite3, force: true do |t|
-      t.string :string_nocase, collation: 'NOCASE'
-      t.text :text_rtrim, collation: 'RTRIM'
+      t.string :string_nocase, collation: "NOCASE"
+      t.text :text_rtrim, collation: "RTRIM"
     end
   end
 
@@ -17,32 +17,32 @@ class SQLite3CollationTest < ActiveRecord::SQLite3TestCase
   end
 
   test "string column with collation" do
-    column = @connection.columns(:collation_table_sqlite3).find { |c| c.name == 'string_nocase' }
+    column = @connection.columns(:collation_table_sqlite3).find { |c| c.name == "string_nocase" }
     assert_equal :string, column.type
-    assert_equal 'NOCASE', column.collation
+    assert_equal "NOCASE", column.collation
   end
 
   test "text column with collation" do
-    column = @connection.columns(:collation_table_sqlite3).find { |c| c.name == 'text_rtrim' }
+    column = @connection.columns(:collation_table_sqlite3).find { |c| c.name == "text_rtrim" }
     assert_equal :text, column.type
-    assert_equal 'RTRIM', column.collation
+    assert_equal "RTRIM", column.collation
   end
 
   test "add column with collation" do
-    @connection.add_column :collation_table_sqlite3, :title, :string, collation: 'RTRIM'
+    @connection.add_column :collation_table_sqlite3, :title, :string, collation: "RTRIM"
 
-    column = @connection.columns(:collation_table_sqlite3).find { |c| c.name == 'title' }
+    column = @connection.columns(:collation_table_sqlite3).find { |c| c.name == "title" }
     assert_equal :string, column.type
-    assert_equal 'RTRIM', column.collation
+    assert_equal "RTRIM", column.collation
   end
 
   test "change column with collation" do
     @connection.add_column :collation_table_sqlite3, :description, :string
-    @connection.change_column :collation_table_sqlite3, :description, :text, collation: 'RTRIM'
+    @connection.change_column :collation_table_sqlite3, :description, :text, collation: "RTRIM"
 
-    column = @connection.columns(:collation_table_sqlite3).find { |c| c.name == 'description' }
+    column = @connection.columns(:collation_table_sqlite3).find { |c| c.name == "description" }
     assert_equal :text, column.type
-    assert_equal 'RTRIM', column.collation
+    assert_equal "RTRIM", column.collation
   end
 
   test "schema dump includes collation" do
diff --git a/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb b/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb
index 34e3b2e023..81058064e2 100644
--- a/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb
@@ -10,7 +10,7 @@ class CopyTableTest < ActiveRecord::SQLite3TestCase
     end
   end
 
-  def test_copy_table(from = 'customers', to = 'customers2', options = {})
+  def test_copy_table(from = "customers", to = "customers2", options = {})
     assert_nothing_raised {copy_table(from, to, options)}
     assert_equal row_count(from), row_count(to)
 
@@ -24,39 +24,39 @@ class CopyTableTest < ActiveRecord::SQLite3TestCase
   end
 
   def test_copy_table_renaming_column
-    test_copy_table('customers', 'customers2',
-        :rename => {'name' => 'person_name'}) do |from, to, options|
-      expected = column_values(from, 'name')
-      assert_equal expected, column_values(to, 'person_name')
+    test_copy_table("customers", "customers2",
+        :rename => {"name" => "person_name"}) do |from, to, options|
+      expected = column_values(from, "name")
+      assert_equal expected, column_values(to, "person_name")
       assert expected.any?, "No values in table: #{expected.inspect}"
     end
   end
 
   def test_copy_table_allows_to_pass_options_to_create_table
-    @connection.create_table('blocker_table')
-    test_copy_table('customers', 'blocker_table', force: true)
+    @connection.create_table("blocker_table")
+    test_copy_table("customers", "blocker_table", force: true)
   end
 
   def test_copy_table_with_index
-    test_copy_table('comments', 'comments_with_index') do
-      @connection.add_index('comments_with_index', ['post_id', 'type'])
-      test_copy_table('comments_with_index', 'comments_with_index2') do
-        assert_equal table_indexes_without_name('comments_with_index'),
-                     table_indexes_without_name('comments_with_index2')
+    test_copy_table("comments", "comments_with_index") do
+      @connection.add_index("comments_with_index", ["post_id", "type"])
+      test_copy_table("comments_with_index", "comments_with_index2") do
+        assert_equal table_indexes_without_name("comments_with_index"),
+                     table_indexes_without_name("comments_with_index2")
       end
     end
   end
 
   def test_copy_table_without_primary_key
-    test_copy_table('developers_projects', 'programmers_projects') do
-      assert_nil @connection.primary_key('programmers_projects')
+    test_copy_table("developers_projects", "programmers_projects") do
+      assert_nil @connection.primary_key("programmers_projects")
     end
   end
 
   def test_copy_table_with_id_col_that_is_not_primary_key
-    test_copy_table('goofy_string_id', 'goofy_string_id2') do
-      original_id = @connection.columns('goofy_string_id').detect{|col| col.name == 'id' }
-      copied_id = @connection.columns('goofy_string_id2').detect{|col| col.name == 'id' }
+    test_copy_table("goofy_string_id", "goofy_string_id2") do
+      original_id = @connection.columns("goofy_string_id").detect{|col| col.name == "id" }
+      copied_id = @connection.columns("goofy_string_id2").detect{|col| col.name == "id" }
       assert_equal original_id.type, copied_id.type
       assert_equal original_id.sql_type, copied_id.sql_type
       assert_equal original_id.limit, copied_id.limit
@@ -64,15 +64,15 @@ class CopyTableTest < ActiveRecord::SQLite3TestCase
   end
 
   def test_copy_table_with_unconventional_primary_key
-    test_copy_table('owners', 'owners_unconventional') do
-      original_pk = @connection.primary_key('owners')
-      copied_pk = @connection.primary_key('owners_unconventional')
+    test_copy_table("owners", "owners_unconventional") do
+      original_pk = @connection.primary_key("owners")
+      copied_pk = @connection.primary_key("owners_unconventional")
       assert_equal original_pk, copied_pk
     end
   end
 
   def test_copy_table_with_binary_column
-    test_copy_table 'binaries', 'binaries2'
+    test_copy_table "binaries", "binaries2"
   end
 
 protected
@@ -81,7 +81,7 @@ protected
   end
 
   def column_names(table)
-    @connection.table_structure(table).map {|column| column['name']}
+    @connection.table_structure(table).map {|column| column["name"]}
   end
 
   def column_values(table, column)
@@ -93,6 +93,6 @@ protected
   end
 
   def row_count(table)
-    @connection.select_one("SELECT COUNT(*) AS count FROM #{table}")['count']
+    @connection.select_one("SELECT COUNT(*) AS count FROM #{table}")["count"]
   end
 end
diff --git a/activerecord/test/cases/adapters/sqlite3/explain_test.rb b/activerecord/test/cases/adapters/sqlite3/explain_test.rb
index 4d25bd615d..128acb79cf 100644
--- a/activerecord/test/cases/adapters/sqlite3/explain_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/explain_test.rb
@@ -1,6 +1,6 @@
 require "cases/helper"
-require 'models/developer'
-require 'models/computer'
+require "models/developer"
+require "models/computer"
 
 class SQLite3ExplainTest < ActiveRecord::SQLite3TestCase
   fixtures :developers
diff --git a/activerecord/test/cases/adapters/sqlite3/quoting_test.rb b/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
index fe2425b845..80a37e83ff 100644
--- a/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
@@ -1,7 +1,7 @@
 require "cases/helper"
-require 'bigdecimal'
-require 'yaml'
-require 'securerandom'
+require "bigdecimal"
+require "yaml"
+require "securerandom"
 
 class SQLite3QuotingTest < ActiveRecord::SQLite3TestCase
   def setup
@@ -16,7 +16,7 @@ class SQLite3QuotingTest < ActiveRecord::SQLite3TestCase
   end
 
   def test_type_cast_symbol
-    assert_equal 'foo', @conn.type_cast(:foo)
+    assert_equal "foo", @conn.type_cast(:foo)
   end
 
   def test_type_cast_date
@@ -41,15 +41,15 @@ class SQLite3QuotingTest < ActiveRecord::SQLite3TestCase
   end
 
   def test_type_cast_true
-    assert_equal 't', @conn.type_cast(true)
+    assert_equal "t", @conn.type_cast(true)
   end
 
   def test_type_cast_false
-    assert_equal 'f', @conn.type_cast(false)
+    assert_equal "f", @conn.type_cast(false)
   end
 
   def test_type_cast_bigdecimal
-    bd = BigDecimal.new '10.0'
+    bd = BigDecimal.new "10.0"
     assert_equal bd.to_f, @conn.type_cast(bd)
   end
 
@@ -79,7 +79,7 @@ class SQLite3QuotingTest < ActiveRecord::SQLite3TestCase
   end
 
   def test_quoting_binary_strings
-    value = "hello".encode('ascii-8bit')
+    value = "hello".encode("ascii-8bit")
     type = ActiveRecord::Type::String.new
 
     assert_equal "'hello'", @conn.quote(type.serialize(value))
diff --git a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
index bbc9f978bf..7edec0cb47 100644
--- a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
@@ -1,7 +1,7 @@
 require "cases/helper"
-require 'models/owner'
-require 'tempfile'
-require 'support/ddl_helper'
+require "models/owner"
+require "tempfile"
+require "support/ddl_helper"
 
 module ActiveRecord
   module ConnectionAdapters
@@ -14,22 +14,22 @@ module ActiveRecord
       end
 
       def setup
-        @conn = Base.sqlite3_connection database: ':memory:',
-                                        adapter: 'sqlite3',
+        @conn = Base.sqlite3_connection database: ":memory:",
+                                        adapter: "sqlite3",
                                         timeout: 100
       end
 
       def test_bad_connection
         assert_raise ActiveRecord::NoDatabaseError do
           connection = ActiveRecord::Base.sqlite3_connection(adapter: "sqlite3", database: "/tmp/should/_not/_exist/-cinco-dog.db")
-          connection.drop_table 'ex', if_exists: true
+          connection.drop_table "ex", if_exists: true
         end
       end
 
       unless in_memory_db?
         def test_connect_with_url
           original_connection = ActiveRecord::Base.remove_connection
-          tf = Tempfile.open 'whatever'
+          tf = Tempfile.open "whatever"
           url = "sqlite3:#{tf.path}"
           ActiveRecord::Base.establish_connection(url)
           assert ActiveRecord::Base.connection
@@ -51,7 +51,7 @@ module ActiveRecord
 
       def test_valid_column
         with_example_table do
-          column = @conn.columns('ex').find { |col| col.name == 'id' }
+          column = @conn.columns("ex").find { |col| col.name == "id" }
           assert @conn.valid_type?(column.type)
         end
       end
@@ -66,9 +66,9 @@ module ActiveRecord
       end
 
       def test_column_types
-        owner = Owner.create!(name: "hello".encode('ascii-8bit'))
+        owner = Owner.create!(name: "hello".encode("ascii-8bit"))
         owner.reload
-        select = Owner.columns.map { |c| "typeof(#{c.name})" }.join ', '
+        select = Owner.columns.map { |c| "typeof(#{c.name})" }.join ", "
         result = Owner.connection.exec_query <<-esql
           SELECT #{select}
           FROM   #{Owner.table_name}
@@ -83,10 +83,10 @@ module ActiveRecord
       def test_exec_insert
         with_example_table do
           vals = [Relation::QueryAttribute.new("number", 10, Type::Value.new)]
-          @conn.exec_insert('insert into ex (number) VALUES (?)', 'SQL', vals)
+          @conn.exec_insert("insert into ex (number) VALUES (?)", "SQL", vals)
 
           result = @conn.exec_query(
-            'select number from ex where number = ?', 'SQL', vals)
+            "select number from ex where number = ?", "SQL", vals)
 
           assert_equal 1, result.rows.length
           assert_equal 10, result.rows.first.first
@@ -94,8 +94,8 @@ module ActiveRecord
       end
 
       def test_primary_key_returns_nil_for_no_pk
-        with_example_table 'id int, data string' do
-          assert_nil @conn.primary_key('ex')
+        with_example_table "id int, data string" do
+          assert_nil @conn.primary_key("ex")
         end
       end
 
@@ -107,69 +107,69 @@ module ActiveRecord
 
       def test_bad_timeout
         assert_raises(TypeError) do
-          Base.sqlite3_connection database: ':memory:',
-                                  adapter: 'sqlite3',
-                                  timeout: 'usa'
+          Base.sqlite3_connection database: ":memory:",
+                                  adapter: "sqlite3",
+                                  timeout: "usa"
         end
       end
 
       # connection is OK with a nil timeout
       def test_nil_timeout
-        conn = Base.sqlite3_connection database: ':memory:',
-                                       adapter: 'sqlite3',
+        conn = Base.sqlite3_connection database: ":memory:",
+                                       adapter: "sqlite3",
                                        timeout: nil
-        assert conn, 'made a connection'
+        assert conn, "made a connection"
       end
 
       def test_connect
-        assert @conn, 'should have connection'
+        assert @conn, "should have connection"
       end
 
       # sqlite3 defaults to UTF-8 encoding
       def test_encoding
-        assert_equal 'UTF-8', @conn.encoding
+        assert_equal "UTF-8", @conn.encoding
       end
 
       def test_exec_no_binds
-        with_example_table 'id int, data string' do
-          result = @conn.exec_query('SELECT id, data FROM ex')
+        with_example_table "id int, data string" do
+          result = @conn.exec_query("SELECT id, data FROM ex")
           assert_equal 0, result.rows.length
           assert_equal 2, result.columns.length
           assert_equal %w{ id data }, result.columns
 
           @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
-          result = @conn.exec_query('SELECT id, data FROM ex')
+          result = @conn.exec_query("SELECT id, data FROM ex")
           assert_equal 1, result.rows.length
           assert_equal 2, result.columns.length
 
-          assert_equal [[1, 'foo']], result.rows
+          assert_equal [[1, "foo"]], result.rows
         end
       end
 
       def test_exec_query_with_binds
-        with_example_table 'id int, data string' do
+        with_example_table "id int, data string" do
           @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
           result = @conn.exec_query(
-            'SELECT id, data FROM ex WHERE id = ?', nil, [Relation::QueryAttribute.new(nil, 1, Type::Value.new)])
+            "SELECT id, data FROM ex WHERE id = ?", nil, [Relation::QueryAttribute.new(nil, 1, Type::Value.new)])
 
           assert_equal 1, result.rows.length
           assert_equal 2, result.columns.length
 
-          assert_equal [[1, 'foo']], result.rows
+          assert_equal [[1, "foo"]], result.rows
         end
       end
 
       def test_exec_query_typecasts_bind_vals
-        with_example_table 'id int, data string' do
+        with_example_table "id int, data string" do
           @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
 
           result = @conn.exec_query(
-            'SELECT id, data FROM ex WHERE id = ?', nil, [Relation::QueryAttribute.new("id", "1-fuu", Type::Integer.new)])
+            "SELECT id, data FROM ex WHERE id = ?", nil, [Relation::QueryAttribute.new("id", "1-fuu", Type::Integer.new)])
 
           assert_equal 1, result.rows.length
           assert_equal 2, result.columns.length
 
-          assert_equal [[1, 'foo']], result.rows
+          assert_equal [[1, "foo"]], result.rows
         end
       end
 
@@ -182,15 +182,15 @@ module ActiveRecord
           )
         eosql
         str = "\x80".force_encoding("ASCII-8BIT")
-        binary = DualEncoding.new name: 'いただきます！', data: str
+        binary = DualEncoding.new name: "いただきます！", data: str
         binary.save!
         assert_equal str, binary.data
       ensure
-        DualEncoding.connection.drop_table 'dual_encodings', if_exists: true
+        DualEncoding.connection.drop_table "dual_encodings", if_exists: true
       end
 
       def test_type_cast_should_not_mutate_encoding
-        name  = 'hello'.force_encoding(Encoding::ASCII_8BIT)
+        name  = "hello".force_encoding(Encoding::ASCII_8BIT)
         Owner.create(name: name)
         assert_equal Encoding::ASCII_8BIT, name.encoding
       ensure
@@ -204,8 +204,8 @@ module ActiveRecord
           assert_equal 1, records.length
 
           record = records.first
-          assert_equal 10, record['number']
-          assert_equal 1, record['id']
+          assert_equal 10, record["number"]
+          assert_equal 1, record["id"]
         end
       end
 
@@ -226,7 +226,7 @@ module ActiveRecord
       def test_insert_id_value_returned
         with_example_table do
           sql = "INSERT INTO ex (number) VALUES (10)"
-          idval = 'vuvuzela'
+          idval = "vuvuzela"
           id = @conn.insert(sql, nil, nil, idval)
           assert_equal idval, id
         end
@@ -237,7 +237,7 @@ module ActiveRecord
           2.times do |i|
             @conn.create "INSERT INTO ex (number) VALUES (#{i})"
           end
-          rows = @conn.select_rows 'select number, id from ex'
+          rows = @conn.select_rows "select number, id from ex"
           assert_equal [[0, 1], [1, 2]], rows
         end
       end
@@ -254,7 +254,7 @@ module ActiveRecord
 
       def test_transaction
         with_example_table do
-          count_sql = 'select count(*) from ex'
+          count_sql = "select count(*) from ex"
 
           @conn.begin_db_transaction
           @conn.create "INSERT INTO ex (number) VALUES (10)"
@@ -268,7 +268,7 @@ module ActiveRecord
       def test_tables
         with_example_table do
           ActiveSupport::Deprecation.silence { assert_equal %w{ ex }, @conn.tables }
-          with_example_table 'id integer PRIMARY KEY AUTOINCREMENT, number integer', 'people' do
+          with_example_table "id integer PRIMARY KEY AUTOINCREMENT, number integer", "people" do
             ActiveSupport::Deprecation.silence { assert_equal %w{ ex people }.sort, @conn.tables.sort }
           end
         end
@@ -279,17 +279,17 @@ module ActiveRecord
           SELECT name FROM sqlite_master
           WHERE type IN ('table','view') AND name <> 'sqlite_sequence'
         SQL
-        assert_logged [[sql.squish, 'SCHEMA', []]] do
+        assert_logged [[sql.squish, "SCHEMA", []]] do
           ActiveSupport::Deprecation.silence do
-            @conn.tables('hello')
+            @conn.tables("hello")
           end
         end
       end
 
       def test_indexes_logs_name
         with_example_table do
-          assert_logged [["PRAGMA index_list(\"ex\")", 'SCHEMA', []]] do
-            @conn.indexes('ex', 'hello')
+          assert_logged [["PRAGMA index_list(\"ex\")", "SCHEMA", []]] do
+            @conn.indexes("ex", "hello")
           end
         end
       end
@@ -300,9 +300,9 @@ module ActiveRecord
             SELECT name FROM sqlite_master
             WHERE type IN ('table','view') AND name <> 'sqlite_sequence' AND name = 'ex'
           SQL
-          assert_logged [[sql.squish, 'SCHEMA', []]] do
+          assert_logged [[sql.squish, "SCHEMA", []]] do
             ActiveSupport::Deprecation.silence do
-              assert @conn.table_exists?('ex')
+              assert @conn.table_exists?("ex")
             end
           end
         end
@@ -310,7 +310,7 @@ module ActiveRecord
 
       def test_columns
         with_example_table do
-          columns = @conn.columns('ex').sort_by(&:name)
+          columns = @conn.columns("ex").sort_by(&:name)
           assert_equal 2, columns.length
           assert_equal %w{ id number }.sort, columns.map(&:name)
           assert_equal [nil, nil], columns.map(&:default)
@@ -319,17 +319,17 @@ module ActiveRecord
       end
 
       def test_columns_with_default
-        with_example_table 'id integer PRIMARY KEY AUTOINCREMENT, number integer default 10' do
-          column = @conn.columns('ex').find { |x|
-            x.name == 'number'
+        with_example_table "id integer PRIMARY KEY AUTOINCREMENT, number integer default 10" do
+          column = @conn.columns("ex").find { |x|
+            x.name == "number"
           }
-          assert_equal '10', column.default
+          assert_equal "10", column.default
         end
       end
 
       def test_columns_with_not_null
-        with_example_table 'id integer PRIMARY KEY AUTOINCREMENT, number integer not null' do
-          column = @conn.columns('ex').find { |x| x.name == 'number' }
+        with_example_table "id integer PRIMARY KEY AUTOINCREMENT, number integer not null" do
+          column = @conn.columns("ex").find { |x| x.name == "number" }
           assert_not column.null, "column should not be null"
         end
       end
@@ -337,59 +337,59 @@ module ActiveRecord
       def test_indexes_logs
         with_example_table do
           assert_logged [["PRAGMA index_list(\"ex\")", "SCHEMA", []]] do
-            @conn.indexes('ex')
+            @conn.indexes("ex")
           end
         end
       end
 
       def test_no_indexes
-        assert_equal [], @conn.indexes('items')
+        assert_equal [], @conn.indexes("items")
       end
 
       def test_index
         with_example_table do
-          @conn.add_index 'ex', 'id', unique: true, name: 'fun'
-          index = @conn.indexes('ex').find { |idx| idx.name == 'fun' }
+          @conn.add_index "ex", "id", unique: true, name: "fun"
+          index = @conn.indexes("ex").find { |idx| idx.name == "fun" }
 
-          assert_equal 'ex', index.table
-          assert index.unique, 'index is unique'
-          assert_equal ['id'], index.columns
+          assert_equal "ex", index.table
+          assert index.unique, "index is unique"
+          assert_equal ["id"], index.columns
         end
       end
 
       def test_non_unique_index
         with_example_table do
-          @conn.add_index 'ex', 'id', name: 'fun'
-          index = @conn.indexes('ex').find { |idx| idx.name == 'fun' }
-          assert_not index.unique, 'index is not unique'
+          @conn.add_index "ex", "id", name: "fun"
+          index = @conn.indexes("ex").find { |idx| idx.name == "fun" }
+          assert_not index.unique, "index is not unique"
         end
       end
 
       def test_compound_index
         with_example_table do
-          @conn.add_index 'ex', %w{ id number }, name: 'fun'
-          index = @conn.indexes('ex').find { |idx| idx.name == 'fun' }
+          @conn.add_index "ex", %w{ id number }, name: "fun"
+          index = @conn.indexes("ex").find { |idx| idx.name == "fun" }
           assert_equal %w{ id number }.sort, index.columns.sort
         end
       end
 
       def test_primary_key
         with_example_table do
-          assert_equal 'id', @conn.primary_key('ex')
-          with_example_table 'internet integer PRIMARY KEY AUTOINCREMENT, number integer not null', 'foos' do
-            assert_equal 'internet', @conn.primary_key('foos')
+          assert_equal "id", @conn.primary_key("ex")
+          with_example_table "internet integer PRIMARY KEY AUTOINCREMENT, number integer not null", "foos" do
+            assert_equal "internet", @conn.primary_key("foos")
           end
         end
       end
 
       def test_no_primary_key
-        with_example_table 'number integer not null' do
-          assert_nil @conn.primary_key('ex')
+        with_example_table "number integer not null" do
+          assert_nil @conn.primary_key("ex")
         end
       end
 
       def test_supports_extensions
-        assert_not @conn.supports_extensions?, 'does not support extensions'
+        assert_not @conn.supports_extensions?, "does not support extensions"
       end
 
       def test_respond_to_enable_extension
@@ -402,15 +402,15 @@ module ActiveRecord
 
       def test_statement_closed
         db = ::SQLite3::Database.new(ActiveRecord::Base.
-                                   configurations['arunit']['database'])
+                                   configurations["arunit"]["database"])
         statement = ::SQLite3::Statement.new(db,
-                                           'CREATE TABLE statement_test (number integer not null)')
-        statement.stub(:step, ->{ raise ::SQLite3::BusyException.new('busy') }) do
+                                           "CREATE TABLE statement_test (number integer not null)")
+        statement.stub(:step, ->{ raise ::SQLite3::BusyException.new("busy") }) do
           assert_called(statement, :columns, returns: []) do
             assert_called(statement, :close) do
               ::SQLite3::Statement.stub(:new, statement) do
                 assert_raises ActiveRecord::StatementInvalid do
-                  @conn.exec_query 'select * from statement_test'
+                  @conn.exec_query "select * from statement_test"
                 end
               end
             end
@@ -422,14 +422,14 @@ module ActiveRecord
 
       def assert_logged logs
         subscriber = SQLSubscriber.new
-        subscription = ActiveSupport::Notifications.subscribe('sql.active_record', subscriber)
+        subscription = ActiveSupport::Notifications.subscribe("sql.active_record", subscriber)
         yield
         assert_equal logs, subscriber.logged
       ensure
         ActiveSupport::Notifications.unsubscribe(subscription)
       end
 
-      def with_example_table(definition = nil, table_name = 'ex', &block)
+      def with_example_table(definition = nil, table_name = "ex", &block)
         definition ||= <<-SQL
           id integer PRIMARY KEY AUTOINCREMENT,
           number integer
diff --git a/activerecord/test/cases/adapters/sqlite3/sqlite3_create_folder_test.rb b/activerecord/test/cases/adapters/sqlite3/sqlite3_create_folder_test.rb
index 9b675b804b..6b1b266372 100644
--- a/activerecord/test/cases/adapters/sqlite3/sqlite3_create_folder_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/sqlite3_create_folder_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'models/owner'
+require "models/owner"
 
 module ActiveRecord
   module ConnectionAdapters
@@ -9,11 +9,11 @@ module ActiveRecord
           begin
             dir = Pathname.new(dir)
             @conn = Base.sqlite3_connection :database => dir.join("db/foo.sqlite3"),
-                                 :adapter => 'sqlite3',
+                                 :adapter => "sqlite3",
                                  :timeout => 100
 
-            assert Dir.exist? dir.join('db')
-            assert File.exist? dir.join('db/foo.sqlite3')
+            assert Dir.exist? dir.join("db")
+            assert File.exist? dir.join("db/foo.sqlite3")
           ensure
             @conn.disconnect! if @conn
           end
diff --git a/activerecord/test/cases/adapters/sqlite3/statement_pool_test.rb b/activerecord/test/cases/adapters/sqlite3/statement_pool_test.rb
index 24cc6875ab..aebcce3691 100644
--- a/activerecord/test/cases/adapters/sqlite3/statement_pool_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/statement_pool_test.rb
@@ -1,20 +1,20 @@
-require 'cases/helper'
+require "cases/helper"
 
 class SQLite3StatementPoolTest < ActiveRecord::SQLite3TestCase
   if Process.respond_to?(:fork)
     def test_cache_is_per_pid
 
       cache = ActiveRecord::ConnectionAdapters::SQLite3Adapter::StatementPool.new(10)
-      cache['foo'] = 'bar'
-      assert_equal 'bar', cache['foo']
+      cache["foo"] = "bar"
+      assert_equal "bar", cache["foo"]
 
       pid = fork {
-        lookup = cache['foo'];
+        lookup = cache["foo"];
         exit!(!lookup)
       }
 
       Process.waitpid pid
-      assert $?.success?, 'process should exit successfully'
+      assert $?.success?, "process should exit successfully"
     end
   end
 end
diff --git a/activerecord/test/cases/aggregations_test.rb b/activerecord/test/cases/aggregations_test.rb
index 4e865264c7..1daa0896ca 100644
--- a/activerecord/test/cases/aggregations_test.rb
+++ b/activerecord/test/cases/aggregations_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'models/customer'
+require "models/customer"
 
 class AggregationsTest < ActiveRecord::TestCase
   fixtures :customers
@@ -51,17 +51,17 @@ class AggregationsTest < ActiveRecord::TestCase
 
     Customer.update_all("gps_location = '24x113'")
     customers(:david).reload
-    assert_equal '24x113', customers(:david)['gps_location']
+    assert_equal "24x113", customers(:david)["gps_location"]
 
-    assert_equal GpsLocation.new('24x113'), customers(:david).gps_location
+    assert_equal GpsLocation.new("24x113"), customers(:david).gps_location
   end
 
   def test_gps_equality
-    assert_equal GpsLocation.new('39x110'), GpsLocation.new('39x110')
+    assert_equal GpsLocation.new("39x110"), GpsLocation.new("39x110")
   end
 
   def test_gps_inequality
-    assert_not_equal GpsLocation.new('39x110'), GpsLocation.new('39x111')
+    assert_not_equal GpsLocation.new("39x110"), GpsLocation.new("39x111")
   end
 
   def test_allow_nil_gps_is_nil
@@ -102,7 +102,7 @@ class AggregationsTest < ActiveRecord::TestCase
   end
 
   def test_nil_assignment_results_in_nil
-    customers(:david).gps_location = GpsLocation.new('39x111')
+    customers(:david).gps_location = GpsLocation.new("39x111")
     assert_not_nil customers(:david).gps_location
     customers(:david).gps_location = nil
     assert_nil customers(:david).gps_location
@@ -129,13 +129,13 @@ class AggregationsTest < ActiveRecord::TestCase
   end
 
   def test_custom_constructor
-    assert_equal 'Barney GUMBLE', customers(:barney).fullname.to_s
+    assert_equal "Barney GUMBLE", customers(:barney).fullname.to_s
     assert_kind_of Fullname, customers(:barney).fullname
   end
 
   def test_custom_converter
-    customers(:barney).fullname = 'Barnoit Gumbleau'
-    assert_equal 'Barnoit GUMBLEAU', customers(:barney).fullname.to_s
+    customers(:barney).fullname = "Barnoit Gumbleau"
+    assert_equal "Barnoit GUMBLEAU", customers(:barney).fullname.to_s
     assert_kind_of Fullname, customers(:barney).fullname
   end
 
@@ -158,7 +158,7 @@ class OverridingAggregationsTest < ActiveRecord::TestCase
   end
 
   class DifferentPerson < Person
-    composed_of :composed_of, :class_name => 'DifferentName', :mapping => %w(different_person_first_name first_name)
+    composed_of :composed_of, :class_name => "DifferentName", :mapping => %w(different_person_first_name first_name)
   end
 
   def test_composed_of_aggregation_redefinition_reflections_should_differ_and_not_inherited
diff --git a/activerecord/test/cases/ar_schema_test.rb b/activerecord/test/cases/ar_schema_test.rb
index 9c99689c1e..37f7a01978 100644
--- a/activerecord/test/cases/ar_schema_test.rb
+++ b/activerecord/test/cases/ar_schema_test.rb
@@ -100,8 +100,8 @@ if ActiveRecord::Base.connection.supports_migrations?
         end
       end
 
-      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'created_at' }.null
-      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'updated_at' }.null
+      assert !@connection.columns(:has_timestamps).find { |c| c.name == "created_at" }.null
+      assert !@connection.columns(:has_timestamps).find { |c| c.name == "updated_at" }.null
     end
 
     def test_timestamps_without_null_set_null_to_false_on_change_table
@@ -113,8 +113,8 @@ if ActiveRecord::Base.connection.supports_migrations?
         end
       end
 
-      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'created_at' }.null
-      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'updated_at' }.null
+      assert !@connection.columns(:has_timestamps).find { |c| c.name == "created_at" }.null
+      assert !@connection.columns(:has_timestamps).find { |c| c.name == "updated_at" }.null
     end
 
     def test_timestamps_without_null_set_null_to_false_on_add_timestamps
@@ -123,8 +123,8 @@ if ActiveRecord::Base.connection.supports_migrations?
         add_timestamps :has_timestamps, default: Time.now
       end
 
-      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'created_at' }.null
-      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'updated_at' }.null
+      assert !@connection.columns(:has_timestamps).find { |c| c.name == "created_at" }.null
+      assert !@connection.columns(:has_timestamps).find { |c| c.name == "updated_at" }.null
     end
   end
 end
diff --git a/activerecord/test/cases/associations/association_scope_test.rb b/activerecord/test/cases/associations/association_scope_test.rb
index 472e270f8c..c322333f6d 100644
--- a/activerecord/test/cases/associations/association_scope_test.rb
+++ b/activerecord/test/cases/associations/association_scope_test.rb
@@ -1,11 +1,11 @@
-require 'cases/helper'
-require 'models/post'
-require 'models/author'
+require "cases/helper"
+require "models/post"
+require "models/author"
 
 module ActiveRecord
   module Associations
     class AssociationScopeTest < ActiveRecord::TestCase
-      test 'does not duplicate conditions' do
+      test "does not duplicate conditions" do
         scope = AssociationScope.scope(Author.new.association(:welcome_posts),
                                         Author.connection)
         binds = scope.where_clause.binds.map(&:value)
diff --git a/activerecord/test/cases/associations/belongs_to_associations_test.rb b/activerecord/test/cases/associations/belongs_to_associations_test.rb
index 9dadd114a1..20c3b72b41 100644
--- a/activerecord/test/cases/associations/belongs_to_associations_test.rb
+++ b/activerecord/test/cases/associations/belongs_to_associations_test.rb
@@ -1,28 +1,28 @@
-require 'cases/helper'
-require 'models/developer'
-require 'models/project'
-require 'models/company'
-require 'models/topic'
-require 'models/reply'
-require 'models/computer'
-require 'models/post'
-require 'models/author'
-require 'models/tag'
-require 'models/tagging'
-require 'models/comment'
-require 'models/sponsor'
-require 'models/member'
-require 'models/essay'
-require 'models/toy'
-require 'models/invoice'
-require 'models/line_item'
-require 'models/column'
-require 'models/record'
-require 'models/admin'
-require 'models/admin/user'
-require 'models/ship'
-require 'models/treasure'
-require 'models/parrot'
+require "cases/helper"
+require "models/developer"
+require "models/project"
+require "models/company"
+require "models/topic"
+require "models/reply"
+require "models/computer"
+require "models/post"
+require "models/author"
+require "models/tag"
+require "models/tagging"
+require "models/comment"
+require "models/sponsor"
+require "models/member"
+require "models/essay"
+require "models/toy"
+require "models/invoice"
+require "models/line_item"
+require "models/column"
+require "models/record"
+require "models/admin"
+require "models/admin/user"
+require "models/ship"
+require "models/treasure"
+require "models/parrot"
 
 class BelongsToAssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :companies, :developers, :projects, :topics,
@@ -43,7 +43,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     ActiveRecord::SQLCounter.clear_log
     Client.find(3).firm
   ensure
-    assert ActiveRecord::SQLCounter.log_all.all? { |sql| /order by/i !~ sql }, 'ORDER BY was used in the query'
+    assert ActiveRecord::SQLCounter.log_all.all? { |sql| /order by/i !~ sql }, "ORDER BY was used in the query"
   end
 
   def test_belongs_to_with_primary_key
@@ -120,12 +120,12 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     counter = 0
 
     comments = Class.new(ActiveRecord::Base) {
-      self.table_name = 'comments'
-      self.inheritance_column = 'not_there'
+      self.table_name = "comments"
+      self.inheritance_column = "not_there"
 
       posts = Class.new(ActiveRecord::Base) {
-        self.table_name = 'posts'
-        self.inheritance_column = 'not_there'
+        self.table_name = "posts"
+        self.inheritance_column = "not_there"
 
         default_scope -> {
           counter += 1
@@ -166,7 +166,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     Admin.const_set "Region", Class.new(ActiveRecord::Base)
 
     e = assert_raise(ActiveRecord::AssociationTypeMismatch) {
-      Admin::RegionalUser.new(region: 'wrong value')
+      Admin::RegionalUser.new(region: "wrong value")
     }
     assert_match(/^Region\([^)]+\) expected, got "wrong value" which is an instance of String\([^)]+\)$/, e.message)
   ensure
@@ -325,7 +325,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     sponsor.association(:sponsorable).reload
     assert_nil sponsor.sponsorable
 
-    sponsor.sponsorable_type = '' # the column doesn't have to be declared NOT NULL
+    sponsor.sponsorable_type = "" # the column doesn't have to be declared NOT NULL
     assert_nil sponsor.association(:sponsorable).send(:klass)
     sponsor.association(:sponsorable).reload
     assert_nil sponsor.sponsorable
@@ -352,10 +352,10 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   def test_belongs_to_without_counter_cache_option
     # Ship has a conventionally named `treasures_count` column, but the counter_cache
     # option is not given on the association.
-    ship = Ship.create(name: 'Countless')
+    ship = Ship.create(name: "Countless")
 
     assert_no_difference lambda { ship.reload.treasures_count }, "treasures_count should not be changed unless counter_cache is given on the relation" do
-      treasure = Treasure.new(name: 'Gold', ship: ship)
+      treasure = Treasure.new(name: "Gold", ship: ship)
       treasure.save
     end
 
@@ -820,7 +820,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_nil essay.writer_type
 
     essay.writer_id = 1
-    essay.writer_type = 'Author'
+    essay.writer_type = "Author"
 
     essay.writer = nil
     assert_nil essay.writer_id
@@ -872,11 +872,11 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     error = assert_raise ArgumentError do
       Class.new(Author).belongs_to :special_author_address, :dependent => :nullify
     end
-    assert_equal error.message, 'The :dependent option must be one of [:destroy, :delete], but is :nullify'
+    assert_equal error.message, "The :dependent option must be one of [:destroy, :delete], but is :nullify"
   end
 
   def test_attributes_are_being_set_when_initialized_from_belongs_to_association_with_where_clause
-    new_firm = accounts(:signals37).build_firm(:name => 'Apple')
+    new_firm = accounts(:signals37).build_firm(:name => "Apple")
     assert_equal new_firm.name, "Apple"
   end
 
@@ -930,7 +930,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert !proxy.stale_target?
     assert_equal members(:groucho), sponsor.sponsorable
 
-    sponsor.sponsorable_type = 'Firm'
+    sponsor.sponsorable_type = "Firm"
 
     assert proxy.stale_target?
     assert_equal companies(:first_firm), sponsor.sponsorable
@@ -955,7 +955,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     comment = comments(:greetings)
 
     assert_difference lambda { post.reload.tags_count }, -1 do
-      assert_difference 'comment.reload.tags_count', +1 do
+      assert_difference "comment.reload.tags_count", +1 do
         tagging.taggable = comment
       end
     end
@@ -1002,24 +1002,24 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_build_with_block
-    client = Client.create(:name => 'Client Company')
+    client = Client.create(:name => "Client Company")
 
-    firm = client.build_firm{ |f| f.name = 'Agency Company' }
-    assert_equal 'Agency Company', firm.name
+    firm = client.build_firm{ |f| f.name = "Agency Company" }
+    assert_equal "Agency Company", firm.name
   end
 
   def test_create_with_block
-    client = Client.create(:name => 'Client Company')
+    client = Client.create(:name => "Client Company")
 
-    firm = client.create_firm{ |f| f.name = 'Agency Company' }
-    assert_equal 'Agency Company', firm.name
+    firm = client.create_firm{ |f| f.name = "Agency Company" }
+    assert_equal "Agency Company", firm.name
   end
 
   def test_create_bang_with_block
-    client = Client.create(:name => 'Client Company')
+    client = Client.create(:name => "Client Company")
 
-    firm = client.create_firm!{ |f| f.name = 'Agency Company' }
-    assert_equal 'Agency Company', firm.name
+    firm = client.create_firm!{ |f| f.name = "Agency Company" }
+    assert_equal "Agency Company", firm.name
   end
 
   def test_should_set_foreign_key_on_create_association
@@ -1086,8 +1086,8 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal post.author_id, author2.id
   end
 
-  test 'dangerous association name raises ArgumentError' do
-    [:errors, 'errors', :save, 'save'].each do |name|
+  test "dangerous association name raises ArgumentError" do
+    [:errors, "errors", :save, "save"].each do |name|
       assert_raises(ArgumentError, "Association #{name} should not be allowed") do
         Class.new(ActiveRecord::Base) do
           belongs_to name
@@ -1096,7 +1096,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'belongs_to works with model called Record' do
+  test "belongs_to works with model called Record" do
     record = Record.create!
     Column.create! record: record
     assert_equal 1, Column.count
diff --git a/activerecord/test/cases/associations/bidirectional_destroy_dependencies_test.rb b/activerecord/test/cases/associations/bidirectional_destroy_dependencies_test.rb
index 2b867965ba..8a0e041864 100644
--- a/activerecord/test/cases/associations/bidirectional_destroy_dependencies_test.rb
+++ b/activerecord/test/cases/associations/bidirectional_destroy_dependencies_test.rb
@@ -1,5 +1,5 @@
-require 'cases/helper'
-require 'models/content'
+require "cases/helper"
+require "models/content"
 
 class BidirectionalDestroyDependenciesTest < ActiveRecord::TestCase
   fixtures :content, :content_positions
diff --git a/activerecord/test/cases/associations/callbacks_test.rb b/activerecord/test/cases/associations/callbacks_test.rb
index a4298a25a6..fd35f68d50 100644
--- a/activerecord/test/cases/associations/callbacks_test.rb
+++ b/activerecord/test/cases/associations/callbacks_test.rb
@@ -1,10 +1,10 @@
 require "cases/helper"
-require 'models/post'
-require 'models/author'
-require 'models/project'
-require 'models/developer'
-require 'models/computer'
-require 'models/company'
+require "models/post"
+require "models/author"
+require "models/project"
+require "models/developer"
+require "models/computer"
+require "models/company"
 
 class AssociationCallbacksTest < ActiveRecord::TestCase
   fixtures :posts, :authors, :projects, :developers
@@ -115,7 +115,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
       }
     end
     rec = klass.create!
-    alice = Developer.new(:name => 'alice')
+    alice = Developer.new(:name => "alice")
     rec.developers_with_callbacks << alice
     assert_equal alice, dev
     assert_not_nil new_dev
@@ -126,14 +126,14 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
   def test_has_and_belongs_to_many_after_add_called_after_save
     ar = projects(:active_record)
     assert ar.developers_log.empty?
-    alice = Developer.new(:name => 'alice')
+    alice = Developer.new(:name => "alice")
     ar.developers_with_callbacks << alice
     assert_equal"after_adding#{alice.id}", ar.developers_log.last
 
-    bob = ar.developers_with_callbacks.create(:name => 'bob')
+    bob = ar.developers_with_callbacks.create(:name => "bob")
     assert_equal "after_adding#{bob.id}", ar.developers_log.last
 
-    ar.developers_with_callbacks.build(:name => 'charlie')
+    ar.developers_with_callbacks.build(:name => "charlie")
     assert_equal "after_adding<new>", ar.developers_log.last
   end
 
diff --git a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
index 51d8e0523e..0a60de011e 100644
--- a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
+++ b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
@@ -1,15 +1,15 @@
 require "cases/helper"
-require 'models/post'
-require 'models/comment'
-require 'models/author'
-require 'models/categorization'
-require 'models/category'
-require 'models/company'
-require 'models/topic'
-require 'models/reply'
-require 'models/person'
-require 'models/vertex'
-require 'models/edge'
+require "models/post"
+require "models/comment"
+require "models/author"
+require "models/categorization"
+require "models/category"
+require "models/company"
+require "models/topic"
+require "models/reply"
+require "models/person"
+require "models/vertex"
+require "models/edge"
 
 class CascadedEagerLoadingTest < ActiveRecord::TestCase
   fixtures :authors, :mixins, :companies, :posts, :topics, :accounts, :comments,
@@ -44,9 +44,9 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
 
   def test_eager_association_loading_grafts_stashed_associations_to_correct_parent
     assert_nothing_raised do
-      Person.eager_load(:primary_contact => :primary_contact).where('primary_contacts_people_2.first_name = ?', 'Susan').order('people.id').to_a
+      Person.eager_load(:primary_contact => :primary_contact).where("primary_contacts_people_2.first_name = ?", "Susan").order("people.id").to_a
     end
-    assert_equal people(:michael), Person.eager_load(:primary_contact => :primary_contact).where('primary_contacts_people_2.first_name = ?', 'Susan').order('people.id').first
+    assert_equal people(:michael), Person.eager_load(:primary_contact => :primary_contact).where("primary_contacts_people_2.first_name = ?", "Susan").order("people.id").first
   end
 
   def test_cascaded_eager_association_loading_with_join_for_count
@@ -112,7 +112,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_has_many_sti
-    topics = Topic.all.merge!(:includes => :replies, :order => 'topics.id').to_a
+    topics = Topic.all.merge!(:includes => :replies, :order => "topics.id").to_a
     first, second, = topics(:first).replies.size, topics(:second).replies.size
     assert_no_queries do
       assert_equal first, topics[0].replies.size
@@ -125,7 +125,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
     silly.parent_id = 1
     assert silly.save
 
-    topics = Topic.all.merge!(:includes => :replies, :order => ['topics.id', 'replies_topics.id']).to_a
+    topics = Topic.all.merge!(:includes => :replies, :order => ["topics.id", "replies_topics.id"]).to_a
     assert_no_queries do
       assert_equal 2, topics[0].replies.size
       assert_equal 0, topics[1].replies.size
@@ -133,14 +133,14 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_belongs_to_sti
-    replies = Reply.all.merge!(:includes => :topic, :order => 'topics.id').to_a
+    replies = Reply.all.merge!(:includes => :topic, :order => "topics.id").to_a
     assert replies.include?(topics(:second))
     assert !replies.include?(topics(:first))
     assert_equal topics(:first), assert_no_queries { replies.first.topic }
   end
 
   def test_eager_association_loading_with_multiple_stis_and_order
-    author = Author.all.merge!(:includes => { :posts => [ :special_comments , :very_special_comment ] }, :order => ['authors.name', 'comments.body', 'very_special_comments_posts.body'], :where => 'posts.id = 4').first
+    author = Author.all.merge!(:includes => { :posts => [ :special_comments , :very_special_comment ] }, :order => ["authors.name", "comments.body", "very_special_comments_posts.body"], :where => "posts.id = 4").first
     assert_equal authors(:david), author
     assert_no_queries do
       author.posts.first.special_comments
@@ -149,7 +149,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_of_stis_with_multiple_references
-    authors = Author.all.merge!(:includes => { :posts => { :special_comments => { :post => [ :special_comments, :very_special_comment ] } } }, :order => 'comments.body, very_special_comments_posts.body', :where => 'posts.id = 4').to_a
+    authors = Author.all.merge!(:includes => { :posts => { :special_comments => { :post => [ :special_comments, :very_special_comment ] } } }, :order => "comments.body, very_special_comments_posts.body", :where => "posts.id = 4").to_a
     assert_equal [authors(:david)], authors
     assert_no_queries do
       authors.first.posts.first.special_comments.first.post.special_comments
@@ -158,7 +158,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_where_first_level_returns_nil
-    authors = Author.all.merge!(:includes => {:post_about_thinking => :comments}, :order => 'authors.id DESC').to_a
+    authors = Author.all.merge!(:includes => {:post_about_thinking => :comments}, :order => "authors.id DESC").to_a
     assert_equal [authors(:bob), authors(:mary), authors(:david)], authors
     assert_no_queries do
       authors[2].post_about_thinking.comments.first
@@ -166,12 +166,12 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_recursive_cascading_four_levels_has_many_through
-    source = Vertex.all.merge!(:includes=>{:sinks=>{:sinks=>{:sinks=>:sinks}}}, :order => 'vertices.id').first
+    source = Vertex.all.merge!(:includes=>{:sinks=>{:sinks=>{:sinks=>:sinks}}}, :order => "vertices.id").first
     assert_equal vertices(:vertex_4), assert_no_queries { source.sinks.first.sinks.first.sinks.first }
   end
 
   def test_eager_association_loading_with_recursive_cascading_four_levels_has_and_belongs_to_many
-    sink = Vertex.all.merge!(:includes=>{:sources=>{:sources=>{:sources=>:sources}}}, :order => 'vertices.id DESC').first
+    sink = Vertex.all.merge!(:includes=>{:sources=>{:sources=>{:sources=>:sources}}}, :order => "vertices.id DESC").first
     assert_equal vertices(:vertex_1), assert_no_queries { sink.sources.first.sources.first.sources.first.sources.first }
   end
 
diff --git a/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb b/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb
index 75a6295350..e852e91f20 100644
--- a/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb
+++ b/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb
@@ -1,11 +1,11 @@
-require 'cases/helper'
-require 'models/post'
-require 'models/tagging'
+require "cases/helper"
+require "models/post"
+require "models/tagging"
 
 module Namespaced
   class Post < ActiveRecord::Base
-    self.table_name = 'posts'
-    has_one :tagging, :as => :taggable, :class_name => 'Tagging'
+    self.table_name = "posts"
+    has_one :tagging, :as => :taggable, :class_name => "Tagging"
   end
 end
 
@@ -16,7 +16,7 @@ class EagerLoadIncludeFullStiClassNamesTest < ActiveRecord::TestCase
   end
 
   def generate_test_objects
-    post = Namespaced::Post.create( :title => 'Great stuff', :body => 'This is not', :author_id => 1 )
+    post = Namespaced::Post.create( :title => "Great stuff", :body => "This is not", :author_id => 1 )
     Tagging.create( :taggable => post )
   end
 
@@ -24,11 +24,11 @@ class EagerLoadIncludeFullStiClassNamesTest < ActiveRecord::TestCase
     old = ActiveRecord::Base.store_full_sti_class
 
     ActiveRecord::Base.store_full_sti_class = false
-    post = Namespaced::Post.includes(:tagging).find_by_title('Great stuff')
+    post = Namespaced::Post.includes(:tagging).find_by_title("Great stuff")
     assert_nil post.tagging
 
     ActiveRecord::Base.store_full_sti_class = true
-    post = Namespaced::Post.includes(:tagging).find_by_title('Great stuff')
+    post = Namespaced::Post.includes(:tagging).find_by_title("Great stuff")
     assert_instance_of Tagging, post.tagging
   ensure
     ActiveRecord::Base.store_full_sti_class = old
diff --git a/activerecord/test/cases/associations/eager_load_nested_include_test.rb b/activerecord/test/cases/associations/eager_load_nested_include_test.rb
index f571198079..4762ef90c5 100644
--- a/activerecord/test/cases/associations/eager_load_nested_include_test.rb
+++ b/activerecord/test/cases/associations/eager_load_nested_include_test.rb
@@ -1,11 +1,11 @@
-require 'cases/helper'
-require 'models/post'
-require 'models/tag'
-require 'models/author'
-require 'models/comment'
-require 'models/category'
-require 'models/categorization'
-require 'models/tagging'
+require "cases/helper"
+require "models/post"
+require "models/tag"
+require "models/author"
+require "models/comment"
+require "models/category"
+require "models/categorization"
+require "models/tagging"
 
 module Remembered
   extend ActiveSupport::Concern
@@ -103,9 +103,9 @@ end
 
 class EagerLoadNestedIncludeWithMissingDataTest < ActiveRecord::TestCase
   def setup
-    @davey_mcdave = Author.create(:name => 'Davey McDave')
-    @first_post = @davey_mcdave.posts.create(:title => 'Davey Speaks', :body => 'Expressive wordage')
-    @first_comment = @first_post.comments.create(:body => 'Inflamatory doublespeak')
+    @davey_mcdave = Author.create(:name => "Davey McDave")
+    @first_post = @davey_mcdave.posts.create(:title => "Davey Speaks", :body => "Expressive wordage")
+    @first_comment = @first_post.comments.create(:body => "Inflamatory doublespeak")
     @first_categorization = @davey_mcdave.categorizations.create(:category => Category.first, :post => @first_post)
   end
 
@@ -120,7 +120,7 @@ class EagerLoadNestedIncludeWithMissingDataTest < ActiveRecord::TestCase
     assert_nothing_raised do
       # @davey_mcdave doesn't have any author_favorites
       includes = {:posts => :comments, :categorizations => :category, :author_favorites => :favorite_author }
-      Author.all.merge!(:includes => includes, :where => {:authors => {:name => @davey_mcdave.name}}, :order => 'categories.name').to_a
+      Author.all.merge!(:includes => includes, :where => {:authors => {:name => @davey_mcdave.name}}, :order => "categories.name").to_a
     end
   end
 end
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
 
diff --git a/activerecord/test/cases/associations/extension_test.rb b/activerecord/test/cases/associations/extension_test.rb
index b161cde335..8f9fc10ba5 100644
--- a/activerecord/test/cases/associations/extension_test.rb
+++ b/activerecord/test/cases/associations/extension_test.rb
@@ -1,10 +1,10 @@
 require "cases/helper"
-require 'models/post'
-require 'models/comment'
-require 'models/project'
-require 'models/developer'
-require 'models/computer'
-require 'models/company_in_module'
+require "models/post"
+require "models/comment"
+require "models/project"
+require "models/developer"
+require "models/computer"
+require "models/company_in_module"
 
 class AssociationsExtensionsTest < ActiveRecord::TestCase
   fixtures :projects, :developers, :developers_projects, :comments, :posts
@@ -63,14 +63,14 @@ class AssociationsExtensionsTest < ActiveRecord::TestCase
     extend!(Developer)
     extend!(MyApplication::Business::Developer)
 
-    assert Object.const_get 'DeveloperAssociationNameAssociationExtension'
-    assert MyApplication::Business.const_get 'DeveloperAssociationNameAssociationExtension'
+    assert Object.const_get "DeveloperAssociationNameAssociationExtension"
+    assert MyApplication::Business.const_get "DeveloperAssociationNameAssociationExtension"
   end
 
   def test_proxy_association_after_scoped
     post = posts(:welcome)
     assert_equal post.association(:comments), post.comments.the_association
-    assert_equal post.association(:comments), post.comments.where('1=1').the_association
+    assert_equal post.association(:comments), post.comments.where("1=1").the_association
   end
 
   private
diff --git a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
index a959f3c06a..e274a0dc96 100644
--- a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
@@ -1,38 +1,38 @@
 require "cases/helper"
-require 'models/developer'
-require 'models/computer'
-require 'models/project'
-require 'models/company'
-require 'models/course'
-require 'models/customer'
-require 'models/order'
-require 'models/categorization'
-require 'models/category'
-require 'models/post'
-require 'models/author'
-require 'models/tag'
-require 'models/tagging'
-require 'models/parrot'
-require 'models/person'
-require 'models/pirate'
-require 'models/professor'
-require 'models/treasure'
-require 'models/price_estimate'
-require 'models/club'
-require 'models/user'
-require 'models/member'
-require 'models/membership'
-require 'models/sponsor'
-require 'models/country'
-require 'models/treaty'
-require 'models/vertex'
-require 'models/publisher'
-require 'models/publisher/article'
-require 'models/publisher/magazine'
-require 'active_support/core_ext/string/conversions'
+require "models/developer"
+require "models/computer"
+require "models/project"
+require "models/company"
+require "models/course"
+require "models/customer"
+require "models/order"
+require "models/categorization"
+require "models/category"
+require "models/post"
+require "models/author"
+require "models/tag"
+require "models/tagging"
+require "models/parrot"
+require "models/person"
+require "models/pirate"
+require "models/professor"
+require "models/treasure"
+require "models/price_estimate"
+require "models/club"
+require "models/user"
+require "models/member"
+require "models/membership"
+require "models/sponsor"
+require "models/country"
+require "models/treaty"
+require "models/vertex"
+require "models/publisher"
+require "models/publisher/article"
+require "models/publisher/magazine"
+require "active_support/core_ext/string/conversions"
 
 class ProjectWithAfterCreateHook < ActiveRecord::Base
-  self.table_name = 'projects'
+  self.table_name = "projects"
   has_and_belongs_to_many :developers,
     :class_name => "DeveloperForProjectWithAfterCreateHook",
     :join_table => "developers_projects",
@@ -42,13 +42,13 @@ class ProjectWithAfterCreateHook < ActiveRecord::Base
   after_create :add_david
 
   def add_david
-    david = DeveloperForProjectWithAfterCreateHook.find_by_name('David')
+    david = DeveloperForProjectWithAfterCreateHook.find_by_name("David")
     david.projects << self
   end
 end
 
 class DeveloperForProjectWithAfterCreateHook < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
   has_and_belongs_to_many :projects,
     :class_name => "ProjectWithAfterCreateHook",
     :join_table => "developers_projects",
@@ -57,7 +57,7 @@ class DeveloperForProjectWithAfterCreateHook < ActiveRecord::Base
 end
 
 class ProjectWithSymbolsForKeys < ActiveRecord::Base
-  self.table_name = 'projects'
+  self.table_name = "projects"
   has_and_belongs_to_many :developers,
     :class_name => "DeveloperWithSymbolsForKeys",
     :join_table => :developers_projects,
@@ -66,7 +66,7 @@ class ProjectWithSymbolsForKeys < ActiveRecord::Base
 end
 
 class DeveloperWithSymbolsForKeys < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
   has_and_belongs_to_many :projects,
     :class_name => "ProjectWithSymbolsForKeys",
     :join_table => :developers_projects,
@@ -75,9 +75,9 @@ class DeveloperWithSymbolsForKeys < ActiveRecord::Base
 end
 
 class SubDeveloper < Developer
-  self.table_name = 'developers'
+  self.table_name = "developers"
   has_and_belongs_to_many :special_projects,
-    :join_table => 'developers_projects',
+    :join_table => "developers_projects",
     :foreign_key => "project_id",
     :association_foreign_key => "developer_id"
 end
@@ -89,7 +89,7 @@ end
 class DeveloperWithExtendOption < Developer
   module NamedExtension
     def category
-      'sns'
+      "sns"
     end
   end
 
@@ -97,8 +97,8 @@ class DeveloperWithExtendOption < Developer
 end
 
 class ProjectUnscopingDavidDefaultScope < ActiveRecord::Base
-  self.table_name = 'projects'
-  has_and_belongs_to_many :developers, -> { unscope(where: 'name') },
+  self.table_name = "projects"
+  has_and_belongs_to_many :developers, -> { unscope(where: "name") },
     class_name: "LazyBlockDeveloperCalledDavid",
     join_table: "developers_projects",
     foreign_key: "project_id",
@@ -110,14 +110,14 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
            :parrots, :pirates, :parrots_pirates, :treasures, :price_estimates, :tags, :taggings, :computers
 
   def setup_data_for_habtm_case
-    ActiveRecord::Base.connection.execute('delete from countries_treaties')
+    ActiveRecord::Base.connection.execute("delete from countries_treaties")
 
-    country = Country.new(:name => 'India')
-    country.country_id = 'c1'
+    country = Country.new(:name => "India")
+    country.country_id = "c1"
     country.save!
 
-    treaty = Treaty.new(:name => 'peace')
-    treaty.treaty_id = 't1'
+    treaty = Treaty.new(:name => "peace")
+    treaty.treaty_id = "t1"
     country.treaties << treaty
   end
 
@@ -131,29 +131,29 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     setup_data_for_habtm_case
 
     con = ActiveRecord::Base.connection
-    sql = 'select * from countries_treaties'
+    sql = "select * from countries_treaties"
     record = con.select_rows(sql).last
-    assert_equal 'c1', record[0]
-    assert_equal 't1', record[1]
+    assert_equal "c1", record[0]
+    assert_equal "t1", record[1]
   end
 
   def test_proper_usage_of_primary_keys_and_join_table
     setup_data_for_habtm_case
 
-    assert_equal 'country_id', Country.primary_key
-    assert_equal 'treaty_id', Treaty.primary_key
+    assert_equal "country_id", Country.primary_key
+    assert_equal "treaty_id", Treaty.primary_key
 
     country = Country.first
     assert_equal 1, country.treaties.count
   end
 
   def test_join_table_composite_primary_key_should_not_warn
-    country = Country.new(:name => 'India')
-    country.country_id = 'c1'
+    country = Country.new(:name => "India")
+    country.country_id = "c1"
     country.save!
 
-    treaty = Treaty.new(:name => 'peace')
-    treaty.treaty_id = 't1'
+    treaty = Treaty.new(:name => "peace")
+    treaty.treaty_id = "t1"
     warning = capture(:stderr) do
       country.treaties << treaty
     end
@@ -285,7 +285,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_habtm_collection_size_from_params
     devel = Developer.new({
       projects_attributes: {
-        '0' => {}
+        "0" => {}
       }
     })
 
@@ -362,16 +362,16 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
 
   def test_creation_respects_hash_condition
     # in Oracle '' is saved as null therefore need to save ' ' in not null column
-    post = categories(:general).post_with_conditions.build(:body => ' ')
+    post = categories(:general).post_with_conditions.build(:body => " ")
 
     assert        post.save
-    assert_equal  'Yet Another Testing Title', post.title
+    assert_equal  "Yet Another Testing Title", post.title
 
     # in Oracle '' is saved as null therefore need to save ' ' in not null column
-    another_post = categories(:general).post_with_conditions.create(:body => ' ')
+    another_post = categories(:general).post_with_conditions.create(:body => " ")
 
     assert        another_post.persisted?
-    assert_equal  'Yet Another Testing Title', another_post.title
+    assert_equal  "Yet Another Testing Title", another_post.title
   end
 
   def test_distinct_after_the_fact
@@ -577,15 +577,15 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
 
   def test_dynamic_find_should_respect_association_order
     # Developers are ordered 'name DESC, id DESC'
-    high_id_jamis = projects(:active_record).developers.create(:name => 'Jamis')
+    high_id_jamis = projects(:active_record).developers.create(:name => "Jamis")
 
     assert_equal high_id_jamis, projects(:active_record).developers.merge(:where => "name = 'Jamis'").first
-    assert_equal high_id_jamis, projects(:active_record).developers.find_by_name('Jamis')
+    assert_equal high_id_jamis, projects(:active_record).developers.find_by_name("Jamis")
   end
 
   def test_find_should_append_to_association_order
-    ordered_developers = projects(:active_record).developers.order('projects.id')
-    assert_equal ['developers.name desc, developers.id desc', 'projects.id'], ordered_developers.order_values
+    ordered_developers = projects(:active_record).developers.order("projects.id")
+    assert_equal ["developers.name desc, developers.id desc", "projects.id"], ordered_developers.order_values
   end
 
   def test_dynamic_find_all_should_respect_readonly_access
@@ -594,8 +594,8 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_new_with_values_in_collection
-    jamis = DeveloperForProjectWithAfterCreateHook.find_by_name('Jamis')
-    david = DeveloperForProjectWithAfterCreateHook.find_by_name('David')
+    jamis = DeveloperForProjectWithAfterCreateHook.find_by_name("Jamis")
+    david = DeveloperForProjectWithAfterCreateHook.find_by_name("David")
     project = ProjectWithAfterCreateHook.new(:name => "Cooking with Bertie")
     project.developers << jamis
     project.save!
@@ -613,8 +613,8 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_association_with_extend_option
-    eponine = DeveloperWithExtendOption.create(name: 'Eponine')
-    assert_equal 'sns', eponine.projects.category
+    eponine = DeveloperWithExtendOption.create(name: "Eponine")
+    assert_equal "sns", eponine.projects.category
   end
 
   def test_replace_with_less
@@ -690,7 +690,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_habtm_respects_select_query_method
-    assert_equal ['id'], developers(:david).projects.select(:id).first.attributes.keys
+    assert_equal ["id"], developers(:david).projects.select(:id).first.attributes.keys
   end
 
   def test_join_table_alias
@@ -702,7 +702,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
       3,
       Developer.references(:developers_projects_join).merge(
         :includes => {:projects => :developers},
-        :where => 'projects_developers_projects_join.joined_on IS NOT NULL'
+        :where => "projects_developers_projects_join.joined_on IS NOT NULL"
       ).to_a.size
     )
   end
@@ -721,7 +721,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal(
       3,
       Developer.references(:developers_projects_join).merge(
-        :includes => {:projects => :developers}, :where => 'projects_developers_projects_join.joined_on IS NOT NULL',
+        :includes => {:projects => :developers}, :where => "projects_developers_projects_join.joined_on IS NOT NULL",
         :group => group.join(",")
       ).to_a.size
     )
@@ -729,7 +729,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
 
   def test_find_grouped
     all_posts_from_category1 = Post.all.merge!(:where => "category_id = 1", :joins => :categories).to_a
-    grouped_posts_of_category1 = Post.all.merge!(:where => "category_id = 1", :group => "author_id", :select => 'count(posts.id) as posts_count', :joins => :categories).to_a
+    grouped_posts_of_category1 = Post.all.merge!(:where => "category_id = 1", :group => "author_id", :select => "count(posts.id) as posts_count", :joins => :categories).to_a
     assert_equal 5, all_posts_from_category1.size
     assert_equal 2, grouped_posts_of_category1.size
   end
@@ -776,7 +776,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
 
   def test_assign_ids_ignoring_blanks
     developer = Developer.new("name" => "Joe")
-    developer.project_ids = [projects(:active_record).id, nil, projects(:action_controller).id, '']
+    developer.project_ids = [projects(:active_record).id, nil, projects(:action_controller).id, ""]
     developer.save
     developer.reload
     assert_equal 2, developer.projects.length
@@ -796,8 +796,8 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_symbols_as_keys
-    developer = DeveloperWithSymbolsForKeys.new(:name => 'David')
-    project = ProjectWithSymbolsForKeys.new(:name => 'Rails Testing')
+    developer = DeveloperWithSymbolsForKeys.new(:name => "David")
+    project = ProjectWithSymbolsForKeys.new(:name => "Rails Testing")
     project.developers << developer
     project.save!
 
@@ -810,7 +810,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_dynamic_find_should_respect_association_include
     # SQL error in sort clause if :include is not included
     # due to Unknown column 'authors.id'
-    assert Category.find(1).posts_with_authors_sorted_by_author_id.find_by_title('Welcome to the weblog')
+    assert Category.find(1).posts_with_authors_sorted_by_author_id.find_by_title("Welcome to the weblog")
   end
 
   def test_count
@@ -872,7 +872,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     projects = Developer.new.projects
     assert_no_queries(ignore_none: false) do
       assert_equal [], projects
-      assert_equal [], projects.where(title: 'omg')
+      assert_equal [], projects.where(title: "omg")
       assert_equal [], projects.pluck(:title)
       assert_equal 0, projects.count
     end
@@ -886,7 +886,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     treasure.valid?
 
     assert_equal 1, treasure.rich_people.size
-    assert_nil rich_person.first_name, 'should not run associated person validation on create when validate: false'
+    assert_nil rich_person.first_name, "should not run associated person validation on create when validate: false"
   end
 
   def test_association_with_validate_false_does_not_run_associated_validation_callbacks_on_update
@@ -899,11 +899,11 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     treasure.valid?
 
     assert_equal 1, treasure.rich_people.size
-    assert_equal person_first_name, rich_person.first_name, 'should not run associated person validation on update when validate: false'
+    assert_equal person_first_name, rich_person.first_name, "should not run associated person validation on update when validate: false"
   end
 
   def test_custom_join_table
-    assert_equal 'edges', Vertex.reflect_on_association(:sources).join_table
+    assert_equal "edges", Vertex.reflect_on_association(:sources).join_table
   end
 
   def test_has_and_belongs_to_many_in_a_namespaced_model_pointing_to_a_namespaced_model
@@ -927,11 +927,11 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_redefine_habtm
     child = SubDeveloper.new("name" => "Aredridel")
     child.special_projects << SpecialProject.new("name" => "Special Project")
-    assert child.save, 'child object should be saved'
+    assert child.save, "child object should be saved"
   end
 
   def test_habtm_with_reflection_using_class_name_and_fixtures
-    assert_not_nil Developer._reflections['shared_computers']
+    assert_not_nil Developer._reflections["shared_computers"]
     # Checking the fixture for named association is important here, because it's the only way
     # we've been able to reproduce this bug
     assert_not_nil File.read(File.expand_path("../../../fixtures/developers.yml", __FILE__)).index("shared_computers")
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index 113131b28c..c8901a29d3 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -1,43 +1,43 @@
 require "cases/helper"
-require 'models/developer'
-require 'models/computer'
-require 'models/project'
-require 'models/company'
-require 'models/contract'
-require 'models/topic'
-require 'models/reply'
-require 'models/category'
-require 'models/image'
-require 'models/post'
-require 'models/author'
-require 'models/essay'
-require 'models/comment'
-require 'models/person'
-require 'models/reader'
-require 'models/tagging'
-require 'models/tag'
-require 'models/invoice'
-require 'models/line_item'
-require 'models/car'
-require 'models/bulb'
-require 'models/engine'
-require 'models/categorization'
-require 'models/minivan'
-require 'models/speedometer'
-require 'models/reference'
-require 'models/job'
-require 'models/college'
-require 'models/student'
-require 'models/pirate'
-require 'models/ship'
-require 'models/ship_part'
-require 'models/treasure'
-require 'models/parrot'
-require 'models/tyre'
-require 'models/subscriber'
-require 'models/subscription'
-require 'models/zine'
-require 'models/interest'
+require "models/developer"
+require "models/computer"
+require "models/project"
+require "models/company"
+require "models/contract"
+require "models/topic"
+require "models/reply"
+require "models/category"
+require "models/image"
+require "models/post"
+require "models/author"
+require "models/essay"
+require "models/comment"
+require "models/person"
+require "models/reader"
+require "models/tagging"
+require "models/tag"
+require "models/invoice"
+require "models/line_item"
+require "models/car"
+require "models/bulb"
+require "models/engine"
+require "models/categorization"
+require "models/minivan"
+require "models/speedometer"
+require "models/reference"
+require "models/job"
+require "models/college"
+require "models/student"
+require "models/pirate"
+require "models/ship"
+require "models/ship_part"
+require "models/treasure"
+require "models/parrot"
+require "models/tyre"
+require "models/subscriber"
+require "models/subscription"
+require "models/zine"
+require "models/interest"
 
 class HasManyAssociationsTestForReorderWithJoinDependency < ActiveRecord::TestCase
   fixtures :authors, :posts, :comments
@@ -46,7 +46,7 @@ class HasManyAssociationsTestForReorderWithJoinDependency < ActiveRecord::TestCa
     author = authors(:david)
     # this can fail on adapters which require ORDER BY expressions to be included in the SELECT expression
     # if the reorder clauses are not correctly handled
-    assert author.posts_with_comments_sorted_by_comment_id.where('comments.id > 0').reorder('posts.comments_count DESC', 'posts.tags_count DESC').last
+    assert author.posts_with_comments_sorted_by_comment_id.where("comments.id > 0").reorder("posts.comments_count DESC", "posts.tags_count DESC").last
   end
 end
 
@@ -54,14 +54,14 @@ class HasManyAssociationsTestPrimaryKeys < ActiveRecord::TestCase
   fixtures :authors, :essays, :subscribers, :subscriptions, :people
 
   def test_custom_primary_key_on_new_record_should_fetch_with_query
-    subscriber = Subscriber.new(nick: 'webster132')
+    subscriber = Subscriber.new(nick: "webster132")
     assert !subscriber.subscriptions.loaded?
 
     assert_queries 1 do
       assert_equal 2, subscriber.subscriptions.size
     end
 
-    assert_equal subscriber.subscriptions, Subscription.where(subscriber_id: 'webster132')
+    assert_equal subscriber.subscriptions, Subscription.where(subscriber_id: "webster132")
   end
 
   def test_association_primary_key_on_new_record_should_fetch_with_query
@@ -116,14 +116,14 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_anonymous_has_many
     developer = Class.new(ActiveRecord::Base) {
-      self.table_name = 'developers'
+      self.table_name = "developers"
       dev = self
 
       developer_project = Class.new(ActiveRecord::Base) {
-        self.table_name = 'developers_projects'
+        self.table_name = "developers_projects"
         belongs_to :developer, :anonymous_class => dev
       }
-      has_many :developer_projects, :anonymous_class => developer_project, :foreign_key => 'developer_id'
+      has_many :developer_projects, :anonymous_class => developer_project, :foreign_key => "developer_id"
     }
     dev = developer.first
     named = Developer.find(dev.id)
@@ -135,20 +135,20 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_default_scope_on_relations_is_not_cached
     counter = 0
     posts = Class.new(ActiveRecord::Base) {
-      self.table_name = 'posts'
-      self.inheritance_column = 'not_there'
+      self.table_name = "posts"
+      self.inheritance_column = "not_there"
       post = self
 
       comments = Class.new(ActiveRecord::Base) {
-        self.table_name = 'comments'
-        self.inheritance_column = 'not_there'
+        self.table_name = "comments"
+        self.inheritance_column = "not_there"
         belongs_to :post, :anonymous_class => post
         default_scope -> {
           counter += 1
           where("id = :inc", :inc => counter)
         }
       }
-      has_many :comments, :anonymous_class => comments, :foreign_key => 'post_id'
+      has_many :comments, :anonymous_class => comments, :foreign_key => "post_id"
     }
     assert_equal 0, counter
     post = posts.first
@@ -159,15 +159,15 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_has_many_build_with_options
-    college = College.create(name: 'UFMT')
-    Student.create(active: true, college_id: college.id, name: 'Sarah')
+    college = College.create(name: "UFMT")
+    Student.create(active: true, college_id: college.id, name: "Sarah")
 
     assert_equal college.students, Student.where(active: true, college_id: college.id)
   end
 
   def test_add_record_to_collection_should_change_its_updated_at
-    ship = Ship.create(name: 'dauntless')
-    part = ShipPart.create(name: 'cockpit')
+    ship = Ship.create(name: "dauntless")
+    part = ShipPart.create(name: "cockpit")
     updated_at = part.updated_at
 
     travel(1.second) do
@@ -181,8 +181,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_clear_collection_should_not_change_updated_at
     # GH#17161: .clear calls delete_all (and returns the association),
     # which is intended to not touch associated objects's updated_at field
-    ship = Ship.create(name: 'dauntless')
-    part = ShipPart.create(name: 'cockpit', ship_id: ship.id)
+    ship = Ship.create(name: "dauntless")
+    part = ShipPart.create(name: "cockpit", ship_id: ship.id)
 
     ship.parts.clear
     part.reload
@@ -192,27 +192,27 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_create_from_association_should_respect_default_scope
-    car = Car.create(:name => 'honda')
-    assert_equal 'honda', car.name
+    car = Car.create(:name => "honda")
+    assert_equal "honda", car.name
 
     bulb = Bulb.create
-    assert_equal 'defaulty', bulb.name
+    assert_equal "defaulty", bulb.name
 
     bulb = car.bulbs.build
-    assert_equal 'defaulty', bulb.name
+    assert_equal "defaulty", bulb.name
 
     bulb = car.bulbs.create
-    assert_equal 'defaulty', bulb.name
+    assert_equal "defaulty", bulb.name
   end
 
   def test_build_and_create_from_association_should_respect_passed_attributes_over_default_scope
-    car = Car.create(name: 'honda')
+    car = Car.create(name: "honda")
 
-    bulb = car.bulbs.build(name: 'exotic')
-    assert_equal 'exotic', bulb.name
+    bulb = car.bulbs.build(name: "exotic")
+    assert_equal "exotic", bulb.name
 
-    bulb = car.bulbs.create(name: 'exotic')
-    assert_equal 'exotic', bulb.name
+    bulb = car.bulbs.create(name: "exotic")
+    assert_equal "exotic", bulb.name
 
     bulb = car.awesome_bulbs.build(frickinawesome: false)
     assert_equal false, bulb.frickinawesome
@@ -225,24 +225,24 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     author = Author.new
 
     post = author.thinking_posts.build
-    assert_equal 'So I was thinking', post.title
+    assert_equal "So I was thinking", post.title
   end
 
   def test_create_from_association_with_nil_values_should_work
-    car = Car.create(:name => 'honda')
+    car = Car.create(:name => "honda")
 
     bulb = car.bulbs.new(nil)
-    assert_equal 'defaulty', bulb.name
+    assert_equal "defaulty", bulb.name
 
     bulb = car.bulbs.build(nil)
-    assert_equal 'defaulty', bulb.name
+    assert_equal "defaulty", bulb.name
 
     bulb = car.bulbs.create(nil)
-    assert_equal 'defaulty', bulb.name
+    assert_equal "defaulty", bulb.name
   end
 
   def test_do_not_call_callbacks_for_delete_all
-    car = Car.create(:name => 'honda')
+    car = Car.create(:name => "honda")
     car.funky_bulbs.create!
     assert_equal 1, car.funky_bulbs.count
     assert_nothing_raised { car.reload.funky_bulbs.delete_all }
@@ -314,7 +314,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_association_keys_bypass_attribute_protection
-    car = Car.create(:name => 'honda')
+    car = Car.create(:name => "honda")
 
     bulb = car.bulbs.new
     assert_equal car.id, bulb.car_id
@@ -374,7 +374,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_no_sql_should_be_fired_if_association_already_loaded
-    Car.create(:name => 'honda')
+    Car.create(:name => "honda")
     bulbs = Car.first.bulbs
     bulbs.to_a # to load all instances of bulbs
 
@@ -425,7 +425,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_create_resets_cached_counters
-    person = Person.create!(:first_name => 'tenderlove')
+    person = Person.create!(:first_name => "tenderlove")
     post   = Post.first
 
     assert_equal [], person.readers
@@ -441,7 +441,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_update_all_respects_association_scope
     person = Person.new
-    person.first_name = 'Naruto'
+    person.first_name = "Naruto"
     person.references << Reference.new
     person.id = 10
     person.references
@@ -451,7 +451,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_exists_respects_association_scope
     person = Person.new
-    person.first_name = 'Sasuke'
+    person.first_name = "Sasuke"
     person.references << Reference.new
     person.id = 10
     person.references
@@ -497,13 +497,13 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_find_should_append_to_association_order
-    ordered_clients =  companies(:first_firm).clients_sorted_desc.order('companies.id')
-    assert_equal ['id DESC', 'companies.id'], ordered_clients.order_values
+    ordered_clients =  companies(:first_firm).clients_sorted_desc.order("companies.id")
+    assert_equal ["id DESC", "companies.id"], ordered_clients.order_values
   end
 
   def test_dynamic_find_should_respect_association_order
     assert_equal companies(:another_first_firm_client), companies(:first_firm).clients_sorted_desc.where("type = 'Client'").first
-    assert_equal companies(:another_first_firm_client), companies(:first_firm).clients_sorted_desc.find_by_type('Client')
+    assert_equal companies(:another_first_firm_client), companies(:first_firm).clients_sorted_desc.find_by_type("Client")
   end
 
   def test_taking
@@ -575,21 +575,21 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_update_all_on_association_accessed_before_save
-    firm = Firm.new(name: 'Firm')
+    firm = Firm.new(name: "Firm")
     clients_proxy_id = firm.clients.object_id
     firm.clients << Client.first
     firm.save!
-    assert_equal firm.clients.count, firm.clients.update_all(description: 'Great!')
+    assert_equal firm.clients.count, firm.clients.update_all(description: "Great!")
     assert_not_equal clients_proxy_id, firm.clients.object_id
   end
 
   def test_update_all_on_association_accessed_before_save_with_explicit_foreign_key
     # We can use the same cached proxy object because the id is available for the scope
-    firm = Firm.new(name: 'Firm', id: 100)
+    firm = Firm.new(name: "Firm", id: 100)
     clients_proxy_id = firm.clients.object_id
     firm.clients << Client.first
     firm.save!
-    assert_equal firm.clients.count, firm.clients.update_all(description: 'Great!')
+    assert_equal firm.clients.count, firm.clients.update_all(description: "Great!")
     assert_equal clients_proxy_id, firm.clients.object_id
   end
 
@@ -654,7 +654,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     firm = companies(:first_firm)
 
     assert_queries(2) do
-      firm.clients.where(name: 'Microsoft').find_each(batch_size: 1) do |c|
+      firm.clients.where(name: "Microsoft").find_each(batch_size: 1) do |c|
         assert_equal firm.id, c.firm_id
         assert_equal "Microsoft", c.name
       end
@@ -695,13 +695,13 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_find_first_sanitized
     firm = Firm.all.merge!(:order => "id").first
     client2 = Client.find(2)
-    assert_equal client2, firm.clients.merge!(:where => ["#{QUOTED_TYPE} = ?", 'Client'], :order => "id").first
-    assert_equal client2, firm.clients.merge!(:where => ["#{QUOTED_TYPE} = :type", { :type => 'Client' }], :order => "id").first
+    assert_equal client2, firm.clients.merge!(:where => ["#{QUOTED_TYPE} = ?", "Client"], :order => "id").first
+    assert_equal client2, firm.clients.merge!(:where => ["#{QUOTED_TYPE} = :type", { :type => "Client" }], :order => "id").first
   end
 
   def test_find_all_with_include_and_conditions
     assert_nothing_raised do
-      Developer.all.merge!(:joins => :audit_logs, :where => {'audit_logs.message' => nil, :name => 'Smith'}).to_a
+      Developer.all.merge!(:joins => :audit_logs, :where => {"audit_logs.message" => nil, :name => "Smith"}).to_a
     end
   end
 
@@ -712,7 +712,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_find_grouped
     all_clients_of_firm1 = Client.all.merge!(:where => "firm_id = 1").to_a
-    grouped_clients_of_firm1 = Client.all.merge!(:where => "firm_id = 1", :group => "firm_id", :select => 'firm_id, count(id) as clients_count').to_a
+    grouped_clients_of_firm1 = Client.all.merge!(:where => "firm_id = 1", :group => "firm_id", :select => "firm_id, count(id) as clients_count").to_a
     assert_equal 3, all_clients_of_firm1.size
     assert_equal 1, grouped_clients_of_firm1.size
   end
@@ -734,7 +734,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_select_query_method
-    assert_equal ['id', 'body'], posts(:welcome).comments.select(:id, :body).first.attributes.keys
+    assert_equal ["id", "body"], posts(:welcome).comments.select(:id, :body).first.attributes.keys
   end
 
   def test_select_with_block
@@ -993,7 +993,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_has_many_without_counter_cache_option
     # Ship has a conventionally named `treasures_count` column, but the counter_cache
     # option is not given on the association.
-    ship = Ship.create(name: 'Countless', treasures_count: 10)
+    ship = Ship.create(name: "Countless", treasures_count: 10)
 
     assert_not Ship.reflect_on_association(:treasures).has_cached_counter?
 
@@ -1001,7 +1001,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal ship.treasures.size, 0
 
     assert_no_difference lambda { ship.reload.treasures_count }, "treasures_count should not be changed" do
-      ship.treasures.create(name: 'Gold')
+      ship.treasures.create(name: "Gold")
     end
 
     assert_no_difference lambda { ship.reload.treasures_count }, "treasures_count should not be changed" do
@@ -1211,7 +1211,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_clearing_updates_counter_cache
     topic = Topic.first
 
-    assert_difference 'topic.reload.replies_count', -1 do
+    assert_difference "topic.reload.replies_count", -1 do
       topic.replies.clear
     end
   end
@@ -1220,7 +1220,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     car = Car.first
     car.engines.create!
 
-    assert_difference 'car.reload.engines_count', -1 do
+    assert_difference "car.reload.engines_count", -1 do
       car.engines.clear
     end
   end
@@ -1329,12 +1329,12 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     ms_client = companies(:first_firm).clients_like_ms_with_hash_conditions.build
 
     assert        ms_client.save
-    assert_equal  'Microsoft', ms_client.name
+    assert_equal  "Microsoft", ms_client.name
 
     another_ms_client = companies(:first_firm).clients_like_ms_with_hash_conditions.create
 
     assert        another_ms_client.persisted?
-    assert_equal  'Microsoft', another_ms_client.name
+    assert_equal  "Microsoft", another_ms_client.name
   end
 
   def test_clearing_without_initial_access
@@ -1351,7 +1351,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
     assert_predicate companies(:first_firm).clients_of_firm, :loaded?
 
-    summit = Client.find_by_name('Summit')
+    summit = Client.find_by_name("Summit")
     companies(:first_firm).clients_of_firm.delete(summit)
     assert_equal 2, companies(:first_firm).clients_of_firm.size
     assert_equal 2, companies(:first_firm).clients_of_firm.reload.size
@@ -1361,7 +1361,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_deleting_by_integer_id
     david = Developer.find(1)
 
-    assert_difference 'david.projects.count', -1 do
+    assert_difference "david.projects.count", -1 do
       assert_equal 1, david.projects.delete(1).size
     end
 
@@ -1371,8 +1371,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_deleting_by_string_id
     david = Developer.find(1)
 
-    assert_difference 'david.projects.count', -1 do
-      assert_equal 1, david.projects.delete('1').size
+    assert_difference "david.projects.count", -1 do
+      assert_equal 1, david.projects.delete("1").size
     end
 
     assert_equal 1, david.projects.size
@@ -1462,7 +1462,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_dependence_for_associations_with_hash_condition
     david = authors(:david)
-    assert_difference('Post.count', -1) { assert david.destroy }
+    assert_difference("Post.count", -1) { assert david.destroy }
   end
 
   def test_destroy_dependent_when_deleted_from_association
@@ -1518,21 +1518,21 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_restrict_with_exception
-    firm = RestrictedWithExceptionFirm.create!(:name => 'restrict')
-    firm.companies.create(:name => 'child')
+    firm = RestrictedWithExceptionFirm.create!(:name => "restrict")
+    firm.companies.create(:name => "child")
 
     assert !firm.companies.empty?
     assert_raise(ActiveRecord::DeleteRestrictionError) { firm.destroy }
-    assert RestrictedWithExceptionFirm.exists?(:name => 'restrict')
-    assert firm.companies.exists?(:name => 'child')
+    assert RestrictedWithExceptionFirm.exists?(:name => "restrict")
+    assert firm.companies.exists?(:name => "child")
   end
 
   def test_restrict_with_error_is_deprecated_using_key_many
     I18n.backend = I18n::Backend::Simple.new
-    I18n.backend.store_translations :en, activerecord: { errors: { messages: { restrict_dependent_destroy: { many: 'message for deprecated key' } } } }
+    I18n.backend.store_translations :en, activerecord: { errors: { messages: { restrict_dependent_destroy: { many: "message for deprecated key" } } } }
 
-    firm = RestrictedWithErrorFirm.create!(name: 'restrict')
-    firm.companies.create(name: 'child')
+    firm = RestrictedWithErrorFirm.create!(name: "restrict")
+    firm.companies.create(name: "child")
 
     assert !firm.companies.empty?
 
@@ -1540,16 +1540,16 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
     assert !firm.errors.empty?
 
-    assert_equal 'message for deprecated key', firm.errors[:base].first
-    assert RestrictedWithErrorFirm.exists?(name: 'restrict')
-    assert firm.companies.exists?(name: 'child')
+    assert_equal "message for deprecated key", firm.errors[:base].first
+    assert RestrictedWithErrorFirm.exists?(name: "restrict")
+    assert firm.companies.exists?(name: "child")
   ensure
     I18n.backend.reload!
   end
 
   def test_restrict_with_error
-    firm = RestrictedWithErrorFirm.create!(:name => 'restrict')
-    firm.companies.create(:name => 'child')
+    firm = RestrictedWithErrorFirm.create!(:name => "restrict")
+    firm.companies.create(:name => "child")
 
     assert !firm.companies.empty?
 
@@ -1558,15 +1558,15 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert !firm.errors.empty?
 
     assert_equal "Cannot delete record because dependent companies exist", firm.errors[:base].first
-    assert RestrictedWithErrorFirm.exists?(:name => 'restrict')
-    assert firm.companies.exists?(:name => 'child')
+    assert RestrictedWithErrorFirm.exists?(:name => "restrict")
+    assert firm.companies.exists?(:name => "child")
   end
 
   def test_restrict_with_error_with_locale
     I18n.backend = I18n::Backend::Simple.new
-    I18n.backend.store_translations 'en', activerecord: {attributes: {restricted_with_error_firm: {companies: 'client companies'}}}
-    firm = RestrictedWithErrorFirm.create!(name: 'restrict')
-    firm.companies.create(name: 'child')
+    I18n.backend.store_translations "en", activerecord: {attributes: {restricted_with_error_firm: {companies: "client companies"}}}
+    firm = RestrictedWithErrorFirm.create!(name: "restrict")
+    firm.companies.create(name: "child")
 
     assert !firm.companies.empty?
 
@@ -1575,8 +1575,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert !firm.errors.empty?
 
     assert_equal "Cannot delete record because dependent client companies exist", firm.errors[:base].first
-    assert RestrictedWithErrorFirm.exists?(name: 'restrict')
-    assert firm.companies.exists?(name: 'child')
+    assert RestrictedWithErrorFirm.exists?(name: "restrict")
+    assert firm.companies.exists?(name: "child")
   ensure
     I18n.backend.reload!
   end
@@ -1586,10 +1586,10 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_included_in_collection_for_new_records
-    client = Client.create(:name => 'Persisted')
+    client = Client.create(:name => "Persisted")
     assert_nil client.client_of
     assert_equal false, Firm.new.clients_of_firm.include?(client),
-     'includes a client that does not belong to any firm'
+     "includes a client that does not belong to any firm"
   end
 
   def test_adding_array_and_collection
@@ -1644,7 +1644,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
       firm.clients = []
     end
 
-    assert_equal [], firm.send('clients=', [])
+    assert_equal [], firm.send("clients=", [])
   end
 
   def test_transactions_when_replacing_on_persisted
@@ -1724,8 +1724,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_assign_ids_ignoring_blanks
-    firm = Firm.create!(:name => 'Apple')
-    firm.client_ids = [companies(:first_client).id, nil, companies(:second_client).id, '']
+    firm = Firm.create!(:name => "Apple")
+    firm.client_ids = [companies(:first_client).id, nil, companies(:second_client).id, ""]
     firm.save!
 
     assert_equal 2, firm.clients.reload.size
@@ -1747,7 +1747,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_dynamic_find_should_respect_association_order_for_through
     assert_equal Comment.find(10), authors(:david).comments_desc.where("comments.type = 'SpecialComment'").first
-    assert_equal Comment.find(10), authors(:david).comments_desc.find_by_type('SpecialComment')
+    assert_equal Comment.find(10), authors(:david).comments_desc.find_by_type("SpecialComment")
   end
 
   def test_has_many_through_respects_hash_conditions
@@ -1781,7 +1781,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_include_returns_false_for_non_matching_record_to_verify_scoping
     firm = companies(:first_firm)
-    client = Client.create!(:name => 'Not Associated')
+    client = Client.create!(:name => "Not Associated")
 
     assert ! firm.clients.loaded?
     assert_equal false, firm.clients.include?(client)
@@ -1810,7 +1810,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_calling_first_or_last_on_existing_record_with_build_should_load_association
     firm = companies(:first_firm)
-    firm.clients.build(:name => 'Foo')
+    firm.clients.build(:name => "Foo")
     assert !firm.clients.loaded?
 
     assert_queries 1 do
@@ -1824,7 +1824,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_calling_first_nth_or_last_on_existing_record_with_create_should_not_load_association
     firm = companies(:first_firm)
-    firm.clients.create(:name => 'Foo')
+    firm.clients.create(:name => "Foo")
     assert !firm.clients.loaded?
 
     assert_queries 3 do
@@ -1848,7 +1848,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_calling_first_or_last_with_integer_on_association_should_not_load_association
     firm = companies(:first_firm)
-    firm.clients.create(:name => 'Foo')
+    firm.clients.create(:name => "Foo")
     assert !firm.clients.loaded?
 
     assert_queries 2 do
@@ -1978,8 +1978,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     old = ActiveRecord::Base.store_full_sti_class
     ActiveRecord::Base.store_full_sti_class = true
 
-    firm = Namespaced::Firm.create({ :name => 'Some Company' })
-    firm.clients.create({ :name => 'Some Client' })
+    firm = Namespaced::Firm.create({ :name => "Some Company" })
+    firm.clients.create({ :name => "Some Client" })
 
     stats = Namespaced::Firm.all.merge!(
       :select => "#{Namespaced::Firm.table_name}.id, COUNT(#{Namespaced::Client.table_name}.id) AS num_clients",
@@ -2011,7 +2011,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_creating_using_primary_key
     firm = Firm.all.merge!(:order => "id").first
-    client = firm.clients_using_primary_key.create!(:name => 'test')
+    client = firm.clients_using_primary_key.create!(:name => "test")
     assert_equal firm.name, client.firm_name
   end
 
@@ -2039,7 +2039,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_attributes_are_being_set_when_initialized_from_has_many_association_with_multiple_where_clauses
-    new_comment = posts(:welcome).comments.where(:body => "Some content").where(:type => 'SpecialComment').build
+    new_comment = posts(:welcome).comments.where(:body => "Some content").where(:type => "SpecialComment").build
     assert_equal new_comment.body, "Some content"
     assert_equal new_comment.type, "SpecialComment"
     assert_equal new_comment.post_id, posts(:welcome).id
@@ -2096,7 +2096,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_with_polymorphic_has_many_with_custom_columns_name
-    post = Post.create! :title => 'foo', :body => 'bar'
+    post = Post.create! :title => "foo", :body => "bar"
     image = Image.create!
 
     post.images << image
@@ -2106,10 +2106,10 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_build_with_polymorphic_has_many_does_not_allow_to_override_type_and_id
     welcome = posts(:welcome)
-    tagging = welcome.taggings.build(:taggable_id => 99, :taggable_type => 'ShouldNotChange')
+    tagging = welcome.taggings.build(:taggable_id => 99, :taggable_type => "ShouldNotChange")
 
     assert_equal welcome.id, tagging.taggable_id
-    assert_equal 'Post', tagging.taggable_type
+    assert_equal "Post", tagging.taggable_type
   end
 
   def test_dont_call_save_callbacks_twice_on_has_many
@@ -2121,30 +2121,30 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_association_attributes_are_available_to_after_initialize
-    car = Car.create(:name => 'honda')
+    car = Car.create(:name => "honda")
     bulb = car.bulbs.build
 
-    assert_equal car.id, bulb.attributes_after_initialize['car_id']
+    assert_equal car.id, bulb.attributes_after_initialize["car_id"]
   end
 
   def test_attributes_are_set_when_initialized_from_has_many_null_relationship
-    car  = Car.new name: 'honda'
-    bulb = car.bulbs.where(name: 'headlight').first_or_initialize
-    assert_equal 'headlight', bulb.name
+    car  = Car.new name: "honda"
+    bulb = car.bulbs.where(name: "headlight").first_or_initialize
+    assert_equal "headlight", bulb.name
   end
 
   def test_attributes_are_set_when_initialized_from_polymorphic_has_many_null_relationship
-    post    = Post.new title: 'title', body: 'bar'
-    tag     = Tag.create!(name: 'foo')
+    post    = Post.new title: "title", body: "bar"
+    tag     = Tag.create!(name: "foo")
 
     tagging = post.taggings.where(tag: tag).first_or_initialize
 
     assert_equal tag.id, tagging.tag_id
-    assert_equal 'Post', tagging.taggable_type
+    assert_equal "Post", tagging.taggable_type
   end
 
   def test_replace
-    car = Car.create(:name => 'honda')
+    car = Car.create(:name => "honda")
     bulb1 = car.bulbs.create
     bulb2 = Bulb.create
 
@@ -2155,7 +2155,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_replace_returns_target
-    car = Car.create(:name => 'honda')
+    car = Car.create(:name => "honda")
     bulb1 = car.bulbs.create
     bulb2 = car.bulbs.create
     bulb3 = Bulb.create
@@ -2172,15 +2172,15 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   test "first_or_initialize adds the record to the association" do
-    firm = Firm.create! name: 'omg'
+    firm = Firm.create! name: "omg"
     client = firm.clients_of_firm.first_or_initialize
     assert_equal [client], firm.clients_of_firm
   end
 
   test "first_or_create adds the record to the association" do
-    firm = Firm.create! name: 'omg'
+    firm = Firm.create! name: "omg"
     firm.clients_of_firm.load_target
-    client = firm.clients_of_firm.first_or_create name: 'lol'
+    client = firm.clients_of_firm.first_or_create name: "lol"
     assert_equal [client], firm.clients_of_firm
     assert_equal [client], firm.reload.clients_of_firm
   end
@@ -2202,7 +2202,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
     assert_no_queries(ignore_none: false) do
       assert_equal [], post.comments
-      assert_equal [], post.comments.where(body: 'omg')
+      assert_equal [], post.comments.where(body: "omg")
       assert_equal [], post.comments.pluck(:body)
       assert_equal 0,  post.comments.sum(:id)
       assert_equal 0,  post.comments.count
@@ -2230,7 +2230,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     david = authors(:david)
 
     post = david.posts.first
-    post.type = 'PostWithSpecialCategorization'
+    post.type = "PostWithSpecialCategorization"
     post.save
 
     categorization = post.categorizations.first
@@ -2243,8 +2243,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   test "does not duplicate associations when used with natural primary keys" do
-    speedometer = Speedometer.create!(id: '4')
-    speedometer.minivans.create!(minivan_id: 'a-van-red' ,name: 'a van', color: 'red')
+    speedometer = Speedometer.create!(id: "4")
+    speedometer.minivans.create!(minivan_id: "a-van-red" ,name: "a van", color: "red")
 
     assert_equal 1, speedometer.minivans.to_a.size, "Only one association should be present:\n#{speedometer.minivans.to_a}"
     assert_equal 1, speedometer.reload.minivans.to_a.size
@@ -2260,7 +2260,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   test "can unscope and where the default scope of the associated model" do
-    Car.has_many :other_bulbs, -> { unscope(where: [:name]).where(name: 'other') }, class_name: "Bulb"
+    Car.has_many :other_bulbs, -> { unscope(where: [:name]).where(name: "other") }, class_name: "Bulb"
     car = Car.create!
     bulb1 = Bulb.create! name: "defaulty", car: car
     bulb2 = Bulb.create! name: "other",    car: car
@@ -2270,7 +2270,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   test "can rewhere the default scope of the associated model" do
-    Car.has_many :old_bulbs, -> { rewhere(name: 'old') }, class_name: "Bulb"
+    Car.has_many :old_bulbs, -> { rewhere(name: "old") }, class_name: "Bulb"
     car = Car.create!
     bulb1 = Bulb.create! name: "defaulty", car: car
     bulb2 = Bulb.create! name: "old",      car: car
@@ -2279,7 +2279,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal [bulb2], car.old_bulbs
   end
 
-  test 'unscopes the default scope of associated model when used with include' do
+  test "unscopes the default scope of associated model when used with include" do
     car = Car.create!
     bulb = Bulb.create! name: "other", car: car
 
@@ -2299,7 +2299,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal "Failed to destroy the record", error.message
   end
 
-  test 'updates counter cache when default scope is given' do
+  test "updates counter cache when default scope is given" do
     topic = DefaultRejectedTopic.create approved: true
 
     assert_difference "topic.reload.replies_count", 1 do
@@ -2307,8 +2307,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'dangerous association name raises ArgumentError' do
-    [:errors, 'errors', :save, 'save'].each do |name|
+  test "dangerous association name raises ArgumentError" do
+    [:errors, "errors", :save, "save"].each do |name|
       assert_raises(ArgumentError, "Association #{name} should not be allowed") do
         Class.new(ActiveRecord::Base) do
           has_many name
@@ -2317,7 +2317,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'passes custom context validation to validate children' do
+  test "passes custom context validation to validate children" do
     pirate = FamousPirate.new
     pirate.famous_ships << ship = FamousShip.new
 
@@ -2326,7 +2326,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal "can't be blank", ship.errors[:name].first
   end
 
-  test 'association with instance dependent scope' do
+  test "association with instance dependent scope" do
     bob = authors(:bob)
     Post.create!(title: "signed post by bob", body: "stuff", author: authors(:bob))
     Post.create!(title: "anonymous post", body: "more stuff", author: authors(:bob))
@@ -2336,7 +2336,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal [], authors(:david).posts_with_signature.map(&:title)
   end
 
-  test 'associations autosaves when object is already persisted' do
+  test "associations autosaves when object is already persisted" do
     bulb = Bulb.create!
     tyre = Tyre.create!
 
@@ -2349,7 +2349,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal 1, car.tyres.count
   end
 
-  test 'associations replace in memory when records have the same id' do
+  test "associations replace in memory when records have the same id" do
     bulb = Bulb.create!
     car = Car.create!(bulbs: [bulb])
 
@@ -2360,7 +2360,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal "foo", car.bulbs.first.name
   end
 
-  test 'in memory replacement executes no queries' do
+  test "in memory replacement executes no queries" do
     bulb = Bulb.create!
     car = Car.create!(bulbs: [bulb])
 
@@ -2371,7 +2371,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'in memory replacements do not execute callbacks' do
+  test "in memory replacements do not execute callbacks" do
     raise_after_add = false
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = :cars
@@ -2392,7 +2392,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'in memory replacements sets inverse instance' do
+  test "in memory replacements sets inverse instance" do
     bulb = Bulb.create!
     car = Car.create!(bulbs: [bulb])
 
@@ -2402,7 +2402,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_same car, new_bulb.car
   end
 
-  test 'in memory replacement maintains order' do
+  test "in memory replacement maintains order" do
     first_bulb = Bulb.create!
     second_bulb = Bulb.create!
     car = Car.create!(bulbs: [first_bulb, second_bulb])
@@ -2413,7 +2413,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal [first_bulb, second_bulb], car.bulbs
   end
 
-  test 'double insertion of new object to association when same association used in the after create callback of a new object' do
+  test "double insertion of new object to association when same association used in the after create callback of a new object" do
     car = Car.create!
     car.bulbs << TrickyBulb.new
     assert_equal 1, car.bulbs.size
@@ -2456,7 +2456,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_ids_reader_memoization
-    car = Car.create!(name: 'Tofaş')
+    car = Car.create!(name: "Tofaş")
     bulb = Bulb.create!(car: car)
 
     assert_equal [bulb.id], car.bulb_ids
diff --git a/activerecord/test/cases/associations/has_many_through_associations_test.rb b/activerecord/test/cases/associations/has_many_through_associations_test.rb
index aa35844a03..f6c723aebd 100644
--- a/activerecord/test/cases/associations/has_many_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_through_associations_test.rb
@@ -1,33 +1,33 @@
 require "cases/helper"
-require 'models/post'
-require 'models/person'
-require 'models/reference'
-require 'models/job'
-require 'models/reader'
-require 'models/comment'
-require 'models/rating'
-require 'models/tag'
-require 'models/tagging'
-require 'models/author'
-require 'models/owner'
-require 'models/pet'
-require 'models/pet_treasure'
-require 'models/toy'
-require 'models/treasure'
-require 'models/contract'
-require 'models/company'
-require 'models/developer'
-require 'models/computer'
-require 'models/subscriber'
-require 'models/book'
-require 'models/subscription'
-require 'models/essay'
-require 'models/category'
-require 'models/categorization'
-require 'models/member'
-require 'models/membership'
-require 'models/club'
-require 'models/organization'
+require "models/post"
+require "models/person"
+require "models/reference"
+require "models/job"
+require "models/reader"
+require "models/comment"
+require "models/rating"
+require "models/tag"
+require "models/tagging"
+require "models/author"
+require "models/owner"
+require "models/pet"
+require "models/pet_treasure"
+require "models/toy"
+require "models/treasure"
+require "models/contract"
+require "models/company"
+require "models/developer"
+require "models/computer"
+require "models/subscriber"
+require "models/book"
+require "models/subscription"
+require "models/essay"
+require "models/category"
+require "models/categorization"
+require "models/member"
+require "models/membership"
+require "models/club"
+require "models/organization"
 
 class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   fixtures :posts, :readers, :people, :comments, :authors, :categories, :taggings, :tags,
@@ -37,7 +37,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   # Dummies to force column loads so query counts are clean.
   def setup
-    Person.create :first_name => 'gummy'
+    Person.create :first_name => "gummy"
     Reader.create :person_id => 0, :post_id => 0
   end
 
@@ -49,9 +49,9 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_preload_sti_middle_relation
-    club = Club.create!(name: 'Aaron cool banana club')
-    member1 = Member.create!(name: 'Aaron')
-    member2 = Member.create!(name: 'Cat')
+    club = Club.create!(name: "Aaron cool banana club")
+    member1 = Member.create!(name: "Aaron")
+    member2 = Member.create!(name: "Cat")
 
     SuperMembership.create! club: club, member: member1
     CurrentMembership.create! club: club, member: member2
@@ -67,10 +67,10 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_ordered_has_many_through
     person_prime = Class.new(ActiveRecord::Base) do
-      def self.name; 'Person'; end
+      def self.name; "Person"; end
 
       has_many :readers
-      has_many :posts, -> { order('posts.id DESC') }, :through => :readers
+      has_many :posts, -> { order("posts.id DESC") }, :through => :readers
     end
     posts = person_prime.includes(:posts).first.posts
 
@@ -85,7 +85,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     subscription = make_model "Subscription"
     subscriber   = make_model "Subscriber"
 
-    subscriber.primary_key = 'nick'
+    subscriber.primary_key = "nick"
     subscription.belongs_to :book,       anonymous_class: book
     subscription.belongs_to :subscriber, anonymous_class: subscriber
 
@@ -124,8 +124,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
     sicp.students.reload
     assert_operator lesson_student.count, :>=, 2
-    assert_no_difference('student.count') do
-      assert_difference('lesson_student.count', -2) do
+    assert_no_difference("student.count") do
+      assert_difference("lesson_student.count", -2) do
         sicp.students.destroy(*student.all.to_a)
       end
     end
@@ -150,11 +150,11 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def make_no_pk_hm_t
-    lesson = make_model 'Lesson'
-    student = make_model 'Student'
+    lesson = make_model "Lesson"
+    student = make_model "Student"
 
-    lesson_student = make_model 'LessonStudent'
-    lesson_student.table_name = 'lessons_students'
+    lesson_student = make_model "LessonStudent"
+    lesson_student.table_name = "lessons_students"
 
     lesson_student.belongs_to :lesson, :anonymous_class => lesson
     lesson_student.belongs_to :student, :anonymous_class => student
@@ -197,8 +197,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     person = people(:david)
     assert_equal 1, person.jobs_with_dependent_destroy.count
 
-    assert_no_difference 'Job.count' do
-      assert_difference 'Reference.count', -1 do
+    assert_no_difference "Job.count" do
+      assert_difference "Reference.count", -1 do
         person.reload.jobs_with_dependent_destroy.delete_all
       end
     end
@@ -208,8 +208,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     person = people(:david)
     assert_equal 1, person.jobs_with_dependent_nullify.count
 
-    assert_no_difference 'Job.count' do
-      assert_no_difference 'Reference.count' do
+    assert_no_difference "Job.count" do
+      assert_no_difference "Reference.count" do
         person.reload.jobs_with_dependent_nullify.delete_all
       end
     end
@@ -219,8 +219,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     person = people(:david)
     assert_equal 1, person.jobs_with_dependent_delete_all.count
 
-    assert_no_difference 'Job.count' do
-      assert_difference 'Reference.count', -1 do
+    assert_no_difference "Job.count" do
+      assert_difference "Reference.count", -1 do
         person.reload.jobs_with_dependent_delete_all.delete_all
       end
     end
@@ -238,7 +238,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     post   = posts(:thinking)
     person = people(:david)
 
-    assert_difference 'post.people.to_a.count', 2 do
+    assert_difference "post.people.to_a.count", 2 do
       post.people << person
       post.people << person
     end
@@ -248,7 +248,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     post   = posts(:thinking)
     person = people(:david)
 
-    assert_difference 'post.people.count', 2 do
+    assert_difference "post.people.count", 2 do
       post.people << person
       post.people << person
     end
@@ -261,7 +261,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     post.people << person
     post.people << person
 
-    counts = ['post.people.count', 'post.people.to_a.count', 'post.readers.count', 'post.readers.to_a.count']
+    counts = ["post.people.count", "post.people.to_a.count", "post.readers.count", "post.readers.to_a.count"]
     assert_difference counts, -2 do
       post.people.delete(person)
     end
@@ -274,7 +274,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     new_person = nil # so block binding catches it
 
     assert_queries(0) do
-      new_person = Person.new :first_name => 'bob'
+      new_person = Person.new :first_name => "bob"
     end
 
     # Associating new records always saves them
@@ -308,7 +308,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     #    * 2 new records = 4
     # + 1 query to save the actual post = 5
     assert_queries(5) do
-      posts(:thinking).body += '-changed'
+      posts(:thinking).body += "-changed"
       posts(:thinking).save
     end
 
@@ -335,8 +335,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_both_parent_ids_set_when_saving_new
-    post = Post.new(title: 'Hello', body: 'world')
-    person = Person.new(first_name: 'Sean')
+    post = Post.new(title: "Hello", body: "world")
+    person = Person.new(first_name: "Sean")
 
     post.people = [person]
     post.save
@@ -396,8 +396,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     job       = jobs(:magician)
     reference = Reference.where(:job_id => job.id, :person_id => person.id).first
 
-    assert_no_difference ['Job.count', 'Reference.count'] do
-      assert_difference 'person.jobs.count', -1 do
+    assert_no_difference ["Job.count", "Reference.count"] do
+      assert_difference "person.jobs.count", -1 do
         person.jobs_with_dependent_nullify.delete(job)
       end
     end
@@ -416,8 +416,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     # Make sure we're not deleting everything
     assert person.jobs.count >= 2
 
-    assert_no_difference 'Job.count' do
-      assert_difference ['person.jobs.count', 'Reference.count'], -1 do
+    assert_no_difference "Job.count" do
+      assert_difference ["person.jobs.count", "Reference.count"], -1 do
         person.jobs_with_dependent_delete_all.delete(job)
       end
     end
@@ -437,8 +437,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     # Make sure we're not deleting everything
     assert person.jobs.count >= 2
 
-    assert_no_difference 'Job.count' do
-      assert_difference ['person.jobs.count', 'Reference.count'], -1 do
+    assert_no_difference "Job.count" do
+      assert_difference ["person.jobs.count", "Reference.count"], -1 do
         person.jobs_with_dependent_destroy.delete(job)
       end
     end
@@ -455,8 +455,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     # Create a reference which is not linked to a job. This should not be destroyed.
     person.references.create!
 
-    assert_no_difference 'Job.count' do
-      assert_difference 'Reference.count', -person.jobs.count do
+    assert_no_difference "Job.count" do
+      assert_difference "Reference.count", -person.jobs.count do
         person.destroy
       end
     end
@@ -468,8 +468,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     # Create a reference which is not linked to a job. This should not be destroyed.
     person.references.create!
 
-    assert_no_difference 'Job.count' do
-      assert_difference 'Reference.count', -person.jobs.count do
+    assert_no_difference "Job.count" do
+      assert_difference "Reference.count", -person.jobs.count do
         person.destroy
       end
     end
@@ -480,7 +480,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
     references = person.references.to_a
 
-    assert_no_difference ['Reference.count', 'Job.count'] do
+    assert_no_difference ["Reference.count", "Job.count"] do
       person.destroy
     end
 
@@ -491,30 +491,30 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_update_counter_caches_on_delete
     post = posts(:welcome)
-    tag  = post.tags.create!(:name => 'doomed')
+    tag  = post.tags.create!(:name => "doomed")
 
-    assert_difference ['post.reload.tags_count'], -1 do
+    assert_difference ["post.reload.tags_count"], -1 do
       posts(:welcome).tags.delete(tag)
     end
   end
 
   def test_update_counter_caches_on_delete_with_dependent_destroy
     post = posts(:welcome)
-    tag  = post.tags.create!(:name => 'doomed')
+    tag  = post.tags.create!(:name => "doomed")
     post.update_columns(tags_with_destroy_count: post.tags.count)
 
-    assert_difference ['post.reload.tags_with_destroy_count'], -1 do
+    assert_difference ["post.reload.tags_with_destroy_count"], -1 do
       posts(:welcome).tags_with_destroy.delete(tag)
     end
   end
 
   def test_update_counter_caches_on_delete_with_dependent_nullify
     post = posts(:welcome)
-    tag  = post.tags.create!(:name => 'doomed')
+    tag  = post.tags.create!(:name => "doomed")
     post.update_columns(tags_with_nullify_count: post.tags.count)
 
-    assert_no_difference 'post.reload.tags_count' do
-      assert_difference 'post.reload.tags_with_nullify_count', -1 do
+    assert_no_difference "post.reload.tags_count" do
+      assert_difference "post.reload.tags_with_nullify_count", -1 do
         posts(:welcome).tags_with_nullify.delete(tag)
       end
     end
@@ -522,7 +522,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_update_counter_caches_on_replace_association
     post = posts(:welcome)
-    tag  = post.tags.create!(:name => 'doomed')
+    tag  = post.tags.create!(:name => "doomed")
     tag.tagged_posts << posts(:thinking)
 
     tag.tagged_posts = []
@@ -533,9 +533,9 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_update_counter_caches_on_destroy
     post = posts(:welcome)
-    tag  = post.tags.create!(name: 'doomed')
+    tag  = post.tags.create!(name: "doomed")
 
-    assert_difference 'post.reload.tags_count', -1 do
+    assert_difference "post.reload.tags_count", -1 do
       tag.tagged_posts.destroy(post)
     end
   end
@@ -561,23 +561,23 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   def test_replace_order_is_preserved
     posts(:welcome).people.clear
     posts(:welcome).people = [people(:david), people(:michael)]
-    assert_equal [people(:david).id, people(:michael).id], posts(:welcome).readers.order('id').map(&:person_id)
+    assert_equal [people(:david).id, people(:michael).id], posts(:welcome).readers.order("id").map(&:person_id)
 
     # Test the inverse order in case the first success was a coincidence
     posts(:welcome).people.clear
     posts(:welcome).people = [people(:michael), people(:david)]
-    assert_equal [people(:michael).id, people(:david).id], posts(:welcome).readers.order('id').map(&:person_id)
+    assert_equal [people(:michael).id, people(:david).id], posts(:welcome).readers.order("id").map(&:person_id)
   end
 
   def test_replace_by_id_order_is_preserved
     posts(:welcome).people.clear
     posts(:welcome).person_ids = [people(:david).id, people(:michael).id]
-    assert_equal [people(:david).id, people(:michael).id], posts(:welcome).readers.order('id').map(&:person_id)
+    assert_equal [people(:david).id, people(:michael).id], posts(:welcome).readers.order("id").map(&:person_id)
 
     # Test the inverse order in case the first success was a coincidence
     posts(:welcome).people.clear
     posts(:welcome).person_ids = [people(:michael).id, people(:david).id]
-    assert_equal [people(:michael).id, people(:david).id], posts(:welcome).readers.order('id').map(&:person_id)
+    assert_equal [people(:michael).id, people(:david).id], posts(:welcome).readers.order("id").map(&:person_id)
   end
 
   def test_associate_with_create
@@ -605,19 +605,19 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_associate_with_create_and_no_options
     peeps = posts(:thinking).people.count
-    posts(:thinking).people.create(:first_name => 'foo')
+    posts(:thinking).people.create(:first_name => "foo")
     assert_equal peeps + 1, posts(:thinking).people.count
   end
 
   def test_associate_with_create_with_through_having_conditions
     impatient_people = posts(:thinking).impatient_people.count
-    posts(:thinking).impatient_people.create!(:first_name => 'foo')
+    posts(:thinking).impatient_people.create!(:first_name => "foo")
     assert_equal impatient_people + 1, posts(:thinking).impatient_people.count
   end
 
   def test_associate_with_create_exclamation_and_no_options
     peeps = posts(:thinking).people.count
-    posts(:thinking).people.create!(:first_name => 'foo')
+    posts(:thinking).people.create!(:first_name => "foo")
     assert_equal peeps + 1, posts(:thinking).people.count
   end
 
@@ -633,38 +633,38 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_associate_with_create_and_invalid_options
     firm = companies(:first_firm)
-    assert_no_difference('firm.developers.count') { assert_nothing_raised { firm.developers.create(:name => '0') } }
+    assert_no_difference("firm.developers.count") { assert_nothing_raised { firm.developers.create(:name => "0") } }
   end
 
   def test_associate_with_create_and_valid_options
     firm = companies(:first_firm)
-    assert_difference('firm.developers.count', 1) { firm.developers.create(:name => 'developer') }
+    assert_difference("firm.developers.count", 1) { firm.developers.create(:name => "developer") }
   end
 
   def test_associate_with_create_bang_and_invalid_options
     firm = companies(:first_firm)
-    assert_no_difference('firm.developers.count') { assert_raises(ActiveRecord::RecordInvalid) { firm.developers.create!(:name => '0') } }
+    assert_no_difference("firm.developers.count") { assert_raises(ActiveRecord::RecordInvalid) { firm.developers.create!(:name => "0") } }
   end
 
   def test_associate_with_create_bang_and_valid_options
     firm = companies(:first_firm)
-    assert_difference('firm.developers.count', 1) { firm.developers.create!(:name => 'developer') }
+    assert_difference("firm.developers.count", 1) { firm.developers.create!(:name => "developer") }
   end
 
   def test_push_with_invalid_record
     firm = companies(:first_firm)
-    assert_raises(ActiveRecord::RecordInvalid) { firm.developers << Developer.new(:name => '0') }
+    assert_raises(ActiveRecord::RecordInvalid) { firm.developers << Developer.new(:name => "0") }
   end
 
   def test_push_with_invalid_join_record
     repair_validations(Contract) do
-      Contract.validate {|r| r.errors[:base] << 'Invalid Contract' }
+      Contract.validate {|r| r.errors[:base] << "Invalid Contract" }
 
       firm = companies(:first_firm)
-      lifo = Developer.new(:name => 'lifo')
+      lifo = Developer.new(:name => "lifo")
       assert_raises(ActiveRecord::RecordInvalid) { firm.developers << lifo }
 
-      lifo = Developer.create!(:name => 'lifo')
+      lifo = Developer.create!(:name => "lifo")
       assert_raises(ActiveRecord::RecordInvalid) { firm.developers << lifo }
     end
   end
@@ -729,7 +729,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   def test_dynamic_find_should_respect_association_include
     # SQL error in sort clause if :include is not included
     # due to Unknown column 'comments.id'
-    assert Person.find(1).posts_with_comments_sorted_by_comment_id.find_by_title('Welcome to the weblog')
+    assert Person.find(1).posts_with_comments_sorted_by_comment_id.find_by_title("Welcome to the weblog")
   end
 
   def test_count_with_include_should_alias_join_table
@@ -745,7 +745,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_get_ids_for_has_many_through_with_conditions_should_not_preload
-    Tagging.create!(:taggable_type => 'Post', :taggable_id => posts(:welcome).id, :tag => tags(:misc))
+    Tagging.create!(:taggable_type => "Post", :taggable_id => posts(:welcome).id, :tag => tags(:misc))
     assert_not_called(ActiveRecord::Associations::Preloader, :new) do
       posts(:welcome).misc_tag_ids
     end
@@ -816,8 +816,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_has_many_association_through_a_has_many_association_to_self
-    sarah = Person.create!(:first_name => 'Sarah', :primary_contact_id => people(:susan).id, :gender => 'F', :number1_fan_id => 1)
-    john = Person.create!(:first_name => 'John', :primary_contact_id => sarah.id, :gender => 'M', :number1_fan_id => 1)
+    sarah = Person.create!(:first_name => "Sarah", :primary_contact_id => people(:susan).id, :gender => "F", :number1_fan_id => 1)
+    john = Person.create!(:first_name => "John", :primary_contact_id => sarah.id, :gender => "M", :number1_fan_id => 1)
     assert_equal sarah.agents, [john]
     assert_equal people(:susan).agents.flat_map(&:agents), people(:susan).agents_of_agents
   end
@@ -899,7 +899,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_attributes_are_being_set_when_initialized_from_hm_through_association_with_multiple_where_clauses
-    new_subscriber = books(:awdr).subscribers.where(:nick => "marklazz").where(:name => 'Marcelo Giorgi').build
+    new_subscriber = books(:awdr).subscribers.where(:nick => "marklazz").where(:name => "Marcelo Giorgi").build
     assert_equal new_subscriber.nick, "marklazz"
     assert_equal new_subscriber.name, "Marcelo Giorgi"
   end
@@ -932,7 +932,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   def test_has_many_through_polymorphic_with_primary_key_option
     assert_equal [categories(:general)], authors(:david).essay_categories
 
-    authors = Author.joins(:essay_categories).where('categories.id' => categories(:general).id)
+    authors = Author.joins(:essay_categories).where("categories.id" => categories(:general).id)
     assert_equal authors(:david), authors.first
 
     assert_equal [owners(:blackbeard)], authors(:david).essay_owners
@@ -944,7 +944,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   def test_has_many_through_with_primary_key_option
     assert_equal [categories(:general)], authors(:david).essay_categories_2
 
-    authors = Author.joins(:essay_categories_2).where('categories.id' => categories(:general).id)
+    authors = Author.joins(:essay_categories_2).where("categories.id" => categories(:general).id)
     assert_equal authors(:david), authors.first
   end
 
@@ -956,7 +956,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_has_many_through_with_default_scope_on_join_model
-    assert_equal posts(:welcome).comments.order('id').to_a, authors(:david).comments_on_first_posts
+    assert_equal posts(:welcome).comments.order("id").to_a, authors(:david).comments_on_first_posts
   end
 
   def test_create_has_many_through_with_default_scope_on_join_model
@@ -971,15 +971,15 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_joining_has_many_through_belongs_to
-    posts = Post.joins(:author_categorizations).order('posts.id').
-                 where('categorizations.id' => categorizations(:mary_thinking_sti).id)
+    posts = Post.joins(:author_categorizations).order("posts.id").
+                 where("categorizations.id" => categorizations(:mary_thinking_sti).id)
 
     assert_equal [posts(:eager_other), posts(:misc_by_mary), posts(:other_by_mary)], posts
   end
 
   def test_select_chosen_fields_only
     author = authors(:david)
-    assert_equal ['body', 'id'].sort, author.comments.select('comments.body').first.attributes.keys.sort
+    assert_equal ["body", "id"].sort, author.comments.select("comments.body").first.attributes.keys.sort
   end
 
   def test_get_has_many_through_belongs_to_ids_with_conditions
@@ -1039,29 +1039,29 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_create_should_not_raise_exception_when_join_record_has_errors
     repair_validations(Categorization) do
-      Categorization.validate { |r| r.errors[:base] << 'Invalid Categorization' }
-      Category.create(:name => 'Fishing', :authors => [Author.first])
+      Categorization.validate { |r| r.errors[:base] << "Invalid Categorization" }
+      Category.create(:name => "Fishing", :authors => [Author.first])
     end
   end
 
   def test_assign_array_to_new_record_builds_join_records
-    c = Category.new(:name => 'Fishing', :authors => [Author.first])
+    c = Category.new(:name => "Fishing", :authors => [Author.first])
     assert_equal 1, c.categorizations.size
   end
 
   def test_create_bang_should_raise_exception_when_join_record_has_errors
     repair_validations(Categorization) do
-      Categorization.validate { |r| r.errors[:base] << 'Invalid Categorization' }
+      Categorization.validate { |r| r.errors[:base] << "Invalid Categorization" }
       assert_raises(ActiveRecord::RecordInvalid) do
-        Category.create!(:name => 'Fishing', :authors => [Author.first])
+        Category.create!(:name => "Fishing", :authors => [Author.first])
       end
     end
   end
 
   def test_save_bang_should_raise_exception_when_join_record_has_errors
     repair_validations(Categorization) do
-      Categorization.validate { |r| r.errors[:base] << 'Invalid Categorization' }
-      c = Category.new(:name => 'Fishing', :authors => [Author.first])
+      Categorization.validate { |r| r.errors[:base] << "Invalid Categorization" }
+      c = Category.new(:name => "Fishing", :authors => [Author.first])
       assert_raises(ActiveRecord::RecordInvalid) do
         c.save!
       end
@@ -1070,17 +1070,17 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_save_returns_falsy_when_join_record_has_errors
     repair_validations(Categorization) do
-      Categorization.validate { |r| r.errors[:base] << 'Invalid Categorization' }
-      c = Category.new(:name => 'Fishing', :authors => [Author.first])
+      Categorization.validate { |r| r.errors[:base] << "Invalid Categorization" }
+      c = Category.new(:name => "Fishing", :authors => [Author.first])
       assert_not c.save
     end
   end
 
   def test_preloading_empty_through_association_via_joins
     person = Person.create!(:first_name => "Gaga")
-    person = Person.where(:id => person.id).where('readers.id = 1 or 1=1').references(:readers).includes(:posts).to_a.first
+    person = Person.where(:id => person.id).where("readers.id = 1 or 1=1").references(:readers).includes(:posts).to_a.first
 
-    assert person.posts.loaded?, 'person.posts should be loaded'
+    assert person.posts.loaded?, "person.posts should be loaded"
     assert_equal [], person.posts
   end
 
@@ -1116,7 +1116,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
     assert_no_queries(ignore_none: false) do
       assert_equal [], person.posts
-      assert_equal [], person.posts.where(body: 'omg')
+      assert_equal [], person.posts.where(body: "omg")
       assert_equal [], person.posts.pluck(:body)
       assert_equal 0,  person.posts.sum(:tags_count)
       assert_equal 0,  person.posts.count
@@ -1148,7 +1148,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_has_many_through_unscope_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
 
@@ -1160,8 +1160,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_has_many_through_add_with_sti_middle_relation
-    club = SuperClub.create!(name: 'Fight Club')
-    member = Member.create!(name: 'Tyler Durden')
+    club = SuperClub.create!(name: "Fight Club")
+    member = Member.create!(name: "Tyler Durden")
 
     club.members << member
     assert_equal 1, SuperMembership.where(member_id: member.id, club_id: club.id).count
diff --git a/activerecord/test/cases/associations/has_one_associations_test.rb b/activerecord/test/cases/associations/has_one_associations_test.rb
index 1574f373c2..9b049438f1 100644
--- a/activerecord/test/cases/associations/has_one_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_associations_test.rb
@@ -1,15 +1,15 @@
 require "cases/helper"
-require 'models/developer'
-require 'models/computer'
-require 'models/project'
-require 'models/company'
-require 'models/ship'
-require 'models/pirate'
-require 'models/car'
-require 'models/bulb'
-require 'models/author'
-require 'models/image'
-require 'models/post'
+require "models/developer"
+require "models/computer"
+require "models/project"
+require "models/company"
+require "models/ship"
+require "models/pirate"
+require "models/car"
+require "models/bulb"
+require "models/author"
+require "models/image"
+require "models/post"
 
 class HasOneAssociationsTest < ActiveRecord::TestCase
   self.use_transactional_tests = false unless supports_savepoints?
@@ -28,7 +28,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     ActiveRecord::SQLCounter.clear_log
     companies(:first_firm).account
   ensure
-    assert ActiveRecord::SQLCounter.log_all.all? { |sql| /order by/i !~ sql }, 'ORDER BY was used in the query'
+    assert ActiveRecord::SQLCounter.log_all.all? { |sql| /order by/i !~ sql }, "ORDER BY was used in the query"
   end
 
   def test_has_one_cache_nils
@@ -170,27 +170,27 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_dependence_with_nil_associate
-    firm = DependentFirm.new(:name => 'nullify')
+    firm = DependentFirm.new(:name => "nullify")
     firm.save!
     assert_nothing_raised { firm.destroy }
   end
 
   def test_restrict_with_exception
-    firm = RestrictedWithExceptionFirm.create!(:name => 'restrict')
+    firm = RestrictedWithExceptionFirm.create!(:name => "restrict")
     firm.create_account(:credit_limit => 10)
 
     assert_not_nil firm.account
 
     assert_raise(ActiveRecord::DeleteRestrictionError) { firm.destroy }
-    assert RestrictedWithExceptionFirm.exists?(:name => 'restrict')
+    assert RestrictedWithExceptionFirm.exists?(:name => "restrict")
     assert firm.account.present?
   end
 
   def test_restrict_with_error_is_deprecated_using_key_one
     I18n.backend = I18n::Backend::Simple.new
-    I18n.backend.store_translations :en, activerecord: { errors: { messages: { restrict_dependent_destroy: { one: 'message for deprecated key' } } } }
+    I18n.backend.store_translations :en, activerecord: { errors: { messages: { restrict_dependent_destroy: { one: "message for deprecated key" } } } }
 
-    firm = RestrictedWithErrorFirm.create!(name: 'restrict')
+    firm = RestrictedWithErrorFirm.create!(name: "restrict")
     firm.create_account(credit_limit: 10)
 
     assert_not_nil firm.account
@@ -198,15 +198,15 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     assert_deprecated { firm.destroy }
 
     assert !firm.errors.empty?
-    assert_equal 'message for deprecated key', firm.errors[:base].first
-    assert RestrictedWithErrorFirm.exists?(name: 'restrict')
+    assert_equal "message for deprecated key", firm.errors[:base].first
+    assert RestrictedWithErrorFirm.exists?(name: "restrict")
     assert firm.account.present?
   ensure
     I18n.backend.reload!
   end
 
   def test_restrict_with_error
-    firm = RestrictedWithErrorFirm.create!(:name => 'restrict')
+    firm = RestrictedWithErrorFirm.create!(:name => "restrict")
     firm.create_account(:credit_limit => 10)
 
     assert_not_nil firm.account
@@ -215,14 +215,14 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
     assert !firm.errors.empty?
     assert_equal "Cannot delete record because a dependent account exists", firm.errors[:base].first
-    assert RestrictedWithErrorFirm.exists?(:name => 'restrict')
+    assert RestrictedWithErrorFirm.exists?(:name => "restrict")
     assert firm.account.present?
   end
 
   def test_restrict_with_error_with_locale
     I18n.backend = I18n::Backend::Simple.new
-    I18n.backend.store_translations 'en', activerecord: {attributes: {restricted_with_error_firm: {account: 'firm account'}}}
-    firm = RestrictedWithErrorFirm.create!(name: 'restrict')
+    I18n.backend.store_translations "en", activerecord: {attributes: {restricted_with_error_firm: {account: "firm account"}}}
+    firm = RestrictedWithErrorFirm.create!(name: "restrict")
     firm.create_account(credit_limit: 10)
 
     assert_not_nil firm.account
@@ -231,7 +231,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
     assert !firm.errors.empty?
     assert_equal "Cannot delete record because a dependent firm account exists", firm.errors[:base].first
-    assert RestrictedWithErrorFirm.exists?(name: 'restrict')
+    assert RestrictedWithErrorFirm.exists?(name: "restrict")
     assert firm.account.present?
   ensure
     I18n.backend.reload!
@@ -319,7 +319,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_create_with_inexistent_foreign_key_failing
-    firm = Firm.create(name: 'GlobalMegaCorp')
+    firm = Firm.create(name: "GlobalMegaCorp")
 
     assert_raises(ActiveRecord::UnknownAttributeError) do
       firm.create_account_with_inexistent_foreign_key
@@ -365,7 +365,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
   def test_finding_with_interpolated_condition
     firm = Firm.first
-    superior = firm.clients.create(:name => 'SuperiorCo')
+    superior = firm.clients.create(:name => "SuperiorCo")
     superior.rating = 10
     superior.save
     assert_equal 10, firm.clients_with_interpolated_conditions.first.rating
@@ -382,7 +382,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_save_still_works_after_accessing_nil_has_one
-    jp = Company.new :name => 'Jaded Pixel'
+    jp = Company.new :name => "Jaded Pixel"
     jp.dummy_account.nil?
 
     assert_nothing_raised do
@@ -435,7 +435,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_attributes_are_being_set_when_initialized_from_has_one_association_with_where_clause
-    new_account = companies(:first_firm).build_account(:firm_name => 'Account')
+    new_account = companies(:first_firm).build_account(:firm_name => "Account")
     assert_equal new_account.firm_name, "Account"
   end
 
@@ -505,7 +505,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_association_keys_bypass_attribute_protection
-    car = Car.create(:name => 'honda')
+    car = Car.create(:name => "honda")
 
     bulb = car.build_bulb
     assert_equal car.id, bulb.car_id
@@ -537,31 +537,31 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_build_with_block
-    car = Car.create(:name => 'honda')
+    car = Car.create(:name => "honda")
 
-    bulb = car.build_bulb{ |b| b.color = 'Red' }
-    assert_equal 'RED!', bulb.color
+    bulb = car.build_bulb{ |b| b.color = "Red" }
+    assert_equal "RED!", bulb.color
   end
 
   def test_create_with_block
-    car = Car.create(:name => 'honda')
+    car = Car.create(:name => "honda")
 
-    bulb = car.create_bulb{ |b| b.color = 'Red' }
-    assert_equal 'RED!', bulb.color
+    bulb = car.create_bulb{ |b| b.color = "Red" }
+    assert_equal "RED!", bulb.color
   end
 
   def test_create_bang_with_block
-    car = Car.create(:name => 'honda')
+    car = Car.create(:name => "honda")
 
-    bulb = car.create_bulb!{ |b| b.color = 'Red' }
-    assert_equal 'RED!', bulb.color
+    bulb = car.create_bulb!{ |b| b.color = "Red" }
+    assert_equal "RED!", bulb.color
   end
 
   def test_association_attributes_are_available_to_after_initialize
-    car = Car.create(:name => 'honda')
+    car = Car.create(:name => "honda")
     bulb = car.create_bulb
 
-    assert_equal car.id, bulb.attributes_after_initialize['car_id']
+    assert_equal car.id, bulb.attributes_after_initialize["car_id"]
   end
 
   def test_has_one_transaction
@@ -581,36 +581,36 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
   def test_has_one_assignment_dont_trigger_save_on_change_of_same_object
     pirate = Pirate.create!(catchphrase: "Don' botharrr talkin' like one, savvy?")
-    ship = pirate.build_ship(name: 'old name')
+    ship = pirate.build_ship(name: "old name")
     ship.save!
 
-    ship.name = 'new name'
+    ship.name = "new name"
     assert ship.changed?
     assert_queries(1) do
       # One query for updating name, not triggering query for updating pirate_id
       pirate.ship = ship
     end
 
-    assert_equal 'new name', pirate.ship.reload.name
+    assert_equal "new name", pirate.ship.reload.name
   end
 
   def test_has_one_assignment_triggers_save_on_change_on_replacing_object
     pirate = Pirate.create!(catchphrase: "Don' botharrr talkin' like one, savvy?")
-    ship = pirate.build_ship(name: 'old name')
+    ship = pirate.build_ship(name: "old name")
     ship.save!
 
-    new_ship = Ship.create(name: 'new name')
+    new_ship = Ship.create(name: "new name")
     assert_queries(2) do
       # One query for updating name and second query for updating pirate_id
       pirate.ship = new_ship
     end
 
-    assert_equal 'new name', pirate.ship.reload.name
+    assert_equal "new name", pirate.ship.reload.name
   end
 
   def test_has_one_autosave_with_primary_key_manually_set
-    post = Post.create(id: 1234, title: "Some title", body: 'Some content')
-    author = Author.new(id: 33, name: 'Hank Moody')
+    post = Post.create(id: 1234, title: "Some title", body: "Some content")
+    author = Author.new(id: 33, name: "Hank Moody")
 
     author.post = post
     author.save
@@ -621,7 +621,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_has_one_loading_for_new_record
-    post = Post.create!(author_id: 42, title: 'foo', body: 'bar')
+    post = Post.create!(author_id: 42, title: "foo", body: "bar")
     author = Author.new(id: 42)
     assert_equal post, author.post
   end
@@ -635,7 +635,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_with_polymorphic_has_one_with_custom_columns_name
-    post = Post.create! :title => 'foo', :body => 'bar'
+    post = Post.create! :title => "foo", :body => "bar"
     image = Image.create!
 
     post.main_image = image
@@ -644,8 +644,8 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     assert_equal image, post.main_image
   end
 
-  test 'dangerous association name raises ArgumentError' do
-    [:errors, 'errors', :save, 'save'].each do |name|
+  test "dangerous association name raises ArgumentError" do
+    [:errors, "errors", :save, "save"].each do |name|
       assert_raises(ArgumentError, "Association #{name} should not be allowed") do
         Class.new(ActiveRecord::Base) do
           has_one name
@@ -661,20 +661,20 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
   end
 
   class SpecialBook < ActiveRecord::Base
-    self.table_name = 'books'
-    belongs_to :author, class_name: 'SpecialAuthor'
+    self.table_name = "books"
+    belongs_to :author, class_name: "SpecialAuthor"
   end
 
   class SpecialAuthor < ActiveRecord::Base
-    self.table_name = 'authors'
-    has_one :book, class_name: 'SpecialBook', foreign_key: 'author_id'
+    self.table_name = "authors"
+    has_one :book, class_name: "SpecialBook", foreign_key: "author_id"
   end
 
   def test_assocation_enum_works_properly
-    author = SpecialAuthor.create!(name: 'Test')
-    book = SpecialBook.create!(status: 'published')
+    author = SpecialAuthor.create!(name: "Test")
+    book = SpecialBook.create!(status: "published")
     author.book = book
 
-    refute_equal 0, SpecialAuthor.joins(:book).where(books: { status: 'published' } ).count
+    refute_equal 0, SpecialAuthor.joins(:book).where(books: { status: "published" } ).count
   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 b2b46812b9..ef1cc3b27a 100644
--- a/activerecord/test/cases/associations/has_one_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_through_associations_test.rb
@@ -1,25 +1,25 @@
 require "cases/helper"
-require 'models/club'
-require 'models/member_type'
-require 'models/member'
-require 'models/membership'
-require 'models/sponsor'
-require 'models/organization'
-require 'models/member_detail'
-require 'models/minivan'
-require 'models/dashboard'
-require 'models/speedometer'
-require 'models/category'
-require 'models/author'
-require 'models/essay'
-require 'models/owner'
-require 'models/post'
-require 'models/comment'
-require 'models/categorization'
-require 'models/customer'
-require 'models/carrier'
-require 'models/shop_account'
-require 'models/customer_carrier'
+require "models/club"
+require "models/member_type"
+require "models/member"
+require "models/membership"
+require "models/sponsor"
+require "models/organization"
+require "models/member_detail"
+require "models/minivan"
+require "models/dashboard"
+require "models/speedometer"
+require "models/category"
+require "models/author"
+require "models/essay"
+require "models/owner"
+require "models/post"
+require "models/comment"
+require "models/categorization"
+require "models/customer"
+require "models/carrier"
+require "models/shop_account"
+require "models/customer_carrier"
 
 class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   fixtures :member_types, :members, :clubs, :memberships, :sponsors, :organizations, :minivans,
@@ -51,8 +51,8 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_creating_association_sets_both_parent_ids_for_new
-    member = Member.new(name: 'Sean Griffin')
-    club = Club.new(name: 'Da Club')
+    member = Member.new(name: "Sean Griffin")
+    club = Club.new(name: "Da Club")
 
     member.club = club
 
@@ -130,7 +130,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_one_through_nonpreload_eagerloading
     members = assert_queries(1) do
-      Member.all.merge!(:includes => :club, :where => ["members.name = ?", "Groucho Marx"], :order => 'clubs.name').to_a #force fallback
+      Member.all.merge!(:includes => :club, :where => ["members.name = ?", "Groucho Marx"], :order => "clubs.name").to_a #force fallback
     end
     assert_equal 1, members.size
     assert_not_nil assert_no_queries {members[0].club}
@@ -138,7 +138,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_one_through_nonpreload_eager_loading_through_polymorphic
     members = assert_queries(1) do
-      Member.all.merge!(:includes => :sponsor_club, :where => ["members.name = ?", "Groucho Marx"], :order => 'clubs.name').to_a #force fallback
+      Member.all.merge!(:includes => :sponsor_club, :where => ["members.name = ?", "Groucho Marx"], :order => "clubs.name").to_a #force fallback
     end
     assert_equal 1, members.size
     assert_not_nil assert_no_queries {members[0].sponsor_club}
@@ -147,7 +147,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   def test_has_one_through_nonpreload_eager_loading_through_polymorphic_with_more_than_one_through_record
     Sponsor.new(:sponsor_club => clubs(:crazy_club), :sponsorable => members(:groucho)).save!
     members = assert_queries(1) do
-      Member.all.merge!(:includes => :sponsor_club, :where => ["members.name = ?", "Groucho Marx"], :order => 'clubs.name DESC').to_a #force fallback
+      Member.all.merge!(:includes => :sponsor_club, :where => ["members.name = ?", "Groucho Marx"], :order => "clubs.name DESC").to_a #force fallback
     end
     assert_equal 1, members.size
     assert_not_nil assert_no_queries { members[0].sponsor_club }
@@ -176,35 +176,35 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_assigning_to_has_one_through_preserves_decorated_join_record
     @organization = organizations(:nsa)
-    assert_difference 'MemberDetail.count', 1 do
-      @member_detail = MemberDetail.new(:extra_data => 'Extra')
+    assert_difference "MemberDetail.count", 1 do
+      @member_detail = MemberDetail.new(:extra_data => "Extra")
       @member.member_detail = @member_detail
       @member.organization = @organization
     end
     assert_equal @organization, @member.organization
     assert @organization.members.include?(@member)
-    assert_equal 'Extra', @member.member_detail.extra_data
+    assert_equal "Extra", @member.member_detail.extra_data
   end
 
   def test_reassigning_has_one_through
     @organization = organizations(:nsa)
     @new_organization = organizations(:discordians)
 
-    assert_difference 'MemberDetail.count', 1 do
-      @member_detail = MemberDetail.new(:extra_data => 'Extra')
+    assert_difference "MemberDetail.count", 1 do
+      @member_detail = MemberDetail.new(:extra_data => "Extra")
       @member.member_detail = @member_detail
       @member.organization = @organization
     end
     assert_equal @organization, @member.organization
-    assert_equal 'Extra', @member.member_detail.extra_data
+    assert_equal "Extra", @member.member_detail.extra_data
     assert @organization.members.include?(@member)
     assert !@new_organization.members.include?(@member)
 
-    assert_no_difference 'MemberDetail.count' do
+    assert_no_difference "MemberDetail.count" do
       @member.organization = @new_organization
     end
     assert_equal @new_organization, @member.organization
-    assert_equal 'Extra', @member.member_detail.extra_data
+    assert_equal "Extra", @member.member_detail.extra_data
     assert !@organization.members.include?(@member)
     assert @new_organization.members.include?(@member)
   end
@@ -242,7 +242,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_through_belongs_to_after_destroy
-    @member_detail = MemberDetail.new(:extra_data => 'Extra')
+    @member_detail = MemberDetail.new(:extra_data => "Extra")
     @member.member_detail = @member_detail
     @member.save!
 
@@ -261,7 +261,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_value_is_properly_quoted
-    minivan = Minivan.find('m1')
+    minivan = Minivan.find("m1")
     assert_nothing_raised do
       minivan.dashboard
     end
@@ -270,7 +270,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   def test_has_one_through_polymorphic_with_primary_key_option
     assert_equal categories(:general), authors(:david).essay_category
 
-    authors = Author.joins(:essay_category).where('categories.id' => categories(:general).id)
+    authors = Author.joins(:essay_category).where("categories.id" => categories(:general).id)
     assert_equal authors(:david), authors.first
 
     assert_equal owners(:blackbeard), authors(:david).essay_owner
@@ -282,12 +282,12 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   def test_has_one_through_with_primary_key_option
     assert_equal categories(:general), authors(:david).essay_category_2
 
-    authors = Author.joins(:essay_category_2).where('categories.id' => categories(:general).id)
+    authors = Author.joins(:essay_category_2).where("categories.id" => categories(:general).id)
     assert_equal authors(:david), authors.first
   end
 
   def test_has_one_through_with_default_scope_on_join_model
-    assert_equal posts(:welcome).comments.order('id').first, authors(:david).comment_on_first_post
+    assert_equal posts(:welcome).comments.order("id").first, authors(:david).comment_on_first_post
   end
 
   def test_has_one_through_many_raises_exception
diff --git a/activerecord/test/cases/associations/inner_join_association_test.rb b/activerecord/test/cases/associations/inner_join_association_test.rb
index a2158e4f3b..816610ebea 100644
--- a/activerecord/test/cases/associations/inner_join_association_test.rb
+++ b/activerecord/test/cases/associations/inner_join_association_test.rb
@@ -1,13 +1,13 @@
 require "cases/helper"
-require 'models/post'
-require 'models/comment'
-require 'models/author'
-require 'models/essay'
-require 'models/category'
-require 'models/categorization'
-require 'models/person'
-require 'models/tagging'
-require 'models/tag'
+require "models/post"
+require "models/comment"
+require "models/author"
+require "models/essay"
+require "models/category"
+require "models/categorization"
+require "models/person"
+require "models/tagging"
+require "models/tag"
 
 class InnerJoinAssociationTest < ActiveRecord::TestCase
   fixtures :authors, :essays, :posts, :comments, :categories, :categories_posts, :categorizations,
@@ -58,7 +58,7 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
   end
 
   def test_find_with_implicit_inner_joins_honors_readonly_with_select
-    authors = Author.joins(:posts).select('authors.*').to_a
+    authors = Author.joins(:posts).select("authors.*").to_a
     assert !authors.empty?, "expected authors to be non-empty"
     assert authors.all? {|a| !a.readonly? }, "expected no authors to be readonly"
   end
@@ -70,7 +70,7 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
   end
 
   def test_find_with_implicit_inner_joins_does_not_set_associations
-    authors = Author.joins(:posts).select('authors.*').to_a
+    authors = Author.joins(:posts).select("authors.*").to_a
     assert !authors.empty?, "expected authors to be non-empty"
     assert authors.all? { |a| !a.instance_variable_defined?(:@posts) }, "expected no authors to have the @posts association loaded"
   end
@@ -82,12 +82,12 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
 
   def test_calculate_honors_implicit_inner_joins
     real_count = Author.all.to_a.sum{|a| a.posts.count }
-    assert_equal real_count, Author.joins(:posts).calculate(:count, 'authors.id'), "plain inner join count should match the number of referenced posts records"
+    assert_equal real_count, Author.joins(:posts).calculate(:count, "authors.id"), "plain inner join count should match the number of referenced posts records"
   end
 
   def test_calculate_honors_implicit_inner_joins_and_distinct_and_conditions
-    real_count = Author.all.to_a.select {|a| a.posts.any? {|p| p.title.start_with?('Welcome')} }.length
-    authors_with_welcoming_post_titles = Author.all.merge!(joins: :posts, where: "posts.title like 'Welcome%'").distinct.calculate(:count, 'authors.id')
+    real_count = Author.all.to_a.select {|a| a.posts.any? {|p| p.title.start_with?("Welcome")} }.length
+    authors_with_welcoming_post_titles = Author.all.merge!(joins: :posts, where: "posts.title like 'Welcome%'").distinct.calculate(:count, "authors.id")
     assert_equal real_count, authors_with_welcoming_post_titles, "inner join and conditions should have only returned authors posting titles starting with 'Welcome'"
   end
 
@@ -120,8 +120,8 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
 
   test "the default scope of the target is correctly aliased when joining associations" do
     author = Author.create! name: "Jon"
-    author.categories.create! name: 'Not Special'
-    author.special_categories.create! name: 'Special'
+    author.categories.create! name: "Not Special"
+    author.special_categories.create! name: "Special"
 
     categories = author.categories.includes(:special_categorizations).references(:special_categorizations).to_a
     assert_equal 2, categories.size
@@ -129,8 +129,8 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
 
   test "the correct records are loaded when including an aliased association" do
     author = Author.create! name: "Jon"
-    author.categories.create! name: 'Not Special'
-    author.special_categories.create! name: 'Special'
+    author.categories.create! name: "Not Special"
+    author.special_categories.create! name: "Special"
 
     categories = author.categories.eager_load(:special_categorizations).order(:name).to_a
     assert_equal 0, categories.first.special_categorizations.size
diff --git a/activerecord/test/cases/associations/inverse_associations_test.rb b/activerecord/test/cases/associations/inverse_associations_test.rb
index c9743e80d3..6387afeb27 100644
--- a/activerecord/test/cases/associations/inverse_associations_test.rb
+++ b/activerecord/test/cases/associations/inverse_associations_test.rb
@@ -1,21 +1,21 @@
 require "cases/helper"
-require 'models/man'
-require 'models/face'
-require 'models/interest'
-require 'models/zine'
-require 'models/club'
-require 'models/sponsor'
-require 'models/rating'
-require 'models/comment'
-require 'models/car'
-require 'models/bulb'
-require 'models/mixed_case_monkey'
-require 'models/admin'
-require 'models/admin/account'
-require 'models/admin/user'
-require 'models/developer'
-require 'models/company'
-require 'models/project'
+require "models/man"
+require "models/face"
+require "models/interest"
+require "models/zine"
+require "models/club"
+require "models/sponsor"
+require "models/rating"
+require "models/comment"
+require "models/car"
+require "models/bulb"
+require "models/mixed_case_monkey"
+require "models/admin"
+require "models/admin/account"
+require "models/admin/user"
+require "models/developer"
+require "models/company"
+require "models/project"
 
 class AutomaticInverseFindingTests < ActiveRecord::TestCase
   fixtures :ratings, :comments, :cars
@@ -203,9 +203,9 @@ class InverseAssociationTests < ActiveRecord::TestCase
   end
 
   def test_this_inverse_stuff
-    firm = Firm.create!(name: 'Adequate Holdings')
-    Project.create!(name: 'Project 1', firm: firm)
-    Developer.create!(name: 'Gorbypuff', firm: firm)
+    firm = Firm.create!(name: "Adequate Holdings")
+    Project.create!(name: "Project 1", firm: firm)
+    Developer.create!(name: "Gorbypuff", firm: firm)
 
     new_project = Project.last
     assert Project.reflect_on_association(:lead_developer).inverse_of.present?, "Expected inverse of to be present"
@@ -220,73 +220,73 @@ class InverseHasOneTests < ActiveRecord::TestCase
     m = men(:gordon)
     f = m.face
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
+    m.name = "Bongo"
     assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = 'Mungo'
+    f.man.name = "Mungo"
     assert_equal m.name, f.man.name, "Name of man should be the same after changes to child-owned instance"
   end
 
 
   def test_parent_instance_should_be_shared_with_eager_loaded_child_on_find
-    m = Man.all.merge!(:where => {:name => 'Gordon'}, :includes => :face).first
+    m = Man.all.merge!(:where => {:name => "Gordon"}, :includes => :face).first
     f = m.face
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
+    m.name = "Bongo"
     assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = 'Mungo'
+    f.man.name = "Mungo"
     assert_equal m.name, f.man.name, "Name of man should be the same after changes to child-owned instance"
 
-    m = Man.all.merge!(:where => {:name => 'Gordon'}, :includes => :face, :order => 'faces.id').first
+    m = Man.all.merge!(:where => {:name => "Gordon"}, :includes => :face, :order => "faces.id").first
     f = m.face
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
+    m.name = "Bongo"
     assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = 'Mungo'
+    f.man.name = "Mungo"
     assert_equal m.name, f.man.name, "Name of man should be the same after changes to child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_newly_built_child
     m = Man.first
-    f = m.build_face(:description => 'haunted')
+    f = m.build_face(:description => "haunted")
     assert_not_nil f.man
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
+    m.name = "Bongo"
     assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = 'Mungo'
+    f.man.name = "Mungo"
     assert_equal m.name, f.man.name, "Name of man should be the same after changes to just-built-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_newly_created_child
     m = Man.first
-    f = m.create_face(:description => 'haunted')
+    f = m.create_face(:description => "haunted")
     assert_not_nil f.man
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
+    m.name = "Bongo"
     assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = 'Mungo'
+    f.man.name = "Mungo"
     assert_equal m.name, f.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_newly_created_child_via_bang_method
     m = Man.first
-    f = m.create_face!(:description => 'haunted')
+    f = m.create_face!(:description => "haunted")
     assert_not_nil f.man
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
+    m.name = "Bongo"
     assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = 'Mungo'
+    f.man.name = "Mungo"
     assert_equal m.name, f.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_replaced_via_accessor_child
     m = Man.first
-    f = Face.new(:description => 'haunted')
+    f = Face.new(:description => "haunted")
     m.face = f
     assert_not_nil f.man
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
+    m.name = "Bongo"
     assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = 'Mungo'
+    f.man.name = "Mungo"
     assert_equal m.name, f.man.name, "Name of man should be the same after changes to replaced-child-owned instance"
   end
 
@@ -303,67 +303,67 @@ class InverseHasManyTests < ActiveRecord::TestCase
     is = m.interests
     is.each do |i|
       assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-      m.name = 'Bongo'
+      m.name = "Bongo"
       assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-      i.man.name = 'Mungo'
+      i.man.name = "Mungo"
       assert_equal m.name, i.man.name, "Name of man should be the same after changes to child-owned instance"
     end
   end
 
   def test_parent_instance_should_be_shared_with_eager_loaded_children
-    m = Man.all.merge!(:where => {:name => 'Gordon'}, :includes => :interests).first
+    m = Man.all.merge!(:where => {:name => "Gordon"}, :includes => :interests).first
     is = m.interests
     is.each do |i|
       assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-      m.name = 'Bongo'
+      m.name = "Bongo"
       assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-      i.man.name = 'Mungo'
+      i.man.name = "Mungo"
       assert_equal m.name, i.man.name, "Name of man should be the same after changes to child-owned instance"
     end
 
-    m = Man.all.merge!(:where => {:name => 'Gordon'}, :includes => :interests, :order => 'interests.id').first
+    m = Man.all.merge!(:where => {:name => "Gordon"}, :includes => :interests, :order => "interests.id").first
     is = m.interests
     is.each do |i|
       assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-      m.name = 'Bongo'
+      m.name = "Bongo"
       assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-      i.man.name = 'Mungo'
+      i.man.name = "Mungo"
       assert_equal m.name, i.man.name, "Name of man should be the same after changes to child-owned instance"
     end
   end
 
   def test_parent_instance_should_be_shared_with_newly_block_style_built_child
     m = Man.first
-    i = m.interests.build {|ii| ii.topic = 'Industrial Revolution Re-enactment'}
+    i = m.interests.build {|ii| ii.topic = "Industrial Revolution Re-enactment"}
     assert_not_nil i.topic, "Child attributes supplied to build via blocks should be populated"
     assert_not_nil i.man
     assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
+    m.name = "Bongo"
     assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = 'Mungo'
+    i.man.name = "Mungo"
     assert_equal m.name, i.man.name, "Name of man should be the same after changes to just-built-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_newly_created_via_bang_method_child
     m = Man.first
-    i = m.interests.create!(:topic => 'Industrial Revolution Re-enactment')
+    i = m.interests.create!(:topic => "Industrial Revolution Re-enactment")
     assert_not_nil i.man
     assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
+    m.name = "Bongo"
     assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = 'Mungo'
+    i.man.name = "Mungo"
     assert_equal m.name, i.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_newly_block_style_created_child
     m = Man.first
-    i = m.interests.create {|ii| ii.topic = 'Industrial Revolution Re-enactment'}
+    i = m.interests.create {|ii| ii.topic = "Industrial Revolution Re-enactment"}
     assert_not_nil i.topic, "Child attributes supplied to create via blocks should be populated"
     assert_not_nil i.man
     assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
+    m.name = "Bongo"
     assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = 'Mungo'
+    i.man.name = "Mungo"
     assert_equal m.name, i.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
   end
 
@@ -385,25 +385,25 @@ class InverseHasManyTests < ActiveRecord::TestCase
 
   def test_parent_instance_should_be_shared_with_poked_in_child
     m = men(:gordon)
-    i = Interest.create(:topic => 'Industrial Revolution Re-enactment')
+    i = Interest.create(:topic => "Industrial Revolution Re-enactment")
     m.interests << i
     assert_not_nil i.man
     assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
+    m.name = "Bongo"
     assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = 'Mungo'
+    i.man.name = "Mungo"
     assert_equal m.name, i.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_replaced_via_accessor_children
     m = Man.first
-    i = Interest.new(:topic => 'Industrial Revolution Re-enactment')
+    i = Interest.new(:topic => "Industrial Revolution Re-enactment")
     m.interests = [i]
     assert_not_nil i.man
     assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
+    m.name = "Bongo"
     assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = 'Mungo'
+    i.man.name = "Mungo"
     assert_equal m.name, i.man.name, "Name of man should be the same after changes to replaced-child-owned instance"
   end
 
@@ -485,7 +485,7 @@ class InverseHasManyTests < ActiveRecord::TestCase
 
   def test_child_instance_should_point_to_parent_without_saving
     man = Man.new
-    i = Interest.create(:topic => 'Industrial Revolution Re-enactment')
+    i = Interest.create(:topic => "Industrial Revolution Re-enactment")
 
     man.interests << i
     assert_not_nil i.man
@@ -504,49 +504,49 @@ class InverseBelongsToTests < ActiveRecord::TestCase
     f = faces(:trusting)
     m = f.man
     assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
-    f.description = 'gormless'
+    f.description = "gormless"
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to child instance"
-    m.face.description = 'pleasing'
+    m.face.description = "pleasing"
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to parent-owned instance"
   end
 
   def test_eager_loaded_child_instance_should_be_shared_with_parent_on_find
-    f = Face.all.merge!(:includes => :man, :where => {:description => 'trusting'}).first
+    f = Face.all.merge!(:includes => :man, :where => {:description => "trusting"}).first
     m = f.man
     assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
-    f.description = 'gormless'
+    f.description = "gormless"
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to child instance"
-    m.face.description = 'pleasing'
+    m.face.description = "pleasing"
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to parent-owned instance"
 
-    f = Face.all.merge!(:includes => :man, :order => 'men.id', :where => {:description => 'trusting'}).first
+    f = Face.all.merge!(:includes => :man, :order => "men.id", :where => {:description => "trusting"}).first
     m = f.man
     assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
-    f.description = 'gormless'
+    f.description = "gormless"
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to child instance"
-    m.face.description = 'pleasing'
+    m.face.description = "pleasing"
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to parent-owned instance"
   end
 
   def test_child_instance_should_be_shared_with_newly_built_parent
     f = faces(:trusting)
-    m = f.build_man(:name => 'Charles')
+    m = f.build_man(:name => "Charles")
     assert_not_nil m.face
     assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
-    f.description = 'gormless'
+    f.description = "gormless"
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to child instance"
-    m.face.description = 'pleasing'
+    m.face.description = "pleasing"
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to just-built-parent-owned instance"
   end
 
   def test_child_instance_should_be_shared_with_newly_created_parent
     f = faces(:trusting)
-    m = f.create_man(:name => 'Charles')
+    m = f.create_man(:name => "Charles")
     assert_not_nil m.face
     assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
-    f.description = 'gormless'
+    f.description = "gormless"
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to child instance"
-    m.face.description = 'pleasing'
+    m.face.description = "pleasing"
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to newly-created-parent-owned instance"
   end
 
@@ -557,21 +557,21 @@ class InverseBelongsToTests < ActiveRecord::TestCase
     iz = m.interests.detect { |_iz| _iz.id == i.id}
     assert_not_nil iz
     assert_equal i.topic, iz.topic, "Interest topics should be the same before changes to child"
-    i.topic = 'Eating cheese with a spoon'
+    i.topic = "Eating cheese with a spoon"
     assert_not_equal i.topic, iz.topic, "Interest topics should not be the same after changes to child"
-    iz.topic = 'Cow tipping'
+    iz.topic = "Cow tipping"
     assert_not_equal i.topic, iz.topic, "Interest topics should not be the same after changes to parent-owned instance"
   end
 
   def test_child_instance_should_be_shared_with_replaced_via_accessor_parent
     f = Face.first
-    m = Man.new(:name => 'Charles')
+    m = Man.new(:name => "Charles")
     f.man = m
     assert_not_nil m.face
     assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
-    f.description = 'gormless'
+    f.description = "gormless"
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to child instance"
-    m.face.description = 'pleasing'
+    m.face.description = "pleasing"
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to replaced-parent-owned instance"
   end
 
@@ -584,30 +584,30 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
   fixtures :men, :faces, :interests
 
   def test_child_instance_should_be_shared_with_parent_on_find
-    f = Face.all.merge!(:where => {:description => 'confused'}).first
+    f = Face.all.merge!(:where => {:description => "confused"}).first
     m = f.polymorphic_man
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same before changes to child instance"
-    f.description = 'gormless'
+    f.description = "gormless"
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same after changes to child instance"
-    m.polymorphic_face.description = 'pleasing'
+    m.polymorphic_face.description = "pleasing"
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same after changes to parent-owned instance"
   end
 
   def test_eager_loaded_child_instance_should_be_shared_with_parent_on_find
-    f = Face.all.merge!(:where => {:description => 'confused'}, :includes => :man).first
+    f = Face.all.merge!(:where => {:description => "confused"}, :includes => :man).first
     m = f.polymorphic_man
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same before changes to child instance"
-    f.description = 'gormless'
+    f.description = "gormless"
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same after changes to child instance"
-    m.polymorphic_face.description = 'pleasing'
+    m.polymorphic_face.description = "pleasing"
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same after changes to parent-owned instance"
 
-    f = Face.all.merge!(:where => {:description => 'confused'}, :includes => :man, :order => 'men.id').first
+    f = Face.all.merge!(:where => {:description => "confused"}, :includes => :man, :order => "men.id").first
     m = f.polymorphic_man
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same before changes to child instance"
-    f.description = 'gormless'
+    f.description = "gormless"
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same after changes to child instance"
-    m.polymorphic_face.description = 'pleasing'
+    m.polymorphic_face.description = "pleasing"
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same after changes to parent-owned instance"
   end
 
@@ -619,9 +619,9 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
     face.polymorphic_man = new_man
 
     assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same before changes to parent instance"
-    face.description = 'Bongo'
+    face.description = "Bongo"
     assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same after changes to parent instance"
-    new_man.polymorphic_face.description = 'Mungo'
+    new_man.polymorphic_face.description = "Mungo"
     assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same after changes to replaced-parent-owned instance"
   end
 
@@ -633,9 +633,9 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
     face.polymorphic_man = new_man
 
     assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same before changes to parent instance"
-    face.description = 'Bongo'
+    face.description = "Bongo"
     assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same after changes to parent instance"
-    new_man.polymorphic_face.description = 'Mungo'
+    new_man.polymorphic_face.description = "Mungo"
     assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same after changes to replaced-parent-owned instance"
   end
 
@@ -658,9 +658,9 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
     iz = m.polymorphic_interests.detect { |_iz| _iz.id == i.id}
     assert_not_nil iz
     assert_equal i.topic, iz.topic, "Interest topics should be the same before changes to child"
-    i.topic = 'Eating cheese with a spoon'
+    i.topic = "Eating cheese with a spoon"
     assert_not_equal i.topic, iz.topic, "Interest topics should not be the same after changes to child"
-    iz.topic = 'Cow tipping'
+    iz.topic = "Cow tipping"
     assert_not_equal i.topic, iz.topic, "Interest topics should not be the same after changes to parent-owned instance"
   end
 
@@ -698,8 +698,8 @@ class InverseMultipleHasManyInversesForSameModel < ActiveRecord::TestCase
   def test_that_we_can_create_associations_that_have_the_same_reciprocal_name_from_different_models
     assert_nothing_raised do
       i = Interest.first
-      i.build_zine(:title => 'Get Some in Winter! 2008')
-      i.build_man(:name => 'Gordon')
+      i.build_zine(:title => "Get Some in Winter! 2008")
+      i.build_man(:name => "Gordon")
       i.save!
     end
   end
diff --git a/activerecord/test/cases/associations/join_model_test.rb b/activerecord/test/cases/associations/join_model_test.rb
index 3047914b70..00777fdcf5 100644
--- a/activerecord/test/cases/associations/join_model_test.rb
+++ b/activerecord/test/cases/associations/join_model_test.rb
@@ -1,20 +1,20 @@
 require "cases/helper"
-require 'models/tag'
-require 'models/tagging'
-require 'models/post'
-require 'models/rating'
-require 'models/item'
-require 'models/comment'
-require 'models/author'
-require 'models/category'
-require 'models/categorization'
-require 'models/vertex'
-require 'models/edge'
-require 'models/book'
-require 'models/citation'
-require 'models/aircraft'
-require 'models/engine'
-require 'models/car'
+require "models/tag"
+require "models/tagging"
+require "models/post"
+require "models/rating"
+require "models/item"
+require "models/comment"
+require "models/author"
+require "models/category"
+require "models/categorization"
+require "models/vertex"
+require "models/edge"
+require "models/book"
+require "models/citation"
+require "models/aircraft"
+require "models/engine"
+require "models/car"
 
 class AssociationsJoinModelTest < ActiveRecord::TestCase
   self.use_transactional_tests = false unless supports_savepoints?
@@ -97,7 +97,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_polymorphic_has_many_create_model_with_inheritance_and_custom_base_class
-    post = SubStiPost.create :title => 'SubStiPost', :body => 'SubStiPost body'
+    post = SubStiPost.create :title => "SubStiPost", :body => "SubStiPost body"
     assert_instance_of SubStiPost, post
 
     tagging = tags(:misc).taggings.create(:taggable => post)
@@ -174,7 +174,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_delete_polymorphic_has_many_with_delete_all
     assert_equal 1, posts(:welcome).taggings.count
-    posts(:welcome).taggings.first.update_columns taggable_type: 'PostWithHasManyDeleteAll'
+    posts(:welcome).taggings.first.update_columns taggable_type: "PostWithHasManyDeleteAll"
     post = find_post_with_dependency(1, :has_many, :taggings, :delete_all)
 
     old_count = Tagging.count
@@ -185,7 +185,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_delete_polymorphic_has_many_with_destroy
     assert_equal 1, posts(:welcome).taggings.count
-    posts(:welcome).taggings.first.update_columns taggable_type: 'PostWithHasManyDestroy'
+    posts(:welcome).taggings.first.update_columns taggable_type: "PostWithHasManyDestroy"
     post = find_post_with_dependency(1, :has_many, :taggings, :destroy)
 
     old_count = Tagging.count
@@ -196,7 +196,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_delete_polymorphic_has_many_with_nullify
     assert_equal 1, posts(:welcome).taggings.count
-    posts(:welcome).taggings.first.update_columns taggable_type: 'PostWithHasManyNullify'
+    posts(:welcome).taggings.first.update_columns taggable_type: "PostWithHasManyNullify"
     post = find_post_with_dependency(1, :has_many, :taggings, :nullify)
 
     old_count = Tagging.count
@@ -207,7 +207,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_delete_polymorphic_has_one_with_destroy
     assert posts(:welcome).tagging
-    posts(:welcome).tagging.update_columns taggable_type: 'PostWithHasOneDestroy'
+    posts(:welcome).tagging.update_columns taggable_type: "PostWithHasOneDestroy"
     post = find_post_with_dependency(1, :has_one, :tagging, :destroy)
 
     old_count = Tagging.count
@@ -219,7 +219,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_delete_polymorphic_has_one_with_nullify
     assert posts(:welcome).tagging
-    posts(:welcome).tagging.update_columns taggable_type: 'PostWithHasOneNullify'
+    posts(:welcome).tagging.update_columns taggable_type: "PostWithHasOneNullify"
     post = find_post_with_dependency(1, :has_one, :tagging, :nullify)
 
     old_count = Tagging.count
@@ -235,15 +235,15 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_create_through_has_many_with_piggyback
     category = categories(:sti_test)
-    ernie = category.authors_with_select.create(:name => 'Ernie')
+    ernie = category.authors_with_select.create(:name => "Ernie")
     assert_nothing_raised do
-      assert_equal ernie, category.authors_with_select.detect {|a| a.name == 'Ernie'}
+      assert_equal ernie, category.authors_with_select.detect {|a| a.name == "Ernie"}
     end
   end
 
   def test_include_has_many_through
-    posts              = Post.all.merge!(:order => 'posts.id').to_a
-    posts_with_authors = Post.all.merge!(:includes => :authors, :order => 'posts.id').to_a
+    posts              = Post.all.merge!(:order => "posts.id").to_a
+    posts_with_authors = Post.all.merge!(:includes => :authors, :order => "posts.id").to_a
     assert_equal posts.length, posts_with_authors.length
     posts.length.times do |i|
       assert_equal posts[i].authors.length, assert_no_queries { posts_with_authors[i].authors.length }
@@ -267,8 +267,8 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_include_polymorphic_has_many_through
-    posts           = Post.all.merge!(:order => 'posts.id').to_a
-    posts_with_tags = Post.all.merge!(:includes => :tags, :order => 'posts.id').to_a
+    posts           = Post.all.merge!(:order => "posts.id").to_a
+    posts_with_tags = Post.all.merge!(:includes => :tags, :order => "posts.id").to_a
     assert_equal posts.length, posts_with_tags.length
     posts.length.times do |i|
       assert_equal posts[i].tags.length, assert_no_queries { posts_with_tags[i].tags.length }
@@ -276,8 +276,8 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_include_polymorphic_has_many
-    posts               = Post.all.merge!(:order => 'posts.id').to_a
-    posts_with_taggings = Post.all.merge!(:includes => :taggings, :order => 'posts.id').to_a
+    posts               = Post.all.merge!(:order => "posts.id").to_a
+    posts_with_taggings = Post.all.merge!(:includes => :taggings, :order => "posts.id").to_a
     assert_equal posts.length, posts_with_taggings.length
     posts.length.times do |i|
       assert_equal posts[i].taggings.length, assert_no_queries { posts_with_taggings[i].taggings.length }
@@ -302,7 +302,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_array_methods_called_by_method_missing
-    assert authors(:david).categories.any? { |category| category.name == 'General' }
+    assert authors(:david).categories.any? { |category| category.name == "General" }
     assert_nothing_raised { authors(:david).categories.sort }
   end
 
@@ -324,7 +324,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_through_with_custom_primary_key_on_has_many_source
-    assert_equal [authors(:david), authors(:bob)], posts(:thinking).authors_using_custom_pk.order('authors.id')
+    assert_equal [authors(:david), authors(:bob)], posts(:thinking).authors_using_custom_pk.order("authors.id")
   end
 
   def test_belongs_to_polymorphic_with_counter_cache
@@ -354,7 +354,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     end
 
     assert_raise ActiveRecord::EagerLoadPolymorphicError do
-      tags(:general).taggings.includes(:taggable).where('bogus_table.column = 1').references(:bogus_table).to_a
+      tags(:general).taggings.includes(:taggable).where("bogus_table.column = 1").references(:bogus_table).to_a
     end
   end
 
@@ -365,7 +365,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_has_many_polymorphic_associations_merges_through_scope
     Tag.has_many :null_taggings, -> { none }, class_name: :Tagging
-    Tag.has_many :null_tagged_posts, :through => :null_taggings, :source => 'taggable', :source_type => 'Post'
+    Tag.has_many :null_tagged_posts, :through => :null_taggings, :source => "taggable", :source_type => "Post"
     assert_equal [], tags(:general).null_tagged_posts
     refute_equal [], tags(:general).tagged_posts
   end
@@ -381,19 +381,19 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_through_has_many_find_all
-    assert_equal comments(:greetings), authors(:david).comments.order('comments.id').to_a.first
+    assert_equal comments(:greetings), authors(:david).comments.order("comments.id").to_a.first
   end
 
   def test_has_many_through_has_many_find_all_with_custom_class
-    assert_equal comments(:greetings), authors(:david).funky_comments.order('comments.id').to_a.first
+    assert_equal comments(:greetings), authors(:david).funky_comments.order("comments.id").to_a.first
   end
 
   def test_has_many_through_has_many_find_first
-    assert_equal comments(:greetings), authors(:david).comments.order('comments.id').first
+    assert_equal comments(:greetings), authors(:david).comments.order("comments.id").first
   end
 
   def test_has_many_through_has_many_find_conditions
-    options = { :where => "comments.#{QUOTED_TYPE}='SpecialComment'", :order => 'comments.id' }
+    options = { :where => "comments.#{QUOTED_TYPE}='SpecialComment'", :order => "comments.id" }
     assert_equal comments(:does_it_hurt), authors(:david).comments.merge(options).first
   end
 
@@ -418,7 +418,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_eager_load_has_many_through_has_many
-    author = Author.all.merge!(:where => ['name = ?', 'David'], :includes => :comments, :order => 'comments.id').first
+    author = Author.all.merge!(:where => ["name = ?", "David"], :includes => :comments, :order => "comments.id").first
     SpecialComment.new; VerySpecialComment.new
     assert_no_queries do
       assert_equal [1,2,3,5,6,7,8,9,10,12], author.comments.collect(&:id)
@@ -491,7 +491,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_create_associate_when_adding_to_has_many_through
     count = posts(:thinking).tags.count
-    push = Tag.create!(:name => 'pushme')
+    push = Tag.create!(:name => "pushme")
     post_thinking = posts(:thinking)
     assert_nothing_raised { post_thinking.tags << push }
     assert_nil( wrong = post_thinking.tags.detect { |t| t.class != Tag },
@@ -501,7 +501,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert_equal(count + 1, post_thinking.reload.tags.size)
     assert_equal(count + 1, post_thinking.tags.reload.size)
 
-    assert_kind_of Tag, post_thinking.tags.create!(:name => 'foo')
+    assert_kind_of Tag, post_thinking.tags.create!(:name => "foo")
     assert_nil( wrong = post_thinking.tags.detect { |t| t.class != Tag },
                 message = "Expected a Tag in tags collection, got #{wrong.class}.")
     assert_nil( wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
@@ -509,7 +509,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert_equal(count + 2, post_thinking.reload.tags.size)
     assert_equal(count + 2, post_thinking.tags.reload.size)
 
-    assert_nothing_raised { post_thinking.tags.concat(Tag.create!(:name => 'abc'), Tag.create!(:name => 'def')) }
+    assert_nothing_raised { post_thinking.tags.concat(Tag.create!(:name => "abc"), Tag.create!(:name => "def")) }
     assert_nil( wrong = post_thinking.tags.detect { |t| t.class != Tag },
                 message = "Expected a Tag in tags collection, got #{wrong.class}.")
     assert_nil( wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
@@ -550,7 +550,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   def test_delete_associate_when_deleting_from_has_many_through_with_nonstandard_id
     count = books(:awdr).references.count
     references_before = books(:awdr).references
-    book = Book.create!(:name => 'Getting Real')
+    book = Book.create!(:name => "Getting Real")
     book_awdr = books(:awdr)
     book_awdr.references << book
     assert_equal(count + 1, book_awdr.references.reload.size)
@@ -564,7 +564,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   def test_delete_associate_when_deleting_from_has_many_through
     count = posts(:thinking).tags.count
     tags_before = posts(:thinking).tags.sort
-    tag = Tag.create!(:name => 'doomed')
+    tag = Tag.create!(:name => "doomed")
     post_thinking = posts(:thinking)
     post_thinking.tags << tag
     assert_equal(count + 1, post_thinking.taggings.reload.size)
@@ -581,9 +581,9 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   def test_delete_associate_when_deleting_from_has_many_through_with_multiple_tags
     count = posts(:thinking).tags.count
     tags_before = posts(:thinking).tags.sort
-    doomed = Tag.create!(:name => 'doomed')
-    doomed2 = Tag.create!(:name => 'doomed2')
-    quaked = Tag.create!(:name => 'quaked')
+    doomed = Tag.create!(:name => "doomed")
+    doomed2 = Tag.create!(:name => "doomed2")
+    quaked = Tag.create!(:name => "quaked")
     post_thinking = posts(:thinking)
     post_thinking.tags << doomed << doomed2
     assert_equal(count + 2, post_thinking.reload.tags.reload.size)
@@ -601,7 +601,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   def test_deleting_by_integer_id_from_has_many_through
     post = posts(:thinking)
 
-    assert_difference 'post.tags.count', -1 do
+    assert_difference "post.tags.count", -1 do
       assert_equal 1, post.tags.delete(1).size
     end
 
@@ -611,8 +611,8 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   def test_deleting_by_string_id_from_has_many_through
     post = posts(:thinking)
 
-    assert_difference 'post.tags.count', -1 do
-      assert_equal 1, post.tags.delete('1').size
+    assert_difference "post.tags.count", -1 do
+      assert_equal 1, post.tags.delete("1").size
     end
 
     assert_equal 0, post.tags.size
@@ -660,8 +660,8 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_preload_polymorphic_has_many_through
-    posts           = Post.all.merge!(:order => 'posts.id').to_a
-    posts_with_tags = Post.all.merge!(:includes => :tags, :order => 'posts.id').to_a
+    posts           = Post.all.merge!(:order => "posts.id").to_a
+    posts_with_tags = Post.all.merge!(:includes => :tags, :order => "posts.id").to_a
     assert_equal posts.length, posts_with_tags.length
     posts.length.times do |i|
       assert_equal posts[i].tags.length, assert_no_queries { posts_with_tags[i].tags.length }
@@ -669,7 +669,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_preload_polymorph_many_types
-    taggings = Tagging.all.merge!(:includes => :taggable, :where => ['taggable_type != ?', 'FakeModel']).to_a
+    taggings = Tagging.all.merge!(:includes => :taggable, :where => ["taggable_type != ?", "FakeModel"]).to_a
     assert_no_queries do
       taggings.first.taggable.id
       taggings[1].taggable.id
@@ -682,13 +682,13 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_preload_nil_polymorphic_belongs_to
     assert_nothing_raised do
-      Tagging.all.merge!(:includes => :taggable, :where => ['taggable_type IS NULL']).to_a
+      Tagging.all.merge!(:includes => :taggable, :where => ["taggable_type IS NULL"]).to_a
     end
   end
 
   def test_preload_polymorphic_has_many
-    posts               = Post.all.merge!(:order => 'posts.id').to_a
-    posts_with_taggings = Post.all.merge!(:includes => :taggings, :order => 'posts.id').to_a
+    posts               = Post.all.merge!(:order => "posts.id").to_a
+    posts_with_taggings = Post.all.merge!(:includes => :taggings, :order => "posts.id").to_a
     assert_equal posts.length, posts_with_taggings.length
     posts.length.times do |i|
       assert_equal posts[i].taggings.length, assert_no_queries { posts_with_taggings[i].taggings.length }
@@ -696,7 +696,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_belongs_to_shared_parent
-    comments = Comment.all.merge!(:includes => :post, :where => 'post_id = 1').to_a
+    comments = Comment.all.merge!(:includes => :post, :where => "post_id = 1").to_a
     assert_no_queries do
       assert_equal comments.first.post, comments[1].post
     end
@@ -728,15 +728,15 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_has_many_through_include_returns_false_for_non_matching_record_to_verify_scoping
     david = authors(:david)
-    category = Category.create!(:name => 'Not Associated')
+    category = Category.create!(:name => "Not Associated")
 
     assert ! david.categories.loaded?
     assert ! david.categories.include?(category)
   end
 
   def test_has_many_through_goes_through_all_sti_classes
-    sub_sti_post = SubStiPost.create!(:title => 'test', :body => 'test', :author_id => 1)
-    new_comment = sub_sti_post.comments.create(:body => 'test')
+    sub_sti_post = SubStiPost.create!(:title => "test", :body => "test", :author_id => 1)
+    new_comment = sub_sti_post.comments.create(:body => "test")
 
     assert_equal [9, 10, new_comment.id], authors(:david).sti_post_comments.map(&:id).sort
   end
@@ -749,17 +749,17 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_proper_error_message_for_eager_load_and_includes_association_errors
     includes_error = assert_raises(ActiveRecord::ConfigurationError) {
-      Post.includes(:nonexistent_relation).where(nonexistent_relation: {name: 'Rochester'}).find(1)
+      Post.includes(:nonexistent_relation).where(nonexistent_relation: {name: "Rochester"}).find(1)
     }
     assert_equal("Can't join 'Post' to association named 'nonexistent_relation'; perhaps you misspelled it?", includes_error.message)
 
     eager_load_error = assert_raises(ActiveRecord::ConfigurationError) {
-      Post.eager_load(:nonexistent_relation).where(nonexistent_relation: {name: 'Rochester'}).find(1)
+      Post.eager_load(:nonexistent_relation).where(nonexistent_relation: {name: "Rochester"}).find(1)
     }
     assert_equal("Can't join 'Post' to association named 'nonexistent_relation'; perhaps you misspelled it?", eager_load_error.message)
 
     includes_and_eager_load_error = assert_raises(ActiveRecord::ConfigurationError) {
-      Post.eager_load(:nonexistent_relation).includes(:nonexistent_relation).where(nonexistent_relation: {name: 'Rochester'}).find(1)
+      Post.eager_load(:nonexistent_relation).includes(:nonexistent_relation).where(nonexistent_relation: {name: "Rochester"}).find(1)
     }
     assert_equal("Can't join 'Post' to association named 'nonexistent_relation'; perhaps you misspelled it?", includes_and_eager_load_error.message)
   end
@@ -770,7 +770,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
       class_name = "PostWith#{association.to_s.classify}#{dependency.to_s.classify}"
       Post.find(post_id).update_columns type: class_name
       klass = Object.const_set(class_name, Class.new(ActiveRecord::Base))
-      klass.table_name = 'posts'
+      klass.table_name = "posts"
       klass.send(association, association_name, :as => :taggable, :dependent => dependency)
       klass.find(post_id)
     end
diff --git a/activerecord/test/cases/associations/left_outer_join_association_test.rb b/activerecord/test/cases/associations/left_outer_join_association_test.rb
index e3b257efb2..6258c356fc 100644
--- a/activerecord/test/cases/associations/left_outer_join_association_test.rb
+++ b/activerecord/test/cases/associations/left_outer_join_association_test.rb
@@ -1,11 +1,11 @@
 require "cases/helper"
-require 'models/post'
-require 'models/comment'
-require 'models/author'
-require 'models/essay'
-require 'models/categorization'
-require 'models/person'
-require 'active_support/core_ext/regexp'
+require "models/post"
+require "models/comment"
+require "models/author"
+require "models/essay"
+require "models/categorization"
+require "models/person"
+require "active_support/core_ext/regexp"
 
 class LeftOuterJoinAssociationTest < ActiveRecord::TestCase
   fixtures :authors, :essays, :posts, :comments, :categorizations, :people
diff --git a/activerecord/test/cases/associations/nested_through_associations_test.rb b/activerecord/test/cases/associations/nested_through_associations_test.rb
index b040485d99..09264f08db 100644
--- a/activerecord/test/cases/associations/nested_through_associations_test.rb
+++ b/activerecord/test/cases/associations/nested_through_associations_test.rb
@@ -1,27 +1,27 @@
 require "cases/helper"
-require 'models/author'
-require 'models/post'
-require 'models/person'
-require 'models/reference'
-require 'models/job'
-require 'models/reader'
-require 'models/comment'
-require 'models/tag'
-require 'models/tagging'
-require 'models/subscriber'
-require 'models/book'
-require 'models/subscription'
-require 'models/rating'
-require 'models/member'
-require 'models/member_detail'
-require 'models/member_type'
-require 'models/sponsor'
-require 'models/club'
-require 'models/organization'
-require 'models/category'
-require 'models/categorization'
-require 'models/membership'
-require 'models/essay'
+require "models/author"
+require "models/post"
+require "models/person"
+require "models/reference"
+require "models/job"
+require "models/reader"
+require "models/comment"
+require "models/tag"
+require "models/tagging"
+require "models/subscriber"
+require "models/book"
+require "models/subscription"
+require "models/rating"
+require "models/member"
+require "models/member_detail"
+require "models/member_type"
+require "models/sponsor"
+require "models/club"
+require "models/organization"
+require "models/category"
+require "models/categorization"
+require "models/membership"
+require "models/essay"
 
 class NestedThroughAssociationsTest < ActiveRecord::TestCase
   fixtures :authors, :books, :posts, :subscriptions, :subscribers, :tags, :taggings,
@@ -65,12 +65,12 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_many_through_has_many_with_has_many_through_source_reflection_preload_via_joins
     assert_includes_and_joins_equal(
-      Author.where('tags.id' => tags(:general).id),
+      Author.where("tags.id" => tags(:general).id),
       [authors(:david)], :tags
     )
 
     # This ensures that the polymorphism of taggings is being observed correctly
-    authors = Author.joins(:tags).where('taggings.taggable_type' => 'FakeModel')
+    authors = Author.joins(:tags).where("taggings.taggable_type" => "FakeModel")
     assert authors.empty?
   end
 
@@ -79,7 +79,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
   # Through: has_many through
   def test_has_many_through_has_many_through_with_has_many_source_reflection
     luke, david = subscribers(:first), subscribers(:second)
-    assert_equal [luke, david, david], authors(:david).subscribers.order('subscribers.nick')
+    assert_equal [luke, david, david], authors(:david).subscribers.order("subscribers.nick")
   end
 
   def test_has_many_through_has_many_through_with_has_many_source_reflection_preload
@@ -93,7 +93,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
   def test_has_many_through_has_many_through_with_has_many_source_reflection_preload_via_joins
     # All authors with subscribers where one of the subscribers' nick is 'alterself'
     assert_includes_and_joins_equal(
-      Author.where('subscribers.nick' => 'alterself'),
+      Author.where("subscribers.nick" => "alterself"),
       [authors(:david)], :subscribers
     )
   end
@@ -115,7 +115,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_many_through_has_one_with_has_one_through_source_reflection_preload_via_joins
     assert_includes_and_joins_equal(
-      Member.where('member_types.id' => member_types(:founding).id),
+      Member.where("member_types.id" => member_types(:founding).id),
       [members(:groucho)], :nested_member_types
     )
   end
@@ -137,7 +137,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_many_through_has_one_through_with_has_one_source_reflection_preload_via_joins
     assert_includes_and_joins_equal(
-      Member.where('sponsors.id' => sponsors(:moustache_club_sponsor_for_groucho).id),
+      Member.where("sponsors.id" => sponsors(:moustache_club_sponsor_for_groucho).id),
       [members(:groucho)], :nested_sponsors
     )
   end
@@ -149,7 +149,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
     groucho_details, other_details = member_details(:groucho), member_details(:some_other_guy)
 
     assert_equal [groucho_details, other_details],
-                 members(:groucho).organization_member_details.order('member_details.id')
+                 members(:groucho).organization_member_details.order("member_details.id")
   end
 
   def test_has_many_through_has_one_with_has_many_through_source_reflection_preload
@@ -164,12 +164,12 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_many_through_has_one_with_has_many_through_source_reflection_preload_via_joins
     assert_includes_and_joins_equal(
-      Member.where('member_details.id' => member_details(:groucho).id).order('member_details.id'),
+      Member.where("member_details.id" => member_details(:groucho).id).order("member_details.id"),
       [members(:groucho), members(:some_other_guy)], :organization_member_details
     )
 
     members = Member.joins(:organization_member_details).
-                     where('member_details.id' => 9)
+                     where("member_details.id" => 9)
     assert members.empty?
   end
 
@@ -180,7 +180,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
     groucho_details, other_details = member_details(:groucho), member_details(:some_other_guy)
 
     assert_equal [groucho_details, other_details],
-                 members(:groucho).organization_member_details_2.order('member_details.id')
+                 members(:groucho).organization_member_details_2.order("member_details.id")
   end
 
   def test_has_many_through_has_one_through_with_has_many_source_reflection_preload
@@ -196,12 +196,12 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_many_through_has_one_through_with_has_many_source_reflection_preload_via_joins
     assert_includes_and_joins_equal(
-      Member.where('member_details.id' => member_details(:groucho).id).order('member_details.id'),
+      Member.where("member_details.id" => member_details(:groucho).id).order("member_details.id"),
       [members(:groucho), members(:some_other_guy)], :organization_member_details_2
     )
 
     members = Member.joins(:organization_member_details_2).
-                     where('member_details.id' => 9)
+                     where("member_details.id" => 9)
     assert members.empty?
   end
 
@@ -211,7 +211,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
   def test_has_many_through_has_many_with_has_and_belongs_to_many_source_reflection
     general, cooking = categories(:general), categories(:cooking)
 
-    assert_equal [general, cooking], authors(:bob).post_categories.order('categories.id')
+    assert_equal [general, cooking], authors(:bob).post_categories.order("categories.id")
   end
 
   def test_has_many_through_has_many_with_has_and_belongs_to_many_source_reflection_preload
@@ -228,7 +228,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
     Author.joins(:post_categories).first
 
     assert_includes_and_joins_equal(
-      Author.where('categories.id' => categories(:cooking).id),
+      Author.where("categories.id" => categories(:cooking).id),
       [authors(:bob)], :post_categories
     )
   end
@@ -239,7 +239,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
   def test_has_many_through_has_and_belongs_to_many_with_has_many_source_reflection
     greetings, more = comments(:greetings), comments(:more_greetings)
 
-    assert_equal [greetings, more], categories(:technology).post_comments.order('comments.id')
+    assert_equal [greetings, more], categories(:technology).post_comments.order("comments.id")
   end
 
   def test_has_many_through_has_and_belongs_to_many_with_has_many_source_reflection_preload
@@ -257,7 +257,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
     Category.joins(:post_comments).first
 
     assert_includes_and_joins_equal(
-      Category.where('comments.id' => comments(:more_greetings).id).order('categories.id'),
+      Category.where("comments.id" => comments(:more_greetings).id).order("categories.id"),
       [categories(:general), categories(:technology)], :post_comments
     )
   end
@@ -268,7 +268,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
   def test_has_many_through_has_many_with_has_many_through_habtm_source_reflection
     greetings, more = comments(:greetings), comments(:more_greetings)
 
-    assert_equal [greetings, more], authors(:bob).category_post_comments.order('comments.id')
+    assert_equal [greetings, more], authors(:bob).category_post_comments.order("comments.id")
   end
 
   def test_has_many_through_has_many_with_has_many_through_habtm_source_reflection_preload
@@ -285,7 +285,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
     Author.joins(:category_post_comments).first
 
     assert_includes_and_joins_equal(
-      Author.where('comments.id' => comments(:does_it_hurt).id).order('authors.id'),
+      Author.where("comments.id" => comments(:does_it_hurt).id).order("authors.id"),
       [authors(:david), authors(:mary)], :category_post_comments
     )
   end
@@ -308,7 +308,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_many_through_has_many_through_with_belongs_to_source_reflection_preload_via_joins
     assert_includes_and_joins_equal(
-      Author.where('tags.id' => tags(:general).id),
+      Author.where("tags.id" => tags(:general).id),
       [authors(:david)], :tagging_tags
     )
   end
@@ -320,7 +320,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
     welcome_general, thinking_general = taggings(:welcome_general), taggings(:thinking_general)
 
     assert_equal [welcome_general, thinking_general],
-                 categorizations(:david_welcome_general).post_taggings.order('taggings.id')
+                 categorizations(:david_welcome_general).post_taggings.order("taggings.id")
   end
 
   def test_has_many_through_belongs_to_with_has_many_through_source_reflection_preload
@@ -334,7 +334,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_many_through_belongs_to_with_has_many_through_source_reflection_preload_via_joins
     assert_includes_and_joins_equal(
-      Categorization.where('taggings.id' => taggings(:welcome_general).id).order('taggings.id'),
+      Categorization.where("taggings.id" => taggings(:welcome_general).id).order("taggings.id"),
       [categorizations(:david_welcome_general)], :post_taggings
     )
   end
@@ -357,7 +357,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_one_through_has_one_with_has_one_through_source_reflection_preload_via_joins
     assert_includes_and_joins_equal(
-      Member.where('member_types.id' => member_types(:founding).id),
+      Member.where("member_types.id" => member_types(:founding).id),
       [members(:groucho)], :nested_member_type
     )
   end
@@ -391,7 +391,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_one_through_has_one_through_with_belongs_to_source_reflection_preload_via_joins
     assert_includes_and_joins_equal(
-      Member.where('categories.id' => categories(:technology).id),
+      Member.where("categories.id" => categories(:technology).id),
       [members(:blarpy_winkup)], :club_category
     )
   end
@@ -404,7 +404,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
   def test_distinct_has_many_through_a_has_many_through_association_on_through_reflection
     author = authors(:david)
     assert_equal [subscribers(:first), subscribers(:second)],
-                 author.distinct_subscribers.order('subscribers.nick')
+                 author.distinct_subscribers.order("subscribers.nick")
   end
 
   def test_nested_has_many_through_with_a_table_referenced_multiple_times
@@ -413,26 +413,26 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
                  author.similar_posts.sort_by(&:id)
 
     # Mary and Bob both have posts in misc, but they are the only ones.
-    authors = Author.joins(:similar_posts).where('posts.id' => posts(:misc_by_bob).id)
+    authors = Author.joins(:similar_posts).where("posts.id" => posts(:misc_by_bob).id)
     assert_equal [authors(:mary), authors(:bob)], authors.distinct.sort_by(&:id)
 
     # Check the polymorphism of taggings is being observed correctly (in both joins)
-    authors = Author.joins(:similar_posts).where('taggings.taggable_type' => 'FakeModel')
+    authors = Author.joins(:similar_posts).where("taggings.taggable_type" => "FakeModel")
     assert authors.empty?
-    authors = Author.joins(:similar_posts).where('taggings_authors_join.taggable_type' => 'FakeModel')
+    authors = Author.joins(:similar_posts).where("taggings_authors_join.taggable_type" => "FakeModel")
     assert authors.empty?
   end
 
   def test_has_many_through_with_foreign_key_option_on_through_reflection
-    assert_equal [posts(:welcome), posts(:authorless)], people(:david).agents_posts.order('posts.id')
+    assert_equal [posts(:welcome), posts(:authorless)], people(:david).agents_posts.order("posts.id")
     assert_equal [authors(:david)], references(:david_unicyclist).agents_posts_authors
 
-    references = Reference.joins(:agents_posts_authors).where('authors.id' => authors(:david).id)
+    references = Reference.joins(:agents_posts_authors).where("authors.id" => authors(:david).id)
     assert_equal [references(:david_unicyclist)], references
   end
 
   def test_has_many_through_with_foreign_key_option_on_source_reflection
-    assert_equal [people(:michael), people(:susan)], jobs(:unicyclist).agents.order('people.id')
+    assert_equal [people(:michael), people(:susan)], jobs(:unicyclist).agents.order("people.id")
 
     jobs = Job.joins(:agents)
     assert_equal [jobs(:unicyclist), jobs(:unicyclist)], jobs
@@ -505,7 +505,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_nested_has_many_through_with_conditions_on_through_associations_preload
-    assert Author.where('tags.id' => 100).joins(:misc_post_first_blue_tags).empty?
+    assert Author.where("tags.id" => 100).joins(:misc_post_first_blue_tags).empty?
 
     authors = assert_queries(3) { Author.includes(:misc_post_first_blue_tags).to_a.sort_by(&:id) }
     blue = tags(:blue)
@@ -518,7 +518,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
   def test_nested_has_many_through_with_conditions_on_through_associations_preload_via_joins
     # Pointless condition to force single-query loading
     assert_includes_and_joins_equal(
-      Author.where('tags.id = tags.id').references(:tags),
+      Author.where("tags.id = tags.id").references(:tags),
       [authors(:bob)], :misc_post_first_blue_tags
     )
   end
@@ -539,7 +539,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
   def test_nested_has_many_through_with_conditions_on_source_associations_preload_via_joins
     # Pointless condition to force single-query loading
     assert_includes_and_joins_equal(
-      Author.where('tags.id = tags.id').references(:tags),
+      Author.where("tags.id = tags.id").references(:tags),
       [authors(:bob)], :misc_post_first_blue_tags_2
     )
   end
@@ -548,13 +548,13 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
     assert_equal [categories(:general)], organizations(:nsa).author_essay_categories
 
     organizations = Organization.joins(:author_essay_categories).
-                                 where('categories.id' => categories(:general).id)
+                                 where("categories.id" => categories(:general).id)
     assert_equal [organizations(:nsa)], organizations
 
     assert_equal categories(:general), organizations(:nsa).author_owned_essay_category
 
     organizations = Organization.joins(:author_owned_essay_category).
-                                 where('categories.id' => categories(:general).id)
+                                 where("categories.id" => categories(:general).id)
     assert_equal [organizations(:nsa)], organizations
   end
 
diff --git a/activerecord/test/cases/associations/required_test.rb b/activerecord/test/cases/associations/required_test.rb
index 3e5494e897..7d7da44629 100644
--- a/activerecord/test/cases/associations/required_test.rb
+++ b/activerecord/test/cases/associations/required_test.rb
@@ -18,8 +18,8 @@ class RequiredAssociationsTest < ActiveRecord::TestCase
   end
 
   teardown do
-    @connection.drop_table 'parents', if_exists: true
-    @connection.drop_table 'children', if_exists: true
+    @connection.drop_table "parents", if_exists: true
+    @connection.drop_table "children", if_exists: true
   end
 
   test "belongs_to associations are not required by default" do
diff --git a/activerecord/test/cases/associations_test.rb b/activerecord/test/cases/associations_test.rb
index 7efacb44f3..f0b1f0bbe8 100644
--- a/activerecord/test/cases/associations_test.rb
+++ b/activerecord/test/cases/associations_test.rb
@@ -1,36 +1,36 @@
 require "cases/helper"
-require 'models/computer'
-require 'models/developer'
-require 'models/project'
-require 'models/company'
-require 'models/categorization'
-require 'models/category'
-require 'models/post'
-require 'models/author'
-require 'models/comment'
-require 'models/tag'
-require 'models/tagging'
-require 'models/person'
-require 'models/reader'
-require 'models/ship_part'
-require 'models/ship'
-require 'models/liquid'
-require 'models/molecule'
-require 'models/electron'
-require 'models/man'
-require 'models/interest'
+require "models/computer"
+require "models/developer"
+require "models/project"
+require "models/company"
+require "models/categorization"
+require "models/category"
+require "models/post"
+require "models/author"
+require "models/comment"
+require "models/tag"
+require "models/tagging"
+require "models/person"
+require "models/reader"
+require "models/ship_part"
+require "models/ship"
+require "models/liquid"
+require "models/molecule"
+require "models/electron"
+require "models/man"
+require "models/interest"
 
 class AssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :companies, :developers, :projects, :developers_projects,
            :computers, :people, :readers, :authors, :author_favorites
 
   def test_eager_loading_should_not_change_count_of_children
-    liquid = Liquid.create(:name => 'salty')
-    molecule = liquid.molecules.create(:name => 'molecule_1')
-    molecule.electrons.create(:name => 'electron_1')
-    molecule.electrons.create(:name => 'electron_2')
+    liquid = Liquid.create(:name => "salty")
+    molecule = liquid.molecules.create(:name => "molecule_1")
+    molecule.electrons.create(:name => "electron_1")
+    molecule.electrons.create(:name => "electron_2")
 
-    liquids = Liquid.includes(:molecules => :electrons).references(:molecules).where('molecules.id is not null')
+    liquids = Liquid.includes(:molecules => :electrons).references(:molecules).where("molecules.id is not null")
     assert_equal 1, liquids[0].molecules.length
   end
 
@@ -52,24 +52,24 @@ class AssociationsTest < ActiveRecord::TestCase
     ship = Ship.create!(:name => "The good ship Dollypop")
     part = ship.parts.create!(:name => "Mast")
     part.mark_for_destruction
-    ShipPart.find(part.id).update_columns(name: 'Deck')
-    assert_equal 'Deck', ship.parts[0].name
+    ShipPart.find(part.id).update_columns(name: "Deck")
+    assert_equal "Deck", ship.parts[0].name
   end
 
 
   def test_include_with_order_works
-    assert_nothing_raised {Account.all.merge!(:order => 'id', :includes => :firm).first}
+    assert_nothing_raised {Account.all.merge!(:order => "id", :includes => :firm).first}
     assert_nothing_raised {Account.all.merge!(:order => :id, :includes => :firm).first}
   end
 
   def test_bad_collection_keys
-    assert_raise(ArgumentError, 'ActiveRecord should have barked on bad collection keys') do
-      Class.new(ActiveRecord::Base).has_many(:wheels, :name => 'wheels')
+    assert_raise(ArgumentError, "ActiveRecord should have barked on bad collection keys") do
+      Class.new(ActiveRecord::Base).has_many(:wheels, :name => "wheels")
     end
   end
 
   def test_should_construct_new_finder_sql_after_create
-    person = Person.new :first_name => 'clark'
+    person = Person.new :first_name => "clark"
     assert_equal [], person.readers.to_a
     person.save!
     reader = Reader.create! :person => person, :post => Post.new(:title => "foo", :body => "bar")
@@ -120,7 +120,7 @@ class AssociationsTest < ActiveRecord::TestCase
 
   def test_association_with_references
     firm = companies(:first_firm)
-    assert_includes firm.association_with_references.references_values, 'foo'
+    assert_includes firm.association_with_references.references_values, "foo"
   end
 
 end
@@ -190,7 +190,7 @@ class AssociationProxyTest < ActiveRecord::TestCase
   end
 
   def test_inspect_does_not_reload_a_not_yet_loaded_target
-    andreas = Developer.new :name => 'Andreas', :log => 'new developer added'
+    andreas = Developer.new :name => "Andreas", :log => "new developer added"
     assert !andreas.audit_logs.loaded?
     assert_match(/message: "new developer added"/, andreas.audit_logs.inspect)
   end
@@ -225,7 +225,7 @@ class AssociationProxyTest < ActiveRecord::TestCase
   end
 
   def test_scoped_allows_conditions
-    assert developers(:david).projects.merge(where: 'foo').to_sql.include?('foo')
+    assert developers(:david).projects.merge(where: "foo").to_sql.include?("foo")
   end
 
   test "getting a scope from an association" do
@@ -280,10 +280,10 @@ class OverridingAssociationsTest < ActiveRecord::TestCase
 
   class DifferentPeopleList < PeopleList
     # Different association with the same name, callbacks should be omitted here.
-    has_and_belongs_to_many :has_and_belongs_to_many, :class_name => 'DifferentPerson'
-    has_many :has_many, :class_name => 'DifferentPerson'
-    belongs_to :belongs_to, :class_name => 'DifferentPerson'
-    has_one :has_one, :class_name => 'DifferentPerson'
+    has_and_belongs_to_many :has_and_belongs_to_many, :class_name => "DifferentPerson"
+    has_many :has_many, :class_name => "DifferentPerson"
+    belongs_to :belongs_to, :class_name => "DifferentPerson"
+    has_one :has_one, :class_name => "DifferentPerson"
   end
 
   def test_habtm_association_redefinition_callbacks_should_differ_and_not_inherited
diff --git a/activerecord/test/cases/attribute_decorators_test.rb b/activerecord/test/cases/attribute_decorators_test.rb
index 2aeb2601c2..cfa6ed1da6 100644
--- a/activerecord/test/cases/attribute_decorators_test.rb
+++ b/activerecord/test/cases/attribute_decorators_test.rb
@@ -1,9 +1,9 @@
-require 'cases/helper'
+require "cases/helper"
 
 module ActiveRecord
   class AttributeDecoratorsTest < ActiveRecord::TestCase
     class Model < ActiveRecord::Base
-      self.table_name = 'attribute_decorators_model'
+      self.table_name = "attribute_decorators_model"
     end
 
     class StringDecorator < SimpleDelegator
@@ -28,19 +28,19 @@ module ActiveRecord
 
     teardown do
       return unless @connection
-      @connection.drop_table 'attribute_decorators_model', if_exists: true
+      @connection.drop_table "attribute_decorators_model", if_exists: true
       Model.attribute_type_decorations.clear
       Model.reset_column_information
     end
 
     test "attributes can be decorated" do
-      model = Model.new(a_string: 'Hello')
-      assert_equal 'Hello', model.a_string
+      model = Model.new(a_string: "Hello")
+      assert_equal "Hello", model.a_string
 
       Model.decorate_attribute_type(:a_string, :test) { |t| StringDecorator.new(t) }
 
-      model = Model.new(a_string: 'Hello')
-      assert_equal 'Hello decorated!', model.a_string
+      model = Model.new(a_string: "Hello")
+      assert_equal "Hello decorated!", model.a_string
     end
 
     test "decoration does not eagerly load existing columns" do
@@ -51,54 +51,54 @@ module ActiveRecord
     end
 
     test "undecorated columns are not touched" do
-      Model.attribute :another_string, :string, default: 'something or other'
+      Model.attribute :another_string, :string, default: "something or other"
       Model.decorate_attribute_type(:a_string, :test) { |t| StringDecorator.new(t) }
 
-      assert_equal 'something or other', Model.new.another_string
+      assert_equal "something or other", Model.new.another_string
     end
 
     test "decorators can be chained" do
       Model.decorate_attribute_type(:a_string, :test) { |t| StringDecorator.new(t) }
       Model.decorate_attribute_type(:a_string, :other) { |t| StringDecorator.new(t) }
 
-      model = Model.new(a_string: 'Hello!')
+      model = Model.new(a_string: "Hello!")
 
-      assert_equal 'Hello! decorated! decorated!', model.a_string
+      assert_equal "Hello! decorated! decorated!", model.a_string
     end
 
     test "decoration of the same type multiple times is idempotent" do
       Model.decorate_attribute_type(:a_string, :test) { |t| StringDecorator.new(t) }
       Model.decorate_attribute_type(:a_string, :test) { |t| StringDecorator.new(t) }
 
-      model = Model.new(a_string: 'Hello')
-      assert_equal 'Hello decorated!', model.a_string
+      model = Model.new(a_string: "Hello")
+      assert_equal "Hello decorated!", model.a_string
     end
 
     test "decorations occur in order of declaration" do
       Model.decorate_attribute_type(:a_string, :test) { |t| StringDecorator.new(t) }
       Model.decorate_attribute_type(:a_string, :other) do |type|
-        StringDecorator.new(type, 'decorated again!')
+        StringDecorator.new(type, "decorated again!")
       end
 
-      model = Model.new(a_string: 'Hello!')
+      model = Model.new(a_string: "Hello!")
 
-      assert_equal 'Hello! decorated! decorated again!', model.a_string
+      assert_equal "Hello! decorated! decorated again!", model.a_string
     end
 
     test "decorating attributes does not modify parent classes" do
-      Model.attribute :another_string, :string, default: 'whatever'
+      Model.attribute :another_string, :string, default: "whatever"
       Model.decorate_attribute_type(:a_string, :test) { |t| StringDecorator.new(t) }
       child_class = Class.new(Model)
       child_class.decorate_attribute_type(:another_string, :test) { |t| StringDecorator.new(t) }
       child_class.decorate_attribute_type(:a_string, :other) { |t| StringDecorator.new(t) }
 
-      model = Model.new(a_string: 'Hello!')
-      child = child_class.new(a_string: 'Hello!')
+      model = Model.new(a_string: "Hello!")
+      child = child_class.new(a_string: "Hello!")
 
-      assert_equal 'Hello! decorated!', model.a_string
-      assert_equal 'whatever', model.another_string
-      assert_equal 'Hello! decorated! decorated!', child.a_string
-      assert_equal 'whatever decorated!', child.another_string
+      assert_equal "Hello! decorated!", model.a_string
+      assert_equal "whatever", model.another_string
+      assert_equal "Hello! decorated! decorated!", child.a_string
+      assert_equal "whatever decorated!", child.another_string
     end
 
     class Multiplier < SimpleDelegator
@@ -116,9 +116,9 @@ module ActiveRecord
         Multiplier.new(type)
       end
 
-      model = Model.new(a_string: 'whatever', an_int: 1)
+      model = Model.new(a_string: "whatever", an_int: 1)
 
-      assert_equal 'whatever', model.a_string
+      assert_equal "whatever", model.a_string
       assert_equal 2, model.an_int
     end
   end
diff --git a/activerecord/test/cases/attribute_methods/read_test.rb b/activerecord/test/cases/attribute_methods/read_test.rb
index 74e556211b..2d2ecb4079 100644
--- a/activerecord/test/cases/attribute_methods/read_test.rb
+++ b/activerecord/test/cases/attribute_methods/read_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'thread'
+require "thread"
 
 module ActiveRecord
   module AttributeMethods
diff --git a/activerecord/test/cases/attribute_methods_test.rb b/activerecord/test/cases/attribute_methods_test.rb
index 9d66c9964c..102884d255 100644
--- a/activerecord/test/cases/attribute_methods_test.rb
+++ b/activerecord/test/cases/attribute_methods_test.rb
@@ -1,15 +1,15 @@
 require "cases/helper"
-require 'models/minimalistic'
-require 'models/developer'
-require 'models/auto_id'
-require 'models/boolean'
-require 'models/computer'
-require 'models/topic'
-require 'models/company'
-require 'models/category'
-require 'models/reply'
-require 'models/contact'
-require 'models/keyboard'
+require "models/minimalistic"
+require "models/developer"
+require "models/auto_id"
+require "models/boolean"
+require "models/computer"
+require "models/topic"
+require "models/company"
+require "models/category"
+require "models/reply"
+require "models/contact"
+require "models/keyboard"
 
 class AttributeMethodsTest < ActiveRecord::TestCase
   include InTimeZone
@@ -19,7 +19,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
   def setup
     @old_matchers = ActiveRecord::Base.send(:attribute_method_matchers).dup
     @target = Class.new(ActiveRecord::Base)
-    @target.table_name = 'topics'
+    @target.table_name = "topics"
   end
 
   teardown do
@@ -27,34 +27,34 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     ActiveRecord::Base.send(:attribute_method_matchers).concat(@old_matchers)
   end
 
-  test 'attribute_for_inspect with a string' do
+  test "attribute_for_inspect with a string" do
     t = topics(:first)
     t.title = "The First Topic Now Has A Title With\nNewlines And More Than 50 Characters"
 
     assert_equal '"The First Topic Now Has A Title With\nNewlines And ..."', t.attribute_for_inspect(:title)
   end
 
-  test 'attribute_for_inspect with a date' do
+  test "attribute_for_inspect with a date" do
     t = topics(:first)
 
     assert_equal %("#{t.written_on.to_s(:db)}"), t.attribute_for_inspect(:written_on)
   end
 
-  test 'attribute_for_inspect with an array' do
+  test "attribute_for_inspect with an array" do
     t = topics(:first)
     t.content = [Object.new]
 
     assert_match %r(\[#<Object:0x[0-9a-f]+>\]), t.attribute_for_inspect(:content)
   end
 
-  test 'attribute_for_inspect with a long array' do
+  test "attribute_for_inspect with a long array" do
     t = topics(:first)
     t.content = (1..11).to_a
 
     assert_equal "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]", t.attribute_for_inspect(:content)
   end
 
-  test 'attribute_present' do
+  test "attribute_present" do
     t = Topic.new
     t.title = "hello there!"
     t.written_on = Time.now
@@ -65,7 +65,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert !t.attribute_present?("author_name")
   end
 
-  test 'attribute_present with booleans' do
+  test "attribute_present with booleans" do
     b1 = Boolean.new
     b1.value = false
     assert b1.attribute_present?(:value)
@@ -83,44 +83,44 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert Boolean.find(b4.id).attribute_present?(:value)
   end
 
-  test 'caching a nil primary key' do
+  test "caching a nil primary key" do
     klass = Class.new(Minimalistic)
     assert_called(klass, :reset_primary_key, returns: nil) do
       2.times { klass.primary_key }
     end
   end
 
-  test 'attribute keys on a new instance' do
+  test "attribute keys on a new instance" do
     t = Topic.new
     assert_equal nil, t.title, "The topics table has a title column, so it should be nil"
     assert_raise(NoMethodError) { t.title2 }
   end
 
-  test 'boolean attributes' do
+  test "boolean attributes" do
     assert !Topic.find(1).approved?
     assert Topic.find(2).approved?
   end
 
-  test 'set attributes' do
+  test "set attributes" do
     topic = Topic.find(1)
-    topic.attributes = { title: 'Budget', author_name: 'Jason' }
+    topic.attributes = { title: "Budget", author_name: "Jason" }
     topic.save
-    assert_equal('Budget', topic.title)
-    assert_equal('Jason', topic.author_name)
+    assert_equal("Budget", topic.title)
+    assert_equal("Jason", topic.author_name)
     assert_equal(topics(:first).author_email_address, Topic.find(1).author_email_address)
   end
 
-  test 'set attributes without a hash' do
+  test "set attributes without a hash" do
     topic = Topic.new
-    assert_raise(ArgumentError) { topic.attributes = '' }
+    assert_raise(ArgumentError) { topic.attributes = "" }
   end
 
-  test 'integers as nil' do
-    test = AutoId.create(value: '')
+  test "integers as nil" do
+    test = AutoId.create(value: "")
     assert_nil AutoId.find(test.id).value
   end
 
-  test 'set attributes with a block' do
+  test "set attributes with a block" do
     topic = Topic.new do |t|
       t.title       = "Budget"
       t.author_name = "Jason"
@@ -130,7 +130,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal("Jason", topic.author_name)
   end
 
-  test 'respond_to?' do
+  test "respond_to?" do
     topic = Topic.find(1)
     assert_respond_to topic, "title"
     assert_respond_to topic, "title?"
@@ -144,27 +144,27 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert !topic.respond_to?(:nothingness)
   end
 
-  test 'respond_to? with a custom primary key' do
+  test "respond_to? with a custom primary key" do
     keyboard = Keyboard.create
     assert_not_nil keyboard.key_number
     assert_equal keyboard.key_number, keyboard.id
-    assert keyboard.respond_to?('key_number')
-    assert keyboard.respond_to?('id')
+    assert keyboard.respond_to?("key_number")
+    assert keyboard.respond_to?("id")
   end
 
-  test 'id_before_type_cast with a custom primary key' do
+  test "id_before_type_cast with a custom primary key" do
     keyboard = Keyboard.create
-    keyboard.key_number = '10'
-    assert_equal '10', keyboard.id_before_type_cast
-    assert_equal nil, keyboard.read_attribute_before_type_cast('id')
-    assert_equal '10', keyboard.read_attribute_before_type_cast('key_number')
-    assert_equal '10', keyboard.read_attribute_before_type_cast(:key_number)
+    keyboard.key_number = "10"
+    assert_equal "10", keyboard.id_before_type_cast
+    assert_equal nil, keyboard.read_attribute_before_type_cast("id")
+    assert_equal "10", keyboard.read_attribute_before_type_cast("key_number")
+    assert_equal "10", keyboard.read_attribute_before_type_cast(:key_number)
   end
 
   # Syck calls respond_to? before actually calling initialize.
-  test 'respond_to? with an allocated object' do
+  test "respond_to? with an allocated object" do
     klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'topics'
+      self.table_name = "topics"
     end
 
     topic = klass.allocate
@@ -175,12 +175,12 @@ class AttributeMethodsTest < ActiveRecord::TestCase
   end
 
   # IRB inspects the return value of MyModel.allocate.
-  test 'allocated objects can be inspected' do
+  test "allocated objects can be inspected" do
     topic = Topic.allocate
     assert_equal "#<Topic not initialized>", topic.inspect
   end
 
-  test 'array content' do
+  test "array content" do
     content = %w( one two three )
     topic = Topic.new
     topic.content = content
@@ -189,16 +189,16 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal content, Topic.find(topic.id).content
   end
 
-  test 'read attributes_before_type_cast' do
-    category = Category.new(name: 'Test category', type: nil)
-    category_attrs = { 'name' => 'Test category', 'id' => nil, 'type' => nil, 'categorizations_count' => nil }
+  test "read attributes_before_type_cast" do
+    category = Category.new(name: "Test category", type: nil)
+    category_attrs = { "name" => "Test category", "id" => nil, "type" => nil, "categorizations_count" => nil }
     assert_equal category_attrs, category.attributes_before_type_cast
   end
 
   if current_adapter?(:Mysql2Adapter)
-    test 'read attributes_before_type_cast on a boolean' do
+    test "read attributes_before_type_cast on a boolean" do
       bool = Boolean.create!({ "value" => false })
-      if RUBY_PLATFORM.include?('java')
+      if RUBY_PLATFORM.include?("java")
         # JRuby will return the value before typecast as string.
         assert_equal "0", bool.reload.attributes_before_type_cast["value"]
       else
@@ -207,7 +207,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'read attributes_before_type_cast on a datetime' do
+  test "read attributes_before_type_cast on a datetime" do
     in_time_zone "Pacific Time (US & Canada)" do
       record = @target.new
 
@@ -222,7 +222,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'read attributes_after_type_cast on a date' do
+  test "read attributes_after_type_cast on a date" do
     tz = "Pacific Time (US & Canada)"
 
     in_time_zone tz do
@@ -243,7 +243,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'hash content' do
+  test "hash content" do
     topic = Topic.new
     topic.content = { "one" => 1, "two" => 2 }
     topic.save
@@ -257,7 +257,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal 3, Topic.find(topic.id).content["three"]
   end
 
-  test 'update array content' do
+  test "update array content" do
     topic = Topic.new
     topic.content = %w( one two three )
 
@@ -271,25 +271,25 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal(%w( one two three four five ), topic.content)
   end
 
-  test 'case-sensitive attributes hash' do
+  test "case-sensitive attributes hash" do
     # DB2 is not case-sensitive.
     return true if current_adapter?(:DB2Adapter)
 
-    assert_equal @loaded_fixtures['computers']['workstation'].to_hash, Computer.first.attributes
+    assert_equal @loaded_fixtures["computers"]["workstation"].to_hash, Computer.first.attributes
   end
 
-  test 'attributes without primary key' do
+  test "attributes without primary key" do
     klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'developers_projects'
+      self.table_name = "developers_projects"
     end
 
     assert_equal klass.column_names, klass.new.attributes.keys
-    assert_not klass.new.has_attribute?('id')
+    assert_not klass.new.has_attribute?("id")
   end
 
-  test 'hashes are not mangled' do
-    new_topic = { title: 'New Topic' }
-    new_topic_values = { title: 'AnotherTopic' }
+  test "hashes are not mangled" do
+    new_topic = { title: "New Topic" }
+    new_topic_values = { title: "AnotherTopic" }
 
     topic = Topic.new(new_topic)
     assert_equal new_topic[:title], topic.title
@@ -298,13 +298,13 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal new_topic_values[:title], topic.title
   end
 
-  test 'create through factory' do
-    topic = Topic.create(title: 'New Topic')
+  test "create through factory" do
+    topic = Topic.create(title: "New Topic")
     topicReloaded = Topic.find(topic.id)
     assert_equal(topic, topicReloaded)
   end
 
-  test 'write_attribute' do
+  test "write_attribute" do
     topic = Topic.new
     topic.send(:write_attribute, :title, "Still another topic")
     assert_equal "Still another topic", topic.title
@@ -319,7 +319,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal "Still another topic: part 4", topic.title
   end
 
-  test 'read_attribute' do
+  test "read_attribute" do
     topic = Topic.new
     topic.title = "Don't change the topic"
     assert_equal "Don't change the topic", topic.read_attribute("title")
@@ -329,15 +329,15 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal "Don't change the topic", topic[:title]
   end
 
-  test 'read_attribute raises ActiveModel::MissingAttributeError when the attribute does not exist' do
-    computer = Computer.select('id').first
+  test "read_attribute raises ActiveModel::MissingAttributeError when the attribute does not exist" do
+    computer = Computer.select("id").first
     assert_raises(ActiveModel::MissingAttributeError) { computer[:developer] }
     assert_raises(ActiveModel::MissingAttributeError) { computer[:extendedWarranty] }
-    assert_raises(ActiveModel::MissingAttributeError) { computer[:no_column_exists] = 'Hello!' }
-    assert_nothing_raised { computer[:developer] = 'Hello!' }
+    assert_raises(ActiveModel::MissingAttributeError) { computer[:no_column_exists] = "Hello!" }
+    assert_nothing_raised { computer[:developer] = "Hello!" }
   end
 
-  test 'read_attribute when false' do
+  test "read_attribute when false" do
     topic = topics(:first)
     topic.approved = false
     assert !topic.approved?, "approved should be false"
@@ -345,7 +345,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert !topic.approved?, "approved should be false"
   end
 
-  test 'read_attribute when true' do
+  test "read_attribute when true" do
     topic = topics(:first)
     topic.approved = true
     assert topic.approved?, "approved should be true"
@@ -353,7 +353,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert topic.approved?, "approved should be true"
   end
 
-  test 'boolean attributes writing and reading' do
+  test "boolean attributes writing and reading" do
     topic = Topic.new
     topic.approved = "false"
     assert !topic.approved?, "approved should be false"
@@ -368,7 +368,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert topic.approved?, "approved should be true"
   end
 
-  test 'overridden write_attribute' do
+  test "overridden write_attribute" do
     topic = Topic.new
     def topic.write_attribute(attr_name, value)
       super(attr_name, value.downcase)
@@ -387,7 +387,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal "yet another topic: part 4", topic.title
   end
 
-  test 'overridden read_attribute' do
+  test "overridden read_attribute" do
     topic = Topic.new
     topic.title = "Stop changing the topic"
     def topic.read_attribute(attr_name)
@@ -401,30 +401,30 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal "STOP CHANGING THE TOPIC", topic[:title]
   end
 
-  test 'read overridden attribute' do
-    topic = Topic.new(title: 'a')
-    def topic.title() 'b' end
-    assert_equal 'a', topic[:title]
+  test "read overridden attribute" do
+    topic = Topic.new(title: "a")
+    def topic.title() "b" end
+    assert_equal "a", topic[:title]
   end
 
-  test 'string attribute predicate' do
+  test "string attribute predicate" do
     [nil, "", " "].each do |value|
       assert_equal false, Topic.new(author_name: value).author_name?
     end
 
-    assert_equal true, Topic.new(author_name: 'Name').author_name?
+    assert_equal true, Topic.new(author_name: "Name").author_name?
   end
 
-  test 'number attribute predicate' do
-    [nil, 0, '0'].each do |value|
+  test "number attribute predicate" do
+    [nil, 0, "0"].each do |value|
       assert_equal false, Developer.new(salary: value).salary?
     end
 
     assert_equal true, Developer.new(salary: 1).salary?
-    assert_equal true, Developer.new(salary: '1').salary?
+    assert_equal true, Developer.new(salary: "1").salary?
   end
 
-  test 'boolean attribute predicate' do
+  test "boolean attribute predicate" do
     [nil, "", false, "false", "f", 0].each do |value|
       assert_equal false, Topic.new(approved: value).approved?
     end
@@ -434,7 +434,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'custom field attribute predicate' do
+  test "custom field attribute predicate" do
     object = Company.find_by_sql(<<-SQL).first
       SELECT c1.*, c2.type as string_value, c2.rating as int_value
         FROM companies c1, companies c2
@@ -455,93 +455,93 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert !object.int_value?
   end
 
-  test 'non-attribute read and write' do
+  test "non-attribute read and write" do
     topic = Topic.new
     assert !topic.respond_to?("mumbo")
     assert_raise(NoMethodError) { topic.mumbo }
     assert_raise(NoMethodError) { topic.mumbo = 5 }
   end
 
-  test 'undeclared attribute method does not affect respond_to? and method_missing' do
-    topic = @target.new(title: 'Budget')
-    assert topic.respond_to?('title')
-    assert_equal 'Budget', topic.title
-    assert !topic.respond_to?('title_hello_world')
+  test "undeclared attribute method does not affect respond_to? and method_missing" do
+    topic = @target.new(title: "Budget")
+    assert topic.respond_to?("title")
+    assert_equal "Budget", topic.title
+    assert !topic.respond_to?("title_hello_world")
     assert_raise(NoMethodError) { topic.title_hello_world }
   end
 
-  test 'declared prefixed attribute method affects respond_to? and method_missing' do
-    topic = @target.new(title: 'Budget')
+  test "declared prefixed attribute method affects respond_to? and method_missing" do
+    topic = @target.new(title: "Budget")
     %w(default_ title_).each do |prefix|
       @target.class_eval "def #{prefix}attribute(*args) args end"
       @target.attribute_method_prefix prefix
 
       meth = "#{prefix}title"
       assert topic.respond_to?(meth)
-      assert_equal ['title'], topic.send(meth)
-      assert_equal ['title', 'a'], topic.send(meth, 'a')
-      assert_equal ['title', 1, 2, 3], topic.send(meth, 1, 2, 3)
+      assert_equal ["title"], topic.send(meth)
+      assert_equal ["title", "a"], topic.send(meth, "a")
+      assert_equal ["title", 1, 2, 3], topic.send(meth, 1, 2, 3)
     end
   end
 
-  test 'declared suffixed attribute method affects respond_to? and method_missing' do
+  test "declared suffixed attribute method affects respond_to? and method_missing" do
     %w(_default _title_default _it! _candidate= able?).each do |suffix|
       @target.class_eval "def attribute#{suffix}(*args) args end"
       @target.attribute_method_suffix suffix
-      topic = @target.new(title: 'Budget')
+      topic = @target.new(title: "Budget")
 
       meth = "title#{suffix}"
       assert topic.respond_to?(meth)
-      assert_equal ['title'], topic.send(meth)
-      assert_equal ['title', 'a'], topic.send(meth, 'a')
-      assert_equal ['title', 1, 2, 3], topic.send(meth, 1, 2, 3)
+      assert_equal ["title"], topic.send(meth)
+      assert_equal ["title", "a"], topic.send(meth, "a")
+      assert_equal ["title", 1, 2, 3], topic.send(meth, 1, 2, 3)
     end
   end
 
-  test 'declared affixed attribute method affects respond_to? and method_missing' do
-    [['mark_', '_for_update'], ['reset_', '!'], ['default_', '_value?']].each do |prefix, suffix|
+  test "declared affixed attribute method affects respond_to? and method_missing" do
+    [["mark_", "_for_update"], ["reset_", "!"], ["default_", "_value?"]].each do |prefix, suffix|
       @target.class_eval "def #{prefix}attribute#{suffix}(*args) args end"
       @target.attribute_method_affix(prefix: prefix, suffix: suffix)
-      topic = @target.new(title: 'Budget')
+      topic = @target.new(title: "Budget")
 
       meth = "#{prefix}title#{suffix}"
       assert topic.respond_to?(meth)
-      assert_equal ['title'], topic.send(meth)
-      assert_equal ['title', 'a'], topic.send(meth, 'a')
-      assert_equal ['title', 1, 2, 3], topic.send(meth, 1, 2, 3)
+      assert_equal ["title"], topic.send(meth)
+      assert_equal ["title", "a"], topic.send(meth, "a")
+      assert_equal ["title", 1, 2, 3], topic.send(meth, 1, 2, 3)
     end
   end
 
-  test 'should unserialize attributes for frozen records' do
+  test "should unserialize attributes for frozen records" do
     myobj = { value1: :value2 }
     topic = Topic.create(content: myobj)
     topic.freeze
     assert_equal myobj, topic.content
   end
 
-  test 'typecast attribute from select to false' do
-    Topic.create(title: 'Budget')
+  test "typecast attribute from select to false" do
+    Topic.create(title: "Budget")
     # Oracle does not support boolean expressions in SELECT.
     if current_adapter?(:OracleAdapter, :FbAdapter)
-      topic = Topic.all.merge!(select: 'topics.*, 0 as is_test').first
+      topic = Topic.all.merge!(select: "topics.*, 0 as is_test").first
     else
-      topic = Topic.all.merge!(select: 'topics.*, 1=2 as is_test').first
+      topic = Topic.all.merge!(select: "topics.*, 1=2 as is_test").first
     end
     assert !topic.is_test?
   end
 
-  test 'typecast attribute from select to true' do
-    Topic.create(title: 'Budget')
+  test "typecast attribute from select to true" do
+    Topic.create(title: "Budget")
     # Oracle does not support boolean expressions in SELECT.
     if current_adapter?(:OracleAdapter, :FbAdapter)
-      topic = Topic.all.merge!(select: 'topics.*, 1 as is_test').first
+      topic = Topic.all.merge!(select: "topics.*, 1 as is_test").first
     else
-      topic = Topic.all.merge!(select: 'topics.*, 2=2 as is_test').first
+      topic = Topic.all.merge!(select: "topics.*, 2=2 as is_test").first
     end
     assert topic.is_test?
   end
 
-  test 'raises ActiveRecord::DangerousAttributeError when defining an AR method in a model' do
+  test "raises ActiveRecord::DangerousAttributeError when defining an AR method in a model" do
     %w(save create_or_update).each do |method|
       klass = Class.new(ActiveRecord::Base)
       klass.class_eval "def #{method}() 'defined #{method}' end"
@@ -551,7 +551,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'converted values are returned after assignment' do
+  test "converted values are returned after assignment" do
     developer = Developer.new(name: 1337, salary: "50000")
 
     assert_equal "50000", developer.salary_before_type_cast
@@ -566,7 +566,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal "1337", developer.name
   end
 
-  test 'write nil to time attribute' do
+  test "write nil to time attribute" do
     in_time_zone "Pacific Time (US & Canada)" do
       record = @target.new
       record.written_on = nil
@@ -574,7 +574,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'write time to date attribute' do
+  test "write time to date attribute" do
     in_time_zone "Pacific Time (US & Canada)" do
       record = @target.new
       record.last_read = Time.utc(2010, 1, 1, 10)
@@ -582,7 +582,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'time attributes are retrieved in the current time zone' do
+  test "time attributes are retrieved in the current time zone" do
     in_time_zone "Pacific Time (US & Canada)" do
       utc_time = Time.utc(2008, 1, 1)
       record   = @target.new
@@ -594,7 +594,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'setting a time zone-aware attribute to UTC' do
+  test "setting a time zone-aware attribute to UTC" do
     in_time_zone "Pacific Time (US & Canada)" do
       utc_time = Time.utc(2008, 1, 1)
       record   = @target.new
@@ -605,7 +605,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'setting time zone-aware attribute in other time zone' do
+  test "setting time zone-aware attribute in other time zone" do
     utc_time = Time.utc(2008, 1, 1)
     cst_time = utc_time.in_time_zone("Central Time (US & Canada)")
     in_time_zone "Pacific Time (US & Canada)" do
@@ -617,7 +617,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'setting time zone-aware read attribute' do
+  test "setting time zone-aware read attribute" do
     utc_time = Time.utc(2008, 1, 1)
     cst_time = utc_time.in_time_zone("Central Time (US & Canada)")
     in_time_zone "Pacific Time (US & Canada)" do
@@ -628,7 +628,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'setting time zone-aware attribute with a string' do
+  test "setting time zone-aware attribute with a string" do
     utc_time = Time.utc(2008, 1, 1)
     (-11..13).each do |timezone_offset|
       time_string = utc_time.in_time_zone(timezone_offset).to_s
@@ -642,27 +642,27 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'time zone-aware attribute saved' do
+  test "time zone-aware attribute saved" do
     in_time_zone 1 do
-      record = @target.create(written_on: '2012-02-20 10:00')
+      record = @target.create(written_on: "2012-02-20 10:00")
 
-      record.written_on = '2012-02-20 09:00'
+      record.written_on = "2012-02-20 09:00"
       record.save
       assert_equal Time.zone.local(2012, 02, 20, 9), record.reload.written_on
     end
   end
 
-  test 'setting a time zone-aware attribute to a blank string returns nil' do
+  test "setting a time zone-aware attribute to a blank string returns nil" do
     in_time_zone "Pacific Time (US & Canada)" do
       record   = @target.new
-      record.written_on = ' '
+      record.written_on = " "
       assert_nil record.written_on
       assert_nil record[:written_on]
     end
   end
 
-  test 'setting a time zone-aware attribute interprets time zone-unaware string in time zone' do
-    time_string = 'Tue Jan 01 00:00:00 2008'
+  test "setting a time zone-aware attribute interprets time zone-unaware string in time zone" do
+    time_string = "Tue Jan 01 00:00:00 2008"
     (-11..13).each do |timezone_offset|
       in_time_zone timezone_offset do
         record   = @target.new
@@ -674,7 +674,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'setting a time zone-aware datetime in the current time zone' do
+  test "setting a time zone-aware datetime in the current time zone" do
     utc_time = Time.utc(2008, 1, 1)
     in_time_zone "Pacific Time (US & Canada)" do
       record   = @target.new
@@ -685,7 +685,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'YAML dumping a record with time zone-aware attribute' do
+  test "YAML dumping a record with time zone-aware attribute" do
     in_time_zone "Pacific Time (US & Canada)" do
       record = Topic.new(id: 1)
       record.written_on = "Jan 01 00:00:00 2014"
@@ -693,7 +693,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'setting a time zone-aware time in the current time zone' do
+  test "setting a time zone-aware time in the current time zone" do
     in_time_zone "Pacific Time (US & Canada)" do
       record = @target.new
       time_string = "10:00:00"
@@ -703,12 +703,12 @@ class AttributeMethodsTest < ActiveRecord::TestCase
       assert_equal expected_time, record.bonus_time
       assert_equal ActiveSupport::TimeZone["Pacific Time (US & Canada)"], record.bonus_time.time_zone
 
-      record.bonus_time = ''
+      record.bonus_time = ""
       assert_nil record.bonus_time
     end
   end
 
-  test 'setting a time zone-aware time with DST' do
+  test "setting a time zone-aware time with DST" do
     in_time_zone "Pacific Time (US & Canada)" do
       current_time = Time.zone.local(2014, 06, 15, 10)
       record = @target.new(bonus_time: current_time)
@@ -722,7 +722,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'removing time zone-aware types' do
+  test "removing time zone-aware types" do
     with_time_zone_aware_types(:datetime) do
       in_time_zone "Pacific Time (US & Canada)" do
         record = @target.new(bonus_time: "10:00:00")
@@ -734,14 +734,14 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'time zone-aware attributes do not recurse infinitely on invalid values' do
+  test "time zone-aware attributes do not recurse infinitely on invalid values" do
     in_time_zone "Pacific Time (US & Canada)" do
       record = @target.new(bonus_time: [])
       assert_equal nil, record.bonus_time
     end
   end
 
-  test 'setting a time_zone_conversion_for_attributes should write the value on a class variable' do
+  test "setting a time_zone_conversion_for_attributes should write the value on a class variable" do
     Topic.skip_time_zone_conversion_for_attributes = [:field_a]
     Minimalistic.skip_time_zone_conversion_for_attributes = [:field_b]
 
@@ -749,44 +749,44 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal [:field_b], Minimalistic.skip_time_zone_conversion_for_attributes
   end
 
-  test 'attribute readers respect access control' do
-    privatize('title')
+  test "attribute readers respect access control" do
+    privatize("title")
 
-    topic = @target.new(title: 'The pros and cons of programming naked.')
+    topic = @target.new(title: "The pros and cons of programming naked.")
     assert !topic.respond_to?(:title)
     exception = assert_raise(NoMethodError) { topic.title }
-    assert exception.message.include?('private method')
+    assert exception.message.include?("private method")
     assert_equal "I'm private", topic.send(:title)
   end
 
-  test 'attribute writers respect access control' do
-    privatize('title=(value)')
+  test "attribute writers respect access control" do
+    privatize("title=(value)")
 
     topic = @target.new
     assert !topic.respond_to?(:title=)
-    exception = assert_raise(NoMethodError) { topic.title = 'Pants' }
-    assert exception.message.include?('private method')
-    topic.send(:title=, 'Very large pants')
+    exception = assert_raise(NoMethodError) { topic.title = "Pants" }
+    assert exception.message.include?("private method")
+    topic.send(:title=, "Very large pants")
   end
 
-  test 'attribute predicates respect access control' do
-    privatize('title?')
+  test "attribute predicates respect access control" do
+    privatize("title?")
 
     topic = @target.new(title: "Isaac Newton's pants")
     assert !topic.respond_to?(:title?)
     exception = assert_raise(NoMethodError) { topic.title? }
-    assert exception.message.include?('private method')
+    assert exception.message.include?("private method")
     assert topic.send(:title?)
   end
 
-  test 'bulk updates respect access control' do
-    privatize('title=(value)')
+  test "bulk updates respect access control" do
+    privatize("title=(value)")
 
-    assert_raise(ActiveRecord::UnknownAttributeError) { @target.new(title: 'Rants about pants') }
-    assert_raise(ActiveRecord::UnknownAttributeError) { @target.new.attributes = { title: 'Ants in pants' } }
+    assert_raise(ActiveRecord::UnknownAttributeError) { @target.new(title: "Rants about pants") }
+    assert_raise(ActiveRecord::UnknownAttributeError) { @target.new.attributes = { title: "Ants in pants" } }
   end
 
-  test 'bulk update raises ActiveRecord::UnknownAttributeError' do
+  test "bulk update raises ActiveRecord::UnknownAttributeError" do
     error = assert_raises(ActiveRecord::UnknownAttributeError) {
       Topic.new(hello: "world")
     }
@@ -795,7 +795,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal "unknown attribute 'hello' for Topic.", error.message
   end
 
-  test 'method overrides in multi-level subclasses' do
+  test "method overrides in multi-level subclasses" do
     klass = Class.new(Developer) do
       def name
         "dev:#{read_attribute(:name)}"
@@ -803,14 +803,14 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
 
     2.times { klass = Class.new(klass) }
-    dev = klass.new(name: 'arthurnn')
+    dev = klass.new(name: "arthurnn")
     dev.save!
-    assert_equal 'dev:arthurnn', dev.reload.name
+    assert_equal "dev:arthurnn", dev.reload.name
   end
 
-  test 'global methods are overwritten' do
+  test "global methods are overwritten" do
     klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'computers'
+      self.table_name = "computers"
     end
 
     assert !klass.instance_method_already_implemented?(:system)
@@ -818,13 +818,13 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_nil computer.system
   end
 
-  test 'global methods are overwritten when subclassing' do
+  test "global methods are overwritten when subclassing" do
     klass = Class.new(ActiveRecord::Base) do
       self.abstract_class = true
     end
 
     subklass = Class.new(klass) do
-      self.table_name = 'computers'
+      self.table_name = "computers"
     end
 
     assert !klass.instance_method_already_implemented?(:system)
@@ -833,7 +833,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_nil computer.system
   end
 
-  test 'instance methods should be defined on the base class' do
+  test "instance methods should be defined on the base class" do
     subklass = Class.new(Topic)
 
     Topic.define_attribute_methods
@@ -849,14 +849,14 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert subklass.method_defined?(:id), "subklass is missing id method"
   end
 
-  test 'read_attribute with nil should not asplode' do
+  test "read_attribute with nil should not asplode" do
     assert_nil Topic.new.read_attribute(nil)
   end
 
   # If B < A, and A defines an accessor for 'foo', we don't want to override
   # that by defining a 'foo' method in the generated methods module for B.
   # (That module will be inserted between the two, e.g. [B, <GeneratedAttributes>, A].)
-  test 'inherited custom accessors' do
+  test "inherited custom accessors" do
     klass = new_topic_like_ar_class do
       self.abstract_class = true
       def title; "omg"; end
@@ -872,9 +872,9 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal "lol", topic.author_name
   end
 
-  test 'inherited custom accessors with reserved names' do
+  test "inherited custom accessors with reserved names" do
     klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'computers'
+      self.table_name = "computers"
       self.abstract_class = true
       def system; "omg"; end
       def system=(val); self.developer = val; end
@@ -890,18 +890,18 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal 99, computer.developer
   end
 
-  test 'on_the_fly_super_invokable_generated_attribute_methods_via_method_missing' do
+  test "on_the_fly_super_invokable_generated_attribute_methods_via_method_missing" do
     klass = new_topic_like_ar_class do
       def title
-        super + '!'
+        super + "!"
       end
     end
 
     real_topic = topics(:first)
-    assert_equal real_topic.title + '!', klass.find(real_topic.id).title
+    assert_equal real_topic.title + "!", klass.find(real_topic.id).title
   end
 
-  test 'on-the-fly super-invokable generated attribute predicates via method_missing' do
+  test "on-the-fly super-invokable generated attribute predicates via method_missing" do
     klass = new_topic_like_ar_class do
       def title?
         !super
@@ -912,7 +912,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal !real_topic.title?, klass.find(real_topic.id).title?
   end
 
-  test 'calling super when the parent does not define method raises NoMethodError' do
+  test "calling super when the parent does not define method raises NoMethodError" do
     klass = new_topic_like_ar_class do
       def some_method_that_is_not_on_super
         super
@@ -924,38 +924,38 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'attribute_method?' do
+  test "attribute_method?" do
     assert @target.attribute_method?(:title)
     assert @target.attribute_method?(:title=)
     assert_not @target.attribute_method?(:wibble)
   end
 
-  test 'attribute_method? returns false if the table does not exist' do
-    @target.table_name = 'wibble'
+  test "attribute_method? returns false if the table does not exist" do
+    @target.table_name = "wibble"
     assert_not @target.attribute_method?(:title)
   end
 
-  test 'attribute_names on a new record' do
+  test "attribute_names on a new record" do
     model = @target.new
 
     assert_equal @target.column_names, model.attribute_names
   end
 
-  test 'attribute_names on a queried record' do
+  test "attribute_names on a queried record" do
     model = @target.last!
 
     assert_equal @target.column_names, model.attribute_names
   end
 
-  test 'attribute_names with a custom select' do
-    model = @target.select('id').last!
+  test "attribute_names with a custom select" do
+    model = @target.select("id").last!
 
-    assert_equal ['id'], model.attribute_names
+    assert_equal ["id"], model.attribute_names
     # Sanity check, make sure other columns exist.
-    assert_not_equal ['id'], @target.column_names
+    assert_not_equal ["id"], @target.column_names
   end
 
-  test 'came_from_user?' do
+  test "came_from_user?" do
     model = @target.first
 
     assert_not model.id_came_from_user?
@@ -963,7 +963,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert model.id_came_from_user?
   end
 
-  test 'accessed_fields' do
+  test "accessed_fields" do
     model = @target.first
 
     assert_equal [], model.accessed_fields
@@ -977,7 +977,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
 
   def new_topic_like_ar_class(&block)
     klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'topics'
+      self.table_name = "topics"
       class_eval(&block)
     end
 
diff --git a/activerecord/test/cases/attribute_set_test.rb b/activerecord/test/cases/attribute_set_test.rb
index 7a24b85a36..4dfe40bea6 100644
--- a/activerecord/test/cases/attribute_set_test.rb
+++ b/activerecord/test/cases/attribute_set_test.rb
@@ -1,10 +1,10 @@
-require 'cases/helper'
+require "cases/helper"
 
 module ActiveRecord
   class AttributeSetTest < ActiveRecord::TestCase
     test "building a new set from raw attributes" do
       builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      attributes = builder.build_from_database(foo: '1.1', bar: '2.2')
+      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
 
       assert_equal 1, attributes[:foo].value
       assert_equal 2.2, attributes[:bar].value
@@ -14,7 +14,7 @@ module ActiveRecord
 
     test "building with custom types" do
       builder = AttributeSet::Builder.new(foo: Type::Float.new)
-      attributes = builder.build_from_database({ foo: '3.3', bar: '4.4' }, { bar: Type::Integer.new })
+      attributes = builder.build_from_database({ foo: "3.3", bar: "4.4" }, { bar: Type::Integer.new })
 
       assert_equal 3.3, attributes[:foo].value
       assert_equal 4, attributes[:bar].value
@@ -22,16 +22,16 @@ module ActiveRecord
 
     test "[] returns a null object" do
       builder = AttributeSet::Builder.new(foo: Type::Float.new)
-      attributes = builder.build_from_database(foo: '3.3')
+      attributes = builder.build_from_database(foo: "3.3")
 
-      assert_equal '3.3', attributes[:foo].value_before_type_cast
+      assert_equal "3.3", attributes[:foo].value_before_type_cast
       assert_equal nil, attributes[:bar].value_before_type_cast
       assert_equal :bar, attributes[:bar].name
     end
 
     test "duping creates a new hash, but does not dup the attributes" do
       builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::String.new)
-      attributes = builder.build_from_database(foo: 1, bar: 'foo')
+      attributes = builder.build_from_database(foo: 1, bar: "foo")
 
       # Ensure the type cast value is cached
       attributes[:foo].value
@@ -39,17 +39,17 @@ module ActiveRecord
 
       duped = attributes.dup
       duped.write_from_database(:foo, 2)
-      duped[:bar].value << 'bar'
+      duped[:bar].value << "bar"
 
       assert_equal 1, attributes[:foo].value
       assert_equal 2, duped[:foo].value
-      assert_equal 'foobar', attributes[:bar].value
-      assert_equal 'foobar', duped[:bar].value
+      assert_equal "foobar", attributes[:bar].value
+      assert_equal "foobar", duped[:bar].value
     end
 
     test "deep_duping creates a new hash and dups each attribute" do
       builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::String.new)
-      attributes = builder.build_from_database(foo: 1, bar: 'foo')
+      attributes = builder.build_from_database(foo: 1, bar: "foo")
 
       # Ensure the type cast value is cached
       attributes[:foo].value
@@ -57,12 +57,12 @@ module ActiveRecord
 
       duped = attributes.deep_dup
       duped.write_from_database(:foo, 2)
-      duped[:bar].value << 'bar'
+      duped[:bar].value << "bar"
 
       assert_equal 1, attributes[:foo].value
       assert_equal 2, duped[:foo].value
-      assert_equal 'foo', attributes[:bar].value
-      assert_equal 'foobar', duped[:bar].value
+      assert_equal "foo", attributes[:bar].value
+      assert_equal "foobar", duped[:bar].value
     end
 
     test "freezing cloned set does not freeze original" do
@@ -77,7 +77,7 @@ module ActiveRecord
 
     test "to_hash returns a hash of the type cast values" do
       builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      attributes = builder.build_from_database(foo: '1.1', bar: '2.2')
+      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
 
       assert_equal({ foo: 1, bar: 2.2 }, attributes.to_hash)
       assert_equal({ foo: 1, bar: 2.2 }, attributes.to_h)
@@ -85,7 +85,7 @@ module ActiveRecord
 
     test "to_hash maintains order" do
       builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      attributes = builder.build_from_database(foo: '2.2', bar: '3.3')
+      attributes = builder.build_from_database(foo: "2.2", bar: "3.3")
 
       attributes[:bar]
       hash = attributes.to_h
@@ -95,9 +95,9 @@ module ActiveRecord
 
     test "values_before_type_cast" do
       builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Integer.new)
-      attributes = builder.build_from_database(foo: '1.1', bar: '2.2')
+      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
 
-      assert_equal({ foo: '1.1', bar: '2.2' }, attributes.values_before_type_cast)
+      assert_equal({ foo: "1.1", bar: "2.2" }, attributes.values_before_type_cast)
     end
 
     test "known columns are built with uninitialized attributes" do
@@ -129,7 +129,7 @@ module ActiveRecord
 
     test "fetch_value returns the value for the given initialized attribute" do
       builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      attributes = builder.build_from_database(foo: '1.1', bar: '2.2')
+      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
 
       assert_equal 1, attributes.fetch_value(:foo)
       assert_equal 2.2, attributes.fetch_value(:bar)
@@ -150,8 +150,8 @@ module ActiveRecord
 
     test "fetch_value uses the given block for uninitialized attributes" do
       attributes = attributes_with_uninitialized_key
-      value = attributes.fetch_value(:bar) { |n| n.to_s + '!' }
-      assert_equal 'bar!', value
+      value = attributes.fetch_value(:bar) { |n| n.to_s + "!" }
+      assert_equal "bar!", value
     end
 
     test "fetch_value returns nil for uninitialized attributes if no block is given" do
@@ -207,7 +207,7 @@ module ActiveRecord
 
     def attributes_with_uninitialized_key
       builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      builder.build_from_database(foo: '1.1')
+      builder.build_from_database(foo: "1.1")
     end
 
     test "freezing doesn't prevent the set from materializing" do
diff --git a/activerecord/test/cases/attribute_test.rb b/activerecord/test/cases/attribute_test.rb
index b1b8639696..7cf6b498c9 100644
--- a/activerecord/test/cases/attribute_test.rb
+++ b/activerecord/test/cases/attribute_test.rb
@@ -1,4 +1,4 @@
-require 'cases/helper'
+require "cases/helper"
 
 module ActiveRecord
   class AttributeTest < ActiveRecord::TestCase
@@ -11,91 +11,91 @@ module ActiveRecord
     end
 
     test "from_database + read type casts from database" do
-      @type.expect(:deserialize, 'type cast from database', ['a value'])
-      attribute = Attribute.from_database(nil, 'a value', @type)
+      @type.expect(:deserialize, "type cast from database", ["a value"])
+      attribute = Attribute.from_database(nil, "a value", @type)
 
       type_cast_value = attribute.value
 
-      assert_equal 'type cast from database', type_cast_value
+      assert_equal "type cast from database", type_cast_value
     end
 
     test "from_user + read type casts from user" do
-      @type.expect(:cast, 'type cast from user', ['a value'])
-      attribute = Attribute.from_user(nil, 'a value', @type)
+      @type.expect(:cast, "type cast from user", ["a value"])
+      attribute = Attribute.from_user(nil, "a value", @type)
 
       type_cast_value = attribute.value
 
-      assert_equal 'type cast from user', type_cast_value
+      assert_equal "type cast from user", type_cast_value
     end
 
     test "reading memoizes the value" do
-      @type.expect(:deserialize, 'from the database', ['whatever'])
-      attribute = Attribute.from_database(nil, 'whatever', @type)
+      @type.expect(:deserialize, "from the database", ["whatever"])
+      attribute = Attribute.from_database(nil, "whatever", @type)
 
       type_cast_value = attribute.value
       second_read = attribute.value
 
-      assert_equal 'from the database', type_cast_value
+      assert_equal "from the database", type_cast_value
       assert_same type_cast_value, second_read
     end
 
     test "reading memoizes falsy values" do
-      @type.expect(:deserialize, false, ['whatever'])
-      attribute = Attribute.from_database(nil, 'whatever', @type)
+      @type.expect(:deserialize, false, ["whatever"])
+      attribute = Attribute.from_database(nil, "whatever", @type)
 
       attribute.value
       attribute.value
     end
 
     test "read_before_typecast returns the given value" do
-      attribute = Attribute.from_database(nil, 'raw value', @type)
+      attribute = Attribute.from_database(nil, "raw value", @type)
 
       raw_value = attribute.value_before_type_cast
 
-      assert_equal 'raw value', raw_value
+      assert_equal "raw value", raw_value
     end
 
     test "from_database + read_for_database type casts to and from database" do
-      @type.expect(:deserialize, 'read from database', ['whatever'])
-      @type.expect(:serialize, 'ready for database', ['read from database'])
-      attribute = Attribute.from_database(nil, 'whatever', @type)
+      @type.expect(:deserialize, "read from database", ["whatever"])
+      @type.expect(:serialize, "ready for database", ["read from database"])
+      attribute = Attribute.from_database(nil, "whatever", @type)
 
       serialize = attribute.value_for_database
 
-      assert_equal 'ready for database', serialize
+      assert_equal "ready for database", serialize
     end
 
     test "from_user + read_for_database type casts from the user to the database" do
-      @type.expect(:cast, 'read from user', ['whatever'])
-      @type.expect(:serialize, 'ready for database', ['read from user'])
-      attribute = Attribute.from_user(nil, 'whatever', @type)
+      @type.expect(:cast, "read from user", ["whatever"])
+      @type.expect(:serialize, "ready for database", ["read from user"])
+      attribute = Attribute.from_user(nil, "whatever", @type)
 
       serialize = attribute.value_for_database
 
-      assert_equal 'ready for database', serialize
+      assert_equal "ready for database", serialize
     end
 
     test "duping dups the value" do
-      @type.expect(:deserialize, 'type cast', ['a value'])
-      attribute = Attribute.from_database(nil, 'a value', @type)
+      @type.expect(:deserialize, "type cast", ["a value"])
+      attribute = Attribute.from_database(nil, "a value", @type)
 
       value_from_orig = attribute.value
       value_from_clone = attribute.dup.value
-      value_from_orig << ' foo'
+      value_from_orig << " foo"
 
-      assert_equal 'type cast foo', value_from_orig
-      assert_equal 'type cast', value_from_clone
+      assert_equal "type cast foo", value_from_orig
+      assert_equal "type cast", value_from_clone
     end
 
     test "duping does not dup the value if it is not dupable" do
-      @type.expect(:deserialize, false, ['a value'])
-      attribute = Attribute.from_database(nil, 'a value', @type)
+      @type.expect(:deserialize, false, ["a value"])
+      attribute = Attribute.from_database(nil, "a value", @type)
 
       assert_same attribute.value, attribute.dup.value
     end
 
     test "duping does not eagerly type cast if we have not yet type cast" do
-      attribute = Attribute.from_database(nil, 'a value', @type)
+      attribute = Attribute.from_database(nil, "a value", @type)
       attribute.dup
     end
 
diff --git a/activerecord/test/cases/attributes_test.rb b/activerecord/test/cases/attributes_test.rb
index 604411da97..7ec1f6f18c 100644
--- a/activerecord/test/cases/attributes_test.rb
+++ b/activerecord/test/cases/attributes_test.rb
@@ -1,10 +1,10 @@
-require 'cases/helper'
+require "cases/helper"
 
 class OverloadedType < ActiveRecord::Base
   attribute :overloaded_float, :integer
   attribute :overloaded_string_with_limit, :string, limit: 50
   attribute :non_existent_decimal, :decimal
-  attribute :string_with_default, :string, default: 'the overloaded default'
+  attribute :string_with_default, :string, default: "the overloaded default"
 end
 
 class ChildOfOverloadedType < OverloadedType
@@ -15,7 +15,7 @@ class GrandchildOfOverloadedType < ChildOfOverloadedType
 end
 
 class UnoverloadedType < ActiveRecord::Base
-  self.table_name = 'overloaded_types'
+  self.table_name = "overloaded_types"
 end
 
 module ActiveRecord
@@ -44,14 +44,14 @@ module ActiveRecord
     end
 
     test "properties assigned in constructor" do
-      data = OverloadedType.new(overloaded_float: '3.3')
+      data = OverloadedType.new(overloaded_float: "3.3")
 
       assert_equal 3, data.overloaded_float
     end
 
     test "overloaded properties with limit" do
-      assert_equal 50, OverloadedType.type_for_attribute('overloaded_string_with_limit').limit
-      assert_equal 255, UnoverloadedType.type_for_attribute('overloaded_string_with_limit').limit
+      assert_equal 50, OverloadedType.type_for_attribute("overloaded_string_with_limit").limit
+      assert_equal 255, UnoverloadedType.type_for_attribute("overloaded_string_with_limit").limit
     end
 
     test "nonexistent attribute" do
@@ -65,7 +65,7 @@ module ActiveRecord
 
     test "model with nonexistent attribute with default value can be saved" do
       klass = Class.new(OverloadedType) do
-        attribute :non_existent_string_with_default, :string, default: 'nonexistent'
+        attribute :non_existent_string_with_default, :string, default: "nonexistent"
       end
 
       model = klass.new
@@ -76,22 +76,22 @@ module ActiveRecord
       data = OverloadedType.new
       unoverloaded_data = UnoverloadedType.new
 
-      assert_equal 'the overloaded default', data.string_with_default
-      assert_equal 'the original default', unoverloaded_data.string_with_default
+      assert_equal "the overloaded default", data.string_with_default
+      assert_equal "the original default", unoverloaded_data.string_with_default
     end
 
     test "defaults are not touched on the columns" do
-      assert_equal 'the original default', OverloadedType.columns_hash['string_with_default'].default
+      assert_equal "the original default", OverloadedType.columns_hash["string_with_default"].default
     end
 
     test "children inherit custom properties" do
-      data = ChildOfOverloadedType.new(overloaded_float: '4.4')
+      data = ChildOfOverloadedType.new(overloaded_float: "4.4")
 
       assert_equal 4, data.overloaded_float
     end
 
     test "children can override parents" do
-      data = GrandchildOfOverloadedType.new(overloaded_float: '4.4')
+      data = GrandchildOfOverloadedType.new(overloaded_float: "4.4")
 
       assert_equal 4.4, data.overloaded_float
     end
@@ -106,13 +106,13 @@ module ActiveRecord
 
       assert_equal 6, klass.attribute_types.length
       assert_equal 6, klass.column_defaults.length
-      assert_not klass.attribute_types.include?('wibble')
+      assert_not klass.attribute_types.include?("wibble")
 
       klass.attribute :wibble, Type::Value.new
 
       assert_equal 7, klass.attribute_types.length
       assert_equal 7, klass.column_defaults.length
-      assert klass.attribute_types.include?('wibble')
+      assert klass.attribute_types.include?("wibble")
     end
 
     test "the given default value is cast from user" do
diff --git a/activerecord/test/cases/autosave_association_test.rb b/activerecord/test/cases/autosave_association_test.rb
index 9e3266b7d6..cb45079597 100644
--- a/activerecord/test/cases/autosave_association_test.rb
+++ b/activerecord/test/cases/autosave_association_test.rb
@@ -1,55 +1,55 @@
-require 'cases/helper'
-require 'models/bird'
-require 'models/comment'
-require 'models/company'
-require 'models/customer'
-require 'models/developer'
-require 'models/computer'
-require 'models/invoice'
-require 'models/line_item'
-require 'models/order'
-require 'models/parrot'
-require 'models/person'
-require 'models/pirate'
-require 'models/post'
-require 'models/reader'
-require 'models/ship'
-require 'models/ship_part'
-require 'models/tag'
-require 'models/tagging'
-require 'models/treasure'
-require 'models/eye'
-require 'models/electron'
-require 'models/molecule'
-require 'models/member'
-require 'models/member_detail'
-require 'models/organization'
-require 'models/guitar'
-require 'models/tuning_peg'
+require "cases/helper"
+require "models/bird"
+require "models/comment"
+require "models/company"
+require "models/customer"
+require "models/developer"
+require "models/computer"
+require "models/invoice"
+require "models/line_item"
+require "models/order"
+require "models/parrot"
+require "models/person"
+require "models/pirate"
+require "models/post"
+require "models/reader"
+require "models/ship"
+require "models/ship_part"
+require "models/tag"
+require "models/tagging"
+require "models/treasure"
+require "models/eye"
+require "models/electron"
+require "models/molecule"
+require "models/member"
+require "models/member_detail"
+require "models/organization"
+require "models/guitar"
+require "models/tuning_peg"
 
 class TestAutosaveAssociationsInGeneral < ActiveRecord::TestCase
   def test_autosave_validation
     person = Class.new(ActiveRecord::Base) {
-      self.table_name = 'people'
+      self.table_name = "people"
       validate :should_be_cool, :on => :create
-      def self.name; 'Person'; end
+      def self.name; "Person"; end
 
       private
 
       def should_be_cool
-        unless self.first_name == 'cool'
+        unless self.first_name == "cool"
           errors.add :first_name, "not cool"
         end
       end
     }
     reference = Class.new(ActiveRecord::Base) {
       self.table_name = "references"
-      def self.name; 'Reference'; end
+      def self.name; "Reference"; end
       belongs_to :person, autosave: true, anonymous_class: person
     }
 
-    u = person.create!(first_name: 'cool')
-    u.update_attributes!(first_name: 'nah') # still valid because validation only applies on 'create'
+    u = person.create!(first_name: "cool")
+    u.update_attributes!(first_name: "nah") # still valid because validation only applies on 'create'
     assert reference.create!(person: u).persisted?
   end
 
@@ -97,7 +97,7 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
   fixtures :companies, :accounts
 
   def test_should_save_parent_but_not_invalid_child
-    firm = Firm.new(:name => 'GlobalMegaCorp')
+    firm = Firm.new(:name => "GlobalMegaCorp")
     assert firm.valid?
 
     firm.build_account_using_primary_key
@@ -179,7 +179,7 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
 
   def test_not_resaved_when_unchanged
     firm = Firm.all.merge!(:includes => :account).first
-    firm.name += '-changed'
+    firm.name += "-changed"
     assert_queries(1) { firm.save! }
 
     firm = Firm.first
@@ -196,21 +196,21 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
   end
 
   def test_callbacks_firing_order_on_create
-    eye = Eye.create(:iris_attributes => {:color => 'honey'})
+    eye = Eye.create(:iris_attributes => {:color => "honey"})
     assert_equal [true, false], eye.after_create_callbacks_stack
   end
 
   def test_callbacks_firing_order_on_update
-    eye = Eye.create(iris_attributes: {color: 'honey'})
-    eye.update(iris_attributes: {color: 'green'})
+    eye = Eye.create(iris_attributes: {color: "honey"})
+    eye.update(iris_attributes: {color: "green"})
     assert_equal [true, false], eye.after_update_callbacks_stack
   end
 
   def test_callbacks_firing_order_on_save
-    eye = Eye.create(iris_attributes: {color: 'honey'})
+    eye = Eye.create(iris_attributes: {color: "honey"})
     assert_equal [false, false], eye.after_save_callbacks_stack
 
-    eye.update(iris_attributes: {color: 'blue'})
+    eye.update(iris_attributes: {color: "blue"})
     assert_equal [false, false, false, false], eye.after_save_callbacks_stack
   end
 end
@@ -219,7 +219,7 @@ class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::Test
   fixtures :companies, :posts, :tags, :taggings
 
   def test_should_save_parent_but_not_invalid_child
-    client = Client.new(:name => 'Joe (the Plumber)')
+    client = Client.new(:name => "Joe (the Plumber)")
     assert client.valid?
 
     client.build_firm
@@ -388,7 +388,7 @@ end
 class TestDefaultAutosaveAssociationOnAHasManyAssociationWithAcceptsNestedAttributes < ActiveRecord::TestCase
   def test_invalid_adding_with_nested_attributes
     molecule = Molecule.new
-    valid_electron = Electron.new(name: 'electron')
+    valid_electron = Electron.new(name: "electron")
     invalid_electron = Electron.new
 
     molecule.electrons = [valid_electron, invalid_electron]
@@ -396,7 +396,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociationWithAcceptsNestedAttrib
 
     assert_not invalid_electron.valid?
     assert valid_electron.valid?
-    assert_not molecule.persisted?, 'Molecule should not be persisted when its electrons are invalid'
+    assert_not molecule.persisted?, "Molecule should not be persisted when its electrons are invalid"
   end
 
   def test_errors_should_be_indexed_when_passed_as_array
@@ -419,7 +419,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociationWithAcceptsNestedAttrib
     ActiveRecord::Base.index_nested_attribute_errors = true
 
     molecule = Molecule.new
-    valid_electron = Electron.new(name: 'electron')
+    valid_electron = Electron.new(name: "electron")
     invalid_electron = Electron.new
 
     molecule.electrons = [valid_electron, invalid_electron]
@@ -435,7 +435,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociationWithAcceptsNestedAttrib
 
   def test_errors_details_should_be_set
     molecule = Molecule.new
-    valid_electron = Electron.new(name: 'electron')
+    valid_electron = Electron.new(name: "electron")
     invalid_electron = Electron.new
 
     molecule.electrons = [valid_electron, invalid_electron]
@@ -466,7 +466,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociationWithAcceptsNestedAttrib
     ActiveRecord::Base.index_nested_attribute_errors = true
 
     molecule = Molecule.new
-    valid_electron = Electron.new(name: 'electron')
+    valid_electron = Electron.new(name: "electron")
     invalid_electron = Electron.new
 
     molecule.electrons = [valid_electron, invalid_electron]
@@ -482,7 +482,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociationWithAcceptsNestedAttrib
 
   def test_valid_adding_with_nested_attributes
     molecule = Molecule.new
-    valid_electron = Electron.new(name: 'electron')
+    valid_electron = Electron.new(name: "electron")
 
     molecule.electrons = [valid_electron]
     molecule.save
@@ -602,7 +602,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
     new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.build("name" => "Another Client") }
     assert !company.clients_of_firm.loaded?
 
-    company.name += '-changed'
+    company.name += "-changed"
     assert_queries(2) { assert company.save }
     assert new_client.persisted?
     assert_equal 3, company.clients_of_firm.reload.size
@@ -612,7 +612,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
     company = companies(:first_firm)
     assert_no_queries(ignore_none: false) { company.clients_of_firm.build([{"name" => "Another Client"}, {"name" => "Another Client II"}]) }
 
-    company.name += '-changed'
+    company.name += "-changed"
     assert_queries(3) { assert company.save }
     assert_equal 4, company.clients_of_firm.reload.size
   end
@@ -622,7 +622,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
     new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.build {|client| client.name = "Another Client" } }
     assert !company.clients_of_firm.loaded?
 
-    company.name += '-changed'
+    company.name += "-changed"
     assert_queries(2) { assert company.save }
     assert new_client.persisted?
     assert_equal 3, company.clients_of_firm.reload.size
@@ -636,7 +636,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
       end
     end
 
-    company.name += '-changed'
+    company.name += "-changed"
     assert_queries(3) { assert company.save }
     assert_equal 4, company.clients_of_firm.reload.size
   end
@@ -715,8 +715,8 @@ class TestDefaultAutosaveAssociationOnNewRecord < ActiveRecord::TestCase
   end
 
   def test_autosave_new_record_with_after_create_callback
-    post = PostWithAfterCreateCallback.new(title: 'Captain Murphy', body: 'is back')
-    post.comments.build(body: 'foo')
+    post = PostWithAfterCreateCallback.new(title: "Captain Murphy", body: "is back")
+    post.comments.build(body: "foo")
     post.save!
 
     assert_not_nil post.author_id
@@ -728,7 +728,7 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
 
   setup do
     @pirate = Pirate.create(:catchphrase => "Don' botharrr talkin' like one, savvy?")
-    @ship = @pirate.create_ship(:name => 'Nights Dirty Lightning')
+    @ship = @pirate.create_ship(:name => "Nights Dirty Lightning")
   end
 
   teardown do
@@ -764,12 +764,12 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
   end
 
   def test_should_skip_validation_on_a_child_association_if_marked_for_destruction
-    @pirate.ship.name = ''
+    @pirate.ship.name = ""
     assert !@pirate.valid?
 
     @pirate.ship.mark_for_destruction
     @pirate.ship.expects(:valid?).never
-    assert_difference('Ship.count', -1) { @pirate.save! }
+    assert_difference("Ship.count", -1) { @pirate.save! }
   end
 
   def test_a_child_marked_for_destruction_should_not_be_destroyed_twice
@@ -787,7 +787,7 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
       def save(*args)
         super
         destroy
-        raise 'Oh noes!'
+        raise "Oh noes!"
       end
     end
 
@@ -824,12 +824,12 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
   end
 
   def test_should_skip_validation_on_a_parent_association_if_marked_for_destruction
-    @ship.pirate.catchphrase = ''
+    @ship.pirate.catchphrase = ""
     assert !@ship.valid?
 
     @ship.pirate.mark_for_destruction
     @ship.pirate.expects(:valid?).never
-    assert_difference('Pirate.count', -1) { @ship.save! }
+    assert_difference("Pirate.count", -1) { @ship.save! }
   end
 
   def test_a_parent_marked_for_destruction_should_not_be_destroyed_twice
@@ -847,7 +847,7 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
       def save(*args)
         super
         destroy
-        raise 'Oh noes!'
+        raise "Oh noes!"
       end
     end
 
@@ -859,11 +859,11 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
 
   def test_should_save_changed_child_objects_if_parent_is_saved
     @pirate = @ship.create_pirate(:catchphrase => "Don' botharrr talkin' like one, savvy?")
-    @parrot = @pirate.parrots.create!(:name => 'Posideons Killer')
+    @parrot = @pirate.parrots.create!(:name => "Posideons Killer")
     @parrot.name = "NewName"
     @ship.save
 
-    assert_equal 'NewName', @parrot.reload.name
+    assert_equal "NewName", @parrot.reload.name
   end
 
   def test_should_destroy_has_many_as_part_of_the_save_transaction_if_they_were_marked_for_destruction
@@ -893,7 +893,7 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
   def test_should_skip_validation_on_has_many_if_marked_for_destruction
     2.times { |i| @pirate.birds.create!(:name => "birds_#{i}") }
 
-    @pirate.birds.each { |bird| bird.name = '' }
+    @pirate.birds.each { |bird| bird.name = "" }
     assert !@pirate.valid?
 
     @pirate.birds.each do |bird|
@@ -906,7 +906,7 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
   def test_should_skip_validation_on_has_many_if_destroyed
     @pirate.birds.create!(:name => "birds_1")
 
-    @pirate.birds.each { |bird| bird.name = '' }
+    @pirate.birds.each { |bird| bird.name = "" }
     assert !@pirate.valid?
 
     @pirate.birds.each(&:destroy)
@@ -931,7 +931,7 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
     class << before.last
       def destroy(*args)
         super
-        raise 'Oh noes!'
+        raise "Oh noes!"
       end
     end
 
@@ -1017,7 +1017,7 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
   def test_should_skip_validation_on_habtm_if_marked_for_destruction
     2.times { |i| @pirate.parrots.create!(:name => "parrots_#{i}") }
 
-    @pirate.parrots.each { |parrot| parrot.name = '' }
+    @pirate.parrots.each { |parrot| parrot.name = "" }
     assert !@pirate.valid?
 
     @pirate.parrots.each do |parrot|
@@ -1032,7 +1032,7 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
   def test_should_skip_validation_on_habtm_if_destroyed
     @pirate.parrots.create!(:name => "parrots_1")
 
-    @pirate.parrots.each { |parrot| parrot.name = '' }
+    @pirate.parrots.each { |parrot| parrot.name = "" }
     assert !@pirate.valid?
 
     @pirate.parrots.each(&:destroy)
@@ -1059,7 +1059,7 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
     class << @pirate.association(:parrots)
       def destroy(*args)
         super
-        raise 'Oh noes!'
+        raise "Oh noes!"
       end
     end
 
@@ -1109,20 +1109,20 @@ class TestAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
   def setup
     super
     @pirate = Pirate.create(:catchphrase => "Don' botharrr talkin' like one, savvy?")
-    @ship = @pirate.create_ship(:name => 'Nights Dirty Lightning')
+    @ship = @pirate.create_ship(:name => "Nights Dirty Lightning")
   end
 
   def test_should_still_work_without_an_associated_model
     @ship.destroy
     @pirate.reload.catchphrase = "Arr"
     @pirate.save
-    assert_equal 'Arr', @pirate.reload.catchphrase
+    assert_equal "Arr", @pirate.reload.catchphrase
   end
 
   def test_should_automatically_save_the_associated_model
-    @pirate.ship.name = 'The Vile Insanity'
+    @pirate.ship.name = "The Vile Insanity"
     @pirate.save
-    assert_equal 'The Vile Insanity', @pirate.reload.ship.name
+    assert_equal "The Vile Insanity", @pirate.reload.ship.name
   end
 
   def test_changed_for_autosave_should_handle_cycles
@@ -1136,13 +1136,13 @@ class TestAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
   end
 
   def test_should_automatically_save_bang_the_associated_model
-    @pirate.ship.name = 'The Vile Insanity'
+    @pirate.ship.name = "The Vile Insanity"
     @pirate.save!
-    assert_equal 'The Vile Insanity', @pirate.reload.ship.name
+    assert_equal "The Vile Insanity", @pirate.reload.ship.name
   end
 
   def test_should_automatically_validate_the_associated_model
-    @pirate.ship.name = ''
+    @pirate.ship.name = ""
     assert @pirate.invalid?
     assert @pirate.errors[:"ship.name"].any?
   end
@@ -1169,23 +1169,23 @@ class TestAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
   end
 
   def test_should_still_allow_to_bypass_validations_on_the_associated_model
-    @pirate.catchphrase = ''
-    @pirate.ship.name = ''
+    @pirate.catchphrase = ""
+    @pirate.ship.name = ""
     @pirate.save(:validate => false)
     # Oracle saves empty string as NULL
     if current_adapter?(:OracleAdapter)
       assert_equal [nil, nil], [@pirate.reload.catchphrase, @pirate.ship.name]
     else
-      assert_equal ['', ''], [@pirate.reload.catchphrase, @pirate.ship.name]
+      assert_equal ["", ""], [@pirate.reload.catchphrase, @pirate.ship.name]
     end
   end
 
   def test_should_allow_to_bypass_validations_on_associated_models_at_any_depth
     2.times { |i| @pirate.ship.parts.create!(:name => "part #{i}") }
 
-    @pirate.catchphrase = ''
-    @pirate.ship.name = ''
-    @pirate.ship.parts.each { |part| part.name = '' }
+    @pirate.catchphrase = ""
+    @pirate.ship.name = ""
+    @pirate.ship.parts.each { |part| part.name = "" }
     @pirate.save(:validate => false)
 
     values = [@pirate.reload.catchphrase, @pirate.ship.name, *@pirate.ship.parts.map(&:name)]
@@ -1193,24 +1193,24 @@ class TestAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
     if current_adapter?(:OracleAdapter)
       assert_equal [nil, nil, nil, nil], values
     else
-      assert_equal ['', '', '', ''], values
+      assert_equal ["", "", "", ""], values
     end
   end
 
   def test_should_still_raise_an_ActiveRecordRecord_Invalid_exception_if_we_want_that
-    @pirate.ship.name = ''
+    @pirate.ship.name = ""
     assert_raise(ActiveRecord::RecordInvalid) do
       @pirate.save!
     end
   end
 
   def test_should_not_save_and_return_false_if_a_callback_cancelled_saving
-    pirate = Pirate.new(:catchphrase => 'Arr')
-    ship = pirate.build_ship(:name => 'The Vile Insanity')
+    pirate = Pirate.new(:catchphrase => "Arr")
+    ship = pirate.build_ship(:name => "The Vile Insanity")
     ship.cancel_save_from_callback = true
 
-    assert_no_difference 'Pirate.count' do
-      assert_no_difference 'Ship.count' do
+    assert_no_difference "Pirate.count" do
+      assert_no_difference "Ship.count" do
         assert !pirate.save
       end
     end
@@ -1219,14 +1219,14 @@ class TestAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
   def test_should_rollback_any_changes_if_an_exception_occurred_while_saving
     before = [@pirate.catchphrase, @pirate.ship.name]
 
-    @pirate.catchphrase = 'Arr'
-    @pirate.ship.name = 'The Vile Insanity'
+    @pirate.catchphrase = "Arr"
+    @pirate.ship.name = "The Vile Insanity"
 
     # Stub the save method of the @pirate.ship instance to raise an exception
     class << @pirate.ship
       def save(*args)
         super
-        raise 'Oh noes!'
+        raise "Oh noes!"
       end
     end
 
@@ -1235,7 +1235,7 @@ class TestAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
   end
 
   def test_should_not_load_the_associated_model
-    assert_queries(1) { @pirate.catchphrase = 'Arr'; @pirate.save! }
+    assert_queries(1) { @pirate.catchphrase = "Arr"; @pirate.save! }
   end
 
   def test_mark_for_destruction_is_ignored_without_autosave_true
@@ -1260,7 +1260,7 @@ class TestAutosaveAssociationOnAHasOneThroughAssociation < ActiveRecord::TestCas
     class << @member.organization
       def save(*args)
         super
-        raise 'Oh noes!'
+        raise "Oh noes!"
       end
     end
     assert_nothing_raised { @member.save }
@@ -1272,7 +1272,7 @@ class TestAutosaveAssociationOnABelongsToAssociation < ActiveRecord::TestCase
 
   def setup
     super
-    @ship = Ship.create(:name => 'Nights Dirty Lightning')
+    @ship = Ship.create(:name => "Nights Dirty Lightning")
     @pirate = @ship.create_pirate(:catchphrase => "Don' botharrr talkin' like one, savvy?")
   end
 
@@ -1280,23 +1280,23 @@ class TestAutosaveAssociationOnABelongsToAssociation < ActiveRecord::TestCase
     @pirate.destroy
     @ship.reload.name = "The Vile Insanity"
     @ship.save
-    assert_equal 'The Vile Insanity', @ship.reload.name
+    assert_equal "The Vile Insanity", @ship.reload.name
   end
 
   def test_should_automatically_save_the_associated_model
-    @ship.pirate.catchphrase = 'Arr'
+    @ship.pirate.catchphrase = "Arr"
     @ship.save
-    assert_equal 'Arr', @ship.reload.pirate.catchphrase
+    assert_equal "Arr", @ship.reload.pirate.catchphrase
   end
 
   def test_should_automatically_save_bang_the_associated_model
-    @ship.pirate.catchphrase = 'Arr'
+    @ship.pirate.catchphrase = "Arr"
     @ship.save!
-    assert_equal 'Arr', @ship.reload.pirate.catchphrase
+    assert_equal "Arr", @ship.reload.pirate.catchphrase
   end
 
   def test_should_automatically_validate_the_associated_model
-    @ship.pirate.catchphrase = ''
+    @ship.pirate.catchphrase = ""
     assert @ship.invalid?
     assert @ship.errors[:"pirate.catchphrase"].any?
   end
@@ -1310,31 +1310,31 @@ class TestAutosaveAssociationOnABelongsToAssociation < ActiveRecord::TestCase
   end
 
   def test_should_still_allow_to_bypass_validations_on_the_associated_model
-    @ship.pirate.catchphrase = ''
-    @ship.name = ''
+    @ship.pirate.catchphrase = ""
+    @ship.name = ""
     @ship.save(:validate => false)
     # Oracle saves empty string as NULL
     if current_adapter?(:OracleAdapter)
       assert_equal [nil, nil], [@ship.reload.name, @ship.pirate.catchphrase]
     else
-      assert_equal ['', ''], [@ship.reload.name, @ship.pirate.catchphrase]
+      assert_equal ["", ""], [@ship.reload.name, @ship.pirate.catchphrase]
     end
   end
 
   def test_should_still_raise_an_ActiveRecordRecord_Invalid_exception_if_we_want_that
-    @ship.pirate.catchphrase = ''
+    @ship.pirate.catchphrase = ""
     assert_raise(ActiveRecord::RecordInvalid) do
       @ship.save!
     end
   end
 
   def test_should_not_save_and_return_false_if_a_callback_cancelled_saving
-    ship = Ship.new(:name => 'The Vile Insanity')
-    pirate = ship.build_pirate(:catchphrase => 'Arr')
+    ship = Ship.new(:name => "The Vile Insanity")
+    pirate = ship.build_pirate(:catchphrase => "Arr")
     pirate.cancel_save_from_callback = true
 
-    assert_no_difference 'Ship.count' do
-      assert_no_difference 'Pirate.count' do
+    assert_no_difference "Ship.count" do
+      assert_no_difference "Pirate.count" do
         assert !ship.save
       end
     end
@@ -1343,14 +1343,14 @@ class TestAutosaveAssociationOnABelongsToAssociation < ActiveRecord::TestCase
   def test_should_rollback_any_changes_if_an_exception_occurred_while_saving
     before = [@ship.pirate.catchphrase, @ship.name]
 
-    @ship.pirate.catchphrase = 'Arr'
-    @ship.name = 'The Vile Insanity'
+    @ship.pirate.catchphrase = "Arr"
+    @ship.name = "The Vile Insanity"
 
     # Stub the save method of the @ship.pirate instance to raise an exception
     class << @ship.pirate
       def save(*args)
         super
-        raise 'Oh noes!'
+        raise "Oh noes!"
       end
     end
 
@@ -1359,13 +1359,13 @@ class TestAutosaveAssociationOnABelongsToAssociation < ActiveRecord::TestCase
   end
 
   def test_should_not_load_the_associated_model
-    assert_queries(1) { @ship.name = 'The Vile Insanity'; @ship.save! }
+    assert_queries(1) { @ship.name = "The Vile Insanity"; @ship.save! }
   end
 end
 
 module AutosaveAssociationOnACollectionAssociationTests
   def test_should_automatically_save_the_associated_models
-    new_names = ['Grace OMalley', 'Privateers Greed']
+    new_names = ["Grace OMalley", "Privateers Greed"]
     @pirate.send(@association_name).each_with_index { |child, i| child.name = new_names[i] }
 
     @pirate.save
@@ -1373,7 +1373,7 @@ module AutosaveAssociationOnACollectionAssociationTests
   end
 
   def test_should_automatically_save_bang_the_associated_models
-    new_names = ['Grace OMalley', 'Privateers Greed']
+    new_names = ["Grace OMalley", "Privateers Greed"]
     @pirate.send(@association_name).each_with_index { |child, i| child.name = new_names[i] }
 
     @pirate.save!
@@ -1391,7 +1391,7 @@ module AutosaveAssociationOnACollectionAssociationTests
   end
 
   def test_should_automatically_validate_the_associated_models
-    @pirate.send(@association_name).each { |child| child.name = '' }
+    @pirate.send(@association_name).each { |child| child.name = "" }
 
     assert !@pirate.valid?
     assert_equal ["can't be blank"], @pirate.errors["#{@association_name}.name"]
@@ -1399,7 +1399,7 @@ module AutosaveAssociationOnACollectionAssociationTests
   end
 
   def test_should_not_use_default_invalid_error_on_associated_models
-    @pirate.send(@association_name).build(:name => '')
+    @pirate.send(@association_name).build(:name => "")
 
     assert !@pirate.valid?
     assert_equal ["can't be blank"], @pirate.errors["#{@association_name}.name"]
@@ -1411,7 +1411,7 @@ module AutosaveAssociationOnACollectionAssociationTests
       { @associated_model_name.to_s.to_sym => { blank: "cannot be blank" } }
     }})
 
-    @pirate.send(@association_name).build(name: '')
+    @pirate.send(@association_name).build(name: "")
 
     assert !@pirate.valid?
     assert_equal ["cannot be blank"], @pirate.errors["#{@association_name}.name"]
@@ -1422,7 +1422,7 @@ module AutosaveAssociationOnACollectionAssociationTests
   end
 
   def test_should_merge_errors_on_the_associated_models_onto_the_parent_even_if_it_is_not_valid
-    @pirate.send(@association_name).each { |child| child.name = '' }
+    @pirate.send(@association_name).each { |child| child.name = "" }
     @pirate.catchphrase = nil
 
     assert !@pirate.valid?
@@ -1431,8 +1431,8 @@ module AutosaveAssociationOnACollectionAssociationTests
   end
 
   def test_should_allow_to_bypass_validations_on_the_associated_models_on_update
-    @pirate.catchphrase = ''
-    @pirate.send(@association_name).each { |child| child.name = '' }
+    @pirate.catchphrase = ""
+    @pirate.send(@association_name).each { |child| child.name = "" }
 
     assert @pirate.save(:validate => false)
     # Oracle saves empty string as NULL
@@ -1443,7 +1443,7 @@ module AutosaveAssociationOnACollectionAssociationTests
         @pirate.send(@association_name).last.name
       ]
     else
-      assert_equal ['', '', ''], [
+      assert_equal ["", "", ""], [
         @pirate.reload.catchphrase,
         @pirate.send(@association_name).first.name,
         @pirate.send(@association_name).last.name
@@ -1466,19 +1466,19 @@ module AutosaveAssociationOnACollectionAssociationTests
   end
 
   def test_should_not_save_and_return_false_if_a_callback_cancelled_saving_in_either_create_or_update
-    @pirate.catchphrase = 'Changed'
-    @child_1.name = 'Changed'
+    @pirate.catchphrase = "Changed"
+    @child_1.name = "Changed"
     @child_1.cancel_save_from_callback = true
 
     assert !@pirate.save
     assert_equal "Don' botharrr talkin' like one, savvy?", @pirate.reload.catchphrase
     assert_equal "Posideons Killer", @child_1.reload.name
 
-    new_pirate = Pirate.new(:catchphrase => 'Arr')
-    new_child = new_pirate.send(@association_name).build(:name => 'Grace OMalley')
+    new_pirate = Pirate.new(:catchphrase => "Arr")
+    new_child = new_pirate.send(@association_name).build(:name => "Grace OMalley")
     new_child.cancel_save_from_callback = true
 
-    assert_no_difference 'Pirate.count' do
+    assert_no_difference "Pirate.count" do
       assert_no_difference "#{new_child.class.name}.count" do
         assert !new_pirate.save
       end
@@ -1487,16 +1487,16 @@ module AutosaveAssociationOnACollectionAssociationTests
 
   def test_should_rollback_any_changes_if_an_exception_occurred_while_saving
     before = [@pirate.catchphrase, *@pirate.send(@association_name).map(&:name)]
-    new_names = ['Grace OMalley', 'Privateers Greed']
+    new_names = ["Grace OMalley", "Privateers Greed"]
 
-    @pirate.catchphrase = 'Arr'
+    @pirate.catchphrase = "Arr"
     @pirate.send(@association_name).each_with_index { |child, i| child.name = new_names[i] }
 
     # Stub the save method of the first child instance to raise an exception
     class << @pirate.send(@association_name).first
       def save(*args)
         super
-        raise 'Oh noes!'
+        raise "Oh noes!"
       end
     end
 
@@ -1505,20 +1505,20 @@ module AutosaveAssociationOnACollectionAssociationTests
   end
 
   def test_should_still_raise_an_ActiveRecordRecord_Invalid_exception_if_we_want_that
-    @pirate.send(@association_name).each { |child| child.name = '' }
+    @pirate.send(@association_name).each { |child| child.name = "" }
     assert_raise(ActiveRecord::RecordInvalid) do
       @pirate.save!
     end
   end
 
   def test_should_not_load_the_associated_models_if_they_were_not_loaded_yet
-    assert_queries(1) { @pirate.catchphrase = 'Arr'; @pirate.save! }
+    assert_queries(1) { @pirate.catchphrase = "Arr"; @pirate.save! }
 
     @pirate.send(@association_name).load_target
 
     assert_queries(3) do
-      @pirate.catchphrase = 'Yarr'
-      new_names = ['Grace OMalley', 'Privateers Greed']
+      @pirate.catchphrase = "Yarr"
+      new_names = ["Grace OMalley", "Privateers Greed"]
       @pirate.send(@association_name).each_with_index { |child, i| child.name = new_names[i] }
       @pirate.save!
     end
@@ -1534,8 +1534,8 @@ class TestAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCase
     @associated_model_name = :bird
 
     @pirate = Pirate.create(:catchphrase => "Don' botharrr talkin' like one, savvy?")
-    @child_1 = @pirate.birds.create(:name => 'Posideons Killer')
-    @child_2 = @pirate.birds.create(:name => 'Killer bandita Dionne')
+    @child_1 = @pirate.birds.create(:name => "Posideons Killer")
+    @child_2 = @pirate.birds.create(:name => "Killer bandita Dionne")
   end
 
   include AutosaveAssociationOnACollectionAssociationTests
@@ -1551,8 +1551,8 @@ class TestAutosaveAssociationOnAHasAndBelongsToManyAssociation < ActiveRecord::T
     @habtm = true
 
     @pirate = Pirate.create(catchphrase: "Don' botharrr talkin' like one, savvy?")
-    @child_1 = @pirate.parrots.create(name: 'Posideons Killer')
-    @child_2 = @pirate.parrots.create(name: 'Killer bandita Dionne')
+    @child_1 = @pirate.parrots.create(name: "Posideons Killer")
+    @child_2 = @pirate.parrots.create(name: "Killer bandita Dionne")
   end
 
   include AutosaveAssociationOnACollectionAssociationTests
@@ -1568,8 +1568,8 @@ class TestAutosaveAssociationOnAHasAndBelongsToManyAssociationWithAcceptsNestedA
     @habtm = true
 
     @pirate = Pirate.create(catchphrase: "Don' botharrr talkin' like one, savvy?")
-    @child_1 = @pirate.parrots.create(name: 'Posideons Killer')
-    @child_2 = @pirate.parrots.create(name: 'Killer bandita Dionne')
+    @child_1 = @pirate.parrots.create(name: "Posideons Killer")
+    @child_2 = @pirate.parrots.create(name: "Killer bandita Dionne")
   end
 
   include AutosaveAssociationOnACollectionAssociationTests
@@ -1581,12 +1581,12 @@ class TestAutosaveAssociationValidationsOnAHasManyAssociation < ActiveRecord::Te
   def setup
     super
     @pirate = Pirate.create(:catchphrase => "Don' botharrr talkin' like one, savvy?")
-    @pirate.birds.create(:name => 'cookoo')
+    @pirate.birds.create(:name => "cookoo")
   end
 
   test "should automatically validate associations" do
     assert @pirate.valid?
-    @pirate.birds.each { |bird| bird.name = '' }
+    @pirate.birds.each { |bird| bird.name = "" }
 
     assert !@pirate.valid?
   end
@@ -1598,19 +1598,19 @@ class TestAutosaveAssociationValidationsOnAHasOneAssociation < ActiveRecord::Tes
   def setup
     super
     @pirate = Pirate.create(:catchphrase => "Don' botharrr talkin' like one, savvy?")
-    @pirate.create_ship(:name => 'titanic')
+    @pirate.create_ship(:name => "titanic")
     super
   end
 
   test "should automatically validate associations with :validate => true" do
     assert @pirate.valid?
-    @pirate.ship.name = ''
+    @pirate.ship.name = ""
     assert !@pirate.valid?
   end
 
   test "should not automatically add validate associations without :validate => true" do
     assert @pirate.valid?
-    @pirate.non_validated_ship.name = ''
+    @pirate.non_validated_ship.name = ""
     assert @pirate.valid?
   end
 end
@@ -1625,13 +1625,13 @@ class TestAutosaveAssociationValidationsOnABelongsToAssociation < ActiveRecord::
 
   test "should automatically validate associations with :validate => true" do
     assert @pirate.valid?
-    @pirate.parrot = Parrot.new(:name => '')
+    @pirate.parrot = Parrot.new(:name => "")
     assert !@pirate.valid?
   end
 
   test "should not automatically validate associations without :validate => true" do
     assert @pirate.valid?
-    @pirate.non_validated_parrot = Parrot.new(:name => '')
+    @pirate.non_validated_parrot = Parrot.new(:name => "")
     assert @pirate.valid?
   end
 end
@@ -1646,15 +1646,15 @@ class TestAutosaveAssociationValidationsOnAHABTMAssociation < ActiveRecord::Test
 
   test "should automatically validate associations with :validate => true" do
     assert @pirate.valid?
-    @pirate.parrots = [ Parrot.new(:name => 'popuga') ]
-    @pirate.parrots.each { |parrot| parrot.name = '' }
+    @pirate.parrots = [ Parrot.new(:name => "popuga") ]
+    @pirate.parrots.each { |parrot| parrot.name = "" }
     assert !@pirate.valid?
   end
 
   test "should not automatically validate associations without :validate => true" do
     assert @pirate.valid?
-    @pirate.non_validated_parrots = [ Parrot.new(:name => 'popuga') ]
-    @pirate.non_validated_parrots.each { |parrot| parrot.name = '' }
+    @pirate.non_validated_parrots = [ Parrot.new(:name => "popuga") ]
+    @pirate.non_validated_parrots.each { |parrot| parrot.name = "" }
     assert @pirate.valid?
   end
 end
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index 7b1ce40c0d..96de9fe8d5 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -1,30 +1,30 @@
 require "cases/helper"
-require 'models/post'
-require 'models/author'
-require 'models/topic'
-require 'models/reply'
-require 'models/category'
-require 'models/company'
-require 'models/customer'
-require 'models/developer'
-require 'models/computer'
-require 'models/project'
-require 'models/default'
-require 'models/auto_id'
-require 'models/boolean'
-require 'models/column_name'
-require 'models/subscriber'
-require 'models/comment'
-require 'models/minimalistic'
-require 'models/warehouse_thing'
-require 'models/parrot'
-require 'models/person'
-require 'models/edge'
-require 'models/joke'
-require 'models/bird'
-require 'models/car'
-require 'models/bulb'
-require 'concurrent/atomic/count_down_latch'
+require "models/post"
+require "models/author"
+require "models/topic"
+require "models/reply"
+require "models/category"
+require "models/company"
+require "models/customer"
+require "models/developer"
+require "models/computer"
+require "models/project"
+require "models/default"
+require "models/auto_id"
+require "models/boolean"
+require "models/column_name"
+require "models/subscriber"
+require "models/comment"
+require "models/minimalistic"
+require "models/warehouse_thing"
+require "models/parrot"
+require "models/person"
+require "models/edge"
+require "models/joke"
+require "models/bird"
+require "models/car"
+require "models/bulb"
+require "concurrent/atomic/count_down_latch"
 
 class FirstAbstractClass < ActiveRecord::Base
   self.abstract_class = true
@@ -73,17 +73,17 @@ class LintTest < ActiveRecord::TestCase
 end
 
 class BasicsTest < ActiveRecord::TestCase
-  fixtures :topics, :companies, :developers, :projects, :computers, :accounts, :minimalistics, 'warehouse-things', :authors, :categorizations, :categories, :posts
+  fixtures :topics, :companies, :developers, :projects, :computers, :accounts, :minimalistics, "warehouse-things", :authors, :categorizations, :categories, :posts
 
   def test_column_names_are_escaped
     conn      = ActiveRecord::Base.connection
     classname = conn.class.name[/[^:]*$/]
     badchar   = {
-      'SQLite3Adapter'    => '"',
-      'Mysql2Adapter'     => '`',
-      'PostgreSQLAdapter' => '"',
-      'OracleAdapter'     => '"',
-      'FbAdapter'         => '"'
+      "SQLite3Adapter"    => '"',
+      "Mysql2Adapter"     => "`",
+      "PostgreSQLAdapter" => '"',
+      "OracleAdapter"     => '"',
+      "FbAdapter"         => '"'
     }.fetch(classname) {
       raise "need a bad char for #{classname}"
     }
@@ -100,7 +100,7 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_columns_should_obey_set_primary_key
     pk = Subscriber.columns_hash[Subscriber.primary_key]
-    assert_equal 'nick', pk.name, 'nick should be primary key'
+    assert_equal "nick", pk.name, "nick should be primary key"
   end
 
   def test_primary_key_with_no_id
@@ -164,17 +164,17 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_previously_changed
     topic = Topic.first
-    topic.title = '<3<3<3'
+    topic.title = "<3<3<3"
     assert_equal({}, topic.previous_changes)
 
     topic.save!
     expected = ["The First Topic", "<3<3<3"]
-    assert_equal(expected, topic.previous_changes['title'])
+    assert_equal(expected, topic.previous_changes["title"])
   end
 
   def test_previously_changed_dup
     topic = Topic.first
-    topic.title = '<3<3<3'
+    topic.title = "<3<3<3"
     topic.save!
 
     t2 = topic.dup
@@ -211,7 +211,7 @@ class BasicsTest < ActiveRecord::TestCase
     with_env_tz eastern_time_zone do
       with_timezone_config default: :utc do
         time = Time.local(2000)
-        topic = Topic.create('written_on' => time)
+        topic = Topic.create("written_on" => time)
         saved_time = Topic.find(topic.id).reload.written_on
         assert_equal time, saved_time
         assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "EST"], time.to_a
@@ -223,9 +223,9 @@ class BasicsTest < ActiveRecord::TestCase
   def test_preserving_time_objects_with_time_with_zone_conversion_to_default_timezone_utc
     with_env_tz eastern_time_zone do
       with_timezone_config default: :utc do
-        Time.use_zone 'Central Time (US & Canada)' do
+        Time.use_zone "Central Time (US & Canada)" do
           time = Time.zone.local(2000)
-          topic = Topic.create('written_on' => time)
+          topic = Topic.create("written_on" => time)
           saved_time = Topic.find(topic.id).reload.written_on
           assert_equal time, saved_time
           assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "CST"], time.to_a
@@ -239,7 +239,7 @@ class BasicsTest < ActiveRecord::TestCase
     with_env_tz eastern_time_zone do
       with_timezone_config default: :local do
         time = Time.utc(2000)
-        topic = Topic.create('written_on' => time)
+        topic = Topic.create("written_on" => time)
         saved_time = Topic.find(topic.id).reload.written_on
         assert_equal time, saved_time
         assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "UTC"], time.to_a
@@ -251,9 +251,9 @@ class BasicsTest < ActiveRecord::TestCase
   def test_preserving_time_objects_with_time_with_zone_conversion_to_default_timezone_local
     with_env_tz eastern_time_zone do
       with_timezone_config default: :local do
-        Time.use_zone 'Central Time (US & Canada)' do
+        Time.use_zone "Central Time (US & Canada)" do
           time = Time.zone.local(2000)
-          topic = Topic.create('written_on' => time)
+          topic = Topic.create("written_on" => time)
           saved_time = Topic.find(topic.id).reload.written_on
           assert_equal time, saved_time
           assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "CST"], time.to_a
@@ -295,27 +295,27 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_create_after_initialize_without_block
-    cb = CustomBulb.create(:name => 'Dude')
-    assert_equal('Dude', cb.name)
+    cb = CustomBulb.create(:name => "Dude")
+    assert_equal("Dude", cb.name)
     assert_equal(true, cb.frickinawesome)
   end
 
   def test_create_after_initialize_with_block
-    cb = CustomBulb.create {|c| c.name = 'Dude' }
-    assert_equal('Dude', cb.name)
+    cb = CustomBulb.create {|c| c.name = "Dude" }
+    assert_equal("Dude", cb.name)
     assert_equal(true, cb.frickinawesome)
   end
 
   def test_create_after_initialize_with_array_param
-    cbs = CustomBulb.create([{ name: 'Dude' }, { name: 'Bob' }])
-    assert_equal 'Dude', cbs[0].name
-    assert_equal 'Bob', cbs[1].name
+    cbs = CustomBulb.create([{ name: "Dude" }, { name: "Bob" }])
+    assert_equal "Dude", cbs[0].name
+    assert_equal "Bob", cbs[1].name
     assert cbs[0].frickinawesome
     assert !cbs[1].frickinawesome
   end
 
   def test_load
-    topics = Topic.all.merge!(:order => 'id').to_a
+    topics = Topic.all.merge!(:order => "id").to_a
     assert_equal(5, topics.size)
     assert_equal(topics(:first).title, topics.first.title)
   end
@@ -443,7 +443,7 @@ class BasicsTest < ActiveRecord::TestCase
 
   if current_adapter?(:Mysql2Adapter)
     def test_update_all_with_order_and_limit
-      assert_equal 1, Topic.limit(1).order('id DESC').update_all(:content => 'bulk updated!')
+      assert_equal 1, Topic.limit(1).order("id DESC").update_all(:content => "bulk updated!")
     end
   end
 
@@ -518,16 +518,16 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_find_by_slug
-    assert_equal Topic.find('1-meowmeow'), Topic.find(1)
+    assert_equal Topic.find("1-meowmeow"), Topic.find(1)
   end
 
   def test_find_by_slug_with_array
-    assert_equal Topic.find([1, 2]), Topic.find(['1-meowmeow', '2-hello'])
-    assert_equal 'The Second Topic of the day', Topic.find(['2-hello', '1-meowmeow']).first.title
+    assert_equal Topic.find([1, 2]), Topic.find(["1-meowmeow", "2-hello"])
+    assert_equal "The Second Topic of the day", Topic.find(["2-hello", "1-meowmeow"]).first.title
   end
 
   def test_find_by_slug_with_range
-    assert_equal Topic.where(id: '1-meowmeow'..'2-hello'), Topic.where(id: 1..2)
+    assert_equal Topic.where(id: "1-meowmeow".."2-hello"), Topic.where(id: 1..2)
   end
 
   def test_equality_of_new_records
@@ -536,7 +536,7 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_equality_of_destroyed_records
-    topic_1 = Topic.new(:title => 'test_1')
+    topic_1 = Topic.new(:title => "test_1")
     topic_1.save
     topic_2 = Topic.find(topic_1.id)
     topic_1.destroy
@@ -545,8 +545,8 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_equality_with_blank_ids
-    one = Subscriber.new(:id => '')
-    two = Subscriber.new(:id => '')
+    one = Subscriber.new(:id => "")
+    two = Subscriber.new(:id => "")
     assert_equal one, two
   end
 
@@ -555,8 +555,8 @@ class BasicsTest < ActiveRecord::TestCase
     car.bulbs.build
     car.save
 
-    assert car.bulbs == Bulb.where(car_id: car.id), 'CollectionProxy should be comparable with Relation'
-    assert Bulb.where(car_id: car.id) == car.bulbs, 'Relation should be comparable with CollectionProxy'
+    assert car.bulbs == Bulb.where(car_id: car.id), "CollectionProxy should be comparable with Relation"
+    assert Bulb.where(car_id: car.id) == car.bulbs, "Relation should be comparable with CollectionProxy"
   end
 
   def test_equality_of_relation_and_array
@@ -564,7 +564,7 @@ class BasicsTest < ActiveRecord::TestCase
     car.bulbs.build
     car.save
 
-    assert Bulb.where(car_id: car.id) == car.bulbs.to_a, 'Relation should be comparable with Array'
+    assert Bulb.where(car_id: car.id) == car.bulbs.to_a, "Relation should be comparable with Array"
   end
 
   def test_equality_of_relation_and_association_relation
@@ -572,8 +572,8 @@ class BasicsTest < ActiveRecord::TestCase
     car.bulbs.build
     car.save
 
-    assert_equal Bulb.where(car_id: car.id), car.bulbs.includes(:car), 'Relation should be comparable with AssociationRelation'
-    assert_equal car.bulbs.includes(:car), Bulb.where(car_id: car.id), 'AssociationRelation should be comparable with Relation'
+    assert_equal Bulb.where(car_id: car.id), car.bulbs.includes(:car), "Relation should be comparable with AssociationRelation"
+    assert_equal car.bulbs.includes(:car), Bulb.where(car_id: car.id), "AssociationRelation should be comparable with Relation"
   end
 
   def test_equality_of_collection_proxy_and_association_relation
@@ -581,8 +581,8 @@ class BasicsTest < ActiveRecord::TestCase
     car.bulbs.build
     car.save
 
-    assert_equal car.bulbs, car.bulbs.includes(:car), 'CollectionProxy should be comparable with AssociationRelation'
-    assert_equal car.bulbs.includes(:car), car.bulbs, 'AssociationRelation should be comparable with CollectionProxy'
+    assert_equal car.bulbs, car.bulbs.includes(:car), "CollectionProxy should be comparable with AssociationRelation"
+    assert_equal car.bulbs.includes(:car), car.bulbs, "AssociationRelation should be comparable with CollectionProxy"
   end
 
   def test_hashing
@@ -604,14 +604,14 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_create_without_prepared_statement
     topic = Topic.connection.unprepared_statement do
-      Topic.create(:title => 'foo')
+      Topic.create(:title => "foo")
     end
 
     assert_equal topic, Topic.find(topic.id)
   end
 
   def test_destroy_without_prepared_statement
-    topic = Topic.create(title: 'foo')
+    topic = Topic.create(title: "foo")
     Topic.connection.unprepared_statement do
       Topic.find(topic.id).destroy
     end
@@ -633,7 +633,7 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_readonly_attributes
-    assert_equal Set.new([ 'title' , 'comments_count' ]), ReadonlyTitlePost.readonly_attributes
+    assert_equal Set.new([ "title" , "comments_count" ]), ReadonlyTitlePost.readonly_attributes
 
     post = ReadonlyTitlePost.create(:title => "cannot change this", :body => "changeable")
     post.reload
@@ -647,8 +647,8 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_unicode_column_name
     Weird.reset_column_information
-    weird = Weird.create(:なまえ => 'たこ焼き仮面')
-    assert_equal 'たこ焼き仮面', weird.なまえ
+    weird = Weird.create(:なまえ => "たこ焼き仮面")
+    assert_equal "たこ焼き仮面", weird.なまえ
   end
 
   unless current_adapter?(:PostgreSQLAdapter)
@@ -666,21 +666,21 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_non_valid_identifier_column_name
-    weird = Weird.create('a$b' => 'value')
+    weird = Weird.create("a$b" => "value")
     weird.reload
-    assert_equal 'value', weird.send('a$b')
-    assert_equal 'value', weird.read_attribute('a$b')
+    assert_equal "value", weird.send("a$b")
+    assert_equal "value", weird.read_attribute("a$b")
 
-    weird.update_columns('a$b' => 'value2')
+    weird.update_columns("a$b" => "value2")
     weird.reload
-    assert_equal 'value2', weird.send('a$b')
-    assert_equal 'value2', weird.read_attribute('a$b')
+    assert_equal "value2", weird.send("a$b")
+    assert_equal "value2", weird.read_attribute("a$b")
   end
 
   def test_group_weirds_by_from
-    Weird.create('a$b' => 'value', :from => 'aaron')
+    Weird.create("a$b" => "value", :from => "aaron")
     count = Weird.group(Weird.arel_table[:from]).count
-    assert_equal 1, count['aaron']
+    assert_equal 1, count["aaron"]
   end
 
   def test_attributes_on_dummy_time
@@ -789,8 +789,8 @@ class BasicsTest < ActiveRecord::TestCase
   DeveloperSalary = Struct.new(:amount)
   def test_dup_with_aggregate_of_same_name_as_attribute
     developer_with_aggregate = Class.new(ActiveRecord::Base) do
-      self.table_name = 'developers'
-      composed_of :salary, :class_name => 'BasicsTest::DeveloperSalary', :mapping => [%w(salary amount)]
+      self.table_name = "developers"
+      composed_of :salary, :class_name => "BasicsTest::DeveloperSalary", :mapping => [%w(salary amount)]
     end
 
     dev = developer_with_aggregate.find(1)
@@ -837,7 +837,7 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_clone_of_new_object_marks_attributes_as_dirty
-    developer = Developer.new :name => 'Bjorn', :salary => 100000
+    developer = Developer.new :name => "Bjorn", :salary => 100000
     assert developer.name_changed?
     assert developer.salary_changed?
 
@@ -847,7 +847,7 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_clone_of_new_object_marks_as_dirty_only_changed_attributes
-    developer = Developer.new :name => 'Bjorn'
+    developer = Developer.new :name => "Bjorn"
     assert developer.name_changed?            # obviously
     assert !developer.salary_changed?         # attribute has non-nil default value, so treated as not changed
 
@@ -857,7 +857,7 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_dup_of_saved_object_marks_attributes_as_dirty
-    developer = Developer.create! :name => 'Bjorn', :salary => 100000
+    developer = Developer.create! :name => "Bjorn", :salary => 100000
     assert !developer.name_changed?
     assert !developer.salary_changed?
 
@@ -867,7 +867,7 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_dup_of_saved_object_marks_as_dirty_only_changed_attributes
-    developer = Developer.create! :name => 'Bjorn'
+    developer = Developer.create! :name => "Bjorn"
     assert !developer.name_changed?           # both attributes of saved object should be treated as not changed
     assert !developer.salary_changed?
 
@@ -895,15 +895,15 @@ class BasicsTest < ActiveRecord::TestCase
         assert_equal Time.local(2004, 1,1,0,0,0,0), default.fixed_time
 
         # char types
-        assert_equal 'Y', default.char1
-        assert_equal 'a varchar field', default.char2
-        assert_equal 'a text field', default.char3
+        assert_equal "Y", default.char1
+        assert_equal "a varchar field", default.char2
+        assert_equal "a text field", default.char3
       end
     end
   end
 
   class NumericData < ActiveRecord::Base
-    self.table_name = 'numeric_data'
+    self.table_name = "numeric_data"
 
     attribute :my_house_population, :integer
     attribute :atoms_in_universe, :integer
@@ -1008,7 +1008,7 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_quote
     author_name = "\\ \001 ' \n \\n \""
-    topic = Topic.create('author_name' => author_name)
+    topic = Topic.create("author_name" => author_name)
     assert_equal author_name, Topic.find(topic.id).author_name
   end
 
@@ -1087,7 +1087,7 @@ class BasicsTest < ActiveRecord::TestCase
   def test_set_table_name_symbol_converted_to_string
     k = Class.new(Joke)
     k.table_name = :cold_jokes
-    assert_equal 'cold_jokes', k.table_name
+    assert_equal "cold_jokes", k.table_name
   end
 
   def test_quoted_table_name_after_set_table_name
@@ -1155,11 +1155,11 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_find_last
     last  = Developer.last
-    assert_equal last, Developer.all.merge!(:order => 'id desc').first
+    assert_equal last, Developer.all.merge!(:order => "id desc").first
   end
 
   def test_last
-    assert_equal Developer.all.merge!(:order => 'id desc').first, Developer.last
+    assert_equal Developer.all.merge!(:order => "id desc").first, Developer.last
   end
 
   def test_all
@@ -1169,32 +1169,32 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_all_with_conditions
-    assert_equal Developer.all.merge!(:order => 'id desc').to_a, Developer.order('id desc').to_a
+    assert_equal Developer.all.merge!(:order => "id desc").to_a, Developer.order("id desc").to_a
   end
 
   def test_find_ordered_last
-    last  = Developer.all.merge!(:order => 'developers.salary ASC').last
-    assert_equal last, Developer.all.merge!(:order => 'developers.salary ASC').to_a.last
+    last  = Developer.all.merge!(:order => "developers.salary ASC").last
+    assert_equal last, Developer.all.merge!(:order => "developers.salary ASC").to_a.last
   end
 
   def test_find_reverse_ordered_last
-    last  = Developer.all.merge!(:order => 'developers.salary DESC').last
-    assert_equal last, Developer.all.merge!(:order => 'developers.salary DESC').to_a.last
+    last  = Developer.all.merge!(:order => "developers.salary DESC").last
+    assert_equal last, Developer.all.merge!(:order => "developers.salary DESC").to_a.last
   end
 
   def test_find_multiple_ordered_last
-    last  = Developer.all.merge!(:order => 'developers.name, developers.salary DESC').last
-    assert_equal last, Developer.all.merge!(:order => 'developers.name, developers.salary DESC').to_a.last
+    last  = Developer.all.merge!(:order => "developers.name, developers.salary DESC").last
+    assert_equal last, Developer.all.merge!(:order => "developers.name, developers.salary DESC").to_a.last
   end
 
   def test_find_keeps_multiple_order_values
-    combined = Developer.all.merge!(:order => 'developers.name, developers.salary').to_a
-    assert_equal combined, Developer.all.merge!(:order => ['developers.name', 'developers.salary']).to_a
+    combined = Developer.all.merge!(:order => "developers.name, developers.salary").to_a
+    assert_equal combined, Developer.all.merge!(:order => ["developers.name", "developers.salary"]).to_a
   end
 
   def test_find_keeps_multiple_group_values
-    combined = Developer.all.merge!(:group => 'developers.name, developers.salary, developers.id, developers.created_at, developers.updated_at, developers.created_on, developers.updated_on').to_a
-    assert_equal combined, Developer.all.merge!(:group => ['developers.name', 'developers.salary', 'developers.id', 'developers.created_at', 'developers.updated_at', 'developers.created_on', 'developers.updated_on']).to_a
+    combined = Developer.all.merge!(:group => "developers.name, developers.salary, developers.id, developers.created_at, developers.updated_at, developers.created_on, developers.updated_on").to_a
+    assert_equal combined, Developer.all.merge!(:group => ["developers.name", "developers.salary", "developers.id", "developers.created_at", "developers.updated_at", "developers.created_on", "developers.updated_on"]).to_a
   end
 
   def test_find_symbol_ordered_last
@@ -1210,7 +1210,7 @@ class BasicsTest < ActiveRecord::TestCase
     old_class = LooseDescendant
     Object.send :remove_const, :LooseDescendant
 
-    descendant = old_class.create! :first_name => 'bob'
+    descendant = old_class.create! :first_name => "bob"
     assert_not_nil LoosePerson.find(descendant.id), "Should have found instance of LooseDescendant when finding abstract LoosePerson: #{descendant.inspect}"
   ensure
     unless Object.const_defined?(:LooseDescendant)
@@ -1219,7 +1219,7 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_assert_queries
-    query = lambda { ActiveRecord::Base.connection.execute 'select count(*) from developers' }
+    query = lambda { ActiveRecord::Base.connection.execute "select count(*) from developers" }
     assert_queries(2) { 2.times { query.call } }
     assert_queries 1, &query
     assert_no_queries { assert true }
@@ -1253,9 +1253,9 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_clear_cache!
     # preheat cache
-    c1 = Post.connection.schema_cache.columns('posts')
+    c1 = Post.connection.schema_cache.columns("posts")
     ActiveRecord::Base.clear_cache!
-    c2 = Post.connection.schema_cache.columns('posts')
+    c2 = Post.connection.schema_cache.columns("posts")
     c1.each_with_index do |v, i|
       assert_not_same v, c2[i]
     end
@@ -1346,11 +1346,11 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_has_attribute
-    assert Company.has_attribute?('id')
-    assert Company.has_attribute?('type')
-    assert Company.has_attribute?('name')
-    assert_not Company.has_attribute?('lastname')
-    assert_not Company.has_attribute?('age')
+    assert Company.has_attribute?("id")
+    assert Company.has_attribute?("type")
+    assert Company.has_attribute?("name")
+    assert_not Company.has_attribute?("lastname")
+    assert_not Company.has_attribute?("age")
   end
 
   def test_has_attribute_with_symbol
@@ -1389,10 +1389,10 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_column_types_typecast
     topic = Topic.first
-    assert_not_equal 't.lo', topic.author_name
+    assert_not_equal "t.lo", topic.author_name
 
     attrs = topic.attributes.dup
-    attrs.delete 'id'
+    attrs.delete "id"
 
     typecast = Class.new(ActiveRecord::Type::Value) {
       def cast value
@@ -1400,26 +1400,26 @@ class BasicsTest < ActiveRecord::TestCase
       end
     }
 
-    types = { 'author_name' => typecast.new }
+    types = { "author_name" => typecast.new }
     topic = Topic.instantiate(attrs, types)
 
-    assert_equal 't.lo', topic.author_name
+    assert_equal "t.lo", topic.author_name
   end
 
   def test_typecasting_aliases
-    assert_equal 10, Topic.select('10 as tenderlove').first.tenderlove
+    assert_equal 10, Topic.select("10 as tenderlove").first.tenderlove
   end
 
   def test_slice
     company = Company.new(:rating => 1, :name => "37signals", :firm_name => "37signals")
     hash = company.slice(:name, :rating, "arbitrary_method")
     assert_equal hash[:name], company.name
-    assert_equal hash['name'], company.name
+    assert_equal hash["name"], company.name
     assert_equal hash[:rating], company.rating
-    assert_equal hash['arbitrary_method'], company.arbitrary_method
+    assert_equal hash["arbitrary_method"], company.arbitrary_method
     assert_equal hash[:arbitrary_method], company.arbitrary_method
     assert_nil hash[:firm_name]
-    assert_nil hash['firm_name']
+    assert_nil hash["firm_name"]
   end
 
   def test_default_values_are_deeply_dupped
@@ -1430,7 +1430,7 @@ class BasicsTest < ActiveRecord::TestCase
 
   test "scoped can take a values hash" do
     klass = Class.new(ActiveRecord::Base)
-    assert_equal ['foo'], klass.all.merge!(select: 'foo').select_values
+    assert_equal ["foo"], klass.all.merge!(select: "foo").select_values
   end
 
   test "connection_handler can be overridden" do
@@ -1512,8 +1512,8 @@ class BasicsTest < ActiveRecord::TestCase
 
   test "ignored columns are not present in columns_hash" do
     cache_columns = Developer.connection.schema_cache.columns_hash(Developer.table_name)
-    assert_includes cache_columns.keys, 'first_name'
-    refute_includes Developer.columns_hash.keys, 'first_name'
+    assert_includes cache_columns.keys, "first_name"
+    refute_includes Developer.columns_hash.keys, "first_name"
   end
 
   test "ignored columns have no attribute methods" do
diff --git a/activerecord/test/cases/batches_test.rb b/activerecord/test/cases/batches_test.rb
index 8a4c1bd615..c48c356773 100644
--- a/activerecord/test/cases/batches_test.rb
+++ b/activerecord/test/cases/batches_test.rb
@@ -1,6 +1,6 @@
-require 'cases/helper'
-require 'models/post'
-require 'models/subscriber'
+require "cases/helper"
+require "models/post"
+require "models/subscriber"
 
 class EachTest < ActiveRecord::TestCase
   fixtures :posts, :subscribers
@@ -8,7 +8,7 @@ class EachTest < ActiveRecord::TestCase
   def setup
     @posts = Post.order("id asc")
     @total = Post.count
-    Post.count('id') # preheat arel's table cache
+    Post.count("id") # preheat arel's table cache
   end
 
   def test_each_should_execute_one_query_per_batch
@@ -68,7 +68,7 @@ class EachTest < ActiveRecord::TestCase
     end
   end
 
-  test 'find_each should honor limit if passed a block' do
+  test "find_each should honor limit if passed a block" do
     limit = @total - 1
     total = 0
 
@@ -79,7 +79,7 @@ class EachTest < ActiveRecord::TestCase
     assert_equal limit, total
   end
 
-  test 'find_each should honor limit if no block is passed' do
+  test "find_each should honor limit if no block is passed" do
     limit = @total - 1
     total = 0
 
@@ -100,7 +100,7 @@ class EachTest < ActiveRecord::TestCase
     previous_logger = ActiveRecord::Base.logger
     ActiveRecord::Base.logger = nil
     assert_nothing_raised do
-      Post.order('comments_count DESC').find_each { |post| post }
+      Post.order("comments_count DESC").find_each { |post| post }
     end
   ensure
     ActiveRecord::Base.logger = previous_logger
@@ -232,7 +232,7 @@ class EachTest < ActiveRecord::TestCase
   end
 
   def test_find_in_batches_should_use_any_column_as_primary_key
-    nick_order_subscribers = Subscriber.order('nick asc')
+    nick_order_subscribers = Subscriber.order("nick asc")
     start_nick = nick_order_subscribers.second.nick
 
     subscribers = []
@@ -265,7 +265,7 @@ class EachTest < ActiveRecord::TestCase
     end
   end
 
-  test 'find_in_batches should honor limit if passed a block' do
+  test "find_in_batches should honor limit if passed a block" do
     limit = @total - 1
     total = 0
 
@@ -276,7 +276,7 @@ class EachTest < ActiveRecord::TestCase
     assert_equal limit, total
   end
 
-  test 'find_in_batches should honor limit if no block is passed' do
+  test "find_in_batches should honor limit if no block is passed" do
     limit = @total - 1
     total = 0
 
@@ -328,7 +328,7 @@ class EachTest < ActiveRecord::TestCase
   end
 
   def test_in_batches_each_record_should_be_ordered_by_id
-    ids = Post.order('id ASC').pluck(:id)
+    ids = Post.order("id ASC").pluck(:id)
     assert_queries(6) do
       Post.in_batches(of: 2).each_record.with_index do |post, i|
         assert_equal ids[i], post.id
@@ -344,9 +344,9 @@ class EachTest < ActiveRecord::TestCase
   end
 
   def test_in_batches_delete_all_should_not_delete_records_in_other_batches
-    not_deleted_count = Post.where('id <= 2').count
-    Post.where('id > 2').in_batches(of: 2).delete_all
-    assert_equal 0, Post.where('id > 2').count
+    not_deleted_count = Post.where("id <= 2").count
+    Post.where("id > 2").in_batches(of: 2).delete_all
+    assert_equal 0, Post.where("id > 2").count
     assert_equal not_deleted_count, Post.count
   end
 
@@ -383,7 +383,7 @@ class EachTest < ActiveRecord::TestCase
   end
 
   def test_in_batches_should_start_from_the_start_option
-    post = Post.order('id ASC').where('id >= ?', 2).first
+    post = Post.order("id ASC").where("id >= ?", 2).first
     assert_queries(2) do
       relation = Post.in_batches(of: 1, start: 2).first
       assert_equal post, relation.first
@@ -391,7 +391,7 @@ class EachTest < ActiveRecord::TestCase
   end
 
   def test_in_batches_should_end_at_the_finish_option
-    post = Post.order('id DESC').where('id <= ?', 5).first
+    post = Post.order("id DESC").where("id <= ?", 5).first
     assert_queries(7) do
       relation = Post.in_batches(of: 1, finish: 5, load: true).reverse_each.first
       assert_equal post, relation.last
@@ -450,7 +450,7 @@ class EachTest < ActiveRecord::TestCase
   end
 
   def test_in_batches_should_use_any_column_as_primary_key
-    nick_order_subscribers = Subscriber.order('nick asc')
+    nick_order_subscribers = Subscriber.order("nick asc")
     start_nick = nick_order_subscribers.second.nick
 
     subscribers = []
@@ -510,7 +510,7 @@ class EachTest < ActiveRecord::TestCase
     person.update_attributes(author_id: 1)
 
     Post.in_batches(of: 2) do |batch|
-      batch.where('author_id >= 1').update_all('author_id = author_id + 1')
+      batch.where("author_id >= 1").update_all("author_id = author_id + 1")
     end
     assert_equal 2, person.reload.author_id # incremented only once
   end
@@ -587,10 +587,10 @@ class EachTest < ActiveRecord::TestCase
     end
   end
 
-  test '.error_on_ignored_order_or_limit= is deprecated' do
+  test ".error_on_ignored_order_or_limit= is deprecated" do
     begin
       prev = ActiveRecord::Base.error_on_ignored_order
-      assert_deprecated 'Please use error_on_ignored_order= instead.' do
+      assert_deprecated "Please use error_on_ignored_order= instead." do
         ActiveRecord::Base.error_on_ignored_order_or_limit = true
       end
       assert ActiveRecord::Base.error_on_ignored_order
@@ -599,17 +599,17 @@ class EachTest < ActiveRecord::TestCase
     end
   end
 
-  test '.error_on_ignored_order_or_limit is deprecated' do
+  test ".error_on_ignored_order_or_limit is deprecated" do
     expected = ActiveRecord::Base.error_on_ignored_order
-    actual = assert_deprecated 'Please use error_on_ignored_order instead.' do
+    actual = assert_deprecated "Please use error_on_ignored_order instead." do
       ActiveRecord::Base.error_on_ignored_order_or_limit
     end
     assert_equal expected, actual
   end
 
-  test '#error_on_ignored_order_or_limit is deprecated' do
+  test "#error_on_ignored_order_or_limit is deprecated" do
     expected = ActiveRecord::Base.error_on_ignored_order
-    actual = assert_deprecated 'Please use error_on_ignored_order instead.' do
+    actual = assert_deprecated "Please use error_on_ignored_order instead." do
       Post.new.error_on_ignored_order_or_limit
     end
     assert_equal expected, actual
diff --git a/activerecord/test/cases/binary_test.rb b/activerecord/test/cases/binary_test.rb
index 9eb5352150..ebb4c3b5f5 100644
--- a/activerecord/test/cases/binary_test.rb
+++ b/activerecord/test/cases/binary_test.rb
@@ -4,23 +4,23 @@ require "cases/helper"
 # BLOB data with DB2, because the length of a statement
 # is limited to 32KB.
 unless current_adapter?(:DB2Adapter)
-  require 'models/binary'
+  require "models/binary"
 
   class BinaryTest < ActiveRecord::TestCase
     FIXTURES = %w(flowers.jpg example.log test.txt)
 
     def test_mixed_encoding
       str = "\x80"
-      str.force_encoding('ASCII-8BIT')
+      str.force_encoding("ASCII-8BIT")
 
-      binary = Binary.new :name => 'いただきます！', :data => str
+      binary = Binary.new :name => "いただきます！", :data => str
       binary.save!
       binary.reload
       assert_equal str, binary.data
 
       name = binary.name
 
-      assert_equal 'いただきます！', name
+      assert_equal "いただきます！", name
     end
 
     def test_load_save
@@ -28,16 +28,16 @@ unless current_adapter?(:DB2Adapter)
 
       FIXTURES.each do |filename|
         data = File.read(ASSETS_ROOT + "/#{filename}")
-        data.force_encoding('ASCII-8BIT')
+        data.force_encoding("ASCII-8BIT")
         data.freeze
 
         bin = Binary.new(:data => data)
-        assert_equal data, bin.data, 'Newly assigned data differs from original'
+        assert_equal data, bin.data, "Newly assigned data differs from original"
 
         bin.save!
-        assert_equal data, bin.data, 'Data differs from original after save'
+        assert_equal data, bin.data, "Data differs from original after save"
 
-        assert_equal data, bin.reload.data, 'Reloaded data differs from original'
+        assert_equal data, bin.reload.data, "Reloaded data differs from original"
       end
     end
   end
diff --git a/activerecord/test/cases/bind_parameter_test.rb b/activerecord/test/cases/bind_parameter_test.rb
index 3f01885489..97d080b2a3 100644
--- a/activerecord/test/cases/bind_parameter_test.rb
+++ b/activerecord/test/cases/bind_parameter_test.rb
@@ -1,7 +1,7 @@
-require 'cases/helper'
-require 'models/topic'
-require 'models/author'
-require 'models/post'
+require "cases/helper"
+require "models/topic"
+require "models/author"
+require "models/post"
 
 module ActiveRecord
   class BindParameterTest < ActiveRecord::TestCase
@@ -24,7 +24,7 @@ module ActiveRecord
       @connection = ActiveRecord::Base.connection
       @subscriber = LogListener.new
       @pk = Topic.columns_hash[Topic.primary_key]
-      @subscription = ActiveSupport::Notifications.subscribe('sql.active_record', @subscriber)
+      @subscription = ActiveSupport::Notifications.subscribe("sql.active_record", @subscriber)
     end
 
     teardown do
@@ -34,8 +34,8 @@ module ActiveRecord
     if ActiveRecord::Base.connection.supports_statement_cache? &&
        ActiveRecord::Base.connection.prepared_statements
       def test_bind_from_join_in_subquery
-        subquery = Author.joins(:thinking_posts).where(name: 'David')
-        scope = Author.from(subquery, 'authors').where(id: 1)
+        subquery = Author.joins(:thinking_posts).where(name: "David")
+        scope = Author.from(subquery, "authors").where(id: 1)
         assert_equal 1, scope.count
       end
 
@@ -44,7 +44,7 @@ module ActiveRecord
         binds = [Relation::QueryAttribute.new("id", 1, Type::Value.new)]
         sql   = "select * from topics where id = #{sub.to_sql}"
 
-        @connection.exec_query(sql, 'SQL', binds)
+        @connection.exec_query(sql, "SQL", binds)
 
         message = @subscriber.calls.find { |args| args[4][:sql] == sql }
         assert_equal binds, message[4][:binds]
@@ -53,20 +53,20 @@ module ActiveRecord
       def test_find_one_uses_binds
         Topic.find(1)
         message = @subscriber.calls.find { |args| args[4][:binds].any? { |attr| attr.value == 1 } }
-        assert message, 'expected a message with binds'
+        assert message, "expected a message with binds"
       end
 
       def test_logs_bind_vars_after_type_cast
         binds = [Relation::QueryAttribute.new("id", "10", Type::Integer.new)]
         type_casted_binds = binds.map { |attr| type_cast(attr.value_for_database) }
         payload = {
-          :name  => 'SQL',
-          :sql   => 'select * from topics where id = ?',
+          :name  => "SQL",
+          :sql   => "select * from topics where id = ?",
           :binds => binds,
           :type_casted_binds => type_casted_binds
         }
         event  = ActiveSupport::Notifications::Event.new(
-          'foo',
+          "foo",
           Time.now,
           Time.now,
           123,
diff --git a/activerecord/test/cases/calculations_test.rb b/activerecord/test/cases/calculations_test.rb
index 6acfec0621..7c3caca5d1 100644
--- a/activerecord/test/cases/calculations_test.rb
+++ b/activerecord/test/cases/calculations_test.rb
@@ -1,24 +1,24 @@
 require "cases/helper"
 require "models/book"
-require 'models/club'
-require 'models/company'
+require "models/club"
+require "models/company"
 require "models/contract"
-require 'models/edge'
-require 'models/organization'
-require 'models/possession'
-require 'models/topic'
-require 'models/reply'
-require 'models/minivan'
-require 'models/speedometer'
-require 'models/ship_part'
-require 'models/treasure'
-require 'models/developer'
-require 'models/comment'
-require 'models/rating'
-require 'models/post'
+require "models/edge"
+require "models/organization"
+require "models/possession"
+require "models/topic"
+require "models/reply"
+require "models/minivan"
+require "models/speedometer"
+require "models/ship_part"
+require "models/treasure"
+require "models/developer"
+require "models/comment"
+require "models/rating"
+require "models/post"
 
 class NumericData < ActiveRecord::Base
-  self.table_name = 'numeric_data'
+  self.table_name = "numeric_data"
 
   attribute :world_population, :integer
   attribute :my_house_population, :integer
@@ -57,7 +57,7 @@ class CalculationsTest < ActiveRecord::TestCase
 
   def test_should_return_integer_average_if_db_returns_such
     ShipPart.delete_all
-    ShipPart.create!(:id => 3, :name => 'foo')
+    ShipPart.create!(:id => 3, :name => "foo")
     value = ShipPart.average(:id)
     assert_equal 3, value
   end
@@ -105,12 +105,12 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_group_by_multiple_fields
-    c = Account.group('firm_id', :credit_limit).count(:all)
+    c = Account.group("firm_id", :credit_limit).count(:all)
     [ [nil, 50], [1, 50], [6, 50], [6, 55], [9, 53], [2, 60] ].each { |firm_and_limit| assert c.keys.include?(firm_and_limit) }
   end
 
   def test_should_group_by_multiple_fields_having_functions
-    c = Topic.group(:author_name, 'COALESCE(type, title)').count(:all)
+    c = Topic.group(:author_name, "COALESCE(type, title)").count(:all)
     assert_equal 1, c[["Carl", "The Third Topic of the day"]]
     assert_equal 1, c[["Mary", "Reply"]]
     assert_equal 1, c[["David", "The First Topic"]]
@@ -166,14 +166,14 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_limit_should_apply_before_count
-    accounts = Account.limit(3).where('firm_id IS NOT NULL')
+    accounts = Account.limit(3).where("firm_id IS NOT NULL")
 
     assert_equal 3, accounts.count(:firm_id)
     assert_equal 3, accounts.select(:firm_id).count
   end
 
   def test_limit_should_apply_before_count_arel_attribute
-    accounts = Account.limit(3).where('firm_id IS NOT NULL')
+    accounts = Account.limit(3).where("firm_id IS NOT NULL")
 
     firm_id_attribute = Account.arel_table[:firm_id]
     assert_equal 3, accounts.count(firm_id_attribute)
@@ -228,7 +228,7 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_group_by_summed_field_having_condition
-    c = Account.group(:firm_id).having('sum(credit_limit) > 50').sum(:credit_limit)
+    c = Account.group(:firm_id).having("sum(credit_limit) > 50").sum(:credit_limit)
     assert_nil        c[1]
     assert_equal 105, c[6]
     assert_equal 60,  c[2]
@@ -249,12 +249,12 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_sum_field_with_conditions
-    assert_equal 105, Account.where('firm_id = 6').sum(:credit_limit)
+    assert_equal 105, Account.where("firm_id = 6").sum(:credit_limit)
   end
 
   def test_should_return_zero_if_sum_conditions_return_nothing
-    assert_equal 0, Account.where('1 = 2').sum(:credit_limit)
-    assert_equal 0, companies(:rails_core).companies.where('1 = 2').sum(:id)
+    assert_equal 0, Account.where("1 = 2").sum(:credit_limit)
+    assert_equal 0, companies(:rails_core).companies.where("1 = 2").sum(:id)
   end
 
   def test_sum_should_return_valid_values_for_decimals
@@ -263,38 +263,38 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_return_type_casted_values_with_group_and_expression
-    assert_equal 0.5, Account.group(:firm_name).sum('0.01 * credit_limit')['37signals']
+    assert_equal 0.5, Account.group(:firm_name).sum("0.01 * credit_limit")["37signals"]
   end
 
   def test_should_group_by_summed_field_with_conditions
-    c = Account.where('firm_id > 1').group(:firm_id).sum(:credit_limit)
+    c = Account.where("firm_id > 1").group(:firm_id).sum(:credit_limit)
     assert_nil        c[1]
     assert_equal 105, c[6]
     assert_equal 60,  c[2]
   end
 
   def test_should_group_by_summed_field_with_conditions_and_having
-    c = Account.where('firm_id > 1').group(:firm_id).
-     having('sum(credit_limit) > 60').sum(:credit_limit)
+    c = Account.where("firm_id > 1").group(:firm_id).
+     having("sum(credit_limit) > 60").sum(:credit_limit)
     assert_nil        c[1]
     assert_equal 105, c[6]
     assert_nil        c[2]
   end
 
   def test_should_group_by_fields_with_table_alias
-    c = Account.group('accounts.firm_id').sum(:credit_limit)
+    c = Account.group("accounts.firm_id").sum(:credit_limit)
     assert_equal 50,  c[1]
     assert_equal 105, c[6]
     assert_equal 60,  c[2]
   end
 
   def test_should_calculate_with_invalid_field
-    assert_equal 6, Account.calculate(:count, '*')
+    assert_equal 6, Account.calculate(:count, "*")
     assert_equal 6, Account.calculate(:count, :all)
   end
 
   def test_should_calculate_grouped_with_invalid_field
-    c = Account.group('accounts.firm_id').count(:all)
+    c = Account.group("accounts.firm_id").count(:all)
     assert_equal 1, c[1]
     assert_equal 2, c[6]
     assert_equal 1, c[2]
@@ -308,8 +308,8 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_group_by_association_with_non_numeric_foreign_key
-    Speedometer.create! id: 'ABC'
-    Minivan.create! id: 'OMG', speedometer_id: 'ABC'
+    Speedometer.create! id: "ABC"
+    Minivan.create! id: "OMG", speedometer_id: "ABC"
 
     c = Minivan.group(:speedometer).count(:all)
     first_key = c.keys.first
@@ -318,7 +318,7 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_calculate_grouped_association_with_foreign_key_option
-    Account.belongs_to :another_firm, :class_name => 'Firm', :foreign_key => 'firm_id'
+    Account.belongs_to :another_firm, :class_name => "Firm", :foreign_key => "firm_id"
     c = Account.group(:another_firm).count(:all)
     assert_equal 1, c[companies(:first_firm)]
     assert_equal 2, c[companies(:rails_core)]
@@ -328,17 +328,17 @@ class CalculationsTest < ActiveRecord::TestCase
   def test_should_calculate_grouped_by_function
     c = Company.group("UPPER(#{QUOTED_TYPE})").count(:all)
     assert_equal 2, c[nil]
-    assert_equal 1, c['DEPENDENTFIRM']
-    assert_equal 5, c['CLIENT']
-    assert_equal 2, c['FIRM']
+    assert_equal 1, c["DEPENDENTFIRM"]
+    assert_equal 5, c["CLIENT"]
+    assert_equal 2, c["FIRM"]
   end
 
   def test_should_calculate_grouped_by_function_with_table_alias
     c = Company.group("UPPER(companies.#{QUOTED_TYPE})").count(:all)
     assert_equal 2, c[nil]
-    assert_equal 1, c['DEPENDENTFIRM']
-    assert_equal 5, c['CLIENT']
-    assert_equal 2, c['FIRM']
+    assert_equal 1, c["DEPENDENTFIRM"]
+    assert_equal 5, c["CLIENT"]
+    assert_equal 2, c["FIRM"]
   end
 
   def test_should_not_overshadow_enumerable_sum
@@ -354,19 +354,19 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_sum_scoped_field_with_conditions
-    assert_equal 8,  companies(:rails_core).companies.where('id > 7').sum(:id)
+    assert_equal 8,  companies(:rails_core).companies.where("id > 7").sum(:id)
   end
 
   def test_should_group_by_scoped_field
     c = companies(:rails_core).companies.group(:name).sum(:id)
-    assert_equal 7, c['Leetsoft']
-    assert_equal 8, c['Jadedpixel']
+    assert_equal 7, c["Leetsoft"]
+    assert_equal 8, c["Jadedpixel"]
   end
 
   def test_should_group_by_summed_field_through_association_and_having
-    c = companies(:rails_core).companies.group(:name).having('sum(id) > 7').sum(:id)
-    assert_nil      c['Leetsoft']
-    assert_equal 8, c['Jadedpixel']
+    c = companies(:rails_core).companies.group(:name).having("sum(id) > 7").sum(:id)
+    assert_nil      c["Leetsoft"]
+    assert_equal 8, c["Jadedpixel"]
   end
 
   def test_should_count_selected_field_with_include
@@ -381,7 +381,7 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_perform_joined_include_when_referencing_included_tables
-    joined_count = Account.includes(:firm).where(:companies => {:name => '37signals'}).count
+    joined_count = Account.includes(:firm).where(:companies => {:name => "37signals"}).count
     assert_equal 1, joined_count
   end
 
@@ -392,10 +392,10 @@ class CalculationsTest < ActiveRecord::TestCase
 
   def test_should_count_scoped_select_with_options
     Account.update_all("credit_limit = NULL")
-    Account.last.update_columns('credit_limit' => 49)
-    Account.first.update_columns('credit_limit' => 51)
+    Account.last.update_columns("credit_limit" => 49)
+    Account.first.update_columns("credit_limit" => 51)
 
-    assert_equal 1, Account.select("credit_limit").where('credit_limit >= 50').count
+    assert_equal 1, Account.select("credit_limit").where("credit_limit >= 50").count
   end
 
   def test_should_count_manual_select_with_include
@@ -436,8 +436,8 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_count_field_in_joined_table
-    assert_equal 5, Account.joins(:firm).count('companies.id')
-    assert_equal 4, Account.joins(:firm).distinct.count('companies.id')
+    assert_equal 5, Account.joins(:firm).count("companies.id")
+    assert_equal 4, Account.joins(:firm).distinct.count("companies.id")
   end
 
   def test_count_arel_attribute_in_joined_table_with
@@ -451,14 +451,14 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_count_field_in_joined_table_with_group_by
-    c = Account.group('accounts.firm_id').joins(:firm).count('companies.id')
+    c = Account.group("accounts.firm_id").joins(:firm).count("companies.id")
 
     [1,6,2,9].each { |firm_id| assert c.keys.include?(firm_id) }
   end
 
   def test_should_count_field_of_root_table_with_conflicting_group_by_column
     assert_equal({ 1 => 1 }, Firm.joins(:accounts).group(:firm_id).count)
-    assert_equal({ 1 => 1 }, Firm.joins(:accounts).group('accounts.firm_id').count)
+    assert_equal({ 1 => 1 }, Firm.joins(:accounts).group("accounts.firm_id").count)
   end
 
   def test_count_with_no_parameters_isnt_deprecated
@@ -478,9 +478,9 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_count_with_where_and_order
-    assert_equal 1, Account.where(firm_name: '37signals').count
-    assert_equal 1, Account.where(firm_name: '37signals').order(:firm_name).count
-    assert_equal 1, Account.where(firm_name: '37signals').order(:firm_name).reverse_order.count
+    assert_equal 1, Account.where(firm_name: "37signals").count
+    assert_equal 1, Account.where(firm_name: "37signals").order(:firm_name).count
+    assert_equal 1, Account.where(firm_name: "37signals").order(:firm_name).reverse_order.count
   end
 
   def test_count_with_block
@@ -497,39 +497,39 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_sum_expression_returns_zero_when_no_records_to_sum
-    assert_equal 0, Account.where('1 = 2').sum("2 * credit_limit")
+    assert_equal 0, Account.where("1 = 2").sum("2 * credit_limit")
   end
 
   def test_count_with_from_option
-    assert_equal Company.count(:all), Company.from('companies').count(:all)
+    assert_equal Company.count(:all), Company.from("companies").count(:all)
     assert_equal Account.where("credit_limit = 50").count(:all),
-        Account.from('accounts').where("credit_limit = 50").count(:all)
+        Account.from("accounts").where("credit_limit = 50").count(:all)
     assert_equal Company.where(:type => "Firm").count(:type),
-        Company.where(:type => "Firm").from('companies').count(:type)
+        Company.where(:type => "Firm").from("companies").count(:type)
   end
 
   def test_sum_with_from_option
-    assert_equal Account.sum(:credit_limit), Account.from('accounts').sum(:credit_limit)
+    assert_equal Account.sum(:credit_limit), Account.from("accounts").sum(:credit_limit)
     assert_equal Account.where("credit_limit > 50").sum(:credit_limit),
-        Account.where("credit_limit > 50").from('accounts').sum(:credit_limit)
+        Account.where("credit_limit > 50").from("accounts").sum(:credit_limit)
   end
 
   def test_average_with_from_option
-    assert_equal Account.average(:credit_limit), Account.from('accounts').average(:credit_limit)
+    assert_equal Account.average(:credit_limit), Account.from("accounts").average(:credit_limit)
     assert_equal Account.where("credit_limit > 50").average(:credit_limit),
-        Account.where("credit_limit > 50").from('accounts').average(:credit_limit)
+        Account.where("credit_limit > 50").from("accounts").average(:credit_limit)
   end
 
   def test_minimum_with_from_option
-    assert_equal Account.minimum(:credit_limit), Account.from('accounts').minimum(:credit_limit)
+    assert_equal Account.minimum(:credit_limit), Account.from("accounts").minimum(:credit_limit)
     assert_equal Account.where("credit_limit > 50").minimum(:credit_limit),
-        Account.where("credit_limit > 50").from('accounts').minimum(:credit_limit)
+        Account.where("credit_limit > 50").from("accounts").minimum(:credit_limit)
   end
 
   def test_maximum_with_from_option
-    assert_equal Account.maximum(:credit_limit), Account.from('accounts').maximum(:credit_limit)
+    assert_equal Account.maximum(:credit_limit), Account.from("accounts").maximum(:credit_limit)
     assert_equal Account.where("credit_limit > 50").maximum(:credit_limit),
-        Account.where("credit_limit > 50").from('accounts').maximum(:credit_limit)
+        Account.where("credit_limit > 50").from("accounts").maximum(:credit_limit)
   end
 
   def test_maximum_with_not_auto_table_name_prefix_if_column_included
@@ -552,14 +552,14 @@ class CalculationsTest < ActiveRecord::TestCase
 
   if current_adapter?(:Mysql2Adapter)
     def test_from_option_with_specified_index
-      assert_equal Edge.count(:all), Edge.from('edges USE INDEX(unique_edge_index)').count(:all)
-      assert_equal Edge.where('sink_id < 5').count(:all),
-          Edge.from('edges USE INDEX(unique_edge_index)').where('sink_id < 5').count(:all)
+      assert_equal Edge.count(:all), Edge.from("edges USE INDEX(unique_edge_index)").count(:all)
+      assert_equal Edge.where("sink_id < 5").count(:all),
+          Edge.from("edges USE INDEX(unique_edge_index)").where("sink_id < 5").count(:all)
     end
   end
 
   def test_from_option_with_table_different_than_class
-    assert_equal Account.count(:all), Company.from('accounts').count(:all)
+    assert_equal Account.count(:all), Company.from("accounts").count(:all)
   end
 
   def test_distinct_is_honored_when_used_with_count_operation_after_group
@@ -599,7 +599,7 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_pluck_on_aliased_attribute
-    assert_equal 'The First Topic', Topic.order(:id).pluck(:heading).first
+    assert_equal "The First Topic", Topic.order(:id).pluck(:heading).first
   end
 
   def test_pluck_with_serialization
@@ -627,14 +627,14 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_pluck_with_selection_clause
-    assert_equal [50, 53, 55, 60], Account.pluck('DISTINCT credit_limit').sort
-    assert_equal [50, 53, 55, 60], Account.pluck('DISTINCT accounts.credit_limit').sort
-    assert_equal [50, 53, 55, 60], Account.pluck('DISTINCT(credit_limit)').sort
+    assert_equal [50, 53, 55, 60], Account.pluck("DISTINCT credit_limit").sort
+    assert_equal [50, 53, 55, 60], Account.pluck("DISTINCT accounts.credit_limit").sort
+    assert_equal [50, 53, 55, 60], Account.pluck("DISTINCT(credit_limit)").sort
 
     # MySQL returns "SUM(DISTINCT(credit_limit))" as the column name unless
     # an alias is provided.  Without the alias, the column cannot be found
     # and properly typecast.
-    assert_equal [50 + 53 + 55 + 60], Account.pluck('SUM(DISTINCT(credit_limit)) as credit_limit')
+    assert_equal [50 + 53 + 55 + 60], Account.pluck("SUM(DISTINCT(credit_limit)) as credit_limit")
   end
 
   def test_plucks_with_ids
@@ -643,7 +643,7 @@ class CalculationsTest < ActiveRecord::TestCase
 
   def test_pluck_with_includes_limit_and_empty_result
     assert_equal [], Topic.includes(:replies).limit(0).pluck(:id)
-    assert_equal [], Topic.includes(:replies).limit(1).where('0 = 1').pluck(:id)
+    assert_equal [], Topic.includes(:replies).limit(1).where("0 = 1").pluck(:id)
   end
 
   def test_pluck_not_auto_table_name_prefix_if_column_included
@@ -668,12 +668,12 @@ class CalculationsTest < ActiveRecord::TestCase
 
   def test_pluck_with_multiple_columns_and_selection_clause
     assert_equal [[1, 50], [2, 50], [3, 50], [4, 60], [5, 55], [6, 53]],
-      Account.pluck('id, credit_limit')
+      Account.pluck("id, credit_limit")
   end
 
   def test_pluck_with_multiple_columns_and_includes
     Company.create!(:name => "test", :contracts => [Contract.new(:developer_id => 7)])
-    companies_and_developers = Company.order('companies.id').includes(:contracts).pluck(:name, :developer_id)
+    companies_and_developers = Company.order("companies.id").includes(:contracts).pluck(:name, :developer_id)
 
     assert_equal Company.count, companies_and_developers.length
     assert_equal ["37signals", nil], companies_and_developers.first
@@ -695,7 +695,7 @@ class CalculationsTest < ActiveRecord::TestCase
   def test_pluck_columns_with_same_name
     expected = [["The First Topic", "The Second Topic of the day"], ["The Third Topic of the day", "The Fourth Topic of the day"]]
     actual = Topic.joins(:replies)
-      .pluck('topics.title', 'replies_topics.title')
+      .pluck("topics.title", "replies_topics.title")
     assert_equal expected, actual
   end
 
@@ -716,21 +716,21 @@ class CalculationsTest < ActiveRecord::TestCase
   def test_pluck_loaded_relation
     companies = Company.order(:id).limit(3).load
     assert_no_queries do
-      assert_equal ['37signals', 'Summit', 'Microsoft'], companies.pluck(:name)
+      assert_equal ["37signals", "Summit", "Microsoft"], companies.pluck(:name)
     end
   end
 
   def test_pluck_loaded_relation_multiple_columns
     companies = Company.order(:id).limit(3).load
     assert_no_queries do
-      assert_equal [[1, '37signals'], [2, 'Summit'], [3, 'Microsoft']], companies.pluck(:id, :name)
+      assert_equal [[1, "37signals"], [2, "Summit"], [3, "Microsoft"]], companies.pluck(:id, :name)
     end
   end
 
   def test_pluck_loaded_relation_sql_fragment
     companies = Company.order(:name).limit(3).load
     assert_queries 1 do
-      assert_equal ['37signals', 'Apex', 'Ex Nihilo'], companies.pluck('DISTINCT name')
+      assert_equal ["37signals", "Apex", "Ex Nihilo"], companies.pluck("DISTINCT name")
     end
   end
 
@@ -748,7 +748,7 @@ class CalculationsTest < ActiveRecord::TestCase
 
   def test_should_reference_correct_aliases_while_joining_tables_of_has_many_through_association
     assert_nothing_raised do
-      developer = Developer.create!(name: 'developer')
+      developer = Developer.create!(name: "developer")
       developer.ratings.includes(comment: :post).where(posts: { id: 1 }).count
     end
   end
@@ -783,7 +783,7 @@ class CalculationsTest < ActiveRecord::TestCase
       end
     end
 
-    params = protected_params.new(credit_limit: '50')
+    params = protected_params.new(credit_limit: "50")
 
     assert_raises(ActiveModel::ForbiddenAttributesError) do
       Account.group(:id).having(params)
diff --git a/activerecord/test/cases/callbacks_test.rb b/activerecord/test/cases/callbacks_test.rb
index 8a722b4f22..584ec759a5 100644
--- a/activerecord/test/cases/callbacks_test.rb
+++ b/activerecord/test/cases/callbacks_test.rb
@@ -1,9 +1,9 @@
 require "cases/helper"
-require 'models/developer'
-require 'models/computer'
+require "models/developer"
+require "models/computer"
 
 class CallbackDeveloper < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
   class << self
     def callback_string(callback_method)
@@ -31,7 +31,7 @@ class CallbackDeveloper < ActiveRecord::Base
   end
 
   ActiveRecord::Callbacks::CALLBACKS.each do |callback_method|
-    next if callback_method.to_s.start_with?('around_')
+    next if callback_method.to_s.start_with?("around_")
     define_callback_method(callback_method)
     ActiveSupport::Deprecation.silence { send(callback_method, callback_string(callback_method)) }
     send(callback_method, callback_proc(callback_method))
@@ -55,7 +55,7 @@ class CallbackDeveloperWithHaltedValidation < CallbackDeveloper
 end
 
 class ParentDeveloper < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
   attr_accessor :after_save_called
   before_validation {|record| record.after_save_called = true}
 end
@@ -65,7 +65,7 @@ class ChildDeveloper < ParentDeveloper
 end
 
 class ImmutableDeveloper < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
   validates_inclusion_of :salary, :in => 50000..200000
 
@@ -79,7 +79,7 @@ class ImmutableDeveloper < ActiveRecord::Base
 end
 
 class DeveloperWithCanceledCallbacks < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
   validates_inclusion_of :salary, in: 50000..200000
 
@@ -93,7 +93,7 @@ class DeveloperWithCanceledCallbacks < ActiveRecord::Base
 end
 
 class OnCallbacksDeveloper < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
   before_validation { history << :before_validation }
   before_validation(:on => :create){ history << :before_validation_on_create }
@@ -113,7 +113,7 @@ class OnCallbacksDeveloper < ActiveRecord::Base
 end
 
 class ContextualCallbacksDeveloper < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
   before_validation { history << :before_validation }
   before_validation :before_validation_on_create_and_update, :on => [ :create, :update ]
@@ -139,7 +139,7 @@ class ContextualCallbacksDeveloper < ActiveRecord::Base
 end
 
 class CallbackCancellationDeveloper < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
   attr_reader   :after_save_called, :after_create_called, :after_update_called, :after_destroy_called
   attr_accessor :cancel_before_save, :cancel_before_create, :cancel_before_update, :cancel_before_destroy
@@ -156,7 +156,7 @@ class CallbackCancellationDeveloper < ActiveRecord::Base
 end
 
 class CallbackHaltedDeveloper < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
   attr_reader   :after_save_called, :after_create_called, :after_update_called, :after_destroy_called
   attr_accessor :cancel_before_save, :cancel_before_create, :cancel_before_update, :cancel_before_destroy
@@ -252,7 +252,7 @@ class CallbacksTest < ActiveRecord::TestCase
   end
 
   def test_create
-    david = CallbackDeveloper.create('name' => 'David', 'salary' => 1000000)
+    david = CallbackDeveloper.create("name" => "David", "salary" => 1000000)
     assert_equal [
       [ :after_initialize,            :method ],
       [ :after_initialize,            :string ],
@@ -298,7 +298,7 @@ class CallbacksTest < ActiveRecord::TestCase
   end
 
   def test_validate_on_create
-    david = OnCallbacksDeveloper.create('name' => 'David', 'salary' => 1000000)
+    david = OnCallbacksDeveloper.create("name" => "David", "salary" => 1000000)
     assert_equal [
       :before_validation,
       :before_validation_on_create,
@@ -309,7 +309,7 @@ class CallbacksTest < ActiveRecord::TestCase
   end
 
   def test_validate_on_contextual_create
-    david = ContextualCallbacksDeveloper.create('name' => 'David', 'salary' => 1000000)
+    david = ContextualCallbacksDeveloper.create("name" => "David", "salary" => 1000000)
     assert_equal [
       :before_validation,
       :before_validation_on_create,
diff --git a/activerecord/test/cases/clone_test.rb b/activerecord/test/cases/clone_test.rb
index 5e43082c33..b89294c094 100644
--- a/activerecord/test/cases/clone_test.rb
+++ b/activerecord/test/cases/clone_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'models/topic'
+require "models/topic"
 
 module ActiveRecord
   class CloneTest < ActiveRecord::TestCase
@@ -8,9 +8,9 @@ module ActiveRecord
     def test_persisted
       topic = Topic.first
       cloned = topic.clone
-      assert topic.persisted?, 'topic persisted'
-      assert cloned.persisted?, 'topic persisted'
-      assert !cloned.new_record?, 'topic is not new'
+      assert topic.persisted?, "topic persisted"
+      assert cloned.persisted?, "topic persisted"
+      assert !cloned.new_record?, "topic is not new"
     end
 
     def test_stays_frozen
@@ -18,16 +18,16 @@ module ActiveRecord
       topic.freeze
 
       cloned = topic.clone
-      assert cloned.persisted?, 'topic persisted'
-      assert !cloned.new_record?, 'topic is not new'
-      assert cloned.frozen?, 'topic should be frozen'
+      assert cloned.persisted?, "topic persisted"
+      assert !cloned.new_record?, "topic is not new"
+      assert cloned.frozen?, "topic should be frozen"
     end
 
     def test_shallow
       topic = Topic.first
       cloned = topic.clone
-      topic.author_name = 'Aaron'
-      assert_equal 'Aaron', cloned.author_name
+      topic.author_name = "Aaron"
+      assert_equal "Aaron", cloned.author_name
     end
 
     def test_freezing_a_cloned_model_does_not_freeze_clone
diff --git a/activerecord/test/cases/coders/yaml_column_test.rb b/activerecord/test/cases/coders/yaml_column_test.rb
index b72c54f97b..b9c6224425 100644
--- a/activerecord/test/cases/coders/yaml_column_test.rb
+++ b/activerecord/test/cases/coders/yaml_column_test.rb
@@ -35,7 +35,7 @@ module ActiveRecord
 
       def test_returns_string_unless_starts_with_dash
         coder = YAMLColumn.new
-        assert_equal 'foo', coder.load("foo")
+        assert_equal "foo", coder.load("foo")
       end
 
       def test_load_handles_other_classes
@@ -45,7 +45,7 @@ module ActiveRecord
 
       def test_load_doesnt_swallow_yaml_exceptions
         coder = YAMLColumn.new
-        bad_yaml = '--- {'
+        bad_yaml = "--- {"
         assert_raises(Psych::SyntaxError) do
           coder.load(bad_yaml)
         end
diff --git a/activerecord/test/cases/column_alias_test.rb b/activerecord/test/cases/column_alias_test.rb
index 40707d9cb2..85d65b074c 100644
--- a/activerecord/test/cases/column_alias_test.rb
+++ b/activerecord/test/cases/column_alias_test.rb
@@ -1,17 +1,17 @@
 require "cases/helper"
-require 'models/topic'
+require "models/topic"
 
 class TestColumnAlias < ActiveRecord::TestCase
   fixtures :topics
 
-  QUERY = if 'Oracle' == ActiveRecord::Base.connection.adapter_name
-            'SELECT id AS pk FROM topics WHERE ROWNUM < 2'
+  QUERY = if "Oracle" == ActiveRecord::Base.connection.adapter_name
+            "SELECT id AS pk FROM topics WHERE ROWNUM < 2"
           else
-            'SELECT id AS pk FROM topics'
+            "SELECT id AS pk FROM topics"
           end
 
   def test_column_alias
     records = Topic.connection.select_all(QUERY)
-    assert_equal 'pk', records[0].keys[0]
+    assert_equal "pk", records[0].keys[0]
   end
 end
diff --git a/activerecord/test/cases/comment_test.rb b/activerecord/test/cases/comment_test.rb
index 839fdbe578..87cc30f0d7 100644
--- a/activerecord/test/cases/comment_test.rb
+++ b/activerecord/test/cases/comment_test.rb
@@ -1,5 +1,5 @@
-require 'cases/helper'
-require 'support/schema_dumping_helper'
+require "cases/helper"
+require "support/schema_dumping_helper"
 
 if ActiveRecord::Base.connection.supports_comments?
 
@@ -7,7 +7,7 @@ class CommentTest < ActiveRecord::TestCase
   include SchemaDumpingHelper
 
   class Commented < ActiveRecord::Base
-    self.table_name = 'commenteds'
+    self.table_name = "commenteds"
   end
 
   class BlankComment < ActiveRecord::Base
@@ -16,20 +16,20 @@ class CommentTest < ActiveRecord::TestCase
   setup do
     @connection = ActiveRecord::Base.connection
 
-    @connection.create_table('commenteds', comment: 'A table with comment', force: true) do |t|
-      t.string  'name',    comment: 'Comment should help clarify the column purpose'
-      t.boolean 'obvious', comment: 'Question is: should you comment obviously named objects?'
-      t.string  'content'
-      t.index   'name',    comment: %Q["Very important" index that powers all the performance.\nAnd it's fun!]
+    @connection.create_table("commenteds", comment: "A table with comment", force: true) do |t|
+      t.string  "name",    comment: "Comment should help clarify the column purpose"
+      t.boolean "obvious", comment: "Question is: should you comment obviously named objects?"
+      t.string  "content"
+      t.index   "name",    comment: %Q["Very important" index that powers all the performance.\nAnd it's fun!]
     end
 
-    @connection.create_table('blank_comments', comment: ' ', force: true) do |t|
-      t.string :space_comment, comment: ' '
-      t.string :empty_comment, comment: ''
+    @connection.create_table("blank_comments", comment: " ", force: true) do |t|
+      t.string :space_comment, comment: " "
+      t.string :empty_comment, comment: ""
       t.string :nil_comment, comment: nil
       t.string :absent_comment
-      t.index :space_comment, comment: ' '
-      t.index :empty_comment, comment: ''
+      t.index :space_comment, comment: " "
+      t.index :empty_comment, comment: ""
       t.index :nil_comment, comment: nil
       t.index :absent_comment
     end
@@ -39,14 +39,14 @@ class CommentTest < ActiveRecord::TestCase
   end
 
   teardown do
-    @connection.drop_table 'commenteds', if_exists: true
-    @connection.drop_table 'blank_comments', if_exists: true
+    @connection.drop_table "commenteds", if_exists: true
+    @connection.drop_table "blank_comments", if_exists: true
   end
 
   def test_column_created_in_block
-    column = Commented.columns_hash['name']
+    column = Commented.columns_hash["name"]
     assert_equal :string, column.type
-    assert_equal 'Comment should help clarify the column purpose', column.comment
+    assert_equal "Comment should help clarify the column purpose", column.comment
   end
 
   def test_blank_columns_created_in_block
@@ -58,41 +58,41 @@ class CommentTest < ActiveRecord::TestCase
   end
 
   def test_blank_indexes_created_in_block
-    @connection.indexes('blank_comments').each do |index|
+    @connection.indexes("blank_comments").each do |index|
       assert_nil index.comment
     end
   end
 
   def test_add_column_with_comment_later
-    @connection.add_column :commenteds, :rating, :integer, comment: 'I am running out of imagination'
+    @connection.add_column :commenteds, :rating, :integer, comment: "I am running out of imagination"
     Commented.reset_column_information
-    column = Commented.columns_hash['rating']
+    column = Commented.columns_hash["rating"]
 
     assert_equal :integer, column.type
-    assert_equal 'I am running out of imagination', column.comment
+    assert_equal "I am running out of imagination", column.comment
   end
 
   def test_add_index_with_comment_later
-    @connection.add_index :commenteds, :obvious, name: 'idx_obvious', comment: 'We need to see obvious comments'
-    index = @connection.indexes('commenteds').find { |idef| idef.name == 'idx_obvious' }
-    assert_equal 'We need to see obvious comments', index.comment
+    @connection.add_index :commenteds, :obvious, name: "idx_obvious", comment: "We need to see obvious comments"
+    index = @connection.indexes("commenteds").find { |idef| idef.name == "idx_obvious" }
+    assert_equal "We need to see obvious comments", index.comment
   end
 
   def test_add_comment_to_column
-    @connection.change_column :commenteds, :content, :string, comment: 'Whoa, content describes itself!'
+    @connection.change_column :commenteds, :content, :string, comment: "Whoa, content describes itself!"
 
     Commented.reset_column_information
-    column = Commented.columns_hash['content']
+    column = Commented.columns_hash["content"]
 
     assert_equal :string, column.type
-    assert_equal 'Whoa, content describes itself!', column.comment
+    assert_equal "Whoa, content describes itself!", column.comment
   end
 
   def test_remove_comment_from_column
     @connection.change_column :commenteds, :obvious, :string, comment: nil
 
     Commented.reset_column_information
-    column = Commented.columns_hash['obvious']
+    column = Commented.columns_hash["obvious"]
 
     assert_equal :string, column.type
     assert_nil column.comment
@@ -100,13 +100,13 @@ class CommentTest < ActiveRecord::TestCase
 
   def test_schema_dump_with_comments
     # Do all the stuff from other tests
-    @connection.add_column    :commenteds, :rating, :integer, comment: 'I am running out of imagination'
-    @connection.change_column :commenteds, :content, :string, comment: 'Whoa, content describes itself!'
+    @connection.add_column    :commenteds, :rating, :integer, comment: "I am running out of imagination"
+    @connection.change_column :commenteds, :content, :string, comment: "Whoa, content describes itself!"
     @connection.change_column :commenteds, :obvious, :string, comment: nil
-    @connection.add_index     :commenteds, :obvious, name: 'idx_obvious', comment: 'We need to see obvious comments'
+    @connection.add_index     :commenteds, :obvious, name: "idx_obvious", comment: "We need to see obvious comments"
 
     # And check that these changes are reflected in dump
-    output = dump_table_schema 'commenteds'
+    output = dump_table_schema "commenteds"
     assert_match %r[create_table "commenteds",.+\s+comment: "A table with comment"], output
     assert_match %r[t\.string\s+"name",\s+comment: "Comment should help clarify the column purpose"], output
     assert_match %r[t\.string\s+"obvious"\n], output
@@ -117,7 +117,7 @@ class CommentTest < ActiveRecord::TestCase
   end
 
   def test_schema_dump_omits_blank_comments
-    output = dump_table_schema 'blank_comments'
+    output = dump_table_schema "blank_comments"
 
     assert_match %r[create_table "blank_comments"], output
     assert_no_match %r[create_table "blank_comments",.+comment:], output
diff --git a/activerecord/test/cases/connection_adapters/adapter_leasing_test.rb b/activerecord/test/cases/connection_adapters/adapter_leasing_test.rb
index c7ca428ab7..64189381cb 100644
--- a/activerecord/test/cases/connection_adapters/adapter_leasing_test.rb
+++ b/activerecord/test/cases/connection_adapters/adapter_leasing_test.rb
@@ -17,23 +17,23 @@ module ActiveRecord
       end
 
       def test_in_use?
-        assert_not @adapter.in_use?, 'adapter is not in use'
-        assert @adapter.lease, 'lease adapter'
-        assert @adapter.in_use?, 'adapter is in use'
+        assert_not @adapter.in_use?, "adapter is not in use"
+        assert @adapter.lease, "lease adapter"
+        assert @adapter.in_use?, "adapter is in use"
       end
 
       def test_lease_twice
-        assert @adapter.lease, 'should lease adapter'
+        assert @adapter.lease, "should lease adapter"
         assert_raises(ActiveRecordError) do
           @adapter.lease
         end
       end
 
       def test_expire_mutates_in_use
-        assert @adapter.lease, 'lease adapter'
-        assert @adapter.in_use?, 'adapter is in use'
+        assert @adapter.lease, "lease adapter"
+        assert @adapter.in_use?, "adapter is in use"
         @adapter.expire
-        assert_not @adapter.in_use?, 'adapter is in use'
+        assert_not @adapter.in_use?, "adapter is in use"
       end
 
       def test_close
diff --git a/activerecord/test/cases/connection_adapters/connection_handler_test.rb b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
index a019cc6490..d9bcc0c130 100644
--- a/activerecord/test/cases/connection_adapters/connection_handler_test.rb
+++ b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
@@ -6,18 +6,18 @@ module ActiveRecord
       def setup
         @handler = ConnectionHandler.new
         @spec_name = "primary"
-        @pool    = @handler.establish_connection(ActiveRecord::Base.configurations['arunit'])
+        @pool    = @handler.establish_connection(ActiveRecord::Base.configurations["arunit"])
       end
 
       def test_establish_connection_uses_spec_name
-        config = {"readonly" => {"adapter" => 'sqlite3'}}
+        config = {"readonly" => {"adapter" => "sqlite3"}}
         resolver = ConnectionAdapters::ConnectionSpecification::Resolver.new(config)
         spec =   resolver.spec(:readonly)
         @handler.establish_connection(spec.to_hash)
 
-        assert_not_nil @handler.retrieve_connection_pool('readonly')
+        assert_not_nil @handler.retrieve_connection_pool("readonly")
       ensure
-        @handler.remove_connection('readonly')
+        @handler.remove_connection("readonly")
       end
 
       def test_retrieve_connection
@@ -68,7 +68,7 @@ module ActiveRecord
 
         def test_retrieve_connection_pool_copies_schema_cache_from_ancestor_pool
           @pool.schema_cache = @pool.connection.schema_cache
-          @pool.schema_cache.add('posts')
+          @pool.schema_cache.add("posts")
 
           rd, wr = IO.pipe
           rd.binmode
@@ -90,7 +90,7 @@ module ActiveRecord
         end
 
         def test_a_class_using_custom_pool_and_switching_back_to_primary
-          klass2 = Class.new(Base) { def self.name; 'klass2'; end }
+          klass2 = Class.new(Base) { def self.name; "klass2"; end }
 
           assert_equal klass2.connection.object_id, ActiveRecord::Base.connection.object_id
 
@@ -113,7 +113,7 @@ module ActiveRecord
         end
 
         def test_remove_connection_should_not_remove_parent
-          klass2 = Class.new(Base) { def self.name; 'klass2'; end }
+          klass2 = Class.new(Base) { def self.name; "klass2"; end }
           klass2.remove_connection
           refute_nil ActiveRecord::Base.connection.object_id
           assert_equal klass2.connection.object_id, ActiveRecord::Base.connection.object_id
diff --git a/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb b/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb
index f25b85e8a7..b1ba6f11f2 100644
--- a/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb
+++ b/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb
@@ -24,7 +24,7 @@ module ActiveRecord
       end
 
       def test_resolver_with_database_uri_and_current_env_symbol_key
-        ENV['DATABASE_URL'] = "postgres://localhost/foo"
+        ENV["DATABASE_URL"] = "postgres://localhost/foo"
         config   = { "not_production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
         actual   = resolve_spec(:default_env, config)
         expected = { "adapter"=>"postgresql", "database"=>"foo", "host"=>"localhost", "name"=>"default_env" }
@@ -32,8 +32,8 @@ module ActiveRecord
       end
 
       def test_resolver_with_database_uri_and_current_env_symbol_key_and_rails_env
-        ENV['DATABASE_URL'] = "postgres://localhost/foo"
-        ENV['RAILS_ENV']    = "foo"
+        ENV["DATABASE_URL"] = "postgres://localhost/foo"
+        ENV["RAILS_ENV"]    = "foo"
 
         config   = { "not_production" => { "adapter" => "not_postgres", "database" => "not_foo" } }
         actual   = resolve_spec(:foo, config)
@@ -42,8 +42,8 @@ module ActiveRecord
       end
 
       def test_resolver_with_database_uri_and_current_env_symbol_key_and_rack_env
-        ENV['DATABASE_URL'] = "postgres://localhost/foo"
-        ENV['RACK_ENV']     = "foo"
+        ENV["DATABASE_URL"] = "postgres://localhost/foo"
+        ENV["RACK_ENV"]     = "foo"
 
         config   = { "not_production" => { "adapter" => "not_postgres", "database" => "not_foo" } }
         actual   = resolve_spec(:foo, config)
@@ -52,7 +52,7 @@ module ActiveRecord
       end
 
       def test_resolver_with_database_uri_and_known_key
-        ENV['DATABASE_URL'] = "postgres://localhost/foo"
+        ENV["DATABASE_URL"] = "postgres://localhost/foo"
         config   = { "production" => { "adapter" => "not_postgres", "database" => "not_foo", "host" => "localhost" } }
         actual   = resolve_spec(:production, config)
         expected = { "adapter"=>"not_postgres", "database"=>"not_foo", "host"=>"localhost", "name"=>"production" }
@@ -60,7 +60,7 @@ module ActiveRecord
       end
 
       def test_resolver_with_database_uri_and_unknown_symbol_key
-        ENV['DATABASE_URL'] = "postgres://localhost/foo"
+        ENV["DATABASE_URL"] = "postgres://localhost/foo"
         config   = { "not_production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
         assert_raises AdapterNotSpecified do
           resolve_spec(:production, config)
@@ -68,7 +68,7 @@ module ActiveRecord
       end
 
       def test_resolver_with_database_uri_and_supplied_url
-        ENV['DATABASE_URL'] = "not-postgres://not-localhost/not_foo"
+        ENV["DATABASE_URL"] = "not-postgres://not-localhost/not_foo"
         config   = { "production" => {  "adapter" => "also_not_postgres", "database" => "also_not_foo" } }
         actual   = resolve_spec("postgres://localhost/foo", config)
         expected = { "adapter"=>"postgresql", "database"=>"foo", "host"=>"localhost" }
@@ -82,7 +82,7 @@ module ActiveRecord
       end
 
       def test_environment_does_not_exist_in_config_url_does_exist
-        ENV['DATABASE_URL'] = "postgres://localhost/foo"
+        ENV["DATABASE_URL"] = "postgres://localhost/foo"
         config      = { "not_default_env" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
         actual      = resolve_config(config)
         expect_prod = { "adapter"=>"postgresql", "database"=>"foo", "host"=>"localhost" }
@@ -90,7 +90,7 @@ module ActiveRecord
       end
 
       def test_url_with_hyphenated_scheme
-        ENV['DATABASE_URL'] = "ibm-db://localhost/foo"
+        ENV["DATABASE_URL"] = "ibm-db://localhost/foo"
         config   = { "default_env" => { "adapter" => "not_postgres", "database" => "not_foo", "host" => "localhost" } }
         actual   = resolve_spec(:default_env, config)
         expected = { "adapter"=>"ibm_db", "database"=>"foo", "host"=>"localhost", "name"=>"default_env" }
@@ -134,7 +134,7 @@ module ActiveRecord
       end
 
       def test_blank_with_database_url
-        ENV['DATABASE_URL'] = "postgres://localhost/foo"
+        ENV["DATABASE_URL"] = "postgres://localhost/foo"
 
         config   = {}
         actual   = resolve_config(config)
@@ -152,8 +152,8 @@ module ActiveRecord
       end
 
       def test_blank_with_database_url_with_rails_env
-        ENV['RAILS_ENV'] = "not_production"
-        ENV['DATABASE_URL'] = "postgres://localhost/foo"
+        ENV["RAILS_ENV"] = "not_production"
+        ENV["DATABASE_URL"] = "postgres://localhost/foo"
 
         config   = {}
         actual   = resolve_config(config)
@@ -174,8 +174,8 @@ module ActiveRecord
       end
 
       def test_blank_with_database_url_with_rack_env
-        ENV['RACK_ENV'] = "not_production"
-        ENV['DATABASE_URL'] = "postgres://localhost/foo"
+        ENV["RACK_ENV"] = "not_production"
+        ENV["DATABASE_URL"] = "postgres://localhost/foo"
 
         config   = {}
         actual   = resolve_config(config)
@@ -196,7 +196,7 @@ module ActiveRecord
       end
 
       def test_database_url_with_ipv6_host_and_port
-        ENV['DATABASE_URL'] = "postgres://[::1]:5454/foo"
+        ENV["DATABASE_URL"] = "postgres://[::1]:5454/foo"
 
         config   = {}
         actual   = resolve_config(config)
@@ -208,7 +208,7 @@ module ActiveRecord
       end
 
       def test_url_sub_key_with_database_url
-        ENV['DATABASE_URL'] = "NOT-POSTGRES://localhost/NOT_FOO"
+        ENV["DATABASE_URL"] = "NOT-POSTGRES://localhost/NOT_FOO"
 
         config   = { "default_env" => { "url" => "postgres://localhost/foo" } }
         actual   = resolve_config(config)
@@ -222,7 +222,7 @@ module ActiveRecord
       end
 
       def test_merge_no_conflicts_with_database_url
-        ENV['DATABASE_URL'] = "postgres://localhost/foo"
+        ENV["DATABASE_URL"] = "postgres://localhost/foo"
 
         config   = {"default_env" => { "pool" => "5" } }
         actual   = resolve_config(config)
@@ -237,7 +237,7 @@ module ActiveRecord
       end
 
       def test_merge_conflicts_with_database_url
-        ENV['DATABASE_URL'] = "postgres://localhost/foo"
+        ENV["DATABASE_URL"] = "postgres://localhost/foo"
 
         config   = {"default_env" => { "adapter" => "NOT-POSTGRES", "database" => "NOT-FOO", "pool" => "5" } }
         actual   = resolve_config(config)
diff --git a/activerecord/test/cases/connection_adapters/mysql_type_lookup_test.rb b/activerecord/test/cases/connection_adapters/mysql_type_lookup_test.rb
index f2b1d9e4e7..209802d34f 100644
--- a/activerecord/test/cases/connection_adapters/mysql_type_lookup_test.rb
+++ b/activerecord/test/cases/connection_adapters/mysql_type_lookup_test.rb
@@ -10,8 +10,8 @@ module ActiveRecord
 
       def test_boolean_types
         emulate_booleans(true) do
-          assert_lookup_type :boolean, 'tinyint(1)'
-          assert_lookup_type :boolean, 'TINYINT(1)'
+          assert_lookup_type :boolean, "tinyint(1)"
+          assert_lookup_type :boolean, "TINYINT(1)"
         end
       end
 
@@ -31,16 +31,16 @@ module ActiveRecord
       end
 
       def test_binary_types
-        assert_lookup_type :binary, 'bit'
-        assert_lookup_type :binary, 'BIT'
+        assert_lookup_type :binary, "bit"
+        assert_lookup_type :binary, "BIT"
       end
 
       def test_integer_types
         emulate_booleans(false) do
-          assert_lookup_type :integer, 'tinyint(1)'
-          assert_lookup_type :integer, 'TINYINT(1)'
-          assert_lookup_type :integer, 'year'
-          assert_lookup_type :integer, 'YEAR'
+          assert_lookup_type :integer, "tinyint(1)"
+          assert_lookup_type :integer, "TINYINT(1)"
+          assert_lookup_type :integer, "year"
+          assert_lookup_type :integer, "YEAR"
         end
       end
 
diff --git a/activerecord/test/cases/connection_adapters/schema_cache_test.rb b/activerecord/test/cases/connection_adapters/schema_cache_test.rb
index db832fe55d..d4459603af 100644
--- a/activerecord/test/cases/connection_adapters/schema_cache_test.rb
+++ b/activerecord/test/cases/connection_adapters/schema_cache_test.rb
@@ -9,28 +9,28 @@ module ActiveRecord
       end
 
       def test_primary_key
-        assert_equal 'id', @cache.primary_keys('posts')
+        assert_equal "id", @cache.primary_keys("posts")
       end
 
       def test_primary_key_for_non_existent_table
-        assert_nil @cache.primary_keys('omgponies')
+        assert_nil @cache.primary_keys("omgponies")
       end
 
       def test_caches_columns
-        columns = @cache.columns('posts')
-        assert_equal columns, @cache.columns('posts')
+        columns = @cache.columns("posts")
+        assert_equal columns, @cache.columns("posts")
       end
 
       def test_caches_columns_hash
-        columns_hash = @cache.columns_hash('posts')
-        assert_equal columns_hash, @cache.columns_hash('posts')
+        columns_hash = @cache.columns_hash("posts")
+        assert_equal columns_hash, @cache.columns_hash("posts")
       end
 
       def test_clearing
-        @cache.columns('posts')
-        @cache.columns_hash('posts')
-        @cache.data_sources('posts')
-        @cache.primary_keys('posts')
+        @cache.columns("posts")
+        @cache.columns_hash("posts")
+        @cache.data_sources("posts")
+        @cache.primary_keys("posts")
 
         @cache.clear!
 
@@ -38,23 +38,23 @@ module ActiveRecord
       end
 
       def test_dump_and_load
-        @cache.columns('posts')
-        @cache.columns_hash('posts')
-        @cache.data_sources('posts')
-        @cache.primary_keys('posts')
+        @cache.columns("posts")
+        @cache.columns_hash("posts")
+        @cache.data_sources("posts")
+        @cache.primary_keys("posts")
 
         @cache = Marshal.load(Marshal.dump(@cache))
 
-        assert_equal 11, @cache.columns('posts').size
-        assert_equal 11, @cache.columns_hash('posts').size
-        assert @cache.data_sources('posts')
-        assert_equal 'id', @cache.primary_keys('posts')
+        assert_equal 11, @cache.columns("posts").size
+        assert_equal 11, @cache.columns_hash("posts").size
+        assert @cache.data_sources("posts")
+        assert_equal "id", @cache.primary_keys("posts")
       end
 
       def test_table_methods_deprecation
-        assert_deprecated { assert @cache.table_exists?('posts') }
-        assert_deprecated { assert @cache.tables('posts') }
-        assert_deprecated { @cache.clear_table_cache!('posts') }
+        assert_deprecated { assert @cache.table_exists?("posts") }
+        assert_deprecated { assert @cache.tables("posts") }
+        assert_deprecated { @cache.clear_table_cache!("posts") }
       end
     end
   end
diff --git a/activerecord/test/cases/connection_adapters/type_lookup_test.rb b/activerecord/test/cases/connection_adapters/type_lookup_test.rb
index 3acbafbff4..c01464ed68 100644
--- a/activerecord/test/cases/connection_adapters/type_lookup_test.rb
+++ b/activerecord/test/cases/connection_adapters/type_lookup_test.rb
@@ -9,74 +9,74 @@ module ActiveRecord
       end
 
       def test_boolean_types
-        assert_lookup_type :boolean, 'boolean'
-        assert_lookup_type :boolean, 'BOOLEAN'
+        assert_lookup_type :boolean, "boolean"
+        assert_lookup_type :boolean, "BOOLEAN"
       end
 
       def test_string_types
-        assert_lookup_type :string, 'char'
-        assert_lookup_type :string, 'varchar'
-        assert_lookup_type :string, 'VARCHAR'
-        assert_lookup_type :string, 'varchar(255)'
-        assert_lookup_type :string, 'character varying'
+        assert_lookup_type :string, "char"
+        assert_lookup_type :string, "varchar"
+        assert_lookup_type :string, "VARCHAR"
+        assert_lookup_type :string, "varchar(255)"
+        assert_lookup_type :string, "character varying"
       end
 
       def test_binary_types
-        assert_lookup_type :binary, 'binary'
-        assert_lookup_type :binary, 'BINARY'
-        assert_lookup_type :binary, 'blob'
-        assert_lookup_type :binary, 'BLOB'
+        assert_lookup_type :binary, "binary"
+        assert_lookup_type :binary, "BINARY"
+        assert_lookup_type :binary, "blob"
+        assert_lookup_type :binary, "BLOB"
       end
 
       def test_text_types
-        assert_lookup_type :text, 'text'
-        assert_lookup_type :text, 'TEXT'
-        assert_lookup_type :text, 'clob'
-        assert_lookup_type :text, 'CLOB'
+        assert_lookup_type :text, "text"
+        assert_lookup_type :text, "TEXT"
+        assert_lookup_type :text, "clob"
+        assert_lookup_type :text, "CLOB"
       end
 
       def test_date_types
-        assert_lookup_type :date, 'date'
-        assert_lookup_type :date, 'DATE'
+        assert_lookup_type :date, "date"
+        assert_lookup_type :date, "DATE"
       end
 
       def test_time_types
-        assert_lookup_type :time, 'time'
-        assert_lookup_type :time, 'TIME'
+        assert_lookup_type :time, "time"
+        assert_lookup_type :time, "TIME"
       end
 
       def test_datetime_types
-        assert_lookup_type :datetime, 'datetime'
-        assert_lookup_type :datetime, 'DATETIME'
-        assert_lookup_type :datetime, 'timestamp'
-        assert_lookup_type :datetime, 'TIMESTAMP'
+        assert_lookup_type :datetime, "datetime"
+        assert_lookup_type :datetime, "DATETIME"
+        assert_lookup_type :datetime, "timestamp"
+        assert_lookup_type :datetime, "TIMESTAMP"
       end
 
       def test_decimal_types
-        assert_lookup_type :decimal, 'decimal'
-        assert_lookup_type :decimal, 'decimal(2,8)'
-        assert_lookup_type :decimal, 'DECIMAL'
-        assert_lookup_type :decimal, 'numeric'
-        assert_lookup_type :decimal, 'numeric(2,8)'
-        assert_lookup_type :decimal, 'NUMERIC'
-        assert_lookup_type :decimal, 'number'
-        assert_lookup_type :decimal, 'number(2,8)'
-        assert_lookup_type :decimal, 'NUMBER'
+        assert_lookup_type :decimal, "decimal"
+        assert_lookup_type :decimal, "decimal(2,8)"
+        assert_lookup_type :decimal, "DECIMAL"
+        assert_lookup_type :decimal, "numeric"
+        assert_lookup_type :decimal, "numeric(2,8)"
+        assert_lookup_type :decimal, "NUMERIC"
+        assert_lookup_type :decimal, "number"
+        assert_lookup_type :decimal, "number(2,8)"
+        assert_lookup_type :decimal, "NUMBER"
       end
 
       def test_float_types
-        assert_lookup_type :float, 'float'
-        assert_lookup_type :float, 'FLOAT'
-        assert_lookup_type :float, 'double'
-        assert_lookup_type :float, 'DOUBLE'
+        assert_lookup_type :float, "float"
+        assert_lookup_type :float, "FLOAT"
+        assert_lookup_type :float, "double"
+        assert_lookup_type :float, "DOUBLE"
       end
 
       def test_integer_types
-        assert_lookup_type :integer, 'integer'
-        assert_lookup_type :integer, 'INTEGER'
-        assert_lookup_type :integer, 'tinyint'
-        assert_lookup_type :integer, 'smallint'
-        assert_lookup_type :integer, 'bigint'
+        assert_lookup_type :integer, "integer"
+        assert_lookup_type :integer, "INTEGER"
+        assert_lookup_type :integer, "tinyint"
+        assert_lookup_type :integer, "smallint"
+        assert_lookup_type :integer, "bigint"
       end
 
       def test_bigint_limit
diff --git a/activerecord/test/cases/connection_management_test.rb b/activerecord/test/cases/connection_management_test.rb
index 1f9b6add7a..88620f9f09 100644
--- a/activerecord/test/cases/connection_management_test.rb
+++ b/activerecord/test/cases/connection_management_test.rb
@@ -14,7 +14,7 @@ module ActiveRecord
 
         def call(env)
           @calls << env
-          [200, {}, ['hi mom']]
+          [200, {}, ["hi mom"]]
         end
       end
 
@@ -39,7 +39,7 @@ module ActiveRecord
         _, _, body = @management.call(@env)
         bits = []
         body.each { |bit| bits << bit }
-        assert_equal ['hi mom'], bits
+        assert_equal ["hi mom"], bits
       end
 
       def test_connections_are_cleared_after_body_close
@@ -88,10 +88,10 @@ module ActiveRecord
       end
 
       test "doesn't mutate the original response" do
-        original_response = [200, {}, 'hi']
+        original_response = [200, {}, "hi"]
         app = lambda { |_| original_response }
         middleware(app).call(@env)[2]
-        assert_equal 'hi', original_response.last
+        assert_equal "hi", original_response.last
       end
 
       private
diff --git a/activerecord/test/cases/connection_pool_test.rb b/activerecord/test/cases/connection_pool_test.rb
index bbcb42d58e..8324fecd3a 100644
--- a/activerecord/test/cases/connection_pool_test.rb
+++ b/activerecord/test/cases/connection_pool_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'concurrent/atomic/count_down_latch'
+require "concurrent/atomic/count_down_latch"
 
 module ActiveRecord
   module ConnectionAdapters
@@ -343,12 +343,12 @@ module ActiveRecord
 
       def test_connection_notification_is_called
         payloads = []
-        subscription = ActiveSupport::Notifications.subscribe('!connection.active_record') do |name, started, finished, unique_id, payload|
+        subscription = ActiveSupport::Notifications.subscribe("!connection.active_record") do |name, started, finished, unique_id, payload|
           payloads << payload
         end
         ActiveRecord::Base.establish_connection :arunit
         assert_equal [:config, :connection_id, :spec_name], payloads[0].keys.sort
-        assert_equal 'primary', payloads[0][:spec_name]
+        assert_equal "primary", payloads[0][:spec_name]
       ensure
         ActiveSupport::Notifications.unsubscribe(subscription) if subscription
       end
@@ -395,8 +395,8 @@ module ActiveRecord
             all_threads_in_new_connection.wait
           end
         rescue Timeout::Error
-          flunk 'pool unable to establish connections concurrently or implementation has ' <<
-                'changed, this test then needs to patch a different :new_connection method'
+          flunk "pool unable to establish connections concurrently or implementation has " <<
+                "changed, this test then needs to patch a different :new_connection method"
         ensure
           # clean up the threads
           all_go.count_down
@@ -519,7 +519,7 @@ module ActiveRecord
           pool.clear_reloadable_connections
 
           unless stuck_thread.join(2)
-            flunk 'clear_reloadable_connections must not let other connection waiting threads get stuck in queue'
+            flunk "clear_reloadable_connections must not let other connection waiting threads get stuck in queue"
           end
 
           assert_equal 0, pool.num_waiting_in_queue
diff --git a/activerecord/test/cases/connection_specification/resolver_test.rb b/activerecord/test/cases/connection_specification/resolver_test.rb
index b30a83d9ce..7a6125d81b 100644
--- a/activerecord/test/cases/connection_specification/resolver_test.rb
+++ b/activerecord/test/cases/connection_specification/resolver_test.rb
@@ -14,7 +14,7 @@ module ActiveRecord
 
         def test_url_invalid_adapter
           error = assert_raises(LoadError) do
-            spec 'ridiculous://foo?encoding=utf8'
+            spec "ridiculous://foo?encoding=utf8"
           end
 
           assert_match "Could not load 'active_record/connection_adapters/ridiculous_adapter'", error.message
@@ -24,7 +24,7 @@ module ActiveRecord
         # checks that the adapter file can be required in.
 
         def test_url_from_environment
-          spec = resolve :production, 'production' => 'abstract://foo?encoding=utf8'
+          spec = resolve :production, "production" => "abstract://foo?encoding=utf8"
           assert_equal({
             "adapter"  =>  "abstract",
             "host"     =>  "foo",
@@ -33,7 +33,7 @@ module ActiveRecord
         end
 
         def test_url_sub_key
-          spec = resolve :production, 'production' => {"url" => 'abstract://foo?encoding=utf8'}
+          spec = resolve :production, "production" => {"url" => "abstract://foo?encoding=utf8"}
           assert_equal({
             "adapter"  => "abstract",
             "host"     => "foo",
@@ -42,8 +42,8 @@ module ActiveRecord
         end
 
         def test_url_sub_key_merges_correctly
-          hash = {"url" => 'abstract://foo?encoding=utf8&', "adapter" => "sqlite3", "host" => "bar", "pool" => "3"}
-          spec = resolve :production, 'production' => hash
+          hash = {"url" => "abstract://foo?encoding=utf8&", "adapter" => "sqlite3", "host" => "bar", "pool" => "3"}
+          spec = resolve :production, "production" => hash
           assert_equal({
             "adapter"  => "abstract",
             "host"     => "foo",
@@ -53,7 +53,7 @@ module ActiveRecord
         end
 
         def test_url_host_no_db
-          spec = resolve 'abstract://foo?encoding=utf8'
+          spec = resolve "abstract://foo?encoding=utf8"
           assert_equal({
             "adapter"  => "abstract",
             "host"     => "foo",
@@ -61,13 +61,13 @@ module ActiveRecord
         end
 
         def test_url_missing_scheme
-          spec = resolve 'foo'
+          spec = resolve "foo"
           assert_equal({
             "database" => "foo" }, spec)
         end
 
         def test_url_host_db
-          spec = resolve 'abstract://foo/bar?encoding=utf8'
+          spec = resolve "abstract://foo/bar?encoding=utf8"
           assert_equal({
             "adapter"  => "abstract",
             "database" => "bar",
@@ -76,7 +76,7 @@ module ActiveRecord
         end
 
         def test_url_port
-          spec = resolve 'abstract://foo:123?encoding=utf8'
+          spec = resolve "abstract://foo:123?encoding=utf8"
           assert_equal({
             "adapter"  => "abstract",
             "port"     => 123,
@@ -85,34 +85,34 @@ module ActiveRecord
         end
 
         def test_encoded_password
-          password = 'am@z1ng_p@ssw0rd#!'
+          password = "am@z1ng_p@ssw0rd#!"
           encoded_password = URI.encode_www_form_component(password)
           spec = resolve "abstract://foo:#{encoded_password}@localhost/bar"
           assert_equal password, spec["password"]
         end
 
         def test_url_with_authority_for_sqlite3
-          spec = resolve 'sqlite3:///foo_test'
-          assert_equal('/foo_test', spec["database"])
+          spec = resolve "sqlite3:///foo_test"
+          assert_equal("/foo_test", spec["database"])
         end
 
         def test_url_absolute_path_for_sqlite3
-          spec = resolve 'sqlite3:/foo_test'
-          assert_equal('/foo_test', spec["database"])
+          spec = resolve "sqlite3:/foo_test"
+          assert_equal("/foo_test", spec["database"])
         end
 
         def test_url_relative_path_for_sqlite3
-          spec = resolve 'sqlite3:foo_test'
-          assert_equal('foo_test', spec["database"])
+          spec = resolve "sqlite3:foo_test"
+          assert_equal("foo_test", spec["database"])
         end
 
         def test_url_memory_db_for_sqlite3
-          spec = resolve 'sqlite3::memory:'
-          assert_equal(':memory:', spec["database"])
+          spec = resolve "sqlite3::memory:"
+          assert_equal(":memory:", spec["database"])
         end
 
         def test_url_sub_key_for_sqlite3
-          spec = resolve :production, 'production' => {"url" => 'sqlite3:foo?encoding=utf8'}
+          spec = resolve :production, "production" => {"url" => "sqlite3:foo?encoding=utf8"}
           assert_equal({
             "adapter"  => "sqlite3",
             "database" => "foo",
@@ -121,12 +121,12 @@ module ActiveRecord
         end
 
         def test_spec_name_on_key_lookup
-          spec = spec(:readonly, 'readonly' => {'adapter' => 'sqlite3'})
+          spec = spec(:readonly, "readonly" => {"adapter" => "sqlite3"})
           assert_equal "readonly", spec.name
         end
 
         def test_spec_name_with_inline_config
-          spec = spec({'adapter' => 'sqlite3'})
+          spec = spec({"adapter" => "sqlite3"})
           assert_equal "primary", spec.name, "should default to primary id"
         end
       end
diff --git a/activerecord/test/cases/core_test.rb b/activerecord/test/cases/core_test.rb
index 3cb98832c5..051afa4f1f 100644
--- a/activerecord/test/cases/core_test.rb
+++ b/activerecord/test/cases/core_test.rb
@@ -1,8 +1,8 @@
-require 'cases/helper'
-require 'models/person'
-require 'models/topic'
-require 'pp'
-require 'active_support/core_ext/string/strip'
+require "cases/helper"
+require "models/person"
+require "models/topic"
+require "pp"
+require "active_support/core_ext/string/strip"
 
 class NonExistentTable < ActiveRecord::Base; end
 
@@ -10,8 +10,8 @@ class CoreTest < ActiveRecord::TestCase
   fixtures :topics
 
   def test_inspect_class
-    assert_equal 'ActiveRecord::Base', ActiveRecord::Base.inspect
-    assert_equal 'LoosePerson(abstract)', LoosePerson.inspect
+    assert_equal "ActiveRecord::Base", ActiveRecord::Base.inspect
+    assert_equal "LoosePerson(abstract)", LoosePerson.inspect
     assert_match(/^Topic\(id: integer, title: string/, Topic.inspect)
   end
 
@@ -25,8 +25,8 @@ class CoreTest < ActiveRecord::TestCase
   end
 
   def test_inspect_limited_select_instance
-    assert_equal %(#<Topic id: 1>), Topic.all.merge!(:select => 'id', :where => 'id = 1').first.inspect
-    assert_equal %(#<Topic id: 1, title: "The First Topic">), Topic.all.merge!(:select => 'id, title', :where => 'id = 1').first.inspect
+    assert_equal %(#<Topic id: 1>), Topic.all.merge!(:select => "id", :where => "id = 1").first.inspect
+    assert_equal %(#<Topic id: 1, title: "The First Topic">), Topic.all.merge!(:select => "id, title", :where => "id = 1").first.inspect
   end
 
   def test_inspect_class_without_table
@@ -35,7 +35,7 @@ class CoreTest < ActiveRecord::TestCase
 
   def test_pretty_print_new
     topic = Topic.new
-    actual = ''
+    actual = ""
     PP.pp(topic, StringIO.new(actual))
     expected = <<-PRETTY.strip_heredoc
     #<Topic:0xXXXXXX
@@ -58,13 +58,13 @@ class CoreTest < ActiveRecord::TestCase
      created_at: nil,
      updated_at: nil>
     PRETTY
-    assert actual.start_with?(expected.split('XXXXXX').first)
-    assert actual.end_with?(expected.split('XXXXXX').last)
+    assert actual.start_with?(expected.split("XXXXXX").first)
+    assert actual.end_with?(expected.split("XXXXXX").last)
   end
 
   def test_pretty_print_persisted
     topic = topics(:first)
-    actual = ''
+    actual = ""
     PP.pp(topic, StringIO.new(actual))
     expected = <<-PRETTY.strip_heredoc
     #<Topic:0x\\w+
@@ -92,11 +92,11 @@ class CoreTest < ActiveRecord::TestCase
 
   def test_pretty_print_uninitialized
     topic = Topic.allocate
-    actual = ''
+    actual = ""
     PP.pp(topic, StringIO.new(actual))
     expected = "#<Topic:XXXXXX not initialized>\n"
-    assert actual.start_with?(expected.split('XXXXXX').first)
-    assert actual.end_with?(expected.split('XXXXXX').last)
+    assert actual.start_with?(expected.split("XXXXXX").first)
+    assert actual.end_with?(expected.split("XXXXXX").last)
   end
 
   def test_pretty_print_overridden_by_inspect
@@ -105,7 +105,7 @@ class CoreTest < ActiveRecord::TestCase
         "inspecting topic"
       end
     end
-    actual = ''
+    actual = ""
     PP.pp(subtopic.new, StringIO.new(actual))
     assert_equal "inspecting topic\n", actual
   end
diff --git a/activerecord/test/cases/counter_cache_test.rb b/activerecord/test/cases/counter_cache_test.rb
index 66b4c3f1ff..e22a243591 100644
--- a/activerecord/test/cases/counter_cache_test.rb
+++ b/activerecord/test/cases/counter_cache_test.rb
@@ -1,30 +1,30 @@
-require 'cases/helper'
-require 'models/topic'
-require 'models/car'
-require 'models/aircraft'
-require 'models/wheel'
-require 'models/engine'
-require 'models/reply'
-require 'models/category'
-require 'models/categorization'
-require 'models/dog'
-require 'models/dog_lover'
-require 'models/person'
-require 'models/friendship'
-require 'models/subscriber'
-require 'models/subscription'
-require 'models/book'
+require "cases/helper"
+require "models/topic"
+require "models/car"
+require "models/aircraft"
+require "models/wheel"
+require "models/engine"
+require "models/reply"
+require "models/category"
+require "models/categorization"
+require "models/dog"
+require "models/dog_lover"
+require "models/person"
+require "models/friendship"
+require "models/subscriber"
+require "models/subscription"
+require "models/book"
 
 class CounterCacheTest < ActiveRecord::TestCase
   fixtures :topics, :categories, :categorizations, :cars, :dogs, :dog_lovers, :people, :friendships, :subscribers, :subscriptions, :books
 
   class ::SpecialTopic < ::Topic
-    has_many :special_replies, :foreign_key => 'parent_id'
-    has_many :lightweight_special_replies, -> { select('topics.id, topics.title') }, :foreign_key => 'parent_id', :class_name => 'SpecialReply'
+    has_many :special_replies, :foreign_key => "parent_id"
+    has_many :lightweight_special_replies, -> { select("topics.id, topics.title") }, :foreign_key => "parent_id", :class_name => "SpecialReply"
   end
 
   class ::SpecialReply < ::Reply
-    belongs_to :special_topic, :foreign_key => 'parent_id', :counter_cache => 'replies_count'
+    belongs_to :special_topic, :foreign_key => "parent_id", :counter_cache => "replies_count"
   end
 
   setup do
@@ -32,13 +32,13 @@ class CounterCacheTest < ActiveRecord::TestCase
   end
 
   test "increment counter" do
-    assert_difference '@topic.reload.replies_count' do
+    assert_difference "@topic.reload.replies_count" do
       Topic.increment_counter(:replies_count, @topic.id)
     end
   end
 
   test "decrement counter" do
-    assert_difference '@topic.reload.replies_count', -1 do
+    assert_difference "@topic.reload.replies_count", -1 do
       Topic.decrement_counter(:replies_count, @topic.id)
     end
   end
@@ -48,7 +48,7 @@ class CounterCacheTest < ActiveRecord::TestCase
     Topic.increment_counter(:replies_count, @topic.id)
 
     # check that it gets reset
-    assert_difference '@topic.reload.replies_count', -1 do
+    assert_difference "@topic.reload.replies_count", -1 do
       Topic.reset_counters(@topic.id, :replies)
     end
   end
@@ -58,31 +58,31 @@ class CounterCacheTest < ActiveRecord::TestCase
     Topic.increment_counter(:replies_count, @topic.id)
 
     # check that it gets reset
-    assert_difference '@topic.reload.replies_count', -1 do
+    assert_difference "@topic.reload.replies_count", -1 do
       Topic.reset_counters(@topic.id, :replies_count)
     end
   end
 
-  test 'reset multiple counters' do
+  test "reset multiple counters" do
     Topic.update_counters @topic.id, replies_count: 1, unique_replies_count: 1
-    assert_difference ['@topic.reload.replies_count', '@topic.reload.unique_replies_count'], -1 do
+    assert_difference ["@topic.reload.replies_count", "@topic.reload.unique_replies_count"], -1 do
       Topic.reset_counters(@topic.id, :replies, :unique_replies)
     end
   end
 
   test "reset counters with string argument" do
-    Topic.increment_counter('replies_count', @topic.id)
+    Topic.increment_counter("replies_count", @topic.id)
 
-    assert_difference '@topic.reload.replies_count', -1 do
-      Topic.reset_counters(@topic.id, 'replies')
+    assert_difference "@topic.reload.replies_count", -1 do
+      Topic.reset_counters(@topic.id, "replies")
     end
   end
 
   test "reset counters with modularized and camelized classnames" do
-    special = SpecialTopic.create!(:title => 'Special')
+    special = SpecialTopic.create!(:title => "Special")
     SpecialTopic.increment_counter(:replies_count, special.id)
 
-    assert_difference 'special.reload.replies_count', -1 do
+    assert_difference "special.reload.replies_count", -1 do
       SpecialTopic.reset_counters(special.id, :special_replies)
     end
   end
@@ -103,10 +103,10 @@ class CounterCacheTest < ActiveRecord::TestCase
     DogLover.increment_counter(:bred_dogs_count, david.id)
     DogLover.increment_counter(:trained_dogs_count, david.id)
 
-    assert_difference 'david.reload.bred_dogs_count', -1 do
+    assert_difference "david.reload.bred_dogs_count", -1 do
       DogLover.reset_counters(david.id, :bred_dogs)
     end
-    assert_difference 'david.reload.trained_dogs_count', -1 do
+    assert_difference "david.reload.trained_dogs_count", -1 do
       DogLover.reset_counters(david.id, :trained_dogs)
     end
   end
@@ -121,7 +121,7 @@ class CounterCacheTest < ActiveRecord::TestCase
   end
 
   test "update counter for decrement" do
-    assert_difference '@topic.reload.replies_count', -3 do
+    assert_difference "@topic.reload.replies_count", -3 do
       Topic.update_counters(@topic.id, :replies_count => -3)
     end
   end
@@ -129,13 +129,13 @@ class CounterCacheTest < ActiveRecord::TestCase
   test "update counters of multiple records" do
     t1, t2 = topics(:first, :second)
 
-    assert_difference ['t1.reload.replies_count', 't2.reload.replies_count'], 2 do
+    assert_difference ["t1.reload.replies_count", "t2.reload.replies_count"], 2 do
       Topic.update_counters([t1.id, t2.id], :replies_count => 2)
     end
   end
 
-  test 'update multiple counters' do
-    assert_difference ['@topic.reload.replies_count', '@topic.reload.unique_replies_count'], 2 do
+  test "update multiple counters" do
+    assert_difference ["@topic.reload.replies_count", "@topic.reload.unique_replies_count"], 2 do
       Topic.update_counters @topic.id, replies_count: 2, unique_replies_count: 2
     end
   end
@@ -144,7 +144,7 @@ class CounterCacheTest < ActiveRecord::TestCase
     david, joanna = dog_lovers(:david, :joanna)
     joanna = joanna # squelch a warning
 
-    assert_difference 'joanna.reload.dogs_count', -1 do
+    assert_difference "joanna.reload.dogs_count", -1 do
       david.destroy
     end
   end
@@ -157,12 +157,12 @@ class CounterCacheTest < ActiveRecord::TestCase
   end
 
   test "reset counter of has_many :through association" do
-    subscriber = subscribers('second')
-    Subscriber.reset_counters(subscriber.id, 'books')
-    Subscriber.increment_counter('books_count', subscriber.id)
+    subscriber = subscribers("second")
+    Subscriber.reset_counters(subscriber.id, "books")
+    Subscriber.increment_counter("books_count", subscriber.id)
 
-    assert_difference 'subscriber.reload.books_count', -1 do
-      Subscriber.reset_counters(subscriber.id, 'books')
+    assert_difference "subscriber.reload.books_count", -1 do
+      Subscriber.reset_counters(subscriber.id, "books")
     end
   end
 
@@ -174,10 +174,10 @@ class CounterCacheTest < ActiveRecord::TestCase
   end
 
   test "reset counter works with select declared on association" do
-    special = SpecialTopic.create!(:title => 'Special')
+    special = SpecialTopic.create!(:title => "Special")
     SpecialTopic.increment_counter(:replies_count, special.id)
 
-    assert_difference 'special.reload.replies_count', -1 do
+    assert_difference "special.reload.replies_count", -1 do
       SpecialTopic.reset_counters(special.id, :lightweight_special_replies)
     end
   end
@@ -203,11 +203,11 @@ class CounterCacheTest < ActiveRecord::TestCase
   test "update counters in a polymorphic relationship" do
     aircraft = Aircraft.create!
 
-    assert_difference 'aircraft.reload.wheels_count' do
+    assert_difference "aircraft.reload.wheels_count" do
       aircraft.wheels << Wheel.create!
     end
 
-    assert_difference 'aircraft.reload.wheels_count', -1 do
+    assert_difference "aircraft.reload.wheels_count", -1 do
       aircraft.wheels.first.destroy
     end
   end
diff --git a/activerecord/test/cases/custom_locking_test.rb b/activerecord/test/cases/custom_locking_test.rb
index 26d015bf71..bec4311545 100644
--- a/activerecord/test/cases/custom_locking_test.rb
+++ b/activerecord/test/cases/custom_locking_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'models/person'
+require "models/person"
 
 module ActiveRecord
   class CustomLockingTest < ActiveRecord::TestCase
@@ -7,9 +7,9 @@ module ActiveRecord
 
     def test_custom_lock
       if current_adapter?(:Mysql2Adapter)
-        assert_match 'SHARE MODE', Person.lock('LOCK IN SHARE MODE').to_sql
+        assert_match "SHARE MODE", Person.lock("LOCK IN SHARE MODE").to_sql
         assert_sql(/LOCK IN SHARE MODE/) do
-          Person.all.merge!(:lock => 'LOCK IN SHARE MODE').find(1)
+          Person.all.merge!(:lock => "LOCK IN SHARE MODE").find(1)
         end
       end
     end
diff --git a/activerecord/test/cases/date_test.rb b/activerecord/test/cases/date_test.rb
index f112081c14..e8a86d0e33 100644
--- a/activerecord/test/cases/date_test.rb
+++ b/activerecord/test/cases/date_test.rb
@@ -1,5 +1,5 @@
-require 'cases/helper'
-require 'models/topic'
+require "cases/helper"
+require "models/topic"
 
 class DateTest < ActiveRecord::TestCase
   def test_date_with_time_value
@@ -9,7 +9,7 @@ class DateTest < ActiveRecord::TestCase
   end
 
   def test_date_with_string_value
-    string_value = '2016-05-11 19:00:00'
+    string_value = "2016-05-11 19:00:00"
     topic = Topic.create(last_read: string_value)
     assert_equal topic, Topic.find_by(last_read: string_value)
   end
diff --git a/activerecord/test/cases/date_time_precision_test.rb b/activerecord/test/cases/date_time_precision_test.rb
index f8664d83bd..40c68f9dc8 100644
--- a/activerecord/test/cases/date_time_precision_test.rb
+++ b/activerecord/test/cases/date_time_precision_test.rb
@@ -1,5 +1,5 @@
-require 'cases/helper'
-require 'support/schema_dumping_helper'
+require "cases/helper"
+require "support/schema_dumping_helper"
 
 if subsecond_precision_supported?
 class DateTimePrecisionTest < ActiveRecord::TestCase
@@ -21,24 +21,24 @@ class DateTimePrecisionTest < ActiveRecord::TestCase
     @connection.create_table(:foos, force: true)
     @connection.add_column :foos, :created_at, :datetime, precision: 0
     @connection.add_column :foos, :updated_at, :datetime, precision: 5
-    assert_equal 0, Foo.columns_hash['created_at'].precision
-    assert_equal 5, Foo.columns_hash['updated_at'].precision
+    assert_equal 0, Foo.columns_hash["created_at"].precision
+    assert_equal 5, Foo.columns_hash["updated_at"].precision
   end
 
   def test_timestamps_helper_with_custom_precision
     @connection.create_table(:foos, force: true) do |t|
       t.timestamps precision: 4
     end
-    assert_equal 4, Foo.columns_hash['created_at'].precision
-    assert_equal 4, Foo.columns_hash['updated_at'].precision
+    assert_equal 4, Foo.columns_hash["created_at"].precision
+    assert_equal 4, Foo.columns_hash["updated_at"].precision
   end
 
   def test_passing_precision_to_datetime_does_not_set_limit
     @connection.create_table(:foos, force: true) do |t|
       t.timestamps precision: 4
     end
-    assert_nil Foo.columns_hash['created_at'].limit
-    assert_nil Foo.columns_hash['updated_at'].limit
+    assert_nil Foo.columns_hash["created_at"].limit
+    assert_nil Foo.columns_hash["updated_at"].limit
   end
 
   def test_invalid_datetime_precision_raises_error
diff --git a/activerecord/test/cases/date_time_test.rb b/activerecord/test/cases/date_time_test.rb
index 4cbff564aa..3bc08f80ec 100644
--- a/activerecord/test/cases/date_time_test.rb
+++ b/activerecord/test/cases/date_time_test.rb
@@ -1,12 +1,12 @@
 require "cases/helper"
-require 'models/topic'
-require 'models/task'
+require "models/topic"
+require "models/task"
 
 class DateTimeTest < ActiveRecord::TestCase
   include InTimeZone
 
   def test_saves_both_date_and_time
-    with_env_tz 'America/New_York' do
+    with_env_tz "America/New_York" do
       with_timezone_config default: :utc do
         time_values = [1807, 2, 10, 15, 30, 45]
         # create DateTime value with local time zone offset
@@ -25,7 +25,7 @@ class DateTimeTest < ActiveRecord::TestCase
 
   def test_assign_empty_date_time
     task = Task.new
-    task.starting = ''
+    task.starting = ""
     task.ending = nil
     assert_nil task.starting
     assert_nil task.ending
@@ -34,20 +34,20 @@ class DateTimeTest < ActiveRecord::TestCase
   def test_assign_bad_date_time_with_timezone
     in_time_zone "Pacific Time (US & Canada)" do
       task = Task.new
-      task.starting = '2014-07-01T24:59:59GMT'
+      task.starting = "2014-07-01T24:59:59GMT"
       assert_nil task.starting
     end
   end
 
   def test_assign_empty_date
     topic = Topic.new
-    topic.last_read = ''
+    topic.last_read = ""
     assert_nil topic.last_read
   end
 
   def test_assign_empty_time
     topic = Topic.new
-    topic.bonus_time = ''
+    topic.bonus_time = ""
     assert_nil topic.bonus_time
   end
 
diff --git a/activerecord/test/cases/defaults_test.rb b/activerecord/test/cases/defaults_test.rb
index 067513e24c..f03610bcd3 100644
--- a/activerecord/test/cases/defaults_test.rb
+++ b/activerecord/test/cases/defaults_test.rb
@@ -1,7 +1,7 @@
 require "cases/helper"
-require 'support/schema_dumping_helper'
-require 'models/default'
-require 'models/entrant'
+require "support/schema_dumping_helper"
+require "models/default"
+require "models/entrant"
 
 class DefaultTest < ActiveRecord::TestCase
   def test_nil_defaults_for_not_null_columns
@@ -99,7 +99,7 @@ if current_adapter?(:Mysql2Adapter)
   class MysqlDefaultExpressionTest < ActiveRecord::TestCase
     include SchemaDumpingHelper
 
-    if ActiveRecord::Base.connection.version >= '5.6.0'
+    if ActiveRecord::Base.connection.version >= "5.6.0"
       test "schema dump includes default expression" do
         output = dump_table_schema("datetime_defaults")
         assert_match %r/t\.datetime\s+"modified_datetime",\s+default: -> { "CURRENT_TIMESTAMP" }/, output
@@ -142,8 +142,8 @@ if current_adapter?(:Mysql2Adapter)
       using_strict(false) do
         with_text_blob_not_null_table do |klass|
           record = klass.new
-          assert_equal '', record.non_null_blob
-          assert_equal '', record.non_null_text
+          assert_equal "", record.non_null_blob
+          assert_equal "", record.non_null_text
 
           assert_nil record.null_blob
           assert_nil record.null_text
@@ -151,8 +151,8 @@ if current_adapter?(:Mysql2Adapter)
           record.save!
           record.reload
 
-          assert_equal '', record.non_null_text
-          assert_equal '', record.non_null_blob
+          assert_equal "", record.non_null_text
+          assert_equal "", record.non_null_blob
 
           assert_nil record.null_text
           assert_nil record.null_blob
@@ -176,7 +176,7 @@ if current_adapter?(:Mysql2Adapter)
 
     def with_text_blob_not_null_table
       klass = Class.new(ActiveRecord::Base)
-      klass.table_name = 'test_mysql_text_not_null_defaults'
+      klass.table_name = "test_mysql_text_not_null_defaults"
       klass.connection.create_table klass.table_name do |t|
         t.column :non_null_text, :text, :null => false
         t.column :non_null_blob, :blob, :null => false
@@ -193,16 +193,16 @@ if current_adapter?(:Mysql2Adapter)
     # We use an implicit NULL so schema.rb is compatible with other databases.
     def test_mysql_integer_not_null_defaults
       klass = Class.new(ActiveRecord::Base)
-      klass.table_name = 'test_integer_not_null_default_zero'
+      klass.table_name = "test_integer_not_null_default_zero"
       klass.connection.create_table klass.table_name do |t|
         t.column :zero, :integer, :null => false, :default => 0
         t.column :omit, :integer, :null => false
       end
 
-      assert_equal '0', klass.columns_hash['zero'].default
-      assert !klass.columns_hash['zero'].null
-      assert_equal nil, klass.columns_hash['omit'].default
-      assert !klass.columns_hash['omit'].null
+      assert_equal "0", klass.columns_hash["zero"].default
+      assert !klass.columns_hash["zero"].null
+      assert_equal nil, klass.columns_hash["omit"].default
+      assert !klass.columns_hash["omit"].null
 
       assert_raise(ActiveRecord::StatementInvalid) { klass.create! }
 
diff --git a/activerecord/test/cases/dirty_test.rb b/activerecord/test/cases/dirty_test.rb
index 3c58b6ad09..382ca7c6ac 100644
--- a/activerecord/test/cases/dirty_test.rb
+++ b/activerecord/test/cases/dirty_test.rb
@@ -1,12 +1,12 @@
-require 'cases/helper'
-require 'models/topic'    # For booleans
-require 'models/pirate'   # For timestamps
-require 'models/parrot'
-require 'models/person'   # For optimistic locking
-require 'models/aircraft'
+require "cases/helper"
+require "models/topic"    # For booleans
+require "models/pirate"   # For timestamps
+require "models/parrot"
+require "models/person"   # For optimistic locking
+require "models/aircraft"
 
 class NumericData < ActiveRecord::Base
-  self.table_name = 'numeric_data'
+  self.table_name = "numeric_data"
 end
 
 class DirtyTest < ActiveRecord::TestCase
@@ -14,7 +14,7 @@ class DirtyTest < ActiveRecord::TestCase
 
   # Dummy to force column loads so query counts are clean.
   def setup
-    Person.create :first_name => 'foo'
+    Person.create :first_name => "foo"
   end
 
   def test_attribute_changes
@@ -24,10 +24,10 @@ class DirtyTest < ActiveRecord::TestCase
     assert_equal false, pirate.non_validated_parrot_id_changed?
 
     # Change catchphrase.
-    pirate.catchphrase = 'arrr'
+    pirate.catchphrase = "arrr"
     assert pirate.catchphrase_changed?
     assert_nil pirate.catchphrase_was
-    assert_equal [nil, 'arrr'], pirate.catchphrase_change
+    assert_equal [nil, "arrr"], pirate.catchphrase_change
 
     # Saved - no changes.
     pirate.save!
@@ -35,15 +35,15 @@ class DirtyTest < ActiveRecord::TestCase
     assert_nil pirate.catchphrase_change
 
     # Same value - no changes.
-    pirate.catchphrase = 'arrr'
+    pirate.catchphrase = "arrr"
     assert !pirate.catchphrase_changed?
     assert_nil pirate.catchphrase_change
   end
 
   def test_time_attributes_changes_with_time_zone
-    in_time_zone 'Paris' do
+    in_time_zone "Paris" do
       target = Class.new(ActiveRecord::Base)
-      target.table_name = 'pirates'
+      target.table_name = "pirates"
 
       # New record - no changes.
       pirate = target.new
@@ -51,7 +51,7 @@ class DirtyTest < ActiveRecord::TestCase
       assert_nil pirate.created_on_change
 
       # Saved - no changes.
-      pirate.catchphrase = 'arrrr, time zone!!'
+      pirate.catchphrase = "arrrr, time zone!!"
       pirate.save!
       assert !pirate.created_on_changed?
       assert_nil pirate.created_on_change
@@ -68,9 +68,9 @@ class DirtyTest < ActiveRecord::TestCase
   end
 
   def test_setting_time_attributes_with_time_zone_field_to_itself_should_not_be_marked_as_a_change
-    in_time_zone 'Paris' do
+    in_time_zone "Paris" do
       target = Class.new(ActiveRecord::Base)
-      target.table_name = 'pirates'
+      target.table_name = "pirates"
 
       pirate = target.create!
       pirate.created_on = pirate.created_on
@@ -79,9 +79,9 @@ class DirtyTest < ActiveRecord::TestCase
   end
 
   def test_time_attributes_changes_without_time_zone_by_skip
-    in_time_zone 'Paris' do
+    in_time_zone "Paris" do
       target = Class.new(ActiveRecord::Base)
-      target.table_name = 'pirates'
+      target.table_name = "pirates"
 
       target.skip_time_zone_conversion_for_attributes = [:created_on]
 
@@ -91,7 +91,7 @@ class DirtyTest < ActiveRecord::TestCase
       assert_nil pirate.created_on_change
 
       # Saved - no changes.
-      pirate.catchphrase = 'arrrr, time zone!!'
+      pirate.catchphrase = "arrrr, time zone!!"
       pirate.save!
       assert !pirate.created_on_changed?
       assert_nil pirate.created_on_change
@@ -110,7 +110,7 @@ class DirtyTest < ActiveRecord::TestCase
   def test_time_attributes_changes_without_time_zone
     with_timezone_config aware_attributes: false do
       target = Class.new(ActiveRecord::Base)
-      target.table_name = 'pirates'
+      target.table_name = "pirates"
 
       # New record - no changes.
       pirate = target.new
@@ -118,7 +118,7 @@ class DirtyTest < ActiveRecord::TestCase
       assert_nil pirate.created_on_change
 
       # Saved - no changes.
-      pirate.catchphrase = 'arrrr, time zone!!'
+      pirate.catchphrase = "arrrr, time zone!!"
       pirate.save!
       assert !pirate.created_on_changed?
       assert_nil pirate.created_on_change
@@ -142,15 +142,15 @@ class DirtyTest < ActiveRecord::TestCase
     assert !parrot.title_changed?
     assert_nil parrot.title_change
 
-    parrot.name = 'Sam'
+    parrot.name = "Sam"
     assert parrot.title_changed?
     assert_nil parrot.title_was
     assert_equal parrot.name_change, parrot.title_change
   end
 
   def test_restore_attribute!
-    pirate = Pirate.create!(:catchphrase => 'Yar!')
-    pirate.catchphrase = 'Ahoy!'
+    pirate = Pirate.create!(:catchphrase => "Yar!")
+    pirate.catchphrase = "Ahoy!"
 
     pirate.restore_catchphrase!
     assert_equal "Yar!", pirate.catchphrase
@@ -189,9 +189,9 @@ class DirtyTest < ActiveRecord::TestCase
   end
 
   def test_nullable_datetime_not_marked_as_changed_if_new_value_is_blank
-    in_time_zone 'Edinburgh' do
+    in_time_zone "Edinburgh" do
       target = Class.new(ActiveRecord::Base)
-      target.table_name = 'topics'
+      target.table_name = "topics"
 
       topic = target.create
       assert_nil topic.written_on
@@ -207,19 +207,19 @@ class DirtyTest < ActiveRecord::TestCase
   def test_integer_zero_to_string_zero_not_marked_as_changed
     pirate = Pirate.new
     pirate.parrot_id = 0
-    pirate.catchphrase = 'arrr'
+    pirate.catchphrase = "arrr"
     assert pirate.save!
 
     assert !pirate.changed?
 
-    pirate.parrot_id = '0'
+    pirate.parrot_id = "0"
     assert !pirate.changed?
   end
 
   def test_integer_zero_to_integer_zero_not_marked_as_changed
     pirate = Pirate.new
     pirate.parrot_id = 0
-    pirate.catchphrase = 'arrr'
+    pirate.catchphrase = "arrr"
     assert pirate.save!
 
     assert !pirate.changed?
@@ -234,13 +234,13 @@ class DirtyTest < ActiveRecord::TestCase
 
     assert_not data.changed?
 
-    data.temperature = '0'
+    data.temperature = "0"
     assert_empty data.changes
 
-    data.temperature = '0.0'
+    data.temperature = "0.0"
     assert_empty data.changes
 
-    data.temperature = '0.00'
+    data.temperature = "0.00"
     assert_empty data.changes
   end
 
@@ -252,7 +252,7 @@ class DirtyTest < ActiveRecord::TestCase
 
     # check the change from 1 to ''
     pirate = Pirate.find_by_catchphrase("Yarrrr, me hearties")
-    pirate.parrot_id = ''
+    pirate.parrot_id = ""
     assert pirate.parrot_id_changed?
     assert_equal([1, nil], pirate.parrot_id_change)
     pirate.save
@@ -266,7 +266,7 @@ class DirtyTest < ActiveRecord::TestCase
 
     # check the change from 0 to ''
     pirate = Pirate.find_by_catchphrase("Yarrrr, me hearties")
-    pirate.parrot_id = ''
+    pirate.parrot_id = ""
     assert pirate.parrot_id_changed?
     assert_equal([0, nil], pirate.parrot_id_change)
   end
@@ -277,11 +277,11 @@ class DirtyTest < ActiveRecord::TestCase
     assert_equal [], pirate.changed
     assert_equal Hash.new, pirate.changes
 
-    pirate.catchphrase = 'arrr'
+    pirate.catchphrase = "arrr"
     assert pirate.changed?
     assert_nil pirate.catchphrase_was
     assert_equal %w(catchphrase), pirate.changed
-    assert_equal({'catchphrase' => [nil, 'arrr']}, pirate.changes)
+    assert_equal({"catchphrase" => [nil, "arrr"]}, pirate.changes)
 
     pirate.save
     assert !pirate.changed?
@@ -290,21 +290,21 @@ class DirtyTest < ActiveRecord::TestCase
   end
 
   def test_attribute_will_change!
-    pirate = Pirate.create!(:catchphrase => 'arr')
+    pirate = Pirate.create!(:catchphrase => "arr")
 
     assert !pirate.catchphrase_changed?
     assert pirate.catchphrase_will_change!
     assert pirate.catchphrase_changed?
-    assert_equal ['arr', 'arr'], pirate.catchphrase_change
+    assert_equal ["arr", "arr"], pirate.catchphrase_change
 
-    pirate.catchphrase << ' matey!'
+    pirate.catchphrase << " matey!"
     assert pirate.catchphrase_changed?
-    assert_equal ['arr', 'arr matey!'], pirate.catchphrase_change
+    assert_equal ["arr", "arr matey!"], pirate.catchphrase_change
   end
 
   def test_association_assignment_changes_foreign_key
-    pirate = Pirate.create!(:catchphrase => 'jarl')
-    pirate.parrot = Parrot.create!(:name => 'Lorre')
+    pirate = Pirate.create!(:catchphrase => "jarl")
+    pirate.parrot = Parrot.create!(:name => "Lorre")
     assert pirate.changed?
     assert_equal %w(parrot_id), pirate.changed
   end
@@ -323,7 +323,7 @@ class DirtyTest < ActiveRecord::TestCase
   end
 
   def test_partial_update
-    pirate = Pirate.new(:catchphrase => 'foo')
+    pirate = Pirate.new(:catchphrase => "foo")
     old_updated_on = 1.hour.ago.beginning_of_day
 
     with_partial_writes Pirate, false do
@@ -335,25 +335,25 @@ class DirtyTest < ActiveRecord::TestCase
       assert_queries(0) { 2.times { pirate.save! } }
       assert_equal old_updated_on, pirate.reload.updated_on
 
-      assert_queries(1) { pirate.catchphrase = 'bar'; pirate.save! }
+      assert_queries(1) { pirate.catchphrase = "bar"; pirate.save! }
       assert_not_equal old_updated_on, pirate.reload.updated_on
     end
   end
 
   def test_partial_update_with_optimistic_locking
-    person = Person.new(:first_name => 'foo')
+    person = Person.new(:first_name => "foo")
     old_lock_version = 1
 
     with_partial_writes Person, false do
       assert_queries(2) { 2.times { person.save! } }
-      Person.where(id: person.id).update_all(:first_name => 'baz')
+      Person.where(id: person.id).update_all(:first_name => "baz")
     end
 
     with_partial_writes Person, true do
       assert_queries(0) { 2.times { person.save! } }
       assert_equal old_lock_version, person.reload.lock_version
 
-      assert_queries(1) { person.first_name = 'bar'; person.save! }
+      assert_queries(1) { person.first_name = "bar"; person.save! }
       assert_not_equal old_lock_version, person.reload.lock_version
     end
   end
@@ -451,20 +451,20 @@ class DirtyTest < ActiveRecord::TestCase
 
       updated_at = topic.updated_at
       travel(1.second) do
-        topic.content[:hello] = 'world'
+        topic.content[:hello] = "world"
         topic.save!
       end
 
       assert_not_equal updated_at, topic.updated_at
-      assert_equal 'world', topic.content[:hello]
+      assert_equal "world", topic.content[:hello]
     end
   end
 
   def test_save_should_not_save_serialized_attribute_with_partial_writes_if_not_present
     with_partial_writes(Topic) do
-      Topic.create!(:author_name => 'Bill', :content => {:a => "a"})
-      topic = Topic.select('id, author_name').first
-      topic.update_columns author_name: 'John'
+      Topic.create!(:author_name => "Bill", :content => {:a => "a"})
+      topic = Topic.select("id, author_name").first
+      topic.update_columns author_name: "John"
       topic = Topic.first
       assert_not_nil topic.content
     end
@@ -479,13 +479,13 @@ class DirtyTest < ActiveRecord::TestCase
     pirate.save!
 
     assert_equal 4, pirate.previous_changes.size
-    assert_equal [nil, "arrr"], pirate.previous_changes['catchphrase']
-    assert_equal [nil, pirate.id], pirate.previous_changes['id']
-    assert_nil pirate.previous_changes['updated_on'][0]
-    assert_not_nil pirate.previous_changes['updated_on'][1]
-    assert_nil pirate.previous_changes['created_on'][0]
-    assert_not_nil pirate.previous_changes['created_on'][1]
-    assert !pirate.previous_changes.key?('parrot_id')
+    assert_equal [nil, "arrr"], pirate.previous_changes["catchphrase"]
+    assert_equal [nil, pirate.id], pirate.previous_changes["id"]
+    assert_nil pirate.previous_changes["updated_on"][0]
+    assert_not_nil pirate.previous_changes["updated_on"][1]
+    assert_nil pirate.previous_changes["created_on"][0]
+    assert_not_nil pirate.previous_changes["created_on"][1]
+    assert !pirate.previous_changes.key?("parrot_id")
 
     # original values should be in previous_changes
     pirate = Pirate.new
@@ -495,11 +495,11 @@ class DirtyTest < ActiveRecord::TestCase
     pirate.save
 
     assert_equal 4, pirate.previous_changes.size
-    assert_equal [nil, "arrr"], pirate.previous_changes['catchphrase']
-    assert_equal [nil, pirate.id], pirate.previous_changes['id']
-    assert pirate.previous_changes.include?('updated_on')
-    assert pirate.previous_changes.include?('created_on')
-    assert !pirate.previous_changes.key?('parrot_id')
+    assert_equal [nil, "arrr"], pirate.previous_changes["catchphrase"]
+    assert_equal [nil, pirate.id], pirate.previous_changes["id"]
+    assert pirate.previous_changes.include?("updated_on")
+    assert pirate.previous_changes.include?("created_on")
+    assert !pirate.previous_changes.key?("parrot_id")
 
     pirate.catchphrase = "Yar!!"
     pirate.reload
@@ -513,11 +513,11 @@ class DirtyTest < ActiveRecord::TestCase
     pirate.save!
 
     assert_equal 2, pirate.previous_changes.size
-    assert_equal ["arrr", "Me Maties!"], pirate.previous_changes['catchphrase']
-    assert_not_nil pirate.previous_changes['updated_on'][0]
-    assert_not_nil pirate.previous_changes['updated_on'][1]
-    assert !pirate.previous_changes.key?('parrot_id')
-    assert !pirate.previous_changes.key?('created_on')
+    assert_equal ["arrr", "Me Maties!"], pirate.previous_changes["catchphrase"]
+    assert_not_nil pirate.previous_changes["updated_on"][0]
+    assert_not_nil pirate.previous_changes["updated_on"][1]
+    assert !pirate.previous_changes.key?("parrot_id")
+    assert !pirate.previous_changes.key?("created_on")
 
     pirate = Pirate.find_by_catchphrase("Me Maties!")
 
@@ -527,11 +527,11 @@ class DirtyTest < ActiveRecord::TestCase
     pirate.save
 
     assert_equal 2, pirate.previous_changes.size
-    assert_equal ["Me Maties!", "Thar She Blows!"], pirate.previous_changes['catchphrase']
-    assert_not_nil pirate.previous_changes['updated_on'][0]
-    assert_not_nil pirate.previous_changes['updated_on'][1]
-    assert !pirate.previous_changes.key?('parrot_id')
-    assert !pirate.previous_changes.key?('created_on')
+    assert_equal ["Me Maties!", "Thar She Blows!"], pirate.previous_changes["catchphrase"]
+    assert_not_nil pirate.previous_changes["updated_on"][0]
+    assert_not_nil pirate.previous_changes["updated_on"][1]
+    assert !pirate.previous_changes.key?("parrot_id")
+    assert !pirate.previous_changes.key?("created_on")
 
     travel(1.second)
 
@@ -539,11 +539,11 @@ class DirtyTest < ActiveRecord::TestCase
     pirate.update(catchphrase: "Ahoy!")
 
     assert_equal 2, pirate.previous_changes.size
-    assert_equal ["Thar She Blows!", "Ahoy!"], pirate.previous_changes['catchphrase']
-    assert_not_nil pirate.previous_changes['updated_on'][0]
-    assert_not_nil pirate.previous_changes['updated_on'][1]
-    assert !pirate.previous_changes.key?('parrot_id')
-    assert !pirate.previous_changes.key?('created_on')
+    assert_equal ["Thar She Blows!", "Ahoy!"], pirate.previous_changes["catchphrase"]
+    assert_not_nil pirate.previous_changes["updated_on"][0]
+    assert_not_nil pirate.previous_changes["updated_on"][1]
+    assert !pirate.previous_changes.key?("parrot_id")
+    assert !pirate.previous_changes.key?("created_on")
 
     travel(1.second)
 
@@ -551,11 +551,11 @@ class DirtyTest < ActiveRecord::TestCase
     pirate.update_attribute(:catchphrase, "Ninjas suck!")
 
     assert_equal 2, pirate.previous_changes.size
-    assert_equal ["Ahoy!", "Ninjas suck!"], pirate.previous_changes['catchphrase']
-    assert_not_nil pirate.previous_changes['updated_on'][0]
-    assert_not_nil pirate.previous_changes['updated_on'][1]
-    assert !pirate.previous_changes.key?('parrot_id')
-    assert !pirate.previous_changes.key?('created_on')
+    assert_equal ["Ahoy!", "Ninjas suck!"], pirate.previous_changes["catchphrase"]
+    assert_not_nil pirate.previous_changes["updated_on"][0]
+    assert_not_nil pirate.previous_changes["updated_on"][1]
+    assert !pirate.previous_changes.key?("parrot_id")
+    assert !pirate.previous_changes.key?("created_on")
   ensure
     travel_back
   end
@@ -576,24 +576,24 @@ class DirtyTest < ActiveRecord::TestCase
 
   def test_datetime_attribute_can_be_updated_with_fractional_seconds
     skip "Fractional seconds are not supported" unless subsecond_precision_supported?
-    in_time_zone 'Paris' do
+    in_time_zone "Paris" do
       target = Class.new(ActiveRecord::Base)
-      target.table_name = 'topics'
+      target.table_name = "topics"
 
-      written_on = Time.utc(2012, 12, 1, 12, 0, 0).in_time_zone('Paris')
+      written_on = Time.utc(2012, 12, 1, 12, 0, 0).in_time_zone("Paris")
 
       topic = target.create(:written_on => written_on)
       topic.written_on += 0.3
 
-      assert topic.written_on_changed?, 'Fractional second update not detected'
+      assert topic.written_on_changed?, "Fractional second update not detected"
     end
   end
 
   def test_datetime_attribute_doesnt_change_if_zone_is_modified_in_string
-    time_in_paris = Time.utc(2014, 1, 1, 12, 0, 0).in_time_zone('Paris')
-    pirate = Pirate.create!(:catchphrase => 'rrrr', :created_on => time_in_paris)
+    time_in_paris = Time.utc(2014, 1, 1, 12, 0, 0).in_time_zone("Paris")
+    pirate = Pirate.create!(:catchphrase => "rrrr", :created_on => time_in_paris)
 
-    pirate.created_on = pirate.created_on.in_time_zone('Tokyo').to_s
+    pirate.created_on = pirate.created_on.in_time_zone("Tokyo").to_s
     assert !pirate.created_on_changed?
   end
 
@@ -601,13 +601,13 @@ class DirtyTest < ActiveRecord::TestCase
     with_partial_writes Person do
       jon = nil
       assert_sql(/first_name/i) do
-        jon = Person.create! first_name: 'Jon'
+        jon = Person.create! first_name: "Jon"
       end
 
-      assert ActiveRecord::SQLCounter.log_all.none? { |sql| sql.include?('followers_count') }
+      assert ActiveRecord::SQLCounter.log_all.none? { |sql| sql.include?("followers_count") }
 
       jon.reload
-      assert_equal 'Jon', jon.first_name
+      assert_equal "Jon", jon.first_name
       assert_equal 0, jon.followers_count
       assert_not_nil jon.id
     end
@@ -672,7 +672,7 @@ class DirtyTest < ActiveRecord::TestCase
       end
     end
     klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'people'
+      self.table_name = "people"
       attribute :foo, test_type_class.new
     end
 
@@ -682,7 +682,7 @@ class DirtyTest < ActiveRecord::TestCase
 
   test "attribute_will_change! doesn't try to save non-persistable attributes" do
     klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'people'
+      self.table_name = "people"
       attribute :non_persisted_attribute, :string
     end
 
diff --git a/activerecord/test/cases/dup_test.rb b/activerecord/test/cases/dup_test.rb
index 638cffe0e6..4e8b8db11c 100644
--- a/activerecord/test/cases/dup_test.rb
+++ b/activerecord/test/cases/dup_test.rb
@@ -1,6 +1,6 @@
 require "cases/helper"
-require 'models/reply'
-require 'models/topic'
+require "models/reply"
+require "models/topic"
 
 module ActiveRecord
   class DupTest < ActiveRecord::TestCase
@@ -14,7 +14,7 @@ module ActiveRecord
       topic = Topic.first
 
       duped = topic.dup
-      assert !duped.readonly?, 'should not be readonly'
+      assert !duped.readonly?, "should not be readonly"
     end
 
     def test_is_readonly
@@ -22,15 +22,15 @@ module ActiveRecord
       topic.readonly!
 
       duped = topic.dup
-      assert duped.readonly?, 'should be readonly'
+      assert duped.readonly?, "should be readonly"
     end
 
     def test_dup_not_persisted
       topic = Topic.first
       duped = topic.dup
 
-      assert !duped.persisted?, 'topic not persisted'
-      assert duped.new_record?, 'topic is new'
+      assert !duped.persisted?, "topic not persisted"
+      assert duped.new_record?, "topic is new"
     end
 
     def test_dup_not_destroyed
@@ -49,9 +49,9 @@ module ActiveRecord
 
     def test_dup_with_modified_attributes
       topic = Topic.first
-      topic.author_name = 'Aaron'
+      topic.author_name = "Aaron"
       duped = topic.dup
-      assert_equal 'Aaron', duped.author_name
+      assert_equal "Aaron", duped.author_name
     end
 
     def test_dup_with_changes
@@ -71,10 +71,10 @@ module ActiveRecord
 
     def test_dup_topics_are_independent
       topic = Topic.first
-      topic.author_name = 'Aaron'
+      topic.author_name = "Aaron"
       duped = topic.dup
 
-      duped.author_name = 'meow'
+      duped.author_name = "meow"
 
       assert_not_equal topic.changes, duped.changes
     end
@@ -83,11 +83,11 @@ module ActiveRecord
       topic = Topic.first
       duped = topic.dup
 
-      duped.author_name = 'meow'
-      topic.author_name = 'Aaron'
+      duped.author_name = "meow"
+      topic.author_name = "Aaron"
 
-      assert_equal 'Aaron', topic.author_name
-      assert_equal 'meow', duped.author_name
+      assert_equal "Aaron", topic.author_name
+      assert_equal "meow", duped.author_name
     end
 
     def test_dup_timestamps_are_cleared
@@ -127,7 +127,7 @@ module ActiveRecord
         assert duped.invalid?
 
         topic.title = nil
-        duped.title = 'Mathematics'
+        duped.title = "Mathematics"
         assert topic.invalid?
         assert duped.valid?
       end
@@ -144,7 +144,7 @@ module ActiveRecord
 
     def test_dup_without_primary_key
       klass = Class.new(ActiveRecord::Base) do
-        self.table_name = 'parrots_pirates'
+        self.table_name = "parrots_pirates"
       end
 
       record = klass.create!
diff --git a/activerecord/test/cases/enum_test.rb b/activerecord/test/cases/enum_test.rb
index 1ee6f71d08..c2009843f0 100644
--- a/activerecord/test/cases/enum_test.rb
+++ b/activerecord/test/cases/enum_test.rb
@@ -1,5 +1,5 @@
-require 'cases/helper'
-require 'models/book'
+require "cases/helper"
+require "models/book"
 
 class EnumTest < ActiveRecord::TestCase
   fixtures :books
@@ -122,8 +122,8 @@ class EnumTest < ActiveRecord::TestCase
     old_language = @book.language
     @book.status = :proposed
     @book.language = :spanish
-    assert_equal [old_status, 'proposed'], @book.changes[:status]
-    assert_equal [old_language, 'spanish'], @book.changes[:language]
+    assert_equal [old_status, "proposed"], @book.changes[:status]
+    assert_equal [old_language, "spanish"], @book.changes[:language]
   end
 
   test "enum attribute was" do
@@ -145,8 +145,8 @@ class EnumTest < ActiveRecord::TestCase
   test "enum attribute changed to" do
     @book.status = :proposed
     @book.language = :french
-    assert @book.attribute_changed?(:status, to: 'proposed')
-    assert @book.attribute_changed?(:language, to: 'french')
+    assert @book.attribute_changed?(:status, to: "proposed")
+    assert @book.attribute_changed?(:language, to: "french")
   end
 
   test "enum attribute changed from" do
@@ -163,8 +163,8 @@ class EnumTest < ActiveRecord::TestCase
     old_language = @book.language
     @book.status = :proposed
     @book.language = :french
-    assert @book.attribute_changed?(:status, from: old_status, to: 'proposed')
-    assert @book.attribute_changed?(:language, from: old_language, to: 'french')
+    assert @book.attribute_changed?(:status, from: old_status, to: "proposed")
+    assert @book.attribute_changed?(:language, from: old_language, to: "french")
   end
 
   test "enum didn't change" do
@@ -216,12 +216,12 @@ class EnumTest < ActiveRecord::TestCase
   end
 
   test "assign empty string value" do
-    @book.status = ''
+    @book.status = ""
     assert_nil @book.status
   end
 
   test "assign long empty string value" do
-    @book.status = '   '
+    @book.status = "   "
     assert_nil @book.status
   end
 
@@ -318,7 +318,7 @@ class EnumTest < ActiveRecord::TestCase
 
   test "validate uniqueness" do
     klass = Class.new(ActiveRecord::Base) do
-      def self.name; 'Book'; end
+      def self.name; "Book"; end
       enum status: [:proposed, :written]
       validates_uniqueness_of :status
     end
@@ -332,7 +332,7 @@ class EnumTest < ActiveRecord::TestCase
 
   test "validate inclusion of value in array" do
     klass = Class.new(ActiveRecord::Base) do
-      def self.name; 'Book'; end
+      def self.name; "Book"; end
       enum status: [:proposed, :written]
       validates_inclusion_of :status, in: ["written"]
     end
@@ -356,11 +356,11 @@ class EnumTest < ActiveRecord::TestCase
 
     book1 = klass1.proposed.create!
     book1.status = :written
-    assert_equal ['proposed', 'written'], book1.status_change
+    assert_equal ["proposed", "written"], book1.status_change
 
     book2 = klass2.drafted.create!
     book2.status = :uploaded
-    assert_equal ['drafted', 'uploaded'], book2.status_change
+    assert_equal ["drafted", "uploaded"], book2.status_change
   end
 
   test "enums are inheritable" do
@@ -372,11 +372,11 @@ class EnumTest < ActiveRecord::TestCase
 
     book1 = subklass1.proposed.create!
     book1.status = :written
-    assert_equal ['proposed', 'written'], book1.status_change
+    assert_equal ["proposed", "written"], book1.status_change
 
     book2 = subklass2.drafted.create!
     book2.status = :uploaded
-    assert_equal ['drafted', 'uploaded'], book2.status_change
+    assert_equal ["drafted", "uploaded"], book2.status_change
   end
 
   test "declare multiple enums at a time" do
@@ -402,11 +402,11 @@ class EnumTest < ActiveRecord::TestCase
 
     book = klass.proposed.create!
     assert book.proposed?
-    assert_equal 'proposed', book.aliased_status
+    assert_equal "proposed", book.aliased_status
 
     book = klass.find(book.id)
     assert book.proposed?
-    assert_equal 'proposed', book.aliased_status
+    assert_equal "proposed", book.aliased_status
   end
 
   test "query state by predicate with prefix" do
@@ -439,6 +439,6 @@ class EnumTest < ActiveRecord::TestCase
   end
 
   test "data type of Enum type" do
-    assert_equal :integer, Book.type_for_attribute('status').type
+    assert_equal :integer, Book.type_for_attribute("status").type
   end
 end
diff --git a/activerecord/test/cases/explain_subscriber_test.rb b/activerecord/test/cases/explain_subscriber_test.rb
index 2dee8a26a5..ca87e04012 100644
--- a/activerecord/test/cases/explain_subscriber_test.rb
+++ b/activerecord/test/cases/explain_subscriber_test.rb
@@ -1,6 +1,6 @@
-require 'cases/helper'
-require 'active_record/explain_subscriber'
-require 'active_record/explain_registry'
+require "cases/helper"
+require "active_record/explain_subscriber"
+require "active_record/explain_registry"
 
 if ActiveRecord::Base.connection.supports_explain?
   class ExplainSubscriberTest < ActiveRecord::TestCase
@@ -25,31 +25,31 @@ if ActiveRecord::Base.connection.supports_explain?
 
     def test_collects_nothing_if_collect_is_false
       ActiveRecord::ExplainRegistry.collect = false
-      SUBSCRIBER.finish(nil, nil, name: 'SQL', sql: 'select 1 from users', binds: [1, 2])
+      SUBSCRIBER.finish(nil, nil, name: "SQL", sql: "select 1 from users", binds: [1, 2])
       assert queries.empty?
     end
 
     def test_collects_pairs_of_queries_and_binds
-      sql   = 'select 1 from users'
+      sql   = "select 1 from users"
       binds = [1, 2]
-      SUBSCRIBER.finish(nil, nil, name: 'SQL', sql: sql, binds: binds)
+      SUBSCRIBER.finish(nil, nil, name: "SQL", sql: sql, binds: binds)
       assert_equal 1, queries.size
       assert_equal sql, queries[0][0]
       assert_equal binds, queries[0][1]
     end
 
     def test_collects_nothing_if_the_statement_is_not_whitelisted
-      SUBSCRIBER.finish(nil, nil, name: 'SQL', sql: 'SHOW max_identifier_length')
+      SUBSCRIBER.finish(nil, nil, name: "SQL", sql: "SHOW max_identifier_length")
       assert queries.empty?
     end
 
     def test_collects_nothing_if_the_statement_is_only_partially_matched
-      SUBSCRIBER.finish(nil, nil, name: 'SQL', sql: 'select_db yo_mama')
+      SUBSCRIBER.finish(nil, nil, name: "SQL", sql: "select_db yo_mama")
       assert queries.empty?
     end
 
     def test_collects_cte_queries
-      SUBSCRIBER.finish(nil, nil, name: 'SQL', sql: 'with s as (values(3)) select 1 from s')
+      SUBSCRIBER.finish(nil, nil, name: "SQL", sql: "with s as (values(3)) select 1 from s")
       assert_equal 1, queries.size
     end
 
diff --git a/activerecord/test/cases/explain_test.rb b/activerecord/test/cases/explain_test.rb
index 6409290e8d..e8816743ea 100644
--- a/activerecord/test/cases/explain_test.rb
+++ b/activerecord/test/cases/explain_test.rb
@@ -1,6 +1,6 @@
-require 'cases/helper'
-require 'models/car'
-require 'active_support/core_ext/string/strip'
+require "cases/helper"
+require "models/car"
+require "active_support/core_ext/string/strip"
 
 if ActiveRecord::Base.connection.supports_explain?
   class ExplainTest < ActiveRecord::TestCase
@@ -15,13 +15,13 @@ if ActiveRecord::Base.connection.supports_explain?
     end
 
     def test_relation_explain
-      message = Car.where(:name => 'honda').explain
+      message = Car.where(:name => "honda").explain
       assert_match(/^EXPLAIN for:/, message)
     end
 
     def test_collecting_queries_for_explain
       queries = ActiveRecord::Base.collecting_queries_for_explain do
-        Car.where(:name => 'honda').to_a
+        Car.where(:name => "honda").to_a
       end
 
       sql, binds = queries[0]
@@ -30,7 +30,7 @@ if ActiveRecord::Base.connection.supports_explain?
         assert_equal 1, binds.length
         assert_equal "honda", binds.last.value
       else
-        assert_match 'honda', sql
+        assert_match "honda", sql
       end
     end
 
@@ -47,7 +47,7 @@ if ActiveRecord::Base.connection.supports_explain?
 
     def test_exec_explain_with_binds
       sqls    = %w(foo bar)
-      binds   = [[bind_param('wadus', 1)], [bind_param('chaflan', 2)]]
+      binds   = [[bind_param("wadus", 1)], [bind_param("chaflan", 2)]]
       queries = sqls.zip(binds)
 
       stub_explain_for_query_plans(["query plan foo\n", "query plan bar\n"]) do
@@ -65,14 +65,14 @@ if ActiveRecord::Base.connection.supports_explain?
     def test_unsupported_connection_adapter
       connection.stub(:supports_explain?, false) do
         assert_not_called(base.logger, :warn) do
-          Car.where(:name => 'honda').to_a
+          Car.where(:name => "honda").to_a
         end
       end
     end
 
     private
 
-      def stub_explain_for_query_plans(query_plans = ['query plan foo', 'query plan bar'])
+      def stub_explain_for_query_plans(query_plans = ["query plan foo", "query plan bar"])
         explain_called = 0
 
         connection.stub(:explain, proc{ explain_called += 1; query_plans[explain_called - 1] }) do
diff --git a/activerecord/test/cases/finder_respond_to_test.rb b/activerecord/test/cases/finder_respond_to_test.rb
index 6ab2657c44..1b3d6a71b2 100644
--- a/activerecord/test/cases/finder_respond_to_test.rb
+++ b/activerecord/test/cases/finder_respond_to_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'models/topic'
+require "models/topic"
 
 class FinderRespondToTest < ActiveRecord::TestCase
 
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index 6eaaa30cd0..099a79e9bc 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -1,22 +1,22 @@
 require "cases/helper"
-require 'models/post'
-require 'models/author'
-require 'models/categorization'
-require 'models/comment'
-require 'models/company'
-require 'models/tagging'
-require 'models/topic'
-require 'models/reply'
-require 'models/entrant'
-require 'models/project'
-require 'models/developer'
-require 'models/computer'
-require 'models/customer'
-require 'models/toy'
-require 'models/matey'
-require 'models/dog'
-require 'models/car'
-require 'models/tyre'
+require "models/post"
+require "models/author"
+require "models/categorization"
+require "models/comment"
+require "models/company"
+require "models/tagging"
+require "models/topic"
+require "models/reply"
+require "models/entrant"
+require "models/project"
+require "models/developer"
+require "models/computer"
+require "models/customer"
+require "models/toy"
+require "models/matey"
+require "models/dog"
+require "models/car"
+require "models/tyre"
 
 class FinderTest < ActiveRecord::TestCase
   fixtures :companies, :topics, :entrants, :developers, :developers_projects, :posts, :comments, :accounts, :authors, :author_addresses, :customers, :categories, :categorizations, :cars
@@ -29,7 +29,7 @@ class FinderTest < ActiveRecord::TestCase
 
   def test_find_by_title_and_id_with_hash
     assert_raises(ActiveRecord::StatementInvalid) do
-      Post.find_by_title_and_id('foo', :limit => 1)
+      Post.find_by_title_and_id("foo", :limit => 1)
     end
   end
 
@@ -50,53 +50,53 @@ class FinderTest < ActiveRecord::TestCase
 
   def test_find_with_ids_returning_ordered
     records = Topic.find([4,2,5])
-    assert_equal 'The Fourth Topic of the day', records[0].title
-    assert_equal 'The Second Topic of the day', records[1].title
-    assert_equal 'The Fifth Topic of the day', records[2].title
+    assert_equal "The Fourth Topic of the day", records[0].title
+    assert_equal "The Second Topic of the day", records[1].title
+    assert_equal "The Fifth Topic of the day", records[2].title
 
     records = Topic.find(4,2,5)
-    assert_equal 'The Fourth Topic of the day', records[0].title
-    assert_equal 'The Second Topic of the day', records[1].title
-    assert_equal 'The Fifth Topic of the day', records[2].title
+    assert_equal "The Fourth Topic of the day", records[0].title
+    assert_equal "The Second Topic of the day", records[1].title
+    assert_equal "The Fifth Topic of the day", records[2].title
 
-    records = Topic.find(['4','2','5'])
-    assert_equal 'The Fourth Topic of the day', records[0].title
-    assert_equal 'The Second Topic of the day', records[1].title
-    assert_equal 'The Fifth Topic of the day', records[2].title
+    records = Topic.find(["4","2","5"])
+    assert_equal "The Fourth Topic of the day", records[0].title
+    assert_equal "The Second Topic of the day", records[1].title
+    assert_equal "The Fifth Topic of the day", records[2].title
 
-    records = Topic.find('4','2','5')
-    assert_equal 'The Fourth Topic of the day', records[0].title
-    assert_equal 'The Second Topic of the day', records[1].title
-    assert_equal 'The Fifth Topic of the day', records[2].title
+    records = Topic.find("4","2","5")
+    assert_equal "The Fourth Topic of the day", records[0].title
+    assert_equal "The Second Topic of the day", records[1].title
+    assert_equal "The Fifth Topic of the day", records[2].title
   end
 
   def test_find_with_ids_and_order_clause
     # The order clause takes precedence over the informed ids
     records = Topic.order(:author_name).find([5,3,1])
-    assert_equal 'The Third Topic of the day', records[0].title
-    assert_equal 'The First Topic',            records[1].title
-    assert_equal 'The Fifth Topic of the day', records[2].title
+    assert_equal "The Third Topic of the day", records[0].title
+    assert_equal "The First Topic",            records[1].title
+    assert_equal "The Fifth Topic of the day", records[2].title
 
     records = Topic.order(:id).find([5,3,1])
-    assert_equal 'The First Topic',            records[0].title
-    assert_equal 'The Third Topic of the day', records[1].title
-    assert_equal 'The Fifth Topic of the day', records[2].title
+    assert_equal "The First Topic",            records[0].title
+    assert_equal "The Third Topic of the day", records[1].title
+    assert_equal "The Fifth Topic of the day", records[2].title
   end
 
   def test_find_with_ids_with_limit_and_order_clause
     # The order clause takes precedence over the informed ids
     records = Topic.limit(2).order(:id).find([5,3,1])
     assert_equal 2, records.size
-    assert_equal 'The First Topic',            records[0].title
-    assert_equal 'The Third Topic of the day', records[1].title
+    assert_equal "The First Topic",            records[0].title
+    assert_equal "The Third Topic of the day", records[1].title
   end
 
   def test_find_with_ids_and_limit
     records = Topic.limit(3).find([3,2,5,1,4])
     assert_equal 3, records.size
-    assert_equal 'The Third Topic of the day',  records[0].title
-    assert_equal 'The Second Topic of the day', records[1].title
-    assert_equal 'The Fifth Topic of the day',  records[2].title
+    assert_equal "The Third Topic of the day",  records[0].title
+    assert_equal "The Second Topic of the day", records[1].title
+    assert_equal "The Fifth Topic of the day",  records[2].title
   end
 
   def test_find_with_ids_where_and_limit
@@ -104,17 +104,17 @@ class FinderTest < ActiveRecord::TestCase
     # if it were among the first 3 it would raise an ActiveRecord::RecordNotFound
     records = Topic.where(approved: true).limit(3).find([3,2,5,1,4])
     assert_equal 3, records.size
-    assert_equal 'The Third Topic of the day',  records[0].title
-    assert_equal 'The Second Topic of the day', records[1].title
-    assert_equal 'The Fifth Topic of the day',  records[2].title
+    assert_equal "The Third Topic of the day",  records[0].title
+    assert_equal "The Second Topic of the day", records[1].title
+    assert_equal "The Fifth Topic of the day",  records[2].title
   end
 
   def test_find_with_ids_and_offset
     records = Topic.offset(2).find([3,2,5,1,4])
     assert_equal 3, records.size
-    assert_equal 'The Fifth Topic of the day',  records[0].title
-    assert_equal 'The First Topic',             records[1].title
-    assert_equal 'The Fourth Topic of the day', records[2].title
+    assert_equal "The Fifth Topic of the day",  records[0].title
+    assert_equal "The First Topic",             records[1].title
+    assert_equal "The Fourth Topic of the day", records[2].title
   end
 
   def test_find_passing_active_record_object_is_deprecated
@@ -155,11 +155,11 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_exists_with_polymorphic_relation
-    post = Post.create!(title: 'Post', body: 'default', taggings: [Tagging.new(comment: 'tagging comment')])
-    relation = Post.tagged_with_comment('tagging comment')
+    post = Post.create!(title: "Post", body: "default", taggings: [Tagging.new(comment: "tagging comment")])
+    relation = Post.tagged_with_comment("tagging comment")
 
-    assert_equal true, relation.exists?(title: ['Post'])
-    assert_equal true, relation.exists?(['title LIKE ?', 'Post%'])
+    assert_equal true, relation.exists?(title: ["Post"])
+    assert_equal true, relation.exists?(["title LIKE ?", "Post%"])
     assert_equal true, relation.exists?
     assert_equal true, relation.exists?(post.id)
     assert_equal true, relation.exists?(post.id.to_s)
@@ -209,7 +209,7 @@ class FinderTest < ActiveRecord::TestCase
 
   def test_exists_with_includes_limit_and_empty_result
     assert_equal false, Topic.includes(:replies).limit(0).exists?
-    assert_equal false, Topic.includes(:replies).limit(1).where('0 = 1').exists?
+    assert_equal false, Topic.includes(:replies).limit(1).where("0 = 1").exists?
   end
 
   def test_exists_with_distinct_association_includes_and_limit
@@ -220,8 +220,8 @@ class FinderTest < ActiveRecord::TestCase
 
   def test_exists_with_distinct_association_includes_limit_and_order
     author = Author.first
-    assert_equal false, author.unique_categorized_posts.includes(:special_comments).order('comments.tags_count DESC').limit(0).exists?
-    assert_equal true, author.unique_categorized_posts.includes(:special_comments).order('comments.tags_count DESC').limit(1).exists?
+    assert_equal false, author.unique_categorized_posts.includes(:special_comments).order("comments.tags_count DESC").limit(0).exists?
+    assert_equal true, author.unique_categorized_posts.includes(:special_comments).order("comments.tags_count DESC").limit(1).exists?
   end
 
   def test_exists_with_empty_table_and_no_args_given
@@ -264,7 +264,7 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal 2, Entrant.limit(2).find([1,3,2]).size
     entrants = Entrant.limit(3).offset(2).find([1,3,2])
     assert_equal 1, entrants.size
-    assert_equal 'Ruby Guru', entrants.first.name
+    assert_equal "Ruby Guru", entrants.first.name
 
     # 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
@@ -272,29 +272,29 @@ class FinderTest < ActiveRecord::TestCase
     devs = Developer.all
     last_devs = Developer.limit(3).offset(9).find devs.map(&:id)
     assert_equal 2, last_devs.size
-    assert_equal 'fixture_10', last_devs[0].name
-    assert_equal 'Jamis', last_devs[1].name
+    assert_equal "fixture_10", last_devs[0].name
+    assert_equal "Jamis", last_devs[1].name
   end
 
   def test_find_with_large_number
-    assert_raises(ActiveRecord::RecordNotFound) { Topic.find('9999999999999999999999999999999') }
+    assert_raises(ActiveRecord::RecordNotFound) { Topic.find("9999999999999999999999999999999") }
   end
 
   def test_find_by_with_large_number
-    assert_nil Topic.find_by(id: '9999999999999999999999999999999')
+    assert_nil Topic.find_by(id: "9999999999999999999999999999999")
   end
 
   def test_find_by_id_with_large_number
-    assert_nil Topic.find_by_id('9999999999999999999999999999999')
+    assert_nil Topic.find_by_id("9999999999999999999999999999999")
   end
 
   def test_find_on_relation_with_large_number
-    assert_nil Topic.where('1=1').find_by(id: 9999999999999999999999999999999)
+    assert_nil Topic.where("1=1").find_by(id: 9999999999999999999999999999999)
   end
 
   def test_find_by_bang_on_relation_with_large_number
     assert_raises(ActiveRecord::RecordNotFound) do
-      Topic.where('1=1').find_by!(id: 9999999999999999999999999999999)
+      Topic.where("1=1").find_by!(id: 9999999999999999999999999999999)
     end
   end
 
@@ -311,7 +311,7 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_with_group_and_sanitized_having_method
-    developers = Developer.group(:salary).having("sum(salary) > ?", 10000).select('salary').to_a
+    developers = Developer.group(:salary).having("sum(salary) > ?", 10000).select("salary").to_a
     assert_equal 3, developers.size
     assert_equal 3, developers.map(&:salary).uniq.size
     assert developers.all? { |developer| developer.salary > 10000 }
@@ -601,7 +601,7 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_last_on_relation_with_limit_and_offset
-    post = posts('sti_comments')
+    post = posts("sti_comments")
 
     comments = post.comments.order(id: :asc)
     assert_equal comments.limit(2).to_a.last, comments.limit(2).last
@@ -651,8 +651,8 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_on_hash_conditions_with_qualified_attribute_dot_notation_string
-    assert Topic.where('topics.approved' => false).find(1)
-    assert_raise(ActiveRecord::RecordNotFound) { Topic.where('topics.approved' => true).find(1) }
+    assert Topic.where("topics.approved" => false).find(1)
+    assert_raise(ActiveRecord::RecordNotFound) { Topic.where("topics.approved" => true).find(1) }
   end
 
   def test_find_on_hash_conditions_with_qualified_attribute_dot_notation_symbol
@@ -666,9 +666,9 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_on_combined_explicit_and_hashed_table_names
-    assert Topic.where('topics.approved' => false, topics: { author_name: "David" }).find(1)
-    assert_raise(ActiveRecord::RecordNotFound) { Topic.where('topics.approved' => true, topics: { author_name: "David" }).find(1) }
-    assert_raise(ActiveRecord::RecordNotFound) { Topic.where('topics.approved' => false, topics: { author_name: "Melanie" }).find(1) }
+    assert Topic.where("topics.approved" => false, topics: { author_name: "David" }).find(1)
+    assert_raise(ActiveRecord::RecordNotFound) { Topic.where("topics.approved" => true, topics: { author_name: "David" }).find(1) }
+    assert_raise(ActiveRecord::RecordNotFound) { Topic.where("topics.approved" => false, topics: { author_name: "Melanie" }).find(1) }
   end
 
   def test_find_with_hash_conditions_on_joined_table
@@ -678,16 +678,16 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_with_hash_conditions_on_joined_table_and_with_range
-    firms = DependentFirm.joins(:account).where(name: 'RailsCore', accounts: { credit_limit: 55..60 })
+    firms = DependentFirm.joins(:account).where(name: "RailsCore", accounts: { credit_limit: 55..60 })
     assert_equal 1, firms.size
     assert_equal companies(:rails_core), firms.first
   end
 
   def test_find_on_hash_conditions_with_explicit_table_name_and_aggregate
     david = customers(:david)
-    assert Customer.where('customers.name' => david.name, :address => david.address).find(david.id)
+    assert Customer.where("customers.name" => david.name, :address => david.address).find(david.id)
     assert_raise(ActiveRecord::RecordNotFound) {
-      Customer.where('customers.name' => david.name + "1", :address => david.address).find(david.id)
+      Customer.where("customers.name" => david.name + "1", :address => david.address).find(david.id)
     }
   end
 
@@ -758,9 +758,9 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_hash_condition_find_with_array
-    p1, p2 = Post.limit(2).order('id asc').to_a
-    assert_equal [p1, p2], Post.where(id: [p1, p2]).order('id asc').to_a
-    assert_equal [p1, p2], Post.where(id: [p1, p2.id]).order('id asc').to_a
+    p1, p2 = Post.limit(2).order("id asc").to_a
+    assert_equal [p1, p2], Post.where(id: [p1, p2]).order("id asc").to_a
+    assert_equal [p1, p2], Post.where(id: [p1, p2.id]).order("id asc").to_a
   end
 
   def test_hash_condition_find_with_nil
@@ -812,16 +812,16 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_condition_utc_time_interpolation_with_default_timezone_local
-    with_env_tz 'America/New_York' do
+    with_env_tz "America/New_York" do
       with_timezone_config default: :local do
         topic = Topic.first
-        assert_equal topic, Topic.where(['written_on = ?', topic.written_on.getutc]).first
+        assert_equal topic, Topic.where(["written_on = ?", topic.written_on.getutc]).first
       end
     end
   end
 
   def test_hash_condition_utc_time_interpolation_with_default_timezone_local
-    with_env_tz 'America/New_York' do
+    with_env_tz "America/New_York" do
       with_timezone_config default: :local do
         topic = Topic.first
         assert_equal topic, Topic.where(written_on: topic.written_on.getutc).first
@@ -830,16 +830,16 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_condition_local_time_interpolation_with_default_timezone_utc
-    with_env_tz 'America/New_York' do
+    with_env_tz "America/New_York" do
       with_timezone_config default: :utc do
         topic = Topic.first
-        assert_equal topic, Topic.where(['written_on = ?', topic.written_on.getlocal]).first
+        assert_equal topic, Topic.where(["written_on = ?", topic.written_on.getlocal]).first
       end
     end
   end
 
   def test_hash_condition_local_time_interpolation_with_default_timezone_utc
-    with_env_tz 'America/New_York' do
+    with_env_tz "America/New_York" do
       with_timezone_config default: :utc do
         topic = Topic.first
         assert_equal topic, Topic.where(written_on: topic.written_on.getlocal).first
@@ -901,7 +901,7 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_by_on_attribute_that_is_a_reserved_word
-    dog_alias = 'Dog'
+    dog_alias = "Dog"
     dog = Dog.create(alias: dog_alias)
 
     assert_equal dog, Dog.find_by_alias(dog_alias)
@@ -918,7 +918,7 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_by_one_attribute_with_conditions
-    assert_equal accounts(:rails_core_account), Account.where('firm_id = ?', 6).find_by_credit_limit(50)
+    assert_equal accounts(:rails_core_account), Account.where("firm_id = ?", 6).find_by_credit_limit(50)
   end
 
   def test_find_by_one_attribute_that_is_an_aggregate
@@ -958,12 +958,12 @@ class FinderTest < ActiveRecord::TestCase
   def test_dynamic_finder_on_one_attribute_with_conditions_returns_same_results_after_caching
     # ensure this test can run independently of order
     class << Account; self; end.send(:remove_method, :find_by_credit_limit) if Account.public_methods.include?(:find_by_credit_limit)
-    a = Account.where('firm_id = ?', 6).find_by_credit_limit(50)
-    assert_equal a, Account.where('firm_id = ?', 6).find_by_credit_limit(50) # find_by_credit_limit has been cached
+    a = Account.where("firm_id = ?", 6).find_by_credit_limit(50)
+    assert_equal a, Account.where("firm_id = ?", 6).find_by_credit_limit(50) # find_by_credit_limit has been cached
   end
 
   def test_find_by_one_attribute_with_several_options
-    assert_equal accounts(:unknown), Account.order('id DESC').where('id != ?', 3).find_by_credit_limit(50)
+    assert_equal accounts(:unknown), Account.order("id DESC").where("id != ?", 3).find_by_credit_limit(50)
   end
 
   def test_find_by_one_missing_attribute
@@ -987,12 +987,12 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_last_with_offset
-    devs = Developer.order('id')
+    devs = Developer.order("id")
 
     assert_equal devs[2], Developer.offset(2).first
     assert_equal devs[-3], Developer.offset(2).last
     assert_equal devs[-3], Developer.offset(2).last
-    assert_equal devs[-3], Developer.offset(2).order('id DESC').first
+    assert_equal devs[-3], Developer.offset(2).order("id DESC").first
   end
 
   def test_find_by_nil_attribute
@@ -1012,18 +1012,18 @@ class FinderTest < ActiveRecord::TestCase
 
   def test_find_all_with_join
     developers_on_project_one = Developer.
-      joins('LEFT JOIN developers_projects ON developers.id = developers_projects.developer_id').
-      where('project_id=1').to_a
+      joins("LEFT JOIN developers_projects ON developers.id = developers_projects.developer_id").
+      where("project_id=1").to_a
     assert_equal 3, developers_on_project_one.length
     developer_names = developers_on_project_one.map(&:name)
-    assert developer_names.include?('David')
-    assert developer_names.include?('Jamis')
+    assert developer_names.include?("David")
+    assert developer_names.include?("Jamis")
   end
 
   def test_joins_dont_clobber_id
     first = Firm.
-      joins('INNER JOIN companies clients ON clients.firm_id = companies.id').
-      where('companies.id = 1').first
+      joins("INNER JOIN companies clients ON clients.firm_id = companies.id").
+      where("companies.id = 1").first
     assert_equal 1, first.id
   end
 
@@ -1042,7 +1042,7 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_ignores_previously_inserted_record
-    Post.create!(:title => 'test', :body => 'it out')
+    Post.create!(:title => "test", :body => "it out")
     assert_equal [], Post.where(id: nil)
   end
 
@@ -1051,13 +1051,13 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_by_empty_in_condition
-    assert_equal [], Post.where('id in (?)', [])
+    assert_equal [], Post.where("id in (?)", [])
   end
 
   def test_find_by_records
-    p1, p2 = Post.limit(2).order('id asc').to_a
-    assert_equal [p1, p2], Post.where(['id in (?)', [p1, p2]]).order('id asc')
-    assert_equal [p1, p2], Post.where(['id in (?)', [p1, p2.id]]).order('id asc')
+    p1, p2 = Post.limit(2).order("id asc").to_a
+    assert_equal [p1, p2], Post.where(["id in (?)", [p1, p2]]).order("id asc")
+    assert_equal [p1, p2], Post.where(["id in (?)", [p1, p2.id]]).order("id asc")
   end
 
   def test_select_value
@@ -1086,18 +1086,18 @@ class FinderTest < ActiveRecord::TestCase
   def test_find_with_order_on_included_associations_with_construct_finder_sql_for_association_limiting_and_is_distinct
     assert_equal 2, Post.includes(authors: :author_address).
       where.not(author_addresses: { id: nil }).
-      order('author_addresses.id DESC').limit(2).to_a.size
+      order("author_addresses.id DESC").limit(2).to_a.size
 
     assert_equal 3, Post.includes(author: :author_address, authors: :author_address).
       where.not(author_addresses_authors: { id: nil }).
-      order('author_addresses_authors.id DESC').limit(3).to_a.size
+      order("author_addresses_authors.id DESC").limit(3).to_a.size
   end
 
   def test_find_with_nil_inside_set_passed_for_one_attribute
     client_of = Company.
       where(client_of: [2, 1, nil],
-            name: ['37signals', 'Summit', 'Microsoft']).
-      order('client_of DESC').
+            name: ["37signals", "Summit", "Microsoft"]).
+      order("client_of DESC").
       map(&:client_of)
 
     assert client_of.include?(nil)
@@ -1107,7 +1107,7 @@ class FinderTest < ActiveRecord::TestCase
   def test_find_with_nil_inside_set_passed_for_attribute
     client_of = Company.
       where(client_of: [nil]).
-      order('client_of DESC').
+      order("client_of DESC").
       map(&:client_of)
 
     assert_equal [], client_of.compact
@@ -1116,7 +1116,7 @@ class FinderTest < ActiveRecord::TestCase
   def test_with_limiting_with_custom_select
     posts = Post.references(:authors).merge(
       :includes => :author, :select => 'posts.*, authors.id as "author_id"',
-      :limit => 3, :order => 'posts.id'
+      :limit => 3, :order => "posts.id"
     ).to_a
     assert_equal 3, posts.size
     assert_equal [0, 1, 1], posts.map(&:author_id).sort
@@ -1126,7 +1126,7 @@ class FinderTest < ActiveRecord::TestCase
     table_with_custom_primary_key do |model|
       model.primary_key = :name
       e = assert_raises(ActiveRecord::RecordNotFound) do
-        model.find 'Hello World!'
+        model.find "Hello World!"
       end
       assert_equal %Q{Couldn't find MercedesCar with 'name'=Hello World!}, e.message
     end
@@ -1136,7 +1136,7 @@ class FinderTest < ActiveRecord::TestCase
     table_with_custom_primary_key do |model|
       model.primary_key = :name
       e = assert_raises(ActiveRecord::RecordNotFound) do
-        model.find 'Hello', 'World!'
+        model.find "Hello", "World!"
       end
       assert_equal %Q{Couldn't find all MercedesCars with 'name': (Hello, World!) (found 0 results, but was looking for 2)}, e.message
     end
@@ -1161,7 +1161,7 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   test "find_by with multi-arg conditions returns the first matching record" do
-    assert_equal posts(:eager_other), Post.find_by('id = ?', posts(:eager_other).id)
+    assert_equal posts(:eager_other), Post.find_by("id = ?", posts(:eager_other).id)
   end
 
   test "find_by returns nil if the record is missing" do
@@ -1186,7 +1186,7 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   test "find_by! with multi-arg conditions returns the first matching record" do
-    assert_equal posts(:eager_other), Post.find_by!('id = ?', posts(:eager_other).id)
+    assert_equal posts(:eager_other), Post.find_by!("id = ?", posts(:eager_other).id)
   end
 
   test "find_by! doesn't have implicit ordering" do
@@ -1223,7 +1223,7 @@ class FinderTest < ActiveRecord::TestCase
     def table_with_custom_primary_key
       yield(Class.new(Toy) do
         def self.name
-          'MercedesCar'
+          "MercedesCar"
         end
       end)
     end
diff --git a/activerecord/test/cases/fixture_set/file_test.rb b/activerecord/test/cases/fixture_set/file_test.rb
index e64b90507e..45b770ab8c 100644
--- a/activerecord/test/cases/fixture_set/file_test.rb
+++ b/activerecord/test/cases/fixture_set/file_test.rb
@@ -1,5 +1,5 @@
-require 'cases/helper'
-require 'tempfile'
+require "cases/helper"
+require "tempfile"
 
 module ActiveRecord
   class FixtureSet
@@ -15,7 +15,7 @@ module ActiveRecord
           called = true
           assert_equal 6, fh.to_a.length
         end
-        assert called, 'block called'
+        assert called, "block called"
       end
 
       def test_names
@@ -32,7 +32,7 @@ module ActiveRecord
       def test_values
         File.open(::File.join(FIXTURES_ROOT, "accounts.yml")) do |fh|
           assert_equal [1,2,3,4,5,6].sort, fh.to_a.map(&:last).map { |x|
-            x['id']
+            x["id"]
           }.sort
         end
       end
@@ -45,7 +45,7 @@ module ActiveRecord
       end
 
       def test_empty_file
-        tmp_yaml ['empty', 'yml'], '' do |t|
+        tmp_yaml ["empty", "yml"], "" do |t|
           assert_equal [], File.open(t.path) { |fh| fh.to_a }
         end
       end
@@ -53,7 +53,7 @@ module ActiveRecord
       # A valid YAML file is not necessarily a value Fixture file. Make sure
       # an exception is raised if the format is not valid Fixture format.
       def test_wrong_fixture_format_string
-        tmp_yaml ['empty', 'yml'], 'qwerty' do |t|
+        tmp_yaml ["empty", "yml"], "qwerty" do |t|
           assert_raises(ActiveRecord::Fixture::FormatError) do
             File.open(t.path) { |fh| fh.to_a }
           end
@@ -61,7 +61,7 @@ module ActiveRecord
       end
 
       def test_wrong_fixture_format_nested
-        tmp_yaml ['empty', 'yml'], 'one: two' do |t|
+        tmp_yaml ["empty", "yml"], "one: two" do |t|
           assert_raises(ActiveRecord::Fixture::FormatError) do
             File.open(t.path) { |fh| fh.to_a }
           end
@@ -75,7 +75,7 @@ module ActiveRecord
           end
         end
         yaml = "one:\n  name: <%= fixture_helper %>\n"
-        tmp_yaml ['curious', 'yml'], yaml do |t|
+        tmp_yaml ["curious", "yml"], yaml do |t|
           golden =
               [["one", {"name" => "Fixture helper"}]]
           assert_equal golden, File.open(t.path) { |fh| fh.to_a }
@@ -95,15 +95,15 @@ one:
   File: <%= File.name %>
 END
 
-        golden = [['one', {
-          'ActiveRecord' => 'constant',
-          'ActiveRecord_FixtureSet' => 'constant',
-          'FixtureSet' => nil,
-          'ActiveRecord_FixtureSet_File' => 'constant',
-          'File' => 'File'
+        golden = [["one", {
+          "ActiveRecord" => "constant",
+          "ActiveRecord_FixtureSet" => "constant",
+          "FixtureSet" => nil,
+          "ActiveRecord_FixtureSet_File" => "constant",
+          "File" => "File"
         }]]
 
-        tmp_yaml ['curious', 'yml'], yaml do |t|
+        tmp_yaml ["curious", "yml"], yaml do |t|
           assert_equal golden, File.open(t.path) { |fh| fh.to_a }
         end
       end
@@ -113,8 +113,8 @@ END
       def test_independent_render_contexts
         yaml1 = "<% def leaked_method; 'leak'; end %>\n"
         yaml2 = "one:\n  name: <%= leaked_method %>\n"
-        tmp_yaml ['leaky', 'yml'], yaml1 do |t1|
-          tmp_yaml ['curious', 'yml'], yaml2 do |t2|
+        tmp_yaml ["leaky", "yml"], yaml1 do |t1|
+          tmp_yaml ["curious", "yml"], yaml2 do |t2|
             File.open(t1.path) { |fh| fh.to_a }
             assert_raises(NameError) do
               File.open(t2.path) { |fh| fh.to_a }
@@ -124,19 +124,19 @@ END
       end
 
       def test_removes_fixture_config_row
-        File.open(::File.join(FIXTURES_ROOT, 'other_posts.yml')) do |fh|
-          assert_equal(['second_welcome'], fh.each.map { |name, _| name })
+        File.open(::File.join(FIXTURES_ROOT, "other_posts.yml")) do |fh|
+          assert_equal(["second_welcome"], fh.each.map { |name, _| name })
         end
       end
 
       def test_extracts_model_class_from_config_row
-        File.open(::File.join(FIXTURES_ROOT, 'other_posts.yml')) do |fh|
-          assert_equal 'Post', fh.model_class
+        File.open(::File.join(FIXTURES_ROOT, "other_posts.yml")) do |fh|
+          assert_equal "Post", fh.model_class
         end
       end
 
       def test_erb_filename
-        filename = 'filename.yaml'
+        filename = "filename.yaml"
         erb = File.new(filename).send(:prepare_erb, "<% Rails.env %>\n")
         assert_equal erb.filename, filename
       end
diff --git a/activerecord/test/cases/fixtures_test.rb b/activerecord/test/cases/fixtures_test.rb
index df53bbf950..b5643fe5e2 100644
--- a/activerecord/test/cases/fixtures_test.rb
+++ b/activerecord/test/cases/fixtures_test.rb
@@ -1,31 +1,31 @@
-require 'cases/helper'
-require 'models/admin'
-require 'models/admin/account'
-require 'models/admin/randomly_named_c1'
-require 'models/admin/user'
-require 'models/binary'
-require 'models/book'
-require 'models/bulb'
-require 'models/category'
-require 'models/comment'
-require 'models/company'
-require 'models/computer'
-require 'models/course'
-require 'models/developer'
-require 'models/doubloon'
-require 'models/joke'
-require 'models/matey'
-require 'models/parrot'
-require 'models/pirate'
-require 'models/post'
-require 'models/randomly_named_c1'
-require 'models/reply'
-require 'models/ship'
-require 'models/task'
-require 'models/topic'
-require 'models/traffic_light'
-require 'models/treasure'
-require 'tempfile'
+require "cases/helper"
+require "models/admin"
+require "models/admin/account"
+require "models/admin/randomly_named_c1"
+require "models/admin/user"
+require "models/binary"
+require "models/book"
+require "models/bulb"
+require "models/category"
+require "models/comment"
+require "models/company"
+require "models/computer"
+require "models/course"
+require "models/developer"
+require "models/doubloon"
+require "models/joke"
+require "models/matey"
+require "models/parrot"
+require "models/pirate"
+require "models/post"
+require "models/randomly_named_c1"
+require "models/reply"
+require "models/ship"
+require "models/task"
+require "models/topic"
+require "models/traffic_light"
+require "models/treasure"
+require "tempfile"
 
 class FixturesTest < ActiveRecord::TestCase
   self.use_instantiated_fixtures = true
@@ -53,12 +53,12 @@ class FixturesTest < ActiveRecord::TestCase
   end
 
   def test_broken_yaml_exception
-    badyaml = Tempfile.new ['foo', '.yml']
-    badyaml.write 'a: : '
+    badyaml = Tempfile.new ["foo", ".yml"]
+    badyaml.write "a: : "
     badyaml.flush
 
     dir  = File.dirname badyaml.path
-    name = File.basename badyaml.path, '.yml'
+    name = File.basename badyaml.path, ".yml"
     assert_raises(ActiveRecord::Fixture::FormatError) do
       ActiveRecord::FixtureSet.create_fixtures(dir, name)
     end
@@ -69,8 +69,8 @@ class FixturesTest < ActiveRecord::TestCase
 
   def test_create_fixtures
     fixtures = ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, "parrots")
-    assert Parrot.find_by_name('Curious George'), 'George is not in the database'
-    assert fixtures.detect { |f| f.name == 'parrots' }, "no fixtures named 'parrots' in #{fixtures.map(&:name).inspect}"
+    assert Parrot.find_by_name("Curious George"), "George is not in the database"
+    assert fixtures.detect { |f| f.name == "parrots" }, "no fixtures named 'parrots' in #{fixtures.map(&:name).inspect}"
   end
 
   def test_multiple_clean_fixtures
@@ -83,8 +83,8 @@ class FixturesTest < ActiveRecord::TestCase
   def test_create_symbol_fixtures
     fixtures = ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, :collections, :collections => Course) { Course.connection }
 
-    assert Course.find_by_name('Collection'), 'course is not in the database'
-    assert fixtures.detect { |f| f.name == 'collections' }, "no fixtures named 'collections' in #{fixtures.map(&:name).inspect}"
+    assert Course.find_by_name("Collection"), "course is not in the database"
+    assert fixtures.detect { |f| f.name == "collections" }, "no fixtures named 'collections' in #{fixtures.map(&:name).inspect}"
   end
 
   def test_attributes
@@ -126,8 +126,8 @@ class FixturesTest < ActiveRecord::TestCase
       old_suffix = ActiveRecord::Base.table_name_suffix
 
       # Set a prefix/suffix we can test against
-      ActiveRecord::Base.table_name_prefix = 'prefix_'
-      ActiveRecord::Base.table_name_suffix = '_suffix'
+      ActiveRecord::Base.table_name_prefix = "prefix_"
+      ActiveRecord::Base.table_name_suffix = "_suffix"
 
       other_topic_klass = Class.new(ActiveRecord::Base) do
         def self.name
@@ -170,7 +170,7 @@ class FixturesTest < ActiveRecord::TestCase
 
   def test_logger_level_invariant
     level = ActiveRecord::Base.logger.level
-    create_fixtures('topics')
+    create_fixtures("topics")
     assert_equal level, ActiveRecord::Base.logger.level
   end
 
@@ -229,11 +229,11 @@ class FixturesTest < ActiveRecord::TestCase
 
   def test_omap_fixtures
     assert_nothing_raised do
-      fixtures = ActiveRecord::FixtureSet.new(Account.connection, 'categories', Category, FIXTURES_ROOT + "/categories_ordered")
+      fixtures = ActiveRecord::FixtureSet.new(Account.connection, "categories", Category, FIXTURES_ROOT + "/categories_ordered")
 
       fixtures.each.with_index do |(name, fixture), i|
         assert_equal "fixture_no_#{i}", name
-        assert_equal "Category #{i}", fixture['name']
+        assert_equal "Category #{i}", fixture["name"]
       end
     end
   end
@@ -249,8 +249,8 @@ class FixturesTest < ActiveRecord::TestCase
   end
 
   def test_binary_in_fixtures
-    data = File.open(ASSETS_ROOT + "/flowers.jpg", 'rb') { |f| f.read }
-    data.force_encoding('ASCII-8BIT')
+    data = File.open(ASSETS_ROOT + "/flowers.jpg", "rb") { |f| f.read }
+    data.force_encoding("ASCII-8BIT")
     data.freeze
     assert_equal data, @flowers.data
   end
@@ -260,8 +260,8 @@ class FixturesTest < ActiveRecord::TestCase
   end
 
   def test_fixtures_are_set_up_with_database_env_variable
-    db_url_tmp = ENV['DATABASE_URL']
-    ENV['DATABASE_URL'] = "sqlite3::memory:"
+    db_url_tmp = ENV["DATABASE_URL"]
+    ENV["DATABASE_URL"] = "sqlite3::memory:"
     ActiveRecord::Base.stub(:configurations, {}) do
       test_case = Class.new(ActiveRecord::TestCase) do
         fixtures :accounts
@@ -276,7 +276,7 @@ class FixturesTest < ActiveRecord::TestCase
       assert result.passed?, "Expected #{result.name} to pass:\n#{result}"
     end
   ensure
-    ENV['DATABASE_URL'] = db_url_tmp
+    ENV["DATABASE_URL"] = db_url_tmp
   end
 end
 
@@ -297,11 +297,11 @@ class HasManyThroughFixture < ActiveSupport::TestCase
     parrot.has_many :parrot_treasures, :anonymous_class => pt
     parrot.has_many :treasures, :through => :parrot_treasures
 
-    parrots = File.join FIXTURES_ROOT, 'parrots'
+    parrots = File.join FIXTURES_ROOT, "parrots"
 
     fs = ActiveRecord::FixtureSet.new parrot.connection, "parrots", parrot, parrots
     rows = fs.table_rows
-    assert_equal load_has_and_belongs_to_many['parrots_treasures'], rows['parrots_treasures']
+    assert_equal load_has_and_belongs_to_many["parrots_treasures"], rows["parrots_treasures"]
   end
 
   def test_has_many_through_with_renamed_table
@@ -315,18 +315,18 @@ class HasManyThroughFixture < ActiveSupport::TestCase
     parrot.has_many :parrot_treasures, :anonymous_class => pt
     parrot.has_many :treasures, :through => :parrot_treasures
 
-    parrots = File.join FIXTURES_ROOT, 'parrots'
+    parrots = File.join FIXTURES_ROOT, "parrots"
 
     fs = ActiveRecord::FixtureSet.new parrot.connection, "parrots", parrot, parrots
     rows = fs.table_rows
-    assert_equal load_has_and_belongs_to_many['parrots_treasures'], rows['parrot_treasures']
+    assert_equal load_has_and_belongs_to_many["parrots_treasures"], rows["parrot_treasures"]
   end
 
   def load_has_and_belongs_to_many
     parrot = make_model "Parrot"
     parrot.has_and_belongs_to_many :treasures
 
-    parrots = File.join FIXTURES_ROOT, 'parrots'
+    parrots = File.join FIXTURES_ROOT, "parrots"
 
     fs = ActiveRecord::FixtureSet.new parrot.connection, "parrots", parrot, parrots
     fs.table_rows
@@ -339,7 +339,7 @@ if Account.connection.respond_to?(:reset_pk_sequence!)
     fixtures :companies
 
     def setup
-      @instances = [Account.new(:credit_limit => 50), Company.new(:name => 'RoR Consulting'), Course.new(name: 'Test')]
+      @instances = [Account.new(:credit_limit => 50), Company.new(:name => "RoR Consulting"), Course.new(name: "Test")]
       ActiveRecord::FixtureSet.reset_cache # make sure tables get reinitialized
     end
 
@@ -368,7 +368,7 @@ if Account.connection.respond_to?(:reset_pk_sequence!)
     def test_create_fixtures_resets_sequences_when_not_cached
       @instances.each do |instance|
         max_id = create_fixtures(instance.class.table_name).first.fixtures.inject(0) do |_max_id, (_, fixture)|
-          fixture_id = fixture['id'].to_i
+          fixture_id = fixture["id"].to_i
           fixture_id > _max_id ? fixture_id : _max_id
         end
 
@@ -414,7 +414,7 @@ class FixturesWithoutInstantiationTest < ActiveRecord::TestCase
   def test_reloading_fixtures_through_accessor_methods
     topic = Struct.new(:title)
     assert_equal "The First Topic", topics(:first).title
-    assert_called(@loaded_fixtures['topics']['first'], :find, returns: topic.new("Fresh Topic!")) do
+    assert_called(@loaded_fixtures["topics"]["first"], :find, returns: topic.new("Fresh Topic!")) do
       assert_equal "Fresh Topic!", topics(:first, true).title
     end
   end
@@ -510,13 +510,13 @@ class OverRideFixtureMethodTest < ActiveRecord::TestCase
 
   def topics(name)
     topic = super
-    topic.title = 'omg'
+    topic.title = "omg"
     topic
   end
 
   def test_fixture_methods_can_be_overridden
     x = topics :first
-    assert_equal 'omg', x.title
+    assert_equal "omg", x.title
   end
 end
 
@@ -650,15 +650,15 @@ class TransactionalFixturesOnConnectionNotification < ActiveRecord::TestCase
   private
 
     def fire_connection_notification(connection)
-      ActiveRecord::Base.connection_handler.stubs(:retrieve_connection).with('book').returns(connection)
+      ActiveRecord::Base.connection_handler.stubs(:retrieve_connection).with("book").returns(connection)
       message_bus = ActiveSupport::Notifications.instrumenter
       payload = {
-        spec_name: 'book',
+        spec_name: "book",
         config: nil,
         connection_id: connection.object_id
       }
 
-      message_bus.instrument('!connection.active_record', payload) {}
+      message_bus.instrument("!connection.active_record", payload) {}
     end
 end
 
@@ -719,7 +719,7 @@ class FixturesBrokenRollbackTest < ActiveRecord::TestCase
 
   private
     def load_fixtures(config)
-      raise 'argh'
+      raise "argh"
     end
 end
 
@@ -738,7 +738,7 @@ end
 
 class LoadAllFixturesWithPathnameTest < ActiveRecord::TestCase
   def test_all_there
-    self.class.fixture_path = Pathname.new(FIXTURES_ROOT).join('all')
+    self.class.fixture_path = Pathname.new(FIXTURES_ROOT).join("all")
     self.class.fixtures :all
 
     if File.symlink? FIXTURES_ROOT + "/all/admin"
@@ -760,18 +760,18 @@ class FasterFixturesTest < ActiveRecord::TestCase
   end
 
   def test_cache
-    assert ActiveRecord::FixtureSet.fixture_is_cached?(ActiveRecord::Base.connection, 'categories')
-    assert ActiveRecord::FixtureSet.fixture_is_cached?(ActiveRecord::Base.connection, 'authors')
+    assert ActiveRecord::FixtureSet.fixture_is_cached?(ActiveRecord::Base.connection, "categories")
+    assert ActiveRecord::FixtureSet.fixture_is_cached?(ActiveRecord::Base.connection, "authors")
 
     assert_no_queries do
-      create_fixtures('categories')
-      create_fixtures('authors')
+      create_fixtures("categories")
+      create_fixtures("authors")
     end
 
-    load_extra_fixture('posts')
-    assert ActiveRecord::FixtureSet.fixture_is_cached?(ActiveRecord::Base.connection, 'posts')
+    load_extra_fixture("posts")
+    assert ActiveRecord::FixtureSet.fixture_is_cached?(ActiveRecord::Base.connection, "posts")
     self.class.setup_fixture_accessors :posts
-    assert_equal 'Welcome to the weblog', posts(:welcome).title
+    assert_equal "Welcome to the weblog", posts(:welcome).title
   end
 end
 
@@ -779,9 +779,9 @@ class FoxyFixturesTest < ActiveRecord::TestCase
   fixtures :parrots, :parrots_pirates, :pirates, :treasures, :mateys, :ships, :computers,
            :developers, :"admin/accounts", :"admin/users", :live_parrots, :dead_parrots, :books
 
-  if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
-    require 'models/uuid_parent'
-    require 'models/uuid_child'
+  if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+    require "models/uuid_parent"
+    require "models/uuid_child"
     fixtures :uuid_parents, :uuid_children
   end
 
@@ -798,8 +798,8 @@ class FoxyFixturesTest < ActiveRecord::TestCase
     assert_equal 207281424, ActiveRecord::FixtureSet.identify(:ruby)
     assert_equal 1066363776, ActiveRecord::FixtureSet.identify(:sapphire_2)
 
-    assert_equal 'f92b6bda-0d0d-5fe1-9124-502b18badded', ActiveRecord::FixtureSet.identify(:daddy, :uuid)
-    assert_equal 'b4b10018-ad47-595d-b42f-d8bdaa6d01bf', ActiveRecord::FixtureSet.identify(:sonny, :uuid)
+    assert_equal "f92b6bda-0d0d-5fe1-9124-502b18badded", ActiveRecord::FixtureSet.identify(:daddy, :uuid)
+    assert_equal "b4b10018-ad47-595d-b42f-d8bdaa6d01bf", ActiveRecord::FixtureSet.identify(:sonny, :uuid)
   end
 
   TIMESTAMP_COLUMNS = %w(created_at created_on updated_at updated_on)
@@ -953,10 +953,10 @@ class CustomNameForFixtureOrModelTest < ActiveRecord::TestCase
                         ClassNameThatDoesNotFollowCONVENTIONS,
                     :'admin/randomly_named_a9' =>
                         Admin::ClassNameThatDoesNotFollowCONVENTIONS1,
-                    'admin/randomly_named_b0'  =>
+                    "admin/randomly_named_b0"  =>
                         Admin::ClassNameThatDoesNotFollowCONVENTIONS2
 
-  fixtures :randomly_named_a9, 'admin/randomly_named_a9',
+  fixtures :randomly_named_a9, "admin/randomly_named_a9",
            :'admin/randomly_named_b0'
 
   def test_named_accessor_for_randomly_named_fixture_and_class
@@ -972,8 +972,8 @@ class CustomNameForFixtureOrModelTest < ActiveRecord::TestCase
   end
 
   def test_table_name_is_defined_in_the_model
-    assert_equal 'randomly_named_table2', ActiveRecord::FixtureSet::all_loaded_fixtures["admin/randomly_named_a9"].table_name
-    assert_equal 'randomly_named_table2', Admin::ClassNameThatDoesNotFollowCONVENTIONS1.table_name
+    assert_equal "randomly_named_table2", ActiveRecord::FixtureSet::all_loaded_fixtures["admin/randomly_named_a9"].table_name
+    assert_equal "randomly_named_table2", Admin::ClassNameThatDoesNotFollowCONVENTIONS1.table_name
   end
 end
 
@@ -1009,6 +1009,6 @@ class FixtureClassNamesTest < ActiveRecord::TestCase
   end
 
   test "fixture_class_names returns nil for unregistered identifier" do
-    assert_nil self.fixture_class_names['unregistered_identifier']
+    assert_nil self.fixture_class_names["unregistered_identifier"]
   end
 end
diff --git a/activerecord/test/cases/forbidden_attributes_protection_test.rb b/activerecord/test/cases/forbidden_attributes_protection_test.rb
index 91921469b8..1a606d3118 100644
--- a/activerecord/test/cases/forbidden_attributes_protection_test.rb
+++ b/activerecord/test/cases/forbidden_attributes_protection_test.rb
@@ -1,11 +1,11 @@
-require 'cases/helper'
-require 'active_support/core_ext/hash/indifferent_access'
+require "cases/helper"
+require "active_support/core_ext/hash/indifferent_access"
 
-require 'models/company'
-require 'models/person'
-require 'models/ship'
-require 'models/ship_part'
-require 'models/treasure'
+require "models/company"
+require "models/person"
+require "models/ship"
+require "models/ship_part"
+require "models/treasure"
 
 class ProtectedParams
   attr_accessor :permitted
@@ -44,40 +44,40 @@ end
 
 class ForbiddenAttributesProtectionTest < ActiveRecord::TestCase
   def test_forbidden_attributes_cannot_be_used_for_mass_assignment
-    params = ProtectedParams.new(first_name: 'Guille', gender: 'm')
+    params = ProtectedParams.new(first_name: "Guille", gender: "m")
     assert_raises(ActiveModel::ForbiddenAttributesError) do
       Person.new(params)
     end
   end
 
   def test_permitted_attributes_can_be_used_for_mass_assignment
-    params = ProtectedParams.new(first_name: 'Guille', gender: 'm')
+    params = ProtectedParams.new(first_name: "Guille", gender: "m")
     params.permit!
     person = Person.new(params)
 
-    assert_equal 'Guille', person.first_name
-    assert_equal 'm', person.gender
+    assert_equal "Guille", person.first_name
+    assert_equal "m", person.gender
   end
 
   def test_forbidden_attributes_cannot_be_used_for_sti_inheritance_column
-    params = ProtectedParams.new(type: 'Client')
+    params = ProtectedParams.new(type: "Client")
     assert_raises(ActiveModel::ForbiddenAttributesError) do
       Company.new(params)
     end
   end
 
   def test_permitted_attributes_can_be_used_for_sti_inheritance_column
-    params = ProtectedParams.new(type: 'Client')
+    params = ProtectedParams.new(type: "Client")
     params.permit!
     person = Company.new(params)
     assert_equal person.class, Client
   end
 
   def test_regular_hash_should_still_be_used_for_mass_assignment
-    person = Person.new(first_name: 'Guille', gender: 'm')
+    person = Person.new(first_name: "Guille", gender: "m")
 
-    assert_equal 'Guille', person.first_name
-    assert_equal 'm', person.gender
+    assert_equal "Guille", person.first_name
+    assert_equal "m", person.gender
   end
 
   def test_blank_attributes_should_not_raise
@@ -86,7 +86,7 @@ class ForbiddenAttributesProtectionTest < ActiveRecord::TestCase
   end
 
   def test_create_with_checks_permitted
-    params = ProtectedParams.new(first_name: 'Guille', gender: 'm')
+    params = ProtectedParams.new(first_name: "Guille", gender: "m")
 
     assert_raises(ActiveModel::ForbiddenAttributesError) do
       Person.create_with(params).create!
@@ -94,21 +94,21 @@ class ForbiddenAttributesProtectionTest < ActiveRecord::TestCase
   end
 
   def test_create_with_works_with_permitted_params
-    params = ProtectedParams.new(first_name: 'Guille').permit!
+    params = ProtectedParams.new(first_name: "Guille").permit!
 
     person = Person.create_with(params).create!
-    assert_equal 'Guille', person.first_name
+    assert_equal "Guille", person.first_name
   end
 
   def test_create_with_works_with_params_values
-    params = ProtectedParams.new(first_name: 'Guille')
+    params = ProtectedParams.new(first_name: "Guille")
 
     person = Person.create_with(first_name: params[:first_name]).create!
-    assert_equal 'Guille', person.first_name
+    assert_equal "Guille", person.first_name
   end
 
   def test_where_checks_permitted
-    params = ProtectedParams.new(first_name: 'Guille', gender: 'm')
+    params = ProtectedParams.new(first_name: "Guille", gender: "m")
 
     assert_raises(ActiveModel::ForbiddenAttributesError) do
       Person.where(params).create!
@@ -116,21 +116,21 @@ class ForbiddenAttributesProtectionTest < ActiveRecord::TestCase
   end
 
   def test_where_works_with_permitted_params
-    params = ProtectedParams.new(first_name: 'Guille').permit!
+    params = ProtectedParams.new(first_name: "Guille").permit!
 
     person = Person.where(params).create!
-    assert_equal 'Guille', person.first_name
+    assert_equal "Guille", person.first_name
   end
 
   def test_where_works_with_params_values
-    params = ProtectedParams.new(first_name: 'Guille')
+    params = ProtectedParams.new(first_name: "Guille")
 
     person = Person.where(first_name: params[:first_name]).create!
-    assert_equal 'Guille', person.first_name
+    assert_equal "Guille", person.first_name
   end
 
   def test_where_not_checks_permitted
-    params = ProtectedParams.new(first_name: 'Guille', gender: 'm')
+    params = ProtectedParams.new(first_name: "Guille", gender: "m")
 
     assert_raises(ActiveModel::ForbiddenAttributesError) do
       Person.where().not(params)
@@ -138,9 +138,9 @@ class ForbiddenAttributesProtectionTest < ActiveRecord::TestCase
   end
 
   def test_where_not_works_with_permitted_params
-    params = ProtectedParams.new(first_name: 'Guille').permit!
+    params = ProtectedParams.new(first_name: "Guille").permit!
     Person.create!(params)
-    assert_empty Person.where.not(params).select {|p| p.first_name == 'Guille' }
+    assert_empty Person.where.not(params).select {|p| p.first_name == "Guille" }
   end
 
   def test_strong_params_style_objects_work_with_singular_associations
diff --git a/activerecord/test/cases/habtm_destroy_order_test.rb b/activerecord/test/cases/habtm_destroy_order_test.rb
index 2ce0de360e..8484bbd2e4 100644
--- a/activerecord/test/cases/habtm_destroy_order_test.rb
+++ b/activerecord/test/cases/habtm_destroy_order_test.rb
@@ -9,14 +9,14 @@ class HabtmDestroyOrderTest < ActiveRecord::TestCase
     sicp.students << ben
     sicp.save!
     assert_raises LessonError do
-      assert_no_difference('Lesson.count') do
+      assert_no_difference("Lesson.count") do
         sicp.destroy
       end
     end
     assert !sicp.destroyed?
   end
 
-  test 'should not raise error if have foreign key in the join table' do
+  test "should not raise error if have foreign key in the join table" do
     student = Student.new(:name => "Ben Bitdiddle")
     lesson = Lesson.new(:name => "SICP")
     lesson.students << student
diff --git a/activerecord/test/cases/helper.rb b/activerecord/test/cases/helper.rb
index d2fdf03e9d..16b8a19dc4 100644
--- a/activerecord/test/cases/helper.rb
+++ b/activerecord/test/cases/helper.rb
@@ -1,17 +1,17 @@
-require 'config'
+require "config"
 
-require 'active_support/testing/autorun'
-require 'active_support/testing/method_call_assertions'
-require 'stringio'
+require "active_support/testing/autorun"
+require "active_support/testing/method_call_assertions"
+require "stringio"
 
-require 'active_record'
-require 'cases/test_case'
-require 'active_support/dependencies'
-require 'active_support/logger'
-require 'active_support/core_ext/string/strip'
+require "active_record"
+require "cases/test_case"
+require "active_support/dependencies"
+require "active_support/logger"
+require "active_support/core_ext/string/strip"
 
-require 'support/config'
-require 'support/connection'
+require "support/config"
+require "support/connection"
 
 # TODO: Move all these random hacks into the ARTest namespace and into the support/ dir
 
@@ -27,7 +27,7 @@ I18n.enforce_available_locales = false
 ARTest.connect
 
 # Quote "type" if it's a reserved word for the current connection.
-QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name('type')
+QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name("type")
 
 # FIXME: Remove this when the deprecation cycle on TZ aware types by default ends.
 ActiveRecord::Base.time_zone_aware_types << :time
@@ -49,18 +49,18 @@ def subsecond_precision_supported?
 end
 
 def mysql_enforcing_gtid_consistency?
-  current_adapter?(:Mysql2Adapter) && 'ON' == ActiveRecord::Base.connection.show_variable('enforce_gtid_consistency')
+  current_adapter?(:Mysql2Adapter) && "ON" == ActiveRecord::Base.connection.show_variable("enforce_gtid_consistency")
 end
 
 def supports_savepoints?
   ActiveRecord::Base.connection.supports_savepoints?
 end
 
-def with_env_tz(new_tz = 'US/Eastern')
-  old_tz, ENV['TZ'] = ENV['TZ'], new_tz
+def with_env_tz(new_tz = "US/Eastern")
+  old_tz, ENV["TZ"] = ENV["TZ"], new_tz
   yield
 ensure
-  old_tz ? ENV['TZ'] = old_tz : ENV.delete('TZ')
+  old_tz ? ENV["TZ"] = old_tz : ENV.delete("TZ")
 end
 
 def with_timezone_config(cfg)
@@ -201,4 +201,4 @@ module InTimeZone
   end
 end
 
-require 'mocha/setup' # FIXME: stop using mocha
+require "mocha/setup" # FIXME: stop using mocha
diff --git a/activerecord/test/cases/hot_compatibility_test.rb b/activerecord/test/cases/hot_compatibility_test.rb
index 9fc75b7377..42e7235fba 100644
--- a/activerecord/test/cases/hot_compatibility_test.rb
+++ b/activerecord/test/cases/hot_compatibility_test.rb
@@ -1,5 +1,5 @@
-require 'cases/helper'
-require 'support/connection_helper'
+require "cases/helper"
+require "support/connection_helper"
 
 class HotCompatibilityTest < ActiveRecord::TestCase
   self.use_transactional_tests = false
@@ -12,7 +12,7 @@ class HotCompatibilityTest < ActiveRecord::TestCase
         t.string :bar
       end
 
-      def self.name; 'HotCompatibility'; end
+      def self.name; "HotCompatibility"; end
     end
   end
 
@@ -35,29 +35,29 @@ class HotCompatibilityTest < ActiveRecord::TestCase
 
     # but we can successfully create a record so long as we don't
     # reference the removed column
-    record = @klass.create! foo: 'foo'
+    record = @klass.create! foo: "foo"
     record.reload
-    assert_equal 'foo', record.foo
+    assert_equal "foo", record.foo
   end
 
   test "update after remove_column" do
-    record = @klass.create! foo: 'foo'
+    record = @klass.create! foo: "foo"
     assert_equal 3, @klass.columns.length
     @klass.connection.remove_column :hot_compatibilities, :bar
     assert_equal 3, @klass.columns.length
 
     record.reload
-    assert_equal 'foo', record.foo
-    record.foo = 'bar'
+    assert_equal "foo", record.foo
+    record.foo = "bar"
     record.save!
     record.reload
-    assert_equal 'bar', record.foo
+    assert_equal "bar", record.foo
   end
 
   if current_adapter?(:PostgreSQLAdapter)
     test "cleans up after prepared statement failure in a transaction" do
       with_two_connections do |original_connection, ddl_connection|
-        record = @klass.create! bar: 'bar'
+        record = @klass.create! bar: "bar"
 
         # prepare the reload statement in a transaction
         @klass.transaction do
@@ -83,7 +83,7 @@ class HotCompatibilityTest < ActiveRecord::TestCase
 
     test "cleans up after prepared statement failure in nested transactions" do
       with_two_connections do |original_connection, ddl_connection|
-        record = @klass.create! bar: 'bar'
+        record = @klass.create! bar: "bar"
 
         # prepare the reload statement in a transaction
         @klass.transaction do
diff --git a/activerecord/test/cases/i18n_test.rb b/activerecord/test/cases/i18n_test.rb
index a428f1d87b..f28d6f65d9 100644
--- a/activerecord/test/cases/i18n_test.rb
+++ b/activerecord/test/cases/i18n_test.rb
@@ -1,6 +1,6 @@
 require "cases/helper"
-require 'models/topic'
-require 'models/reply'
+require "models/topic"
+require "models/reply"
 
 class ActiveRecordI18nTests < ActiveRecord::TestCase
 
@@ -9,37 +9,37 @@ class ActiveRecordI18nTests < ActiveRecord::TestCase
   end
 
   def test_translated_model_attributes
-    I18n.backend.store_translations 'en', :activerecord => {:attributes => {:topic => {:title => 'topic title attribute'} } }
-    assert_equal 'topic title attribute', Topic.human_attribute_name('title')
+    I18n.backend.store_translations "en", :activerecord => {:attributes => {:topic => {:title => "topic title attribute"} } }
+    assert_equal "topic title attribute", Topic.human_attribute_name("title")
   end
 
   def test_translated_model_attributes_with_symbols
-    I18n.backend.store_translations 'en', :activerecord => {:attributes => {:topic => {:title => 'topic title attribute'} } }
-    assert_equal 'topic title attribute', Topic.human_attribute_name(:title)
+    I18n.backend.store_translations "en", :activerecord => {:attributes => {:topic => {:title => "topic title attribute"} } }
+    assert_equal "topic title attribute", Topic.human_attribute_name(:title)
   end
 
   def test_translated_model_attributes_with_sti
-    I18n.backend.store_translations 'en', :activerecord => {:attributes => {:reply => {:title => 'reply title attribute'} } }
-    assert_equal 'reply title attribute', Reply.human_attribute_name('title')
+    I18n.backend.store_translations "en", :activerecord => {:attributes => {:reply => {:title => "reply title attribute"} } }
+    assert_equal "reply title attribute", Reply.human_attribute_name("title")
   end
 
   def test_translated_model_attributes_with_sti_fallback
-    I18n.backend.store_translations 'en', :activerecord => {:attributes => {:topic => {:title => 'topic title attribute'} } }
-    assert_equal 'topic title attribute', Reply.human_attribute_name('title')
+    I18n.backend.store_translations "en", :activerecord => {:attributes => {:topic => {:title => "topic title attribute"} } }
+    assert_equal "topic title attribute", Reply.human_attribute_name("title")
   end
 
   def test_translated_model_names
-    I18n.backend.store_translations 'en', :activerecord => {:models => {:topic => 'topic model'} }
-    assert_equal 'topic model', Topic.model_name.human
+    I18n.backend.store_translations "en", :activerecord => {:models => {:topic => "topic model"} }
+    assert_equal "topic model", Topic.model_name.human
   end
 
   def test_translated_model_names_with_sti
-    I18n.backend.store_translations 'en', :activerecord => {:models => {:reply => 'reply model'} }
-    assert_equal 'reply model', Reply.model_name.human
+    I18n.backend.store_translations "en", :activerecord => {:models => {:reply => "reply model"} }
+    assert_equal "reply model", Reply.model_name.human
   end
 
   def test_translated_model_names_with_sti_fallback
-    I18n.backend.store_translations 'en', :activerecord => {:models => {:topic => 'topic model'} }
-    assert_equal 'topic model', Reply.model_name.human
+    I18n.backend.store_translations "en", :activerecord => {:models => {:topic => "topic model"} }
+    assert_equal "topic model", Reply.model_name.human
   end
 end
diff --git a/activerecord/test/cases/inheritance_test.rb b/activerecord/test/cases/inheritance_test.rb
index e234b9a6a9..24e049c18a 100644
--- a/activerecord/test/cases/inheritance_test.rb
+++ b/activerecord/test/cases/inheritance_test.rb
@@ -1,13 +1,13 @@
-require 'cases/helper'
-require 'models/author'
-require 'models/company'
-require 'models/person'
-require 'models/post'
-require 'models/project'
-require 'models/subscriber'
-require 'models/vegetables'
-require 'models/shop'
-require 'models/sponsor'
+require "cases/helper"
+require "models/author"
+require "models/company"
+require "models/person"
+require "models/post"
+require "models/project"
+require "models/subscriber"
+require "models/vegetables"
+require "models/shop"
+require "models/sponsor"
 
 module InheritanceTestHelper
   def with_store_full_sti_class(&block)
@@ -33,7 +33,7 @@ class InheritanceTest < ActiveRecord::TestCase
 
   def test_class_with_store_full_sti_class_returns_full_name
     with_store_full_sti_class do
-      assert_equal 'Namespaced::Company', Namespaced::Company.sti_name
+      assert_equal "Namespaced::Company", Namespaced::Company.sti_name
     end
   end
 
@@ -42,37 +42,37 @@ class InheritanceTest < ActiveRecord::TestCase
     company = company.dup
     company.extend(Module.new {
       def _read_attribute(name)
-        return '  ' if name == 'type'
+        return "  " if name == "type"
         super
       end
     })
     company.save!
     company = Company.all.to_a.find { |x| x.id == company.id }
-    assert_equal '  ', company.type
+    assert_equal "  ", company.type
   end
 
   def test_class_without_store_full_sti_class_returns_demodulized_name
     without_store_full_sti_class do
-      assert_equal 'Company', Namespaced::Company.sti_name
+      assert_equal "Company", Namespaced::Company.sti_name
     end
   end
 
   def test_compute_type_success
-    assert_equal Author, ActiveRecord::Base.send(:compute_type, 'Author')
+    assert_equal Author, ActiveRecord::Base.send(:compute_type, "Author")
   end
 
   def test_compute_type_nonexistent_constant
     e = assert_raises NameError do
-      ActiveRecord::Base.send :compute_type, 'NonexistentModel'
+      ActiveRecord::Base.send :compute_type, "NonexistentModel"
     end
-    assert_equal 'uninitialized constant ActiveRecord::Base::NonexistentModel', e.message
-    assert_equal 'ActiveRecord::Base::NonexistentModel', e.name
+    assert_equal "uninitialized constant ActiveRecord::Base::NonexistentModel", e.message
+    assert_equal "ActiveRecord::Base::NonexistentModel", e.name
   end
 
   def test_compute_type_no_method_error
     ActiveSupport::Dependencies.stub(:safe_constantize, proc{ raise NoMethodError }) do
       assert_raises NoMethodError do
-        ActiveRecord::Base.send :compute_type, 'InvalidModel'
+        ActiveRecord::Base.send :compute_type, "InvalidModel"
       end
     end
   end
@@ -90,7 +90,7 @@ class InheritanceTest < ActiveRecord::TestCase
     ActiveSupport::Dependencies.stub(:safe_constantize, proc{ raise e }) do
 
       exception = assert_raises NameError do
-        ActiveRecord::Base.send :compute_type, 'InvalidModel'
+        ActiveRecord::Base.send :compute_type, "InvalidModel"
       end
       assert_equal error.message, exception.message
     end
@@ -99,7 +99,7 @@ class InheritanceTest < ActiveRecord::TestCase
   def test_compute_type_argument_error
     ActiveSupport::Dependencies.stub(:safe_constantize, proc{ raise ArgumentError }) do
       assert_raises ArgumentError do
-        ActiveRecord::Base.send :compute_type, 'InvalidModel'
+        ActiveRecord::Base.send :compute_type, "InvalidModel"
       end
     end
   end
@@ -107,14 +107,14 @@ class InheritanceTest < ActiveRecord::TestCase
   def test_should_store_demodulized_class_name_with_store_full_sti_class_option_disabled
     without_store_full_sti_class do
       item = Namespaced::Company.new
-      assert_equal 'Company', item[:type]
+      assert_equal "Company", item[:type]
     end
   end
 
   def test_should_store_full_class_name_with_store_full_sti_class_option_enabled
     with_store_full_sti_class do
       item = Namespaced::Company.new
-      assert_equal 'Namespaced::Company', item[:type]
+      assert_equal "Namespaced::Company", item[:type]
     end
   end
 
@@ -154,9 +154,9 @@ class InheritanceTest < ActiveRecord::TestCase
 
   def test_company_descends_from_active_record
     assert !ActiveRecord::Base.descends_from_active_record?
-    assert AbstractCompany.descends_from_active_record?, 'AbstractCompany should descend from ActiveRecord::Base'
-    assert Company.descends_from_active_record?, 'Company should descend from ActiveRecord::Base'
-    assert !Class.new(Company).descends_from_active_record?, 'Company subclass should not descend from ActiveRecord::Base'
+    assert AbstractCompany.descends_from_active_record?, "AbstractCompany should descend from ActiveRecord::Base"
+    assert Company.descends_from_active_record?, "Company should descend from ActiveRecord::Base"
+    assert !Class.new(Company).descends_from_active_record?, "Company subclass should not descend from ActiveRecord::Base"
   end
 
   def test_abstract_class
@@ -214,7 +214,7 @@ class InheritanceTest < ActiveRecord::TestCase
   def test_becomes_and_change_tracking_for_inheritance_columns
     cucumber = Vegetable.find(1)
     cabbage = cucumber.becomes!(Cabbage)
-    assert_equal ['Cucumber', 'Cabbage'], cabbage.custom_type_change
+    assert_equal ["Cucumber", "Cabbage"], cabbage.custom_type_change
   end
 
   def test_alt_becomes_bang_resets_inheritance_type_column
@@ -229,13 +229,13 @@ class InheritanceTest < ActiveRecord::TestCase
   end
 
   def test_inheritance_find_all
-    companies = Company.all.merge!(:order => 'id').to_a
+    companies = Company.all.merge!(:order => "id").to_a
     assert_kind_of Firm, companies[0], "37signals should be a firm"
     assert_kind_of Client, companies[1], "Summit should be a client"
   end
 
   def test_alt_inheritance_find_all
-    companies = Vegetable.all.merge!(:order => 'id').to_a
+    companies = Vegetable.all.merge!(:order => "id").to_a
     assert_kind_of Cucumber, companies[0]
     assert_kind_of Cabbage, companies[1]
   end
@@ -250,7 +250,7 @@ class InheritanceTest < ActiveRecord::TestCase
   end
 
   def test_alt_inheritance_save
-    cabbage = Cabbage.new(:name => 'Savoy')
+    cabbage = Cabbage.new(:name => "Savoy")
     cabbage.save!
 
     savoy = Vegetable.find(cabbage.id)
@@ -263,12 +263,12 @@ class InheritanceTest < ActiveRecord::TestCase
   end
 
   def test_inheritance_new_with_base_class
-    company = Company.new(:type => 'Company')
+    company = Company.new(:type => "Company")
     assert_equal Company, company.class
   end
 
   def test_inheritance_new_with_subclass
-    firm = Company.new(:type => 'Firm')
+    firm = Company.new(:type => "Firm")
     assert_equal Firm, firm.class
   end
 
@@ -287,17 +287,17 @@ class InheritanceTest < ActiveRecord::TestCase
   end
 
   def test_new_with_invalid_type
-    assert_raise(ActiveRecord::SubclassNotFound) { Company.new(:type => 'InvalidType') }
+    assert_raise(ActiveRecord::SubclassNotFound) { Company.new(:type => "InvalidType") }
   end
 
   def test_new_with_unrelated_type
-    assert_raise(ActiveRecord::SubclassNotFound) { Company.new(:type => 'Account') }
+    assert_raise(ActiveRecord::SubclassNotFound) { Company.new(:type => "Account") }
   end
 
   def test_new_with_unrelated_namespaced_type
     without_store_full_sti_class do
       e = assert_raises ActiveRecord::SubclassNotFound do
-        Namespaced::Company.new(type: 'Firm')
+        Namespaced::Company.new(type: "Firm")
       end
 
       assert_equal "Invalid single-table inheritance type: Namespaced::Firm is not a subclass of Namespaced::Company", e.message
@@ -305,21 +305,21 @@ class InheritanceTest < ActiveRecord::TestCase
   end
 
   def test_new_with_complex_inheritance
-    assert_nothing_raised { Client.new(type: 'VerySpecialClient') }
+    assert_nothing_raised { Client.new(type: "VerySpecialClient") }
   end
 
   def test_new_without_storing_full_sti_class
     without_store_full_sti_class do
-      item = Company.new(type: 'SpecialCo')
+      item = Company.new(type: "SpecialCo")
       assert_instance_of Company::SpecialCo, item
     end
   end
 
   def test_new_with_autoload_paths
-    path = File.expand_path('../../models/autoloadable', __FILE__)
+    path = File.expand_path("../../models/autoloadable", __FILE__)
     ActiveSupport::Dependencies.autoload_paths << path
 
-    firm = Company.new(:type => 'ExtraFirm')
+    firm = Company.new(:type => "ExtraFirm")
     assert_equal ExtraFirm, firm.class
   ensure
     ActiveSupport::Dependencies.autoload_paths.reject! { |p| p == path }
@@ -428,7 +428,7 @@ class InheritanceTest < ActiveRecord::TestCase
 
   def test_inheritance_without_mapping
     assert_kind_of SpecialSubscriber, SpecialSubscriber.find("webster132")
-    assert_nothing_raised { s = SpecialSubscriber.new("name" => "And breaaaaathe!"); s.id = 'roger'; s.save }
+    assert_nothing_raised { s = SpecialSubscriber.new("name" => "And breaaaaathe!"); s.id = "roger"; s.save }
   end
 
   def test_scope_inherited_properly
@@ -449,7 +449,7 @@ class InheritanceComputeTypeTest < ActiveRecord::TestCase
   def test_instantiation_doesnt_try_to_require_corresponding_file
     without_store_full_sti_class do
       foo = Firm.first.clone
-      foo.type = 'FirmOnTheFly'
+      foo.type = "FirmOnTheFly"
       foo.save!
 
       # Should fail without FirmOnTheFly in the type condition.
@@ -470,30 +470,30 @@ class InheritanceComputeTypeTest < ActiveRecord::TestCase
   end
 
   def test_sti_type_from_attributes_disabled_in_non_sti_class
-    phone = Shop::Product::Type.new(name: 'Phone')
+    phone = Shop::Product::Type.new(name: "Phone")
     product = Shop::Product.new(:type => phone)
     assert product.save
   end
 
   def test_inheritance_new_with_subclass_as_default
     original_type = Company.columns_hash["type"].default
-    ActiveRecord::Base.connection.change_column_default :companies, :type, 'Firm'
+    ActiveRecord::Base.connection.change_column_default :companies, :type, "Firm"
     Company.reset_column_information
 
     firm = Company.new # without arguments
-    assert_equal 'Firm', firm.type
+    assert_equal "Firm", firm.type
     assert_instance_of Firm, firm
 
-    firm = Company.new(firm_name: 'Shri Hans Plastic') # with arguments
-    assert_equal 'Firm', firm.type
+    firm = Company.new(firm_name: "Shri Hans Plastic") # with arguments
+    assert_equal "Firm", firm.type
     assert_instance_of Firm, firm
 
     client = Client.new
-    assert_equal 'Client', client.type
+    assert_equal "Client", client.type
     assert_instance_of Client, client
 
-    firm = Company.new(type: 'Client') # overwrite the default type
-    assert_equal 'Client', firm.type
+    firm = Company.new(type: "Client") # overwrite the default type
+    assert_equal "Client", firm.type
     assert_instance_of Client, firm
   ensure
     ActiveRecord::Base.connection.change_column_default :companies, :type, original_type
@@ -504,7 +504,7 @@ end
 class InheritanceAttributeTest < ActiveRecord::TestCase
 
   class Company < ActiveRecord::Base
-    self.table_name = 'companies'
+    self.table_name = "companies"
     attribute :type, :string, default: "InheritanceAttributeTest::Startup"
   end
 
@@ -516,11 +516,11 @@ class InheritanceAttributeTest < ActiveRecord::TestCase
 
   def test_inheritance_new_with_subclass_as_default
     startup = Company.new # without arguments
-    assert_equal 'InheritanceAttributeTest::Startup', startup.type
+    assert_equal "InheritanceAttributeTest::Startup", startup.type
     assert_instance_of Startup, startup
 
-    empire = Company.new(type: 'InheritanceAttributeTest::Empire') # without arguments
-    assert_equal 'InheritanceAttributeTest::Empire', empire.type
+    empire = Company.new(type: "InheritanceAttributeTest::Empire") # without arguments
+    assert_equal "InheritanceAttributeTest::Empire", empire.type
     assert_instance_of Empire, empire
   end
 end
@@ -555,7 +555,7 @@ class InheritanceAttributeMappingTest < ActiveRecord::TestCase
   end
 
   class Company < ActiveRecord::Base
-    self.table_name = 'companies'
+    self.table_name = "companies"
     attribute :type, :omg_sti
   end
 
@@ -563,18 +563,18 @@ class InheritanceAttributeMappingTest < ActiveRecord::TestCase
   class Empire < Company; end
 
   class Sponsor < ActiveRecord::Base
-    self.table_name = 'sponsors'
+    self.table_name = "sponsors"
     attribute :sponsorable_type, :omg_sti
 
     belongs_to :sponsorable, polymorphic: true
   end
 
   def test_sti_with_custom_type
-    Startup.create! name: 'a Startup'
-    Empire.create! name: 'an Empire'
+    Startup.create! name: "a Startup"
+    Empire.create! name: "an Empire"
 
     assert_equal [["a Startup", "omg_inheritance_attribute_mapping_test/startup"],
-                  ["an Empire", "omg_inheritance_attribute_mapping_test/empire"]], ActiveRecord::Base.connection.select_rows('SELECT name, type FROM companies').sort
+                  ["an Empire", "omg_inheritance_attribute_mapping_test/empire"]], ActiveRecord::Base.connection.select_rows("SELECT name, type FROM companies").sort
     assert_equal [["a Startup", "InheritanceAttributeMappingTest::Startup"],
                   ["an Empire", "InheritanceAttributeMappingTest::Empire"]], Company.all.map { |a| [a.name, a.type] }.sort
 
@@ -583,17 +583,17 @@ class InheritanceAttributeMappingTest < ActiveRecord::TestCase
     startup.save!
 
     assert_equal [["a Startup", "omg_inheritance_attribute_mapping_test/empire"],
-                  ["an Empire", "omg_inheritance_attribute_mapping_test/empire"]], ActiveRecord::Base.connection.select_rows('SELECT name, type FROM companies').sort
+                  ["an Empire", "omg_inheritance_attribute_mapping_test/empire"]], ActiveRecord::Base.connection.select_rows("SELECT name, type FROM companies").sort
 
     assert_equal [["a Startup", "InheritanceAttributeMappingTest::Empire"],
                   ["an Empire", "InheritanceAttributeMappingTest::Empire"]], Company.all.map { |a| [a.name, a.type] }.sort
   end
 
   def test_polymorphic_associations_custom_type
-    startup = Startup.create! name: 'a Startup'
+    startup = Startup.create! name: "a Startup"
     sponsor = Sponsor.create! sponsorable: startup
 
-    assert_equal ["omg_inheritance_attribute_mapping_test/company"], ActiveRecord::Base.connection.select_values('SELECT sponsorable_type FROM sponsors')
+    assert_equal ["omg_inheritance_attribute_mapping_test/company"], ActiveRecord::Base.connection.select_values("SELECT sponsorable_type FROM sponsors")
 
     sponsor = Sponsor.first
     assert_equal startup, sponsor.sponsorable
diff --git a/activerecord/test/cases/integration_test.rb b/activerecord/test/cases/integration_test.rb
index 97a0cdb5db..766917b196 100644
--- a/activerecord/test/cases/integration_test.rb
+++ b/activerecord/test/cases/integration_test.rb
@@ -1,10 +1,10 @@
 
-require 'cases/helper'
-require 'models/company'
-require 'models/developer'
-require 'models/computer'
-require 'models/owner'
-require 'models/pet'
+require "cases/helper"
+require "models/company"
+require "models/developer"
+require "models/computer"
+require "models/owner"
+require "models/pet"
 
 class IntegrationTest < ActiveRecord::TestCase
   fixtures :companies, :developers, :owners, :pets
@@ -21,79 +21,79 @@ class IntegrationTest < ActiveRecord::TestCase
   def test_to_param_returns_id_if_not_persisted_but_id_is_set
     client = Client.new
     client.id = 1
-    assert_equal '1', client.to_param
+    assert_equal "1", client.to_param
   end
 
   def test_to_param_class_method
     firm = Firm.find(4)
-    assert_equal '4-flamboyant-software', firm.to_param
+    assert_equal "4-flamboyant-software", firm.to_param
   end
 
   def test_to_param_class_method_truncates_words_properly
     firm = Firm.find(4)
-    firm.name << ', Inc.'
-    assert_equal '4-flamboyant-software', firm.to_param
+    firm.name << ", Inc."
+    assert_equal "4-flamboyant-software", firm.to_param
   end
 
   def test_to_param_class_method_truncates_after_parameterize
     firm = Firm.find(4)
     firm.name = "Huey, Dewey, & Louie LLC"
     #               123456789T123456789v
-    assert_equal '4-huey-dewey-louie-llc', firm.to_param
+    assert_equal "4-huey-dewey-louie-llc", firm.to_param
   end
 
   def test_to_param_class_method_truncates_after_parameterize_with_hyphens
     firm = Firm.find(4)
     firm.name = "Door-to-Door Wash-n-Fold Service"
     #               123456789T123456789v
-    assert_equal '4-door-to-door-wash-n', firm.to_param
+    assert_equal "4-door-to-door-wash-n", firm.to_param
   end
 
   def test_to_param_class_method_truncates
     firm = Firm.find(4)
-    firm.name = 'a ' * 100
-    assert_equal '4-a-a-a-a-a-a-a-a-a-a', firm.to_param
+    firm.name = "a " * 100
+    assert_equal "4-a-a-a-a-a-a-a-a-a-a", firm.to_param
   end
 
   def test_to_param_class_method_truncates_edge_case
     firm = Firm.find(4)
-    firm.name = 'David HeinemeierHansson'
-    assert_equal '4-david', firm.to_param
+    firm.name = "David HeinemeierHansson"
+    assert_equal "4-david", firm.to_param
   end
 
   def test_to_param_class_method_truncates_case_shown_in_doc
     firm = Firm.find(4)
-    firm.name = 'David Heinemeier Hansson'
-    assert_equal '4-david-heinemeier', firm.to_param
+    firm.name = "David Heinemeier Hansson"
+    assert_equal "4-david-heinemeier", firm.to_param
   end
 
   def test_to_param_class_method_squishes
     firm = Firm.find(4)
     firm.name = "ab \n" * 100
-    assert_equal '4-ab-ab-ab-ab-ab-ab-ab', firm.to_param
+    assert_equal "4-ab-ab-ab-ab-ab-ab-ab", firm.to_param
   end
 
   def test_to_param_class_method_multibyte_character
     firm = Firm.find(4)
     firm.name = "戦場ヶ原 ひたぎ"
-    assert_equal '4', firm.to_param
+    assert_equal "4", firm.to_param
   end
 
   def test_to_param_class_method_uses_default_if_blank
     firm = Firm.find(4)
     firm.name = nil
-    assert_equal '4', firm.to_param
-    firm.name = ' '
-    assert_equal '4', firm.to_param
+    assert_equal "4", firm.to_param
+    firm.name = " "
+    assert_equal "4", firm.to_param
   end
 
   def test_to_param_class_method_uses_default_if_not_persisted
-    firm = Firm.new(name: 'Fancy Shirts')
+    firm = Firm.new(name: "Fancy Shirts")
     assert_equal nil, firm.to_param
   end
 
   def test_to_param_with_no_arguments
-    assert_equal 'Firm', Firm.to_param
+    assert_equal "Firm", Firm.to_param
   end
 
   def test_cache_key_for_existing_record_is_not_timezone_dependent
diff --git a/activerecord/test/cases/invalid_connection_test.rb b/activerecord/test/cases/invalid_connection_test.rb
index a16b52751a..04fb4ed24e 100644
--- a/activerecord/test/cases/invalid_connection_test.rb
+++ b/activerecord/test/cases/invalid_connection_test.rb
@@ -10,7 +10,7 @@ class TestAdapterWithInvalidConnection < ActiveRecord::TestCase
   def setup
     # Can't just use current adapter; sqlite3 will create a database
     # file on the fly.
-    Bird.establish_connection adapter: 'mysql2', database: 'i_do_not_exist'
+    Bird.establish_connection adapter: "mysql2", database: "i_do_not_exist"
   end
 
   teardown do
diff --git a/activerecord/test/cases/invertible_migration_test.rb b/activerecord/test/cases/invertible_migration_test.rb
index aba854820b..861042bef6 100644
--- a/activerecord/test/cases/invertible_migration_test.rb
+++ b/activerecord/test/cases/invertible_migration_test.rb
@@ -6,7 +6,7 @@ end
 module ActiveRecord
   class InvertibleMigrationTest < ActiveRecord::TestCase
     class SilentMigration < ActiveRecord::Migration::Current
-      def write(text = '')
+      def write(text = "")
         # sssshhhhh!!
       end
     end
@@ -291,16 +291,16 @@ module ActiveRecord
 
         migration1.migrate(:up)
         migration2.migrate(:up)
-        assert_equal true, Horse.connection.extension_enabled?('hstore')
+        assert_equal true, Horse.connection.extension_enabled?("hstore")
 
         migration3.migrate(:up)
-        assert_equal false, Horse.connection.extension_enabled?('hstore')
+        assert_equal false, Horse.connection.extension_enabled?("hstore")
 
         migration3.migrate(:down)
-        assert_equal true, Horse.connection.extension_enabled?('hstore')
+        assert_equal true, Horse.connection.extension_enabled?("hstore")
 
         migration2.migrate(:down)
-        assert_equal false, Horse.connection.extension_enabled?('hstore')
+        assert_equal false, Horse.connection.extension_enabled?("hstore")
       end
     end
 
@@ -351,14 +351,14 @@ module ActiveRecord
     end
 
     def test_migrate_down_with_table_name_prefix
-      ActiveRecord::Base.table_name_prefix = 'p_'
-      ActiveRecord::Base.table_name_suffix = '_s'
+      ActiveRecord::Base.table_name_prefix = "p_"
+      ActiveRecord::Base.table_name_suffix = "_s"
       migration = InvertibleMigration.new
       migration.migrate(:up)
       assert_nothing_raised { migration.migrate(:down) }
       ActiveSupport::Deprecation.silence { assert !ActiveRecord::Base.connection.table_exists?("p_horses_s"), "p_horses_s should not exist" }
     ensure
-      ActiveRecord::Base.table_name_prefix = ActiveRecord::Base.table_name_suffix = ''
+      ActiveRecord::Base.table_name_prefix = ActiveRecord::Base.table_name_suffix = ""
     end
 
     def test_migrations_can_handle_foreign_keys_to_specific_tables
diff --git a/activerecord/test/cases/json_serialization_test.rb b/activerecord/test/cases/json_serialization_test.rb
index a222675918..bfa6a05d00 100644
--- a/activerecord/test/cases/json_serialization_test.rb
+++ b/activerecord/test/cases/json_serialization_test.rb
@@ -1,10 +1,10 @@
 require "cases/helper"
-require 'models/contact'
-require 'models/post'
-require 'models/author'
-require 'models/tagging'
-require 'models/tag'
-require 'models/comment'
+require "models/contact"
+require "models/post"
+require "models/author"
+require "models/tagging"
+require "models/tag"
+require "models/comment"
 
 module JsonSerializationHelpers
   private
@@ -27,18 +27,18 @@ class JsonSerializationTest < ActiveRecord::TestCase
 
   def setup
     @contact = Contact.new(
-      :name        => 'Konata Izumi',
+      :name        => "Konata Izumi",
       :age         => 16,
-      :avatar      => 'binarydata',
+      :avatar      => "binarydata",
       :created_at  => Time.utc(2006, 8, 1),
       :awesome     => true,
-      :preferences => { :shows => 'anime' }
+      :preferences => { :shows => "anime" }
     )
   end
 
   def test_should_demodulize_root_in_json
     set_include_root_in_json(true) do
-      @contact = NamespacedContact.new name: 'whatever'
+      @contact = NamespacedContact.new name: "whatever"
       json = @contact.to_json
       assert_match %r{^\{"namespaced_contact":\{}, json
     end
@@ -125,7 +125,7 @@ class JsonSerializationTest < ActiveRecord::TestCase
 
   def test_does_not_include_inheritance_column_from_sti
     @contact = ContactSti.new(@contact.attributes)
-    assert_equal 'ContactSti', @contact.type
+    assert_equal "ContactSti", @contact.type
 
     json = @contact.to_json
     assert_match %r{"name":"Konata Izumi"}, json
@@ -135,7 +135,7 @@ class JsonSerializationTest < ActiveRecord::TestCase
 
   def test_serializable_hash_with_default_except_option_and_excluding_inheritance_column_from_sti
     @contact = ContactSti.new(@contact.attributes)
-    assert_equal 'ContactSti', @contact.type
+    assert_equal "ContactSti", @contact.type
 
     def @contact.serializable_hash(options={})
       super({ except: %w(age) }.merge!(options))
diff --git a/activerecord/test/cases/locking_test.rb b/activerecord/test/cases/locking_test.rb
index 9fc0041892..d0184ad2b3 100644
--- a/activerecord/test/cases/locking_test.rb
+++ b/activerecord/test/cases/locking_test.rb
@@ -1,18 +1,18 @@
-require 'thread'
+require "thread"
 require "cases/helper"
-require 'models/person'
-require 'models/job'
-require 'models/reader'
-require 'models/ship'
-require 'models/legacy_thing'
-require 'models/personal_legacy_thing'
-require 'models/reference'
-require 'models/string_key_object'
-require 'models/car'
-require 'models/bulb'
-require 'models/engine'
-require 'models/wheel'
-require 'models/treasure'
+require "models/person"
+require "models/job"
+require "models/reader"
+require "models/ship"
+require "models/legacy_thing"
+require "models/personal_legacy_thing"
+require "models/reference"
+require "models/string_key_object"
+require "models/car"
+require "models/bulb"
+require "models/engine"
+require "models/wheel"
+require "models/treasure"
 
 class LockWithoutDefault < ActiveRecord::Base; end
 
@@ -33,7 +33,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     p1 = Person.find(1)
     assert_equal 0, p1.lock_version
 
-    p1.first_name = 'anika2'
+    p1.first_name = "anika2"
     p1.save!
 
     assert_equal 1, p1.lock_version
@@ -45,12 +45,12 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_equal 0, s1.lock_version
     assert_equal 0, s2.lock_version
 
-    s1.name = 'updated record'
+    s1.name = "updated record"
     s1.save!
     assert_equal 1, s1.lock_version
     assert_equal 0, s2.lock_version
 
-    s2.name = 'doubly updated record'
+    s2.name = "doubly updated record"
     assert_raise(ActiveRecord::StaleObjectError) { s2.save! }
   end
 
@@ -60,7 +60,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_equal 0, s1.lock_version
     assert_equal 0, s2.lock_version
 
-    s1.name = 'updated record'
+    s1.name = "updated record"
     s1.save!
     assert_equal 1, s1.lock_version
     assert_equal 0, s2.lock_version
@@ -78,12 +78,12 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_equal 0, p1.lock_version
     assert_equal 0, p2.lock_version
 
-    p1.first_name = 'stu'
+    p1.first_name = "stu"
     p1.save!
     assert_equal 1, p1.lock_version
     assert_equal 0, p2.lock_version
 
-    p2.first_name = 'sue'
+    p2.first_name = "sue"
     assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
   end
 
@@ -94,7 +94,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_equal 0, p1.lock_version
     assert_equal 0, p2.lock_version
 
-    p1.first_name = 'stu'
+    p1.first_name = "stu"
     p1.save!
     assert_equal 1, p1.lock_version
     assert_equal 0, p2.lock_version
@@ -113,56 +113,56 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_equal 0, p1.lock_version
     assert_equal 0, p2.lock_version
 
-    p1.first_name = 'stu'
+    p1.first_name = "stu"
     p1.save!
     assert_equal 1, p1.lock_version
     assert_equal 0, p2.lock_version
 
-    p2.first_name = 'sue'
+    p2.first_name = "sue"
     assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
-    p2.first_name = 'sue2'
+    p2.first_name = "sue2"
     assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
   end
 
   def test_lock_new
-    p1 = Person.new(:first_name => 'anika')
+    p1 = Person.new(:first_name => "anika")
     assert_equal 0, p1.lock_version
 
-    p1.first_name = 'anika2'
+    p1.first_name = "anika2"
     p1.save!
     p2 = Person.find(p1.id)
     assert_equal 0, p1.lock_version
     assert_equal 0, p2.lock_version
 
-    p1.first_name = 'anika3'
+    p1.first_name = "anika3"
     p1.save!
     assert_equal 1, p1.lock_version
     assert_equal 0, p2.lock_version
 
-    p2.first_name = 'sue'
+    p2.first_name = "sue"
     assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
   end
 
   def test_lock_exception_record
-    p1 = Person.new(:first_name => 'mira')
+    p1 = Person.new(:first_name => "mira")
     assert_equal 0, p1.lock_version
 
-    p1.first_name = 'mira2'
+    p1.first_name = "mira2"
     p1.save!
     p2 = Person.find(p1.id)
     assert_equal 0, p1.lock_version
     assert_equal 0, p2.lock_version
 
-    p1.first_name = 'mira3'
+    p1.first_name = "mira3"
     p1.save!
 
-    p2.first_name = 'sue'
+    p2.first_name = "sue"
     error = assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
     assert_equal(error.record.object_id, p2.object_id)
   end
 
   def test_lock_new_with_nil
-    p1 = Person.new(:first_name => 'anika')
+    p1 = Person.new(:first_name => "anika")
     p1.save!
     p1.lock_version = nil # simulate bad fixture or column with no default
     p1.save!
@@ -170,7 +170,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
   end
 
   def test_lock_new_when_explicitly_passing_nil
-    p1 = Person.new(:first_name => 'anika', lock_version: nil)
+    p1 = Person.new(:first_name => "anika", lock_version: nil)
     p1.save!
     assert_equal 0, p1.lock_version
   end
@@ -184,9 +184,9 @@ class OptimisticLockingTest < ActiveRecord::TestCase
   end
 
   def test_touch_stale_object
-    person = Person.create!(first_name: 'Mehmet Emin')
+    person = Person.create!(first_name: "Mehmet Emin")
     stale_person = Person.find(person.id)
-    person.update_attribute(:gender, 'M')
+    person.update_attribute(:gender, "M")
 
     assert_raises(ActiveRecord::StaleObjectError) do
       stale_person.touch
@@ -209,11 +209,11 @@ class OptimisticLockingTest < ActiveRecord::TestCase
   end
 
   def test_lock_column_is_mass_assignable
-    p1 = Person.create(:first_name => 'bianca')
+    p1 = Person.create(:first_name => "bianca")
     assert_equal 0, p1.lock_version
     assert_equal p1.lock_version, Person.new(p1.attributes).lock_version
 
-    p1.first_name = 'bianca2'
+    p1.first_name = "bianca2"
     p1.save!
     assert_equal 1, p1.lock_version
     assert_equal p1.lock_version, Person.new(p1.attributes).lock_version
@@ -240,7 +240,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
   end
 
   def test_readonly_attributes
-    assert_equal Set.new([ 'name' ]), ReadonlyNameShip.readonly_attributes
+    assert_equal Set.new([ "name" ]), ReadonlyNameShip.readonly_attributes
 
     s = ReadonlyNameShip.create(:name => "unchangeable name")
     s.reload
@@ -261,7 +261,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
   # is nothing else being updated.
   def test_update_without_attributes_does_not_only_update_lock_version
     assert_nothing_raised do
-      p1 = Person.create!(:first_name => 'anika')
+      p1 = Person.create!(:first_name => "anika")
       lock_version = p1.lock_version
       p1.save
       p1.reload
@@ -272,17 +272,17 @@ class OptimisticLockingTest < ActiveRecord::TestCase
   def test_polymorphic_destroy_with_dependencies_and_lock_version
     car = Car.create!
 
-    assert_difference 'car.wheels.count'  do
+    assert_difference "car.wheels.count"  do
       car.wheels << Wheel.create!
     end
-    assert_difference 'car.wheels.count', -1  do
+    assert_difference "car.wheels.count", -1  do
       car.reload.destroy
     end
     assert car.destroyed?
   end
 
   def test_removing_has_and_belongs_to_many_associations_upon_destroy
-    p = RichPerson.create! first_name: 'Jon'
+    p = RichPerson.create! first_name: "Jon"
     p.treasures.create!
     assert !p.treasures.empty?
     p.destroy
@@ -329,11 +329,11 @@ class OptimisticLockingWithSchemaChangeTest < ActiveRecord::TestCase
   # See Lighthouse ticket #1966
   def test_destroy_dependents
     # Establish dependent relationship between Person and PersonalLegacyThing
-    add_counter_column_to(Person, 'personal_legacy_things_count')
+    add_counter_column_to(Person, "personal_legacy_things_count")
     PersonalLegacyThing.reset_column_information
 
     # Make sure that counter incrementing doesn't cause problems
-    p1 = Person.new(:first_name => 'fjord')
+    p1 = Person.new(:first_name => "fjord")
     p1.save!
     t = PersonalLegacyThing.new(:person => p1)
     t.save!
@@ -344,13 +344,13 @@ class OptimisticLockingWithSchemaChangeTest < ActiveRecord::TestCase
     assert_raises(ActiveRecord::RecordNotFound) { Person.find(p1.id) }
     assert_raises(ActiveRecord::RecordNotFound) { PersonalLegacyThing.find(t.id) }
   ensure
-    remove_counter_column_from(Person, 'personal_legacy_things_count')
+    remove_counter_column_from(Person, "personal_legacy_things_count")
     PersonalLegacyThing.reset_column_information
   end
 
   private
 
-    def add_counter_column_to(model, col='test_count')
+    def add_counter_column_to(model, col="test_count")
       model.connection.add_column model.table_name, col, :integer, :null => false, :default => 0
       model.reset_column_information
     end
@@ -416,7 +416,7 @@ unless in_memory_db?
       assert_nothing_raised do
         Person.transaction do
           person = Person.find 1
-          old, person.first_name = person.first_name, 'fooman'
+          old, person.first_name = person.first_name, "fooman"
           person.lock!
           assert_equal old, person.first_name
         end
@@ -426,19 +426,19 @@ unless in_memory_db?
     def test_with_lock_commits_transaction
       person = Person.find 1
       person.with_lock do
-        person.first_name = 'fooman'
+        person.first_name = "fooman"
         person.save!
       end
-      assert_equal 'fooman', person.reload.first_name
+      assert_equal "fooman", person.reload.first_name
     end
 
     def test_with_lock_rolls_back_transaction
       person = Person.find 1
       old = person.first_name
       person.with_lock do
-        person.first_name = 'fooman'
+        person.first_name = "fooman"
         person.save!
-        raise 'oops'
+        raise "oops"
       end rescue nil
       assert_equal old, person.reload.first_name
     end
@@ -448,7 +448,7 @@ unless in_memory_db?
         Person.transaction do
           person = Person.find(1)
           assert_sql(/LIMIT \$?\d FOR SHARE NOWAIT/) do
-            person.lock!('FOR SHARE NOWAIT')
+            person.lock!("FOR SHARE NOWAIT")
           end
         end
       end
diff --git a/activerecord/test/cases/log_subscriber_test.rb b/activerecord/test/cases/log_subscriber_test.rb
index c97960a412..c594616aa3 100644
--- a/activerecord/test/cases/log_subscriber_test.rb
+++ b/activerecord/test/cases/log_subscriber_test.rb
@@ -60,20 +60,20 @@ class LogSubscriberTest < ActiveRecord::TestCase
     logger = TestDebugLogSubscriber.new
     assert_equal 0, logger.debugs.length
 
-    logger.sql(event.new(0, sql: 'hi mom!'))
+    logger.sql(event.new(0, sql: "hi mom!"))
     assert_equal 1, logger.debugs.length
 
-    logger.sql(event.new(0, sql: 'hi mom!', name: 'foo'))
+    logger.sql(event.new(0, sql: "hi mom!", name: "foo"))
     assert_equal 2, logger.debugs.length
 
-    logger.sql(event.new(0, sql: 'hi mom!', name: 'SCHEMA'))
+    logger.sql(event.new(0, sql: "hi mom!", name: "SCHEMA"))
     assert_equal 2, logger.debugs.length
   end
 
   def test_sql_statements_are_not_squeezed
     event = Struct.new(:duration, :payload)
     logger = TestDebugLogSubscriber.new
-    logger.sql(event.new(0, sql: 'ruby   rails'))
+    logger.sql(event.new(0, sql: "ruby   rails"))
     assert_match(/ruby   rails/, logger.debugs.first)
   end
 
@@ -211,7 +211,7 @@ class LogSubscriberTest < ActiveRecord::TestCase
 
   if ActiveRecord::Base.connection.prepared_statements
     def test_binary_data_is_not_logged
-      Binary.create(data: 'some binary data')
+      Binary.create(data: "some binary data")
       wait
       assert_match(/<16 bytes of binary data>/, @logger.logged(:debug).join)
     end
diff --git a/activerecord/test/cases/migration/change_schema_test.rb b/activerecord/test/cases/migration/change_schema_test.rb
index d6963b48d7..974a0ea8e2 100644
--- a/activerecord/test/cases/migration/change_schema_test.rb
+++ b/activerecord/test/cases/migration/change_schema_test.rb
@@ -1,4 +1,4 @@
-require 'cases/helper'
+require "cases/helper"
 
 module ActiveRecord
   class Migration
@@ -70,7 +70,7 @@ module ActiveRecord
         assert_equal "hello", one.default
         assert_equal true, connection.lookup_cast_type_from_column(two).deserialize(two.default)
         assert_equal false, connection.lookup_cast_type_from_column(three).deserialize(three.default)
-        assert_equal '1', four.default
+        assert_equal "1", four.default
         assert_equal "hello", five.default unless mysql
       end
 
@@ -105,9 +105,9 @@ module ActiveRecord
         eight   = columns.detect { |c| c.name == "eight_int"   }
 
         if current_adapter?(:OracleAdapter)
-          assert_equal 'NUMBER(19)', eight.sql_type
+          assert_equal "NUMBER(19)", eight.sql_type
         elsif current_adapter?(:SQLite3Adapter)
-          assert_equal 'bigint', eight.sql_type
+          assert_equal "bigint", eight.sql_type
         else
           assert_equal :integer, eight.type
           assert_equal 8, eight.limit
@@ -137,20 +137,20 @@ module ActiveRecord
         eight   = columns.detect { |c| c.name == "eight_int"   }
 
         if current_adapter?(:PostgreSQLAdapter)
-          assert_equal 'integer', default.sql_type
-          assert_equal 'smallint', one.sql_type
-          assert_equal 'integer', four.sql_type
-          assert_equal 'bigint', eight.sql_type
+          assert_equal "integer", default.sql_type
+          assert_equal "smallint", one.sql_type
+          assert_equal "integer", four.sql_type
+          assert_equal "bigint", eight.sql_type
         elsif current_adapter?(:Mysql2Adapter)
-          assert_match 'int(11)', default.sql_type
-          assert_match 'tinyint', one.sql_type
-          assert_match 'int', four.sql_type
-          assert_match 'bigint', eight.sql_type
+          assert_match "int(11)", default.sql_type
+          assert_match "tinyint", one.sql_type
+          assert_match "int", four.sql_type
+          assert_match "bigint", eight.sql_type
         elsif current_adapter?(:OracleAdapter)
-          assert_equal 'NUMBER(38)', default.sql_type
-          assert_equal 'NUMBER(1)', one.sql_type
-          assert_equal 'NUMBER(4)', four.sql_type
-          assert_equal 'NUMBER(8)', eight.sql_type
+          assert_equal "NUMBER(38)", default.sql_type
+          assert_equal "NUMBER(1)", one.sql_type
+          assert_equal "NUMBER(4)", four.sql_type
+          assert_equal "NUMBER(8)", eight.sql_type
         end
       end
 
@@ -200,8 +200,8 @@ module ActiveRecord
         end
         created_columns = connection.columns(table_name)
 
-        created_at_column = created_columns.detect {|c| c.name == 'created_at' }
-        updated_at_column = created_columns.detect {|c| c.name == 'updated_at' }
+        created_at_column = created_columns.detect {|c| c.name == "created_at" }
+        updated_at_column = created_columns.detect {|c| c.name == "updated_at" }
 
         assert !created_at_column.null
         assert !updated_at_column.null
@@ -213,8 +213,8 @@ module ActiveRecord
         end
         created_columns = connection.columns(table_name)
 
-        created_at_column = created_columns.detect {|c| c.name == 'created_at' }
-        updated_at_column = created_columns.detect {|c| c.name == 'updated_at' }
+        created_at_column = created_columns.detect {|c| c.name == "created_at" }
+        updated_at_column = created_columns.detect {|c| c.name == "updated_at" }
 
         assert created_at_column.null
         assert updated_at_column.null
@@ -259,14 +259,14 @@ module ActiveRecord
         end
 
         klass = Class.new(ActiveRecord::Base)
-        klass.table_name = 'testings'
+        klass.table_name = "testings"
 
-        assert_equal :datetime, klass.columns_hash['foo'].type
+        assert_equal :datetime, klass.columns_hash["foo"].type
 
         if current_adapter?(:PostgreSQLAdapter)
-          assert_equal 'timestamp without time zone', klass.columns_hash['foo'].sql_type
+          assert_equal "timestamp without time zone", klass.columns_hash["foo"].sql_type
         else
-          assert_equal klass.connection.type_to_sql('datetime'), klass.columns_hash['foo'].sql_type
+          assert_equal klass.connection.type_to_sql("datetime"), klass.columns_hash["foo"].sql_type
         end
       end
 
@@ -290,7 +290,7 @@ module ActiveRecord
           t.column :title, :string
         end
         person_klass = Class.new(ActiveRecord::Base)
-        person_klass.table_name = 'testings'
+        person_klass.table_name = "testings"
 
         person_klass.connection.add_column "testings", "wealth", :integer, :null => false, :default => 99
         person_klass.reset_column_information
@@ -329,7 +329,7 @@ module ActiveRecord
         assert_equal true, person_klass.columns_hash["money"].null
 
         # change_column_null, make it not nullable and set null values to a default value
-        person_klass.connection.execute('UPDATE testings SET money = NULL')
+        person_klass.connection.execute("UPDATE testings SET money = NULL")
         person_klass.connection.change_column_null "testings", "money", false, 2000
         person_klass.reset_column_information
         assert_nil person_klass.columns_hash["money"].default
@@ -380,7 +380,7 @@ module ActiveRecord
           t.column :foo, :string, limit: 100
           t.column :bar, :decimal, precision: 8, scale: 2
           t.column :taggable_id, :integer, null: false
-          t.column :taggable_type, :string, default: 'Photo'
+          t.column :taggable_type, :string, default: "Photo"
         end
 
         assert connection.column_exists?(:testings, :foo, :string, limit: 100)
@@ -389,7 +389,7 @@ module ActiveRecord
         assert_not connection.column_exists?(:testings, :bar, :decimal, precision: nil, scale: nil)
         assert connection.column_exists?(:testings, :taggable_id, :integer, null: false)
         assert_not connection.column_exists?(:testings, :taggable_id, :integer, null: true)
-        assert connection.column_exists?(:testings, :taggable_type, :string, default: 'Photo')
+        assert connection.column_exists?(:testings, :taggable_type, :string, default: "Photo")
         assert_not connection.column_exists?(:testings, :taggable_type, :string, default: nil)
       end
 
diff --git a/activerecord/test/cases/migration/column_attributes_test.rb b/activerecord/test/cases/migration/column_attributes_test.rb
index 2f71ba870d..847000fa0e 100644
--- a/activerecord/test/cases/migration/column_attributes_test.rb
+++ b/activerecord/test/cases/migration/column_attributes_test.rb
@@ -9,7 +9,7 @@ module ActiveRecord
 
       def test_add_column_newline_default
         string = "foo\nbar"
-        add_column 'test_models', 'command', :string, :default => string
+        add_column "test_models", "command", :string, :default => string
         TestModel.reset_column_information
 
         assert_equal string, TestModel.new.command
@@ -18,10 +18,10 @@ module ActiveRecord
       def test_add_remove_single_field_using_string_arguments
         assert_no_column TestModel, :last_name
 
-        add_column 'test_models', 'last_name', :string
+        add_column "test_models", "last_name", :string
         assert_column TestModel, :last_name
 
-        remove_column 'test_models', 'last_name'
+        remove_column "test_models", "last_name"
         assert_no_column TestModel, :last_name
       end
 
@@ -47,7 +47,7 @@ module ActiveRecord
         def test_unabstracted_database_dependent_types
           add_column :test_models, :intelligence_quotient, :tinyint
           TestModel.reset_column_information
-          assert_match(/tinyint/, TestModel.columns_hash['intelligence_quotient'].sql_type)
+          assert_match(/tinyint/, TestModel.columns_hash["intelligence_quotient"].sql_type)
         end
       end
 
@@ -56,9 +56,9 @@ module ActiveRecord
         # functionality. This allows us to more easily catch INSERT being broken,
         # but SELECT actually working fine.
         def test_native_decimal_insert_manual_vs_automatic
-          correct_value = '0012345678901234567890.0123456789'.to_d
+          correct_value = "0012345678901234567890.0123456789".to_d
 
-          connection.add_column "test_models", "wealth", :decimal, :precision => '30', :scale => '10'
+          connection.add_column "test_models", "wealth", :decimal, :precision => "30", :scale => "10"
 
           # Do a manual insertion
           if current_adapter?(:OracleAdapter)
@@ -94,26 +94,26 @@ module ActiveRecord
       end
 
       def test_add_column_with_precision_and_scale
-        connection.add_column 'test_models', 'wealth', :decimal, :precision => 9, :scale => 7
+        connection.add_column "test_models", "wealth", :decimal, :precision => 9, :scale => 7
 
-        wealth_column = TestModel.columns_hash['wealth']
+        wealth_column = TestModel.columns_hash["wealth"]
         assert_equal 9, wealth_column.precision
         assert_equal 7, wealth_column.scale
       end
 
       if current_adapter?(:SQLite3Adapter)
         def test_change_column_preserve_other_column_precision_and_scale
-          connection.add_column 'test_models', 'last_name', :string
-          connection.add_column 'test_models', 'wealth', :decimal, :precision => 9, :scale => 7
+          connection.add_column "test_models", "last_name", :string
+          connection.add_column "test_models", "wealth", :decimal, :precision => 9, :scale => 7
 
-          wealth_column = TestModel.columns_hash['wealth']
+          wealth_column = TestModel.columns_hash["wealth"]
           assert_equal 9, wealth_column.precision
           assert_equal 7, wealth_column.scale
 
-          connection.change_column 'test_models', 'last_name', :string, :null => false
+          connection.change_column "test_models", "last_name", :string, :null => false
           TestModel.reset_column_information
 
-          wealth_column = TestModel.columns_hash['wealth']
+          wealth_column = TestModel.columns_hash["wealth"]
           assert_equal 9, wealth_column.precision
           assert_equal 7, wealth_column.scale
         end
@@ -126,21 +126,21 @@ module ActiveRecord
           add_column "test_models", "bio", :text
           add_column "test_models", "age", :integer
           add_column "test_models", "height", :float
-          add_column "test_models", "wealth", :decimal, :precision => '30', :scale => '10'
+          add_column "test_models", "wealth", :decimal, :precision => "30", :scale => "10"
           add_column "test_models", "birthday", :datetime
           add_column "test_models", "favorite_day", :date
           add_column "test_models", "moment_of_truth", :datetime
           add_column "test_models", "male", :boolean
 
-          TestModel.create :first_name => 'bob', :last_name => 'bobsen',
+          TestModel.create :first_name => "bob", :last_name => "bobsen",
             :bio => "I was born ....", :age => 18, :height => 1.78,
             :wealth => BigDecimal.new("12345678901234567890.0123456789"),
             :birthday => 18.years.ago, :favorite_day => 10.days.ago,
             :moment_of_truth => "1782-10-10 21:40:18", :male => true
 
           bob = TestModel.first
-          assert_equal 'bob', bob.first_name
-          assert_equal 'bobsen', bob.last_name
+          assert_equal "bob", bob.first_name
+          assert_equal "bobsen", bob.last_name
           assert_equal "I was born ....", bob.bio
           assert_equal 18, bob.age
 
diff --git a/activerecord/test/cases/migration/column_positioning_test.rb b/activerecord/test/cases/migration/column_positioning_test.rb
index 8294da0373..0a4215fa78 100644
--- a/activerecord/test/cases/migration/column_positioning_test.rb
+++ b/activerecord/test/cases/migration/column_positioning_test.rb
@@ -1,4 +1,4 @@
-require 'cases/helper'
+require "cases/helper"
 
 module ActiveRecord
   class Migration
diff --git a/activerecord/test/cases/migration/columns_test.rb b/activerecord/test/cases/migration/columns_test.rb
index fca1cb7e97..7098eb1d2c 100644
--- a/activerecord/test/cases/migration/columns_test.rb
+++ b/activerecord/test/cases/migration/columns_test.rb
@@ -13,7 +13,7 @@ module ActiveRecord
         add_column "test_models", "girlfriend", :string
         TestModel.reset_column_information
 
-        TestModel.create :girlfriend => 'bobette'
+        TestModel.create :girlfriend => "bobette"
 
         rename_column "test_models", "girlfriend", "exgirlfriend"
 
@@ -28,12 +28,12 @@ module ActiveRecord
       def test_rename_column_using_symbol_arguments
         add_column :test_models, :first_name, :string
 
-        TestModel.create :first_name => 'foo'
+        TestModel.create :first_name => "foo"
 
         rename_column :test_models, :first_name, :nick_name
         TestModel.reset_column_information
         assert TestModel.column_names.include?("nick_name")
-        assert_equal ['foo'], TestModel.all.map(&:nick_name)
+        assert_equal ["foo"], TestModel.all.map(&:nick_name)
       end
 
       # FIXME: another integration test.  We should decouple this from the
@@ -41,25 +41,25 @@ module ActiveRecord
       def test_rename_column
         add_column "test_models", "first_name", "string"
 
-        TestModel.create :first_name => 'foo'
+        TestModel.create :first_name => "foo"
 
         rename_column "test_models", "first_name", "nick_name"
         TestModel.reset_column_information
         assert TestModel.column_names.include?("nick_name")
-        assert_equal ['foo'], TestModel.all.map(&:nick_name)
+        assert_equal ["foo"], TestModel.all.map(&:nick_name)
       end
 
       def test_rename_column_preserves_default_value_not_null
-        add_column 'test_models', 'salary', :integer, :default => 70000
+        add_column "test_models", "salary", :integer, :default => 70000
 
         default_before = connection.columns("test_models").find { |c| c.name == "salary" }.default
-        assert_equal '70000', default_before
+        assert_equal "70000", default_before
 
         rename_column "test_models", "salary", "annual_salary"
 
         assert TestModel.column_names.include?("annual_salary")
         default_after = connection.columns("test_models").find { |c| c.name == "annual_salary" }.default
-        assert_equal '70000', default_after
+        assert_equal "70000", default_after
       end
 
       if current_adapter?(:Mysql2Adapter)
@@ -84,7 +84,7 @@ module ActiveRecord
       end
 
       def test_rename_column_with_sql_reserved_word
-        add_column 'test_models', 'first_name', :string
+        add_column "test_models", "first_name", :string
         rename_column "test_models", "first_name", "group"
 
         assert TestModel.column_names.include?("group")
@@ -94,10 +94,10 @@ module ActiveRecord
         add_column "test_models", :hat_name, :string
         add_index :test_models, :hat_name
 
-        assert_equal 1, connection.indexes('test_models').size
+        assert_equal 1, connection.indexes("test_models").size
         rename_column "test_models", "hat_name", "name"
 
-        assert_equal ['index_test_models_on_name'], connection.indexes('test_models').map(&:name)
+        assert_equal ["index_test_models_on_name"], connection.indexes("test_models").map(&:name)
       end
 
       def test_rename_column_with_multi_column_index
@@ -105,37 +105,37 @@ module ActiveRecord
         add_column "test_models", :hat_style, :string, limit: 100
         add_index "test_models", ["hat_style", "hat_size"], unique: true
 
-        rename_column "test_models", "hat_size", 'size'
+        rename_column "test_models", "hat_size", "size"
         if current_adapter? :OracleAdapter
-          assert_equal ['i_test_models_hat_style_size'], connection.indexes('test_models').map(&:name)
+          assert_equal ["i_test_models_hat_style_size"], connection.indexes("test_models").map(&:name)
         else
-          assert_equal ['index_test_models_on_hat_style_and_size'], connection.indexes('test_models').map(&:name)
+          assert_equal ["index_test_models_on_hat_style_and_size"], connection.indexes("test_models").map(&:name)
         end
 
-        rename_column "test_models", "hat_style", 'style'
+        rename_column "test_models", "hat_style", "style"
         if current_adapter? :OracleAdapter
-          assert_equal ['i_test_models_style_size'], connection.indexes('test_models').map(&:name)
+          assert_equal ["i_test_models_style_size"], connection.indexes("test_models").map(&:name)
         else
-          assert_equal ['index_test_models_on_style_and_size'], connection.indexes('test_models').map(&:name)
+          assert_equal ["index_test_models_on_style_and_size"], connection.indexes("test_models").map(&:name)
         end
       end
 
       def test_rename_column_does_not_rename_custom_named_index
         add_column "test_models", :hat_name, :string
-        add_index :test_models, :hat_name, :name => 'idx_hat_name'
+        add_index :test_models, :hat_name, :name => "idx_hat_name"
 
-        assert_equal 1, connection.indexes('test_models').size
+        assert_equal 1, connection.indexes("test_models").size
         rename_column "test_models", "hat_name", "name"
-        assert_equal ['idx_hat_name'], connection.indexes('test_models').map(&:name)
+        assert_equal ["idx_hat_name"], connection.indexes("test_models").map(&:name)
       end
 
       def test_remove_column_with_index
         add_column "test_models", :hat_name, :string
         add_index :test_models, :hat_name
 
-        assert_equal 1, connection.indexes('test_models').size
+        assert_equal 1, connection.indexes("test_models").size
         remove_column("test_models", "hat_name")
-        assert_equal 0, connection.indexes('test_models').size
+        assert_equal 0, connection.indexes("test_models").size
       end
 
       def test_remove_column_with_multi_column_index
@@ -143,15 +143,15 @@ module ActiveRecord
         add_column "test_models", :hat_style, :string, :limit => 100
         add_index "test_models", ["hat_style", "hat_size"], :unique => true
 
-        assert_equal 1, connection.indexes('test_models').size
+        assert_equal 1, connection.indexes("test_models").size
         remove_column("test_models", "hat_size")
 
         # Every database and/or database adapter has their own behavior
         # if it drops the multi-column index when any of the indexed columns dropped by remove_column.
         if current_adapter?(:PostgreSQLAdapter, :OracleAdapter)
-          assert_equal [], connection.indexes('test_models').map(&:name)
+          assert_equal [], connection.indexes("test_models").map(&:name)
         else
-          assert_equal ['index_test_models_on_hat_style_and_hat_size'], connection.indexes('test_models').map(&:name)
+          assert_equal ["index_test_models_on_hat_style_and_hat_size"], connection.indexes("test_models").map(&:name)
         end
       end
 
@@ -160,7 +160,7 @@ module ActiveRecord
         change_column "test_models", "updated_at", :datetime, :null => false
 
         TestModel.reset_column_information
-        assert_equal false, TestModel.columns_hash['updated_at'].null
+        assert_equal false, TestModel.columns_hash["updated_at"].null
       ensure
         change_column "test_models", "updated_at", :datetime, :null => true
       end
@@ -180,24 +180,24 @@ module ActiveRecord
       end
 
       def test_change_column
-        add_column 'test_models', 'age', :integer
-        add_column 'test_models', 'approved', :boolean, :default => true
+        add_column "test_models", "age", :integer
+        add_column "test_models", "approved", :boolean, :default => true
 
         old_columns = connection.columns(TestModel.table_name)
 
-        assert old_columns.find { |c| c.name == 'age' && c.type == :integer }
+        assert old_columns.find { |c| c.name == "age" && c.type == :integer }
 
         change_column "test_models", "age", :string
 
         new_columns = connection.columns(TestModel.table_name)
 
-        assert_not new_columns.find { |c| c.name == 'age' and c.type == :integer }
-        assert new_columns.find { |c| c.name == 'age' and c.type == :string }
+        assert_not new_columns.find { |c| c.name == "age" and c.type == :integer }
+        assert new_columns.find { |c| c.name == "age" and c.type == :string }
 
         old_columns = connection.columns(TestModel.table_name)
         assert old_columns.find { |c|
           default = connection.lookup_cast_type_from_column(c).deserialize(c.default)
-          c.name == 'approved' && c.type == :boolean && default == true
+          c.name == "approved" && c.type == :boolean && default == true
         }
 
         change_column :test_models, :approved, :boolean, :default => false
@@ -205,11 +205,11 @@ module ActiveRecord
 
         assert_not new_columns.find { |c|
           default = connection.lookup_cast_type_from_column(c).deserialize(c.default)
-          c.name == 'approved' and c.type == :boolean and default == true
+          c.name == "approved" and c.type == :boolean and default == true
         }
         assert new_columns.find { |c|
           default = connection.lookup_cast_type_from_column(c).deserialize(c.default)
-          c.name == 'approved' and c.type == :boolean and default == false
+          c.name == "approved" and c.type == :boolean and default == false
         }
         change_column :test_models, :approved, :boolean, :default => true
       end
@@ -235,23 +235,23 @@ module ActiveRecord
 
       def test_change_column_with_custom_index_name
         add_column "test_models", "category", :string
-        add_index :test_models, :category, name: 'test_models_categories_idx'
+        add_index :test_models, :category, name: "test_models_categories_idx"
 
-        assert_equal ['test_models_categories_idx'], connection.indexes('test_models').map(&:name)
-        change_column "test_models", "category", :string, null: false, default: 'article'
+        assert_equal ["test_models_categories_idx"], connection.indexes("test_models").map(&:name)
+        change_column "test_models", "category", :string, null: false, default: "article"
 
-        assert_equal ['test_models_categories_idx'], connection.indexes('test_models').map(&:name)
+        assert_equal ["test_models_categories_idx"], connection.indexes("test_models").map(&:name)
       end
 
       def test_change_column_with_long_index_name
-        table_name_prefix = 'test_models_'
-        long_index_name = table_name_prefix + ('x' * (connection.allowed_index_name_length - table_name_prefix.length))
+        table_name_prefix = "test_models_"
+        long_index_name = table_name_prefix + ("x" * (connection.allowed_index_name_length - table_name_prefix.length))
         add_column "test_models", "category", :string
         add_index :test_models, :category, name: long_index_name
 
-        change_column "test_models", "category", :string, null: false, default: 'article'
+        change_column "test_models", "category", :string, null: false, default: "article"
 
-        assert_equal [long_index_name], connection.indexes('test_models').map(&:name)
+        assert_equal [long_index_name], connection.indexes("test_models").map(&:name)
       end
 
       def test_change_column_default
@@ -287,7 +287,7 @@ module ActiveRecord
         remove_column("my_table", "col_two")
         rename_column("my_table", "col_one", "col_three")
 
-        assert_equal 'my_table_id', connection.primary_key('my_table')
+        assert_equal "my_table_id", connection.primary_key("my_table")
       ensure
         connection.drop_table(:my_table) rescue nil
       end
diff --git a/activerecord/test/cases/migration/command_recorder_test.rb b/activerecord/test/cases/migration/command_recorder_test.rb
index 1e3529db54..39f3fd99c7 100644
--- a/activerecord/test/cases/migration/command_recorder_test.rb
+++ b/activerecord/test/cases/migration/command_recorder_test.rb
@@ -25,26 +25,26 @@ module ActiveRecord
         recorder = CommandRecorder.new(Class.new {
           def create_table(name); end
         }.new)
-        assert recorder.respond_to?(:create_table), 'respond_to? create_table'
+        assert recorder.respond_to?(:create_table), "respond_to? create_table"
         recorder.send(:create_table, :horses)
         assert_equal [[:create_table, [:horses], nil]], recorder.commands
       end
 
       def test_unknown_commands_delegate
         recorder = Struct.new(:foo)
-        recorder = CommandRecorder.new(recorder.new('bar'))
-        assert_equal 'bar', recorder.foo
+        recorder = CommandRecorder.new(recorder.new("bar"))
+        assert_equal "bar", recorder.foo
       end
 
       def test_inverse_of_raise_exception_on_unknown_commands
         assert_raises(ActiveRecord::IrreversibleMigration) do
-          @recorder.inverse_of :execute, ['some sql']
+          @recorder.inverse_of :execute, ["some sql"]
         end
       end
 
       def test_irreversible_commands_raise_exception
         assert_raises(ActiveRecord::IrreversibleMigration) do
-          @recorder.revert{ @recorder.execute 'some sql' }
+          @recorder.revert{ @recorder.execute "some sql" }
         end
       end
 
@@ -166,7 +166,7 @@ module ActiveRecord
 
       def test_invert_change_column_default
         assert_raises(ActiveRecord::IrreversibleMigration) do
-          @recorder.inverse_of :change_column_default, [:table, :column, 'default_value']
+          @recorder.inverse_of :change_column_default, [:table, :column, "default_value"]
         end
       end
 
@@ -283,13 +283,13 @@ module ActiveRecord
       end
 
       def test_invert_enable_extension
-        disable = @recorder.inverse_of :enable_extension, ['uuid-ossp']
-        assert_equal [:disable_extension, ['uuid-ossp'], nil], disable
+        disable = @recorder.inverse_of :enable_extension, ["uuid-ossp"]
+        assert_equal [:disable_extension, ["uuid-ossp"], nil], disable
       end
 
       def test_invert_disable_extension
-        enable = @recorder.inverse_of :disable_extension, ['uuid-ossp']
-        assert_equal [:enable_extension, ['uuid-ossp'], nil], enable
+        enable = @recorder.inverse_of :disable_extension, ["uuid-ossp"]
+        assert_equal [:enable_extension, ["uuid-ossp"], nil], enable
       end
 
       def test_invert_add_foreign_key
diff --git a/activerecord/test/cases/migration/compatibility_test.rb b/activerecord/test/cases/migration/compatibility_test.rb
index 60ca90464d..bb249e5deb 100644
--- a/activerecord/test/cases/migration/compatibility_test.rb
+++ b/activerecord/test/cases/migration/compatibility_test.rb
@@ -1,4 +1,4 @@
-require 'cases/helper'
+require "cases/helper"
 
 module ActiveRecord
   class Migration
@@ -83,8 +83,8 @@ module ActiveRecord
 
         ActiveRecord::Migrator.new(:up, [migration]).migrate
 
-        assert connection.columns(:more_testings).find { |c| c.name == 'created_at' }.null
-        assert connection.columns(:more_testings).find { |c| c.name == 'updated_at' }.null
+        assert connection.columns(:more_testings).find { |c| c.name == "created_at" }.null
+        assert connection.columns(:more_testings).find { |c| c.name == "updated_at" }.null
       ensure
         connection.drop_table :more_testings rescue nil
       end
@@ -98,8 +98,8 @@ module ActiveRecord
 
         ActiveRecord::Migrator.new(:up, [migration]).migrate
 
-        assert connection.columns(:testings).find { |c| c.name == 'created_at' }.null
-        assert connection.columns(:testings).find { |c| c.name == 'updated_at' }.null
+        assert connection.columns(:testings).find { |c| c.name == "created_at" }.null
+        assert connection.columns(:testings).find { |c| c.name == "updated_at" }.null
       end
 
       def test_legacy_migrations_get_deprecation_warning_when_run
diff --git a/activerecord/test/cases/migration/create_join_table_test.rb b/activerecord/test/cases/migration/create_join_table_test.rb
index 920c472c73..372ec40a04 100644
--- a/activerecord/test/cases/migration/create_join_table_test.rb
+++ b/activerecord/test/cases/migration/create_join_table_test.rb
@@ -1,4 +1,4 @@
-require 'cases/helper'
+require "cases/helper"
 
 module ActiveRecord
   class Migration
@@ -31,13 +31,13 @@ module ActiveRecord
       end
 
       def test_create_join_table_with_strings
-        connection.create_join_table 'artists', 'musics'
+        connection.create_join_table "artists", "musics"
 
         assert_equal %w(artist_id music_id), connection.columns(:artists_musics).map(&:name).sort
       end
 
       def test_create_join_table_with_symbol_and_string
-        connection.create_join_table :artists, 'musics'
+        connection.create_join_table :artists, "musics"
 
         assert_equal %w(artist_id music_id), connection.columns(:artists_musics).map(&:name).sort
       end
@@ -55,7 +55,7 @@ module ActiveRecord
       end
 
       def test_create_join_table_with_the_table_name_as_string
-        connection.create_join_table :artists, :musics, table_name: 'catalog'
+        connection.create_join_table :artists, :musics, table_name: "catalog"
 
         assert_equal %w(artist_id music_id), connection.columns(:catalog).map(&:name).sort
       end
@@ -84,51 +84,51 @@ module ActiveRecord
         connection.create_join_table :artists, :musics
         connection.drop_join_table :artists, :musics
 
-        ActiveSupport::Deprecation.silence { assert !connection.table_exists?('artists_musics') }
+        ActiveSupport::Deprecation.silence { assert !connection.table_exists?("artists_musics") }
       end
 
       def test_drop_join_table_with_strings
         connection.create_join_table :artists, :musics
-        connection.drop_join_table 'artists', 'musics'
+        connection.drop_join_table "artists", "musics"
 
-        ActiveSupport::Deprecation.silence { assert !connection.table_exists?('artists_musics') }
+        ActiveSupport::Deprecation.silence { assert !connection.table_exists?("artists_musics") }
       end
 
       def test_drop_join_table_with_the_proper_order
         connection.create_join_table :videos, :musics
         connection.drop_join_table :videos, :musics
 
-        ActiveSupport::Deprecation.silence { assert !connection.table_exists?('musics_videos') }
+        ActiveSupport::Deprecation.silence { assert !connection.table_exists?("musics_videos") }
       end
 
       def test_drop_join_table_with_the_table_name
         connection.create_join_table :artists, :musics, table_name: :catalog
         connection.drop_join_table :artists, :musics, table_name: :catalog
 
-        ActiveSupport::Deprecation.silence { assert !connection.table_exists?('catalog') }
+        ActiveSupport::Deprecation.silence { assert !connection.table_exists?("catalog") }
       end
 
       def test_drop_join_table_with_the_table_name_as_string
-        connection.create_join_table :artists, :musics, table_name: 'catalog'
-        connection.drop_join_table :artists, :musics, table_name: 'catalog'
+        connection.create_join_table :artists, :musics, table_name: "catalog"
+        connection.drop_join_table :artists, :musics, table_name: "catalog"
 
-        ActiveSupport::Deprecation.silence { assert !connection.table_exists?('catalog') }
+        ActiveSupport::Deprecation.silence { assert !connection.table_exists?("catalog") }
       end
 
       def test_drop_join_table_with_column_options
         connection.create_join_table :artists, :musics, column_options: {null: true}
         connection.drop_join_table :artists, :musics, column_options: {null: true}
 
-        ActiveSupport::Deprecation.silence { assert !connection.table_exists?('artists_musics') }
+        ActiveSupport::Deprecation.silence { assert !connection.table_exists?("artists_musics") }
       end
 
       def test_create_and_drop_join_table_with_common_prefix
         with_table_cleanup do
-          connection.create_join_table 'audio_artists', 'audio_musics'
-          ActiveSupport::Deprecation.silence { assert connection.table_exists?('audio_artists_musics') }
+          connection.create_join_table "audio_artists", "audio_musics"
+          ActiveSupport::Deprecation.silence { assert connection.table_exists?("audio_artists_musics") }
 
-          connection.drop_join_table 'audio_artists', 'audio_musics'
-          ActiveSupport::Deprecation.silence { assert !connection.table_exists?('audio_artists_musics'), "Should have dropped join table, but didn't" }
+          connection.drop_join_table "audio_artists", "audio_musics"
+          ActiveSupport::Deprecation.silence { assert !connection.table_exists?("audio_artists_musics"), "Should have dropped join table, but didn't" }
         end
       end
 
diff --git a/activerecord/test/cases/migration/foreign_key_test.rb b/activerecord/test/cases/migration/foreign_key_test.rb
index 4237e89731..b47df24b13 100644
--- a/activerecord/test/cases/migration/foreign_key_test.rb
+++ b/activerecord/test/cases/migration/foreign_key_test.rb
@@ -1,6 +1,6 @@
-require 'cases/helper'
-require 'support/ddl_helper'
-require 'support/schema_dumping_helper'
+require "cases/helper"
+require "support/ddl_helper"
+require "support/schema_dumping_helper"
 
 if ActiveRecord::Base.connection.supports_foreign_keys?
 module ActiveRecord
@@ -268,7 +268,7 @@ module ActiveRecord
       end
 
       def test_add_foreign_key_with_prefix
-        ActiveRecord::Base.table_name_prefix = 'p_'
+        ActiveRecord::Base.table_name_prefix = "p_"
         migration = CreateSchoolsAndClassesMigration.new
         silence_stream($stdout) { migration.migrate(:up) }
         assert_equal 1, @connection.foreign_keys("p_classes").size
@@ -278,7 +278,7 @@ module ActiveRecord
       end
 
       def test_add_foreign_key_with_suffix
-        ActiveRecord::Base.table_name_suffix = '_s'
+        ActiveRecord::Base.table_name_suffix = "_s"
         migration = CreateSchoolsAndClassesMigration.new
         silence_stream($stdout) { migration.migrate(:up) }
         assert_equal 1, @connection.foreign_keys("classes_s").size
diff --git a/activerecord/test/cases/migration/index_test.rb b/activerecord/test/cases/migration/index_test.rb
index 5abd37bfa2..d9b2bc9957 100644
--- a/activerecord/test/cases/migration/index_test.rb
+++ b/activerecord/test/cases/migration/index_test.rb
@@ -1,4 +1,4 @@
-require 'cases/helper'
+require "cases/helper"
 
 module ActiveRecord
   class Migration
@@ -28,32 +28,32 @@ module ActiveRecord
 
       def test_rename_index
         # keep the names short to make Oracle and similar behave
-        connection.add_index(table_name, [:foo], :name => 'old_idx')
-        connection.rename_index(table_name, 'old_idx', 'new_idx')
+        connection.add_index(table_name, [:foo], :name => "old_idx")
+        connection.rename_index(table_name, "old_idx", "new_idx")
 
         # if the adapter doesn't support the indexes call, pick defaults that let the test pass
-        assert_not connection.index_name_exists?(table_name, 'old_idx', false)
-        assert connection.index_name_exists?(table_name, 'new_idx', true)
+        assert_not connection.index_name_exists?(table_name, "old_idx", false)
+        assert connection.index_name_exists?(table_name, "new_idx", true)
       end
 
       def test_rename_index_too_long
-        too_long_index_name = good_index_name + 'x'
+        too_long_index_name = good_index_name + "x"
         # keep the names short to make Oracle and similar behave
-        connection.add_index(table_name, [:foo], :name => 'old_idx')
+        connection.add_index(table_name, [:foo], :name => "old_idx")
         e = assert_raises(ArgumentError) {
-          connection.rename_index(table_name, 'old_idx', too_long_index_name)
+          connection.rename_index(table_name, "old_idx", too_long_index_name)
         }
         assert_match(/too long; the limit is #{connection.allowed_index_name_length} characters/, e.message)
 
         # if the adapter doesn't support the indexes call, pick defaults that let the test pass
-        assert connection.index_name_exists?(table_name, 'old_idx', false)
+        assert connection.index_name_exists?(table_name, "old_idx", false)
       end
 
 
       def test_double_add_index
-        connection.add_index(table_name, [:foo], :name => 'some_idx')
+        connection.add_index(table_name, [:foo], :name => "some_idx")
         assert_raises(ArgumentError) {
-          connection.add_index(table_name, [:foo], :name => 'some_idx')
+          connection.add_index(table_name, [:foo], :name => "some_idx")
         }
       end
 
@@ -69,7 +69,7 @@ module ActiveRecord
       end
 
       def test_add_index_does_not_accept_too_long_index_names
-        too_long_index_name = good_index_name + 'x'
+        too_long_index_name = good_index_name + "x"
 
         e = assert_raises(ArgumentError) {
           connection.add_index(table_name, "foo", name: too_long_index_name)
@@ -81,7 +81,7 @@ module ActiveRecord
       end
 
       def test_internal_index_with_name_matching_database_limit
-        good_index_name = 'x' * connection.index_name_length
+        good_index_name = "x" * connection.index_name_length
         connection.add_index(table_name, "foo", name: good_index_name, internal: true)
 
         assert connection.index_name_exists?(table_name, good_index_name, false)
@@ -210,7 +210,7 @@ module ActiveRecord
 
       private
         def good_index_name
-          'x' * connection.allowed_index_name_length
+          "x" * connection.allowed_index_name_length
         end
 
     end
diff --git a/activerecord/test/cases/migration/logger_test.rb b/activerecord/test/cases/migration/logger_test.rb
index bf6e684887..72d4345702 100644
--- a/activerecord/test/cases/migration/logger_test.rb
+++ b/activerecord/test/cases/migration/logger_test.rb
@@ -26,7 +26,7 @@ module ActiveRecord
       def test_migration_should_be_run_without_logger
         previous_logger = ActiveRecord::Base.logger
         ActiveRecord::Base.logger = nil
-        migrations = [Migration.new('a', 1), Migration.new('b', 2), Migration.new('c', 3)]
+        migrations = [Migration.new("a", 1), Migration.new("b", 2), Migration.new("c", 3)]
         ActiveRecord::Migrator.new(:up, migrations).migrate
       ensure
         ActiveRecord::Base.logger = previous_logger
diff --git a/activerecord/test/cases/migration/pending_migrations_test.rb b/activerecord/test/cases/migration/pending_migrations_test.rb
index 4f5589f32a..61f5a061b0 100644
--- a/activerecord/test/cases/migration/pending_migrations_test.rb
+++ b/activerecord/test/cases/migration/pending_migrations_test.rb
@@ -1,4 +1,4 @@
-require 'cases/helper'
+require "cases/helper"
 
 module ActiveRecord
   class Migration
diff --git a/activerecord/test/cases/migration/references_foreign_key_test.rb b/activerecord/test/cases/migration/references_foreign_key_test.rb
index 9e19eb9f73..992d003e7e 100644
--- a/activerecord/test/cases/migration/references_foreign_key_test.rb
+++ b/activerecord/test/cases/migration/references_foreign_key_test.rb
@@ -1,4 +1,4 @@
-require 'cases/helper'
+require "cases/helper"
 
 if ActiveRecord::Base.connection.supports_foreign_keys?
 module ActiveRecord
@@ -156,7 +156,7 @@ module ActiveRecord
       end
 
       def test_references_foreign_key_with_prefix
-        ActiveRecord::Base.table_name_prefix = 'p_'
+        ActiveRecord::Base.table_name_prefix = "p_"
         migration = CreateDogsMigration.new
         silence_stream($stdout) { migration.migrate(:up) }
         assert_equal 1, @connection.foreign_keys("p_dogs").size
@@ -166,7 +166,7 @@ module ActiveRecord
       end
 
       def test_references_foreign_key_with_suffix
-        ActiveRecord::Base.table_name_suffix = '_s'
+        ActiveRecord::Base.table_name_suffix = "_s"
         migration = CreateDogsMigration.new
         silence_stream($stdout) { migration.migrate(:up) }
         assert_equal 1, @connection.foreign_keys("dogs_s").size
diff --git a/activerecord/test/cases/migration/references_index_test.rb b/activerecord/test/cases/migration/references_index_test.rb
index a9a7f0f4c4..481fe42a8b 100644
--- a/activerecord/test/cases/migration/references_index_test.rb
+++ b/activerecord/test/cases/migration/references_index_test.rb
@@ -1,4 +1,4 @@
-require 'cases/helper'
+require "cases/helper"
 
 module ActiveRecord
   class Migration
diff --git a/activerecord/test/cases/migration/references_statements_test.rb b/activerecord/test/cases/migration/references_statements_test.rb
index 5dddb35c4c..8d0acaaa6e 100644
--- a/activerecord/test/cases/migration/references_statements_test.rb
+++ b/activerecord/test/cases/migration/references_statements_test.rb
@@ -46,18 +46,18 @@ module ActiveRecord
       end
 
       def test_creates_reference_type_column_with_default
-        add_reference table_name, :taggable, polymorphic: { default: 'Photo' }, index: true
-        assert column_exists?(table_name, :taggable_type, :string, default: 'Photo')
+        add_reference table_name, :taggable, polymorphic: { default: "Photo" }, index: true
+        assert column_exists?(table_name, :taggable_type, :string, default: "Photo")
       end
 
       def test_creates_named_index
-        add_reference table_name, :tag, index: { name: 'index_taggings_on_tag_id' }
-        assert index_exists?(table_name, :tag_id, name: 'index_taggings_on_tag_id')
+        add_reference table_name, :tag, index: { name: "index_taggings_on_tag_id" }
+        assert index_exists?(table_name, :tag_id, name: "index_taggings_on_tag_id")
       end
 
       def test_creates_named_unique_index
-        add_reference table_name, :tag, index: { name: 'index_taggings_on_tag_id', unique: true }
-        assert index_exists?(table_name, :tag_id, name: 'index_taggings_on_tag_id', unique: true )
+        add_reference table_name, :tag, index: { name: "index_taggings_on_tag_id", unique: true }
+        assert index_exists?(table_name, :tag_id, name: "index_taggings_on_tag_id", unique: true )
       end
 
       def test_creates_reference_id_with_specified_type
diff --git a/activerecord/test/cases/migration/rename_table_test.rb b/activerecord/test/cases/migration/rename_table_test.rb
index b926a92849..5474c9ce71 100644
--- a/activerecord/test/cases/migration/rename_table_test.rb
+++ b/activerecord/test/cases/migration/rename_table_test.rb
@@ -9,9 +9,9 @@ module ActiveRecord
 
       def setup
         super
-        add_column 'test_models', :url, :string
-        remove_column 'test_models', :created_at
-        remove_column 'test_models', :updated_at
+        add_column "test_models", :url, :string
+        remove_column "test_models", :created_at
+        remove_column "test_models", :updated_at
       end
 
       def teardown
@@ -31,7 +31,7 @@ module ActiveRecord
 
           # Using explicit id in insert for compatibility across all databases
           connection.execute "INSERT INTO 'references' (url, created_at, updated_at) VALUES ('http://rubyonrails.com', 0, 0)"
-          assert_equal 'http://rubyonrails.com', connection.select_value("SELECT url FROM 'references' WHERE id=1")
+          assert_equal "http://rubyonrails.com", connection.select_value("SELECT url FROM 'references' WHERE id=1")
         ensure
           return unless renamed
           connection.rename_table :references, :test_models
@@ -45,7 +45,7 @@ module ActiveRecord
 
           connection.execute "INSERT INTO octopi (#{connection.quote_column_name('id')}, #{connection.quote_column_name('url')}) VALUES (1, 'http://www.foreverflying.com/octopus-black7.jpg')"
 
-          assert_equal 'http://www.foreverflying.com/octopus-black7.jpg', connection.select_value("SELECT url FROM octopi WHERE id=1")
+          assert_equal "http://www.foreverflying.com/octopus-black7.jpg", connection.select_value("SELECT url FROM octopi WHERE id=1")
         end
 
         def test_rename_table_with_an_index
@@ -55,18 +55,18 @@ module ActiveRecord
 
           connection.execute "INSERT INTO octopi (#{connection.quote_column_name('id')}, #{connection.quote_column_name('url')}) VALUES (1, 'http://www.foreverflying.com/octopus-black7.jpg')"
 
-          assert_equal 'http://www.foreverflying.com/octopus-black7.jpg', connection.select_value("SELECT url FROM octopi WHERE id=1")
+          assert_equal "http://www.foreverflying.com/octopus-black7.jpg", connection.select_value("SELECT url FROM octopi WHERE id=1")
           index = connection.indexes(:octopi).first
           assert index.columns.include?("url")
-          assert_equal 'index_octopi_on_url', index.name
+          assert_equal "index_octopi_on_url", index.name
         end
 
         def test_rename_table_does_not_rename_custom_named_index
-          add_index :test_models, :url, name: 'special_url_idx'
+          add_index :test_models, :url, name: "special_url_idx"
 
           rename_table :test_models, :octopi
 
-          assert_equal ['special_url_idx'], connection.indexes(:octopi).map(&:name)
+          assert_equal ["special_url_idx"], connection.indexes(:octopi).map(&:name)
         end
       end
 
@@ -74,7 +74,7 @@ module ActiveRecord
         def test_rename_table_for_postgresql_should_also_rename_default_sequence
           rename_table :test_models, :octopi
 
-          pk, seq = connection.pk_and_sequence_for('octopi')
+          pk, seq = connection.pk_and_sequence_for("octopi")
 
           assert_equal ConnectionAdapters::PostgreSQL::Name.new("public", "octopi_#{pk}_seq"), seq
         end
diff --git a/activerecord/test/cases/migration_test.rb b/activerecord/test/cases/migration_test.rb
index d499aadbae..edfde0a52b 100644
--- a/activerecord/test/cases/migration_test.rb
+++ b/activerecord/test/cases/migration_test.rb
@@ -1,12 +1,12 @@
-require 'cases/helper'
-require 'cases/migration/helper'
-require 'bigdecimal/util'
-require 'concurrent/atomic/count_down_latch'
+require "cases/helper"
+require "cases/migration/helper"
+require "bigdecimal/util"
+require "concurrent/atomic/count_down_latch"
 
-require 'models/person'
-require 'models/topic'
-require 'models/developer'
-require 'models/computer'
+require "models/person"
+require "models/topic"
+require "models/developer"
+require "models/computer"
 
 require MIGRATIONS_ROOT + "/valid/2_we_need_reminders"
 require MIGRATIONS_ROOT + "/rename/1_we_need_things"
@@ -59,7 +59,7 @@ class MigrationTest < ActiveRecord::TestCase
 
     %w(last_name key bio age height wealth birthday favorite_day
        moment_of_truth male administrator funny).each do |column|
-      Person.connection.remove_column('people', column) rescue nil
+      Person.connection.remove_column("people", column) rescue nil
     end
     Person.connection.remove_column("people", "first_name") rescue nil
     Person.connection.remove_column("people", "middle_name") rescue nil
@@ -93,7 +93,7 @@ class MigrationTest < ActiveRecord::TestCase
   end
 
   def test_migration_detection_without_schema_migration_table
-    ActiveRecord::Base.connection.drop_table 'schema_migrations', if_exists: true
+    ActiveRecord::Base.connection.drop_table "schema_migrations", if_exists: true
 
     migrations_path = MIGRATIONS_ROOT + "/valid"
     old_path = ActiveRecord::Migrator.migrations_paths
@@ -248,22 +248,22 @@ class MigrationTest < ActiveRecord::TestCase
 
   def test_instance_based_migration_up
     migration = MockMigration.new
-    assert !migration.went_up, 'have not gone up'
-    assert !migration.went_down, 'have not gone down'
+    assert !migration.went_up, "have not gone up"
+    assert !migration.went_down, "have not gone down"
 
     migration.migrate :up
-    assert migration.went_up, 'have gone up'
-    assert !migration.went_down, 'have not gone down'
+    assert migration.went_up, "have gone up"
+    assert !migration.went_down, "have not gone down"
   end
 
   def test_instance_based_migration_down
     migration = MockMigration.new
-    assert !migration.went_up, 'have not gone up'
-    assert !migration.went_down, 'have not gone down'
+    assert !migration.went_up, "have not gone up"
+    assert !migration.went_down, "have not gone down"
 
     migration.migrate :down
-    assert !migration.went_up, 'have gone up'
-    assert migration.went_down, 'have not gone down'
+    assert !migration.went_up, "have gone up"
+    assert migration.went_down, "have not gone down"
   end
 
   if ActiveRecord::Base.connection.supports_ddl_transactions?
@@ -274,7 +274,7 @@ class MigrationTest < ActiveRecord::TestCase
         def version; 100 end
         def migrate(x)
           add_column "people", "last_name", :string
-          raise 'Something broke'
+          raise "Something broke"
         end
       }.new
 
@@ -295,7 +295,7 @@ class MigrationTest < ActiveRecord::TestCase
         def version; 100 end
         def migrate(x)
           add_column "people", "last_name", :string
-          raise 'Something broke'
+          raise "Something broke"
         end
       }.new
 
@@ -318,7 +318,7 @@ class MigrationTest < ActiveRecord::TestCase
         def version; 101 end
         def migrate(x)
           add_column "people", "last_name", :string
-          raise 'Something broke'
+          raise "Something broke"
         end
       }.new
 
@@ -330,8 +330,8 @@ class MigrationTest < ActiveRecord::TestCase
         "without ddl transactions, the Migrator should not rollback on error but it did."
     ensure
       Person.reset_column_information
-      if Person.column_names.include?('last_name')
-        Person.connection.remove_column('people', 'last_name')
+      if Person.column_names.include?("last_name")
+        Person.connection.remove_column("people", "last_name")
       end
     end
   end
@@ -430,7 +430,7 @@ class MigrationTest < ActiveRecord::TestCase
 
   def test_internal_metadata_stores_environment_when_other_data_exists
     ActiveRecord::InternalMetadata.delete_all
-    ActiveRecord::InternalMetadata[:foo]  = 'bar'
+    ActiveRecord::InternalMetadata[:foo]  = "bar"
 
     current_env     = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
     migrations_path = MIGRATIONS_ROOT + "/valid"
@@ -440,7 +440,7 @@ class MigrationTest < ActiveRecord::TestCase
     current_env     = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
     ActiveRecord::Migrator.up(migrations_path)
     assert_equal current_env, ActiveRecord::InternalMetadata[:environment]
-    assert_equal 'bar', ActiveRecord::InternalMetadata[:foo]
+    assert_equal "bar", ActiveRecord::InternalMetadata[:foo]
   ensure
     ActiveRecord::Migrator.migrations_paths = old_path
   end
@@ -448,7 +448,7 @@ class MigrationTest < ActiveRecord::TestCase
   def test_proper_table_name_on_migration
     reminder_class = new_isolated_reminder_class
     migration = ActiveRecord::Migration.new
-    assert_equal "table", migration.proper_table_name('table')
+    assert_equal "table", migration.proper_table_name("table")
     assert_equal "table", migration.proper_table_name(:table)
     assert_equal "reminders", migration.proper_table_name(reminder_class)
     reminder_class.reset_table_name
@@ -457,26 +457,26 @@ class MigrationTest < ActiveRecord::TestCase
     # Use the model's own prefix/suffix if a model is given
     ActiveRecord::Base.table_name_prefix = "ARprefix_"
     ActiveRecord::Base.table_name_suffix = "_ARsuffix"
-    reminder_class.table_name_prefix = 'prefix_'
-    reminder_class.table_name_suffix = '_suffix'
+    reminder_class.table_name_prefix = "prefix_"
+    reminder_class.table_name_suffix = "_suffix"
     reminder_class.reset_table_name
     assert_equal "prefix_reminders_suffix", migration.proper_table_name(reminder_class)
-    reminder_class.table_name_prefix = ''
-    reminder_class.table_name_suffix = ''
+    reminder_class.table_name_prefix = ""
+    reminder_class.table_name_suffix = ""
     reminder_class.reset_table_name
 
     # Use AR::Base's prefix/suffix if string or symbol is given
     ActiveRecord::Base.table_name_prefix = "prefix_"
     ActiveRecord::Base.table_name_suffix = "_suffix"
     reminder_class.reset_table_name
-    assert_equal "prefix_table_suffix", migration.proper_table_name('table', migration.table_name_options)
+    assert_equal "prefix_table_suffix", migration.proper_table_name("table", migration.table_name_options)
     assert_equal "prefix_table_suffix", migration.proper_table_name(:table, migration.table_name_options)
   end
 
   def test_rename_table_with_prefix_and_suffix
     assert !Thing.table_exists?
-    ActiveRecord::Base.table_name_prefix = 'p_'
-    ActiveRecord::Base.table_name_suffix = '_s'
+    ActiveRecord::Base.table_name_prefix = "p_"
+    ActiveRecord::Base.table_name_suffix = "_s"
     Thing.reset_table_name
     Thing.reset_sequence_name
     WeNeedThings.up
@@ -496,8 +496,8 @@ class MigrationTest < ActiveRecord::TestCase
 
   def test_add_drop_table_with_prefix_and_suffix
     assert !Reminder.table_exists?
-    ActiveRecord::Base.table_name_prefix = 'prefix_'
-    ActiveRecord::Base.table_name_suffix = '_suffix'
+    ActiveRecord::Base.table_name_prefix = "prefix_"
+    ActiveRecord::Base.table_name_suffix = "_suffix"
     Reminder.reset_table_name
     Reminder.reset_sequence_name
     Reminder.reset_column_information
@@ -570,7 +570,7 @@ class MigrationTest < ActiveRecord::TestCase
       assert_nothing_raised do
         begin
           Person.connection.create_table :table_with_name_thats_just_ok,
-            :sequence_name => 'suitably_short_seq' do |t|
+            :sequence_name => "suitably_short_seq" do |t|
             t.column :foo, :string, :null => false
           end
 
@@ -578,7 +578,7 @@ class MigrationTest < ActiveRecord::TestCase
 
         ensure
           Person.connection.drop_table :table_with_name_thats_just_ok,
-            :sequence_name => 'suitably_short_seq' rescue nil
+            :sequence_name => "suitably_short_seq" rescue nil
         end
       end
 
@@ -748,8 +748,8 @@ class ExplicitlyNamedIndexMigrationTest < ActiveRecord::TestCase
     end
 
     assert_nothing_raised do
-      connection.add_index :values, :value, name: 'a_different_name'
-      connection.remove_index :values, column: :value, name: 'a_different_name'
+      connection.add_index :values, :value, name: "a_different_name"
+      connection.remove_index :values, column: :value, name: "a_different_name"
     end
   ensure
     connection.drop_table :values rescue nil
@@ -782,7 +782,7 @@ if ActiveRecord::Base.connection.supports_bulk_alter?
 
       assert_equal 8, columns.size
       [:name, :qualification, :experience].each {|s| assert_equal :string, column(s).type }
-      assert_equal '0', column(:age).default
+      assert_equal "0", column(:age).default
     end
 
     def test_removing_columns
@@ -821,7 +821,7 @@ if ActiveRecord::Base.connection.supports_bulk_alter?
       assert_equal 2, indexes.size
 
       name_age_index = index(:index_delete_me_on_name_and_age)
-      assert_equal ['name', 'age'].sort, name_age_index.columns.sort
+      assert_equal ["name", "age"].sort, name_age_index.columns.sort
       assert ! name_age_index.unique
 
       assert index(:awesome_username_index).unique
@@ -862,12 +862,12 @@ if ActiveRecord::Base.connection.supports_bulk_alter?
       # One query to do the bulk change
       assert_queries(3, :ignore_none => true) do
         with_bulk_change_table do |t|
-          t.change :name, :string, :default => 'NONAME'
+          t.change :name, :string, :default => "NONAME"
           t.change :birthdate, :datetime
         end
       end
 
-      assert_equal 'NONAME', column(:name).default
+      assert_equal "NONAME", column(:name).default
       assert_equal :datetime, column(:birthdate).type
     end
 
@@ -887,7 +887,7 @@ if ActiveRecord::Base.connection.supports_bulk_alter?
     end
 
     def columns
-      @columns ||= Person.connection.columns('delete_me')
+      @columns ||= Person.connection.columns("delete_me")
     end
 
     def index(name)
@@ -895,7 +895,7 @@ if ActiveRecord::Base.connection.supports_bulk_alter?
     end
 
     def indexes
-      @indexes ||= Person.connection.indexes('delete_me')
+      @indexes ||= Person.connection.indexes("delete_me")
     end
   end # AlterTableMigrationsTest
 
diff --git a/activerecord/test/cases/migrator_test.rb b/activerecord/test/cases/migrator_test.rb
index 86eca53141..8e73deb80c 100644
--- a/activerecord/test/cases/migrator_test.rb
+++ b/activerecord/test/cases/migrator_test.rb
@@ -46,21 +46,21 @@ class MigratorTest < ActiveRecord::TestCase
 
   def test_migrator_with_duplicate_names
     assert_raises(ActiveRecord::DuplicateMigrationNameError, "Multiple migrations have the name Chunky") do
-      list = [ActiveRecord::Migration.new('Chunky'), ActiveRecord::Migration.new('Chunky')]
+      list = [ActiveRecord::Migration.new("Chunky"), ActiveRecord::Migration.new("Chunky")]
       ActiveRecord::Migrator.new(:up, list)
     end
   end
 
   def test_migrator_with_duplicate_versions
     assert_raises(ActiveRecord::DuplicateMigrationVersionError) do
-      list = [ActiveRecord::Migration.new('Foo', 1), ActiveRecord::Migration.new('Bar', 1)]
+      list = [ActiveRecord::Migration.new("Foo", 1), ActiveRecord::Migration.new("Bar", 1)]
       ActiveRecord::Migrator.new(:up, list)
     end
   end
 
   def test_migrator_with_missing_version_numbers
     assert_raises(ActiveRecord::UnknownMigrationVersionError) do
-      list = [ActiveRecord::Migration.new('Foo', 1), ActiveRecord::Migration.new('Bar', 2)]
+      list = [ActiveRecord::Migration.new("Foo", 1), ActiveRecord::Migration.new("Bar", 2)]
       ActiveRecord::Migrator.new(:up, list, 3).run
     end
   end
@@ -68,7 +68,7 @@ class MigratorTest < ActiveRecord::TestCase
   def test_finds_migrations
     migrations = ActiveRecord::Migrator.migrations(MIGRATIONS_ROOT + "/valid")
 
-    [[1, 'ValidPeopleHaveLastNames'], [2, 'WeNeedReminders'], [3, 'InnocentJointable']].each_with_index do |pair, i|
+    [[1, "ValidPeopleHaveLastNames"], [2, "WeNeedReminders"], [3, "InnocentJointable"]].each_with_index do |pair, i|
       assert_equal migrations[i].version, pair.first
       assert_equal migrations[i].name, pair.last
     end
@@ -77,14 +77,14 @@ class MigratorTest < ActiveRecord::TestCase
   def test_finds_migrations_in_subdirectories
     migrations = ActiveRecord::Migrator.migrations(MIGRATIONS_ROOT + "/valid_with_subdirectories")
 
-    [[1, 'ValidPeopleHaveLastNames'], [2, 'WeNeedReminders'], [3, 'InnocentJointable']].each_with_index do |pair, i|
+    [[1, "ValidPeopleHaveLastNames"], [2, "WeNeedReminders"], [3, "InnocentJointable"]].each_with_index do |pair, i|
       assert_equal migrations[i].version, pair.first
       assert_equal migrations[i].name, pair.last
     end
   end
 
   def test_finds_migrations_from_two_directories
-    directories = [MIGRATIONS_ROOT + '/valid_with_timestamps', MIGRATIONS_ROOT + '/to_copy_with_timestamps']
+    directories = [MIGRATIONS_ROOT + "/valid_with_timestamps", MIGRATIONS_ROOT + "/to_copy_with_timestamps"]
     migrations = ActiveRecord::Migrator.migrations directories
 
     [[20090101010101, "PeopleHaveHobbies"],
@@ -98,9 +98,9 @@ class MigratorTest < ActiveRecord::TestCase
   end
 
   def test_finds_migrations_in_numbered_directory
-    migrations = ActiveRecord::Migrator.migrations [MIGRATIONS_ROOT + '/10_urban']
+    migrations = ActiveRecord::Migrator.migrations [MIGRATIONS_ROOT + "/10_urban"]
     assert_equal 9, migrations[0].version
-    assert_equal 'AddExpressions', migrations[0].name
+    assert_equal "AddExpressions", migrations[0].name
   end
 
   def test_relative_migrations
@@ -109,14 +109,14 @@ class MigratorTest < ActiveRecord::TestCase
     end
 
     migration_proxy = list.find { |item|
-      item.name == 'ValidPeopleHaveLastNames'
+      item.name == "ValidPeopleHaveLastNames"
     }
-    assert migration_proxy, 'should find pending migration'
+    assert migration_proxy, "should find pending migration"
   end
 
   def test_finds_pending_migrations
-    ActiveRecord::SchemaMigration.create!(:version => '1')
-    migration_list = [ActiveRecord::Migration.new('foo', 1), ActiveRecord::Migration.new('bar', 3)]
+    ActiveRecord::SchemaMigration.create!(:version => "1")
+    migration_list = [ActiveRecord::Migration.new("foo", 1), ActiveRecord::Migration.new("bar", 3)]
     migrations = ActiveRecord::Migrator.new(:up, migration_list).pending_migrations
 
     assert_equal 1, migrations.size
@@ -124,21 +124,21 @@ class MigratorTest < ActiveRecord::TestCase
   end
 
   def test_migrator_interleaved_migrations
-    pass_one = [Sensor.new('One', 1)]
+    pass_one = [Sensor.new("One", 1)]
 
     ActiveRecord::Migrator.new(:up, pass_one).migrate
     assert pass_one.first.went_up
     assert_not pass_one.first.went_down
 
-    pass_two = [Sensor.new('One', 1), Sensor.new('Three', 3)]
+    pass_two = [Sensor.new("One", 1), Sensor.new("Three", 3)]
     ActiveRecord::Migrator.new(:up, pass_two).migrate
     assert_not pass_two[0].went_up
     assert pass_two[1].went_up
     assert pass_two.all? { |x| !x.went_down }
 
-    pass_three = [Sensor.new('One', 1),
-                  Sensor.new('Two', 2),
-                  Sensor.new('Three', 3)]
+    pass_three = [Sensor.new("One", 1),
+                  Sensor.new("Two", 2),
+                  Sensor.new("Three", 3)]
 
     ActiveRecord::Migrator.new(:down, pass_three).migrate
     assert pass_three[0].went_down
@@ -165,7 +165,7 @@ class MigratorTest < ActiveRecord::TestCase
   end
 
   def test_current_version
-    ActiveRecord::SchemaMigration.create!(:version => '1000')
+    ActiveRecord::SchemaMigration.create!(:version => "1000")
     assert_equal 1000, ActiveRecord::Migrator.current_version
   end
 
@@ -313,9 +313,9 @@ class MigratorTest < ActiveRecord::TestCase
     _, migrator = migrator_class(3)
 
     ActiveRecord::Base.connection.drop_table "schema_migrations", if_exists: true
-    ActiveSupport::Deprecation.silence { assert_not ActiveRecord::Base.connection.table_exists?('schema_migrations') }
+    ActiveSupport::Deprecation.silence { assert_not ActiveRecord::Base.connection.table_exists?("schema_migrations") }
     migrator.migrate("valid", 1)
-    ActiveSupport::Deprecation.silence { assert ActiveRecord::Base.connection.table_exists?('schema_migrations') }
+    ActiveSupport::Deprecation.silence { assert ActiveRecord::Base.connection.table_exists?("schema_migrations") }
   end
 
   def test_migrator_forward
@@ -332,7 +332,7 @@ class MigratorTest < ActiveRecord::TestCase
 
   def test_only_loads_pending_migrations
     # migrate up to 1
-    ActiveRecord::SchemaMigration.create!(:version => '1')
+    ActiveRecord::SchemaMigration.create!(:version => "1")
 
     calls, migrator = migrator_class(3)
     migrator.migrate("valid", nil)
diff --git a/activerecord/test/cases/modules_test.rb b/activerecord/test/cases/modules_test.rb
index 486bcc22df..870eda45ed 100644
--- a/activerecord/test/cases/modules_test.rb
+++ b/activerecord/test/cases/modules_test.rb
@@ -1,8 +1,8 @@
 require "cases/helper"
-require 'models/company_in_module'
-require 'models/shop'
-require 'models/developer'
-require 'models/computer'
+require "models/company_in_module"
+require "models/shop"
+require "models/developer"
+require "models/computer"
 
 class ModulesTest < ActiveRecord::TestCase
   fixtures :accounts, :companies, :projects, :developers, :collections, :products, :variants
@@ -31,7 +31,7 @@ class ModulesTest < ActiveRecord::TestCase
   def test_module_spanning_associations
     firm = MyApplication::Business::Firm.first
     assert !firm.clients.empty?, "Firm should have clients"
-    assert_nil firm.class.table_name.match('::'), "Firm shouldn't have the module appear in its table name"
+    assert_nil firm.class.table_name.match("::"), "Firm shouldn't have the module appear in its table name"
   end
 
   def test_module_spanning_has_and_belongs_to_many_associations
@@ -41,7 +41,7 @@ class ModulesTest < ActiveRecord::TestCase
   end
 
   def test_associations_spanning_cross_modules
-    account = MyApplication::Billing::Account.all.merge!(:order => 'id').first
+    account = MyApplication::Billing::Account.all.merge!(:order => "id").first
     assert_kind_of MyApplication::Business::Firm, account.firm
     assert_kind_of MyApplication::Billing::Firm, account.qualified_billing_firm
     assert_kind_of MyApplication::Billing::Firm, account.unqualified_billing_firm
@@ -55,9 +55,9 @@ class ModulesTest < ActiveRecord::TestCase
   end
 
   def test_table_name
-    assert_equal 'accounts', MyApplication::Billing::Account.table_name, 'table_name for ActiveRecord model in module'
-    assert_equal 'companies', MyApplication::Business::Client.table_name, 'table_name for ActiveRecord model subclass'
-    assert_equal 'company_contacts', MyApplication::Business::Client::Contact.table_name, 'table_name for ActiveRecord model enclosed by another ActiveRecord model'
+    assert_equal "accounts", MyApplication::Billing::Account.table_name, "table_name for ActiveRecord model in module"
+    assert_equal "companies", MyApplication::Business::Client.table_name, "table_name for ActiveRecord model subclass"
+    assert_equal "company_contacts", MyApplication::Business::Client::Contact.table_name, "table_name for ActiveRecord model enclosed by another ActiveRecord model"
   end
 
   def test_assign_ids
@@ -73,7 +73,7 @@ class ModulesTest < ActiveRecord::TestCase
     clients = []
 
     assert_nothing_raised do
-      clients << MyApplication::Business::Client.references(:accounts).merge!(:includes => {:firm => :account}, :where => 'accounts.id IS NOT NULL').find(3)
+      clients << MyApplication::Business::Client.references(:accounts).merge!(:includes => {:firm => :account}, :where => "accounts.id IS NOT NULL").find(3)
       clients << MyApplication::Business::Client.includes(:firm => :account).find(3)
     end
 
@@ -85,9 +85,9 @@ class ModulesTest < ActiveRecord::TestCase
   end
 
   def test_module_table_name_prefix
-    assert_equal 'prefixed_companies', MyApplication::Business::Prefixed::Company.table_name, 'inferred table_name for ActiveRecord model in module with table_name_prefix'
-    assert_equal 'prefixed_companies', MyApplication::Business::Prefixed::Nested::Company.table_name, 'table_name for ActiveRecord model in nested module with a parent table_name_prefix'
-    assert_equal 'companies', MyApplication::Business::Prefixed::Firm.table_name, 'explicit table_name for ActiveRecord model in module with table_name_prefix should not be prefixed'
+    assert_equal "prefixed_companies", MyApplication::Business::Prefixed::Company.table_name, "inferred table_name for ActiveRecord model in module with table_name_prefix"
+    assert_equal "prefixed_companies", MyApplication::Business::Prefixed::Nested::Company.table_name, "table_name for ActiveRecord model in nested module with a parent table_name_prefix"
+    assert_equal "companies", MyApplication::Business::Prefixed::Firm.table_name, "explicit table_name for ActiveRecord model in module with table_name_prefix should not be prefixed"
   end
 
   def test_module_table_name_prefix_with_global_prefix
@@ -101,21 +101,21 @@ class ModulesTest < ActiveRecord::TestCase
                 MyApplication::Business::Prefixed::Nested::Company,
                 MyApplication::Billing::Account ]
 
-    ActiveRecord::Base.table_name_prefix = 'global_'
+    ActiveRecord::Base.table_name_prefix = "global_"
     classes.each(&:reset_table_name)
-    assert_equal 'global_companies', MyApplication::Business::Company.table_name, 'inferred table_name for ActiveRecord model in module without table_name_prefix'
-    assert_equal 'prefixed_companies', MyApplication::Business::Prefixed::Company.table_name, 'inferred table_name for ActiveRecord model in module with table_name_prefix'
-    assert_equal 'prefixed_companies', MyApplication::Business::Prefixed::Nested::Company.table_name, 'table_name for ActiveRecord model in nested module with a parent table_name_prefix'
-    assert_equal 'companies', MyApplication::Business::Prefixed::Firm.table_name, 'explicit table_name for ActiveRecord model in module with table_name_prefix should not be prefixed'
+    assert_equal "global_companies", MyApplication::Business::Company.table_name, "inferred table_name for ActiveRecord model in module without table_name_prefix"
+    assert_equal "prefixed_companies", MyApplication::Business::Prefixed::Company.table_name, "inferred table_name for ActiveRecord model in module with table_name_prefix"
+    assert_equal "prefixed_companies", MyApplication::Business::Prefixed::Nested::Company.table_name, "table_name for ActiveRecord model in nested module with a parent table_name_prefix"
+    assert_equal "companies", MyApplication::Business::Prefixed::Firm.table_name, "explicit table_name for ActiveRecord model in module with table_name_prefix should not be prefixed"
   ensure
-    ActiveRecord::Base.table_name_prefix = ''
+    ActiveRecord::Base.table_name_prefix = ""
     classes.each(&:reset_table_name)
   end
 
   def test_module_table_name_suffix
-    assert_equal 'companies_suffixed', MyApplication::Business::Suffixed::Company.table_name, 'inferred table_name for ActiveRecord model in module with table_name_suffix'
-    assert_equal 'companies_suffixed', MyApplication::Business::Suffixed::Nested::Company.table_name, 'table_name for ActiveRecord model in nested module with a parent table_name_suffix'
-    assert_equal 'companies', MyApplication::Business::Suffixed::Firm.table_name, 'explicit table_name for ActiveRecord model in module with table_name_suffix should not be suffixed'
+    assert_equal "companies_suffixed", MyApplication::Business::Suffixed::Company.table_name, "inferred table_name for ActiveRecord model in module with table_name_suffix"
+    assert_equal "companies_suffixed", MyApplication::Business::Suffixed::Nested::Company.table_name, "table_name for ActiveRecord model in nested module with a parent table_name_suffix"
+    assert_equal "companies", MyApplication::Business::Suffixed::Firm.table_name, "explicit table_name for ActiveRecord model in module with table_name_suffix should not be suffixed"
   end
 
   def test_module_table_name_suffix_with_global_suffix
@@ -129,14 +129,14 @@ class ModulesTest < ActiveRecord::TestCase
                 MyApplication::Business::Suffixed::Nested::Company,
                 MyApplication::Billing::Account ]
 
-    ActiveRecord::Base.table_name_suffix = '_global'
+    ActiveRecord::Base.table_name_suffix = "_global"
     classes.each(&:reset_table_name)
-    assert_equal 'companies_global', MyApplication::Business::Company.table_name, 'inferred table_name for ActiveRecord model in module without table_name_suffix'
-    assert_equal 'companies_suffixed', MyApplication::Business::Suffixed::Company.table_name, 'inferred table_name for ActiveRecord model in module with table_name_suffix'
-    assert_equal 'companies_suffixed', MyApplication::Business::Suffixed::Nested::Company.table_name, 'table_name for ActiveRecord model in nested module with a parent table_name_suffix'
-    assert_equal 'companies', MyApplication::Business::Suffixed::Firm.table_name, 'explicit table_name for ActiveRecord model in module with table_name_suffix should not be suffixed'
+    assert_equal "companies_global", MyApplication::Business::Company.table_name, "inferred table_name for ActiveRecord model in module without table_name_suffix"
+    assert_equal "companies_suffixed", MyApplication::Business::Suffixed::Company.table_name, "inferred table_name for ActiveRecord model in module with table_name_suffix"
+    assert_equal "companies_suffixed", MyApplication::Business::Suffixed::Nested::Company.table_name, "table_name for ActiveRecord model in nested module with a parent table_name_suffix"
+    assert_equal "companies", MyApplication::Business::Suffixed::Firm.table_name, "explicit table_name for ActiveRecord model in module with table_name_suffix should not be suffixed"
   ensure
-    ActiveRecord::Base.table_name_suffix = ''
+    ActiveRecord::Base.table_name_suffix = ""
     classes.each(&:reset_table_name)
   end
 
diff --git a/activerecord/test/cases/multiparameter_attributes_test.rb b/activerecord/test/cases/multiparameter_attributes_test.rb
index 59c340ceb7..b2f76398df 100644
--- a/activerecord/test/cases/multiparameter_attributes_test.rb
+++ b/activerecord/test/cases/multiparameter_attributes_test.rb
@@ -1,6 +1,6 @@
 require "cases/helper"
-require 'models/topic'
-require 'models/customer'
+require "models/topic"
+require "models/customer"
 
 class MultiParameterAttributeTest < ActiveRecord::TestCase
   fixtures :topics
diff --git a/activerecord/test/cases/multiple_db_test.rb b/activerecord/test/cases/multiple_db_test.rb
index a4fbf579a1..e3bb51bd77 100644
--- a/activerecord/test/cases/multiple_db_test.rb
+++ b/activerecord/test/cases/multiple_db_test.rb
@@ -1,7 +1,7 @@
 require "cases/helper"
-require 'models/entrant'
-require 'models/bird'
-require 'models/course'
+require "models/entrant"
+require "models/bird"
+require "models/course"
 
 class MultipleDbTest < ActiveRecord::TestCase
   self.use_transactional_tests = false
@@ -60,7 +60,7 @@ class MultipleDbTest < ActiveRecord::TestCase
 
     ActiveSupport::Dependencies.clear
     Object.send(:remove_const, :Course)
-    require_dependency 'models/course'
+    require_dependency "models/course"
 
     assert Course.connection
   end
diff --git a/activerecord/test/cases/nested_attributes_test.rb b/activerecord/test/cases/nested_attributes_test.rb
index 8a08056bbe..c72890aa2b 100644
--- a/activerecord/test/cases/nested_attributes_test.rb
+++ b/activerecord/test/cases/nested_attributes_test.rb
@@ -9,7 +9,7 @@ require "models/man"
 require "models/interest"
 require "models/owner"
 require "models/pet"
-require 'active_support/hash_with_indifferent_access'
+require "active_support/hash_with_indifferent_access"
 
 class TestNestedAttributesInGeneral < ActiveRecord::TestCase
   teardown do
@@ -31,7 +31,7 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
 
   def test_should_not_build_a_new_record_using_reject_all_even_if_destroy_is_given
     pirate = Pirate.create!(:catchphrase => "Don' botharrr talkin' like one, savvy?")
-    pirate.birds_with_reject_all_blank_attributes = [{:name => '', :color => '', :_destroy => '0'}]
+    pirate.birds_with_reject_all_blank_attributes = [{:name => "", :color => "", :_destroy => "0"}]
     pirate.save!
 
     assert pirate.birds_with_reject_all_blank.empty?
@@ -39,7 +39,7 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
 
   def test_should_not_build_a_new_record_if_reject_all_blank_returns_false
     pirate = Pirate.create!(:catchphrase => "Don' botharrr talkin' like one, savvy?")
-    pirate.birds_with_reject_all_blank_attributes = [{:name => '', :color => ''}]
+    pirate.birds_with_reject_all_blank_attributes = [{:name => "", :color => ""}]
     pirate.save!
 
     assert pirate.birds_with_reject_all_blank.empty?
@@ -47,11 +47,11 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
 
   def test_should_build_a_new_record_if_reject_all_blank_does_not_return_false
     pirate = Pirate.create!(:catchphrase => "Don' botharrr talkin' like one, savvy?")
-    pirate.birds_with_reject_all_blank_attributes = [{:name => 'Tweetie', :color => ''}]
+    pirate.birds_with_reject_all_blank_attributes = [{:name => "Tweetie", :color => ""}]
     pirate.save!
 
     assert_equal 1, pirate.birds_with_reject_all_blank.count
-    assert_equal 'Tweetie', pirate.birds_with_reject_all_blank.first.name
+    assert_equal "Tweetie", pirate.birds_with_reject_all_blank.first.name
   end
 
   def test_should_raise_an_ArgumentError_for_non_existing_associations
@@ -72,15 +72,15 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
     Pirate.accepts_nested_attributes_for :ship
 
     pirate = Pirate.create!(catchphrase: "Don' botharrr talkin' like one, savvy?")
-    ship = pirate.create_ship(name: 'Nights Dirty Lightning')
+    ship = pirate.create_ship(name: "Nights Dirty Lightning")
 
-    pirate.update(ship_attributes: { '_destroy' => true, :id => ship.id })
+    pirate.update(ship_attributes: { "_destroy" => true, :id => ship.id })
 
     assert_nothing_raised { pirate.ship.reload }
   end
 
   def test_a_model_should_respond_to_underscore_destroy_and_return_if_it_is_marked_for_destruction
-    ship = Ship.create!(:name => 'Nights Dirty Lightning')
+    ship = Ship.create!(:name => "Nights Dirty Lightning")
     assert !ship._destroy
     ship.mark_for_destruction
     assert ship._destroy
@@ -90,65 +90,65 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
     Pirate.accepts_nested_attributes_for :ship, :reject_if => :new_record?
 
     pirate = Pirate.new(:catchphrase => "Stop wastin' me time")
-    pirate.ship_attributes = { :name => 'Black Pearl' }
-    assert_no_difference('Ship.count') { pirate.save! }
+    pirate.ship_attributes = { :name => "Black Pearl" }
+    assert_no_difference("Ship.count") { pirate.save! }
   end
 
   def test_reject_if_method_with_arguments
     Pirate.accepts_nested_attributes_for :ship, :reject_if => :reject_empty_ships_on_create
 
     pirate = Pirate.new(:catchphrase => "Stop wastin' me time")
-    pirate.ship_attributes = { :name => 'Red Pearl', :_reject_me_if_new => true }
-    assert_no_difference('Ship.count') { pirate.save! }
+    pirate.ship_attributes = { :name => "Red Pearl", :_reject_me_if_new => true }
+    assert_no_difference("Ship.count") { pirate.save! }
 
     # pirate.reject_empty_ships_on_create returns false for saved pirate records
     # in the previous step note that pirate gets saved but ship fails
-    pirate.ship_attributes = { :name => 'Red Pearl', :_reject_me_if_new => true }
-    assert_difference('Ship.count') { pirate.save! }
+    pirate.ship_attributes = { :name => "Red Pearl", :_reject_me_if_new => true }
+    assert_difference("Ship.count") { pirate.save! }
   end
 
   def test_reject_if_with_indifferent_keys
     Pirate.accepts_nested_attributes_for :ship, :reject_if => proc {|attributes| attributes[:name].blank? }
 
     pirate = Pirate.new(:catchphrase => "Stop wastin' me time")
-    pirate.ship_attributes = { :name => 'Hello Pearl' }
-    assert_difference('Ship.count') { pirate.save! }
+    pirate.ship_attributes = { :name => "Hello Pearl" }
+    assert_difference("Ship.count") { pirate.save! }
   end
 
   def test_reject_if_with_a_proc_which_returns_true_always_for_has_one
     Pirate.accepts_nested_attributes_for :ship, :reject_if => proc {|attributes| true }
     pirate = Pirate.new(catchphrase: "Stop wastin' me time")
-    ship = pirate.create_ship(name: 's1')
-    pirate.update({ship_attributes: { name: 's2', id: ship.id } })
-    assert_equal 's1', ship.reload.name
+    ship = pirate.create_ship(name: "s1")
+    pirate.update({ship_attributes: { name: "s2", id: ship.id } })
+    assert_equal "s1", ship.reload.name
   end
 
   def test_reuse_already_built_new_record
     pirate = Pirate.new
     ship_built_first = pirate.build_ship
-    pirate.ship_attributes = { name: 'Ship 1' }
+    pirate.ship_attributes = { name: "Ship 1" }
     assert_equal ship_built_first.object_id, pirate.ship.object_id
   end
 
   def test_do_not_allow_assigning_foreign_key_when_reusing_existing_new_record
     pirate = Pirate.create!(catchphrase: "Don' botharrr talkin' like one, savvy?")
     pirate.build_ship
-    pirate.ship_attributes = { name: 'Ship 1', pirate_id: pirate.id + 1 }
+    pirate.ship_attributes = { name: "Ship 1", pirate_id: pirate.id + 1 }
     assert_equal pirate.id, pirate.ship.pirate_id
   end
 
   def test_reject_if_with_a_proc_which_returns_true_always_for_has_many
     Man.accepts_nested_attributes_for :interests, :reject_if => proc {|attributes| true }
     man = Man.create(name: "John")
-    interest = man.interests.create(topic: 'photography')
-    man.update({interests_attributes: { topic: 'gardening', id: interest.id } })
-    assert_equal 'photography', interest.reload.topic
+    interest = man.interests.create(topic: "photography")
+    man.update({interests_attributes: { topic: "gardening", id: interest.id } })
+    assert_equal "photography", interest.reload.topic
   end
 
   def test_destroy_works_independent_of_reject_if
     Man.accepts_nested_attributes_for :interests, :reject_if => proc {|attributes| true }, :allow_destroy => true
     man = Man.create(name: "Jon")
-    interest = man.interests.create(topic: 'the ladies')
+    interest = man.interests.create(topic: "the ladies")
     man.update({interests_attributes: { _destroy: "1", id: interest.id } })
     assert man.reload.interests.empty?
   end
@@ -168,10 +168,10 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
 
   def test_has_many_association_updating_a_single_record
     Man.accepts_nested_attributes_for(:interests)
-    man = Man.create(name: 'John')
-    interest = man.interests.create(topic: 'photography')
-    man.update({interests_attributes: {topic: 'gardening', id: interest.id}})
-    assert_equal 'gardening', interest.reload.topic
+    man = Man.create(name: "John")
+    interest = man.interests.create(topic: "photography")
+    man.update({interests_attributes: {topic: "gardening", id: interest.id}})
+    assert_equal "gardening", interest.reload.topic
   end
 
   def test_reject_if_with_blank_nested_attributes_id
@@ -186,9 +186,9 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
   def test_first_and_array_index_zero_methods_return_the_same_value_when_nested_attributes_are_set_to_update_existing_record
     Man.accepts_nested_attributes_for(:interests)
     man = Man.create(:name => "John")
-    interest = man.interests.create :topic => 'gardening'
+    interest = man.interests.create :topic => "gardening"
     man = Man.find man.id
-    man.interests_attributes = [{:id => interest.id, :topic => 'gardening'}]
+    man.interests_attributes = [{:id => interest.id, :topic => "gardening"}]
     assert_equal man.interests.first.topic, man.interests[0].topic
   end
 
@@ -220,12 +220,12 @@ end
 class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
   def setup
     @pirate = Pirate.create!(:catchphrase => "Don' botharrr talkin' like one, savvy?")
-    @ship = @pirate.create_ship(:name => 'Nights Dirty Lightning')
+    @ship = @pirate.create_ship(:name => "Nights Dirty Lightning")
   end
 
   def test_should_raise_argument_error_if_trying_to_build_polymorphic_belongs_to
     exception = assert_raise ArgumentError do
-      Treasure.new(:name => 'pearl', :looter_attributes => {:catchphrase => "Arrr"})
+      Treasure.new(:name => "pearl", :looter_attributes => {:catchphrase => "Arrr"})
     end
     assert_equal "Cannot build association `looter'. Are you trying to build a polymorphic one-to-one association?", exception.message
   end
@@ -236,15 +236,15 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
 
   def test_should_build_a_new_record_if_there_is_no_id
     @ship.destroy
-    @pirate.reload.ship_attributes = { :name => 'Davy Jones Gold Dagger' }
+    @pirate.reload.ship_attributes = { :name => "Davy Jones Gold Dagger" }
 
     assert !@pirate.ship.persisted?
-    assert_equal 'Davy Jones Gold Dagger', @pirate.ship.name
+    assert_equal "Davy Jones Gold Dagger", @pirate.ship.name
   end
 
   def test_should_not_build_a_new_record_if_there_is_no_id_and_destroy_is_truthy
     @ship.destroy
-    @pirate.reload.ship_attributes = { :name => 'Davy Jones Gold Dagger', :_destroy => '1' }
+    @pirate.reload.ship_attributes = { :name => "Davy Jones Gold Dagger", :_destroy => "1" }
 
     assert_nil @pirate.ship
   end
@@ -257,25 +257,25 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
   end
 
   def test_should_replace_an_existing_record_if_there_is_no_id
-    @pirate.reload.ship_attributes = { :name => 'Davy Jones Gold Dagger' }
+    @pirate.reload.ship_attributes = { :name => "Davy Jones Gold Dagger" }
 
     assert !@pirate.ship.persisted?
-    assert_equal 'Davy Jones Gold Dagger', @pirate.ship.name
-    assert_equal 'Nights Dirty Lightning', @ship.name
+    assert_equal "Davy Jones Gold Dagger", @pirate.ship.name
+    assert_equal "Nights Dirty Lightning", @ship.name
   end
 
   def test_should_not_replace_an_existing_record_if_there_is_no_id_and_destroy_is_truthy
-    @pirate.reload.ship_attributes = { :name => 'Davy Jones Gold Dagger', :_destroy => '1' }
+    @pirate.reload.ship_attributes = { :name => "Davy Jones Gold Dagger", :_destroy => "1" }
 
     assert_equal @ship, @pirate.ship
-    assert_equal 'Nights Dirty Lightning', @pirate.ship.name
+    assert_equal "Nights Dirty Lightning", @pirate.ship.name
   end
 
   def test_should_modify_an_existing_record_if_there_is_a_matching_id
-    @pirate.reload.ship_attributes = { :id => @ship.id, :name => 'Davy Jones Gold Dagger' }
+    @pirate.reload.ship_attributes = { :id => @ship.id, :name => "Davy Jones Gold Dagger" }
 
     assert_equal @ship, @pirate.ship
-    assert_equal 'Davy Jones Gold Dagger', @pirate.ship.name
+    assert_equal "Davy Jones Gold Dagger", @pirate.ship.name
   end
 
   def test_should_raise_RecordNotFound_if_an_id_is_given_but_doesnt_return_a_record
@@ -286,25 +286,25 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
   end
 
   def test_should_take_a_hash_with_string_keys_and_update_the_associated_model
-    @pirate.reload.ship_attributes = { 'id' => @ship.id, 'name' => 'Davy Jones Gold Dagger' }
+    @pirate.reload.ship_attributes = { "id" => @ship.id, "name" => "Davy Jones Gold Dagger" }
 
     assert_equal @ship, @pirate.ship
-    assert_equal 'Davy Jones Gold Dagger', @pirate.ship.name
+    assert_equal "Davy Jones Gold Dagger", @pirate.ship.name
   end
 
   def test_should_modify_an_existing_record_if_there_is_a_matching_composite_id
-    @ship.stub(:id, 'ABC1X') do
-      @pirate.ship_attributes = { :id => @ship.id, :name => 'Davy Jones Gold Dagger' }
+    @ship.stub(:id, "ABC1X") do
+      @pirate.ship_attributes = { :id => @ship.id, :name => "Davy Jones Gold Dagger" }
 
-      assert_equal 'Davy Jones Gold Dagger', @pirate.ship.name
+      assert_equal "Davy Jones Gold Dagger", @pirate.ship.name
     end
   end
 
   def test_should_destroy_an_existing_record_if_there_is_a_matching_id_and_destroy_is_truthy
     @pirate.ship.destroy
 
-    [1, '1', true, 'true'].each do |truth|
-      ship = @pirate.reload.create_ship(name: 'Mister Pablo')
+    [1, "1", true, "true"].each do |truth|
+      ship = @pirate.reload.create_ship(name: "Mister Pablo")
       @pirate.update(ship_attributes: { id: ship.id, _destroy: truth })
 
       assert_nil @pirate.reload.ship
@@ -313,7 +313,7 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
   end
 
   def test_should_not_destroy_an_existing_record_if_destroy_is_not_truthy
-    [nil, '0', 0, 'false', false].each do |not_truth|
+    [nil, "0", 0, "false", false].each do |not_truth|
       @pirate.update(ship_attributes: { id: @pirate.ship.id, _destroy: not_truth })
 
       assert_equal @ship, @pirate.reload.ship
@@ -323,7 +323,7 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
   def test_should_not_destroy_an_existing_record_if_allow_destroy_is_false
     Pirate.accepts_nested_attributes_for :ship, :allow_destroy => false, :reject_if => proc(&:empty?)
 
-    @pirate.update(ship_attributes: { id: @pirate.ship.id, _destroy: '1' })
+    @pirate.update(ship_attributes: { id: @pirate.ship.id, _destroy: "1" })
 
     assert_equal @ship, @pirate.reload.ship
 
@@ -331,22 +331,22 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
   end
 
   def test_should_also_work_with_a_HashWithIndifferentAccess
-    @pirate.ship_attributes = ActiveSupport::HashWithIndifferentAccess.new(:id => @ship.id, :name => 'Davy Jones Gold Dagger')
+    @pirate.ship_attributes = ActiveSupport::HashWithIndifferentAccess.new(:id => @ship.id, :name => "Davy Jones Gold Dagger")
 
     assert @pirate.ship.persisted?
-    assert_equal 'Davy Jones Gold Dagger', @pirate.ship.name
+    assert_equal "Davy Jones Gold Dagger", @pirate.ship.name
   end
 
   def test_should_work_with_update_as_well
-    @pirate.update({ catchphrase: 'Arr', ship_attributes: { id: @ship.id, name: 'Mister Pablo' } })
+    @pirate.update({ catchphrase: "Arr", ship_attributes: { id: @ship.id, name: "Mister Pablo" } })
     @pirate.reload
 
-    assert_equal 'Arr', @pirate.catchphrase
-    assert_equal 'Mister Pablo', @pirate.ship.name
+    assert_equal "Arr", @pirate.catchphrase
+    assert_equal "Mister Pablo", @pirate.ship.name
   end
 
   def test_should_not_destroy_the_associated_model_until_the_parent_is_saved
-    @pirate.attributes = { :ship_attributes => { :id => @ship.id, :_destroy => '1' } }
+    @pirate.attributes = { :ship_attributes => { :id => @ship.id, :_destroy => "1" } }
 
     assert !@pirate.ship.destroyed?
     assert @pirate.ship.marked_for_destruction?
@@ -362,43 +362,43 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
   end
 
   def test_should_accept_update_only_option
-    @pirate.update(update_only_ship_attributes: { id: @pirate.ship.id, name: 'Mayflower' })
+    @pirate.update(update_only_ship_attributes: { id: @pirate.ship.id, name: "Mayflower" })
   end
 
   def test_should_create_new_model_when_nothing_is_there_and_update_only_is_true
     @ship.delete
 
-    @pirate.reload.update(update_only_ship_attributes: { name: 'Mayflower' })
+    @pirate.reload.update(update_only_ship_attributes: { name: "Mayflower" })
 
     assert_not_nil @pirate.ship
   end
 
   def test_should_update_existing_when_update_only_is_true_and_no_id_is_given
     @ship.delete
-    @ship = @pirate.create_update_only_ship(name: 'Nights Dirty Lightning')
+    @ship = @pirate.create_update_only_ship(name: "Nights Dirty Lightning")
 
-    @pirate.update(update_only_ship_attributes: { name: 'Mayflower' })
+    @pirate.update(update_only_ship_attributes: { name: "Mayflower" })
 
-    assert_equal 'Mayflower', @ship.reload.name
+    assert_equal "Mayflower", @ship.reload.name
     assert_equal @ship, @pirate.reload.ship
   end
 
   def test_should_update_existing_when_update_only_is_true_and_id_is_given
     @ship.delete
-    @ship = @pirate.create_update_only_ship(name: 'Nights Dirty Lightning')
+    @ship = @pirate.create_update_only_ship(name: "Nights Dirty Lightning")
 
-    @pirate.update(update_only_ship_attributes: { name: 'Mayflower', id: @ship.id })
+    @pirate.update(update_only_ship_attributes: { name: "Mayflower", id: @ship.id })
 
-    assert_equal 'Mayflower', @ship.reload.name
+    assert_equal "Mayflower", @ship.reload.name
     assert_equal @ship, @pirate.reload.ship
   end
 
   def test_should_destroy_existing_when_update_only_is_true_and_id_is_given_and_is_marked_for_destruction
     Pirate.accepts_nested_attributes_for :update_only_ship, :update_only => true, :allow_destroy => true
     @ship.delete
-    @ship = @pirate.create_update_only_ship(name: 'Nights Dirty Lightning')
+    @ship = @pirate.create_update_only_ship(name: "Nights Dirty Lightning")
 
-    @pirate.update(update_only_ship_attributes: { name: 'Mayflower', id: @ship.id, _destroy: true })
+    @pirate.update(update_only_ship_attributes: { name: "Mayflower", id: @ship.id, _destroy: true })
 
     assert_nil @pirate.reload.ship
     assert_raise(ActiveRecord::RecordNotFound) { Ship.find(@ship.id) }
@@ -410,8 +410,8 @@ end
 
 class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
   def setup
-    @ship = Ship.new(:name => 'Nights Dirty Lightning')
-    @pirate = @ship.build_pirate(:catchphrase => 'Aye')
+    @ship = Ship.new(:name => "Nights Dirty Lightning")
+    @pirate = @ship.build_pirate(:catchphrase => "Aye")
     @ship.save!
   end
 
@@ -421,15 +421,15 @@ class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
 
   def test_should_build_a_new_record_if_there_is_no_id
     @pirate.destroy
-    @ship.reload.pirate_attributes = { :catchphrase => 'Arr' }
+    @ship.reload.pirate_attributes = { :catchphrase => "Arr" }
 
     assert !@ship.pirate.persisted?
-    assert_equal 'Arr', @ship.pirate.catchphrase
+    assert_equal "Arr", @ship.pirate.catchphrase
   end
 
   def test_should_not_build_a_new_record_if_there_is_no_id_and_destroy_is_truthy
     @pirate.destroy
-    @ship.reload.pirate_attributes = { :catchphrase => 'Arr', :_destroy => '1' }
+    @ship.reload.pirate_attributes = { :catchphrase => "Arr", :_destroy => "1" }
 
     assert_nil @ship.pirate
   end
@@ -442,25 +442,25 @@ class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
   end
 
   def test_should_replace_an_existing_record_if_there_is_no_id
-    @ship.reload.pirate_attributes = { :catchphrase => 'Arr' }
+    @ship.reload.pirate_attributes = { :catchphrase => "Arr" }
 
     assert !@ship.pirate.persisted?
-    assert_equal 'Arr', @ship.pirate.catchphrase
-    assert_equal 'Aye', @pirate.catchphrase
+    assert_equal "Arr", @ship.pirate.catchphrase
+    assert_equal "Aye", @pirate.catchphrase
   end
 
   def test_should_not_replace_an_existing_record_if_there_is_no_id_and_destroy_is_truthy
-    @ship.reload.pirate_attributes = { :catchphrase => 'Arr', :_destroy => '1' }
+    @ship.reload.pirate_attributes = { :catchphrase => "Arr", :_destroy => "1" }
 
     assert_equal @pirate, @ship.pirate
-    assert_equal 'Aye', @ship.pirate.catchphrase
+    assert_equal "Aye", @ship.pirate.catchphrase
   end
 
   def test_should_modify_an_existing_record_if_there_is_a_matching_id
-    @ship.reload.pirate_attributes = { :id => @pirate.id, :catchphrase => 'Arr' }
+    @ship.reload.pirate_attributes = { :id => @pirate.id, :catchphrase => "Arr" }
 
     assert_equal @pirate, @ship.pirate
-    assert_equal 'Arr', @ship.pirate.catchphrase
+    assert_equal "Arr", @ship.pirate.catchphrase
   end
 
   def test_should_raise_RecordNotFound_if_an_id_is_given_but_doesnt_return_a_record
@@ -471,24 +471,24 @@ class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
   end
 
   def test_should_take_a_hash_with_string_keys_and_update_the_associated_model
-    @ship.reload.pirate_attributes = { 'id' => @pirate.id, 'catchphrase' => 'Arr' }
+    @ship.reload.pirate_attributes = { "id" => @pirate.id, "catchphrase" => "Arr" }
 
     assert_equal @pirate, @ship.pirate
-    assert_equal 'Arr', @ship.pirate.catchphrase
+    assert_equal "Arr", @ship.pirate.catchphrase
   end
 
   def test_should_modify_an_existing_record_if_there_is_a_matching_composite_id
-    @pirate.stub(:id, 'ABC1X') do
-      @ship.pirate_attributes = { :id => @pirate.id, :catchphrase => 'Arr' }
+    @pirate.stub(:id, "ABC1X") do
+      @ship.pirate_attributes = { :id => @pirate.id, :catchphrase => "Arr" }
 
-      assert_equal 'Arr', @ship.pirate.catchphrase
+      assert_equal "Arr", @ship.pirate.catchphrase
     end
   end
 
   def test_should_destroy_an_existing_record_if_there_is_a_matching_id_and_destroy_is_truthy
     @ship.pirate.destroy
-    [1, '1', true, 'true'].each do |truth|
-      pirate = @ship.reload.create_pirate(catchphrase: 'Arr')
+    [1, "1", true, "true"].each do |truth|
+      pirate = @ship.reload.create_pirate(catchphrase: "Arr")
       @ship.update(pirate_attributes: { id: pirate.id, _destroy: truth })
       assert_raise(ActiveRecord::RecordNotFound) { pirate.reload }
     end
@@ -509,7 +509,7 @@ class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
   end
 
   def test_should_not_destroy_an_existing_record_if_destroy_is_not_truthy
-    [nil, '0', 0, 'false', false].each do |not_truth|
+    [nil, "0", 0, "false", false].each do |not_truth|
       @ship.update(pirate_attributes: { id: @ship.pirate.id, _destroy: not_truth })
       assert_nothing_raised { @ship.pirate.reload }
     end
@@ -518,24 +518,24 @@ class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
   def test_should_not_destroy_an_existing_record_if_allow_destroy_is_false
     Ship.accepts_nested_attributes_for :pirate, :allow_destroy => false, :reject_if => proc(&:empty?)
 
-    @ship.update(pirate_attributes: { id: @ship.pirate.id, _destroy: '1' })
+    @ship.update(pirate_attributes: { id: @ship.pirate.id, _destroy: "1" })
     assert_nothing_raised { @ship.pirate.reload }
   ensure
     Ship.accepts_nested_attributes_for :pirate, :allow_destroy => true, :reject_if => proc(&:empty?)
   end
 
   def test_should_work_with_update_as_well
-    @ship.update({ name: 'Mister Pablo', pirate_attributes: { catchphrase: 'Arr' } })
+    @ship.update({ name: "Mister Pablo", pirate_attributes: { catchphrase: "Arr" } })
     @ship.reload
 
-    assert_equal 'Mister Pablo', @ship.name
-    assert_equal 'Arr', @ship.pirate.catchphrase
+    assert_equal "Mister Pablo", @ship.name
+    assert_equal "Arr", @ship.pirate.catchphrase
   end
 
   def test_should_not_destroy_the_associated_model_until_the_parent_is_saved
     pirate = @ship.pirate
 
-    @ship.attributes = { :pirate_attributes => { :id => pirate.id, '_destroy' => true } }
+    @ship.attributes = { :pirate_attributes => { :id => pirate.id, "_destroy" => true } }
     assert_nothing_raised { Pirate.find(pirate.id) }
     @ship.save
     assert_raise(ActiveRecord::RecordNotFound) { Pirate.find(pirate.id) }
@@ -547,36 +547,36 @@ class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
 
   def test_should_create_new_model_when_nothing_is_there_and_update_only_is_true
     @pirate.delete
-    @ship.reload.attributes = { :update_only_pirate_attributes => { :catchphrase => 'Arr' } }
+    @ship.reload.attributes = { :update_only_pirate_attributes => { :catchphrase => "Arr" } }
 
     assert !@ship.update_only_pirate.persisted?
   end
 
   def test_should_update_existing_when_update_only_is_true_and_no_id_is_given
     @pirate.delete
-    @pirate = @ship.create_update_only_pirate(catchphrase: 'Aye')
+    @pirate = @ship.create_update_only_pirate(catchphrase: "Aye")
 
-    @ship.update(update_only_pirate_attributes: { catchphrase: 'Arr' })
-    assert_equal 'Arr', @pirate.reload.catchphrase
+    @ship.update(update_only_pirate_attributes: { catchphrase: "Arr" })
+    assert_equal "Arr", @pirate.reload.catchphrase
     assert_equal @pirate, @ship.reload.update_only_pirate
   end
 
   def test_should_update_existing_when_update_only_is_true_and_id_is_given
     @pirate.delete
-    @pirate = @ship.create_update_only_pirate(catchphrase: 'Aye')
+    @pirate = @ship.create_update_only_pirate(catchphrase: "Aye")
 
-    @ship.update(update_only_pirate_attributes: { catchphrase: 'Arr', id: @pirate.id })
+    @ship.update(update_only_pirate_attributes: { catchphrase: "Arr", id: @pirate.id })
 
-    assert_equal 'Arr', @pirate.reload.catchphrase
+    assert_equal "Arr", @pirate.reload.catchphrase
     assert_equal @pirate, @ship.reload.update_only_pirate
   end
 
   def test_should_destroy_existing_when_update_only_is_true_and_id_is_given_and_is_marked_for_destruction
     Ship.accepts_nested_attributes_for :update_only_pirate, :update_only => true, :allow_destroy => true
     @pirate.delete
-    @pirate = @ship.create_update_only_pirate(catchphrase: 'Aye')
+    @pirate = @ship.create_update_only_pirate(catchphrase: "Aye")
 
-    @ship.update(update_only_pirate_attributes: { catchphrase: 'Arr', id: @pirate.id, _destroy: true })
+    @ship.update(update_only_pirate_attributes: { catchphrase: "Arr", id: @pirate.id, _destroy: true })
 
     assert_raise(ActiveRecord::RecordNotFound) { @pirate.reload }
 
@@ -598,8 +598,8 @@ module NestedAttributesOnACollectionAssociationTests
 
   def test_should_save_only_one_association_on_create
     pirate = Pirate.create!({
-      :catchphrase => 'Arr',
-      association_getter => { 'foo' => { :name => 'Grace OMalley' } }
+      :catchphrase => "Arr",
+      association_getter => { "foo" => { :name => "Grace OMalley" } }
     })
 
     assert_equal 1, pirate.reload.send(@association_name).count
@@ -608,76 +608,76 @@ module NestedAttributesOnACollectionAssociationTests
   def test_should_take_a_hash_with_string_keys_and_assign_the_attributes_to_the_associated_models
     @alternate_params[association_getter].stringify_keys!
     @pirate.update @alternate_params
-    assert_equal ['Grace OMalley', 'Privateers Greed'], [@child_1.reload.name, @child_2.reload.name]
+    assert_equal ["Grace OMalley", "Privateers Greed"], [@child_1.reload.name, @child_2.reload.name]
   end
 
   def test_should_take_an_array_and_assign_the_attributes_to_the_associated_models
     @pirate.send(association_setter, @alternate_params[association_getter].values)
     @pirate.save
-    assert_equal ['Grace OMalley', 'Privateers Greed'], [@child_1.reload.name, @child_2.reload.name]
+    assert_equal ["Grace OMalley", "Privateers Greed"], [@child_1.reload.name, @child_2.reload.name]
   end
 
   def test_should_also_work_with_a_HashWithIndifferentAccess
-    @pirate.send(association_setter, ActiveSupport::HashWithIndifferentAccess.new('foo' => ActiveSupport::HashWithIndifferentAccess.new(:id => @child_1.id, :name => 'Grace OMalley')))
+    @pirate.send(association_setter, ActiveSupport::HashWithIndifferentAccess.new("foo" => ActiveSupport::HashWithIndifferentAccess.new(:id => @child_1.id, :name => "Grace OMalley")))
     @pirate.save
-    assert_equal 'Grace OMalley', @child_1.reload.name
+    assert_equal "Grace OMalley", @child_1.reload.name
   end
 
   def test_should_take_a_hash_and_assign_the_attributes_to_the_associated_models
     @pirate.attributes = @alternate_params
-    assert_equal 'Grace OMalley', @pirate.send(@association_name).first.name
-    assert_equal 'Privateers Greed', @pirate.send(@association_name).last.name
+    assert_equal "Grace OMalley", @pirate.send(@association_name).first.name
+    assert_equal "Privateers Greed", @pirate.send(@association_name).last.name
   end
 
   def test_should_not_load_association_when_updating_existing_records
     @pirate.reload
-    @pirate.send(association_setter, [{ :id => @child_1.id, :name => 'Grace OMalley' }])
+    @pirate.send(association_setter, [{ :id => @child_1.id, :name => "Grace OMalley" }])
     assert ! @pirate.send(@association_name).loaded?
 
     @pirate.save
     assert ! @pirate.send(@association_name).loaded?
-    assert_equal 'Grace OMalley', @child_1.reload.name
+    assert_equal "Grace OMalley", @child_1.reload.name
   end
 
   def test_should_not_overwrite_unsaved_updates_when_loading_association
     @pirate.reload
-    @pirate.send(association_setter, [{ :id => @child_1.id, :name => 'Grace OMalley' }])
-    assert_equal 'Grace OMalley', @pirate.send(@association_name).load_target.find { |r| r.id == @child_1.id }.name
+    @pirate.send(association_setter, [{ :id => @child_1.id, :name => "Grace OMalley" }])
+    assert_equal "Grace OMalley", @pirate.send(@association_name).load_target.find { |r| r.id == @child_1.id }.name
   end
 
   def test_should_preserve_order_when_not_overwriting_unsaved_updates
     @pirate.reload
-    @pirate.send(association_setter, [{ :id => @child_1.id, :name => 'Grace OMalley' }])
+    @pirate.send(association_setter, [{ :id => @child_1.id, :name => "Grace OMalley" }])
     assert_equal @child_1.id, @pirate.send(@association_name).load_target.first.id
   end
 
   def test_should_refresh_saved_records_when_not_overwriting_unsaved_updates
     @pirate.reload
-    record = @pirate.class.reflect_on_association(@association_name).klass.new(name: 'Grace OMalley')
+    record = @pirate.class.reflect_on_association(@association_name).klass.new(name: "Grace OMalley")
     @pirate.send(@association_name) << record
     record.save!
-    @pirate.send(@association_name).last.update!(name: 'Polly')
-    assert_equal 'Polly', @pirate.send(@association_name).load_target.last.name
+    @pirate.send(@association_name).last.update!(name: "Polly")
+    assert_equal "Polly", @pirate.send(@association_name).load_target.last.name
   end
 
   def test_should_not_remove_scheduled_destroys_when_loading_association
     @pirate.reload
-    @pirate.send(association_setter, [{ :id => @child_1.id, :_destroy => '1' }])
+    @pirate.send(association_setter, [{ :id => @child_1.id, :_destroy => "1" }])
     assert @pirate.send(@association_name).load_target.find { |r| r.id == @child_1.id }.marked_for_destruction?
   end
 
   def test_should_take_a_hash_with_composite_id_keys_and_assign_the_attributes_to_the_associated_models
-    @child_1.stub(:id, 'ABC1X') do
-      @child_2.stub(:id, 'ABC2X') do
+    @child_1.stub(:id, "ABC1X") do
+      @child_2.stub(:id, "ABC2X") do
 
         @pirate.attributes = {
           association_getter => [
-            { :id => @child_1.id, :name => 'Grace OMalley' },
-            { :id => @child_2.id, :name => 'Privateers Greed' }
+            { :id => @child_1.id, :name => "Grace OMalley" },
+            { :id => @child_2.id, :name => "Privateers Greed" }
           ]
         }
 
-        assert_equal ['Grace OMalley', 'Privateers Greed'], [@child_1.name, @child_2.name]
+        assert_equal ["Grace OMalley", "Privateers Greed"], [@child_1.name, @child_2.name]
       end
     end
   end
@@ -690,8 +690,8 @@ module NestedAttributesOnACollectionAssociationTests
   end
 
   def test_should_raise_RecordNotFound_if_an_id_belonging_to_a_different_record_is_given
-    other_pirate = Pirate.create! catchphrase: 'Ahoy!'
-    other_child = other_pirate.send(@association_name).create! name: 'Buccaneers Servant'
+    other_pirate = Pirate.create! catchphrase: "Ahoy!"
+    other_child = other_pirate.send(@association_name).create! name: "Buccaneers Servant"
 
     exception = assert_raise ActiveRecord::RecordNotFound do
       @pirate.attributes = { association_getter => [{ id: other_child.id }] }
@@ -702,19 +702,19 @@ module NestedAttributesOnACollectionAssociationTests
   def test_should_automatically_build_new_associated_models_for_each_entry_in_a_hash_where_the_id_is_missing
     @pirate.send(@association_name).destroy_all
     @pirate.reload.attributes = {
-      association_getter => { 'foo' => { :name => 'Grace OMalley' }, 'bar' => { :name => 'Privateers Greed' }}
+      association_getter => { "foo" => { :name => "Grace OMalley" }, "bar" => { :name => "Privateers Greed" }}
     }
 
     assert !@pirate.send(@association_name).first.persisted?
-    assert_equal 'Grace OMalley', @pirate.send(@association_name).first.name
+    assert_equal "Grace OMalley", @pirate.send(@association_name).first.name
 
     assert !@pirate.send(@association_name).last.persisted?
-    assert_equal 'Privateers Greed', @pirate.send(@association_name).last.name
+    assert_equal "Privateers Greed", @pirate.send(@association_name).last.name
   end
 
   def test_should_not_assign_destroy_key_to_a_record
     assert_nothing_raised do
-      @pirate.send(association_setter, { 'foo' => { '_destroy' => '0' }})
+      @pirate.send(association_setter, { "foo" => { "_destroy" => "0" }})
     end
   end
 
@@ -722,17 +722,17 @@ module NestedAttributesOnACollectionAssociationTests
     @pirate.send(@association_name).destroy_all
     @pirate.reload.attributes = {
       association_getter => {
-        'foo' => { :name => 'Grace OMalley' },
-        'bar' => { :name => 'Privateers Greed', '_destroy' => '1' }
+        "foo" => { :name => "Grace OMalley" },
+        "bar" => { :name => "Privateers Greed", "_destroy" => "1" }
       }
     }
 
     assert_equal 1, @pirate.send(@association_name).length
-    assert_equal 'Grace OMalley', @pirate.send(@association_name).first.name
+    assert_equal "Grace OMalley", @pirate.send(@association_name).first.name
   end
 
   def test_should_ignore_new_associated_records_if_a_reject_if_proc_returns_false
-    @alternate_params[association_getter]['baz'] = {}
+    @alternate_params[association_getter]["baz"] = {}
     assert_no_difference("@pirate.send(@association_name).count") do
       @pirate.attributes = @alternate_params
     end
@@ -740,11 +740,11 @@ module NestedAttributesOnACollectionAssociationTests
 
   def test_should_sort_the_hash_by_the_keys_before_building_new_associated_models
     attributes = {}
-    attributes['123726353'] = { :name => 'Grace OMalley' }
-    attributes['2'] = { :name => 'Privateers Greed' } # 2 is lower then 123726353
+    attributes["123726353"] = { :name => "Grace OMalley" }
+    attributes["2"] = { :name => "Privateers Greed" } # 2 is lower then 123726353
     @pirate.send(association_setter, attributes)
 
-    assert_equal ['Posideons Killer', 'Killer bandita Dionne', 'Privateers Greed', 'Grace OMalley'].to_set, @pirate.send(@association_name).map(&:name).to_set
+    assert_equal ["Posideons Killer", "Killer bandita Dionne", "Privateers Greed", "Grace OMalley"].to_set, @pirate.send(@association_name).map(&:name).to_set
   end
 
   def test_should_raise_an_argument_error_if_something_else_than_a_hash_is_passed
@@ -758,47 +758,47 @@ module NestedAttributesOnACollectionAssociationTests
   end
 
   def test_should_work_with_update_as_well
-    @pirate.update(catchphrase: 'Arr',
-      association_getter => { 'foo' => { :id => @child_1.id, :name => 'Grace OMalley' }})
+    @pirate.update(catchphrase: "Arr",
+      association_getter => { "foo" => { :id => @child_1.id, :name => "Grace OMalley" }})
 
-    assert_equal 'Grace OMalley', @child_1.reload.name
+    assert_equal "Grace OMalley", @child_1.reload.name
   end
 
   def test_should_update_existing_records_and_add_new_ones_that_have_no_id
-    @alternate_params[association_getter]['baz'] = { name: 'Buccaneers Servant' }
-    assert_difference('@pirate.send(@association_name).count', +1) do
+    @alternate_params[association_getter]["baz"] = { name: "Buccaneers Servant" }
+    assert_difference("@pirate.send(@association_name).count", +1) do
       @pirate.update @alternate_params
     end
-    assert_equal ['Grace OMalley', 'Privateers Greed', 'Buccaneers Servant'].to_set, @pirate.reload.send(@association_name).map(&:name).to_set
+    assert_equal ["Grace OMalley", "Privateers Greed", "Buccaneers Servant"].to_set, @pirate.reload.send(@association_name).map(&:name).to_set
   end
 
   def test_should_be_possible_to_destroy_a_record
-    ['1', 1, 'true', true].each do |true_variable|
-      record = @pirate.reload.send(@association_name).create!(:name => 'Grace OMalley')
+    ["1", 1, "true", true].each do |true_variable|
+      record = @pirate.reload.send(@association_name).create!(:name => "Grace OMalley")
       @pirate.send(association_setter,
-        @alternate_params[association_getter].merge('baz' => { :id => record.id, '_destroy' => true_variable })
+        @alternate_params[association_getter].merge("baz" => { :id => record.id, "_destroy" => true_variable })
       )
 
-      assert_difference('@pirate.send(@association_name).count', -1) do
+      assert_difference("@pirate.send(@association_name).count", -1) do
         @pirate.save
       end
     end
   end
 
   def test_should_not_destroy_the_associated_model_with_a_non_truthy_argument
-    [nil, '', '0', 0, 'false', false].each do |false_variable|
-      @alternate_params[association_getter]['foo']['_destroy'] = false_variable
-      assert_no_difference('@pirate.send(@association_name).count') do
+    [nil, "", "0", 0, "false", false].each do |false_variable|
+      @alternate_params[association_getter]["foo"]["_destroy"] = false_variable
+      assert_no_difference("@pirate.send(@association_name).count") do
         @pirate.update(@alternate_params)
       end
     end
   end
 
   def test_should_not_destroy_the_associated_model_until_the_parent_is_saved
-    assert_no_difference('@pirate.send(@association_name).count') do
-      @pirate.send(association_setter, @alternate_params[association_getter].merge('baz' => { :id => @child_1.id, '_destroy' => true }))
+    assert_no_difference("@pirate.send(@association_name).count") do
+      @pirate.send(association_setter, @alternate_params[association_getter].merge("baz" => { :id => @child_1.id, "_destroy" => true }))
     end
-    assert_difference('@pirate.send(@association_name).count', -1) { @pirate.save }
+    assert_difference("@pirate.send(@association_name).count", -1) { @pirate.save }
   end
 
   def test_should_automatically_enable_autosave_on_the_association
@@ -812,10 +812,10 @@ module NestedAttributesOnACollectionAssociationTests
 
     repair_validations(Interest) do
       Interest.validates_presence_of(:man)
-      assert_difference 'Man.count' do
-        assert_difference 'Interest.count', 2 do
-          man = Man.create!(:name => 'John',
-                            :interests_attributes => [{:topic=>'Cars'}, {:topic=>'Sports'}])
+      assert_difference "Man.count" do
+        assert_difference "Interest.count", 2 do
+          man = Man.create!(:name => "John",
+                            :interests_attributes => [{:topic=>"Cars"}, {:topic=>"Sports"}])
           assert_equal 2, man.interests.count
         end
       end
@@ -823,7 +823,7 @@ module NestedAttributesOnACollectionAssociationTests
   end
 
   def test_can_use_symbols_as_object_identifier
-    @pirate.attributes = { :parrots_attributes => { :foo => { :name => 'Lovely Day' }, :bar => { :name => 'Blown Away' } } }
+    @pirate.attributes = { :parrots_attributes => { :foo => { :name => "Lovely Day" }, :bar => { :name => "Blown Away" } } }
     assert_nothing_raised { @pirate.save! }
   end
 
@@ -832,10 +832,10 @@ module NestedAttributesOnACollectionAssociationTests
 
     repair_validations(Interest) do
       Interest.validates_numericality_of(:zine_id)
-      man = Man.create(name: 'John')
-      interest = man.interests.create(topic: 'bar', zine_id: 0)
+      man = Man.create(name: "John")
+      interest = man.interests.create(topic: "bar", zine_id: 0)
       assert interest.save
-      assert !man.update({interests_attributes: { id: interest.id, zine_id: 'foo' }})
+      assert !man.update({interests_attributes: { id: interest.id, zine_id: "foo" }})
     end
   end
 
@@ -856,15 +856,15 @@ class TestNestedAttributesOnAHasManyAssociation < ActiveRecord::TestCase
     @association_name = :birds
 
     @pirate = Pirate.create!(:catchphrase => "Don' botharrr talkin' like one, savvy?")
-    @pirate.birds.create!(:name => 'Posideons Killer')
-    @pirate.birds.create!(:name => 'Killer bandita Dionne')
+    @pirate.birds.create!(:name => "Posideons Killer")
+    @pirate.birds.create!(:name => "Killer bandita Dionne")
 
     @child_1, @child_2 = @pirate.birds
 
     @alternate_params = {
       :birds_attributes => {
-        'foo' => { :id => @child_1.id, :name => 'Grace OMalley' },
-        'bar' => { :id => @child_2.id, :name => 'Privateers Greed' }
+        "foo" => { :id => @child_1.id, :name => "Grace OMalley" },
+        "bar" => { :id => @child_2.id, :name => "Privateers Greed" }
       }
     }
   end
@@ -878,15 +878,15 @@ class TestNestedAttributesOnAHasAndBelongsToManyAssociation < ActiveRecord::Test
     @association_name = :parrots
 
     @pirate = Pirate.create!(:catchphrase => "Don' botharrr talkin' like one, savvy?")
-    @pirate.parrots.create!(:name => 'Posideons Killer')
-    @pirate.parrots.create!(:name => 'Killer bandita Dionne')
+    @pirate.parrots.create!(:name => "Posideons Killer")
+    @pirate.parrots.create!(:name => "Killer bandita Dionne")
 
     @child_1, @child_2 = @pirate.parrots
 
     @alternate_params = {
       :parrots_attributes => {
-        'foo' => { :id => @child_1.id, :name => 'Grace OMalley' },
-        'bar' => { :id => @child_2.id, :name => 'Privateers Greed' }
+        "foo" => { :id => @child_1.id, :name => "Grace OMalley" },
+        "bar" => { :id => @child_2.id, :name => "Privateers Greed" }
       }
     }
   end
@@ -900,20 +900,20 @@ module NestedAttributesLimitTests
   end
 
   def test_limit_with_less_records
-    @pirate.attributes = { :parrots_attributes => { 'foo' => { :name => 'Big Big Love' } } }
-    assert_difference('Parrot.count') { @pirate.save! }
+    @pirate.attributes = { :parrots_attributes => { "foo" => { :name => "Big Big Love" } } }
+    assert_difference("Parrot.count") { @pirate.save! }
   end
 
   def test_limit_with_number_exact_records
-    @pirate.attributes = { :parrots_attributes => { 'foo' => { :name => 'Lovely Day' }, 'bar' => { :name => 'Blown Away' } } }
-    assert_difference('Parrot.count', 2) { @pirate.save! }
+    @pirate.attributes = { :parrots_attributes => { "foo" => { :name => "Lovely Day" }, "bar" => { :name => "Blown Away" } } }
+    assert_difference("Parrot.count", 2) { @pirate.save! }
   end
 
   def test_limit_with_exceeding_records
     assert_raises(ActiveRecord::NestedAttributes::TooManyRecords) do
-      @pirate.attributes = { :parrots_attributes => { 'foo' => { :name => 'Lovely Day' },
-                                                      'bar' => { :name => 'Blown Away' },
-                                                      'car' => { :name => 'The Happening' }} }
+      @pirate.attributes = { :parrots_attributes => { "foo" => { :name => "Lovely Day" },
+                                                      "bar" => { :name => "Blown Away" },
+                                                      "car" => { :name => "The Happening" }} }
     end
   end
 end
@@ -959,15 +959,15 @@ class TestNestedAttributesWithNonStandardPrimaryKeys < ActiveRecord::TestCase
 
     @params = {
       :pets_attributes => {
-        '0' => { :id => @pet1.id, :name => 'Foo' },
-        '1' => { :id => @pet2.id, :name => 'Bar' }
+        "0" => { :id => @pet1.id, :name => "Foo" },
+        "1" => { :id => @pet2.id, :name => "Bar" }
       }
     }
   end
 
   def test_should_update_existing_records_with_non_standard_primary_key
     @owner.update(@params)
-    assert_equal ['Foo', 'Bar'], @owner.pets.map(&:name)
+    assert_equal ["Foo", "Bar"], @owner.pets.map(&:name)
   end
 
   def test_attr_accessor_of_child_should_be_value_provided_during_update
@@ -978,7 +978,7 @@ class TestNestedAttributesWithNonStandardPrimaryKeys < ActiveRecord::TestCase
                                                 :current_user => "John",
                                                 :_destroy=>true }}}
     @owner.update(attributes)
-    assert_equal 'John', Pet.after_destroy_output
+    assert_equal "John", Pet.after_destroy_output
   end
 
 end
@@ -1007,12 +1007,12 @@ class TestHasOneAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveRe
 
   test "when great-grandchild marked_for_destruction via attributes, saving parent should destroy great-grandchild" do
     @pirate.attributes = {:ship_attributes => {:id => @ship.id, :parts_attributes => [{:id => @part.id, :trinkets_attributes => [{:id => @trinket.id, :_destroy => true}]}]}}
-    assert_difference('@part.trinkets.count', -1) { @pirate.save }
+    assert_difference("@part.trinkets.count", -1) { @pirate.save }
   end
 
   test "when great-grandchild added via attributes, saving parent should create great-grandchild" do
     @pirate.attributes = {:ship_attributes => {:id => @ship.id, :parts_attributes => [{:id => @part.id, :trinkets_attributes => [{:name => "created"}]}]}}
-    assert_difference('@part.trinkets.count', 1) { @pirate.save }
+    assert_difference("@part.trinkets.count", 1) { @pirate.save }
   end
 
   test "when extra records exist for associations, validate (which calls nested_records_changed_for_autosave?) should not load them up" do
@@ -1033,21 +1033,21 @@ class TestHasManyAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveR
   end
 
   test "if association is not loaded and association record is saved and then in memory record attributes should be saved" do
-    @ship.parts_attributes=[{:id => @part.id,:name =>'Deck'}]
+    @ship.parts_attributes=[{:id => @part.id,:name =>"Deck"}]
     assert_equal 1, @ship.association(:parts).target.size
-    assert_equal 'Deck', @ship.parts[0].name
+    assert_equal "Deck", @ship.parts[0].name
   end
 
   test "if association is not loaded and child doesn't change and I am saving a grandchild then in memory record should be used" do
-    @ship.parts_attributes=[{:id => @part.id,:trinkets_attributes =>[{:id => @trinket.id, :name => 'Ruby'}]}]
+    @ship.parts_attributes=[{:id => @part.id,:trinkets_attributes =>[{:id => @trinket.id, :name => "Ruby"}]}]
     assert_equal 1, @ship.association(:parts).target.size
-    assert_equal 'Mast', @ship.parts[0].name
+    assert_equal "Mast", @ship.parts[0].name
     assert_no_difference("@ship.parts[0].association(:trinkets).target.size") do
       @ship.parts[0].association(:trinkets).target.size
     end
-    assert_equal 'Ruby', @ship.parts[0].trinkets[0].name
+    assert_equal "Ruby", @ship.parts[0].trinkets[0].name
     @ship.save
-    assert_equal 'Ruby', @ship.parts[0].trinkets[0].name
+    assert_equal "Ruby", @ship.parts[0].trinkets[0].name
   end
 
   test "when grandchild changed in memory, saving parent should save grandchild" do
@@ -1064,12 +1064,12 @@ class TestHasManyAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveR
 
   test "when grandchild marked_for_destruction via attributes, saving parent should destroy grandchild" do
     @ship.attributes = {:parts_attributes => [{:id => @part.id, :trinkets_attributes => [{:id => @trinket.id, :_destroy => true}]}]}
-    assert_difference('@part.trinkets.count', -1) { @ship.save }
+    assert_difference("@part.trinkets.count", -1) { @ship.save }
   end
 
   test "when grandchild added via attributes, saving parent should create grandchild" do
     @ship.attributes = {:parts_attributes => [{:id => @part.id, :trinkets_attributes => [{:name => "created"}]}]}
-    assert_difference('@part.trinkets.count', 1) { @ship.save }
+    assert_difference("@part.trinkets.count", 1) { @ship.save }
   end
 
   test "when extra records exist for associations, validate (which calls nested_records_changed_for_autosave?) should not load them up" do
diff --git a/activerecord/test/cases/nested_attributes_with_callbacks_test.rb b/activerecord/test/cases/nested_attributes_with_callbacks_test.rb
index 43a69928b6..3f87e514b5 100644
--- a/activerecord/test/cases/nested_attributes_with_callbacks_test.rb
+++ b/activerecord/test/cases/nested_attributes_with_callbacks_test.rb
@@ -21,7 +21,7 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
     @@add_callback_called = []
     @pirate = Pirate.new.tap do |pirate|
       pirate.catchphrase = "Don't call me!"
-      pirate.birds_attributes = [{:name => 'Bird1'},{:name => 'Bird2'}]
+      pirate.birds_attributes = [{:name => "Bird1"},{:name => "Bird2"}]
       pirate.save!
     end
     @birds = @pirate.birds.to_a
@@ -46,17 +46,17 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
   end
 
   def new_bird_attributes
-     [{'name' => "New Bird"}]
+     [{"name" => "New Bird"}]
   end
 
   def destroy_bird_attributes
-    [{'id' => bird_to_destroy.id.to_s, "_destroy" => true}]
+    [{"id" => bird_to_destroy.id.to_s, "_destroy" => true}]
   end
 
   def update_new_and_destroy_bird_attributes
-    [{'id' => @birds[0].id.to_s, 'name' => 'New Name'},
-     {'name' => "New Bird"},
-     {'id' => bird_to_destroy.id.to_s, "_destroy" => true}]
+    [{"id" => @birds[0].id.to_s, "name" => "New Name"},
+     {"name" => "New Bird"},
+     {"id" => bird_to_destroy.id.to_s, "_destroy" => true}]
   end
 
   # Characterizing when :before_add callback is called
@@ -137,8 +137,8 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
   def assert_assignment_affects_records_in_target(association_name)
     association = @pirate.send(association_name)
     assert association.detect {|b| b == bird_to_update }.name_changed?,
-      'Update record not updated'
+      "Update record not updated"
     assert association.detect {|b| b == bird_to_destroy }.marked_for_destruction?,
-      'Destroy record not marked for destruction'
+      "Destroy record not marked for destruction"
   end
 end
diff --git a/activerecord/test/cases/persistence_test.rb b/activerecord/test/cases/persistence_test.rb
index 56092aaa0c..ec8fe53158 100644
--- a/activerecord/test/cases/persistence_test.rb
+++ b/activerecord/test/cases/persistence_test.rb
@@ -1,30 +1,30 @@
 require "cases/helper"
-require 'models/aircraft'
-require 'models/post'
-require 'models/comment'
-require 'models/author'
-require 'models/topic'
-require 'models/reply'
-require 'models/category'
-require 'models/company'
-require 'models/developer'
-require 'models/computer'
-require 'models/project'
-require 'models/minimalistic'
-require 'models/warehouse_thing'
-require 'models/parrot'
-require 'models/minivan'
-require 'models/owner'
-require 'models/person'
-require 'models/pet'
-require 'models/ship'
-require 'models/toy'
-require 'models/admin'
-require 'models/admin/user'
-require 'rexml/document'
+require "models/aircraft"
+require "models/post"
+require "models/comment"
+require "models/author"
+require "models/topic"
+require "models/reply"
+require "models/category"
+require "models/company"
+require "models/developer"
+require "models/computer"
+require "models/project"
+require "models/minimalistic"
+require "models/warehouse_thing"
+require "models/parrot"
+require "models/minivan"
+require "models/owner"
+require "models/person"
+require "models/pet"
+require "models/ship"
+require "models/toy"
+require "models/admin"
+require "models/admin/user"
+require "rexml/document"
 
 class PersistenceTest < ActiveRecord::TestCase
-  fixtures :topics, :companies, :developers, :projects, :computers, :accounts, :minimalistics, 'warehouse-things', :authors, :author_addresses, :categorizations, :categories, :posts, :minivans, :pets, :toys
+  fixtures :topics, :companies, :developers, :projects, :computers, :accounts, :minimalistics, "warehouse-things", :authors, :author_addresses, :categorizations, :categories, :posts, :minivans, :pets, :toys
 
   # Oracle UPDATE does not support ORDER BY
   unless current_adapter?(:OracleAdapter)
@@ -39,18 +39,18 @@ class PersistenceTest < ActiveRecord::TestCase
       assert_equal authors(:david).id + 1, authors(:mary).id # make sure there is going to be a duplicate PK error
       test_update_with_order_succeeds = lambda do |order|
         begin
-          Author.order(order).update_all('id = id + 1')
+          Author.order(order).update_all("id = id + 1")
         rescue ActiveRecord::ActiveRecordError
           false
         end
       end
 
-      if test_update_with_order_succeeds.call('id DESC')
-        assert !test_update_with_order_succeeds.call('id ASC') # test that this wasn't a fluke and using an incorrect order results in an exception
+      if test_update_with_order_succeeds.call("id DESC")
+        assert !test_update_with_order_succeeds.call("id ASC") # test that this wasn't a fluke and using an incorrect order results in an exception
       else
         # test that we're failing because the current Arel's engine doesn't support UPDATE ORDER BY queries is using subselects instead
         assert_sql(/\AUPDATE .+ \(SELECT .* ORDER BY id DESC\)\Z/i) do
-          test_update_with_order_succeeds.call('id DESC')
+          test_update_with_order_succeeds.call("id DESC")
         end
       end
     end
@@ -83,7 +83,7 @@ class PersistenceTest < ActiveRecord::TestCase
   end
 
   def test_delete_all_with_joins_and_where_part_is_hash
-    where_args = {:toys => {:name => 'Bone'}}
+    where_args = {:toys => {:name => "Bone"}}
     count = Pet.joins(:toys).where(where_args).count
 
     assert_equal count, 1
@@ -91,7 +91,7 @@ class PersistenceTest < ActiveRecord::TestCase
   end
 
   def test_delete_all_with_joins_and_where_part_is_not_hash
-    where_args = ['toys.name = ?', 'Bone']
+    where_args = ["toys.name = ?", "Bone"]
     count = Pet.joins(:toys).where(where_args).count
 
     assert_equal count, 1
@@ -133,10 +133,10 @@ class PersistenceTest < ActiveRecord::TestCase
 
   def test_destroy_all
     conditions = "author_name = 'Mary'"
-    topics_by_mary = Topic.all.merge!(:where => conditions, :order => 'id').to_a
+    topics_by_mary = Topic.all.merge!(:where => conditions, :order => "id").to_a
     assert ! topics_by_mary.empty?
 
-    assert_difference('Topic.count', -topics_by_mary.size) do
+    assert_difference("Topic.count", -topics_by_mary.size) do
       destroyed = Topic.where(conditions).destroy_all.sort_by(&:id)
       assert_equal topics_by_mary, destroyed
       assert destroyed.all?(&:frozen?), "destroyed topics should be frozen"
@@ -144,9 +144,9 @@ class PersistenceTest < ActiveRecord::TestCase
   end
 
   def test_destroy_many
-    clients = Client.all.merge!(:order => 'id').find([2, 3])
+    clients = Client.all.merge!(:order => "id").find([2, 3])
 
-    assert_difference('Client.count', -2) do
+    assert_difference("Client.count", -2) do
       destroyed = Client.destroy([2, 3]).sort_by(&:id)
       assert_equal clients, destroyed
       assert destroyed.all?(&:frozen?), "destroyed clients should be frozen"
@@ -170,7 +170,7 @@ class PersistenceTest < ActiveRecord::TestCase
     child_class = Class.new(Admin::User) do
       store_accessor :settings, :foo
 
-      def self.name; 'Admin::ChildUser'; end
+      def self.name; "Admin::ChildUser"; end
     end
 
     admin = Admin::User.new
@@ -281,9 +281,9 @@ class PersistenceTest < ActiveRecord::TestCase
 
   def test_create_columns_not_equal_attributes
     topic = Topic.instantiate(
-      'attributes' => {
-        'title'          => 'Another New Topic',
-        'does_not_exist' => 'test'
+      "attributes" => {
+        "title"          => "Another New Topic",
+        "does_not_exist" => "test"
       }
     )
     assert_nothing_raised { topic.save }
@@ -330,8 +330,8 @@ class PersistenceTest < ActiveRecord::TestCase
     topic.title = "Still another topic"
     topic.save
 
-    topic_reloaded = Topic.instantiate(topic.attributes.merge('does_not_exist' => 'test'))
-    topic_reloaded.title = 'A New Topic'
+    topic_reloaded = Topic.instantiate(topic.attributes.merge("does_not_exist" => "test"))
+    topic_reloaded.title = "A New Topic"
     assert_nothing_raised { topic_reloaded.save }
   end
 
@@ -371,7 +371,7 @@ class PersistenceTest < ActiveRecord::TestCase
 
   def test_update_after_create
     klass = Class.new(Topic) do
-      def self.name; 'Topic'; end
+      def self.name; "Topic"; end
       after_create do
         update_attribute("author_name", "David")
       end
@@ -387,24 +387,24 @@ class PersistenceTest < ActiveRecord::TestCase
 
   def test_update_attribute_does_not_run_sql_if_attribute_is_not_changed
     klass = Class.new(Topic) do
-      def self.name; 'Topic'; end
+      def self.name; "Topic"; end
     end
-    topic = klass.create(title: 'Another New Topic')
+    topic = klass.create(title: "Another New Topic")
     assert_queries(0) do
-      topic.update_attribute(:title, 'Another New Topic')
+      topic.update_attribute(:title, "Another New Topic")
     end
   end
 
   def test_update_does_not_run_sql_if_record_has_not_changed
-    topic = Topic.create(title: 'Another New Topic')
-    assert_queries(0) { topic.update(title: 'Another New Topic') }
-    assert_queries(0) { topic.update_attributes(title: 'Another New Topic') }
+    topic = Topic.create(title: "Another New Topic")
+    assert_queries(0) { topic.update(title: "Another New Topic") }
+    assert_queries(0) { topic.update_attributes(title: "Another New Topic") }
   end
 
   def test_delete
     topic = Topic.find(1)
-    assert_equal topic, topic.delete, 'topic.delete did not return self'
-    assert topic.frozen?, 'topic not frozen after delete'
+    assert_equal topic, topic.delete, "topic.delete did not return self"
+    assert topic.frozen?, "topic not frozen after delete"
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(topic.id) }
   end
 
@@ -415,15 +415,15 @@ class PersistenceTest < ActiveRecord::TestCase
 
   def test_destroy
     topic = Topic.find(1)
-    assert_equal topic, topic.destroy, 'topic.destroy did not return self'
-    assert topic.frozen?, 'topic not frozen after destroy'
+    assert_equal topic, topic.destroy, "topic.destroy did not return self"
+    assert topic.frozen?, "topic not frozen after destroy"
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(topic.id) }
   end
 
   def test_destroy!
     topic = Topic.find(1)
-    assert_equal topic, topic.destroy!, 'topic.destroy! did not return self'
-    assert topic.frozen?, 'topic not frozen after destroy!'
+    assert_equal topic, topic.destroy!, "topic.destroy! did not return self"
+    assert topic.frozen?, "topic not frozen after destroy!"
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(topic.id) }
   end
 
@@ -436,17 +436,17 @@ class PersistenceTest < ActiveRecord::TestCase
     assert_equal "bulk updated!", Topic.find(1).content
     assert_equal "bulk updated!", Topic.find(2).content
 
-    assert_equal Topic.count, Topic.update_all(['content = ?', 'bulk updated again!'])
+    assert_equal Topic.count, Topic.update_all(["content = ?", "bulk updated again!"])
     assert_equal "bulk updated again!", Topic.find(1).content
     assert_equal "bulk updated again!", Topic.find(2).content
 
-    assert_equal Topic.count, Topic.update_all(['content = ?', nil])
+    assert_equal Topic.count, Topic.update_all(["content = ?", nil])
     assert_nil Topic.find(1).content
   end
 
   def test_update_all_with_hash
     assert_not_nil Topic.find(1).last_read
-    assert_equal Topic.count, Topic.update_all(:content => 'bulk updated with hash!', :last_read => nil)
+    assert_equal Topic.count, Topic.update_all(:content => "bulk updated with hash!", :last_read => nil)
     assert_equal "bulk updated with hash!", Topic.find(1).content
     assert_equal "bulk updated with hash!", Topic.find(2).content
     assert_nil Topic.find(1).last_read
@@ -454,7 +454,7 @@ class PersistenceTest < ActiveRecord::TestCase
   end
 
   def test_update_all_with_non_standard_table_name
-    assert_equal 1, WarehouseThing.where(id: 1).update_all(['value = ?', 0])
+    assert_equal 1, WarehouseThing.where(id: 1).update_all(["value = ?", 0])
     assert_equal 0, WarehouseThing.find(1).value
   end
 
@@ -496,20 +496,20 @@ class PersistenceTest < ActiveRecord::TestCase
   end
 
   def test_update_attribute_for_readonly_attribute
-    minivan = Minivan.find('m1')
-    assert_raises(ActiveRecord::ActiveRecordError) { minivan.update_attribute(:color, 'black') }
+    minivan = Minivan.find("m1")
+    assert_raises(ActiveRecord::ActiveRecordError) { minivan.update_attribute(:color, "black") }
   end
 
   def test_update_attribute_with_one_updated
     t = Topic.first
-    t.update_attribute(:title, 'super_title')
-    assert_equal 'super_title', t.title
+    t.update_attribute(:title, "super_title")
+    assert_equal "super_title", t.title
     assert !t.changed?, "topic should not have changed"
     assert !t.title_changed?, "title should not have changed"
-    assert_nil t.title_change, 'title change should be nil'
+    assert_nil t.title_change, "title change should be nil"
 
     t.reload
-    assert_equal 'super_title', t.title
+    assert_equal "super_title", t.title
   end
 
   def test_update_attribute_for_updated_at_on
@@ -569,17 +569,17 @@ class PersistenceTest < ActiveRecord::TestCase
   end
 
   def test_update_column_with_model_having_primary_key_other_than_id
-    minivan = Minivan.find('m1')
-    new_name = 'sebavan'
+    minivan = Minivan.find("m1")
+    new_name = "sebavan"
 
     minivan.update_column(:name, new_name)
     assert_equal new_name, minivan.name
   end
 
   def test_update_column_for_readonly_attribute
-    minivan = Minivan.find('m1')
+    minivan = Minivan.find("m1")
     prev_color = minivan.color
-    assert_raises(ActiveRecord::ActiveRecordError) { minivan.update_column(:color, 'black') }
+    assert_raises(ActiveRecord::ActiveRecordError) { minivan.update_column(:color, "black") }
     assert_equal prev_color, minivan.color
   end
 
@@ -598,26 +598,26 @@ class PersistenceTest < ActiveRecord::TestCase
   end
 
   def test_update_column_with_one_changed_and_one_updated
-    t = Topic.order('id').limit(1).first
+    t = Topic.order("id").limit(1).first
     author_name = t.author_name
-    t.author_name = 'John'
-    t.update_column(:title, 'super_title')
-    assert_equal 'John', t.author_name
-    assert_equal 'super_title', t.title
+    t.author_name = "John"
+    t.update_column(:title, "super_title")
+    assert_equal "John", t.author_name
+    assert_equal "super_title", t.title
     assert t.changed?, "topic should have changed"
     assert t.author_name_changed?, "author_name should have changed"
 
     t.reload
     assert_equal author_name, t.author_name
-    assert_equal 'super_title', t.title
+    assert_equal "super_title", t.title
   end
 
   def test_update_column_with_default_scope
     developer = DeveloperCalledDavid.first
-    developer.name = 'John'
+    developer.name = "John"
     developer.save!
 
-    assert developer.update_column(:name, 'Will'), 'did not update record due to default scope'
+    assert developer.update_column(:name, "Will"), "did not update record due to default scope"
   end
 
   def test_update_columns
@@ -660,18 +660,18 @@ class PersistenceTest < ActiveRecord::TestCase
   end
 
   def test_update_columns_with_model_having_primary_key_other_than_id
-    minivan = Minivan.find('m1')
-    new_name = 'sebavan'
+    minivan = Minivan.find("m1")
+    new_name = "sebavan"
 
     minivan.update_columns(name: new_name)
     assert_equal new_name, minivan.name
   end
 
   def test_update_columns_with_one_readonly_attribute
-    minivan = Minivan.find('m1')
+    minivan = Minivan.find("m1")
     prev_color = minivan.color
     prev_name = minivan.name
-    assert_raises(ActiveRecord::ActiveRecordError) { minivan.update_columns({ name: "My old minivan", color: 'black' }) }
+    assert_raises(ActiveRecord::ActiveRecordError) { minivan.update_columns({ name: "My old minivan", color: "black" }) }
     assert_equal prev_color, minivan.color
     assert_equal prev_name, minivan.name
 
@@ -697,18 +697,18 @@ class PersistenceTest < ActiveRecord::TestCase
   end
 
   def test_update_columns_with_one_changed_and_one_updated
-    t = Topic.order('id').limit(1).first
+    t = Topic.order("id").limit(1).first
     author_name = t.author_name
-    t.author_name = 'John'
-    t.update_columns(title: 'super_title')
-    assert_equal 'John', t.author_name
-    assert_equal 'super_title', t.title
+    t.author_name = "John"
+    t.update_columns(title: "super_title")
+    assert_equal "John", t.author_name
+    assert_equal "super_title", t.title
     assert t.changed?, "topic should have changed"
     assert t.author_name_changed?, "author_name should have changed"
 
     t.reload
     assert_equal author_name, t.author_name
-    assert_equal 'super_title', t.title
+    assert_equal "super_title", t.title
   end
 
   def test_update_columns_changing_id
@@ -726,10 +726,10 @@ class PersistenceTest < ActiveRecord::TestCase
 
   def test_update_columns_with_default_scope
     developer = DeveloperCalledDavid.first
-    developer.name = 'John'
+    developer.name = "John"
     developer.save!
 
-    assert developer.update_columns(name: 'Will'), 'did not update record due to default scope'
+    assert developer.update_columns(name: "Will"), "did not update record due to default scope"
   end
 
   def test_update
@@ -909,7 +909,7 @@ class PersistenceTest < ActiveRecord::TestCase
   end
 
   def test_reload_removes_custom_selects
-    post = Post.select('posts.*, 1 as wibble').last!
+    post = Post.select("posts.*, 1 as wibble").last!
 
     assert_equal 1, post[:wibble]
     assert_nil post.reload[:wibble]
@@ -930,8 +930,8 @@ class PersistenceTest < ActiveRecord::TestCase
   def test_reload_via_querycache
     ActiveRecord::Base.connection.enable_query_cache!
     ActiveRecord::Base.connection.clear_query_cache
-    assert ActiveRecord::Base.connection.query_cache_enabled, 'cache should be on'
-    parrot = Parrot.create(:name => 'Shane')
+    assert ActiveRecord::Base.connection.query_cache_enabled, "cache should be on"
+    parrot = Parrot.create(:name => "Shane")
 
     # populate the cache with the SELECT result
     found_parrot = Parrot.find(parrot.id)
@@ -940,16 +940,16 @@ class PersistenceTest < ActiveRecord::TestCase
     # Manually update the 'name' attribute in the DB directly
     assert_equal 1, ActiveRecord::Base.connection.query_cache.length
     ActiveRecord::Base.uncached do
-      found_parrot.name = 'Mary'
+      found_parrot.name = "Mary"
       found_parrot.save
     end
 
     # Now reload, and verify that it gets the DB version, and not the querycache version
     found_parrot.reload
-    assert_equal 'Mary', found_parrot.name
+    assert_equal "Mary", found_parrot.name
 
     found_parrot = Parrot.find(parrot.id)
-    assert_equal 'Mary', found_parrot.name
+    assert_equal "Mary", found_parrot.name
   ensure
     ActiveRecord::Base.connection.disable_query_cache!
   end
@@ -968,7 +968,7 @@ class PersistenceTest < ActiveRecord::TestCase
       end
 
       instance  = widget.create!({
-        name: 'Bob',
+        name: "Bob",
         created_at: 1.day.ago,
         updated_at: 1.day.ago
       })
@@ -976,7 +976,7 @@ class PersistenceTest < ActiveRecord::TestCase
       created_at = instance.created_at
       updated_at = instance.updated_at
 
-      instance.name = 'Barb'
+      instance.name = "Barb"
       instance.save!(touch: false)
       assert_equal instance.created_at, created_at
       assert_equal instance.updated_at, updated_at
diff --git a/activerecord/test/cases/primary_keys_test.rb b/activerecord/test/cases/primary_keys_test.rb
index ea36c199f4..5bfacd7ce3 100644
--- a/activerecord/test/cases/primary_keys_test.rb
+++ b/activerecord/test/cases/primary_keys_test.rb
@@ -1,12 +1,12 @@
 require "cases/helper"
-require 'support/schema_dumping_helper'
-require 'models/topic'
-require 'models/reply'
-require 'models/subscriber'
-require 'models/movie'
-require 'models/keyboard'
-require 'models/mixed_case_monkey'
-require 'models/dashboard'
+require "support/schema_dumping_helper"
+require "models/topic"
+require "models/reply"
+require "models/subscriber"
+require "models/movie"
+require "models/keyboard"
+require "models/mixed_case_monkey"
+require "models/dashboard"
 
 class PrimaryKeysTest < ActiveRecord::TestCase
   fixtures :topics, :subscribers, :movies, :mixed_case_monkeys
@@ -54,9 +54,9 @@ class PrimaryKeysTest < ActiveRecord::TestCase
 
   def test_customized_primary_key_auto_assigns_on_save
     Keyboard.delete_all
-    keyboard = Keyboard.new(:name => 'HHKB')
+    keyboard = Keyboard.new(:name => "HHKB")
     assert_nothing_raised { keyboard.save! }
-    assert_equal keyboard.id, Keyboard.find_by_name('HHKB').id
+    assert_equal keyboard.id, Keyboard.find_by_name("HHKB").id
   end
 
   def test_customized_primary_key_can_be_get_before_saving
@@ -67,9 +67,9 @@ class PrimaryKeysTest < ActiveRecord::TestCase
 
   def test_customized_string_primary_key_settable_before_save
     subscriber = Subscriber.new
-    assert_nothing_raised { subscriber.id = 'webster123' }
-    assert_equal 'webster123', subscriber.id
-    assert_equal 'webster123', subscriber.nick
+    assert_nothing_raised { subscriber.id = "webster123" }
+    assert_equal "webster123", subscriber.id
+    assert_equal "webster123", subscriber.nick
   end
 
   def test_string_key
@@ -138,15 +138,15 @@ class PrimaryKeysTest < ActiveRecord::TestCase
   if ActiveRecord::Base.connection.supports_primary_key?
     def test_primary_key_returns_value_if_it_exists
       klass = Class.new(ActiveRecord::Base) do
-        self.table_name = 'developers'
+        self.table_name = "developers"
       end
 
-      assert_equal 'id', klass.primary_key
+      assert_equal "id", klass.primary_key
     end
 
     def test_primary_key_returns_nil_if_it_does_not_exist
       klass = Class.new(ActiveRecord::Base) do
-        self.table_name = 'developers_projects'
+        self.table_name = "developers_projects"
       end
 
       assert_nil klass.primary_key
@@ -166,17 +166,17 @@ class PrimaryKeysTest < ActiveRecord::TestCase
   end
 
   def test_primary_key_update_with_custom_key_name
-    dashboard = Dashboard.create!(dashboard_id: '1')
-    dashboard.id = '2'
+    dashboard = Dashboard.create!(dashboard_id: "1")
+    dashboard.id = "2"
     dashboard.save!
 
     dashboard = Dashboard.first
-    assert_equal '2', dashboard.id
+    assert_equal "2", dashboard.id
   end
 
   def test_create_without_primary_key_no_extra_query
     klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'dashboards'
+      self.table_name = "dashboards"
     end
     klass.create! # warmup schema cache
     assert_queries(3, ignore_none: true) { klass.create! }
@@ -205,13 +205,13 @@ class PrimaryKeyWithNoConnectionTest < ActiveRecord::TestCase
       connection = ActiveRecord::Base.remove_connection
 
       model = Class.new(ActiveRecord::Base)
-      model.primary_key = 'foo'
+      model.primary_key = "foo"
 
-      assert_equal 'foo', model.primary_key
+      assert_equal "foo", model.primary_key
 
       ActiveRecord::Base.establish_connection(connection)
 
-      assert_equal 'foo', model.primary_key
+      assert_equal "foo", model.primary_key
     end
   end
 end
@@ -304,7 +304,7 @@ if current_adapter?(:Mysql2Adapter)
     end
 
     test "primary key with bigint allows default override via nil" do
-      column = @connection.columns(:bigint_defaults).find { |c| c.name == 'id' }
+      column = @connection.columns(:bigint_defaults).find { |c| c.name == "id" }
       assert column.bigint?
       assert_not column.auto_increment?
     end
@@ -362,7 +362,7 @@ if current_adapter?(:PostgreSQLAdapter, :Mysql2Adapter)
     if current_adapter?(:Mysql2Adapter)
       test "primary key column type with options" do
         @connection.create_table(:widgets, id: :primary_key, limit: 8, unsigned: true, force: true)
-        column = @connection.columns(:widgets).find { |c| c.name == 'id' }
+        column = @connection.columns(:widgets).find { |c| c.name == "id" }
         assert column.auto_increment?
         assert_equal :integer, column.type
         assert_equal 8, column.limit
diff --git a/activerecord/test/cases/query_cache_test.rb b/activerecord/test/cases/query_cache_test.rb
index 085636553e..d99e8a1dc6 100644
--- a/activerecord/test/cases/query_cache_test.rb
+++ b/activerecord/test/cases/query_cache_test.rb
@@ -1,9 +1,9 @@
 require "cases/helper"
-require 'models/topic'
-require 'models/task'
-require 'models/category'
-require 'models/post'
-require 'rack'
+require "models/topic"
+require "models/task"
+require "models/category"
+require "models/post"
+require "rack"
 
 class QueryCacheTest < ActiveRecord::TestCase
   self.use_transactional_tests = false
@@ -16,7 +16,7 @@ class QueryCacheTest < ActiveRecord::TestCase
   end
 
   def test_exceptional_middleware_clears_and_disables_cache_on_error
-    assert !ActiveRecord::Base.connection.query_cache_enabled, 'cache off'
+    assert !ActiveRecord::Base.connection.query_cache_enabled, "cache off"
 
     mw = middleware { |env|
       Task.find 1
@@ -27,7 +27,7 @@ class QueryCacheTest < ActiveRecord::TestCase
     assert_raises(RuntimeError) { mw.call({}) }
 
     assert_equal 0, ActiveRecord::Base.connection.query_cache.length
-    assert !ActiveRecord::Base.connection.query_cache_enabled, 'cache off'
+    assert !ActiveRecord::Base.connection.query_cache_enabled, "cache off"
   end
 
   def test_exceptional_middleware_leaves_enabled_cache_alone
@@ -38,7 +38,7 @@ class QueryCacheTest < ActiveRecord::TestCase
     }
     assert_raises(RuntimeError) { mw.call({}) }
 
-    assert ActiveRecord::Base.connection.query_cache_enabled, 'cache on'
+    assert ActiveRecord::Base.connection.query_cache_enabled, "cache on"
   end
 
   def test_middleware_delegates
@@ -48,7 +48,7 @@ class QueryCacheTest < ActiveRecord::TestCase
       [200, {}, nil]
     }
     mw.call({})
-    assert called, 'middleware should delegate'
+    assert called, "middleware should delegate"
   end
 
   def test_middleware_caches
@@ -62,10 +62,10 @@ class QueryCacheTest < ActiveRecord::TestCase
   end
 
   def test_cache_enabled_during_call
-    assert !ActiveRecord::Base.connection.query_cache_enabled, 'cache off'
+    assert !ActiveRecord::Base.connection.query_cache_enabled, "cache off"
 
     mw = middleware { |env|
-      assert ActiveRecord::Base.connection.query_cache_enabled, 'cache on'
+      assert ActiveRecord::Base.connection.query_cache_enabled, "cache on"
       [200, {}, nil]
     }
     mw.call({})
@@ -166,7 +166,7 @@ class QueryCacheTest < ActiveRecord::TestCase
 
   def test_cache_is_not_available_when_using_a_not_connected_connection
     spec_name = Task.connection_specification_name
-    conf = ActiveRecord::Base.configurations['arunit'].merge('name' => 'test2')
+    conf = ActiveRecord::Base.configurations["arunit"].merge("name" => "test2")
     ActiveRecord::Base.connection_handler.establish_connection(conf)
     Task.connection_specification_name = "test2"
     refute Task.connected?
@@ -185,30 +185,30 @@ class QueryCacheTest < ActiveRecord::TestCase
     post = Post.first
 
     Post.transaction do
-      post.update_attributes(title: 'rollback')
-      assert_equal 1, Post.where(title: 'rollback').to_a.count
+      post.update_attributes(title: "rollback")
+      assert_equal 1, Post.where(title: "rollback").to_a.count
       raise ActiveRecord::Rollback
     end
 
-    assert_equal 0, Post.where(title: 'rollback').to_a.count
+    assert_equal 0, Post.where(title: "rollback").to_a.count
 
     ActiveRecord::Base.connection.uncached do
-      assert_equal 0, Post.where(title: 'rollback').to_a.count
+      assert_equal 0, Post.where(title: "rollback").to_a.count
     end
 
     begin
       Post.transaction do
-        post.update_attributes(title: 'rollback')
-        assert_equal 1, Post.where(title: 'rollback').to_a.count
-        raise 'broken'
+        post.update_attributes(title: "rollback")
+        assert_equal 1, Post.where(title: "rollback").to_a.count
+        raise "broken"
       end
     rescue Exception
     end
 
-    assert_equal 0, Post.where(title: 'rollback').to_a.count
+    assert_equal 0, Post.where(title: "rollback").to_a.count
 
     ActiveRecord::Base.connection.uncached do
-      assert_equal 0, Post.where(title: 'rollback').to_a.count
+      assert_equal 0, Post.where(title: "rollback").to_a.count
     end
   end
 
diff --git a/activerecord/test/cases/quoting_test.rb b/activerecord/test/cases/quoting_test.rb
index 225e23bc83..1c276aa765 100644
--- a/activerecord/test/cases/quoting_test.rb
+++ b/activerecord/test/cases/quoting_test.rb
@@ -16,20 +16,20 @@ module ActiveRecord
       end
 
       def test_quote_column_name
-        assert_equal "foo", @quoter.quote_column_name('foo')
+        assert_equal "foo", @quoter.quote_column_name("foo")
       end
 
       def test_quote_table_name
-        assert_equal "foo", @quoter.quote_table_name('foo')
+        assert_equal "foo", @quoter.quote_table_name("foo")
       end
 
       def test_quote_table_name_calls_quote_column_name
         @quoter.extend(Module.new {
           def quote_column_name(string)
-            'lol'
+            "lol"
           end
         })
-        assert_equal 'lol', @quoter.quote_table_name('foo')
+        assert_equal "lol", @quoter.quote_table_name("foo")
       end
 
       def test_quote_string
@@ -86,7 +86,7 @@ module ActiveRecord
       end
 
       def test_quote_nil
-        assert_equal 'NULL', @quoter.quote(nil, nil)
+        assert_equal "NULL", @quoter.quote(nil, nil)
       end
 
       def test_quote_true
@@ -114,11 +114,11 @@ module ActiveRecord
 
       def test_quote_bigdecimal
         bigdec = BigDecimal.new((1 << 100).to_s)
-        assert_equal bigdec.to_s('F'), @quoter.quote(bigdec, nil)
+        assert_equal bigdec.to_s("F"), @quoter.quote(bigdec, nil)
       end
 
       def test_dates_and_times
-        @quoter.extend(Module.new { def quoted_date(value) 'lol' end })
+        @quoter.extend(Module.new { def quoted_date(value) "lol" end })
         assert_equal "'lol'", @quoter.quote(Date.today, nil)
         assert_equal "'lol'", @quoter.quote(Time.now, nil)
         assert_equal "'lol'", @quoter.quote(DateTime.now, nil)
diff --git a/activerecord/test/cases/readonly_test.rb b/activerecord/test/cases/readonly_test.rb
index 5f6eb41240..151bb31fbd 100644
--- a/activerecord/test/cases/readonly_test.rb
+++ b/activerecord/test/cases/readonly_test.rb
@@ -1,13 +1,13 @@
 require "cases/helper"
-require 'models/author'
-require 'models/post'
-require 'models/comment'
-require 'models/developer'
-require 'models/computer'
-require 'models/project'
-require 'models/reader'
-require 'models/person'
-require 'models/ship'
+require "models/author"
+require "models/post"
+require "models/comment"
+require "models/developer"
+require "models/computer"
+require "models/project"
+require "models/reader"
+require "models/person"
+require "models/ship"
 
 class ReadOnlyTest < ActiveRecord::TestCase
   fixtures :authors, :posts, :comments, :developers, :projects, :developers_projects, :people, :readers
@@ -20,9 +20,9 @@ class ReadOnlyTest < ActiveRecord::TestCase
     assert dev.readonly?
 
     assert_nothing_raised do
-      dev.name = 'Luscious forbidden fruit.'
+      dev.name = "Luscious forbidden fruit."
       assert !dev.save
-      dev.name = 'Forbidden.'
+      dev.name = "Forbidden."
     end
 
     e = assert_raise(ActiveRecord::ReadOnlyRecord) { dev.save  }
@@ -44,11 +44,11 @@ class ReadOnlyTest < ActiveRecord::TestCase
   end
 
   def test_find_with_joins_option_does_not_imply_readonly
-    Developer.joins('  ').each { |d| assert_not d.readonly? }
-    Developer.joins('  ').readonly(true).each { |d| assert d.readonly? }
+    Developer.joins("  ").each { |d| assert_not d.readonly? }
+    Developer.joins("  ").readonly(true).each { |d| assert d.readonly? }
 
-    Developer.joins(', projects').each { |d| assert_not d.readonly? }
-    Developer.joins(', projects').readonly(true).each { |d| assert d.readonly? }
+    Developer.joins(", projects").each { |d| assert_not d.readonly? }
+    Developer.joins(", projects").readonly(true).each { |d| assert d.readonly? }
   end
 
   def test_has_many_find_readonly
@@ -77,13 +77,13 @@ class ReadOnlyTest < ActiveRecord::TestCase
   end
 
   def test_readonly_scoping
-    Post.where('1=1').scoping do
+    Post.where("1=1").scoping do
       assert !Post.find(1).readonly?
       assert Post.readonly(true).find(1).readonly?
       assert !Post.readonly(false).find(1).readonly?
     end
 
-    Post.joins('   ').scoping do
+    Post.joins("   ").scoping do
       assert !Post.find(1).readonly?
       assert Post.readonly.find(1).readonly?
       assert !Post.readonly(false).find(1).readonly?
@@ -92,7 +92,7 @@ class ReadOnlyTest < ActiveRecord::TestCase
     # Oracle barfs on this because the join includes unqualified and
     # conflicting column names
     unless current_adapter?(:OracleAdapter)
-      Post.joins(', developers').scoping do
+      Post.joins(", developers").scoping do
         assert_not Post.find(1).readonly?
         assert Post.readonly.find(1).readonly?
         assert !Post.readonly(false).find(1).readonly?
diff --git a/activerecord/test/cases/reaper_test.rb b/activerecord/test/cases/reaper_test.rb
index cccfc6774e..249878b67d 100644
--- a/activerecord/test/cases/reaper_test.rb
+++ b/activerecord/test/cases/reaper_test.rb
@@ -60,7 +60,7 @@ module ActiveRecord
 
       def test_connection_pool_starts_reaper
         spec = ActiveRecord::Base.connection_pool.spec.dup
-        spec.config[:reaping_frequency] = '0.0001'
+        spec.config[:reaping_frequency] = "0.0001"
 
         pool = ConnectionPool.new spec
 
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index 710c86b151..3e58de4258 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -1,30 +1,30 @@
 require "cases/helper"
-require 'models/topic'
-require 'models/customer'
-require 'models/company'
-require 'models/company_in_module'
-require 'models/ship'
-require 'models/pirate'
-require 'models/price_estimate'
-require 'models/essay'
-require 'models/author'
-require 'models/organization'
-require 'models/post'
-require 'models/tagging'
-require 'models/category'
-require 'models/book'
-require 'models/subscriber'
-require 'models/subscription'
-require 'models/tag'
-require 'models/sponsor'
-require 'models/edge'
-require 'models/hotel'
-require 'models/chef'
-require 'models/department'
-require 'models/cake_designer'
-require 'models/drink_designer'
-require 'models/mocktail_designer'
-require 'models/recipe'
+require "models/topic"
+require "models/customer"
+require "models/company"
+require "models/company_in_module"
+require "models/ship"
+require "models/pirate"
+require "models/price_estimate"
+require "models/essay"
+require "models/author"
+require "models/organization"
+require "models/post"
+require "models/tagging"
+require "models/category"
+require "models/book"
+require "models/subscriber"
+require "models/subscription"
+require "models/tag"
+require "models/sponsor"
+require "models/edge"
+require "models/hotel"
+require "models/chef"
+require "models/department"
+require "models/cake_designer"
+require "models/drink_designer"
+require "models/mocktail_designer"
+require "models/recipe"
 
 class ReflectionTest < ActiveRecord::TestCase
   include ActiveRecord::Reflection
@@ -100,7 +100,7 @@ class ReflectionTest < ActiveRecord::TestCase
   end
 
   def test_reflection_klass_for_nested_class_name
-    reflection = ActiveRecord::Reflection.create(:has_many, nil, nil, { :class_name => 'MyApplication::Business::Company' }, ActiveRecord::Base)
+    reflection = ActiveRecord::Reflection.create(:has_many, nil, nil, { :class_name => "MyApplication::Business::Company" }, ActiveRecord::Base)
     assert_nothing_raised do
       assert_equal MyApplication::Business::Company, reflection.klass
     end
@@ -108,10 +108,10 @@ class ReflectionTest < ActiveRecord::TestCase
 
   def test_irregular_reflection_class_name
     ActiveSupport::Inflector.inflections do |inflect|
-      inflect.irregular 'plural_irregular', 'plurales_irregulares'
+      inflect.irregular "plural_irregular", "plurales_irregulares"
     end
-    reflection = ActiveRecord::Reflection.create(:has_many, 'plurales_irregulares', nil, {}, ActiveRecord::Base)
-    assert_equal 'PluralIrregular', reflection.class_name
+    reflection = ActiveRecord::Reflection.create(:has_many, "plurales_irregulares", nil, {}, ActiveRecord::Base)
+    assert_equal "PluralIrregular", reflection.class_name
   end
 
   def test_aggregation_reflection
@@ -153,10 +153,10 @@ class ReflectionTest < ActiveRecord::TestCase
     assert_equal reflection_for_clients, Firm.reflect_on_association(:clients)
 
     assert_equal Client, Firm.reflect_on_association(:clients).klass
-    assert_equal 'companies', Firm.reflect_on_association(:clients).table_name
+    assert_equal "companies", Firm.reflect_on_association(:clients).table_name
 
     assert_equal Client, Firm.reflect_on_association(:clients_of_firm).klass
-    assert_equal 'companies', Firm.reflect_on_association(:clients_of_firm).table_name
+    assert_equal "companies", Firm.reflect_on_association(:clients_of_firm).table_name
   end
 
   def test_has_one_reflection
@@ -164,7 +164,7 @@ class ReflectionTest < ActiveRecord::TestCase
     assert_equal reflection_for_account, Firm.reflect_on_association(:account)
 
     assert_equal Account, Firm.reflect_on_association(:account).klass
-    assert_equal 'accounts', Firm.reflect_on_association(:account).table_name
+    assert_equal "accounts", Firm.reflect_on_association(:account).table_name
   end
 
   def test_belongs_to_inferred_foreign_key_from_assoc_name
@@ -182,44 +182,44 @@ class ReflectionTest < ActiveRecord::TestCase
     assert_reflection MyApplication::Business::Firm,
       :clients_of_firm,
       :klass      => MyApplication::Business::Client,
-      :class_name => 'Client',
-      :table_name => 'companies'
+      :class_name => "Client",
+      :table_name => "companies"
 
     assert_reflection MyApplication::Billing::Account,
       :firm,
       :klass      => MyApplication::Business::Firm,
-      :class_name => 'MyApplication::Business::Firm',
-      :table_name => 'companies'
+      :class_name => "MyApplication::Business::Firm",
+      :table_name => "companies"
 
     assert_reflection MyApplication::Billing::Account,
       :qualified_billing_firm,
       :klass      => MyApplication::Billing::Firm,
-      :class_name => 'MyApplication::Billing::Firm',
-      :table_name => 'companies'
+      :class_name => "MyApplication::Billing::Firm",
+      :table_name => "companies"
 
     assert_reflection MyApplication::Billing::Account,
       :unqualified_billing_firm,
       :klass      => MyApplication::Billing::Firm,
-      :class_name => 'Firm',
-      :table_name => 'companies'
+      :class_name => "Firm",
+      :table_name => "companies"
 
     assert_reflection MyApplication::Billing::Account,
       :nested_qualified_billing_firm,
       :klass      => MyApplication::Billing::Nested::Firm,
-      :class_name => 'MyApplication::Billing::Nested::Firm',
-      :table_name => 'companies'
+      :class_name => "MyApplication::Billing::Nested::Firm",
+      :table_name => "companies"
 
     assert_reflection MyApplication::Billing::Account,
       :nested_unqualified_billing_firm,
       :klass      => MyApplication::Billing::Nested::Firm,
-      :class_name => 'Nested::Firm',
-      :table_name => 'companies'
+      :class_name => "Nested::Firm",
+      :table_name => "companies"
   ensure
     ActiveRecord::Base.store_full_sti_class = true
   end
 
   def test_reflection_should_not_raise_error_when_compared_to_other_object
-    assert_not_equal Object.new, Firm._reflections['clients']
+    assert_not_equal Object.new, Firm._reflections["clients"]
   end
 
   def test_reflections_should_return_keys_as_strings
@@ -227,7 +227,7 @@ class ReflectionTest < ActiveRecord::TestCase
   end
 
   def test_has_and_belongs_to_many_reflection
-    assert_equal :has_and_belongs_to_many, Category.reflections['posts'].macro
+    assert_equal :has_and_belongs_to_many, Category.reflections["posts"].macro
     assert_equal :posts, Category.reflect_on_all_associations(:has_and_belongs_to_many).first.name
   end
 
@@ -399,62 +399,62 @@ class ReflectionTest < ActiveRecord::TestCase
   end
 
   def test_join_table
-    category = Struct.new(:table_name, :pluralize_table_names).new('categories', true)
-    product = Struct.new(:table_name, :pluralize_table_names).new('products', true)
+    category = Struct.new(:table_name, :pluralize_table_names).new("categories", true)
+    product = Struct.new(:table_name, :pluralize_table_names).new("products", true)
 
     reflection = ActiveRecord::Reflection.create(:has_many, :categories, nil, {}, product)
     reflection.stub(:klass, category) do
-      assert_equal 'categories_products', reflection.join_table
+      assert_equal "categories_products", reflection.join_table
     end
 
     reflection = ActiveRecord::Reflection.create(:has_many, :products, nil, {}, category)
     reflection.stub(:klass, product) do
-      assert_equal 'categories_products', reflection.join_table
+      assert_equal "categories_products", reflection.join_table
     end
   end
 
   def test_join_table_with_common_prefix
-    category = Struct.new(:table_name, :pluralize_table_names).new('catalog_categories', true)
-    product = Struct.new(:table_name, :pluralize_table_names).new('catalog_products', true)
+    category = Struct.new(:table_name, :pluralize_table_names).new("catalog_categories", true)
+    product = Struct.new(:table_name, :pluralize_table_names).new("catalog_products", true)
 
     reflection = ActiveRecord::Reflection.create(:has_many, :categories, nil, {}, product)
     reflection.stub(:klass, category) do
-      assert_equal 'catalog_categories_products', reflection.join_table
+      assert_equal "catalog_categories_products", reflection.join_table
     end
 
     reflection = ActiveRecord::Reflection.create(:has_many, :products, nil, {}, category)
     reflection.stub(:klass, product) do
-      assert_equal 'catalog_categories_products', reflection.join_table
+      assert_equal "catalog_categories_products", reflection.join_table
     end
   end
 
   def test_join_table_with_different_prefix
-    category = Struct.new(:table_name, :pluralize_table_names).new('catalog_categories', true)
-    page = Struct.new(:table_name, :pluralize_table_names).new('content_pages', true)
+    category = Struct.new(:table_name, :pluralize_table_names).new("catalog_categories", true)
+    page = Struct.new(:table_name, :pluralize_table_names).new("content_pages", true)
 
     reflection = ActiveRecord::Reflection.create(:has_many, :categories, nil, {}, page)
     reflection.stub(:klass, category) do
-      assert_equal 'catalog_categories_content_pages', reflection.join_table
+      assert_equal "catalog_categories_content_pages", reflection.join_table
     end
 
     reflection = ActiveRecord::Reflection.create(:has_many, :pages, nil, {}, category)
     reflection.stub(:klass, page) do
-      assert_equal 'catalog_categories_content_pages', reflection.join_table
+      assert_equal "catalog_categories_content_pages", reflection.join_table
     end
   end
 
   def test_join_table_can_be_overridden
-    category = Struct.new(:table_name, :pluralize_table_names).new('categories', true)
-    product = Struct.new(:table_name, :pluralize_table_names).new('products', true)
+    category = Struct.new(:table_name, :pluralize_table_names).new("categories", true)
+    product = Struct.new(:table_name, :pluralize_table_names).new("products", true)
 
-    reflection = ActiveRecord::Reflection.create(:has_many, :categories, nil, { :join_table => 'product_categories' }, product)
+    reflection = ActiveRecord::Reflection.create(:has_many, :categories, nil, { :join_table => "product_categories" }, product)
     reflection.stub(:klass, category) do
-      assert_equal 'product_categories', reflection.join_table
+      assert_equal "product_categories", reflection.join_table
     end
 
-    reflection = ActiveRecord::Reflection.create(:has_many, :products, nil, { :join_table => 'product_categories' }, category)
+    reflection = ActiveRecord::Reflection.create(:has_many, :products, nil, { :join_table => "product_categories" }, category)
     reflection.stub(:klass, product) do
-      assert_equal 'product_categories', reflection.join_table
+      assert_equal "product_categories", reflection.join_table
     end
   end
 
@@ -474,7 +474,7 @@ class ReflectionTest < ActiveRecord::TestCase
     department.chefs.create!
 
     assert_nothing_raised do
-      assert_equal department.chefs, Hotel.includes(['departments' => 'chefs']).first.chefs
+      assert_equal department.chefs, Hotel.includes(["departments" => "chefs"]).first.chefs
     end
   end
 
diff --git a/activerecord/test/cases/relation/delegation_test.rb b/activerecord/test/cases/relation/delegation_test.rb
index f0e07e0731..fbae212e65 100644
--- a/activerecord/test/cases/relation/delegation_test.rb
+++ b/activerecord/test/cases/relation/delegation_test.rb
@@ -1,6 +1,6 @@
-require 'cases/helper'
-require 'models/post'
-require 'models/comment'
+require "cases/helper"
+require "models/post"
+require "models/comment"
 
 module ActiveRecord
   class DelegationTest < ActiveRecord::TestCase
diff --git a/activerecord/test/cases/relation/merging_test.rb b/activerecord/test/cases/relation/merging_test.rb
index 60a806c05a..b55084eee6 100644
--- a/activerecord/test/cases/relation/merging_test.rb
+++ b/activerecord/test/cases/relation/merging_test.rb
@@ -1,20 +1,20 @@
-require 'cases/helper'
-require 'models/author'
-require 'models/comment'
-require 'models/developer'
-require 'models/computer'
-require 'models/post'
-require 'models/project'
-require 'models/rating'
+require "cases/helper"
+require "models/author"
+require "models/comment"
+require "models/developer"
+require "models/computer"
+require "models/post"
+require "models/project"
+require "models/rating"
 
 class RelationMergingTest < ActiveRecord::TestCase
   fixtures :developers, :comments, :authors, :posts
 
   def test_relation_merging
-    devs = Developer.where("salary >= 80000").merge(Developer.limit(2)).merge(Developer.order('id ASC').where("id < 3"))
+    devs = Developer.where("salary >= 80000").merge(Developer.limit(2)).merge(Developer.order("id ASC").where("id < 3"))
     assert_equal [developers(:david), developers(:jamis)], devs.to_a
 
-    dev_with_count = Developer.limit(1).merge(Developer.order('id DESC')).merge(Developer.select('developers.*'))
+    dev_with_count = Developer.limit(1).merge(Developer.order("id DESC")).merge(Developer.select("developers.*"))
     assert_equal [developers(:poor_jamis)], dev_with_count.to_a
   end
 
@@ -34,10 +34,10 @@ class RelationMergingTest < ActiveRecord::TestCase
   def test_relation_merging_with_arel_equalities_keeps_last_equality_with_non_attribute_left_hand
     salary_attr = Developer.arel_table[:salary]
     devs = Developer.where(
-      Arel::Nodes::NamedFunction.new('abs', [salary_attr]).eq(80000)
+      Arel::Nodes::NamedFunction.new("abs", [salary_attr]).eq(80000)
     ).merge(
       Developer.where(
-        Arel::Nodes::NamedFunction.new('abs', [salary_attr]).eq(9000)
+        Arel::Nodes::NamedFunction.new("abs", [salary_attr]).eq(9000)
       )
     )
     assert_equal [developers(:poor_jamis)], devs.to_a
@@ -45,8 +45,8 @@ class RelationMergingTest < ActiveRecord::TestCase
 
   def test_relation_merging_with_eager_load
     relations = []
-    relations << Post.order('comments.id DESC').merge(Post.eager_load(:last_comment)).merge(Post.all)
-    relations << Post.eager_load(:last_comment).merge(Post.order('comments.id DESC')).merge(Post.all)
+    relations << Post.order("comments.id DESC").merge(Post.eager_load(:last_comment)).merge(Post.all)
+    relations << Post.eager_load(:last_comment).merge(Post.order("comments.id DESC")).merge(Post.all)
 
     relations.each do |posts|
       post = posts.find { |p| p.id == 1 }
@@ -66,14 +66,14 @@ class RelationMergingTest < ActiveRecord::TestCase
   end
 
   def test_relation_merging_with_joins
-    comments = Comment.joins(:post).where(:body => 'Thank you for the welcome').merge(Post.where(:body => 'Such a lovely day'))
+    comments = Comment.joins(:post).where(:body => "Thank you for the welcome").merge(Post.where(:body => "Such a lovely day"))
     assert_equal 1, comments.count
   end
 
   def test_relation_merging_with_association
     assert_queries(2) do  # one for loading post, and another one merged query
-      post = Post.where(:body => 'Such a lovely day').first
-      comments = Comment.where(:body => 'Thank you for the welcome').merge(post.comments)
+      post = Post.where(:body => "Such a lovely day").first
+      comments = Comment.where(:body => "Thank you for the welcome").merge(post.comments)
       assert_equal 1, comments.count
     end
   end
diff --git a/activerecord/test/cases/relation/mutation_test.rb b/activerecord/test/cases/relation/mutation_test.rb
index 36cb898010..14de5ae337 100644
--- a/activerecord/test/cases/relation/mutation_test.rb
+++ b/activerecord/test/cases/relation/mutation_test.rb
@@ -1,5 +1,5 @@
-require 'cases/helper'
-require 'models/post'
+require "cases/helper"
+require "models/post"
 
 module ActiveRecord
   class RelationMutationTest < ActiveSupport::TestCase
@@ -33,7 +33,7 @@ module ActiveRecord
     end
 
     def relation
-      @relation ||= Relation.new FakeKlass.new('posts'), Post.arel_table, Post.predicate_builder
+      @relation ||= Relation.new FakeKlass.new("posts"), Post.arel_table, Post.predicate_builder
     end
 
     (Relation::MULTI_VALUE_METHODS - [:references, :extending, :order, :unscope, :select, :left_joins]).each do |method|
@@ -48,12 +48,12 @@ module ActiveRecord
       assert_equal [:foo], relation.select_values
     end
 
-    test '#order!' do
-      assert relation.order!('name ASC').equal?(relation)
-      assert_equal ['name ASC'], relation.order_values
+    test "#order!" do
+      assert relation.order!("name ASC").equal?(relation)
+      assert_equal ["name ASC"], relation.order_values
     end
 
-    test '#order! with symbol prepends the table name' do
+    test "#order! with symbol prepends the table name" do
       assert relation.order!(:name).equal?(relation)
       node = relation.order_values.first
       assert node.ascending?
@@ -61,7 +61,7 @@ module ActiveRecord
       assert_equal "posts", node.expr.relation.name
     end
 
-    test '#order! on non-string does not attempt regexp match for references' do
+    test "#order! on non-string does not attempt regexp match for references" do
       obj = Object.new
       assert_not_called(obj, :=~) do
         assert relation.order!(obj)
@@ -69,12 +69,12 @@ module ActiveRecord
       end
     end
 
-    test '#references!' do
+    test "#references!" do
       assert relation.references!(:foo).equal?(relation)
-      assert relation.references_values.include?('foo')
+      assert relation.references_values.include?("foo")
     end
 
-    test 'extending!' do
+    test "extending!" do
       mod, mod2 = Module.new, Module.new
 
       assert relation.extending!(mod).equal?(relation)
@@ -85,7 +85,7 @@ module ActiveRecord
       assert_equal [mod, mod2], relation.extending_values
     end
 
-    test 'extending! with empty args' do
+    test "extending! with empty args" do
       relation.extending!
       assert_equal [], relation.extending_values
     end
@@ -97,25 +97,25 @@ module ActiveRecord
       end
     end
 
-    test '#from!' do
-      assert relation.from!('foo').equal?(relation)
-      assert_equal 'foo', relation.from_clause.value
+    test "#from!" do
+      assert relation.from!("foo").equal?(relation)
+      assert_equal "foo", relation.from_clause.value
     end
 
-    test '#lock!' do
-      assert relation.lock!('foo').equal?(relation)
-      assert_equal 'foo', relation.lock_value
+    test "#lock!" do
+      assert relation.lock!("foo").equal?(relation)
+      assert_equal "foo", relation.lock_value
     end
 
-    test '#reorder!' do
-      @relation = self.relation.order('foo')
+    test "#reorder!" do
+      @relation = self.relation.order("foo")
 
-      assert relation.reorder!('bar').equal?(relation)
-      assert_equal ['bar'], relation.order_values
+      assert relation.reorder!("bar").equal?(relation)
+      assert_equal ["bar"], relation.order_values
       assert relation.reordering_value
     end
 
-    test '#reorder! with symbol prepends the table name' do
+    test "#reorder! with symbol prepends the table name" do
       assert relation.reorder!(:name).equal?(relation)
       node = relation.order_values.first
 
@@ -124,42 +124,42 @@ module ActiveRecord
       assert_equal "posts", node.expr.relation.name
     end
 
-    test 'reverse_order!' do
-      @relation = Post.order('title ASC, comments_count DESC')
+    test "reverse_order!" do
+      @relation = Post.order("title ASC, comments_count DESC")
 
       relation.reverse_order!
 
-      assert_equal 'title DESC', relation.order_values.first
-      assert_equal 'comments_count ASC', relation.order_values.last
+      assert_equal "title DESC", relation.order_values.first
+      assert_equal "comments_count ASC", relation.order_values.last
 
 
       relation.reverse_order!
 
-      assert_equal 'title ASC', relation.order_values.first
-      assert_equal 'comments_count DESC', relation.order_values.last
+      assert_equal "title ASC", relation.order_values.first
+      assert_equal "comments_count DESC", relation.order_values.last
     end
 
-    test 'create_with!' do
-      assert relation.create_with!(foo: 'bar').equal?(relation)
-      assert_equal({foo: 'bar'}, relation.create_with_value)
+    test "create_with!" do
+      assert relation.create_with!(foo: "bar").equal?(relation)
+      assert_equal({foo: "bar"}, relation.create_with_value)
     end
 
-    test 'test_merge!' do
+    test "test_merge!" do
       assert relation.merge!(select: :foo).equal?(relation)
       assert_equal [:foo], relation.select_values
     end
 
-    test 'merge with a proc' do
+    test "merge with a proc" do
       assert_equal [:foo], relation.merge(-> { select(:foo) }).select_values
     end
 
-    test 'none!' do
+    test "none!" do
       assert relation.none!.equal?(relation)
       assert_equal [NullRelation], relation.extending_values
       assert relation.is_a?(NullRelation)
     end
 
-    test 'distinct!' do
+    test "distinct!" do
       relation.distinct! :foo
       assert_equal :foo, relation.distinct_value
 
@@ -168,7 +168,7 @@ module ActiveRecord
       end
     end
 
-    test 'uniq! was replaced by distinct!' do
+    test "uniq! was replaced by distinct!" do
       assert_deprecated(/use distinct! instead/) do
         relation.uniq! :foo
       end
diff --git a/activerecord/test/cases/relation/or_test.rb b/activerecord/test/cases/relation/or_test.rb
index ce8c5ca489..e746f1d55c 100644
--- a/activerecord/test/cases/relation/or_test.rb
+++ b/activerecord/test/cases/relation/or_test.rb
@@ -1,28 +1,28 @@
 require "cases/helper"
-require 'models/post'
+require "models/post"
 
 module ActiveRecord
   class OrTest < ActiveRecord::TestCase
     fixtures :posts
 
     def test_or_with_relation
-      expected = Post.where('id = 1 or id = 2').to_a
-      assert_equal expected, Post.where('id = 1').or(Post.where('id = 2')).to_a
+      expected = Post.where("id = 1 or id = 2").to_a
+      assert_equal expected, Post.where("id = 1").or(Post.where("id = 2")).to_a
     end
 
     def test_or_identity
-      expected = Post.where('id = 1').to_a
-      assert_equal expected, Post.where('id = 1').or(Post.where('id = 1')).to_a
+      expected = Post.where("id = 1").to_a
+      assert_equal expected, Post.where("id = 1").or(Post.where("id = 1")).to_a
     end
 
     def test_or_with_null_left
-      expected = Post.where('id = 1').to_a
-      assert_equal expected, Post.none.or(Post.where('id = 1')).to_a
+      expected = Post.where("id = 1").to_a
+      assert_equal expected, Post.none.or(Post.where("id = 1")).to_a
     end
 
     def test_or_with_null_right
-      expected = Post.where('id = 1').to_a
-      assert_equal expected, Post.where('id = 1').or(Post.none).to_a
+      expected = Post.where("id = 1").to_a
+      assert_equal expected, Post.where("id = 1").or(Post.none).to_a
     end
 
     def test_or_with_bind_params
@@ -36,56 +36,56 @@ module ActiveRecord
 
     def test_or_without_left_where
       expected = Post.all
-      assert_equal expected, Post.or(Post.where('id = 1')).to_a
+      assert_equal expected, Post.or(Post.where("id = 1")).to_a
     end
 
     def test_or_without_right_where
       expected = Post.all
-      assert_equal expected, Post.where('id = 1').or(Post.all).to_a
+      assert_equal expected, Post.where("id = 1").or(Post.all).to_a
     end
 
     def test_or_preserves_other_querying_methods
-      expected = Post.where('id = 1 or id = 2 or id = 3').order('body asc').to_a
-      partial = Post.order('body asc')
-      assert_equal expected, partial.where('id = 1').or(partial.where(:id => [2, 3])).to_a
-      assert_equal expected, Post.order('body asc').where('id = 1').or(Post.order('body asc').where(:id => [2, 3])).to_a
+      expected = Post.where("id = 1 or id = 2 or id = 3").order("body asc").to_a
+      partial = Post.order("body asc")
+      assert_equal expected, partial.where("id = 1").or(partial.where(:id => [2, 3])).to_a
+      assert_equal expected, Post.order("body asc").where("id = 1").or(Post.order("body asc").where(:id => [2, 3])).to_a
     end
 
     def test_or_with_incompatible_relations
       error = assert_raises ArgumentError do
-        Post.order('body asc').where('id = 1').or(Post.order('id desc').where(:id => [2, 3])).to_a
+        Post.order("body asc").where("id = 1").or(Post.order("id desc").where(:id => [2, 3])).to_a
       end
 
       assert_equal "Relation passed to #or must be structurally compatible. Incompatible values: [:order]", error.message
     end
 
     def test_or_when_grouping
-      groups = Post.where('id < 10').group('body').select('body, COUNT(*) AS c')
+      groups = Post.where("id < 10").group("body").select("body, COUNT(*) AS c")
       expected = groups.having("COUNT(*) > 1 OR body like 'Such%'").to_a.map {|o| [o.body, o.c] }
-      assert_equal expected, groups.having('COUNT(*) > 1').or(groups.having("body like 'Such%'")).to_a.map {|o| [o.body, o.c] }
+      assert_equal expected, groups.having("COUNT(*) > 1").or(groups.having("body like 'Such%'")).to_a.map {|o| [o.body, o.c] }
     end
 
     def test_or_with_named_scope
       expected = Post.where("id = 1 or body LIKE '\%a\%'").to_a
-      assert_equal expected, Post.where('id = 1').or(Post.containing_the_letter_a)
+      assert_equal expected, Post.where("id = 1").or(Post.containing_the_letter_a)
     end
 
     def test_or_inside_named_scope
-      expected = Post.where("body LIKE '\%a\%' OR title LIKE ?", "%'%").order('id DESC').to_a
+      expected = Post.where("body LIKE '\%a\%' OR title LIKE ?", "%'%").order("id DESC").to_a
       assert_equal expected, Post.order(id: :desc).typographically_interesting
     end
 
     def test_or_on_loaded_relation
-      expected = Post.where('id = 1 or id = 2').to_a
-      p = Post.where('id = 1')
+      expected = Post.where("id = 1 or id = 2").to_a
+      p = Post.where("id = 1")
       p.load
       assert_equal p.loaded?, true
-      assert_equal expected, p.or(Post.where('id = 2')).to_a
+      assert_equal expected, p.or(Post.where("id = 2")).to_a
     end
 
     def test_or_with_non_relation_object_raises_error
       assert_raises ArgumentError do
-        Post.where(id: [1, 2, 3]).or(title: 'Rails')
+        Post.where(id: [1, 2, 3]).or(title: "Rails")
       end
     end
   end
diff --git a/activerecord/test/cases/relation/predicate_builder_test.rb b/activerecord/test/cases/relation/predicate_builder_test.rb
index 8f62014622..48758dc148 100644
--- a/activerecord/test/cases/relation/predicate_builder_test.rb
+++ b/activerecord/test/cases/relation/predicate_builder_test.rb
@@ -1,11 +1,11 @@
 require "cases/helper"
-require 'models/topic'
+require "models/topic"
 
 module ActiveRecord
   class PredicateBuilderTest < ActiveRecord::TestCase
     def test_registering_new_handlers
       Topic.predicate_builder.register_handler(Regexp, proc do |column, value|
-        Arel::Nodes::InfixOperation.new('~', column, Arel.sql(value.source))
+        Arel::Nodes::InfixOperation.new("~", column, Arel.sql(value.source))
       end)
 
       assert_match %r{["`]topics["`]\.["`]title["`] ~ rails}i, Topic.where(title: /rails/).to_sql
diff --git a/activerecord/test/cases/relation/record_fetch_warning_test.rb b/activerecord/test/cases/relation/record_fetch_warning_test.rb
index 0e0e23b24b..62ca051431 100644
--- a/activerecord/test/cases/relation/record_fetch_warning_test.rb
+++ b/activerecord/test/cases/relation/record_fetch_warning_test.rb
@@ -1,6 +1,6 @@
-require 'cases/helper'
-require 'models/post'
-require 'active_record/relation/record_fetch_warning'
+require "cases/helper"
+require "models/post"
+require "active_record/relation/record_fetch_warning"
 
 module ActiveRecord
   class RecordFetchWarningTest < ActiveRecord::TestCase
diff --git a/activerecord/test/cases/relation/where_chain_test.rb b/activerecord/test/cases/relation/where_chain_test.rb
index 27bbd80f79..3d93cb7bce 100644
--- a/activerecord/test/cases/relation/where_chain_test.rb
+++ b/activerecord/test/cases/relation/where_chain_test.rb
@@ -1,6 +1,6 @@
-require 'cases/helper'
-require 'models/post'
-require 'models/comment'
+require "cases/helper"
+require "models/post"
+require "models/comment"
 
 module ActiveRecord
   class WhereChainTest < ActiveRecord::TestCase
@@ -8,12 +8,12 @@ module ActiveRecord
 
     def setup
       super
-      @name = 'title'
+      @name = "title"
     end
 
     def test_not_inverts_where_clause
-      relation = Post.where.not(title: 'hello')
-      expected_where_clause = Post.where(title: 'hello').where_clause.invert
+      relation = Post.where.not(title: "hello")
+      expected_where_clause = Post.where(title: "hello").where_clause.invert
 
       assert_equal expected_where_clause, relation.where_clause
     end
@@ -26,54 +26,54 @@ module ActiveRecord
 
     def test_association_not_eq
       expected = Arel::Nodes::Grouping.new(Comment.arel_table[@name].not_eq(Arel::Nodes::BindParam.new))
-      relation = Post.joins(:comments).where.not(comments: {title: 'hello'})
+      relation = Post.joins(:comments).where.not(comments: {title: "hello"})
       assert_equal(expected.to_sql, relation.where_clause.ast.to_sql)
     end
 
     def test_not_eq_with_preceding_where
-      relation = Post.where(title: 'hello').where.not(title: 'world')
+      relation = Post.where(title: "hello").where.not(title: "world")
       expected_where_clause =
-        Post.where(title: 'hello').where_clause +
-        Post.where(title: 'world').where_clause.invert
+        Post.where(title: "hello").where_clause +
+        Post.where(title: "world").where_clause.invert
 
       assert_equal expected_where_clause, relation.where_clause
     end
 
     def test_not_eq_with_succeeding_where
-      relation = Post.where.not(title: 'hello').where(title: 'world')
+      relation = Post.where.not(title: "hello").where(title: "world")
       expected_where_clause =
-        Post.where(title: 'hello').where_clause.invert +
-        Post.where(title: 'world').where_clause
+        Post.where(title: "hello").where_clause.invert +
+        Post.where(title: "world").where_clause
 
       assert_equal expected_where_clause, relation.where_clause
     end
 
     def test_chaining_multiple
-      relation = Post.where.not(author_id: [1, 2]).where.not(title: 'ruby on rails')
+      relation = Post.where.not(author_id: [1, 2]).where.not(title: "ruby on rails")
       expected_where_clause =
         Post.where(author_id: [1, 2]).where_clause.invert +
-        Post.where(title: 'ruby on rails').where_clause.invert
+        Post.where(title: "ruby on rails").where_clause.invert
 
       assert_equal expected_where_clause, relation.where_clause
     end
 
     def test_rewhere_with_one_condition
-      relation = Post.where(title: 'hello').where(title: 'world').rewhere(title: 'alone')
-      expected = Post.where(title: 'alone')
+      relation = Post.where(title: "hello").where(title: "world").rewhere(title: "alone")
+      expected = Post.where(title: "alone")
 
       assert_equal expected.where_clause, relation.where_clause
     end
 
     def test_rewhere_with_multiple_overwriting_conditions
-      relation = Post.where(title: 'hello').where(body: 'world').rewhere(title: 'alone', body: 'again')
-      expected = Post.where(title: 'alone', body: 'again')
+      relation = Post.where(title: "hello").where(body: "world").rewhere(title: "alone", body: "again")
+      expected = Post.where(title: "alone", body: "again")
 
       assert_equal expected.where_clause, relation.where_clause
     end
 
     def test_rewhere_with_one_overwriting_condition_and_one_unrelated
-      relation = Post.where(title: 'hello').where(body: 'world').rewhere(title: 'alone')
-      expected = Post.where(body: 'world', title: 'alone')
+      relation = Post.where(title: "hello").where(body: "world").rewhere(title: "alone")
+      expected = Post.where(body: "world", title: "alone")
 
       assert_equal expected.where_clause, relation.where_clause
     end
diff --git a/activerecord/test/cases/relation/where_clause_test.rb b/activerecord/test/cases/relation/where_clause_test.rb
index c20ed94d90..2e2bb9fe36 100644
--- a/activerecord/test/cases/relation/where_clause_test.rb
+++ b/activerecord/test/cases/relation/where_clause_test.rb
@@ -140,7 +140,7 @@ class ActiveRecord::Relation
 
     test "ast removes any empty strings" do
       where_clause = WhereClause.new([table["id"].in([1, 2, 3])], [])
-      where_clause_with_empty = WhereClause.new([table["id"].in([1, 2, 3]), ''], [])
+      where_clause_with_empty = WhereClause.new([table["id"].in([1, 2, 3]), ""], [])
 
       assert_equal where_clause.ast, where_clause_with_empty.ast
     end
diff --git a/activerecord/test/cases/relation/where_test.rb b/activerecord/test/cases/relation/where_test.rb
index 56a2b5b8c6..c7d6018872 100644
--- a/activerecord/test/cases/relation/where_test.rb
+++ b/activerecord/test/cases/relation/where_test.rb
@@ -19,7 +19,7 @@ module ActiveRecord
 
     def test_where_copies_bind_params
       author = authors(:david)
-      posts  = author.posts.where('posts.id != 1')
+      posts  = author.posts.where("posts.id != 1")
       joined = Post.where(id: posts)
 
       assert_operator joined.length, :>, 0
@@ -49,7 +49,7 @@ module ActiveRecord
     end
 
     def test_rewhere_on_root
-      assert_equal posts(:welcome), Post.rewhere(title: 'Welcome to the weblog').first
+      assert_equal posts(:welcome), Post.rewhere(title: "Welcome to the weblog").first
     end
 
     def test_belongs_to_shallow_where
@@ -97,7 +97,7 @@ module ActiveRecord
       treasure = Treasure.new
       treasure.id = 1
 
-      expected = PriceEstimate.where(estimate_of_type: 'Treasure', estimate_of_id: 1)
+      expected = PriceEstimate.where(estimate_of_type: "Treasure", estimate_of_id: 1)
       actual   = PriceEstimate.where(estimate_of: treasure)
 
       assert_equal expected.to_sql, actual.to_sql
@@ -109,7 +109,7 @@ module ActiveRecord
       hidden = HiddenTreasure.new
       hidden.id = 2
 
-      expected = PriceEstimate.where(estimate_of_type: 'Treasure', estimate_of_id: [treasure, hidden])
+      expected = PriceEstimate.where(estimate_of_type: "Treasure", estimate_of_id: [treasure, hidden])
       actual   = PriceEstimate.where(estimate_of: [treasure, hidden])
 
       assert_equal expected.to_sql, actual.to_sql
@@ -127,7 +127,7 @@ module ActiveRecord
     end
 
     def test_polymorphic_nested_relation_where
-      expected = PriceEstimate.where(estimate_of_type: 'Treasure', estimate_of_id: Treasure.where(id: [1,2]))
+      expected = PriceEstimate.where(estimate_of_type: "Treasure", estimate_of_id: Treasure.where(id: [1,2]))
       actual   = PriceEstimate.where(estimate_of: Treasure.where(id: [1,2]))
 
       assert_equal expected.to_sql, actual.to_sql
@@ -137,7 +137,7 @@ module ActiveRecord
       treasure = HiddenTreasure.new
       treasure.id = 1
 
-      expected = PriceEstimate.where(estimate_of_type: 'Treasure', estimate_of_id: 1)
+      expected = PriceEstimate.where(estimate_of_type: "Treasure", estimate_of_id: 1)
       actual   = PriceEstimate.where(estimate_of: treasure)
 
       assert_equal expected.to_sql, actual.to_sql
@@ -147,7 +147,7 @@ module ActiveRecord
       thing = Post.new
       thing.id = 1
 
-      expected = Treasure.where(price_estimates: { thing_type: 'Post', thing_id: 1 }).joins(:price_estimates)
+      expected = Treasure.where(price_estimates: { thing_type: "Post", thing_id: 1 }).joins(:price_estimates)
       actual   = Treasure.where(price_estimates: { thing: thing }).joins(:price_estimates)
 
       assert_equal expected.to_sql, actual.to_sql
@@ -157,7 +157,7 @@ module ActiveRecord
       treasure = HiddenTreasure.new
       treasure.id = 1
 
-      expected = Treasure.where(price_estimates: { estimate_of_type: 'Treasure', estimate_of_id: 1 }).joins(:price_estimates)
+      expected = Treasure.where(price_estimates: { estimate_of_type: "Treasure", estimate_of_id: 1 }).joins(:price_estimates)
       actual   = Treasure.where(price_estimates: { estimate_of: treasure }).joins(:price_estimates)
 
       assert_equal expected.to_sql, actual.to_sql
@@ -182,28 +182,28 @@ module ActiveRecord
       treasure.id = 1
       decorated_treasure = treasure_decorator.new(treasure)
 
-      expected = PriceEstimate.where(estimate_of_type: 'Treasure', estimate_of_id: 1)
+      expected = PriceEstimate.where(estimate_of_type: "Treasure", estimate_of_id: 1)
       actual   = PriceEstimate.where(estimate_of: decorated_treasure)
 
       assert_equal expected.to_sql, actual.to_sql
     end
 
     def test_aliased_attribute
-      expected = Topic.where(heading: 'The First Topic')
-      actual   = Topic.where(title: 'The First Topic')
+      expected = Topic.where(heading: "The First Topic")
+      actual   = Topic.where(title: "The First Topic")
 
       assert_equal expected.to_sql, actual.to_sql
     end
 
     def test_where_error
       assert_raises(ActiveRecord::StatementInvalid) do
-        Post.where(:id => { 'posts.author_id' => 10 }).first
+        Post.where(:id => { "posts.author_id" => 10 }).first
       end
     end
 
     def test_where_with_table_name
       post = Post.first
-      assert_equal post, Post.where(:posts => { 'id' => post.id }).first
+      assert_equal post, Post.where(:posts => { "id" => post.id }).first
     end
 
     def test_where_with_table_name_and_empty_hash
diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index 03583344a8..4776261bd2 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -1,8 +1,8 @@
 require "cases/helper"
-require 'models/post'
-require 'models/comment'
-require 'models/author'
-require 'models/rating'
+require "models/post"
+require "models/comment"
+require "models/author"
+require "models/rating"
 
 module ActiveRecord
   class RelationTest < ActiveRecord::TestCase
@@ -18,7 +18,7 @@ module ActiveRecord
       end
 
       def self.table_name
-        'fake_table'
+        "fake_table"
       end
 
       def self.sanitize_sql_for_order(sql)
@@ -30,7 +30,7 @@ module ActiveRecord
       relation = Relation.new(FakeKlass, :b, nil)
       assert_equal FakeKlass, relation.klass
       assert_equal :b, relation.table
-      assert !relation.loaded, 'relation is not loaded'
+      assert !relation.loaded, "relation is not loaded"
     end
 
     def test_responds_to_model_and_returns_klass
@@ -89,8 +89,8 @@ module ActiveRecord
     end
 
     def test_table_name_delegates_to_klass
-      relation = Relation.new(FakeKlass.new('posts'), :b, Post.predicate_builder)
-      assert_equal 'posts', relation.table_name
+      relation = Relation.new(FakeKlass.new("posts"), :b, Post.predicate_builder)
+      assert_equal "posts", relation.table_name
     end
 
     def test_scope_for_create
@@ -100,7 +100,7 @@ module ActiveRecord
 
     def test_create_with_value
       relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
-      hash = { :hello => 'world' }
+      hash = { :hello => "world" }
       relation.create_with_value = hash
       assert_equal hash, relation.scope_for_create
     end
@@ -108,8 +108,8 @@ module ActiveRecord
     def test_create_with_value_with_wheres
       relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
       relation.where! relation.table[:id].eq(10)
-      relation.create_with_value = {:hello => 'world'}
-      assert_equal({:hello => 'world', :id => 10}, relation.scope_for_create)
+      relation.create_with_value = {:hello => "world"}
+      assert_equal({:hello => "world", :id => 10}, relation.scope_for_create)
     end
 
     # FIXME: is this really wanted or expected behavior?
@@ -120,7 +120,7 @@ module ActiveRecord
       relation.where! relation.table[:id].eq(10)
       assert_equal({}, relation.scope_for_create)
 
-      relation.create_with_value = {:hello => 'world'}
+      relation.create_with_value = {:hello => "world"}
       assert_equal({}, relation.scope_for_create)
     end
 
@@ -145,16 +145,16 @@ module ActiveRecord
       relation = Relation.new(FakeKlass, :b, nil)
       assert_equal [], relation.references_values
       relation = relation.references(:foo).references(:omg, :lol)
-      assert_equal ['foo', 'omg', 'lol'], relation.references_values
+      assert_equal ["foo", "omg", "lol"], relation.references_values
     end
 
     def test_references_values_dont_duplicate
       relation = Relation.new(FakeKlass, :b, nil)
       relation = relation.references(:foo).references(:foo)
-      assert_equal ['foo'], relation.references_values
+      assert_equal ["foo"], relation.references_values
     end
 
-    test 'merging a hash into a relation' do
+    test "merging a hash into a relation" do
       relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
       relation = relation.merge where: {name: :lol}, readonly: true
 
@@ -162,31 +162,31 @@ module ActiveRecord
       assert_equal true, relation.readonly_value
     end
 
-    test 'merging an empty hash into a relation' do
+    test "merging an empty hash into a relation" do
       assert_equal Relation::WhereClause.empty, Relation.new(FakeKlass, :b, nil).merge({}).where_clause
     end
 
-    test 'merging a hash with unknown keys raises' do
-      assert_raises(ArgumentError) { Relation::HashMerger.new(nil, omg: 'lol') }
+    test "merging a hash with unknown keys raises" do
+      assert_raises(ArgumentError) { Relation::HashMerger.new(nil, omg: "lol") }
     end
 
-    test 'merging nil or false raises' do
+    test "merging nil or false raises" do
       relation = Relation.new(FakeKlass, :b, nil)
 
       e = assert_raises(ArgumentError) do
         relation = relation.merge nil
       end
 
-      assert_equal 'invalid argument: nil.', e.message
+      assert_equal "invalid argument: nil.", e.message
 
       e = assert_raises(ArgumentError) do
         relation = relation.merge false
       end
 
-      assert_equal 'invalid argument: false.', e.message
+      assert_equal "invalid argument: false.", e.message
     end
 
-    test '#values returns a dup of the values' do
+    test "#values returns a dup of the values" do
       relation = Relation.new(Post, Post.arel_table, Post.predicate_builder).where!(name: :foo)
       values   = relation.values
 
@@ -194,22 +194,22 @@ module ActiveRecord
       assert_not_nil relation.where_clause
     end
 
-    test 'relations can be created with a values hash' do
+    test "relations can be created with a values hash" do
       relation = Relation.new(FakeKlass, :b, nil, select: [:foo])
       assert_equal [:foo], relation.select_values
     end
 
-    test 'merging a hash interpolates conditions' do
+    test "merging a hash interpolates conditions" do
       klass = Class.new(FakeKlass) do
         def self.sanitize_sql(args)
-          raise unless args == ['foo = ?', 'bar']
-          'foo = bar'
+          raise unless args == ["foo = ?", "bar"]
+          "foo = bar"
         end
       end
 
       relation = Relation.new(klass, :b, nil)
-      relation.merge!(where: ['foo = ?', 'bar'])
-      assert_equal Relation::WhereClause.new(['foo = bar'], []), relation.where_clause
+      relation.merge!(where: ["foo = ?", "bar"])
+      assert_equal Relation::WhereClause.new(["foo = bar"], []), relation.where_clause
     end
 
     def test_merging_readonly_false
@@ -293,7 +293,7 @@ module ActiveRecord
     end
 
     class UpdateAllTestModel < ActiveRecord::Base
-      self.table_name = 'posts'
+      self.table_name = "posts"
 
       attribute :body, EnsureRoundTripTypeCasting.new
     end
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 5604124bb3..9ace34835c 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -1,21 +1,21 @@
 require "cases/helper"
-require 'models/tag'
-require 'models/tagging'
-require 'models/post'
-require 'models/topic'
-require 'models/comment'
-require 'models/author'
-require 'models/entrant'
-require 'models/developer'
-require 'models/computer'
-require 'models/reply'
-require 'models/company'
-require 'models/bird'
-require 'models/car'
-require 'models/engine'
-require 'models/tyre'
-require 'models/minivan'
-require 'models/aircraft'
+require "models/tag"
+require "models/tagging"
+require "models/post"
+require "models/topic"
+require "models/comment"
+require "models/author"
+require "models/entrant"
+require "models/developer"
+require "models/computer"
+require "models/reply"
+require "models/company"
+require "models/bird"
+require "models/car"
+require "models/engine"
+require "models/tyre"
+require "models/minivan"
+require "models/aircraft"
 require "models/possession"
 require "models/reader"
 require "models/categorization"
@@ -27,7 +27,7 @@ class RelationTest < ActiveRecord::TestCase
 
   class TopicWithCallbacks < ActiveRecord::Base
     self.table_name = :topics
-    before_update { |topic| topic.author_name = 'David' if topic.author_name.blank? }
+    before_update { |topic| topic.author_name = "David" if topic.author_name.blank? }
   end
 
   def test_do_not_double_quote_string_id
@@ -54,12 +54,12 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_dynamic_finder
-    x = Post.where('author_id = ?', 1)
-    assert x.klass.respond_to?(:find_by_id), '@klass should handle dynamic finders'
+    x = Post.where("author_id = ?", 1)
+    assert x.klass.respond_to?(:find_by_id), "@klass should handle dynamic finders"
   end
 
   def test_multivalue_where
-    posts = Post.where('author_id = ? AND id = ?', 1, 1)
+    posts = Post.where("author_id = ? AND id = ?", 1, 1)
     assert_equal 1, posts.to_a.size
   end
 
@@ -101,7 +101,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_scoped_first
-    topics = Topic.all.order('id ASC')
+    topics = Topic.all.order("id ASC")
 
     assert_queries(1) do
       2.times { assert_equal "The First Topic", topics.first.title }
@@ -111,7 +111,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_loaded_first
-    topics = Topic.all.order('id ASC')
+    topics = Topic.all.order("id ASC")
     topics.to_a # force load
 
     assert_no_queries do
@@ -122,7 +122,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_loaded_first_with_limit
-    topics = Topic.all.order('id ASC')
+    topics = Topic.all.order("id ASC")
     topics.to_a # force load
 
     assert_no_queries do
@@ -134,7 +134,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_first_get_more_than_available
-    topics = Topic.all.order('id ASC')
+    topics = Topic.all.order("id ASC")
     unloaded_first = topics.first(10)
     topics.to_a # force load
 
@@ -154,7 +154,7 @@ class RelationTest < ActiveRecord::TestCase
     assert topics.loaded?
 
     original_size = topics.to_a.size
-    Topic.create! :title => 'fake'
+    Topic.create! :title => "fake"
 
     assert_queries(1) { topics.reload }
     assert_equal original_size + 1, topics.size
@@ -163,16 +163,16 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_finding_with_subquery
     relation = Topic.where(:approved => true)
-    assert_equal relation.to_a, Topic.select('*').from(relation).to_a
-    assert_equal relation.to_a, Topic.select('subquery.*').from(relation).to_a
-    assert_equal relation.to_a, Topic.select('a.*').from(relation, :a).to_a
+    assert_equal relation.to_a, Topic.select("*").from(relation).to_a
+    assert_equal relation.to_a, Topic.select("subquery.*").from(relation).to_a
+    assert_equal relation.to_a, Topic.select("a.*").from(relation, :a).to_a
   end
 
   def test_finding_with_subquery_with_binds
     relation = Post.first.comments
-    assert_equal relation.to_a, Comment.select('*').from(relation).to_a
-    assert_equal relation.to_a, Comment.select('subquery.*').from(relation).to_a
-    assert_equal relation.to_a, Comment.select('a.*').from(relation, :a).to_a
+    assert_equal relation.to_a, Comment.select("*").from(relation).to_a
+    assert_equal relation.to_a, Comment.select("subquery.*").from(relation).to_a
+    assert_equal relation.to_a, Comment.select("a.*").from(relation, :a).to_a
   end
 
   def test_finding_with_subquery_without_select_does_not_change_the_select
@@ -183,25 +183,25 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_select_with_subquery_in_from_does_not_use_original_table_name
-    relation = Comment.group(:type).select('COUNT(post_id) AS post_count, type')
-    subquery = Comment.from(relation).select('type','post_count')
+    relation = Comment.group(:type).select("COUNT(post_id) AS post_count, type")
+    subquery = Comment.from(relation).select("type","post_count")
     assert_equal(relation.map(&:post_count).sort,subquery.map(&:post_count).sort)
   end
 
   def test_group_with_subquery_in_from_does_not_use_original_table_name
-    relation = Comment.group(:type).select('COUNT(post_id) AS post_count,type')
-    subquery = Comment.from(relation).group('type').average("post_count")
+    relation = Comment.group(:type).select("COUNT(post_id) AS post_count,type")
+    subquery = Comment.from(relation).group("type").average("post_count")
     assert_equal(relation.map(&:post_count).sort,subquery.values.sort)
   end
 
   def test_finding_with_conditions
-    assert_equal ["David"], Author.where(:name => 'David').map(&:name)
-    assert_equal ['Mary'],  Author.where(["name = ?", 'Mary']).map(&:name)
-    assert_equal ['Mary'],  Author.where("name = ?", 'Mary').map(&:name)
+    assert_equal ["David"], Author.where(:name => "David").map(&:name)
+    assert_equal ["Mary"],  Author.where(["name = ?", "Mary"]).map(&:name)
+    assert_equal ["Mary"],  Author.where("name = ?", "Mary").map(&:name)
   end
 
   def test_finding_with_order
-    topics = Topic.order('id')
+    topics = Topic.order("id")
     assert_equal 5, topics.to_a.size
     assert_equal topics(:first).title, topics.first.title
   end
@@ -268,7 +268,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_finding_with_asc_order_with_string
-    topics = Topic.order(id: 'asc')
+    topics = Topic.order(id: "asc")
     assert_equal 5, topics.to_a.size
     assert_equal [topics(:first), topics(:second), topics(:third), topics(:fourth), topics(:fifth)], topics.to_a
   end
@@ -296,7 +296,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_finding_with_order_concatenated
-    topics = Topic.order('author_name').order('title')
+    topics = Topic.order("author_name").order("title")
     assert_equal 5, topics.to_a.size
     assert_equal topics(:fourth).title, topics.first.title
   end
@@ -314,19 +314,19 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_finding_with_reorder
-    topics = Topic.order('author_name').order('title').reorder('id').to_a
+    topics = Topic.order("author_name").order("title").reorder("id").to_a
     topics_titles = topics.map(&:title)
-    assert_equal ['The First Topic', 'The Second Topic of the day', 'The Third Topic of the day', 'The Fourth Topic of the day', 'The Fifth Topic of the day'], topics_titles
+    assert_equal ["The First Topic", "The Second Topic of the day", "The Third Topic of the day", "The Fourth Topic of the day", "The Fifth Topic of the day"], topics_titles
   end
 
   def test_finding_with_reorder_by_aliased_attributes
-    topics = Topic.order('author_name').reorder(:heading)
+    topics = Topic.order("author_name").reorder(:heading)
     assert_equal 5, topics.to_a.size
     assert_equal topics(:fifth).title, topics.first.title
   end
 
   def test_finding_with_assoc_reorder_by_aliased_attributes
-    topics = Topic.order('author_name').reorder(heading: :desc)
+    topics = Topic.order("author_name").reorder(heading: :desc)
     assert_equal 5, topics.to_a.size
     assert_equal topics(:third).title, topics.first.title
   end
@@ -397,7 +397,7 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_none_chainable
     assert_no_queries(ignore_none: false) do
-      assert_equal [], Developer.none.where(:name => 'David')
+      assert_equal [], Developer.none.where(:name => "David")
     end
   end
 
@@ -411,7 +411,7 @@ class RelationTest < ActiveRecord::TestCase
     assert_no_queries(ignore_none: false) do
       assert_equal [],    Developer.none.pluck(:id, :name)
       assert_equal 0,     Developer.none.delete_all
-      assert_equal 0,     Developer.none.update_all(:name => 'David')
+      assert_equal 0,     Developer.none.update_all(:name => "David")
       assert_equal 0,     Developer.none.delete(1)
       assert_equal false, Developer.none.exists?(1)
     end
@@ -433,7 +433,7 @@ class RelationTest < ActiveRecord::TestCase
     assert_no_queries(ignore_none: false) do
       assert_equal 0, Developer.none.count
       assert_equal 0, Developer.none.calculate(:count, nil)
-      assert_equal nil, Developer.none.calculate(:average, 'salary')
+      assert_equal nil, Developer.none.calculate(:average, "salary")
     end
   end
 
@@ -443,7 +443,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_null_relation_where_values_hash
-    assert_equal({ 'salary' => 100_000 }, Developer.none.where(salary: 100_000).where_values_hash)
+    assert_equal({ "salary" => 100_000 }, Developer.none.where(salary: 100_000).where_values_hash)
   end
 
   def test_null_relation_sum
@@ -510,19 +510,19 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_finding_with_hash_conditions_on_joined_table
-    firms = DependentFirm.joins(:account).where({:name => 'RailsCore', :accounts => { :credit_limit => 55..60 }}).to_a
+    firms = DependentFirm.joins(:account).where({:name => "RailsCore", :accounts => { :credit_limit => 55..60 }}).to_a
     assert_equal 1, firms.size
     assert_equal companies(:rails_core), firms.first
   end
 
   def test_find_all_with_join
-    developers_on_project_one = Developer.joins('LEFT JOIN developers_projects ON developers.id = developers_projects.developer_id').
-      where('project_id=1').to_a
+    developers_on_project_one = Developer.joins("LEFT JOIN developers_projects ON developers.id = developers_projects.developer_id").
+      where("project_id=1").to_a
 
     assert_equal 3, developers_on_project_one.length
     developer_names = developers_on_project_one.map(&:name)
-    assert developer_names.include?('David')
-    assert developer_names.include?('Jamis')
+    assert developer_names.include?("David")
+    assert developer_names.include?("Jamis")
   end
 
   def test_find_on_hash_conditions
@@ -600,7 +600,7 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_eager_association_loading_of_stis_with_multiple_references
     authors = Author.eager_load(:posts => { :special_comments => { :post => [ :special_comments, :very_special_comment ] } }).
-      order('comments.body, very_special_comments_posts.body').where('posts.id = 4').to_a
+      order("comments.body, very_special_comments_posts.body").where("posts.id = 4").to_a
 
     assert_equal [authors(:david)], authors
     assert_no_queries do
@@ -611,27 +611,27 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_find_with_preloaded_associations
     assert_queries(2) do
-      posts = Post.preload(:comments).order('posts.id')
+      posts = Post.preload(:comments).order("posts.id")
       assert posts.first.comments.first
     end
 
     assert_queries(2) do
-      posts = Post.preload(:comments).order('posts.id')
+      posts = Post.preload(:comments).order("posts.id")
       assert posts.first.comments.first
     end
 
     assert_queries(2) do
-      posts = Post.preload(:author).order('posts.id')
+      posts = Post.preload(:author).order("posts.id")
       assert posts.first.author
     end
 
     assert_queries(2) do
-      posts = Post.preload(:author).order('posts.id')
+      posts = Post.preload(:author).order("posts.id")
       assert posts.first.author
     end
 
     assert_queries(3) do
-      posts = Post.preload(:author, :comments).order('posts.id')
+      posts = Post.preload(:author, :comments).order("posts.id")
       assert posts.first.author
       assert posts.first.comments.first
     end
@@ -646,58 +646,58 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_find_with_included_associations
     assert_queries(2) do
-      posts = Post.includes(:comments).order('posts.id')
+      posts = Post.includes(:comments).order("posts.id")
       assert posts.first.comments.first
     end
 
     assert_queries(2) do
-      posts = Post.all.includes(:comments).order('posts.id')
+      posts = Post.all.includes(:comments).order("posts.id")
       assert posts.first.comments.first
     end
 
     assert_queries(2) do
-      posts = Post.includes(:author).order('posts.id')
+      posts = Post.includes(:author).order("posts.id")
       assert posts.first.author
     end
 
     assert_queries(3) do
-      posts = Post.includes(:author, :comments).order('posts.id')
+      posts = Post.includes(:author, :comments).order("posts.id")
       assert posts.first.author
       assert posts.first.comments.first
     end
   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_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
 
   def test_default_scoping_finder_methods
-    developers = DeveloperCalledDavid.order('id').map(&:id).sort
-    assert_equal Developer.where(name: 'David').map(&:id).sort, developers
+    developers = DeveloperCalledDavid.order("id").map(&:id).sort
+    assert_equal Developer.where(name: "David").map(&:id).sort, developers
   end
 
   def test_includes_with_select
-    query = Post.select('comments_count AS ranking').order('ranking').includes(:comments)
+    query = Post.select("comments_count AS ranking").order("ranking").includes(:comments)
       .where(comments: { id: 1 })
 
-    assert_equal ['comments_count AS ranking'], query.select_values
+    assert_equal ["comments_count AS ranking"], query.select_values
     assert_equal 1, query.to_a.size
   end
 
   def test_preloading_with_associations_and_merges
-    post = Post.create! title: 'Uhuu', body: 'body'
+    post = Post.create! title: "Uhuu", body: "body"
     reader = Reader.create! post_id: post.id, person_id: 1
-    comment = Comment.create! post_id: post.id, body: 'body'
+    comment = Comment.create! post_id: post.id, body: "body"
 
     assert !comment.respond_to?(:readers)
 
-    post_rel = Post.preload(:readers).joins(:readers).where(title: 'Uhuu')
+    post_rel = Post.preload(:readers).joins(:readers).where(title: "Uhuu")
     result_comment = Comment.joins(:post).merge(post_rel).to_a.first
     assert_equal comment, result_comment
 
@@ -706,7 +706,7 @@ class RelationTest < ActiveRecord::TestCase
       assert_equal [reader], result_comment.post.readers.to_a
     end
 
-    post_rel = Post.includes(:readers).where(title: 'Uhuu')
+    post_rel = Post.includes(:readers).where(title: "Uhuu")
     result_comment = Comment.joins(:post).merge(post_rel).first
     assert_equal comment, result_comment
 
@@ -717,17 +717,17 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_preloading_with_associations_default_scopes_and_merges
-    post = Post.create! title: 'Uhuu', body: 'body'
+    post = Post.create! title: "Uhuu", body: "body"
     reader = Reader.create! post_id: post.id, person_id: 1
 
-    post_rel = PostWithPreloadDefaultScope.preload(:readers).joins(:readers).where(title: 'Uhuu')
+    post_rel = PostWithPreloadDefaultScope.preload(:readers).joins(:readers).where(title: "Uhuu")
     result_post = PostWithPreloadDefaultScope.all.merge(post_rel).to_a.first
 
     assert_no_queries do
       assert_equal [reader], result_post.readers.to_a
     end
 
-    post_rel = PostWithIncludesDefaultScope.includes(:readers).where(title: 'Uhuu')
+    post_rel = PostWithIncludesDefaultScope.includes(:readers).where(title: "Uhuu")
     result_post = PostWithIncludesDefaultScope.all.merge(post_rel).to_a.first
 
     assert_no_queries do
@@ -752,9 +752,9 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_to_sql_on_eager_join
     expected = assert_sql {
-      Post.eager_load(:last_comment).order('comments.id DESC').to_a
+      Post.eager_load(:last_comment).order("comments.id DESC").to_a
     }.first
-    actual = Post.eager_load(:last_comment).order('comments.id DESC').to_sql
+    actual = Post.eager_load(:last_comment).order("comments.id DESC").to_sql
     assert_equal expected, actual
   end
 
@@ -765,7 +765,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_loading_with_one_association_with_non_preload
-    posts = Post.eager_load(:last_comment).order('comments.id DESC')
+    posts = Post.eager_load(:last_comment).order("comments.id DESC")
     post = posts.find { |p| p.id == 1 }
     assert_equal Post.find(1).last_comment, post.last_comment
   end
@@ -789,30 +789,30 @@ class RelationTest < ActiveRecord::TestCase
     author = Author.all.find_by_id!(authors(:david).id)
     assert_equal "David", author.name
 
-    assert_raises(ActiveRecord::RecordNotFound) { Author.all.find_by_id_and_name!(20, 'invalid') }
+    assert_raises(ActiveRecord::RecordNotFound) { Author.all.find_by_id_and_name!(20, "invalid") }
   end
 
   def test_find_id
     authors = Author.all
 
     david = authors.find(authors(:david).id)
-    assert_equal 'David', david.name
+    assert_equal "David", david.name
 
-    assert_raises(ActiveRecord::RecordNotFound) { authors.where(:name => 'lifo').find('42') }
+    assert_raises(ActiveRecord::RecordNotFound) { authors.where(:name => "lifo").find("42") }
   end
 
   def test_find_ids
-    authors = Author.order('id ASC')
+    authors = Author.order("id ASC")
 
     results = authors.find(authors(:david).id, authors(:mary).id)
     assert_kind_of Array, results
     assert_equal 2, results.size
-    assert_equal 'David', results[0].name
-    assert_equal 'Mary', results[1].name
+    assert_equal "David", results[0].name
+    assert_equal "Mary", results[1].name
     assert_equal results, authors.find([authors(:david).id, authors(:mary).id])
 
-    assert_raises(ActiveRecord::RecordNotFound) { authors.where(:name => 'lifo').find(authors(:david).id, '42') }
-    assert_raises(ActiveRecord::RecordNotFound) { authors.find(['42', 43]) }
+    assert_raises(ActiveRecord::RecordNotFound) { authors.where(:name => "lifo").find(authors(:david).id, "42") }
+    assert_raises(ActiveRecord::RecordNotFound) { authors.find(["42", 43]) }
   end
 
   def test_find_in_empty_array
@@ -851,7 +851,7 @@ class RelationTest < ActiveRecord::TestCase
     david = authors(:david)
     relation = Author.unscoped
     relation = relation.where(:name => david.name)
-    relation = relation.where(:name => 'Santiago')
+    relation = relation.where(:name => "Santiago")
     relation = relation.where(:id => david.id)
     assert_equal [], relation.to_a
   end
@@ -859,16 +859,16 @@ class RelationTest < ActiveRecord::TestCase
   def test_multi_where_ands_queries
     relation = Author.unscoped
     david = authors(:david)
-    sql = relation.where(:name => david.name).where(:name => 'Santiago').to_sql
-    assert_match('AND', sql)
+    sql = relation.where(:name => david.name).where(:name => "Santiago").to_sql
+    assert_match("AND", sql)
   end
 
   def test_find_all_with_multiple_should_use_and
     david = authors(:david)
     relation = [
       { :name => david.name },
-      { :name => 'Santiago' },
-      { :name => 'tenderlove' },
+      { :name => "Santiago" },
+      { :name => "tenderlove" },
     ].inject(Author.unscoped) do |memo, param|
       memo.where(param)
     end
@@ -892,12 +892,12 @@ class RelationTest < ActiveRecord::TestCase
     }
 
     assert_queries(1) {
-      relation = Author.where('id in (?)', Author.where(id: david).select(:id))
+      relation = Author.where("id in (?)", Author.where(id: david).select(:id))
       assert_equal [david], relation.to_a
     }
 
     assert_queries(1) do
-      relation = Author.where('id in (:author_ids)', author_ids: Author.where(id: david).select(:id))
+      relation = Author.where("id in (:author_ids)", author_ids: Author.where(id: david).select(:id))
       assert_equal [david], relation.to_a
     end
   end
@@ -912,13 +912,13 @@ class RelationTest < ActiveRecord::TestCase
     end
 
     assert_queries(1) do
-      relation = Post.where('id in (?)', david.posts.select(:id))
-      assert_equal davids_posts, relation.order(:id).to_a, 'should process Relation as bind variables'
+      relation = Post.where("id in (?)", david.posts.select(:id))
+      assert_equal davids_posts, relation.order(:id).to_a, "should process Relation as bind variables"
     end
 
     assert_queries(1) do
-      relation = Post.where('id in (:post_ids)', post_ids: david.posts.select(:id))
-      assert_equal davids_posts, relation.order(:id).to_a, 'should process Relation as named bind variables'
+      relation = Post.where("id in (:post_ids)", post_ids: david.posts.select(:id))
+      assert_equal davids_posts, relation.order(:id).to_a, "should process Relation as named bind variables"
     end
   end
 
@@ -963,7 +963,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_exists
-    davids = Author.where(:name => 'David')
+    davids = Author.where(:name => "David")
     assert davids.exists?
     assert davids.exists?(authors(:david).id)
     assert ! davids.exists?(authors(:mary).id)
@@ -971,7 +971,7 @@ class RelationTest < ActiveRecord::TestCase
     assert ! davids.exists?(42)
     assert ! davids.exists?(davids.new.id)
 
-    fake  = Author.where(:name => 'fake author')
+    fake  = Author.where(:name => "fake author")
     assert ! fake.exists?
     assert ! fake.exists?(authors(:david).id)
   end
@@ -994,13 +994,13 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_destroy_all
-    davids = Author.where(:name => 'David')
+    davids = Author.where(:name => "David")
 
     # Force load
     assert_equal [authors(:david)], davids.to_a
     assert davids.loaded?
 
-    assert_difference('Author.count', -1) { davids.destroy_all }
+    assert_difference("Author.count", -1) { davids.destroy_all }
 
     assert_equal [], davids.to_a
     assert davids.loaded?
@@ -1008,31 +1008,31 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_destroy_all_with_conditions_is_deprecated
     assert_deprecated do
-      assert_difference('Author.count', -1) { Author.destroy_all(name: 'David') }
+      assert_difference("Author.count", -1) { Author.destroy_all(name: "David") }
     end
   end
 
   def test_delete_all
-    davids = Author.where(:name => 'David')
+    davids = Author.where(:name => "David")
 
-    assert_difference('Author.count', -1) { davids.delete_all }
+    assert_difference("Author.count", -1) { davids.delete_all }
     assert ! davids.loaded?
   end
 
   def test_delete_all_with_conditions_is_deprecated
     assert_deprecated do
-      assert_difference('Author.count', -1) { Author.delete_all(name: 'David') }
+      assert_difference("Author.count", -1) { Author.delete_all(name: "David") }
     end
   end
 
   def test_delete_all_loaded
-    davids = Author.where(:name => 'David')
+    davids = Author.where(:name => "David")
 
     # Force load
     assert_equal [authors(:david)], davids.to_a
     assert davids.loaded?
 
-    assert_difference('Author.count', -1) { davids.delete_all }
+    assert_difference("Author.count", -1) { davids.delete_all }
 
     assert_equal [], davids.to_a
     assert davids.loaded?
@@ -1042,7 +1042,7 @@ class RelationTest < ActiveRecord::TestCase
     assert_raises(ActiveRecord::ActiveRecordError) { Author.limit(10).delete_all }
     assert_raises(ActiveRecord::ActiveRecordError) { Author.distinct.delete_all }
     assert_raises(ActiveRecord::ActiveRecordError) { Author.group(:name).delete_all }
-    assert_raises(ActiveRecord::ActiveRecordError) { Author.having('SUM(id) < 3').delete_all }
+    assert_raises(ActiveRecord::ActiveRecordError) { Author.having("SUM(id) < 3").delete_all }
     assert_raises(ActiveRecord::ActiveRecordError) { Author.offset(10).delete_all }
   end
 
@@ -1082,7 +1082,7 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal 11, posts.count(:all)
     assert_equal 11, posts.count(:id)
 
-    assert_equal 1, posts.where('comments_count > 1').count
+    assert_equal 1, posts.where("comments_count > 1").count
     assert_equal 9, posts.where(:comments_count => 0).count
   end
 
@@ -1117,24 +1117,24 @@ class RelationTest < ActiveRecord::TestCase
     Post.tagged_with(tag.id).update_all title: "rofl"
     list = Post.tagged_with(tag.id).all.to_a
     assert_operator list.length, :>, 0
-    list.each { |post| assert_equal 'rofl', post.title }
+    list.each { |post| assert_equal "rofl", post.title }
   end
 
   def test_count_explicit_columns
     Post.update_all(:comments_count => nil)
     posts = Post.all
 
-    assert_equal [0], posts.select('comments_count').where('id is not null').group('id').order('id').count.values.uniq
-    assert_equal 0, posts.where('id is not null').select('comments_count').count
+    assert_equal [0], posts.select("comments_count").where("id is not null").group("id").order("id").count.values.uniq
+    assert_equal 0, posts.where("id is not null").select("comments_count").count
 
-    assert_equal 11, posts.select('comments_count').count('id')
-    assert_equal 0, posts.select('comments_count').count
+    assert_equal 11, posts.select("comments_count").count("id")
+    assert_equal 0, posts.select("comments_count").count
     assert_equal 0, posts.count(:comments_count)
-    assert_equal 0, posts.count('comments_count')
+    assert_equal 0, posts.count("comments_count")
   end
 
   def test_multiple_selects
-    post = Post.all.select('comments_count').select('title').order("id ASC").first
+    post = Post.all.select("comments_count").select("title").order("id ASC").first
     assert_equal "Welcome to the weblog", post.title
     assert_equal 2, post.comments_count
   end
@@ -1179,7 +1179,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_count_complex_chained_relations
-    posts = Post.select('comments_count').where('id is not null').group("author_id").where("comments_count > 0")
+    posts = Post.select("comments_count").where("id is not null").group("author_id").where("comments_count > 0")
 
     expected = { 1 => 2 }
     assert_equal expected, posts.count
@@ -1302,11 +1302,11 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_scoped_build
-    posts = Post.where(:title => 'You told a lie')
+    posts = Post.where(:title => "You told a lie")
 
     post = posts.new
     assert_kind_of Post, post
-    assert_equal 'You told a lie', post.title
+    assert_equal "You told a lie", post.title
   end
 
   def test_create
@@ -1316,9 +1316,9 @@ class RelationTest < ActiveRecord::TestCase
     assert_kind_of Bird, sparrow
     assert !sparrow.persisted?
 
-    hen = birds.where(:name => 'hen').create
+    hen = birds.where(:name => "hen").create
     assert hen.persisted?
-    assert_equal 'hen', hen.name
+    assert_equal "hen", hen.name
   end
 
   def test_create_bang
@@ -1326,177 +1326,177 @@ class RelationTest < ActiveRecord::TestCase
 
     assert_raises(ActiveRecord::RecordInvalid) { birds.create! }
 
-    hen = birds.where(:name => 'hen').create!
+    hen = birds.where(:name => "hen").create!
     assert_kind_of Bird, hen
     assert hen.persisted?
-    assert_equal 'hen', hen.name
+    assert_equal "hen", hen.name
   end
 
   def test_first_or_create
-    parrot = Bird.where(:color => 'green').first_or_create(:name => 'parrot')
+    parrot = Bird.where(:color => "green").first_or_create(:name => "parrot")
     assert_kind_of Bird, parrot
     assert parrot.persisted?
-    assert_equal 'parrot', parrot.name
-    assert_equal 'green', parrot.color
+    assert_equal "parrot", parrot.name
+    assert_equal "green", parrot.color
 
-    same_parrot = Bird.where(:color => 'green').first_or_create(:name => 'parakeet')
+    same_parrot = Bird.where(:color => "green").first_or_create(:name => "parakeet")
     assert_kind_of Bird, same_parrot
     assert same_parrot.persisted?
     assert_equal parrot, same_parrot
   end
 
   def test_first_or_create_with_no_parameters
-    parrot = Bird.where(:color => 'green').first_or_create
+    parrot = Bird.where(:color => "green").first_or_create
     assert_kind_of Bird, parrot
     assert !parrot.persisted?
-    assert_equal 'green', parrot.color
+    assert_equal "green", parrot.color
   end
 
   def test_first_or_create_with_block
-    parrot = Bird.where(:color => 'green').first_or_create { |bird| bird.name = 'parrot' }
+    parrot = Bird.where(:color => "green").first_or_create { |bird| bird.name = "parrot" }
     assert_kind_of Bird, parrot
     assert parrot.persisted?
-    assert_equal 'green', parrot.color
-    assert_equal 'parrot', parrot.name
+    assert_equal "green", parrot.color
+    assert_equal "parrot", parrot.name
 
-    same_parrot = Bird.where(:color => 'green').first_or_create { |bird| bird.name = 'parakeet' }
+    same_parrot = Bird.where(:color => "green").first_or_create { |bird| bird.name = "parakeet" }
     assert_equal parrot, same_parrot
   end
 
   def test_first_or_create_with_array
-    several_green_birds = Bird.where(:color => 'green').first_or_create([{:name => 'parrot'}, {:name => 'parakeet'}])
+    several_green_birds = Bird.where(:color => "green").first_or_create([{:name => "parrot"}, {:name => "parakeet"}])
     assert_kind_of Array, several_green_birds
     several_green_birds.each { |bird| assert bird.persisted? }
 
-    same_parrot = Bird.where(:color => 'green').first_or_create([{:name => 'hummingbird'}, {:name => 'macaw'}])
+    same_parrot = Bird.where(:color => "green").first_or_create([{:name => "hummingbird"}, {:name => "macaw"}])
     assert_kind_of Bird, same_parrot
     assert_equal several_green_birds.first, same_parrot
   end
 
   def test_first_or_create_bang_with_valid_options
-    parrot = Bird.where(:color => 'green').first_or_create!(:name => 'parrot')
+    parrot = Bird.where(:color => "green").first_or_create!(:name => "parrot")
     assert_kind_of Bird, parrot
     assert parrot.persisted?
-    assert_equal 'parrot', parrot.name
-    assert_equal 'green', parrot.color
+    assert_equal "parrot", parrot.name
+    assert_equal "green", parrot.color
 
-    same_parrot = Bird.where(:color => 'green').first_or_create!(:name => 'parakeet')
+    same_parrot = Bird.where(:color => "green").first_or_create!(:name => "parakeet")
     assert_kind_of Bird, same_parrot
     assert same_parrot.persisted?
     assert_equal parrot, same_parrot
   end
 
   def test_first_or_create_bang_with_invalid_options
-    assert_raises(ActiveRecord::RecordInvalid) { Bird.where(:color => 'green').first_or_create!(:pirate_id => 1) }
+    assert_raises(ActiveRecord::RecordInvalid) { Bird.where(:color => "green").first_or_create!(:pirate_id => 1) }
   end
 
   def test_first_or_create_bang_with_no_parameters
-    assert_raises(ActiveRecord::RecordInvalid) { Bird.where(:color => 'green').first_or_create! }
+    assert_raises(ActiveRecord::RecordInvalid) { Bird.where(:color => "green").first_or_create! }
   end
 
   def test_first_or_create_bang_with_valid_block
-    parrot = Bird.where(:color => 'green').first_or_create! { |bird| bird.name = 'parrot' }
+    parrot = Bird.where(:color => "green").first_or_create! { |bird| bird.name = "parrot" }
     assert_kind_of Bird, parrot
     assert parrot.persisted?
-    assert_equal 'green', parrot.color
-    assert_equal 'parrot', parrot.name
+    assert_equal "green", parrot.color
+    assert_equal "parrot", parrot.name
 
-    same_parrot = Bird.where(:color => 'green').first_or_create! { |bird| bird.name = 'parakeet' }
+    same_parrot = Bird.where(:color => "green").first_or_create! { |bird| bird.name = "parakeet" }
     assert_equal parrot, same_parrot
   end
 
   def test_first_or_create_bang_with_invalid_block
     assert_raise(ActiveRecord::RecordInvalid) do
-      Bird.where(:color => 'green').first_or_create! { |bird| bird.pirate_id = 1 }
+      Bird.where(:color => "green").first_or_create! { |bird| bird.pirate_id = 1 }
     end
   end
 
   def test_first_or_create_with_valid_array
-    several_green_birds = Bird.where(:color => 'green').first_or_create!([{:name => 'parrot'}, {:name => 'parakeet'}])
+    several_green_birds = Bird.where(:color => "green").first_or_create!([{:name => "parrot"}, {:name => "parakeet"}])
     assert_kind_of Array, several_green_birds
     several_green_birds.each { |bird| assert bird.persisted? }
 
-    same_parrot = Bird.where(:color => 'green').first_or_create!([{:name => 'hummingbird'}, {:name => 'macaw'}])
+    same_parrot = Bird.where(:color => "green").first_or_create!([{:name => "hummingbird"}, {:name => "macaw"}])
     assert_kind_of Bird, same_parrot
     assert_equal several_green_birds.first, same_parrot
   end
 
   def test_first_or_create_with_invalid_array
-    assert_raises(ActiveRecord::RecordInvalid) { Bird.where(:color => 'green').first_or_create!([ {:name => 'parrot'}, {:pirate_id => 1} ]) }
+    assert_raises(ActiveRecord::RecordInvalid) { Bird.where(:color => "green").first_or_create!([ {:name => "parrot"}, {:pirate_id => 1} ]) }
   end
 
   def test_first_or_initialize
-    parrot = Bird.where(:color => 'green').first_or_initialize(:name => 'parrot')
+    parrot = Bird.where(:color => "green").first_or_initialize(:name => "parrot")
     assert_kind_of Bird, parrot
     assert !parrot.persisted?
     assert parrot.valid?
     assert parrot.new_record?
-    assert_equal 'parrot', parrot.name
-    assert_equal 'green', parrot.color
+    assert_equal "parrot", parrot.name
+    assert_equal "green", parrot.color
   end
 
   def test_first_or_initialize_with_no_parameters
-    parrot = Bird.where(:color => 'green').first_or_initialize
+    parrot = Bird.where(:color => "green").first_or_initialize
     assert_kind_of Bird, parrot
     assert !parrot.persisted?
     assert !parrot.valid?
     assert parrot.new_record?
-    assert_equal 'green', parrot.color
+    assert_equal "green", parrot.color
   end
 
   def test_first_or_initialize_with_block
-    parrot = Bird.where(:color => 'green').first_or_initialize { |bird| bird.name = 'parrot' }
+    parrot = Bird.where(:color => "green").first_or_initialize { |bird| bird.name = "parrot" }
     assert_kind_of Bird, parrot
     assert !parrot.persisted?
     assert parrot.valid?
     assert parrot.new_record?
-    assert_equal 'green', parrot.color
-    assert_equal 'parrot', parrot.name
+    assert_equal "green", parrot.color
+    assert_equal "parrot", parrot.name
   end
 
   def test_find_or_create_by
-    assert_nil Bird.find_by(name: 'bob')
+    assert_nil Bird.find_by(name: "bob")
 
-    bird = Bird.find_or_create_by(name: 'bob')
+    bird = Bird.find_or_create_by(name: "bob")
     assert bird.persisted?
 
-    assert_equal bird, Bird.find_or_create_by(name: 'bob')
+    assert_equal bird, Bird.find_or_create_by(name: "bob")
   end
 
   def test_find_or_create_by_with_create_with
-    assert_nil Bird.find_by(name: 'bob')
+    assert_nil Bird.find_by(name: "bob")
 
-    bird = Bird.create_with(color: 'green').find_or_create_by(name: 'bob')
+    bird = Bird.create_with(color: "green").find_or_create_by(name: "bob")
     assert bird.persisted?
-    assert_equal 'green', bird.color
+    assert_equal "green", bird.color
 
-    assert_equal bird, Bird.create_with(color: 'blue').find_or_create_by(name: 'bob')
+    assert_equal bird, Bird.create_with(color: "blue").find_or_create_by(name: "bob")
   end
 
   def test_find_or_create_by!
-    assert_raises(ActiveRecord::RecordInvalid) { Bird.find_or_create_by!(color: 'green') }
+    assert_raises(ActiveRecord::RecordInvalid) { Bird.find_or_create_by!(color: "green") }
   end
 
   def test_find_or_initialize_by
-    assert_nil Bird.find_by(name: 'bob')
+    assert_nil Bird.find_by(name: "bob")
 
-    bird = Bird.find_or_initialize_by(name: 'bob')
+    bird = Bird.find_or_initialize_by(name: "bob")
     assert bird.new_record?
     bird.save!
 
-    assert_equal bird, Bird.find_or_initialize_by(name: 'bob')
+    assert_equal bird, Bird.find_or_initialize_by(name: "bob")
   end
 
   def test_explicit_create_scope
-    hens = Bird.where(:name => 'hen')
-    assert_equal 'hen', hens.new.name
+    hens = Bird.where(:name => "hen")
+    assert_equal "hen", hens.new.name
 
-    hens = hens.create_with(:name => 'cock')
-    assert_equal 'cock', hens.new.name
+    hens = hens.create_with(:name => "cock")
+    assert_equal "cock", hens.new.name
   end
 
   def test_except
-    relation = Post.where(:author_id => 1).order('id ASC').limit(1)
+    relation = Post.where(:author_id => 1).order("id ASC").limit(1)
     assert_equal [posts(:welcome)], relation.to_a
 
     author_posts = relation.except(:order, :limit)
@@ -1507,7 +1507,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_only
-    relation = Post.where(:author_id => 1).order('id ASC').limit(1)
+    relation = Post.where(:author_id => 1).order("id ASC").limit(1)
     assert_equal [posts(:welcome)], relation.to_a
 
     author_posts = relation.only(:where)
@@ -1518,9 +1518,9 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_anonymous_extension
-    relation = Post.where(:author_id => 1).order('id ASC').extending do
+    relation = Post.where(:author_id => 1).order("id ASC").extending do
       def author
-        'lifo'
+        "lifo"
       end
     end
 
@@ -1529,7 +1529,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_named_extension
-    relation = Post.where(:author_id => 1).order('id ASC').extending(Post::NamedExtension)
+    relation = Post.where(:author_id => 1).order("id ASC").extending(Post::NamedExtension)
     assert_equal "lifo", relation.author
     assert_equal "lifo", relation.limit(1).author
   end
@@ -1539,25 +1539,25 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_default_scope_order_with_scope_order
-    assert_equal 'zyke', CoolCar.order_using_new_style.limit(1).first.name
-    assert_equal 'zyke', FastCar.order_using_new_style.limit(1).first.name
+    assert_equal "zyke", CoolCar.order_using_new_style.limit(1).first.name
+    assert_equal "zyke", FastCar.order_using_new_style.limit(1).first.name
   end
 
   def test_order_using_scoping
-    car1 = CoolCar.order('id DESC').scoping do
-      CoolCar.all.merge!(order: 'id asc').first
+    car1 = CoolCar.order("id DESC").scoping do
+      CoolCar.all.merge!(order: "id asc").first
     end
-    assert_equal 'zyke', car1.name
+    assert_equal "zyke", car1.name
 
-    car2 = FastCar.order('id DESC').scoping do
-      FastCar.all.merge!(order: 'id asc').first
+    car2 = FastCar.order("id DESC").scoping do
+      FastCar.all.merge!(order: "id asc").first
     end
-    assert_equal 'zyke', car2.name
+    assert_equal "zyke", car2.name
   end
 
   def test_unscoped_block_style
-    assert_equal 'honda', CoolCar.unscoped { CoolCar.order_using_new_style.limit(1).first.name}
-    assert_equal 'honda', FastCar.unscoped { FastCar.order_using_new_style.limit(1).first.name}
+    assert_equal "honda", CoolCar.unscoped { CoolCar.order_using_new_style.limit(1).first.name}
+    assert_equal "honda", FastCar.unscoped { FastCar.order_using_new_style.limit(1).first.name}
   end
 
   def test_intersection_with_array
@@ -1573,7 +1573,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_ordering_with_extra_spaces
-    assert_equal authors(:david), Author.order('id DESC , name DESC').last
+    assert_equal authors(:david), Author.order("id DESC , name DESC").last
   end
 
   def test_update_all_with_blank_argument
@@ -1581,7 +1581,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_update_all_with_joins
-    comments = Comment.joins(:post).where('posts.id' => posts(:welcome).id)
+    comments = Comment.joins(:post).where("posts.id" => posts(:welcome).id)
     count    = comments.count
 
     assert_equal count, comments.update_all(:post_id => posts(:thinking).id)
@@ -1589,19 +1589,19 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_update_all_with_joins_and_limit
-    comments = Comment.joins(:post).where('posts.id' => posts(:welcome).id).limit(1)
+    comments = Comment.joins(:post).where("posts.id" => posts(:welcome).id).limit(1)
     assert_equal 1, comments.update_all(:post_id => posts(:thinking).id)
   end
 
   def test_update_all_with_joins_and_limit_and_order
-    comments = Comment.joins(:post).where('posts.id' => posts(:welcome).id).order('comments.id').limit(1)
+    comments = Comment.joins(:post).where("posts.id" => posts(:welcome).id).order("comments.id").limit(1)
     assert_equal 1, comments.update_all(:post_id => posts(:thinking).id)
     assert_equal posts(:thinking), comments(:greetings).post
     assert_equal posts(:welcome),  comments(:more_greetings).post
   end
 
   def test_update_all_with_joins_and_offset
-    all_comments = Comment.joins(:post).where('posts.id' => posts(:welcome).id)
+    all_comments = Comment.joins(:post).where("posts.id" => posts(:welcome).id)
     count        = all_comments.count
     comments     = all_comments.offset(1)
 
@@ -1609,7 +1609,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_update_all_with_joins_and_offset_and_order
-    all_comments = Comment.joins(:post).where('posts.id' => posts(:welcome).id).order('posts.id', 'comments.id')
+    all_comments = Comment.joins(:post).where("posts.id" => posts(:welcome).id).order("posts.id", "comments.id")
     count        = all_comments.count
     comments     = all_comments.offset(1)
 
@@ -1619,49 +1619,49 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_update_on_relation
-    topic1 = TopicWithCallbacks.create! title: 'arel', author_name: nil
-    topic2 = TopicWithCallbacks.create! title: 'activerecord', author_name: nil
+    topic1 = TopicWithCallbacks.create! title: "arel", author_name: nil
+    topic2 = TopicWithCallbacks.create! title: "activerecord", author_name: nil
     topics = TopicWithCallbacks.where(id: [topic1.id, topic2.id])
-    topics.update(title: 'adequaterecord')
+    topics.update(title: "adequaterecord")
 
-    assert_equal 'adequaterecord', topic1.reload.title
-    assert_equal 'adequaterecord', topic2.reload.title
+    assert_equal "adequaterecord", topic1.reload.title
+    assert_equal "adequaterecord", topic2.reload.title
     # Testing that the before_update callbacks have run
-    assert_equal 'David', topic1.reload.author_name
-    assert_equal 'David', topic2.reload.author_name
+    assert_equal "David", topic1.reload.author_name
+    assert_equal "David", topic2.reload.author_name
   end
 
   def test_update_on_relation_passing_active_record_object_is_deprecated
-    topic = Topic.create!(title: 'Foo', author_name: nil)
+    topic = Topic.create!(title: "Foo", author_name: nil)
     assert_deprecated(/update/) do
-      Topic.where(id: topic.id).update(topic, title: 'Bar')
+      Topic.where(id: topic.id).update(topic, title: "Bar")
     end
   end
 
   def test_distinct
-    tag1 = Tag.create(:name => 'Foo')
-    tag2 = Tag.create(:name => 'Foo')
+    tag1 = Tag.create(:name => "Foo")
+    tag2 = Tag.create(:name => "Foo")
 
     query = Tag.select(:name).where(:id => [tag1.id, tag2.id])
 
-    assert_equal ['Foo', 'Foo'], query.map(&:name)
+    assert_equal ["Foo", "Foo"], query.map(&:name)
     assert_sql(/DISTINCT/) do
-      assert_equal ['Foo'], query.distinct.map(&:name)
-      assert_deprecated { assert_equal ['Foo'], query.uniq.map(&:name) }
+      assert_equal ["Foo"], query.distinct.map(&:name)
+      assert_deprecated { assert_equal ["Foo"], query.uniq.map(&:name) }
     end
     assert_sql(/DISTINCT/) do
-      assert_equal ['Foo'], query.distinct(true).map(&:name)
-      assert_deprecated { assert_equal ['Foo'], query.uniq(true).map(&:name) }
+      assert_equal ["Foo"], query.distinct(true).map(&:name)
+      assert_deprecated { assert_equal ["Foo"], query.uniq(true).map(&:name) }
     end
-    assert_equal ['Foo', 'Foo'], query.distinct(true).distinct(false).map(&:name)
+    assert_equal ["Foo", "Foo"], query.distinct(true).distinct(false).map(&:name)
 
     assert_deprecated do
-      assert_equal ['Foo', 'Foo'], query.uniq(true).uniq(false).map(&:name)
+      assert_equal ["Foo", "Foo"], query.uniq(true).uniq(false).map(&:name)
     end
   end
 
   def test_doesnt_add_having_values_if_options_are_blank
-    scope = Post.having('')
+    scope = Post.having("")
     assert scope.having_clause.empty?
 
     scope = Post.having([])
@@ -1702,61 +1702,61 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_automatically_added_where_references
     scope = Post.where(:comments => { :body => "Bla" })
-    assert_equal ['comments'], scope.references_values
+    assert_equal ["comments"], scope.references_values
 
-    scope = Post.where('comments.body' => 'Bla')
-    assert_equal ['comments'], scope.references_values
+    scope = Post.where("comments.body" => "Bla")
+    assert_equal ["comments"], scope.references_values
   end
 
   def test_automatically_added_where_not_references
     scope = Post.where.not(comments: { body: "Bla" })
-    assert_equal ['comments'], scope.references_values
+    assert_equal ["comments"], scope.references_values
 
-    scope = Post.where.not('comments.body' => 'Bla')
-    assert_equal ['comments'], scope.references_values
+    scope = Post.where.not("comments.body" => "Bla")
+    assert_equal ["comments"], scope.references_values
   end
 
   def test_automatically_added_having_references
     scope = Post.having(:comments => { :body => "Bla" })
-    assert_equal ['comments'], scope.references_values
+    assert_equal ["comments"], scope.references_values
 
-    scope = Post.having('comments.body' => 'Bla')
-    assert_equal ['comments'], scope.references_values
+    scope = Post.having("comments.body" => "Bla")
+    assert_equal ["comments"], scope.references_values
   end
 
   def test_automatically_added_order_references
-    scope = Post.order('comments.body')
-    assert_equal ['comments'], scope.references_values
+    scope = Post.order("comments.body")
+    assert_equal ["comments"], scope.references_values
 
-    scope = Post.order('comments.body', 'yaks.body')
-    assert_equal ['comments', 'yaks'], scope.references_values
+    scope = Post.order("comments.body", "yaks.body")
+    assert_equal ["comments", "yaks"], scope.references_values
 
     # Don't infer yaks, let's not go down that road again...
-    scope = Post.order('comments.body, yaks.body')
-    assert_equal ['comments'], scope.references_values
+    scope = Post.order("comments.body, yaks.body")
+    assert_equal ["comments"], scope.references_values
 
-    scope = Post.order('comments.body asc')
-    assert_equal ['comments'], scope.references_values
+    scope = Post.order("comments.body asc")
+    assert_equal ["comments"], scope.references_values
 
-    scope = Post.order('foo(comments.body)')
+    scope = Post.order("foo(comments.body)")
     assert_equal [], scope.references_values
   end
 
   def test_automatically_added_reorder_references
-    scope = Post.reorder('comments.body')
+    scope = Post.reorder("comments.body")
     assert_equal %w(comments), scope.references_values
 
-    scope = Post.reorder('comments.body', 'yaks.body')
+    scope = Post.reorder("comments.body", "yaks.body")
     assert_equal %w(comments yaks), scope.references_values
 
     # Don't infer yaks, let's not go down that road again...
-    scope = Post.reorder('comments.body, yaks.body')
+    scope = Post.reorder("comments.body, yaks.body")
     assert_equal %w(comments), scope.references_values
 
-    scope = Post.reorder('comments.body asc')
+    scope = Post.reorder("comments.body asc")
     assert_equal %w(comments), scope.references_values
 
-    scope = Post.reorder('foo(comments.body)')
+    scope = Post.reorder("foo(comments.body)")
     assert_equal [], scope.references_values
   end
 
@@ -1803,7 +1803,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   test "find_by with multi-arg conditions returns the first matching record" do
-    assert_equal posts(:eager_other), Post.order(:id).find_by('author_id = ?', 2)
+    assert_equal posts(:eager_other), Post.order(:id).find_by("author_id = ?", 2)
   end
 
   test "find_by returns nil if the record is missing" do
@@ -1827,7 +1827,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   test "find_by! with multi-arg conditions returns the first matching record" do
-    assert_equal posts(:eager_other), Post.order(:id).find_by!('author_id = ?', 2)
+    assert_equal posts(:eager_other), Post.order(:id).find_by!("author_id = ?", 2)
   end
 
   test "find_by! doesn't have implicit ordering" do
@@ -1849,7 +1849,7 @@ class RelationTest < ActiveRecord::TestCase
     relation.to_a
 
     assert_raises(ActiveRecord::ImmutableRelation) do
-      relation.where! 'foo'
+      relation.where! "foo"
     end
   end
 
@@ -1867,7 +1867,7 @@ class RelationTest < ActiveRecord::TestCase
     relation.to_a
 
     assert_raises(ActiveRecord::ImmutableRelation) do
-      relation.merge! where: 'foo'
+      relation.merge! where: "foo"
     end
   end
 
@@ -1909,8 +1909,8 @@ class RelationTest < ActiveRecord::TestCase
     end
   end
 
-  test 'using a custom table affects the wheres' do
-    table_alias = Post.arel_table.alias('omg_posts')
+  test "using a custom table affects the wheres" do
+    table_alias = Post.arel_table.alias("omg_posts")
 
     table_metadata = ActiveRecord::TableMetadata.new(Post, table_alias)
     predicate_builder = ActiveRecord::PredicateBuilder.new(table_metadata)
@@ -1921,7 +1921,7 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal table_alias, node.relation
   end
 
-  test '#load' do
+  test "#load" do
     relation = Post.all
     assert_queries(1) do
       assert_equal relation, relation.load
@@ -1929,9 +1929,9 @@ class RelationTest < ActiveRecord::TestCase
     assert_no_queries { relation.to_a }
   end
 
-  test 'group with select and includes' do
-    authors_count = Post.select('author_id, COUNT(author_id) AS num_posts').
-      group('author_id').order('author_id').includes(:author).to_a
+  test "group with select and includes" do
+    authors_count = Post.select("author_id, COUNT(author_id) AS num_posts").
+      group("author_id").order("author_id").includes(:author).to_a
 
     assert_no_queries do
       result = authors_count.map do |post|
@@ -1957,7 +1957,7 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_unscope_removes_binds
     left  = Post.where(id: Arel::Nodes::BindParam.new)
-    column = Post.columns_hash['id']
+    column = Post.columns_hash["id"]
     left.bind_values += [[column, 20]]
 
     relation = left.unscope(where: :id)
@@ -1992,7 +1992,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_relation_join_method
-    assert_equal 'Thank you for the welcome,Thank you again for the welcome', Post.first.comments.join(",")
+    assert_equal "Thank you for the welcome,Thank you again for the welcome", Post.first.comments.join(",")
   end
 
   def test_connection_adapters_can_reorder_binds
diff --git a/activerecord/test/cases/reload_models_test.rb b/activerecord/test/cases/reload_models_test.rb
index 431fbf1297..5dc9d6d8b7 100644
--- a/activerecord/test/cases/reload_models_test.rb
+++ b/activerecord/test/cases/reload_models_test.rb
@@ -1,13 +1,13 @@
 require "cases/helper"
-require 'models/owner'
-require 'models/pet'
+require "models/owner"
+require "models/pet"
 
 class ReloadModelsTest < ActiveRecord::TestCase
   fixtures :pets, :owners
 
   def test_has_one_with_reload
-    pet = Pet.find_by_name('parrot')
-    pet.owner = Owner.find_by_name('ashley')
+    pet = Pet.find_by_name("parrot")
+    pet.owner = Owner.find_by_name("ashley")
 
     # Reload the class Owner, simulating auto-reloading of model classes in a
     # development environment. Note that meanwhile the class Pet is not
@@ -15,8 +15,8 @@ class ReloadModelsTest < ActiveRecord::TestCase
     Object.class_eval { remove_const :Owner }
     Kernel.load(File.expand_path(File.join(File.dirname(__FILE__), "../models/owner.rb")))
 
-    pet = Pet.find_by_name('parrot')
-    pet.owner = Owner.find_by_name('ashley')
-    assert_equal pet.owner, Owner.find_by_name('ashley')
+    pet = Pet.find_by_name("parrot")
+    pet.owner = Owner.find_by_name("ashley")
+    assert_equal pet.owner, Owner.find_by_name("ashley")
   end
 end
diff --git a/activerecord/test/cases/result_test.rb b/activerecord/test/cases/result_test.rb
index 83dc5347e0..8bbd4b3bc5 100644
--- a/activerecord/test/cases/result_test.rb
+++ b/activerecord/test/cases/result_test.rb
@@ -3,10 +3,10 @@ require "cases/helper"
 module ActiveRecord
   class ResultTest < ActiveRecord::TestCase
     def result
-      Result.new(['col_1', 'col_2'], [
-        ['row 1 col 1', 'row 1 col 2'],
-        ['row 2 col 1', 'row 2 col 2'],
-        ['row 3 col 1', 'row 3 col 2'],
+      Result.new(["col_1", "col_2"], [
+        ["row 1 col 1", "row 1 col 2"],
+        ["row 2 col 1", "row 2 col 2"],
+        ["row 3 col 1", "row 3 col 2"],
       ])
     end
 
@@ -16,31 +16,31 @@ module ActiveRecord
 
     test "to_hash returns row_hashes" do
       assert_equal [
-        {'col_1' => 'row 1 col 1', 'col_2' => 'row 1 col 2'},
-        {'col_1' => 'row 2 col 1', 'col_2' => 'row 2 col 2'},
-        {'col_1' => 'row 3 col 1', 'col_2' => 'row 3 col 2'},
+        {"col_1" => "row 1 col 1", "col_2" => "row 1 col 2"},
+        {"col_1" => "row 2 col 1", "col_2" => "row 2 col 2"},
+        {"col_1" => "row 3 col 1", "col_2" => "row 3 col 2"},
       ], result.to_hash
     end
 
     test "first returns first row as a hash" do
       assert_equal(
-        {'col_1' => 'row 1 col 1', 'col_2' => 'row 1 col 2'}, result.first)
+        {"col_1" => "row 1 col 1", "col_2" => "row 1 col 2"}, result.first)
     end
 
     test "last returns last row as a hash" do
       assert_equal(
-        {'col_1' => 'row 3 col 1', 'col_2' => 'row 3 col 2'}, result.last)
+        {"col_1" => "row 3 col 1", "col_2" => "row 3 col 2"}, result.last)
     end
 
     test "each with block returns row hashes" do
       result.each do |row|
-        assert_equal ['col_1', 'col_2'], row.keys
+        assert_equal ["col_1", "col_2"], row.keys
       end
     end
 
     test "each without block returns an enumerator" do
       result.each.with_index do |row, index|
-        assert_equal ['col_1', 'col_2'], row.keys
+        assert_equal ["col_1", "col_2"], row.keys
         assert_kind_of Integer, index
       end
     end
diff --git a/activerecord/test/cases/sanitize_test.rb b/activerecord/test/cases/sanitize_test.rb
index 239f63d27b..f649ef3660 100644
--- a/activerecord/test/cases/sanitize_test.rb
+++ b/activerecord/test/cases/sanitize_test.rb
@@ -1,7 +1,7 @@
 require "cases/helper"
-require 'models/binary'
-require 'models/author'
-require 'models/post'
+require "models/binary"
+require "models/author"
+require "models/post"
 
 class SanitizeTest < ActiveRecord::TestCase
   def setup
@@ -36,42 +36,42 @@ class SanitizeTest < ActiveRecord::TestCase
   end
 
   def test_sanitize_sql_array_handles_relations
-    david = Author.create!(name: 'David')
+    david = Author.create!(name: "David")
     david_posts = david.posts.select(:id)
 
     sub_query_pattern = /\(\bselect\b.*?\bwhere\b.*?\)/i
 
-    select_author_sql = Post.send(:sanitize_sql_array, ['id in (?)', david_posts])
-    assert_match(sub_query_pattern, select_author_sql, 'should sanitize `Relation` as subquery for bind variables')
+    select_author_sql = Post.send(:sanitize_sql_array, ["id in (?)", david_posts])
+    assert_match(sub_query_pattern, select_author_sql, "should sanitize `Relation` as subquery for bind variables")
 
-    select_author_sql = Post.send(:sanitize_sql_array, ['id in (:post_ids)', post_ids: david_posts])
-    assert_match(sub_query_pattern, select_author_sql, 'should sanitize `Relation` as subquery for named bind variables')
+    select_author_sql = Post.send(:sanitize_sql_array, ["id in (:post_ids)", post_ids: david_posts])
+    assert_match(sub_query_pattern, select_author_sql, "should sanitize `Relation` as subquery for named bind variables")
   end
 
   def test_sanitize_sql_array_handles_empty_statement
-    select_author_sql = Post.send(:sanitize_sql_array, [''])
-    assert_equal('', select_author_sql)
+    select_author_sql = Post.send(:sanitize_sql_array, [""])
+    assert_equal("", select_author_sql)
   end
 
   def test_sanitize_sql_like
-    assert_equal '100\%', Binary.send(:sanitize_sql_like, '100%')
-    assert_equal 'snake\_cased\_string', Binary.send(:sanitize_sql_like, 'snake_cased_string')
+    assert_equal '100\%', Binary.send(:sanitize_sql_like, "100%")
+    assert_equal 'snake\_cased\_string', Binary.send(:sanitize_sql_like, "snake_cased_string")
     assert_equal 'C:\\\\Programs\\\\MsPaint', Binary.send(:sanitize_sql_like, 'C:\\Programs\\MsPaint')
-    assert_equal 'normal string 42', Binary.send(:sanitize_sql_like, 'normal string 42')
+    assert_equal "normal string 42", Binary.send(:sanitize_sql_like, "normal string 42")
   end
 
   def test_sanitize_sql_like_with_custom_escape_character
-    assert_equal '100!%', Binary.send(:sanitize_sql_like, '100%', '!')
-    assert_equal 'snake!_cased!_string', Binary.send(:sanitize_sql_like, 'snake_cased_string', '!')
-    assert_equal 'great!!', Binary.send(:sanitize_sql_like, 'great!', '!')
-    assert_equal 'C:\\Programs\\MsPaint', Binary.send(:sanitize_sql_like, 'C:\\Programs\\MsPaint', '!')
-    assert_equal 'normal string 42', Binary.send(:sanitize_sql_like, 'normal string 42', '!')
+    assert_equal "100!%", Binary.send(:sanitize_sql_like, "100%", "!")
+    assert_equal "snake!_cased!_string", Binary.send(:sanitize_sql_like, "snake_cased_string", "!")
+    assert_equal "great!!", Binary.send(:sanitize_sql_like, "great!", "!")
+    assert_equal 'C:\\Programs\\MsPaint', Binary.send(:sanitize_sql_like, 'C:\\Programs\\MsPaint', "!")
+    assert_equal "normal string 42", Binary.send(:sanitize_sql_like, "normal string 42", "!")
   end
 
   def test_sanitize_sql_like_example_use_case
     searchable_post = Class.new(Post) do
       def self.search(term)
-        where("title LIKE ?", sanitize_sql_like(term, '!'))
+        where("title LIKE ?", sanitize_sql_like(term, "!"))
       end
     end
 
@@ -81,17 +81,17 @@ class SanitizeTest < ActiveRecord::TestCase
   end
 
   def test_bind_arity
-    assert_nothing_raised                                { bind '' }
-    assert_raise(ActiveRecord::PreparedStatementInvalid) { bind '', 1 }
+    assert_nothing_raised                                { bind "" }
+    assert_raise(ActiveRecord::PreparedStatementInvalid) { bind "", 1 }
 
-    assert_raise(ActiveRecord::PreparedStatementInvalid) { bind '?' }
-    assert_nothing_raised                                { bind '?', 1 }
-    assert_raise(ActiveRecord::PreparedStatementInvalid) { bind '?', 1, 1 }
+    assert_raise(ActiveRecord::PreparedStatementInvalid) { bind "?" }
+    assert_nothing_raised                                { bind "?", 1 }
+    assert_raise(ActiveRecord::PreparedStatementInvalid) { bind "?", 1, 1 }
   end
 
   def test_named_bind_variables
-    assert_equal '1', bind(':a', :a => 1) # ' ruby-mode
-    assert_equal '1 1', bind(':a :a', :a => 1)  # ' ruby-mode
+    assert_equal "1", bind(":a", :a => 1) # ' ruby-mode
+    assert_equal "1 1", bind(":a :a", :a => 1)  # ' ruby-mode
 
     assert_nothing_raised { bind("'+00:00'", :foo => "bar") }
   end
@@ -117,50 +117,50 @@ class SanitizeTest < ActiveRecord::TestCase
   def test_bind_enumerable
     quoted_abc = %(#{ActiveRecord::Base.connection.quote('a')},#{ActiveRecord::Base.connection.quote('b')},#{ActiveRecord::Base.connection.quote('c')})
 
-    assert_equal '1,2,3', bind('?', [1, 2, 3])
-    assert_equal quoted_abc, bind('?', %w(a b c))
+    assert_equal "1,2,3", bind("?", [1, 2, 3])
+    assert_equal quoted_abc, bind("?", %w(a b c))
 
-    assert_equal '1,2,3', bind(':a', :a => [1, 2, 3])
-    assert_equal quoted_abc, bind(':a', :a => %w(a b c)) # '
+    assert_equal "1,2,3", bind(":a", :a => [1, 2, 3])
+    assert_equal quoted_abc, bind(":a", :a => %w(a b c)) # '
 
-    assert_equal '1,2,3', bind('?', SimpleEnumerable.new([1, 2, 3]))
-    assert_equal quoted_abc, bind('?', SimpleEnumerable.new(%w(a b c)))
+    assert_equal "1,2,3", bind("?", SimpleEnumerable.new([1, 2, 3]))
+    assert_equal quoted_abc, bind("?", SimpleEnumerable.new(%w(a b c)))
 
-    assert_equal '1,2,3', bind(':a', :a => SimpleEnumerable.new([1, 2, 3]))
-    assert_equal quoted_abc, bind(':a', :a => SimpleEnumerable.new(%w(a b c))) # '
+    assert_equal "1,2,3", bind(":a", :a => SimpleEnumerable.new([1, 2, 3]))
+    assert_equal quoted_abc, bind(":a", :a => SimpleEnumerable.new(%w(a b c))) # '
   end
 
   def test_bind_empty_enumerable
     quoted_nil = ActiveRecord::Base.connection.quote(nil)
-    assert_equal quoted_nil, bind('?', [])
-    assert_equal " in (#{quoted_nil})", bind(' in (?)', [])
-    assert_equal "foo in (#{quoted_nil})", bind('foo in (?)', [])
+    assert_equal quoted_nil, bind("?", [])
+    assert_equal " in (#{quoted_nil})", bind(" in (?)", [])
+    assert_equal "foo in (#{quoted_nil})", bind("foo in (?)", [])
   end
 
   def test_bind_empty_string
-    quoted_empty = ActiveRecord::Base.connection.quote('')
-    assert_equal quoted_empty, bind('?', '')
+    quoted_empty = ActiveRecord::Base.connection.quote("")
+    assert_equal quoted_empty, bind("?", "")
   end
 
   def test_bind_chars
     quoted_bambi = ActiveRecord::Base.connection.quote("Bambi")
     quoted_bambi_and_thumper = ActiveRecord::Base.connection.quote("Bambi\nand\nThumper")
-    assert_equal "name=#{quoted_bambi}", bind('name=?', "Bambi")
-    assert_equal "name=#{quoted_bambi_and_thumper}", bind('name=?', "Bambi\nand\nThumper")
-    assert_equal "name=#{quoted_bambi}", bind('name=?', "Bambi".mb_chars)
-    assert_equal "name=#{quoted_bambi_and_thumper}", bind('name=?', "Bambi\nand\nThumper".mb_chars)
+    assert_equal "name=#{quoted_bambi}", bind("name=?", "Bambi")
+    assert_equal "name=#{quoted_bambi_and_thumper}", bind("name=?", "Bambi\nand\nThumper")
+    assert_equal "name=#{quoted_bambi}", bind("name=?", "Bambi".mb_chars)
+    assert_equal "name=#{quoted_bambi_and_thumper}", bind("name=?", "Bambi\nand\nThumper".mb_chars)
   end
 
   def test_bind_record
     o = Struct.new(:quoted_id).new(1)
-    assert_equal '1', bind('?', o)
+    assert_equal "1", bind("?", o)
 
     os = [o] * 3
-    assert_equal '1,1,1', bind('?', os)
+    assert_equal "1,1,1", bind("?", os)
   end
 
   def test_named_bind_with_postgresql_type_casts
-    l = Proc.new { bind(":a::integer '2009-01-01'::date", :a => '10') }
+    l = Proc.new { bind(":a::integer '2009-01-01'::date", :a => "10") }
     assert_nothing_raised(&l)
     assert_equal "#{ActiveRecord::Base.connection.quote('10')}::integer '2009-01-01'::date", l.call
   end
diff --git a/activerecord/test/cases/schema_dumper_test.rb b/activerecord/test/cases/schema_dumper_test.rb
index 12f4196724..cbc79109f7 100644
--- a/activerecord/test/cases/schema_dumper_test.rb
+++ b/activerecord/test/cases/schema_dumper_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 class SchemaDumperTest < ActiveRecord::TestCase
   include SchemaDumpingHelper
@@ -169,7 +169,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
   end
 
   def test_schema_dump_with_string_ignored_table
-    output = dump_all_table_schema(['accounts'])
+    output = dump_all_table_schema(["accounts"])
     assert_no_match %r{create_table "accounts"}, output
     assert_match %r{create_table "authors"}, output
     assert_no_match %r{create_table "schema_migrations"}, output
@@ -289,7 +289,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
       def test_schema_dump_includes_extensions
         connection = ActiveRecord::Base.connection
 
-        connection.stubs(:extensions).returns(['hstore'])
+        connection.stubs(:extensions).returns(["hstore"])
         output = perform_schema_dump
         assert_match "# These are extensions that must be enabled", output
         assert_match %r{enable_extension "hstore"}, output
@@ -359,8 +359,8 @@ class SchemaDumperTest < ActiveRecord::TestCase
 
   def test_schema_dump_with_table_name_prefix_and_suffix
     original, $stdout = $stdout, StringIO.new
-    ActiveRecord::Base.table_name_prefix = 'foo_'
-    ActiveRecord::Base.table_name_suffix = '_bar'
+    ActiveRecord::Base.table_name_prefix = "foo_"
+    ActiveRecord::Base.table_name_suffix = "_bar"
 
     migration = CreateDogMigration.new
     migration.migrate(:up)
@@ -378,7 +378,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
   ensure
     migration.migrate(:down)
 
-    ActiveRecord::Base.table_name_suffix = ActiveRecord::Base.table_name_prefix = ''
+    ActiveRecord::Base.table_name_suffix = ActiveRecord::Base.table_name_prefix = ""
     $stdout = original
   end
 
@@ -396,7 +396,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
 
     original_table_name_prefix = ActiveRecord::Base.table_name_prefix
     original_schema_dumper_ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
-    ActiveRecord::Base.table_name_prefix = 'omg_'
+    ActiveRecord::Base.table_name_prefix = "omg_"
     ActiveRecord::SchemaDumper.ignore_tables = ["cats"]
     migration = create_cat_migration.new
     migration.migrate(:up)
@@ -422,7 +422,7 @@ class SchemaDumperDefaultsTest < ActiveRecord::TestCase
     @connection = ActiveRecord::Base.connection
     @connection.create_table :defaults, force: true do |t|
       t.string   :string_with_default,   default: "Hello!"
-      t.date     :date_with_default,     default: '2014-06-05'
+      t.date     :date_with_default,     default: "2014-06-05"
       t.datetime :datetime_with_default, default: "2014-06-05 07:17:04"
       t.time     :time_with_default,     default: "07:17:04"
     end
@@ -430,11 +430,11 @@ class SchemaDumperDefaultsTest < ActiveRecord::TestCase
 
   teardown do
     return unless @connection
-    @connection.drop_table 'defaults', if_exists: true
+    @connection.drop_table "defaults", if_exists: true
   end
 
   def test_schema_dump_defaults_with_universally_supported_types
-    output = dump_table_schema('defaults')
+    output = dump_table_schema("defaults")
 
     assert_match %r{t\.string\s+"string_with_default",.*?default: "Hello!"}, output
     assert_match %r{t\.date\s+"date_with_default",\s+default: '2014-06-05'}, output
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
diff --git a/activerecord/test/cases/secure_token_test.rb b/activerecord/test/cases/secure_token_test.rb
index e731443fc2..eda0229c26 100644
--- a/activerecord/test/cases/secure_token_test.rb
+++ b/activerecord/test/cases/secure_token_test.rb
@@ -1,5 +1,5 @@
-require 'cases/helper'
-require 'models/user'
+require "cases/helper"
+require "models/user"
 
 class SecureTokenTest < ActiveRecord::TestCase
   setup do
diff --git a/activerecord/test/cases/serialization_test.rb b/activerecord/test/cases/serialization_test.rb
index 14b80f4df4..b4fdc1f30a 100644
--- a/activerecord/test/cases/serialization_test.rb
+++ b/activerecord/test/cases/serialization_test.rb
@@ -1,9 +1,9 @@
 require "cases/helper"
-require 'models/contact'
-require 'models/topic'
-require 'models/book'
-require 'models/author'
-require 'models/post'
+require "models/contact"
+require "models/topic"
+require "models/book"
+require "models/author"
+require "models/post"
 
 class SerializationTest < ActiveRecord::TestCase
   fixtures :books
@@ -12,12 +12,12 @@ class SerializationTest < ActiveRecord::TestCase
 
   def setup
     @contact_attributes = {
-      :name           => 'aaron stack',
+      :name           => "aaron stack",
       :age            => 25,
-      :avatar         => 'binarydata',
+      :avatar         => "binarydata",
       :created_at     => Time.utc(2006, 8, 1),
       :awesome        => false,
-      :preferences    => { :gem => '<strong>ruby</strong>' },
+      :preferences    => { :gem => "<strong>ruby</strong>" },
       :alternative_id => nil,
       :id             => nil
     }
@@ -60,7 +60,7 @@ class SerializationTest < ActiveRecord::TestCase
     ActiveRecord::Base.include_root_in_json = true
 
     klazz = Class.new(ActiveRecord::Base)
-    klazz.table_name = 'topics'
+    klazz.table_name = "topics"
     assert klazz.include_root_in_json
 
     klazz.include_root_in_json = false
@@ -73,7 +73,7 @@ class SerializationTest < ActiveRecord::TestCase
 
   def test_read_attribute_for_serialization_with_format_without_method_missing
     klazz = Class.new(ActiveRecord::Base)
-    klazz.table_name = 'books'
+    klazz.table_name = "books"
 
     book = klazz.new
     assert_nil book.read_attribute_for_serialization(:format)
@@ -81,18 +81,18 @@ class SerializationTest < ActiveRecord::TestCase
 
   def test_read_attribute_for_serialization_with_format_after_init
     klazz = Class.new(ActiveRecord::Base)
-    klazz.table_name = 'books'
+    klazz.table_name = "books"
 
-    book = klazz.new(format: 'paperback')
-    assert_equal 'paperback', book.read_attribute_for_serialization(:format)
+    book = klazz.new(format: "paperback")
+    assert_equal "paperback", book.read_attribute_for_serialization(:format)
   end
 
   def test_read_attribute_for_serialization_with_format_after_find
     klazz = Class.new(ActiveRecord::Base)
-    klazz.table_name = 'books'
+    klazz.table_name = "books"
 
     book = klazz.find(books(:awdr).id)
-    assert_equal 'paperback', book.read_attribute_for_serialization(:format)
+    assert_equal "paperback", book.read_attribute_for_serialization(:format)
   end
 
   def test_find_records_by_serialized_attributes_through_join
diff --git a/activerecord/test/cases/serialized_attribute_test.rb b/activerecord/test/cases/serialized_attribute_test.rb
index 846be857d0..f465e8e7e1 100644
--- a/activerecord/test/cases/serialized_attribute_test.rb
+++ b/activerecord/test/cases/serialized_attribute_test.rb
@@ -1,10 +1,10 @@
-require 'cases/helper'
-require 'models/topic'
-require 'models/reply'
-require 'models/person'
-require 'models/traffic_light'
-require 'models/post'
-require 'bcrypt'
+require "cases/helper"
+require "models/topic"
+require "models/reply"
+require "models/person"
+require "models/traffic_light"
+require "models/post"
+require "bcrypt"
 
 class SerializedAttributeTest < ActiveRecord::TestCase
   fixtures :topics, :posts
@@ -25,7 +25,7 @@ class SerializedAttributeTest < ActiveRecord::TestCase
   def test_serialized_attribute
     Topic.serialize("content", MyObject)
 
-    myobj = MyObject.new('value1', 'value2')
+    myobj = MyObject.new("value1", "value2")
     topic = Topic.create("content" => myobj)
     assert_equal(myobj, topic.content)
 
@@ -36,7 +36,7 @@ class SerializedAttributeTest < ActiveRecord::TestCase
   def test_serialized_attribute_in_base_class
     Topic.serialize("content", Hash)
 
-    hash = { 'content1' => 'value1', 'content2' => 'value2' }
+    hash = { "content1" => "value1", "content2" => "value2" }
     important_topic = ImportantTopic.create("content" => hash)
     assert_equal(hash, important_topic.content)
 
@@ -97,7 +97,7 @@ class SerializedAttributeTest < ActiveRecord::TestCase
   end
 
   def test_serialized_attribute_declared_in_subclass
-    hash = { 'important1' => 'value1', 'important2' => 'value2' }
+    hash = { "important1" => "value1", "important2" => "value2" }
     important_topic = ImportantTopic.create("important" => hash)
     assert_equal(hash, important_topic.important)
 
@@ -137,12 +137,12 @@ class SerializedAttributeTest < ActiveRecord::TestCase
   def test_serialized_attribute_should_raise_exception_on_assignment_with_wrong_type
     Topic.serialize(:content, Hash)
     assert_raise(ActiveRecord::SerializationTypeMismatch) do
-      Topic.new(content: 'string')
+      Topic.new(content: "string")
     end
   end
 
   def test_should_raise_exception_on_serialized_attribute_with_type_mismatch
-    myobj = MyObject.new('value1', 'value2')
+    myobj = MyObject.new("value1", "value2")
     topic = Topic.new(:content => myobj)
     assert topic.save
     Topic.serialize(:content, Hash)
@@ -200,18 +200,18 @@ class SerializedAttributeTest < ActiveRecord::TestCase
     end
 
     Topic.serialize(:content, some_class)
-    topic = Topic.new(:content => some_class.new('my value'))
+    topic = Topic.new(:content => some_class.new("my value"))
     topic.save!
     topic.reload
     assert_kind_of some_class, topic.content
-    assert_equal topic.content, some_class.new('my value')
+    assert_equal topic.content, some_class.new("my value")
   end
 
   def test_serialize_attribute_via_select_method_when_time_zone_available
     with_timezone_config aware_attributes: true do
       Topic.serialize(:content, MyObject)
 
-      myobj = MyObject.new('value1', 'value2')
+      myobj = MyObject.new("value1", "value2")
       topic = Topic.create(content: myobj)
 
       assert_equal(myobj, Topic.select(:content).find(topic.id).content)
@@ -220,8 +220,8 @@ class SerializedAttributeTest < ActiveRecord::TestCase
   end
 
   def test_serialize_attribute_can_be_serialized_in_an_integer_column
-    insures = ['life']
-    person = SerializedPerson.new(first_name: 'David', insures: insures)
+    insures = ["life"]
+    person = SerializedPerson.new(first_name: "David", insures: insures)
     assert person.save
     person = person.reload
     assert_equal(insures, person.insures)
diff --git a/activerecord/test/cases/statement_cache_test.rb b/activerecord/test/cases/statement_cache_test.rb
index 104226010a..e5755d55ed 100644
--- a/activerecord/test/cases/statement_cache_test.rb
+++ b/activerecord/test/cases/statement_cache_test.rb
@@ -1,8 +1,8 @@
-require 'cases/helper'
-require 'models/book'
-require 'models/liquid'
-require 'models/molecule'
-require 'models/electron'
+require "cases/helper"
+require "models/book"
+require "models/liquid"
+require "models/molecule"
+require "models/electron"
 
 module ActiveRecord
   class StatementCacheTest < ActiveRecord::TestCase
@@ -65,12 +65,12 @@ module ActiveRecord
 
     def test_statement_cache_with_complex_statement
       cache = ActiveRecord::StatementCache.create(Book.connection) do |params|
-        Liquid.joins(:molecules => :electrons).where('molecules.name' => 'dioxane', 'electrons.name' => 'lepton')
+        Liquid.joins(:molecules => :electrons).where("molecules.name" => "dioxane", "electrons.name" => "lepton")
       end
 
-      salty = Liquid.create(name: 'salty')
-      molecule = salty.molecules.create(name: 'dioxane')
-      molecule.electrons.create(name: 'lepton')
+      salty = Liquid.create(name: "salty")
+      molecule = salty.molecules.create(name: "dioxane")
+      molecule.electrons.create(name: "lepton")
 
       liquids = cache.execute([], Book, Book.connection)
       assert_equal "salty", liquids[0].name
diff --git a/activerecord/test/cases/store_test.rb b/activerecord/test/cases/store_test.rb
index bce86875e1..44275d3280 100644
--- a/activerecord/test/cases/store_test.rb
+++ b/activerecord/test/cases/store_test.rb
@@ -1,55 +1,55 @@
-require 'cases/helper'
-require 'models/admin'
-require 'models/admin/user'
+require "cases/helper"
+require "models/admin"
+require "models/admin/user"
 
 class StoreTest < ActiveRecord::TestCase
   fixtures :'admin/users'
 
   setup do
-    @john = Admin::User.create!(:name => 'John Doe', :color => 'black', :remember_login => true, :height => 'tall', :is_a_good_guy => true)
+    @john = Admin::User.create!(:name => "John Doe", :color => "black", :remember_login => true, :height => "tall", :is_a_good_guy => true)
   end
 
   test "reading store attributes through accessors" do
-    assert_equal 'black', @john.color
+    assert_equal "black", @john.color
     assert_nil @john.homepage
   end
 
   test "writing store attributes through accessors" do
-    @john.color = 'red'
-    @john.homepage = '37signals.com'
+    @john.color = "red"
+    @john.homepage = "37signals.com"
 
-    assert_equal 'red', @john.color
-    assert_equal '37signals.com', @john.homepage
+    assert_equal "red", @john.color
+    assert_equal "37signals.com", @john.homepage
   end
 
   test "accessing attributes not exposed by accessors" do
-    @john.settings[:icecream] = 'graeters'
+    @john.settings[:icecream] = "graeters"
     @john.save
 
-    assert_equal 'graeters', @john.reload.settings[:icecream]
+    assert_equal "graeters", @john.reload.settings[:icecream]
   end
 
   test "overriding a read accessor" do
-    @john.settings[:phone_number] = '1234567890'
+    @john.settings[:phone_number] = "1234567890"
 
-    assert_equal '(123) 456-7890', @john.phone_number
+    assert_equal "(123) 456-7890", @john.phone_number
   end
 
   test "overriding a read accessor using super" do
     @john.settings[:color] = nil
 
-    assert_equal 'red', @john.color
+    assert_equal "red", @john.color
   end
 
   test "updating the store will mark it as changed" do
-    @john.color = 'red'
+    @john.color = "red"
     assert @john.settings_changed?
   end
 
   test "updating the store populates the changed array correctly" do
-    @john.color = 'red'
-    assert_equal 'black', @john.settings_change[0]['color']
-    assert_equal 'red', @john.settings_change[1]['color']
+    @john.color = "red"
+    assert_equal "black", @john.settings_change[0]["color"]
+    assert_equal "red", @john.settings_change[1]["color"]
   end
 
   test "updating the store won't mark it as changed if an attribute isn't changed" do
@@ -67,74 +67,74 @@ class StoreTest < ActiveRecord::TestCase
   end
 
   test "overriding a write accessor" do
-    @john.phone_number = '(123) 456-7890'
+    @john.phone_number = "(123) 456-7890"
 
-    assert_equal '1234567890', @john.settings[:phone_number]
+    assert_equal "1234567890", @john.settings[:phone_number]
   end
 
   test "overriding a write accessor using super" do
-    @john.color = 'yellow'
+    @john.color = "yellow"
 
-    assert_equal 'blue', @john.color
+    assert_equal "blue", @john.color
   end
 
   test "preserve store attributes data in HashWithIndifferentAccess format without any conversion" do
-    @john.json_data = ActiveSupport::HashWithIndifferentAccess.new(:height => 'tall', 'weight' => 'heavy')
-    @john.height = 'low'
+    @john.json_data = ActiveSupport::HashWithIndifferentAccess.new(:height => "tall", "weight" => "heavy")
+    @john.height = "low"
     assert_equal true, @john.json_data.instance_of?(ActiveSupport::HashWithIndifferentAccess)
-    assert_equal 'low', @john.json_data[:height]
-    assert_equal 'low', @john.json_data['height']
-    assert_equal 'heavy', @john.json_data[:weight]
-    assert_equal 'heavy', @john.json_data['weight']
+    assert_equal "low", @john.json_data[:height]
+    assert_equal "low", @john.json_data["height"]
+    assert_equal "heavy", @john.json_data[:weight]
+    assert_equal "heavy", @john.json_data["weight"]
   end
 
   test "convert store attributes from Hash to HashWithIndifferentAccess saving the data and access attributes indifferently" do
-    user = Admin::User.find_by_name('Jamis')
-    assert_equal 'symbol',  user.settings[:symbol]
-    assert_equal 'symbol',  user.settings['symbol']
-    assert_equal 'string',  user.settings[:string]
-    assert_equal 'string',  user.settings['string']
+    user = Admin::User.find_by_name("Jamis")
+    assert_equal "symbol",  user.settings[:symbol]
+    assert_equal "symbol",  user.settings["symbol"]
+    assert_equal "string",  user.settings[:string]
+    assert_equal "string",  user.settings["string"]
     assert_equal true,      user.settings.instance_of?(ActiveSupport::HashWithIndifferentAccess)
 
-    user.height = 'low'
-    assert_equal 'symbol',  user.settings[:symbol]
-    assert_equal 'symbol',  user.settings['symbol']
-    assert_equal 'string',  user.settings[:string]
-    assert_equal 'string',  user.settings['string']
+    user.height = "low"
+    assert_equal "symbol",  user.settings[:symbol]
+    assert_equal "symbol",  user.settings["symbol"]
+    assert_equal "string",  user.settings[:string]
+    assert_equal "string",  user.settings["string"]
     assert_equal true,      user.settings.instance_of?(ActiveSupport::HashWithIndifferentAccess)
   end
 
   test "convert store attributes from any format other than Hash or HashWithIndifferentAccess losing the data" do
     @john.json_data = "somedata"
-    @john.height = 'low'
+    @john.height = "low"
     assert_equal true, @john.json_data.instance_of?(ActiveSupport::HashWithIndifferentAccess)
-    assert_equal 'low', @john.json_data[:height]
-    assert_equal 'low', @john.json_data['height']
-    assert_equal false, @john.json_data.delete_if { |k, v| k == 'height' }.any?
+    assert_equal "low", @john.json_data[:height]
+    assert_equal "low", @john.json_data["height"]
+    assert_equal false, @john.json_data.delete_if { |k, v| k == "height" }.any?
   end
 
   test "reading store attributes through accessors encoded with JSON" do
-    assert_equal 'tall', @john.height
+    assert_equal "tall", @john.height
     assert_nil @john.weight
   end
 
   test "writing store attributes through accessors encoded with JSON" do
-    @john.height = 'short'
-    @john.weight = 'heavy'
+    @john.height = "short"
+    @john.weight = "heavy"
 
-    assert_equal 'short', @john.height
-    assert_equal 'heavy', @john.weight
+    assert_equal "short", @john.height
+    assert_equal "heavy", @john.weight
   end
 
   test "accessing attributes not exposed by accessors encoded with JSON" do
-    @john.json_data['somestuff'] = 'somecoolstuff'
+    @john.json_data["somestuff"] = "somecoolstuff"
     @john.save
 
-    assert_equal 'somecoolstuff', @john.reload.json_data['somestuff']
+    assert_equal "somecoolstuff", @john.reload.json_data["somestuff"]
   end
 
   test "updating the store will mark it as changed encoded with JSON" do
-    @john.height = 'short'
+    @john.height = "short"
     assert @john.json_data_changed?
   end
 
diff --git a/activerecord/test/cases/suppressor_test.rb b/activerecord/test/cases/suppressor_test.rb
index 2f00241de2..64f39d8574 100644
--- a/activerecord/test/cases/suppressor_test.rb
+++ b/activerecord/test/cases/suppressor_test.rb
@@ -1,6 +1,6 @@
-require 'cases/helper'
-require 'models/notification'
-require 'models/user'
+require "cases/helper"
+require "models/notification"
+require "models/user"
 
 class SuppressorTest < ActiveRecord::TestCase
   def test_suppresses_create
@@ -15,22 +15,22 @@ class SuppressorTest < ActiveRecord::TestCase
   end
 
   def test_suppresses_update
-    user = User.create! token: 'asdf'
+    user = User.create! token: "asdf"
 
     User.suppress do
-      user.update token: 'ghjkl'
-      assert_equal 'asdf', user.reload.token
+      user.update token: "ghjkl"
+      assert_equal "asdf", user.reload.token
 
-      user.update! token: 'zxcvbnm'
-      assert_equal 'asdf', user.reload.token
+      user.update! token: "zxcvbnm"
+      assert_equal "asdf", user.reload.token
 
-      user.token = 'qwerty'
+      user.token = "qwerty"
       user.save
-      assert_equal 'asdf', user.reload.token
+      assert_equal "asdf", user.reload.token
 
-      user.token = 'uiop'
+      user.token = "uiop"
       user.save!
-      assert_equal 'asdf', user.reload.token
+      assert_equal "asdf", user.reload.token
     end
   end
 
diff --git a/activerecord/test/cases/tasks/database_tasks_test.rb b/activerecord/test/cases/tasks/database_tasks_test.rb
index 510bb088c8..946d337572 100644
--- a/activerecord/test/cases/tasks/database_tasks_test.rb
+++ b/activerecord/test/cases/tasks/database_tasks_test.rb
@@ -1,5 +1,5 @@
-require 'cases/helper'
-require 'active_record/tasks/database_tasks'
+require "cases/helper"
+require "active_record/tasks/database_tasks"
 
 module ActiveRecord
   module DatabaseTasksSetupper
@@ -64,12 +64,12 @@ module ActiveRecord
       instance.expects(:structure_dump).with("awesome-file.sql")
 
       ActiveRecord::Tasks::DatabaseTasks.register_task(/foo/, klazz)
-      ActiveRecord::Tasks::DatabaseTasks.structure_dump({'adapter' => :foo}, "awesome-file.sql")
+      ActiveRecord::Tasks::DatabaseTasks.structure_dump({"adapter" => :foo}, "awesome-file.sql")
     end
 
     def test_unregistered_task
       assert_raise(ActiveRecord::Tasks::DatabaseNotSupported) do
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump({'adapter' => :bar}, "awesome-file.sql")
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump({"adapter" => :bar}, "awesome-file.sql")
       end
     end
   end
@@ -80,20 +80,20 @@ module ActiveRecord
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_create") do
         eval("@#{v}").expects(:create)
-        ActiveRecord::Tasks::DatabaseTasks.create 'adapter' => k
+        ActiveRecord::Tasks::DatabaseTasks.create "adapter" => k
       end
     end
   end
 
   class DatabaseTasksCreateAllTest < ActiveRecord::TestCase
     def setup
-      @configurations = {'development' => {'database' => 'my-db'}}
+      @configurations = {"development" => {"database" => "my-db"}}
 
       ActiveRecord::Base.stubs(:configurations).returns(@configurations)
     end
 
     def test_ignores_configurations_without_databases
-      @configurations['development'].merge!('database' => nil)
+      @configurations["development"].merge!("database" => nil)
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:create).never
 
@@ -101,7 +101,7 @@ module ActiveRecord
     end
 
     def test_ignores_remote_databases
-      @configurations['development'].merge!('host' => 'my.server.tld')
+      @configurations["development"].merge!("host" => "my.server.tld")
       $stderr.stubs(:puts).returns(nil)
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:create).never
@@ -110,15 +110,15 @@ module ActiveRecord
     end
 
     def test_warning_for_remote_databases
-      @configurations['development'].merge!('host' => 'my.server.tld')
+      @configurations["development"].merge!("host" => "my.server.tld")
 
-      $stderr.expects(:puts).with('This task only modifies local databases. my-db is on a remote host.')
+      $stderr.expects(:puts).with("This task only modifies local databases. my-db is on a remote host.")
 
       ActiveRecord::Tasks::DatabaseTasks.create_all
     end
 
     def test_creates_configurations_with_local_ip
-      @configurations['development'].merge!('host' => '127.0.0.1')
+      @configurations["development"].merge!("host" => "127.0.0.1")
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:create)
 
@@ -126,7 +126,7 @@ module ActiveRecord
     end
 
     def test_creates_configurations_with_local_host
-      @configurations['development'].merge!('host' => 'localhost')
+      @configurations["development"].merge!("host" => "localhost")
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:create)
 
@@ -134,7 +134,7 @@ module ActiveRecord
     end
 
     def test_creates_configurations_with_blank_hosts
-      @configurations['development'].merge!('host' => nil)
+      @configurations["development"].merge!("host" => nil)
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:create)
 
@@ -145,9 +145,9 @@ module ActiveRecord
   class DatabaseTasksCreateCurrentTest < ActiveRecord::TestCase
     def setup
       @configurations = {
-        'development' => {'database' => 'dev-db'},
-        'test'        => {'database' => 'test-db'},
-        'production'  => {'database' => 'prod-db'}
+        "development" => {"database" => "dev-db"},
+        "test"        => {"database" => "test-db"},
+        "production"  => {"database" => "prod-db"}
       }
 
       ActiveRecord::Base.stubs(:configurations).returns(@configurations)
@@ -156,37 +156,37 @@ module ActiveRecord
 
     def test_creates_current_environment_database
       ActiveRecord::Tasks::DatabaseTasks.expects(:create).
-        with('database' => 'prod-db')
+        with("database" => "prod-db")
 
       ActiveRecord::Tasks::DatabaseTasks.create_current(
-        ActiveSupport::StringInquirer.new('production')
+        ActiveSupport::StringInquirer.new("production")
       )
     end
 
     def test_creates_test_and_development_databases_when_env_was_not_specified
       ActiveRecord::Tasks::DatabaseTasks.expects(:create).
-        with('database' => 'dev-db')
+        with("database" => "dev-db")
       ActiveRecord::Tasks::DatabaseTasks.expects(:create).
-        with('database' => 'test-db')
+        with("database" => "test-db")
 
       ActiveRecord::Tasks::DatabaseTasks.create_current(
-        ActiveSupport::StringInquirer.new('development')
+        ActiveSupport::StringInquirer.new("development")
       )
     end
 
     def test_creates_test_and_development_databases_when_rails_env_is_development
-      old_env = ENV['RAILS_ENV']
-      ENV['RAILS_ENV'] = 'development'
+      old_env = ENV["RAILS_ENV"]
+      ENV["RAILS_ENV"] = "development"
       ActiveRecord::Tasks::DatabaseTasks.expects(:create).
-        with('database' => 'dev-db')
+        with("database" => "dev-db")
       ActiveRecord::Tasks::DatabaseTasks.expects(:create).
-        with('database' => 'test-db')
+        with("database" => "test-db")
 
       ActiveRecord::Tasks::DatabaseTasks.create_current(
-        ActiveSupport::StringInquirer.new('development')
+        ActiveSupport::StringInquirer.new("development")
       )
     ensure
-      ENV['RAILS_ENV'] = old_env
+      ENV["RAILS_ENV"] = old_env
     end
 
     def test_establishes_connection_for_the_given_environment
@@ -195,7 +195,7 @@ module ActiveRecord
       ActiveRecord::Base.expects(:establish_connection).with(:development)
 
       ActiveRecord::Tasks::DatabaseTasks.create_current(
-        ActiveSupport::StringInquirer.new('development')
+        ActiveSupport::StringInquirer.new("development")
       )
     end
   end
@@ -206,20 +206,20 @@ module ActiveRecord
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_drop") do
         eval("@#{v}").expects(:drop)
-        ActiveRecord::Tasks::DatabaseTasks.drop 'adapter' => k
+        ActiveRecord::Tasks::DatabaseTasks.drop "adapter" => k
       end
     end
   end
 
   class DatabaseTasksDropAllTest < ActiveRecord::TestCase
     def setup
-      @configurations = {:development => {'database' => 'my-db'}}
+      @configurations = {:development => {"database" => "my-db"}}
 
       ActiveRecord::Base.stubs(:configurations).returns(@configurations)
     end
 
     def test_ignores_configurations_without_databases
-      @configurations[:development].merge!('database' => nil)
+      @configurations[:development].merge!("database" => nil)
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop).never
 
@@ -227,7 +227,7 @@ module ActiveRecord
     end
 
     def test_ignores_remote_databases
-      @configurations[:development].merge!('host' => 'my.server.tld')
+      @configurations[:development].merge!("host" => "my.server.tld")
       $stderr.stubs(:puts).returns(nil)
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop).never
@@ -236,15 +236,15 @@ module ActiveRecord
     end
 
     def test_warning_for_remote_databases
-      @configurations[:development].merge!('host' => 'my.server.tld')
+      @configurations[:development].merge!("host" => "my.server.tld")
 
-      $stderr.expects(:puts).with('This task only modifies local databases. my-db is on a remote host.')
+      $stderr.expects(:puts).with("This task only modifies local databases. my-db is on a remote host.")
 
       ActiveRecord::Tasks::DatabaseTasks.drop_all
     end
 
     def test_drops_configurations_with_local_ip
-      @configurations[:development].merge!('host' => '127.0.0.1')
+      @configurations[:development].merge!("host" => "127.0.0.1")
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop)
 
@@ -252,7 +252,7 @@ module ActiveRecord
     end
 
     def test_drops_configurations_with_local_host
-      @configurations[:development].merge!('host' => 'localhost')
+      @configurations[:development].merge!("host" => "localhost")
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop)
 
@@ -260,7 +260,7 @@ module ActiveRecord
     end
 
     def test_drops_configurations_with_blank_hosts
-      @configurations[:development].merge!('host' => nil)
+      @configurations[:development].merge!("host" => nil)
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop)
 
@@ -271,9 +271,9 @@ module ActiveRecord
   class DatabaseTasksDropCurrentTest < ActiveRecord::TestCase
     def setup
       @configurations = {
-        'development' => {'database' => 'dev-db'},
-        'test'        => {'database' => 'test-db'},
-        'production'  => {'database' => 'prod-db'}
+        "development" => {"database" => "dev-db"},
+        "test"        => {"database" => "test-db"},
+        "production"  => {"database" => "prod-db"}
       }
 
       ActiveRecord::Base.stubs(:configurations).returns(@configurations)
@@ -281,37 +281,37 @@ module ActiveRecord
 
     def test_drops_current_environment_database
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop).
-        with('database' => 'prod-db')
+        with("database" => "prod-db")
 
       ActiveRecord::Tasks::DatabaseTasks.drop_current(
-        ActiveSupport::StringInquirer.new('production')
+        ActiveSupport::StringInquirer.new("production")
       )
     end
 
     def test_drops_test_and_development_databases_when_env_was_not_specified
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop).
-        with('database' => 'dev-db')
+        with("database" => "dev-db")
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop).
-        with('database' => 'test-db')
+        with("database" => "test-db")
 
       ActiveRecord::Tasks::DatabaseTasks.drop_current(
-        ActiveSupport::StringInquirer.new('development')
+        ActiveSupport::StringInquirer.new("development")
       )
     end
 
     def test_drops_testand_development_databases_when_rails_env_is_development
-      old_env = ENV['RAILS_ENV']
-      ENV['RAILS_ENV'] = 'development'
+      old_env = ENV["RAILS_ENV"]
+      ENV["RAILS_ENV"] = "development"
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop).
-        with('database' => 'dev-db')
+        with("database" => "dev-db")
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop).
-        with('database' => 'test-db')
+        with("database" => "test-db")
 
       ActiveRecord::Tasks::DatabaseTasks.drop_current(
-        ActiveSupport::StringInquirer.new('development')
+        ActiveSupport::StringInquirer.new("development")
       )
     ensure
-      ENV['RAILS_ENV'] = old_env
+      ENV["RAILS_ENV"] = old_env
     end
   end
 
@@ -319,7 +319,7 @@ module ActiveRecord
     self.use_transactional_tests = false
 
     def setup
-      ActiveRecord::Tasks::DatabaseTasks.migrations_paths = 'custom/path'
+      ActiveRecord::Tasks::DatabaseTasks.migrations_paths = "custom/path"
     end
 
     def teardown
@@ -327,15 +327,15 @@ module ActiveRecord
     end
 
     def test_migrate_receives_correct_env_vars
-      verbose, version = ENV['VERBOSE'], ENV['VERSION']
+      verbose, version = ENV["VERBOSE"], ENV["VERSION"]
 
-      ENV['VERBOSE'] = 'false'
-      ENV['VERSION'] = '4'
+      ENV["VERBOSE"] = "false"
+      ENV["VERSION"] = "4"
 
-      ActiveRecord::Migrator.expects(:migrate).with('custom/path', 4)
+      ActiveRecord::Migrator.expects(:migrate).with("custom/path", 4)
       ActiveRecord::Tasks::DatabaseTasks.migrate
     ensure
-      ENV['VERBOSE'], ENV['VERSION'] = verbose, version
+      ENV["VERBOSE"], ENV["VERSION"] = verbose, version
     end
 
     def test_migrate_clears_schema_cache_afterward
@@ -350,7 +350,7 @@ module ActiveRecord
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_purge") do
         eval("@#{v}").expects(:purge)
-        ActiveRecord::Tasks::DatabaseTasks.purge 'adapter' => k
+        ActiveRecord::Tasks::DatabaseTasks.purge "adapter" => k
       end
     end
   end
@@ -358,27 +358,27 @@ module ActiveRecord
   class DatabaseTasksPurgeCurrentTest < ActiveRecord::TestCase
     def test_purges_current_environment_database
       configurations = {
-        'development' => {'database' => 'dev-db'},
-        'test'        => {'database' => 'test-db'},
-        'production'  => {'database' => 'prod-db'}
+        "development" => {"database" => "dev-db"},
+        "test"        => {"database" => "test-db"},
+        "production"  => {"database" => "prod-db"}
       }
       ActiveRecord::Base.stubs(:configurations).returns(configurations)
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:purge).
-        with('database' => 'prod-db')
+        with("database" => "prod-db")
       ActiveRecord::Base.expects(:establish_connection).with(:production)
 
-      ActiveRecord::Tasks::DatabaseTasks.purge_current('production')
+      ActiveRecord::Tasks::DatabaseTasks.purge_current("production")
     end
   end
 
   class DatabaseTasksPurgeAllTest < ActiveRecord::TestCase
     def test_purge_all_local_configurations
-      configurations = {:development => {'database' => 'my-db'}}
+      configurations = {:development => {"database" => "my-db"}}
       ActiveRecord::Base.stubs(:configurations).returns(configurations)
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:purge).
-        with('database' => 'my-db')
+        with("database" => "my-db")
 
       ActiveRecord::Tasks::DatabaseTasks.purge_all
     end
@@ -390,7 +390,7 @@ module ActiveRecord
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_charset") do
         eval("@#{v}").expects(:charset)
-        ActiveRecord::Tasks::DatabaseTasks.charset 'adapter' => k
+        ActiveRecord::Tasks::DatabaseTasks.charset "adapter" => k
       end
     end
   end
@@ -401,7 +401,7 @@ module ActiveRecord
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_collation") do
         eval("@#{v}").expects(:collation)
-        ActiveRecord::Tasks::DatabaseTasks.collation 'adapter' => k
+        ActiveRecord::Tasks::DatabaseTasks.collation "adapter" => k
       end
     end
   end
@@ -412,7 +412,7 @@ module ActiveRecord
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_structure_dump") do
         eval("@#{v}").expects(:structure_dump).with("awesome-file.sql")
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump({'adapter' => k}, "awesome-file.sql")
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump({"adapter" => k}, "awesome-file.sql")
       end
     end
   end
@@ -423,7 +423,7 @@ module ActiveRecord
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_structure_load") do
         eval("@#{v}").expects(:structure_load).with("awesome-file.sql")
-        ActiveRecord::Tasks::DatabaseTasks.structure_load({'adapter' => k}, "awesome-file.sql")
+        ActiveRecord::Tasks::DatabaseTasks.structure_load({"adapter" => k}, "awesome-file.sql")
       end
     end
   end
@@ -437,15 +437,15 @@ module ActiveRecord
 
   class DatabaseTasksCheckSchemaFileDefaultsTest < ActiveRecord::TestCase
     def test_check_schema_file_defaults
-      ActiveRecord::Tasks::DatabaseTasks.stubs(:db_dir).returns('/tmp')
-      assert_equal '/tmp/schema.rb', ActiveRecord::Tasks::DatabaseTasks.schema_file
+      ActiveRecord::Tasks::DatabaseTasks.stubs(:db_dir).returns("/tmp")
+      assert_equal "/tmp/schema.rb", ActiveRecord::Tasks::DatabaseTasks.schema_file
     end
   end
 
   class DatabaseTasksCheckSchemaFileSpecifiedFormatsTest < ActiveRecord::TestCase
-    {ruby: 'schema.rb', sql: 'structure.sql'}.each_pair do |fmt, filename|
+    {ruby: "schema.rb", sql: "structure.sql"}.each_pair do |fmt, filename|
       define_method("test_check_schema_file_for_#{fmt}_format") do
-        ActiveRecord::Tasks::DatabaseTasks.stubs(:db_dir).returns('/tmp')
+        ActiveRecord::Tasks::DatabaseTasks.stubs(:db_dir).returns("/tmp")
         assert_equal "/tmp/#{filename}", ActiveRecord::Tasks::DatabaseTasks.schema_file(fmt)
       end
     end
diff --git a/activerecord/test/cases/tasks/mysql_rake_test.rb b/activerecord/test/cases/tasks/mysql_rake_test.rb
index 70e406038f..16ed83b072 100644
--- a/activerecord/test/cases/tasks/mysql_rake_test.rb
+++ b/activerecord/test/cases/tasks/mysql_rake_test.rb
@@ -1,5 +1,5 @@
-require 'cases/helper'
-require 'active_record/tasks/database_tasks'
+require "cases/helper"
+require "active_record/tasks/database_tasks"
 
 if current_adapter?(:Mysql2Adapter)
 module ActiveRecord
@@ -7,8 +7,8 @@ module ActiveRecord
     def setup
       @connection    = stub(:create_database => true)
       @configuration = {
-        'adapter'  => 'mysql2',
-        'database' => 'my-app-db'
+        "adapter"  => "mysql2",
+        "database" => "my-app-db"
       }
 
       ActiveRecord::Base.stubs(:connection).returns(@connection)
@@ -24,30 +24,30 @@ module ActiveRecord
 
     def test_establishes_connection_without_database
       ActiveRecord::Base.expects(:establish_connection).
-        with('adapter' => 'mysql2', 'database' => nil)
+        with("adapter" => "mysql2", "database" => nil)
 
       ActiveRecord::Tasks::DatabaseTasks.create @configuration
     end
 
     def test_creates_database_with_no_default_options
       @connection.expects(:create_database).
-        with('my-app-db', {})
+        with("my-app-db", {})
 
       ActiveRecord::Tasks::DatabaseTasks.create @configuration
     end
 
     def test_creates_database_with_given_encoding
       @connection.expects(:create_database).
-        with('my-app-db', charset: 'latin1')
+        with("my-app-db", charset: "latin1")
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration.merge('encoding' => 'latin1')
+      ActiveRecord::Tasks::DatabaseTasks.create @configuration.merge("encoding" => "latin1")
     end
 
     def test_creates_database_with_given_collation
       @connection.expects(:create_database).
-        with('my-app-db', collation: 'latin1_swedish_ci')
+        with("my-app-db", collation: "latin1_swedish_ci")
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration.merge('collation' => 'latin1_swedish_ci')
+      ActiveRecord::Tasks::DatabaseTasks.create @configuration.merge("collation" => "latin1_swedish_ci")
     end
 
     def test_establishes_connection_to_database
@@ -78,10 +78,10 @@ module ActiveRecord
       @connection    = stub("Connection", create_database: true)
       @error         = Mysql2::Error.new("Invalid permissions")
       @configuration = {
-        'adapter'  => 'mysql2',
-        'database' => 'my-app-db',
-        'username' => 'pat',
-        'password' => 'wossname'
+        "adapter"  => "mysql2",
+        "database" => "my-app-db",
+        "username" => "pat",
+        "password" => "wossname"
       }
 
       $stdin.stubs(:gets).returns("secret\n")
@@ -110,10 +110,10 @@ module ActiveRecord
     def test_connection_established_as_root
       assert_permissions_granted_for("pat")
       ActiveRecord::Base.expects(:establish_connection).with(
-        'adapter'  => 'mysql2',
-        'database' => nil,
-        'username' => 'root',
-        'password' => 'secret'
+        "adapter"  => "mysql2",
+        "database" => nil,
+        "username" => "root",
+        "password" => "secret"
       )
 
       ActiveRecord::Tasks::DatabaseTasks.create @configuration
@@ -122,7 +122,7 @@ module ActiveRecord
     def test_database_created_by_root
       assert_permissions_granted_for("pat")
       @connection.expects(:create_database).
-        with('my-app-db', {})
+        with("my-app-db", {})
 
       ActiveRecord::Tasks::DatabaseTasks.create @configuration
     end
@@ -133,8 +133,8 @@ module ActiveRecord
     end
 
     def test_do_not_grant_privileges_for_root_user
-      @configuration['username'] = 'root'
-      @configuration['password'] = ''
+      @configuration["username"] = "root"
+      @configuration["password"] = ""
       ActiveRecord::Tasks::DatabaseTasks.create @configuration
     end
 
@@ -142,10 +142,10 @@ module ActiveRecord
       assert_permissions_granted_for("pat")
       ActiveRecord::Base.expects(:establish_connection).returns do
         ActiveRecord::Base.expects(:establish_connection).with(
-          'adapter'  => 'mysql2',
-          'database' => 'my-app-db',
-          'username' => 'pat',
-          'password' => 'secret'
+          "adapter"  => "mysql2",
+          "database" => "my-app-db",
+          "username" => "pat",
+          "password" => "secret"
         )
 
         raise @error
@@ -165,8 +165,8 @@ module ActiveRecord
     private
 
     def assert_permissions_granted_for(db_user)
-      db_name = @configuration['database']
-      db_password = @configuration['password']
+      db_name = @configuration["database"]
+      db_password = @configuration["password"]
       @connection.expects(:execute).with("GRANT ALL PRIVILEGES ON #{db_name}.* TO '#{db_user}'@'localhost' IDENTIFIED BY '#{db_password}' WITH GRANT OPTION;")
     end
   end
@@ -175,8 +175,8 @@ module ActiveRecord
     def setup
       @connection    = stub(:drop_database => true)
       @configuration = {
-        'adapter'  => 'mysql2',
-        'database' => 'my-app-db'
+        "adapter"  => "mysql2",
+        "database" => "my-app-db"
       }
 
       ActiveRecord::Base.stubs(:connection).returns(@connection)
@@ -197,7 +197,7 @@ module ActiveRecord
     end
 
     def test_drops_database
-      @connection.expects(:drop_database).with('my-app-db')
+      @connection.expects(:drop_database).with("my-app-db")
 
       ActiveRecord::Tasks::DatabaseTasks.drop @configuration
     end
@@ -213,8 +213,8 @@ module ActiveRecord
     def setup
       @connection    = stub(:recreate_database => true)
       @configuration = {
-        'adapter'  => 'mysql2',
-        'database' => 'test-db'
+        "adapter"  => "mysql2",
+        "database" => "test-db"
       }
 
       ActiveRecord::Base.stubs(:connection).returns(@connection)
@@ -229,17 +229,17 @@ module ActiveRecord
 
     def test_recreates_database_with_no_default_options
       @connection.expects(:recreate_database).
-        with('test-db', {})
+        with("test-db", {})
 
       ActiveRecord::Tasks::DatabaseTasks.purge @configuration
     end
 
     def test_recreates_database_with_the_given_options
       @connection.expects(:recreate_database).
-        with('test-db', charset: 'latin', collation: 'latin1_swedish_ci')
+        with("test-db", charset: "latin", collation: "latin1_swedish_ci")
 
       ActiveRecord::Tasks::DatabaseTasks.purge @configuration.merge(
-        'encoding' => 'latin', 'collation' => 'latin1_swedish_ci')
+        "encoding" => "latin", "collation" => "latin1_swedish_ci")
     end
   end
 
@@ -247,8 +247,8 @@ module ActiveRecord
     def setup
       @connection    = stub(:create_database => true)
       @configuration = {
-        'adapter'  => 'mysql2',
-        'database' => 'my-app-db'
+        "adapter"  => "mysql2",
+        "database" => "my-app-db"
       }
 
       ActiveRecord::Base.stubs(:connection).returns(@connection)
@@ -265,8 +265,8 @@ module ActiveRecord
     def setup
       @connection    = stub(:create_database => true)
       @configuration = {
-        'adapter'  => 'mysql2',
-        'database' => 'my-app-db'
+        "adapter"  => "mysql2",
+        "database" => "my-app-db"
       }
 
       ActiveRecord::Base.stubs(:connection).returns(@connection)
@@ -282,8 +282,8 @@ module ActiveRecord
   class MySQLStructureDumpTest < ActiveRecord::TestCase
     def setup
       @configuration = {
-        'adapter'  => 'mysql2',
-        'database' => 'test-db'
+        "adapter"  => "mysql2",
+        "database" => "test-db"
       }
     end
 
@@ -311,7 +311,7 @@ module ActiveRecord
       Kernel.expects(:system).with("mysqldump", "--port=10000", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db").returns(true)
 
       ActiveRecord::Tasks::DatabaseTasks.structure_dump(
-        @configuration.merge('port' => 10000),
+        @configuration.merge("port" => 10000),
         filename)
     end
 
@@ -328,14 +328,14 @@ module ActiveRecord
   class MySQLStructureLoadTest < ActiveRecord::TestCase
     def setup
       @configuration = {
-        'adapter'  => 'mysql2',
-        'database' => 'test-db'
+        "adapter"  => "mysql2",
+        "database" => "test-db"
       }
     end
 
     def test_structure_load
       filename = "awesome-file.sql"
-      Kernel.expects(:system).with('mysql', '--execute', %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}, "--database", "test-db")
+      Kernel.expects(:system).with("mysql", "--execute", %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}, "--database", "test-db")
         .returns(true)
 
       ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
diff --git a/activerecord/test/cases/tasks/postgresql_rake_test.rb b/activerecord/test/cases/tasks/postgresql_rake_test.rb
index 99d73e91a4..8c3fc8c6a1 100644
--- a/activerecord/test/cases/tasks/postgresql_rake_test.rb
+++ b/activerecord/test/cases/tasks/postgresql_rake_test.rb
@@ -1,5 +1,5 @@
-require 'cases/helper'
-require 'active_record/tasks/database_tasks'
+require "cases/helper"
+require "active_record/tasks/database_tasks"
 
 if current_adapter?(:PostgreSQLAdapter)
 module ActiveRecord
@@ -7,8 +7,8 @@ module ActiveRecord
     def setup
       @connection    = stub(:create_database => true)
       @configuration = {
-        'adapter'  => 'postgresql',
-        'database' => 'my-app-db'
+        "adapter"  => "postgresql",
+        "database" => "my-app-db"
       }
 
       ActiveRecord::Base.stubs(:connection).returns(@connection)
@@ -24,9 +24,9 @@ module ActiveRecord
 
     def test_establishes_connection_to_postgresql_database
       ActiveRecord::Base.expects(:establish_connection).with(
-        'adapter'            => 'postgresql',
-        'database'           => 'postgres',
-        'schema_search_path' => 'public'
+        "adapter"            => "postgresql",
+        "database"           => "postgres",
+        "schema_search_path" => "public"
       )
 
       ActiveRecord::Tasks::DatabaseTasks.create @configuration
@@ -34,25 +34,25 @@ module ActiveRecord
 
     def test_creates_database_with_default_encoding
       @connection.expects(:create_database).
-        with('my-app-db', @configuration.merge('encoding' => 'utf8'))
+        with("my-app-db", @configuration.merge("encoding" => "utf8"))
 
       ActiveRecord::Tasks::DatabaseTasks.create @configuration
     end
 
     def test_creates_database_with_given_encoding
       @connection.expects(:create_database).
-        with('my-app-db', @configuration.merge('encoding' => 'latin'))
+        with("my-app-db", @configuration.merge("encoding" => "latin"))
 
       ActiveRecord::Tasks::DatabaseTasks.create @configuration.
-        merge('encoding' => 'latin')
+        merge("encoding" => "latin")
     end
 
     def test_creates_database_with_given_collation_and_ctype
       @connection.expects(:create_database).
-        with('my-app-db', @configuration.merge('encoding' => 'utf8', 'collation' => 'ja_JP.UTF8', 'ctype' => 'ja_JP.UTF8'))
+        with("my-app-db", @configuration.merge("encoding" => "utf8", "collation" => "ja_JP.UTF8", "ctype" => "ja_JP.UTF8"))
 
       ActiveRecord::Tasks::DatabaseTasks.create @configuration.
-        merge('collation' => 'ja_JP.UTF8', 'ctype' => 'ja_JP.UTF8')
+        merge("collation" => "ja_JP.UTF8", "ctype" => "ja_JP.UTF8")
     end
 
     def test_establishes_connection_to_new_database
@@ -92,8 +92,8 @@ module ActiveRecord
     def setup
       @connection    = stub(:drop_database => true)
       @configuration = {
-        'adapter'  => 'postgresql',
-        'database' => 'my-app-db'
+        "adapter"  => "postgresql",
+        "database" => "my-app-db"
       }
 
       ActiveRecord::Base.stubs(:connection).returns(@connection)
@@ -109,16 +109,16 @@ module ActiveRecord
 
     def test_establishes_connection_to_postgresql_database
       ActiveRecord::Base.expects(:establish_connection).with(
-        'adapter'            => 'postgresql',
-        'database'           => 'postgres',
-        'schema_search_path' => 'public'
+        "adapter"            => "postgresql",
+        "database"           => "postgres",
+        "schema_search_path" => "public"
       )
 
       ActiveRecord::Tasks::DatabaseTasks.drop @configuration
     end
 
     def test_drops_database
-      @connection.expects(:drop_database).with('my-app-db')
+      @connection.expects(:drop_database).with("my-app-db")
 
       ActiveRecord::Tasks::DatabaseTasks.drop @configuration
     end
@@ -134,8 +134,8 @@ module ActiveRecord
     def setup
       @connection    = stub(:create_database => true, :drop_database => true)
       @configuration = {
-        'adapter'  => 'postgresql',
-        'database' => 'my-app-db'
+        "adapter"  => "postgresql",
+        "database" => "my-app-db"
       }
 
       ActiveRecord::Base.stubs(:connection).returns(@connection)
@@ -151,23 +151,23 @@ module ActiveRecord
 
     def test_establishes_connection_to_postgresql_database
       ActiveRecord::Base.expects(:establish_connection).with(
-        'adapter'            => 'postgresql',
-        'database'           => 'postgres',
-        'schema_search_path' => 'public'
+        "adapter"            => "postgresql",
+        "database"           => "postgres",
+        "schema_search_path" => "public"
       )
 
       ActiveRecord::Tasks::DatabaseTasks.purge @configuration
     end
 
     def test_drops_database
-      @connection.expects(:drop_database).with('my-app-db')
+      @connection.expects(:drop_database).with("my-app-db")
 
       ActiveRecord::Tasks::DatabaseTasks.purge @configuration
     end
 
     def test_creates_database
       @connection.expects(:create_database).
-        with('my-app-db', @configuration.merge('encoding' => 'utf8'))
+        with("my-app-db", @configuration.merge("encoding" => "utf8"))
 
       ActiveRecord::Tasks::DatabaseTasks.purge @configuration
     end
@@ -183,8 +183,8 @@ module ActiveRecord
     def setup
       @connection    = stub(:create_database => true)
       @configuration = {
-        'adapter'  => 'postgresql',
-        'database' => 'my-app-db'
+        "adapter"  => "postgresql",
+        "database" => "my-app-db"
       }
 
       ActiveRecord::Base.stubs(:connection).returns(@connection)
@@ -201,8 +201,8 @@ module ActiveRecord
     def setup
       @connection    = stub(:create_database => true)
       @configuration = {
-        'adapter'  => 'postgresql',
-        'database' => 'my-app-db'
+        "adapter"  => "postgresql",
+        "database" => "my-app-db"
       }
 
       ActiveRecord::Base.stubs(:connection).returns(@connection)
@@ -219,8 +219,8 @@ module ActiveRecord
     def setup
       @connection    = stub(:structure_dump => true)
       @configuration = {
-        'adapter'  => 'postgresql',
-        'database' => 'my-app-db'
+        "adapter"  => "postgresql",
+        "database" => "my-app-db"
       }
       @filename = "awesome-file.sql"
 
@@ -231,23 +231,23 @@ module ActiveRecord
     end
 
     def test_structure_dump
-      Kernel.expects(:system).with('pg_dump', '-s', '-x', '-O', '-f', @filename, 'my-app-db').returns(true)
+      Kernel.expects(:system).with("pg_dump", "-s", "-x", "-O", "-f", @filename, "my-app-db").returns(true)
 
       ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
     end
 
     def test_structure_dump_with_schema_search_path
-      @configuration['schema_search_path'] = 'foo,bar'
+      @configuration["schema_search_path"] = "foo,bar"
 
-      Kernel.expects(:system).with('pg_dump', '-s', '-x', '-O', '-f', @filename, '--schema=foo', '--schema=bar', 'my-app-db').returns(true)
+      Kernel.expects(:system).with("pg_dump", "-s", "-x", "-O", "-f", @filename, "--schema=foo", "--schema=bar", "my-app-db").returns(true)
 
       ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
     end
 
     def test_structure_dump_with_schema_search_path_and_dump_schemas_all
-      @configuration['schema_search_path'] = 'foo,bar'
+      @configuration["schema_search_path"] = "foo,bar"
 
-      Kernel.expects(:system).with("pg_dump", '-s', '-x', '-O', '-f', @filename,  'my-app-db').returns(true)
+      Kernel.expects(:system).with("pg_dump", "-s", "-x", "-O", "-f", @filename,  "my-app-db").returns(true)
 
       with_dump_schemas(:all) do
         ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
@@ -255,9 +255,9 @@ module ActiveRecord
     end
 
     def test_structure_dump_with_dump_schemas_string
-      Kernel.expects(:system).with("pg_dump", '-s', '-x', '-O', '-f', @filename, '--schema=foo', '--schema=bar', "my-app-db").returns(true)
+      Kernel.expects(:system).with("pg_dump", "-s", "-x", "-O", "-f", @filename, "--schema=foo", "--schema=bar", "my-app-db").returns(true)
 
-      with_dump_schemas('foo,bar') do
+      with_dump_schemas("foo,bar") do
         ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
       end
     end
@@ -277,8 +277,8 @@ module ActiveRecord
     def setup
       @connection    = stub
       @configuration = {
-        'adapter'  => 'postgresql',
-        'database' => 'my-app-db'
+        "adapter"  => "postgresql",
+        "database" => "my-app-db"
       }
 
       ActiveRecord::Base.stubs(:connection).returns(@connection)
@@ -288,14 +288,14 @@ module ActiveRecord
 
     def test_structure_load
       filename = "awesome-file.sql"
-      Kernel.expects(:system).with('psql', '-v', 'ON_ERROR_STOP=1', '-q', '-f', filename, @configuration['database']).returns(true)
+      Kernel.expects(:system).with("psql", "-v", "ON_ERROR_STOP=1", "-q", "-f", filename, @configuration["database"]).returns(true)
 
       ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
     end
 
     def test_structure_load_accepts_path_with_spaces
       filename = "awesome file.sql"
-      Kernel.expects(:system).with('psql', '-v', 'ON_ERROR_STOP=1', '-q', '-f', filename, @configuration['database']).returns(true)
+      Kernel.expects(:system).with("psql", "-v", "ON_ERROR_STOP=1", "-q", "-f", filename, @configuration["database"]).returns(true)
 
       ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
     end
diff --git a/activerecord/test/cases/tasks/sqlite_rake_test.rb b/activerecord/test/cases/tasks/sqlite_rake_test.rb
index 4be03c7f61..2477df2c5b 100644
--- a/activerecord/test/cases/tasks/sqlite_rake_test.rb
+++ b/activerecord/test/cases/tasks/sqlite_rake_test.rb
@@ -1,16 +1,16 @@
-require 'cases/helper'
-require 'active_record/tasks/database_tasks'
-require 'pathname'
+require "cases/helper"
+require "active_record/tasks/database_tasks"
+require "pathname"
 
 if current_adapter?(:SQLite3Adapter)
 module ActiveRecord
   class SqliteDBCreateTest < ActiveRecord::TestCase
     def setup
-      @database      = 'db_create.sqlite3'
+      @database      = "db_create.sqlite3"
       @connection    = stub :connection
       @configuration = {
-        'adapter'  => 'sqlite3',
-        'database' => @database
+        "adapter"  => "sqlite3",
+        "database" => @database
       }
 
       File.stubs(:exist?).returns(false)
@@ -28,11 +28,11 @@ module ActiveRecord
     def test_db_checks_database_exists
       File.expects(:exist?).with(@database).returns(false)
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration, '/rails/root'
+      ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
     end
 
     def test_when_db_created_successfully_outputs_info_to_stdout
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration, '/rails/root'
+      ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
 
       assert_equal $stdout.string, "Created database '#{@database}'\n"
     end
@@ -40,7 +40,7 @@ module ActiveRecord
     def test_db_create_when_file_exists
       File.stubs(:exist?).returns(true)
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration, '/rails/root'
+      ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
 
       assert_equal $stderr.string, "Database '#{@database}' already exists\n"
     end
@@ -51,13 +51,13 @@ module ActiveRecord
 
       ActiveRecord::Base.expects(:establish_connection).never
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration, '/rails/root'
+      ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
     end
 
     def test_db_create_establishes_a_connection
       ActiveRecord::Base.expects(:establish_connection).with(@configuration)
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration, '/rails/root'
+      ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
     end
 
     def test_db_create_with_error_prints_message
@@ -67,21 +67,21 @@ module ActiveRecord
       $stderr.expects(:puts).
         with("Couldn't create database for #{@configuration.inspect}")
 
-      assert_raises(Exception) { ActiveRecord::Tasks::DatabaseTasks.create @configuration, '/rails/root' }
+      assert_raises(Exception) { ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root" }
     end
   end
 
   class SqliteDBDropTest < ActiveRecord::TestCase
     def setup
       @database      = "db_create.sqlite3"
-      @path          = stub(:to_s => '/absolute/path', :absolute? => true)
+      @path          = stub(:to_s => "/absolute/path", :absolute? => true)
       @configuration = {
-        'adapter'  => 'sqlite3',
-        'database' => @database
+        "adapter"  => "sqlite3",
+        "database" => @database
       }
 
       Pathname.stubs(:new).returns(@path)
-      File.stubs(:join).returns('/former/relative/path')
+      File.stubs(:join).returns("/former/relative/path")
       FileUtils.stubs(:rm).returns(true)
 
       $stdout, @original_stdout = StringIO.new, $stdout
@@ -95,38 +95,38 @@ module ActiveRecord
     def test_creates_path_from_database
       Pathname.expects(:new).with(@database).returns(@path)
 
-      ActiveRecord::Tasks::DatabaseTasks.drop @configuration, '/rails/root'
+      ActiveRecord::Tasks::DatabaseTasks.drop @configuration, "/rails/root"
     end
 
     def test_removes_file_with_absolute_path
       File.stubs(:exist?).returns(true)
       @path.stubs(:absolute?).returns(true)
 
-      FileUtils.expects(:rm).with('/absolute/path')
+      FileUtils.expects(:rm).with("/absolute/path")
 
-      ActiveRecord::Tasks::DatabaseTasks.drop @configuration, '/rails/root'
+      ActiveRecord::Tasks::DatabaseTasks.drop @configuration, "/rails/root"
     end
 
     def test_generates_absolute_path_with_given_root
       @path.stubs(:absolute?).returns(false)
 
-      File.expects(:join).with('/rails/root', @path).
-        returns('/former/relative/path')
+      File.expects(:join).with("/rails/root", @path).
+        returns("/former/relative/path")
 
-      ActiveRecord::Tasks::DatabaseTasks.drop @configuration, '/rails/root'
+      ActiveRecord::Tasks::DatabaseTasks.drop @configuration, "/rails/root"
     end
 
     def test_removes_file_with_relative_path
       File.stubs(:exist?).returns(true)
       @path.stubs(:absolute?).returns(false)
 
-      FileUtils.expects(:rm).with('/former/relative/path')
+      FileUtils.expects(:rm).with("/former/relative/path")
 
-      ActiveRecord::Tasks::DatabaseTasks.drop @configuration, '/rails/root'
+      ActiveRecord::Tasks::DatabaseTasks.drop @configuration, "/rails/root"
     end
 
     def test_when_db_dropped_successfully_outputs_info_to_stdout
-      ActiveRecord::Tasks::DatabaseTasks.drop @configuration, '/rails/root'
+      ActiveRecord::Tasks::DatabaseTasks.drop @configuration, "/rails/root"
 
       assert_equal $stdout.string, "Dropped database '#{@database}'\n"
     end
@@ -134,11 +134,11 @@ module ActiveRecord
 
   class SqliteDBCharsetTest < ActiveRecord::TestCase
     def setup
-      @database      = 'db_create.sqlite3'
+      @database      = "db_create.sqlite3"
       @connection    = stub :connection
       @configuration = {
-        'adapter'  => 'sqlite3',
-        'database' => @database
+        "adapter"  => "sqlite3",
+        "database" => @database
       }
 
       File.stubs(:exist?).returns(false)
@@ -148,17 +148,17 @@ module ActiveRecord
 
     def test_db_retrieves_charset
       @connection.expects(:encoding)
-      ActiveRecord::Tasks::DatabaseTasks.charset @configuration, '/rails/root'
+      ActiveRecord::Tasks::DatabaseTasks.charset @configuration, "/rails/root"
     end
   end
 
   class SqliteDBCollationTest < ActiveRecord::TestCase
     def setup
-      @database      = 'db_create.sqlite3'
+      @database      = "db_create.sqlite3"
       @connection    = stub :connection
       @configuration = {
-        'adapter'  => 'sqlite3',
-        'database' => @database
+        "adapter"  => "sqlite3",
+        "database" => @database
       }
 
       File.stubs(:exist?).returns(false)
@@ -168,7 +168,7 @@ module ActiveRecord
 
     def test_db_retrieves_collation
       assert_raise NoMethodError do
-        ActiveRecord::Tasks::DatabaseTasks.collation @configuration, '/rails/root'
+        ActiveRecord::Tasks::DatabaseTasks.collation @configuration, "/rails/root"
       end
     end
   end
@@ -177,8 +177,8 @@ module ActiveRecord
     def setup
       @database      = "db_create.sqlite3"
       @configuration = {
-        'adapter'  => 'sqlite3',
-        'database' => @database
+        "adapter"  => "sqlite3",
+        "database" => @database
       }
     end
 
@@ -186,7 +186,7 @@ module ActiveRecord
       dbfile   = @database
       filename = "awesome-file.sql"
 
-      ActiveRecord::Tasks::DatabaseTasks.structure_dump @configuration, filename, '/rails/root'
+      ActiveRecord::Tasks::DatabaseTasks.structure_dump @configuration, filename, "/rails/root"
       assert File.exist?(dbfile)
       assert File.exist?(filename)
     ensure
@@ -199,8 +199,8 @@ module ActiveRecord
     def setup
       @database      = "db_create.sqlite3"
       @configuration = {
-        'adapter'  => 'sqlite3',
-        'database' => @database
+        "adapter"  => "sqlite3",
+        "database" => @database
       }
     end
 
@@ -208,8 +208,8 @@ module ActiveRecord
       dbfile   = @database
       filename = "awesome-file.sql"
 
-      open(filename, 'w') { |f| f.puts("select datetime('now', 'localtime');") }
-      ActiveRecord::Tasks::DatabaseTasks.structure_load @configuration, filename, '/rails/root'
+      open(filename, "w") { |f| f.puts("select datetime('now', 'localtime');") }
+      ActiveRecord::Tasks::DatabaseTasks.structure_load @configuration, filename, "/rails/root"
       assert File.exist?(dbfile)
     ensure
       FileUtils.rm_f(filename)
diff --git a/activerecord/test/cases/test_case.rb b/activerecord/test/cases/test_case.rb
index fcb6552e5b..b0f5b5ca4a 100644
--- a/activerecord/test/cases/test_case.rb
+++ b/activerecord/test/cases/test_case.rb
@@ -1,6 +1,6 @@
-require 'active_support/test_case'
-require 'active_support/testing/stream'
-require 'active_support/core_ext/regexp'
+require "active_support/test_case"
+require "active_support/testing/stream"
+require "active_support/core_ext/regexp"
 
 module ActiveRecord
   # = Active Record Test Case
@@ -113,12 +113,12 @@ module ActiveRecord
 
       # FIXME: this seems bad. we should probably have a better way to indicate
       # the query was cached
-      return if 'CACHE' == values[:name]
+      return if "CACHE" == values[:name]
 
       self.class.log_all << sql
       self.class.log << sql unless ignore.match?(sql)
     end
   end
 
-  ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)
+  ActiveSupport::Notifications.subscribe("sql.active_record", SQLCounter.new)
 end
diff --git a/activerecord/test/cases/test_fixtures_test.rb b/activerecord/test/cases/test_fixtures_test.rb
index 1970fe82d0..14a5faa85e 100644
--- a/activerecord/test/cases/test_fixtures_test.rb
+++ b/activerecord/test/cases/test_fixtures_test.rb
@@ -1,4 +1,4 @@
-require 'cases/helper'
+require "cases/helper"
 
 class TestFixturesTest < ActiveRecord::TestCase
   setup do
@@ -7,7 +7,7 @@ class TestFixturesTest < ActiveRecord::TestCase
   end
 
   def test_deprecated_use_transactional_fixtures=
-    assert_deprecated 'use use_transactional_tests= instead' do
+    assert_deprecated "use use_transactional_tests= instead" do
       @klass.use_transactional_fixtures = true
     end
   end
diff --git a/activerecord/test/cases/time_precision_test.rb b/activerecord/test/cases/time_precision_test.rb
index 628a8eb771..c7f6e9c698 100644
--- a/activerecord/test/cases/time_precision_test.rb
+++ b/activerecord/test/cases/time_precision_test.rb
@@ -1,5 +1,5 @@
-require 'cases/helper'
-require 'support/schema_dumping_helper'
+require "cases/helper"
+require "support/schema_dumping_helper"
 
 if subsecond_precision_supported?
 class TimePrecisionTest < ActiveRecord::TestCase
@@ -21,8 +21,8 @@ class TimePrecisionTest < ActiveRecord::TestCase
     @connection.create_table(:foos, force: true)
     @connection.add_column :foos, :start,  :time, precision: 3
     @connection.add_column :foos, :finish, :time, precision: 6
-    assert_equal 3, Foo.columns_hash['start'].precision
-    assert_equal 6, Foo.columns_hash['finish'].precision
+    assert_equal 3, Foo.columns_hash["start"].precision
+    assert_equal 6, Foo.columns_hash["finish"].precision
   end
 
   def test_passing_precision_to_time_does_not_set_limit
@@ -30,8 +30,8 @@ class TimePrecisionTest < ActiveRecord::TestCase
       t.time :start,  precision: 3
       t.time :finish, precision: 6
     end
-    assert_nil Foo.columns_hash['start'].limit
-    assert_nil Foo.columns_hash['finish'].limit
+    assert_nil Foo.columns_hash["start"].limit
+    assert_nil Foo.columns_hash["finish"].limit
   end
 
   def test_invalid_time_precision_raises_error
diff --git a/activerecord/test/cases/timestamp_test.rb b/activerecord/test/cases/timestamp_test.rb
index 937b84bccc..d9b27d0e3e 100644
--- a/activerecord/test/cases/timestamp_test.rb
+++ b/activerecord/test/cases/timestamp_test.rb
@@ -1,12 +1,12 @@
-require 'cases/helper'
-require 'support/ddl_helper'
-require 'models/developer'
-require 'models/computer'
-require 'models/owner'
-require 'models/pet'
-require 'models/toy'
-require 'models/car'
-require 'models/task'
+require "cases/helper"
+require "support/ddl_helper"
+require "models/developer"
+require "models/computer"
+require "models/owner"
+require "models/pet"
+require "models/toy"
+require "models/car"
+require "models/task"
 
 class TimestampTest < ActiveRecord::TestCase
   fixtures :developers, :owners, :pets, :toys, :cars, :tasks
@@ -38,8 +38,8 @@ class TimestampTest < ActiveRecord::TestCase
 
     assert_not_equal @previously_updated_at, @developer.updated_at
     assert_equal previous_salary + 10000, @developer.salary
-    assert @developer.salary_changed?, 'developer salary should have changed'
-    assert @developer.changed?, 'developer should be marked as changed'
+    assert @developer.salary_changed?, "developer salary should have changed"
+    assert @developer.changed?, "developer should be marked as changed"
     @developer.reload
     assert_equal previous_salary, @developer.salary
   end
@@ -88,8 +88,8 @@ class TimestampTest < ActiveRecord::TestCase
       @developer.touch(:created_at)
     end
 
-    assert !@developer.created_at_changed? , 'created_at should not be changed'
-    assert !@developer.changed?, 'record should not be changed'
+    assert !@developer.created_at_changed? , "created_at should not be changed"
+    assert !@developer.changed?, "record should not be changed"
     assert_not_equal previously_created_at, @developer.created_at
     assert_not_equal @previously_updated_at, @developer.updated_at
   end
@@ -228,7 +228,7 @@ class TimestampTest < ActiveRecord::TestCase
 
   def test_saving_a_new_record_belonging_to_invalid_parent_with_touch_should_not_raise_exception
     klass = Class.new(Owner) do
-      def self.name; 'Owner'; end
+      def self.name; "Owner"; end
       validate { errors.add(:base, :invalid) }
     end
 
@@ -240,7 +240,7 @@ class TimestampTest < ActiveRecord::TestCase
 
   def test_saving_a_record_with_a_belongs_to_that_specifies_touching_a_specific_attribute_the_parent_should_update_that_attribute
     klass = Class.new(ActiveRecord::Base) do
-      def self.name; 'Pet'; end
+      def self.name; "Pet"; end
       belongs_to :owner, :touch => :happy_at
     end
 
@@ -256,7 +256,7 @@ class TimestampTest < ActiveRecord::TestCase
 
   def test_touching_a_record_with_a_belongs_to_that_uses_a_counter_cache_should_update_the_parent
     klass = Class.new(ActiveRecord::Base) do
-      def self.name; 'Pet'; end
+      def self.name; "Pet"; end
       belongs_to :owner, :counter_cache => :use_count, :touch => true
     end
 
@@ -275,7 +275,7 @@ class TimestampTest < ActiveRecord::TestCase
 
   def test_touching_a_record_touches_parent_record_and_grandparent_record
     klass = Class.new(ActiveRecord::Base) do
-      def self.name; 'Toy'; end
+      def self.name; "Toy"; end
       belongs_to :pet, :touch => true
     end
 
@@ -293,11 +293,11 @@ class TimestampTest < ActiveRecord::TestCase
 
   def test_touching_a_record_touches_polymorphic_record
     klass = Class.new(ActiveRecord::Base) do
-      def self.name; 'Toy'; end
+      def self.name; "Toy"; end
     end
 
     wheel_klass = Class.new(ActiveRecord::Base) do
-      def self.name; 'Wheel'; end
+      def self.name; "Wheel"; end
       belongs_to :wheelable, :polymorphic => true, :touch => true
     end
 
@@ -315,7 +315,7 @@ class TimestampTest < ActiveRecord::TestCase
 
   def test_changing_parent_of_a_record_touches_both_new_and_old_parent_record
     klass = Class.new(ActiveRecord::Base) do
-      def self.name; 'Toy'; end
+      def self.name; "Toy"; end
       belongs_to :pet, touch: true
     end
 
@@ -341,11 +341,11 @@ class TimestampTest < ActiveRecord::TestCase
 
   def test_changing_parent_of_a_record_touches_both_new_and_old_polymorphic_parent_record_changes_within_same_class
     car_class = Class.new(ActiveRecord::Base) do
-      def self.name; 'Car'; end
+      def self.name; "Car"; end
     end
 
     wheel_class = Class.new(ActiveRecord::Base) do
-      def self.name; 'Wheel'; end
+      def self.name; "Wheel"; end
       belongs_to :wheelable, :polymorphic => true, :touch => true
     end
 
@@ -368,15 +368,15 @@ class TimestampTest < ActiveRecord::TestCase
 
   def test_changing_parent_of_a_record_touches_both_new_and_old_polymorphic_parent_record_changes_with_other_class
     car_class = Class.new(ActiveRecord::Base) do
-      def self.name; 'Car'; end
+      def self.name; "Car"; end
     end
 
     toy_class = Class.new(ActiveRecord::Base) do
-      def self.name; 'Toy'; end
+      def self.name; "Toy"; end
     end
 
     wheel_class = Class.new(ActiveRecord::Base) do
-      def self.name; 'Wheel'; end
+      def self.name; "Wheel"; end
       belongs_to :wheelable, :polymorphic => true, :touch => true
     end
 
@@ -399,7 +399,7 @@ class TimestampTest < ActiveRecord::TestCase
 
   def test_clearing_association_touches_the_old_record
     klass = Class.new(ActiveRecord::Base) do
-      def self.name; 'Toy'; end
+      def self.name; "Toy"; end
       belongs_to :pet, touch: true
     end
 
@@ -419,14 +419,14 @@ class TimestampTest < ActiveRecord::TestCase
 
   def test_timestamp_column_values_are_present_in_the_callbacks
     klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'people'
+      self.table_name = "people"
 
       before_create do
         self.born_at = self.created_at
       end
     end
 
-    person = klass.create first_name: 'David'
+    person = klass.create first_name: "David"
     assert_not_equal person.born_at, nil
   end
 
@@ -465,8 +465,8 @@ class TimestampTest < ActiveRecord::TestCase
       t.timestamps(:foos, null: true, index: true)
     end
 
-    indexes = ActiveRecord::Base.connection.indexes('foos')
-    assert_equal ['created_at', 'updated_at'], indexes.flat_map(&:columns).sort
+    indexes = ActiveRecord::Base.connection.indexes("foos")
+    assert_equal ["created_at", "updated_at"], indexes.flat_map(&:columns).sort
   ensure
     ActiveRecord::Base.connection.drop_table(:foos)
   end
diff --git a/activerecord/test/cases/touch_later_test.rb b/activerecord/test/cases/touch_later_test.rb
index b47769eed7..697447a4f3 100644
--- a/activerecord/test/cases/touch_later_test.rb
+++ b/activerecord/test/cases/touch_later_test.rb
@@ -1,9 +1,9 @@
-require 'cases/helper'
-require 'models/invoice'
-require 'models/line_item'
-require 'models/topic'
-require 'models/node'
-require 'models/tree'
+require "cases/helper"
+require "models/invoice"
+require "models/line_item"
+require "models/topic"
+require "models/node"
+require "models/tree"
 
 class TouchLaterTest < ActiveRecord::TestCase
   fixtures :nodes, :trees
diff --git a/activerecord/test/cases/transaction_callbacks_test.rb b/activerecord/test/cases/transaction_callbacks_test.rb
index 8a7f19293d..21e2cfa5c5 100644
--- a/activerecord/test/cases/transaction_callbacks_test.rb
+++ b/activerecord/test/cases/transaction_callbacks_test.rb
@@ -1,7 +1,7 @@
 require "cases/helper"
-require 'models/owner'
-require 'models/pet'
-require 'models/topic'
+require "models/owner"
+require "models/pet"
+require "models/topic"
 
 class TransactionCallbacksTest < ActiveRecord::TestCase
   fixtures :topics, :owners, :pets
@@ -88,7 +88,7 @@ class TransactionCallbacksTest < ActiveRecord::TestCase
 
   # FIXME: Test behavior, not implementation.
   def test_before_commit_exception_should_pop_transaction_stack
-    @first.before_commit_block { raise 'better pop this txn from the stack!' }
+    @first.before_commit_block { raise "better pop this txn from the stack!" }
 
     original_txn = @first.class.connection.current_transaction
 
@@ -138,10 +138,10 @@ class TransactionCallbacksTest < ActiveRecord::TestCase
   end
 
   def test_only_call_after_commit_on_create_and_doesnt_leaky
-    r = ReplyWithCallbacks.new(content: 'foo')
+    r = ReplyWithCallbacks.new(content: "foo")
     r.save_on_after_create = true
     r.save!
-    r.content = 'bar'
+    r.content = "bar"
     r.save!
     r.save!
     assert_equal [:commit_on_create], r.history
@@ -355,13 +355,13 @@ class TransactionCallbacksTest < ActiveRecord::TestCase
 
   def test_after_rollback_callbacks_should_validate_on_condition
     assert_raise(ArgumentError) { Topic.after_rollback(on: :save) }
-    e = assert_raise(ArgumentError) { Topic.after_rollback(on: 'create') }
+    e = assert_raise(ArgumentError) { Topic.after_rollback(on: "create") }
     assert_match(/:on conditions for after_commit and after_rollback callbacks have to be one of \[:create, :destroy, :update\]/, e.message)
   end
 
   def test_after_commit_callbacks_should_validate_on_condition
     assert_raise(ArgumentError) { Topic.after_commit(on: :save) }
-    e = assert_raise(ArgumentError) { Topic.after_commit(on: 'create') }
+    e = assert_raise(ArgumentError) { Topic.after_commit(on: "create") }
     assert_match(/:on conditions for after_commit and after_rollback callbacks have to be one of \[:create, :destroy, :update\]/, e.message)
   end
 
@@ -470,7 +470,7 @@ class TransactionEnrollmentCallbacksTest < ActiveRecord::TestCase
 
   def test_commit_does_not_run_transactions_callbacks_without_enrollment
     @topic.transaction do
-      @topic.content = 'foo'
+      @topic.content = "foo"
       @topic.save!
     end
     assert @topic.history.empty?
@@ -479,7 +479,7 @@ class TransactionEnrollmentCallbacksTest < ActiveRecord::TestCase
   def test_commit_run_transactions_callbacks_with_explicit_enrollment
     @topic.transaction do
       2.times do
-        @topic.content = 'foo'
+        @topic.content = "foo"
         @topic.save!
       end
       @topic.class.connection.add_transaction_record(@topic)
@@ -489,7 +489,7 @@ class TransactionEnrollmentCallbacksTest < ActiveRecord::TestCase
 
   def test_rollback_does_not_run_transactions_callbacks_without_enrollment
     @topic.transaction do
-      @topic.content = 'foo'
+      @topic.content = "foo"
       @topic.save!
       raise ActiveRecord::Rollback
     end
@@ -499,7 +499,7 @@ class TransactionEnrollmentCallbacksTest < ActiveRecord::TestCase
   def test_rollback_run_transactions_callbacks_with_explicit_enrollment
     @topic.transaction do
       2.times do
-        @topic.content = 'foo'
+        @topic.content = "foo"
         @topic.save!
       end
       @topic.class.connection.add_transaction_record(@topic)
diff --git a/activerecord/test/cases/transaction_isolation_test.rb b/activerecord/test/cases/transaction_isolation_test.rb
index 2f7d208ed2..f177f0644a 100644
--- a/activerecord/test/cases/transaction_isolation_test.rb
+++ b/activerecord/test/cases/transaction_isolation_test.rb
@@ -1,4 +1,4 @@
-require 'cases/helper'
+require "cases/helper"
 
 unless ActiveRecord::Base.connection.supports_transaction_isolation?
   class TransactionIsolationUnsupportedTest < ActiveRecord::TestCase
@@ -20,11 +20,11 @@ if ActiveRecord::Base.connection.supports_transaction_isolation?
     self.use_transactional_tests = false
 
     class Tag < ActiveRecord::Base
-      self.table_name = 'tags'
+      self.table_name = "tags"
     end
 
     class Tag2 < ActiveRecord::Base
-      self.table_name = 'tags'
+      self.table_name = "tags"
     end
 
     setup do
@@ -63,18 +63,18 @@ if ActiveRecord::Base.connection.supports_transaction_isolation?
     # We are testing that a nonrepeatable read does not happen
     if ActiveRecord::Base.connection.transaction_isolation_levels.include?(:repeatable_read)
       test "repeatable read" do
-        tag = Tag.create(name: 'jon')
+        tag = Tag.create(name: "jon")
 
         Tag.transaction(isolation: :repeatable_read) do
           tag.reload
-          Tag2.find(tag.id).update(name: 'emily')
+          Tag2.find(tag.id).update(name: "emily")
 
           tag.reload
-          assert_equal 'jon', tag.name
+          assert_equal "jon", tag.name
         end
 
         tag.reload
-        assert_equal 'emily', tag.name
+        assert_equal "emily", tag.name
       end
     end
 
diff --git a/activerecord/test/cases/transactions_test.rb b/activerecord/test/cases/transactions_test.rb
index 791b895d02..e775983817 100644
--- a/activerecord/test/cases/transactions_test.rb
+++ b/activerecord/test/cases/transactions_test.rb
@@ -1,12 +1,12 @@
 require "cases/helper"
-require 'models/topic'
-require 'models/reply'
-require 'models/developer'
-require 'models/computer'
-require 'models/book'
-require 'models/author'
-require 'models/post'
-require 'models/movie'
+require "models/topic"
+require "models/reply"
+require "models/developer"
+require "models/computer"
+require "models/book"
+require "models/author"
+require "models/post"
+require "models/movie"
 
 class TransactionTest < ActiveRecord::TestCase
   self.use_transactional_tests = false
@@ -144,7 +144,7 @@ class TransactionTest < ActiveRecord::TestCase
 
   def test_raising_exception_in_callback_rollbacks_in_save
     def @first.after_save_for_transaction
-      raise 'Make the transaction rollback'
+      raise "Make the transaction rollback"
     end
 
     @first.approved = true
@@ -170,7 +170,7 @@ class TransactionTest < ActiveRecord::TestCase
     topic = Topic.new
 
     def topic.after_save_for_transaction
-      raise 'Make the transaction rollback'
+      raise "Make the transaction rollback"
     end
 
     assert_raises(RuntimeError) do
@@ -181,7 +181,7 @@ class TransactionTest < ActiveRecord::TestCase
   end
 
   def test_transaction_state_is_cleared_when_record_is_persisted
-    author = Author.create! name: 'foo'
+    author = Author.create! name: "foo"
     author.name = nil
     assert_not author.save
     assert_not author.new_record?
@@ -230,7 +230,7 @@ class TransactionTest < ActiveRecord::TestCase
       send("add_cancelling_before_#{filter}_with_db_side_effect_to_topic", @first)
       nbooks_before_save = Book.count
       original_author_name = @first.author_name
-      @first.author_name += '_this_should_not_end_up_in_the_db'
+      @first.author_name += "_this_should_not_end_up_in_the_db"
       status = @first.save
       assert !status
       assert_equal original_author_name, @first.reload.author_name
@@ -241,7 +241,7 @@ class TransactionTest < ActiveRecord::TestCase
       send("add_cancelling_before_#{filter}_with_db_side_effect_to_topic", @first)
       nbooks_before_save = Book.count
       original_author_name = @first.author_name
-      @first.author_name += '_this_should_not_end_up_in_the_db'
+      @first.author_name += "_this_should_not_end_up_in_the_db"
 
       begin
         @first.save!
@@ -256,7 +256,7 @@ class TransactionTest < ActiveRecord::TestCase
   def test_callback_rollback_in_create
     topic = Class.new(Topic) {
       def after_create_for_transaction
-        raise 'Make the transaction rollback'
+        raise "Make the transaction rollback"
       end
     }
 
@@ -493,7 +493,7 @@ class TransactionTest < ActiveRecord::TestCase
 
   def test_rollback_when_commit_raises
     assert_called(Topic.connection, :begin_db_transaction) do
-      Topic.connection.stub(:commit_db_transaction, ->{ raise('OH NOES') }) do
+      Topic.connection.stub(:commit_db_transaction, ->{ raise("OH NOES") }) do
         assert_called(Topic.connection, :rollback_db_transaction) do
 
           e = assert_raise RuntimeError do
@@ -501,22 +501,22 @@ class TransactionTest < ActiveRecord::TestCase
               # do nothing
             end
           end
-          assert_equal 'OH NOES', e.message
+          assert_equal "OH NOES", e.message
         end
       end
     end
   end
 
   def test_rollback_when_saving_a_frozen_record
-    topic = Topic.new(:title => 'test')
+    topic = Topic.new(:title => "test")
     topic.freeze
     e = assert_raise(RuntimeError) { topic.save }
     assert_match(/frozen/i, e.message) # Not good enough, but we can't do much
                                        # about it since there is no specific error
                                        # for frozen objects.
-    assert !topic.persisted?, 'not persisted'
+    assert !topic.persisted?, "not persisted"
     assert_nil topic.id
-    assert topic.frozen?, 'not frozen'
+    assert topic.frozen?, "not frozen"
   end
 
   def test_rollback_when_thread_killed
@@ -549,12 +549,12 @@ class TransactionTest < ActiveRecord::TestCase
 
   def test_restore_active_record_state_for_all_records_in_a_transaction
     topic_without_callbacks = Class.new(ActiveRecord::Base) do
-      self.table_name = 'topics'
+      self.table_name = "topics"
     end
 
-    topic_1 = Topic.new(:title => 'test_1')
-    topic_2 = Topic.new(:title => 'test_2')
-    topic_3 = topic_without_callbacks.new(:title => 'test_3')
+    topic_1 = Topic.new(:title => "test_1")
+    topic_2 = Topic.new(:title => "test_2")
+    topic_3 = topic_without_callbacks.new(:title => "test_3")
 
     Topic.transaction do
       assert topic_1.save
@@ -562,27 +562,27 @@ class TransactionTest < ActiveRecord::TestCase
       assert topic_3.save
       @first.save
       @second.destroy
-      assert topic_1.persisted?, 'persisted'
+      assert topic_1.persisted?, "persisted"
       assert_not_nil topic_1.id
-      assert topic_2.persisted?, 'persisted'
+      assert topic_2.persisted?, "persisted"
       assert_not_nil topic_2.id
-      assert topic_3.persisted?, 'persisted'
+      assert topic_3.persisted?, "persisted"
       assert_not_nil topic_3.id
-      assert @first.persisted?, 'persisted'
+      assert @first.persisted?, "persisted"
       assert_not_nil @first.id
-      assert @second.destroyed?, 'destroyed'
+      assert @second.destroyed?, "destroyed"
       raise ActiveRecord::Rollback
     end
 
-    assert !topic_1.persisted?, 'not persisted'
+    assert !topic_1.persisted?, "not persisted"
     assert_nil topic_1.id
-    assert !topic_2.persisted?, 'not persisted'
+    assert !topic_2.persisted?, "not persisted"
     assert_nil topic_2.id
-    assert !topic_3.persisted?, 'not persisted'
+    assert !topic_3.persisted?, "not persisted"
     assert_nil topic_3.id
-    assert @first.persisted?, 'persisted'
+    assert @first.persisted?, "persisted"
     assert_not_nil @first.id
-    assert !@second.destroyed?, 'not destroyed'
+    assert !@second.destroyed?, "not destroyed"
   end
 
   def test_restore_frozen_state_after_double_destroy
@@ -606,7 +606,7 @@ class TransactionTest < ActiveRecord::TestCase
       topic.destroy
       raise ActiveRecord::Rollback
     end
-    assert topic.frozen?, 'frozen'
+    assert topic.frozen?, "frozen"
   end
 
   def test_rollback_for_freshly_persisted_records
@@ -615,7 +615,7 @@ class TransactionTest < ActiveRecord::TestCase
       topic.destroy
       raise ActiveRecord::Rollback
     end
-    assert topic.persisted?, 'persisted'
+    assert topic.persisted?, "persisted"
   end
 
   def test_sqlite_add_column_in_transaction
@@ -629,27 +629,27 @@ class TransactionTest < ActiveRecord::TestCase
 
     assert_nothing_raised do
       Topic.reset_column_information
-      Topic.connection.add_column('topics', 'stuff', :string)
-      assert Topic.column_names.include?('stuff')
+      Topic.connection.add_column("topics", "stuff", :string)
+      assert Topic.column_names.include?("stuff")
 
       Topic.reset_column_information
-      Topic.connection.remove_column('topics', 'stuff')
-      assert !Topic.column_names.include?('stuff')
+      Topic.connection.remove_column("topics", "stuff")
+      assert !Topic.column_names.include?("stuff")
     end
 
     if Topic.connection.supports_ddl_transactions?
       assert_nothing_raised do
-        Topic.transaction { Topic.connection.add_column('topics', 'stuff', :string) }
+        Topic.transaction { Topic.connection.add_column("topics", "stuff", :string) }
       end
     else
       Topic.transaction do
-        assert_raise(ActiveRecord::StatementInvalid) { Topic.connection.add_column('topics', 'stuff', :string) }
+        assert_raise(ActiveRecord::StatementInvalid) { Topic.connection.add_column("topics", "stuff", :string) }
         raise ActiveRecord::Rollback
       end
     end
   ensure
     begin
-      Topic.connection.remove_column('topics', 'stuff')
+      Topic.connection.remove_column("topics", "stuff")
     rescue
     ensure
       Topic.reset_column_information
@@ -691,7 +691,7 @@ class TransactionTest < ActiveRecord::TestCase
     end
 
     klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'transaction_without_primary_keys'
+      self.table_name = "transaction_without_primary_keys"
       after_commit { } # necessary to trigger the has_transactional_callbacks branch
     end
 
@@ -702,7 +702,7 @@ class TransactionTest < ActiveRecord::TestCase
       end
     end
   ensure
-    connection.drop_table 'transaction_without_primary_keys', if_exists: true
+    connection.drop_table "transaction_without_primary_keys", if_exists: true
   end
 
   private
diff --git a/activerecord/test/cases/type/integer_test.rb b/activerecord/test/cases/type/integer_test.rb
index c0932d5357..b411a82705 100644
--- a/activerecord/test/cases/type/integer_test.rb
+++ b/activerecord/test/cases/type/integer_test.rb
@@ -6,13 +6,13 @@ module ActiveRecord
     class IntegerTest < ActiveRecord::TestCase
       test "casting ActiveRecord models" do
         type = Type::Integer.new
-        firm = Firm.create(:name => 'Apple')
+        firm = Firm.create(:name => "Apple")
         assert_nil type.cast(firm)
       end
 
       test "values which are out of range can be re-assigned" do
         klass = Class.new(ActiveRecord::Base) do
-          self.table_name = 'posts'
+          self.table_name = "posts"
           attribute :foo, :integer
         end
         model = klass.new
diff --git a/activerecord/test/cases/type/string_test.rb b/activerecord/test/cases/type/string_test.rb
index 6fe6d46711..a95da864fa 100644
--- a/activerecord/test/cases/type/string_test.rb
+++ b/activerecord/test/cases/type/string_test.rb
@@ -1,21 +1,21 @@
-require 'cases/helper'
+require "cases/helper"
 
 module ActiveRecord
   class StringTypeTest < ActiveRecord::TestCase
     test "string mutations are detected" do
       klass = Class.new(Base)
-      klass.table_name = 'authors'
+      klass.table_name = "authors"
 
-      author = klass.create!(name: 'Sean')
+      author = klass.create!(name: "Sean")
       assert_not author.changed?
 
-      author.name << ' Griffin'
+      author.name << " Griffin"
       assert author.name_changed?
 
       author.save!
       author.reload
 
-      assert_equal 'Sean Griffin', author.name
+      assert_equal "Sean Griffin", author.name
       assert_not author.changed?
     end
   end
diff --git a/activerecord/test/cases/type/type_map_test.rb b/activerecord/test/cases/type/type_map_test.rb
index 172c6dfc4c..0be173b87d 100644
--- a/activerecord/test/cases/type/type_map_test.rb
+++ b/activerecord/test/cases/type/type_map_test.rb
@@ -15,7 +15,7 @@ module ActiveRecord
 
         mapping.register_type(/boolean/i, boolean)
 
-        assert_equal mapping.lookup('boolean'), boolean
+        assert_equal mapping.lookup("boolean"), boolean
       end
 
       def test_overriding_registered_types
@@ -26,7 +26,7 @@ module ActiveRecord
         mapping.register_type(/time/i, time)
         mapping.register_type(/time/i, timestamp)
 
-        assert_equal mapping.lookup('time'), timestamp
+        assert_equal mapping.lookup("time"), timestamp
       end
 
       def test_fuzzy_lookup
@@ -35,7 +35,7 @@ module ActiveRecord
 
         mapping.register_type(/varchar/i, string)
 
-        assert_equal mapping.lookup('varchar(20)'), string
+        assert_equal mapping.lookup("varchar(20)"), string
       end
 
       def test_aliasing_types
@@ -43,9 +43,9 @@ module ActiveRecord
         mapping = TypeMap.new
 
         mapping.register_type(/string/i, string)
-        mapping.alias_type(/varchar/i, 'string')
+        mapping.alias_type(/varchar/i, "string")
 
-        assert_equal mapping.lookup('varchar'), string
+        assert_equal mapping.lookup("varchar"), string
       end
 
       def test_changing_type_changes_aliases
@@ -54,20 +54,20 @@ module ActiveRecord
         mapping = TypeMap.new
 
         mapping.register_type(/timestamp/i, time)
-        mapping.alias_type(/datetime/i, 'timestamp')
+        mapping.alias_type(/datetime/i, "timestamp")
         mapping.register_type(/timestamp/i, timestamp)
 
-        assert_equal mapping.lookup('datetime'), timestamp
+        assert_equal mapping.lookup("datetime"), timestamp
       end
 
       def test_aliases_keep_metadata
         mapping = TypeMap.new
 
         mapping.register_type(/decimal/i) { |sql_type| sql_type }
-        mapping.alias_type(/number/i, 'decimal')
+        mapping.alias_type(/number/i, "decimal")
 
-        assert_equal mapping.lookup('number(20)'), 'decimal(20)'
-        assert_equal mapping.lookup('number'), 'decimal'
+        assert_equal mapping.lookup("number(20)"), "decimal(20)"
+        assert_equal mapping.lookup("number"), "decimal"
       end
 
       def test_register_proc
@@ -76,15 +76,15 @@ module ActiveRecord
         mapping = TypeMap.new
 
         mapping.register_type(/varchar/i) do |type|
-          if type.include?('(')
+          if type.include?("(")
             string
           else
             binary
           end
         end
 
-        assert_equal mapping.lookup('varchar(20)'), string
-        assert_equal mapping.lookup('varchar'), binary
+        assert_equal mapping.lookup("varchar(20)"), string
+        assert_equal mapping.lookup("varchar"), binary
       end
 
       def test_additional_lookup_args
@@ -92,16 +92,16 @@ module ActiveRecord
 
         mapping.register_type(/varchar/i) do |type, limit|
           if limit > 255
-            'text'
+            "text"
           else
-            'string'
+            "string"
           end
         end
-        mapping.alias_type(/string/i, 'varchar')
+        mapping.alias_type(/string/i, "varchar")
 
-        assert_equal mapping.lookup('varchar', 200), 'string'
-        assert_equal mapping.lookup('varchar', 400), 'text'
-        assert_equal mapping.lookup('string', 400), 'text'
+        assert_equal mapping.lookup("varchar", 200), "string"
+        assert_equal mapping.lookup("varchar", 400), "text"
+        assert_equal mapping.lookup("string", 400), "text"
       end
 
       def test_requires_value_or_block
@@ -115,13 +115,13 @@ module ActiveRecord
       def test_lookup_non_strings
         mapping = HashLookupTypeMap.new
 
-        mapping.register_type(1, 'string')
-        mapping.register_type(2, 'int')
+        mapping.register_type(1, "string")
+        mapping.register_type(2, "int")
         mapping.alias_type(3, 1)
 
-        assert_equal mapping.lookup(1), 'string'
-        assert_equal mapping.lookup(2), 'int'
-        assert_equal mapping.lookup(3), 'string'
+        assert_equal mapping.lookup(1), "string"
+        assert_equal mapping.lookup(2), "int"
+        assert_equal mapping.lookup(3), "string"
         assert_kind_of Type::Value, mapping.lookup(4)
       end
 
diff --git a/activerecord/test/cases/types_test.rb b/activerecord/test/cases/types_test.rb
index 81fcf04a27..11476ea0ef 100644
--- a/activerecord/test/cases/types_test.rb
+++ b/activerecord/test/cases/types_test.rb
@@ -9,7 +9,7 @@ module ActiveRecord
           raise
         end
         klass = Class.new(ActiveRecord::Base) do
-          self.table_name = 'posts'
+          self.table_name = "posts"
           attribute :foo, type_which_cannot_go_to_the_database
         end
         model = klass.new
diff --git a/activerecord/test/cases/validations/absence_validation_test.rb b/activerecord/test/cases/validations/absence_validation_test.rb
index c0b3750bcc..870619e4e7 100644
--- a/activerecord/test/cases/validations/absence_validation_test.rb
+++ b/activerecord/test/cases/validations/absence_validation_test.rb
@@ -1,8 +1,8 @@
 require "cases/helper"
-require 'models/face'
-require 'models/interest'
-require 'models/man'
-require 'models/topic'
+require "models/face"
+require "models/interest"
+require "models/man"
+require "models/topic"
 
 class AbsenceValidationTest < ActiveRecord::TestCase
   def test_non_association
@@ -52,7 +52,7 @@ class AbsenceValidationTest < ActiveRecord::TestCase
     end
 
     face_with_to_a = Face.new
-    def face_with_to_a.to_a; ['(/)', '(\)']; end
+    def face_with_to_a.to_a; ["(/)", '(\)']; end
 
     assert_nothing_raised { boy_klass.new(face: face_with_to_a).valid? }
   end
@@ -62,10 +62,10 @@ class AbsenceValidationTest < ActiveRecord::TestCase
       Interest.send(:attr_accessor, :token)
       Interest.validates_absence_of(:token)
 
-      interest = Interest.create!(topic: 'Thought Leadering')
+      interest = Interest.create!(topic: "Thought Leadering")
       assert interest.valid?
 
-      interest.token = 'tl'
+      interest.token = "tl"
 
       assert interest.invalid?
     end
diff --git a/activerecord/test/cases/validations/association_validation_test.rb b/activerecord/test/cases/validations/association_validation_test.rb
index 584a3dc0d8..09044e00b2 100644
--- a/activerecord/test/cases/validations/association_validation_test.rb
+++ b/activerecord/test/cases/validations/association_validation_test.rb
@@ -1,8 +1,8 @@
 require "cases/helper"
-require 'models/topic'
-require 'models/reply'
-require 'models/man'
-require 'models/interest'
+require "models/topic"
+require "models/reply"
+require "models/man"
+require "models/interest"
 
 class AssociationValidationTest < ActiveRecord::TestCase
   fixtures :topics
@@ -80,8 +80,8 @@ class AssociationValidationTest < ActiveRecord::TestCase
     repair_validations(Interest) do
       # Note that Interest and Man have the :inverse_of option set
       Interest.validates_presence_of(:man)
-      man = Man.new(:name => 'John')
-      interest = man.interests.build(:topic => 'Airplanes')
+      man = Man.new(:name => "John")
+      interest = man.interests.build(:topic => "Airplanes")
       assert interest.valid?, "Expected interest to be valid, but was not. Interest should have a man object associated"
     end
   end
@@ -89,8 +89,8 @@ class AssociationValidationTest < ActiveRecord::TestCase
   def test_validates_presence_of_belongs_to_association__existing_parent
     repair_validations(Interest) do
       Interest.validates_presence_of(:man)
-      man = Man.create!(:name => 'John')
-      interest = man.interests.build(:topic => 'Airplanes')
+      man = Man.create!(:name => "John")
+      interest = man.interests.build(:topic => "Airplanes")
       assert interest.valid?, "Expected interest to be valid, but was not. Interest should have a man object associated"
     end
   end
diff --git a/activerecord/test/cases/validations/i18n_generate_message_validation_test.rb b/activerecord/test/cases/validations/i18n_generate_message_validation_test.rb
index 13d4d85afa..bc80aa16e6 100644
--- a/activerecord/test/cases/validations/i18n_generate_message_validation_test.rb
+++ b/activerecord/test/cases/validations/i18n_generate_message_validation_test.rb
@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'models/topic'
+require "models/topic"
 
 class I18nGenerateMessageValidationTest < ActiveRecord::TestCase
   def setup
@@ -20,20 +20,20 @@ class I18nGenerateMessageValidationTest < ActiveRecord::TestCase
 
   # validates_associated: generate_message(attr_name, :invalid, :message => custom_message, :value => value)
   def test_generate_message_invalid_with_default_message
-    assert_equal 'is invalid', @topic.errors.generate_message(:title, :invalid, :value => 'title')
+    assert_equal "is invalid", @topic.errors.generate_message(:title, :invalid, :value => "title")
   end
 
   def test_generate_message_invalid_with_custom_message
-    assert_equal 'custom message title', @topic.errors.generate_message(:title, :invalid, :message => 'custom message %{value}', :value => 'title')
+    assert_equal "custom message title", @topic.errors.generate_message(:title, :invalid, :message => "custom message %{value}", :value => "title")
   end
 
   # validates_uniqueness_of: generate_message(attr_name, :taken, :message => custom_message)
   def test_generate_message_taken_with_default_message
-    assert_equal "has already been taken", @topic.errors.generate_message(:title, :taken, :value => 'title')
+    assert_equal "has already been taken", @topic.errors.generate_message(:title, :taken, :value => "title")
   end
 
   def test_generate_message_taken_with_custom_message
-    assert_equal 'custom message title', @topic.errors.generate_message(:title, :taken, :message => 'custom message %{value}', :value => 'title')
+    assert_equal "custom message title", @topic.errors.generate_message(:title, :taken, :message => "custom message %{value}", :value => "title")
   end
 
   # ActiveRecord#RecordInvalid exception
@@ -47,7 +47,7 @@ class I18nGenerateMessageValidationTest < ActiveRecord::TestCase
 
   test "RecordInvalid exception translation falls back to the :errors namespace" do
     reset_i18n_load_path do
-      I18n.backend.store_translations 'en', :errors => {:messages => {:record_invalid => 'fallback message'}}
+      I18n.backend.store_translations "en", :errors => {:messages => {:record_invalid => "fallback message"}}
       topic = Topic.new
       topic.errors.add(:title, :blank)
       assert_equal "fallback message", ActiveRecord::RecordInvalid.new(topic).message
@@ -57,28 +57,28 @@ class I18nGenerateMessageValidationTest < ActiveRecord::TestCase
   test "translation for 'taken' can be overridden" do
     reset_i18n_load_path do
       I18n.backend.store_translations "en", {errors: {attributes: {title: {taken: "Custom taken message" }}}}
-      assert_equal "Custom taken message", @topic.errors.generate_message(:title, :taken, :value => 'title')
+      assert_equal "Custom taken message", @topic.errors.generate_message(:title, :taken, :value => "title")
     end
   end
 
   test "translation for 'taken' can be overridden in activerecord scope" do
     reset_i18n_load_path do
       I18n.backend.store_translations "en", {activerecord: {errors: {messages: {taken: "Custom taken message" }}}}
-      assert_equal "Custom taken message", @topic.errors.generate_message(:title, :taken, :value => 'title')
+      assert_equal "Custom taken message", @topic.errors.generate_message(:title, :taken, :value => "title")
     end
   end
 
   test "translation for 'taken' can be overridden in activerecord model scope" do
     reset_i18n_load_path do
       I18n.backend.store_translations "en", {activerecord: {errors: {models: {topic: {taken: "Custom taken message" }}}}}
-      assert_equal "Custom taken message", @topic.errors.generate_message(:title, :taken, :value => 'title')
+      assert_equal "Custom taken message", @topic.errors.generate_message(:title, :taken, :value => "title")
     end
   end
 
   test "translation for 'taken' can be overridden in activerecord attributes scope" do
     reset_i18n_load_path do
       I18n.backend.store_translations "en", {activerecord: {errors: {models: {topic: {attributes: {title: {taken: "Custom taken message" }}}}}}}
-      assert_equal "Custom taken message", @topic.errors.generate_message(:title, :taken, :value => 'title')
+      assert_equal "Custom taken message", @topic.errors.generate_message(:title, :taken, :value => "title")
     end
   end
 end
diff --git a/activerecord/test/cases/validations/i18n_validation_test.rb b/activerecord/test/cases/validations/i18n_validation_test.rb
index 5b5307489a..52a00c55e7 100644
--- a/activerecord/test/cases/validations/i18n_validation_test.rb
+++ b/activerecord/test/cases/validations/i18n_validation_test.rb
@@ -1,6 +1,6 @@
 require "cases/helper"
-require 'models/topic'
-require 'models/reply'
+require "models/topic"
+require "models/reply"
 
 class I18nValidationTest < ActiveRecord::TestCase
   repair_validations(Topic, Reply)
@@ -12,7 +12,7 @@ class I18nValidationTest < ActiveRecord::TestCase
     @old_load_path, @old_backend = I18n.load_path.dup, I18n.backend
     I18n.load_path.clear
     I18n.backend = I18n::Backend::Simple.new
-    I18n.backend.store_translations('en', :errors => {:messages => {:custom => nil}})
+    I18n.backend.store_translations("en", :errors => {:messages => {:custom => nil}})
   end
 
   teardown do
@@ -21,7 +21,7 @@ class I18nValidationTest < ActiveRecord::TestCase
   end
 
   def unique_topic
-    @unique ||= Topic.create :title => 'unique!'
+    @unique ||= Topic.create :title => "unique!"
   end
 
   def replied_topic
@@ -49,7 +49,7 @@ class I18nValidationTest < ActiveRecord::TestCase
     test "validates_uniqueness_of on generated message #{name}" do
       Topic.validates_uniqueness_of :title, validation_options
       @topic.title = unique_topic.title
-      assert_called_with(@topic.errors, :generate_message, [:title, :taken, generate_message_options.merge(:value => 'unique!')]) do
+      assert_called_with(@topic.errors, :generate_message, [:title, :taken, generate_message_options.merge(:value => "unique!")]) do
         @topic.valid?
       end
     end
@@ -65,20 +65,20 @@ class I18nValidationTest < ActiveRecord::TestCase
   end
 
   def test_validates_associated_finds_custom_model_key_translation
-    I18n.backend.store_translations 'en', :activerecord => {:errors => {:models => {:topic => {:attributes => {:replies => {:invalid => 'custom message'}}}}}}
-    I18n.backend.store_translations 'en', :activerecord => {:errors => {:messages => {:invalid => 'global message'}}}
+    I18n.backend.store_translations "en", :activerecord => {:errors => {:models => {:topic => {:attributes => {:replies => {:invalid => "custom message"}}}}}}
+    I18n.backend.store_translations "en", :activerecord => {:errors => {:messages => {:invalid => "global message"}}}
 
     Topic.validates_associated :replies
     replied_topic.valid?
-    assert_equal ['custom message'], replied_topic.errors[:replies].uniq
+    assert_equal ["custom message"], replied_topic.errors[:replies].uniq
   end
 
   def test_validates_associated_finds_global_default_translation
-    I18n.backend.store_translations 'en', :activerecord => {:errors => {:messages => {:invalid => 'global message'}}}
+    I18n.backend.store_translations "en", :activerecord => {:errors => {:messages => {:invalid => "global message"}}}
 
     Topic.validates_associated :replies
     replied_topic.valid?
-    assert_equal ['global message'], replied_topic.errors[:replies]
+    assert_equal ["global message"], replied_topic.errors[:replies]
   end
 
 end
diff --git a/activerecord/test/cases/validations/length_validation_test.rb b/activerecord/test/cases/validations/length_validation_test.rb
index 78263fd955..08dd740b01 100644
--- a/activerecord/test/cases/validations/length_validation_test.rb
+++ b/activerecord/test/cases/validations/length_validation_test.rb
@@ -1,47 +1,47 @@
 require "cases/helper"
-require 'models/owner'
-require 'models/pet'
-require 'models/person'
+require "models/owner"
+require "models/pet"
+require "models/person"
 
 class LengthValidationTest < ActiveRecord::TestCase
   fixtures :owners
 
   setup do
     @owner = Class.new(Owner) do
-      def self.name; 'Owner'; end
+      def self.name; "Owner"; end
     end
   end
 
 
   def test_validates_size_of_association
     assert_nothing_raised { @owner.validates_size_of :pets, minimum: 1 }
-    o = @owner.new('name' => 'nopets')
+    o = @owner.new("name" => "nopets")
     assert !o.save
     assert o.errors[:pets].any?
-    o.pets.build('name' => 'apet')
+    o.pets.build("name" => "apet")
     assert o.valid?
   end
 
   def test_validates_size_of_association_using_within
     assert_nothing_raised { @owner.validates_size_of :pets, within: 1..2 }
-    o = @owner.new('name' => 'nopets')
+    o = @owner.new("name" => "nopets")
     assert !o.save
     assert o.errors[:pets].any?
 
-    o.pets.build('name' => 'apet')
+    o.pets.build("name" => "apet")
     assert o.valid?
 
-    2.times { o.pets.build('name' => 'apet') }
+    2.times { o.pets.build("name" => "apet") }
     assert !o.save
     assert o.errors[:pets].any?
   end
 
   def test_validates_size_of_association_utf8
     @owner.validates_size_of :pets, minimum: 1
-    o = @owner.new('name' => 'あいうえおかきくけこ')
+    o = @owner.new("name" => "あいうえおかきくけこ")
     assert !o.save
     assert o.errors[:pets].any?
-    o.pets.build('name' => 'あいうえおかきくけこ')
+    o.pets.build("name" => "あいうえおかきくけこ")
     assert o.valid?
   end
 
@@ -67,11 +67,11 @@ class LengthValidationTest < ActiveRecord::TestCase
       Pet.validates_length_of(:name, minimum: 1)
       Pet.validates_length_of(:nickname, minimum: 1)
 
-      pet = Pet.create!(name: 'Fancy Pants', nickname: 'Fancy')
+      pet = Pet.create!(name: "Fancy Pants", nickname: "Fancy")
 
       assert pet.valid?
 
-      pet.nickname = ''
+      pet.nickname = ""
 
       assert pet.invalid?
     end
diff --git a/activerecord/test/cases/validations/presence_validation_test.rb b/activerecord/test/cases/validations/presence_validation_test.rb
index 868d111b8c..13956e26ec 100644
--- a/activerecord/test/cases/validations/presence_validation_test.rb
+++ b/activerecord/test/cases/validations/presence_validation_test.rb
@@ -1,9 +1,9 @@
 require "cases/helper"
-require 'models/man'
-require 'models/face'
-require 'models/interest'
-require 'models/speedometer'
-require 'models/dashboard'
+require "models/man"
+require "models/face"
+require "models/interest"
+require "models/speedometer"
+require "models/dashboard"
 
 class PresenceValidationTest < ActiveRecord::TestCase
   class Boy < Man; end
@@ -57,7 +57,7 @@ class PresenceValidationTest < ActiveRecord::TestCase
     dash = Dashboard.new
 
     # dashboard has to_a method
-    def dash.to_a; ['(/)', '(\)']; end
+    def dash.to_a; ["(/)", '(\)']; end
 
     s = speedometer.new
     s.dashboard = dash
@@ -71,10 +71,10 @@ class PresenceValidationTest < ActiveRecord::TestCase
       Interest.validates_presence_of(:topic)
       Interest.validates_presence_of(:abbreviation)
 
-      interest = Interest.create!(topic: 'Thought Leadering', abbreviation: 'tl')
+      interest = Interest.create!(topic: "Thought Leadering", abbreviation: "tl")
       assert interest.valid?
 
-      interest.abbreviation = ''
+      interest.abbreviation = ""
 
       assert interest.invalid?
     end
diff --git a/activerecord/test/cases/validations/uniqueness_validation_test.rb b/activerecord/test/cases/validations/uniqueness_validation_test.rb
index 4b0a590adb..7abe9b6d36 100644
--- a/activerecord/test/cases/validations/uniqueness_validation_test.rb
+++ b/activerecord/test/cases/validations/uniqueness_validation_test.rb
@@ -1,11 +1,11 @@
 require "cases/helper"
-require 'models/topic'
-require 'models/reply'
-require 'models/warehouse_thing'
-require 'models/guid'
-require 'models/event'
-require 'models/dashboard'
-require 'models/uuid_item'
+require "models/topic"
+require "models/reply"
+require "models/warehouse_thing"
+require "models/guid"
+require "models/event"
+require "models/dashboard"
+require "models/uuid_item"
 
 class Wizard < ActiveRecord::Base
   self.abstract_class = true
@@ -38,13 +38,13 @@ end
 
 class BigIntTest < ActiveRecord::Base
   INT_MAX_VALUE = 2147483647
-  self.table_name = 'cars'
+  self.table_name = "cars"
   validates :engines_count, uniqueness: true, inclusion: { in: 0..INT_MAX_VALUE }
 end
 
 class BigIntReverseTest < ActiveRecord::Base
   INT_MAX_VALUE = 2147483647
-  self.table_name = 'cars'
+  self.table_name = "cars"
   validates :engines_count, inclusion: { in: 0..INT_MAX_VALUE }
   validates :engines_count, uniqueness: true
 end
@@ -64,7 +64,7 @@ end
 class UniquenessValidationTest < ActiveRecord::TestCase
   INT_MAX_VALUE = 2147483647
 
-  fixtures :topics, 'warehouse-things'
+  fixtures :topics, "warehouse-things"
 
   repair_validations(Topic, Reply)
 
@@ -90,7 +90,7 @@ class UniquenessValidationTest < ActiveRecord::TestCase
     Topic.alias_attribute :new_title, :title
     Topic.validates_uniqueness_of(:new_title)
 
-    topic = Topic.new(new_title: 'abc')
+    topic = Topic.new(new_title: "abc")
     assert topic.valid?
   end
 
@@ -108,21 +108,21 @@ class UniquenessValidationTest < ActiveRecord::TestCase
 
   def test_validates_uniqueness_with_validates
     Topic.validates :title, :uniqueness => true
-    Topic.create!('title' => 'abc')
+    Topic.create!("title" => "abc")
 
-    t2 = Topic.new('title' => 'abc')
+    t2 = Topic.new("title" => "abc")
     assert !t2.valid?
     assert t2.errors[:title]
   end
 
   def test_validate_uniqueness_when_integer_out_of_range
     entry = BigIntTest.create(engines_count: INT_MAX_VALUE + 1)
-    assert_equal entry.errors[:engines_count], ['is not included in the list']
+    assert_equal entry.errors[:engines_count], ["is not included in the list"]
   end
 
   def test_validate_uniqueness_when_integer_out_of_range_show_order_does_not_matter
     entry = BigIntReverseTest.create(engines_count: INT_MAX_VALUE + 1)
-    assert_equal entry.errors[:engines_count], ['is not included in the list']
+    assert_equal entry.errors[:engines_count], ["is not included in the list"]
   end
 
   def test_validates_uniqueness_with_newline_chars
@@ -256,7 +256,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.all.merge!(:select => 'LOWER(title) AS title').find(t_utf8.id).title == "я тоже уникальный!"
+    if Topic.all.merge!(:select => "LOWER(title) AS title").find(t_utf8.id).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"
@@ -315,9 +315,9 @@ class UniquenessValidationTest < ActiveRecord::TestCase
 
   def test_validate_case_sensitive_uniqueness_with_attribute_passed_as_integer
     Topic.validates_uniqueness_of(:title, :case_sensitive => true)
-    Topic.create!('title' => 101)
+    Topic.create!("title" => 101)
 
-    t2 = Topic.new('title' => 101)
+    t2 = Topic.new("title" => 101)
     assert !t2.valid?
     assert t2.errors[:title]
   end
@@ -439,7 +439,7 @@ class UniquenessValidationTest < ActiveRecord::TestCase
 
     topic = TopicWithUniqEvent.new(event: event)
     assert_not topic.valid?
-    assert_equal ['has already been taken'], topic.errors[:event]
+    assert_equal ["has already been taken"], topic.errors[:event]
   end
 
   def test_validate_uniqueness_on_empty_relation
@@ -511,20 +511,20 @@ class UniquenessValidationTest < ActiveRecord::TestCase
 
   def test_validate_uniqueness_uuid
     skip unless current_adapter?(:PostgreSQLAdapter)
-    item = UuidItem.create!(uuid: SecureRandom.uuid, title: 'item1')
-    item.update(title: 'item1-title2')
+    item = UuidItem.create!(uuid: SecureRandom.uuid, title: "item1")
+    item.update(title: "item1-title2")
     assert_empty item.errors
 
-    item2 = UuidValidatingItem.create!(uuid: SecureRandom.uuid, title: 'item2')
-    item2.update(title: 'item2-title2')
+    item2 = UuidValidatingItem.create!(uuid: SecureRandom.uuid, title: "item2")
+    item2.update(title: "item2-title2")
     assert_empty item2.errors
   end
 
   def test_validate_uniqueness_regular_id
-    item = CoolTopic.create!(title: 'MyItem')
+    item = CoolTopic.create!(title: "MyItem")
     assert_empty item.errors
 
-    item2 = CoolTopic.new(id: item.id, title: 'MyItem2')
+    item2 = CoolTopic.new(id: item.id, title: "MyItem2")
     refute item2.valid?
 
     assert_equal(["has already been taken"], item2.errors[:id])
diff --git a/activerecord/test/cases/validations_test.rb b/activerecord/test/cases/validations_test.rb
index 85e33d2218..95652955c2 100644
--- a/activerecord/test/cases/validations_test.rb
+++ b/activerecord/test/cases/validations_test.rb
@@ -1,11 +1,11 @@
 require "cases/helper"
-require 'models/topic'
-require 'models/reply'
-require 'models/person'
-require 'models/developer'
-require 'models/computer'
-require 'models/parrot'
-require 'models/company'
+require "models/topic"
+require "models/reply"
+require "models/person"
+require "models/developer"
+require "models/computer"
+require "models/parrot"
+require "models/company"
 
 class ValidationsTest < ActiveRecord::TestCase
   fixtures :topics, :developers
@@ -53,7 +53,7 @@ class ValidationsTest < ActiveRecord::TestCase
   end
 
   def test_invalid_using_multiple_contexts
-    r = WrongReply.new(:title => 'Wrong Create')
+    r = WrongReply.new(:title => "Wrong Create")
     assert r.invalid?([:special_case, :create])
     assert_equal "Invalid", r.errors[:author_name].join
     assert_equal "is Wrong Create", r.errors[:title].join
@@ -161,8 +161,8 @@ class ValidationsTest < ActiveRecord::TestCase
       validates_numericality_of :wibble, only_integer: true
     end
 
-    topic = Topic.new(wibble: '123-4567')
-    topic.wibble.gsub!('-', '')
+    topic = Topic.new(wibble: "123-4567")
+    topic.wibble.gsub!("-", "")
 
     assert topic.valid?
   ensure
@@ -171,7 +171,7 @@ class ValidationsTest < ActiveRecord::TestCase
 
   def test_acceptance_validator_doesnt_require_db_connection
     klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'posts'
+      self.table_name = "posts"
     end
     klass.reset_column_information
 
diff --git a/activerecord/test/cases/yaml_serialization_test.rb b/activerecord/test/cases/yaml_serialization_test.rb
index d1c9a00786..ac1dc4a453 100644
--- a/activerecord/test/cases/yaml_serialization_test.rb
+++ b/activerecord/test/cases/yaml_serialization_test.rb
@@ -1,8 +1,8 @@
-require 'cases/helper'
-require 'models/topic'
-require 'models/reply'
-require 'models/post'
-require 'models/author'
+require "cases/helper"
+require "models/topic"
+require "models/reply"
+require "models/post"
+require "models/author"
 
 class YamlSerializationTest < ActiveRecord::TestCase
   fixtures :topics, :authors, :posts
@@ -67,16 +67,16 @@ class YamlSerializationTest < ActiveRecord::TestCase
     assert_not topic.new_record?, "Saved records are not new"
     assert_not YAML.load(YAML.dump(topic)).new_record?, "Saved record should not be new after deserialization"
 
-    topic = Topic.select('title').last
+    topic = Topic.select("title").last
 
     assert_not topic.new_record?, "Loaded records without ID are not new"
     assert_not YAML.load(YAML.dump(topic)).new_record?, "Record should not be new after deserialization"
   end
 
   def test_types_of_virtual_columns_are_not_changed_on_round_trip
-    author = Author.select('authors.*, count(posts.id) as posts_count')
+    author = Author.select("authors.*, count(posts.id) as posts_count")
       .joins(:posts)
-      .group('authors.id')
+      .group("authors.id")
       .first
     dumped = YAML.load(YAML.dump(author))
 
@@ -88,7 +88,7 @@ class YamlSerializationTest < ActiveRecord::TestCase
     coder = {}
     Topic.first.encode_with(coder)
 
-    assert coder['active_record_yaml_version']
+    assert coder["active_record_yaml_version"]
   end
 
   def test_deserializing_rails_41_yaml
diff --git a/activerecord/test/models/admin.rb b/activerecord/test/models/admin.rb
index a38e3f4846..bc3ce23447 100644
--- a/activerecord/test/models/admin.rb
+++ b/activerecord/test/models/admin.rb
@@ -1,5 +1,5 @@
 module Admin
   def self.table_name_prefix
-    'admin_'
+    "admin_"
   end
 end
diff --git a/activerecord/test/models/admin/user.rb b/activerecord/test/models/admin/user.rb
index 48a110bd23..3cd829a8d5 100644
--- a/activerecord/test/models/admin/user.rb
+++ b/activerecord/test/models/admin/user.rb
@@ -26,15 +26,15 @@ class Admin::User < ActiveRecord::Base
   end
 
   def phone_number=(value)
-    write_store_attribute(:settings, :phone_number, value && value.gsub(/[^\d]/,''))
+    write_store_attribute(:settings, :phone_number, value && value.gsub(/[^\d]/,""))
   end
 
   def color
-    super || 'red'
+    super || "red"
   end
 
   def color=(value)
-    value = 'blue' unless %w(black red green blue).include?(value)
+    value = "blue" unless %w(black red green blue).include?(value)
     super
   end
 end
diff --git a/activerecord/test/models/author.rb b/activerecord/test/models/author.rb
index 38b983eda0..a9f3063736 100644
--- a/activerecord/test/models/author.rb
+++ b/activerecord/test/models/author.rb
@@ -5,60 +5,60 @@ class Author < ActiveRecord::Base
   has_many :very_special_comments, :through => :posts
   has_many :posts_with_comments, -> { includes(:comments) }, :class_name => "Post"
   has_many :popular_grouped_posts, -> { includes(:comments).group("type").having("SUM(comments_count) > 1").select("type") }, :class_name => "Post"
-  has_many :posts_with_comments_sorted_by_comment_id, -> { includes(:comments).order('comments.id') }, :class_name => "Post"
-  has_many :posts_sorted_by_id_limited, -> { order('posts.id').limit(1) }, :class_name => "Post"
+  has_many :posts_with_comments_sorted_by_comment_id, -> { includes(:comments).order("comments.id") }, :class_name => "Post"
+  has_many :posts_sorted_by_id_limited, -> { order("posts.id").limit(1) }, :class_name => "Post"
   has_many :posts_with_categories, -> { includes(:categories) }, :class_name => "Post"
   has_many :posts_with_comments_and_categories, -> { includes(:comments, :categories).order("posts.id") }, :class_name => "Post"
-  has_many :posts_with_special_categorizations, :class_name => 'PostWithSpecialCategorization'
-  has_one  :post_about_thinking, -> { where("posts.title like '%thinking%'") }, :class_name => 'Post'
-  has_one  :post_about_thinking_with_last_comment, -> { where("posts.title like '%thinking%'").includes(:last_comment) }, :class_name => 'Post'
+  has_many :posts_with_special_categorizations, :class_name => "PostWithSpecialCategorization"
+  has_one  :post_about_thinking, -> { where("posts.title like '%thinking%'") }, :class_name => "Post"
+  has_one  :post_about_thinking_with_last_comment, -> { where("posts.title like '%thinking%'").includes(:last_comment) }, :class_name => "Post"
   has_many :comments, through: :posts do
     def ratings
       Rating.joins(:comment).merge(self)
     end
   end
   has_many :comments_containing_the_letter_e, :through => :posts, :source => :comments
-  has_many :comments_with_order_and_conditions, -> { order('comments.body').where("comments.body like 'Thank%'") }, :through => :posts, :source => :comments
+  has_many :comments_with_order_and_conditions, -> { order("comments.body").where("comments.body like 'Thank%'") }, :through => :posts, :source => :comments
   has_many :comments_with_include, -> { includes(:post) }, :through => :posts, :source => :comments
 
   has_many :first_posts
-  has_many :comments_on_first_posts, -> { order('posts.id desc, comments.id asc') }, :through => :first_posts, :source => :comments
+  has_many :comments_on_first_posts, -> { order("posts.id desc, comments.id asc") }, :through => :first_posts, :source => :comments
 
   has_one :first_post
-  has_one :comment_on_first_post, -> { order('posts.id desc, comments.id asc') }, :through => :first_post, :source => :comments
+  has_one :comment_on_first_post, -> { order("posts.id desc, comments.id asc") }, :through => :first_post, :source => :comments
 
-  has_many :thinking_posts, -> { where(:title => 'So I was thinking') }, :dependent => :delete_all, :class_name => 'Post'
-  has_many :welcome_posts, -> { where(:title => 'Welcome to the weblog') }, :class_name => 'Post'
+  has_many :thinking_posts, -> { where(:title => "So I was thinking") }, :dependent => :delete_all, :class_name => "Post"
+  has_many :welcome_posts, -> { where(:title => "Welcome to the weblog") }, :class_name => "Post"
 
   has_many :welcome_posts_with_one_comment,
-           -> { where(title: 'Welcome to the weblog').where('comments_count = ?', 1) },
-           class_name: 'Post'
+           -> { where(title: "Welcome to the weblog").where("comments_count = ?", 1) },
+           class_name: "Post"
   has_many :welcome_posts_with_comments,
-           -> { where(title: 'Welcome to the weblog').where(Post.arel_table[:comments_count].gt(0)) },
-           class_name: 'Post'
+           -> { where(title: "Welcome to the weblog").where(Post.arel_table[:comments_count].gt(0)) },
+           class_name: "Post"
 
-  has_many :comments_desc, -> { order('comments.id DESC') }, :through => :posts, :source => :comments
+  has_many :comments_desc, -> { order("comments.id DESC") }, :through => :posts, :source => :comments
   has_many :funky_comments, :through => :posts, :source => :comments
-  has_many :ordered_uniq_comments, -> { distinct.order('comments.id') }, :through => :posts, :source => :comments
-  has_many :ordered_uniq_comments_desc, -> { distinct.order('comments.id DESC') }, :through => :posts, :source => :comments
+  has_many :ordered_uniq_comments, -> { distinct.order("comments.id") }, :through => :posts, :source => :comments
+  has_many :ordered_uniq_comments_desc, -> { distinct.order("comments.id DESC") }, :through => :posts, :source => :comments
   has_many :readonly_comments, -> { readonly }, :through => :posts, :source => :comments
 
   has_many :special_posts
   has_many :special_post_comments, :through => :special_posts, :source => :comments
-  has_many :special_posts_with_default_scope, :class_name => 'SpecialPostWithDefaultScope'
+  has_many :special_posts_with_default_scope, :class_name => "SpecialPostWithDefaultScope"
 
-  has_many :sti_posts, :class_name => 'StiPost'
+  has_many :sti_posts, :class_name => "StiPost"
   has_many :sti_post_comments, :through => :sti_posts, :source => :comments
 
   has_many :special_nonexistent_posts, -> { where("posts.body = 'nonexistent'") }, :class_name => "SpecialPost"
-  has_many :special_nonexistent_post_comments, -> { where('comments.post_id' => 0) }, :through => :special_nonexistent_posts, :source => :comments
+  has_many :special_nonexistent_post_comments, -> { where("comments.post_id" => 0) }, :through => :special_nonexistent_posts, :source => :comments
   has_many :nonexistent_comments, :through => :posts
 
   has_many :hello_posts, -> { where "posts.body = 'hello'" }, :class_name => "Post"
   has_many :hello_post_comments, :through => :hello_posts, :source => :comments
-  has_many :posts_with_no_comments, -> { where('comments.id' => nil).includes(:comments) }, :class_name => 'Post'
+  has_many :posts_with_no_comments, -> { where("comments.id" => nil).includes(:comments) }, :class_name => "Post"
 
-  has_many :hello_posts_with_hash_conditions, -> { where(:body => 'hello') }, :class_name => "Post"
+  has_many :hello_posts_with_hash_conditions, -> { where(:body => "hello") }, :class_name => "Post"
   has_many :hello_post_comments_with_hash_conditions, :through =>
 :hello_posts_with_hash_conditions, :source => :comments
 
@@ -85,15 +85,15 @@ class Author < ActiveRecord::Base
   has_many :special_categories, :through => :special_categorizations, :source => :category
   has_one  :special_category,   :through => :special_categorizations, :source => :category
 
-  has_many :categories_like_general, -> { where(:name => 'General') }, :through => :categorizations, :source => :category, :class_name => 'Category'
+  has_many :categories_like_general, -> { where(:name => "General") }, :through => :categorizations, :source => :category, :class_name => "Category"
 
   has_many :categorized_posts, :through => :categorizations, :source => :post
   has_many :unique_categorized_posts, -> { distinct }, :through => :categorizations, :source => :post
 
-  has_many :nothings, :through => :kateggorisatons, :class_name => 'Category'
+  has_many :nothings, :through => :kateggorisatons, :class_name => "Category"
 
   has_many :author_favorites
-  has_many :favorite_authors, -> { order('name') }, :through => :author_favorites
+  has_many :favorite_authors, -> { order("name") }, :through => :author_favorites
 
   has_many :taggings,        :through => :posts, :source => :taggings
   has_many :taggings_2,      :through => :posts, :source => :tagging
@@ -115,17 +115,17 @@ class Author < ActiveRecord::Base
   has_one :essay_category, :through => :essay, :source => :category
   has_one :essay_owner, :through => :essay, :source => :owner
 
-  has_one :essay_2, :primary_key => :name, :class_name => 'Essay', :foreign_key => :author_id
+  has_one :essay_2, :primary_key => :name, :class_name => "Essay", :foreign_key => :author_id
   has_one :essay_category_2, :through => :essay_2, :source => :category
 
   has_many :essays, :primary_key => :name, :as => :writer
   has_many :essay_categories, :through => :essays, :source => :category
   has_many :essay_owners, :through => :essays, :source => :owner
 
-  has_many :essays_2, :primary_key => :name, :class_name => 'Essay', :foreign_key => :author_id
+  has_many :essays_2, :primary_key => :name, :class_name => "Essay", :foreign_key => :author_id
   has_many :essay_categories_2, :through => :essays_2, :source => :category
 
-  belongs_to :owned_essay, :primary_key => :name, :class_name => 'Essay'
+  belongs_to :owned_essay, :primary_key => :name, :class_name => "Essay"
   has_one :owned_essay_category, :through => :owned_essay, :source => :category
 
   belongs_to :author_address,       :dependent => :destroy
@@ -133,13 +133,13 @@ class Author < ActiveRecord::Base
 
   has_many :category_post_comments, :through => :categories, :source => :post_comments
 
-  has_many :misc_posts, -> { where(:posts => { :title => ['misc post by bob', 'misc post by mary'] }) }, :class_name => 'Post'
+  has_many :misc_posts, -> { where(:posts => { :title => ["misc post by bob", "misc post by mary"] }) }, :class_name => "Post"
   has_many :misc_post_first_blue_tags, :through => :misc_posts, :source => :first_blue_tags
 
-  has_many :misc_post_first_blue_tags_2, -> { where(:posts => { :title => ['misc post by bob', 'misc post by mary'] }) },
+  has_many :misc_post_first_blue_tags_2, -> { where(:posts => { :title => ["misc post by bob", "misc post by mary"] }) },
            :through => :posts, :source => :first_blue_tags_2
 
-  has_many :posts_with_default_include, :class_name => 'PostWithDefaultInclude'
+  has_many :posts_with_default_include, :class_name => "PostWithDefaultInclude"
   has_many :comments_on_posts_with_default_include, :through => :posts_with_default_include, :source => :comments
 
   has_many :posts_with_signature, ->(record) { where("posts.title LIKE ?", "%by #{record.name.downcase}%") }, class_name: "Post"
diff --git a/activerecord/test/models/book.rb b/activerecord/test/models/book.rb
index e43e5c3901..5db4f64b74 100644
--- a/activerecord/test/models/book.rb
+++ b/activerecord/test/models/book.rb
@@ -1,7 +1,7 @@
 class Book < ActiveRecord::Base
   has_many :authors
 
-  has_many :citations, :foreign_key => 'book1_id'
+  has_many :citations, :foreign_key => "book1_id"
   has_many :references, -> { distinct }, through: :citations, source: :reference_of
 
   has_many :subscriptions
@@ -14,7 +14,7 @@ class Book < ActiveRecord::Base
   enum author_visibility: [:visible, :invisible], _prefix: true
   enum illustrator_visibility: [:visible, :invisible], _prefix: true
   enum font_size: [:small, :medium, :large], _prefix: :with, _suffix: true
-  enum cover: { hard: 'hard', soft: 'soft' }
+  enum cover: { hard: "hard", soft: "soft" }
 
   def published!
     super
diff --git a/activerecord/test/models/bulb.rb b/activerecord/test/models/bulb.rb
index dc0296305a..88baa60035 100644
--- a/activerecord/test/models/bulb.rb
+++ b/activerecord/test/models/bulb.rb
@@ -1,5 +1,5 @@
 class Bulb < ActiveRecord::Base
-  default_scope { where(:name => 'defaulty') }
+  default_scope { where(:name => "defaulty") }
   belongs_to :car, :touch => true
   scope :awesome, -> { where(frickinawesome: true) }
 
@@ -35,7 +35,7 @@ class CustomBulb < Bulb
   after_initialize :set_awesomeness
 
   def set_awesomeness
-    self.frickinawesome = true if name == 'Dude'
+    self.frickinawesome = true if name == "Dude"
   end
 end
 
diff --git a/activerecord/test/models/car.rb b/activerecord/test/models/car.rb
index 0f37e9a289..9f129689ef 100644
--- a/activerecord/test/models/car.rb
+++ b/activerecord/test/models/car.rb
@@ -1,9 +1,9 @@
 class Car < ActiveRecord::Base
   has_many :bulbs
   has_many :all_bulbs, -> { unscope where: :name }, class_name: "Bulb"
-  has_many :funky_bulbs, class_name: 'FunkyBulb', dependent: :destroy
-  has_many :failed_bulbs, class_name: 'FailedBulb', dependent: :destroy
-  has_many :foo_bulbs, -> { where(:name => 'foo') }, :class_name => "Bulb"
+  has_many :funky_bulbs, class_name: "FunkyBulb", dependent: :destroy
+  has_many :failed_bulbs, class_name: "FailedBulb", dependent: :destroy
+  has_many :foo_bulbs, -> { where(:name => "foo") }, :class_name => "Bulb"
   has_many :awesome_bulbs, -> { awesome }, class_name: "Bulb"
 
   has_one :bulb
@@ -17,13 +17,13 @@ class Car < ActiveRecord::Base
   scope :incl_tyres, -> { includes(:tyres) }
   scope :incl_engines, -> { includes(:engines) }
 
-  scope :order_using_new_style,  -> { order('name asc') }
+  scope :order_using_new_style,  -> { order("name asc") }
 end
 
 class CoolCar < Car
-  default_scope { order('name desc') }
+  default_scope { order("name desc") }
 end
 
 class FastCar < Car
-  default_scope { order('name desc') }
+  default_scope { order("name desc") }
 end
diff --git a/activerecord/test/models/categorization.rb b/activerecord/test/models/categorization.rb
index 4cd67c970a..178aff0541 100644
--- a/activerecord/test/models/categorization.rb
+++ b/activerecord/test/models/categorization.rb
@@ -1,17 +1,17 @@
 class Categorization < ActiveRecord::Base
   belongs_to :post
   belongs_to :category, counter_cache: true
-  belongs_to :named_category, :class_name => 'Category', :foreign_key => :named_category_name, :primary_key => :name
+  belongs_to :named_category, :class_name => "Category", :foreign_key => :named_category_name, :primary_key => :name
   belongs_to :author
 
   has_many :post_taggings, :through => :author, :source => :taggings
 
-  belongs_to :author_using_custom_pk,  :class_name => 'Author', :foreign_key => :author_id, :primary_key => :author_address_extra_id
-  has_many   :authors_using_custom_pk, :class_name => 'Author', :foreign_key => :id,        :primary_key => :category_id
+  belongs_to :author_using_custom_pk,  :class_name => "Author", :foreign_key => :author_id, :primary_key => :author_address_extra_id
+  has_many   :authors_using_custom_pk, :class_name => "Author", :foreign_key => :id,        :primary_key => :category_id
 end
 
 class SpecialCategorization < ActiveRecord::Base
-  self.table_name = 'categorizations'
+  self.table_name = "categorizations"
   default_scope { where(:special => true) }
 
   belongs_to :author
diff --git a/activerecord/test/models/category.rb b/activerecord/test/models/category.rb
index 272223e1d8..0c6794ff65 100644
--- a/activerecord/test/models/category.rb
+++ b/activerecord/test/models/category.rb
@@ -5,20 +5,20 @@ class Category < ActiveRecord::Base
   has_and_belongs_to_many :posts_with_authors_sorted_by_author_id, -> { includes(:authors).order("authors.id") }, :class_name => "Post"
 
   has_and_belongs_to_many :select_testing_posts,
-                          -> { select 'posts.*, 1 as correctness_marker' },
-                          :class_name => 'Post',
-                          :foreign_key => 'category_id',
-                          :association_foreign_key => 'post_id'
+                          -> { select "posts.*, 1 as correctness_marker" },
+                          :class_name => "Post",
+                          :foreign_key => "category_id",
+                          :association_foreign_key => "post_id"
 
   has_and_belongs_to_many :post_with_conditions,
-                          -> { where :title => 'Yet Another Testing Title' },
-                          :class_name => 'Post'
+                          -> { where :title => "Yet Another Testing Title" },
+                          :class_name => "Post"
 
   has_and_belongs_to_many :popular_grouped_posts, -> { group("posts.type").having("sum(comments.post_id) > 2").includes(:comments) }, :class_name => "Post"
   has_and_belongs_to_many :posts_grouped_by_title, -> { group("title").select("title") }, :class_name => "Post"
 
   def self.what_are_you
-    'a category...'
+    "a category..."
   end
 
   has_many :categorizations
@@ -26,9 +26,9 @@ class Category < ActiveRecord::Base
   has_many :post_comments, :through => :posts, :source => :comments
 
   has_many :authors, :through => :categorizations
-  has_many :authors_with_select, -> { select 'authors.*, categorizations.post_id' }, :through => :categorizations, :source => :author
+  has_many :authors_with_select, -> { select "authors.*, categorizations.post_id" }, :through => :categorizations, :source => :author
 
-  scope :general, -> { where(:name => 'General') }
+  scope :general, -> { where(:name => "General") }
 end
 
 class SpecialCategory < Category
diff --git a/activerecord/test/models/club.rb b/activerecord/test/models/club.rb
index 6ceafe5858..e1b3e706f2 100644
--- a/activerecord/test/models/club.rb
+++ b/activerecord/test/models/club.rb
@@ -18,6 +18,6 @@ end
 class SuperClub < ActiveRecord::Base
   self.table_name = "clubs"
 
-  has_many :memberships, class_name: 'SuperMembership', foreign_key: 'club_id'
+  has_many :memberships, class_name: "SuperMembership", foreign_key: "club_id"
   has_many :members, through: :memberships
 end
diff --git a/activerecord/test/models/college.rb b/activerecord/test/models/college.rb
index 501af4a8dd..c9dbe1ecc2 100644
--- a/activerecord/test/models/college.rb
+++ b/activerecord/test/models/college.rb
@@ -1,5 +1,5 @@
-require_dependency 'models/arunit2_model'
-require 'active_support/core_ext/object/with_options'
+require_dependency "models/arunit2_model"
+require "active_support/core_ext/object/with_options"
 
 class College < ARUnit2Model
   has_many :courses
diff --git a/activerecord/test/models/comment.rb b/activerecord/test/models/comment.rb
index dcc5c5a310..45463b69f2 100644
--- a/activerecord/test/models/comment.rb
+++ b/activerecord/test/models/comment.rb
@@ -16,11 +16,11 @@ class Comment < ActiveRecord::Base
   belongs_to :first_post, :foreign_key => :post_id
   belongs_to :special_post_with_default_scope, foreign_key: :post_id
 
-  has_many :children, :class_name => 'Comment', :foreign_key => :parent_id
-  belongs_to :parent, :class_name => 'Comment', :counter_cache => :children_count
+  has_many :children, :class_name => "Comment", :foreign_key => :parent_id
+  belongs_to :parent, :class_name => "Comment", :counter_cache => :children_count
 
   def self.what_are_you
-    'a comment...'
+    "a comment..."
   end
 
   def self.search_by_type(q)
@@ -55,6 +55,6 @@ class CommentThatAutomaticallyAltersPostBody < Comment
 end
 
 class CommentWithDefaultScopeReferencesAssociation < Comment
-  default_scope ->{ includes(:developer).order('developers.name').references(:developer) }
+  default_scope ->{ includes(:developer).order("developers.name").references(:developer) }
   belongs_to :developer
 end
diff --git a/activerecord/test/models/company.rb b/activerecord/test/models/company.rb
index 1dcd9fc21e..6a01dae18d 100644
--- a/activerecord/test/models/company.rb
+++ b/activerecord/test/models/company.rb
@@ -13,7 +13,7 @@ class Company < AbstractCompany
 
   scope :of_first_firm, lambda {
     joins(:account => :firm).
-    where('firms.id' => 1)
+    where("firms.id" => 1)
   }
 
   def arbitrary_method
@@ -35,7 +35,7 @@ module Namespaced
   end
 
   class Firm < ::Company
-    has_many :clients, :class_name => 'Namespaced::Client'
+    has_many :clients, :class_name => "Namespaced::Client"
   end
 
   class Client < ::Company
@@ -57,33 +57,33 @@ class Firm < Company
   has_many :limited_clients, -> { limit 1 }, :class_name => "Client"
   has_many :clients_with_interpolated_conditions, ->(firm) { where "rating > #{firm.rating}" }, :class_name => "Client"
   has_many :clients_like_ms, -> { where("name = 'Microsoft'").order("id") }, :class_name => "Client"
-  has_many :clients_like_ms_with_hash_conditions, -> { where(:name => 'Microsoft').order("id") }, :class_name => "Client"
-  has_many :plain_clients, :class_name => 'Client'
-  has_many :clients_using_primary_key, :class_name => 'Client',
-           :primary_key => 'name', :foreign_key => 'firm_name'
-  has_many :clients_using_primary_key_with_delete_all, :class_name => 'Client',
-           :primary_key => 'name', :foreign_key => 'firm_name', :dependent => :delete_all
+  has_many :clients_like_ms_with_hash_conditions, -> { where(:name => "Microsoft").order("id") }, :class_name => "Client"
+  has_many :plain_clients, :class_name => "Client"
+  has_many :clients_using_primary_key, :class_name => "Client",
+           :primary_key => "name", :foreign_key => "firm_name"
+  has_many :clients_using_primary_key_with_delete_all, :class_name => "Client",
+           :primary_key => "name", :foreign_key => "firm_name", :dependent => :delete_all
   has_many :clients_grouped_by_firm_id, -> { group("firm_id").select("firm_id") }, :class_name => "Client"
   has_many :clients_grouped_by_name, -> { group("name").select("name") }, :class_name => "Client"
 
   has_one :account, :foreign_key => "firm_id", :dependent => :destroy, :validate => true
-  has_one :unvalidated_account, :foreign_key => "firm_id", :class_name => 'Account', :validate => false
-  has_one :account_with_select, -> { select("id, firm_id") }, :foreign_key => "firm_id", :class_name=>'Account'
+  has_one :unvalidated_account, :foreign_key => "firm_id", :class_name => "Account", :validate => false
+  has_one :account_with_select, -> { select("id, firm_id") }, :foreign_key => "firm_id", :class_name=>"Account"
   has_one :readonly_account, -> { readonly }, :foreign_key => "firm_id", :class_name => "Account"
   # added order by id as in fixtures there are two accounts for Rails Core
   # Oracle tests were failing because of that as the second fixture was selected
-  has_one :account_using_primary_key, -> { order('id') }, :primary_key => "firm_id", :class_name => "Account"
+  has_one :account_using_primary_key, -> { order("id") }, :primary_key => "firm_id", :class_name => "Account"
   has_one :account_using_foreign_and_primary_keys, :foreign_key => "firm_name", :primary_key => "name", :class_name => "Account"
-  has_one :account_with_inexistent_foreign_key, class_name: 'Account', foreign_key: "inexistent"
+  has_one :account_with_inexistent_foreign_key, class_name: "Account", foreign_key: "inexistent"
   has_one :deletable_account, :foreign_key => "firm_id", :class_name => "Account", :dependent => :delete
 
   has_one :account_limit_500_with_hash_conditions, -> { where :credit_limit => 500 }, :foreign_key => "firm_id", :class_name => "Account"
 
-  has_one :unautosaved_account, :foreign_key => "firm_id", :class_name => 'Account', :autosave => false
+  has_one :unautosaved_account, :foreign_key => "firm_id", :class_name => "Account", :autosave => false
   has_many :accounts
-  has_many :unautosaved_accounts, :foreign_key => "firm_id", :class_name => 'Account', :autosave => false
+  has_many :unautosaved_accounts, :foreign_key => "firm_id", :class_name => "Account", :autosave => false
 
-  has_many :association_with_references, -> { references(:foo) }, :class_name => 'Client'
+  has_many :association_with_references, -> { references(:foo) }, :class_name => "Client"
 
   has_one :lead_developer, class_name: "Developer"
   has_many :projects
@@ -104,18 +104,18 @@ end
 
 class DependentFirm < Company
   has_one :account, :foreign_key => "firm_id", :dependent => :nullify
-  has_many :companies, :foreign_key => 'client_of', :dependent => :nullify
-  has_one :company, :foreign_key => 'client_of', :dependent => :nullify
+  has_many :companies, :foreign_key => "client_of", :dependent => :nullify
+  has_one :company, :foreign_key => "client_of", :dependent => :nullify
 end
 
 class RestrictedWithExceptionFirm < Company
   has_one :account, -> { order("id") }, :foreign_key => "firm_id", :dependent => :restrict_with_exception
-  has_many :companies, -> { order("id") }, :foreign_key => 'client_of', :dependent => :restrict_with_exception
+  has_many :companies, -> { order("id") }, :foreign_key => "client_of", :dependent => :restrict_with_exception
 end
 
 class RestrictedWithErrorFirm < Company
   has_one :account, -> { order("id") }, :foreign_key => "firm_id", :dependent => :restrict_with_error
-  has_many :companies, -> { order("id") }, :foreign_key => 'client_of', :dependent => :restrict_with_error
+  has_many :companies, -> { order("id") }, :foreign_key => "client_of", :dependent => :restrict_with_error
 end
 
 class Client < Company
@@ -183,7 +183,7 @@ end
 class ExclusivelyDependentFirm < Company
   has_one :account, :foreign_key => "firm_id", :dependent => :delete
   has_many :dependent_sanitized_conditional_clients_of_firm, -> { order("id").where("name = 'BigShot Inc.'") }, :foreign_key => "client_of", :class_name => "Client", :dependent => :delete_all
-  has_many :dependent_conditional_clients_of_firm, -> { order("id").where("name = ?", 'BigShot Inc.') }, :foreign_key => "client_of", :class_name => "Client", :dependent => :delete_all
+  has_many :dependent_conditional_clients_of_firm, -> { order("id").where("name = ?", "BigShot Inc.") }, :foreign_key => "client_of", :class_name => "Client", :dependent => :delete_all
 end
 
 class SpecialClient < Client
@@ -193,7 +193,7 @@ class VerySpecialClient < SpecialClient
 end
 
 class Account < ActiveRecord::Base
-  belongs_to :firm, :class_name => 'Company'
+  belongs_to :firm, :class_name => "Company"
   belongs_to :unautosaved_firm, :foreign_key => "firm_id", :class_name => "Firm", :autosave => false
 
   alias_attribute :available_credit, :credit_limit
@@ -204,7 +204,7 @@ class Account < ActiveRecord::Base
 
   # Test private kernel method through collection proxy using has_many.
   def self.open
-    where('firm_name = ?', '37signals')
+    where("firm_name = ?", "37signals")
   end
 
   before_destroy do |account|
diff --git a/activerecord/test/models/company_in_module.rb b/activerecord/test/models/company_in_module.rb
index bf0a0d1c3e..b444f9c49c 100644
--- a/activerecord/test/models/company_in_module.rb
+++ b/activerecord/test/models/company_in_module.rb
@@ -1,4 +1,4 @@
-require 'active_support/core_ext/object/with_options'
+require "active_support/core_ext/object/with_options"
 
 module MyApplication
   module Business
@@ -10,7 +10,7 @@ module MyApplication
       has_many :clients_sorted_desc, -> { order("id DESC") }, :class_name => "Client"
       has_many :clients_of_firm, -> { order "id" }, :foreign_key => "client_of", :class_name => "Client"
       has_many :clients_like_ms, -> { where("name = 'Microsoft'").order("id") }, :class_name => "Client"
-      has_one :account, :class_name => 'MyApplication::Billing::Account', :dependent => :destroy
+      has_one :account, :class_name => "MyApplication::Billing::Account", :dependent => :destroy
     end
 
     class Client < Company
@@ -31,14 +31,14 @@ module MyApplication
 
     module Prefixed
       def self.table_name_prefix
-        'prefixed_'
+        "prefixed_"
       end
 
       class Company < ActiveRecord::Base
       end
 
       class Firm < Company
-        self.table_name = 'companies'
+        self.table_name = "companies"
       end
 
       module Nested
@@ -49,14 +49,14 @@ module MyApplication
 
     module Suffixed
       def self.table_name_suffix
-        '_suffixed'
+        "_suffixed"
       end
 
       class Company < ActiveRecord::Base
       end
 
       class Firm < Company
-        self.table_name = 'companies'
+        self.table_name = "companies"
       end
 
       module Nested
@@ -68,22 +68,22 @@ module MyApplication
 
   module Billing
     class Firm < ActiveRecord::Base
-      self.table_name = 'companies'
+      self.table_name = "companies"
     end
 
     module Nested
       class Firm < ActiveRecord::Base
-        self.table_name = 'companies'
+        self.table_name = "companies"
       end
     end
 
     class Account < ActiveRecord::Base
       with_options(:foreign_key => :firm_id) do |i|
-        i.belongs_to :firm, :class_name => 'MyApplication::Business::Firm'
-        i.belongs_to :qualified_billing_firm, :class_name => 'MyApplication::Billing::Firm'
-        i.belongs_to :unqualified_billing_firm, :class_name => 'Firm'
-        i.belongs_to :nested_qualified_billing_firm, :class_name => 'MyApplication::Billing::Nested::Firm'
-        i.belongs_to :nested_unqualified_billing_firm, :class_name => 'Nested::Firm'
+        i.belongs_to :firm, :class_name => "MyApplication::Business::Firm"
+        i.belongs_to :qualified_billing_firm, :class_name => "MyApplication::Billing::Firm"
+        i.belongs_to :unqualified_billing_firm, :class_name => "Firm"
+        i.belongs_to :nested_qualified_billing_firm, :class_name => "MyApplication::Billing::Nested::Firm"
+        i.belongs_to :nested_unqualified_billing_firm, :class_name => "Nested::Firm"
       end
 
       validate :check_empty_credit_limit
diff --git a/activerecord/test/models/computer.rb b/activerecord/test/models/computer.rb
index cc8deb1b2b..0295ff9736 100644
--- a/activerecord/test/models/computer.rb
+++ b/activerecord/test/models/computer.rb
@@ -1,3 +1,3 @@
 class Computer < ActiveRecord::Base
-  belongs_to :developer, :foreign_key=>'developer'
+  belongs_to :developer, :foreign_key=>"developer"
 end
diff --git a/activerecord/test/models/contact.rb b/activerecord/test/models/contact.rb
index 9f2f69e1ee..15e3832204 100644
--- a/activerecord/test/models/contact.rb
+++ b/activerecord/test/models/contact.rb
@@ -1,11 +1,11 @@
 module ContactFakeColumns
   def self.extended(base)
     base.class_eval do
-      establish_connection(:adapter => 'fake')
+      establish_connection(:adapter => "fake")
 
       connection.data_sources = [table_name]
       connection.primary_keys = {
-        table_name => 'id'
+        table_name => "id"
       }
 
       column :id,             :integer
@@ -19,7 +19,7 @@ module ContactFakeColumns
 
       serialize :preferences
 
-      belongs_to :alternative, :class_name => 'Contact'
+      belongs_to :alternative, :class_name => "Contact"
     end
   end
 
@@ -37,5 +37,5 @@ class ContactSti < ActiveRecord::Base
   extend ContactFakeColumns
   column :type, :string
 
-  def type; 'ContactSti' end
+  def type; "ContactSti" end
 end
diff --git a/activerecord/test/models/content.rb b/activerecord/test/models/content.rb
index 140e1dfc78..68db2127d8 100644
--- a/activerecord/test/models/content.rb
+++ b/activerecord/test/models/content.rb
@@ -1,5 +1,5 @@
 class Content < ActiveRecord::Base
-  self.table_name = 'content'
+  self.table_name = "content"
   has_one :content_position, dependent: :destroy
 
   def self.destroyed_ids
@@ -12,8 +12,8 @@ class Content < ActiveRecord::Base
 end
 
 class ContentWhichRequiresTwoDestroyCalls < ActiveRecord::Base
-  self.table_name = 'content'
-  has_one :content_position, foreign_key: 'content_id', dependent: :destroy
+  self.table_name = "content"
+  has_one :content_position, foreign_key: "content_id", dependent: :destroy
 
   after_initialize do
     @destroy_count = 0
diff --git a/activerecord/test/models/contract.rb b/activerecord/test/models/contract.rb
index cdf7b267b5..e16758498f 100644
--- a/activerecord/test/models/contract.rb
+++ b/activerecord/test/models/contract.rb
@@ -1,7 +1,7 @@
 class Contract < ActiveRecord::Base
   belongs_to :company
   belongs_to :developer
-  belongs_to :firm, :foreign_key => 'company_id'
+  belongs_to :firm, :foreign_key => "company_id"
 
   before_save :hi
   after_save :bye
diff --git a/activerecord/test/models/course.rb b/activerecord/test/models/course.rb
index f3d0e05ff7..348f2bf1e0 100644
--- a/activerecord/test/models/course.rb
+++ b/activerecord/test/models/course.rb
@@ -1,4 +1,4 @@
-require_dependency 'models/arunit2_model'
+require_dependency "models/arunit2_model"
 
 class Course < ARUnit2Model
   belongs_to :college
diff --git a/activerecord/test/models/developer.rb b/activerecord/test/models/developer.rb
index 9a907273f8..41cbe35cb4 100644
--- a/activerecord/test/models/developer.rb
+++ b/activerecord/test/models/developer.rb
@@ -1,4 +1,4 @@
-require 'ostruct'
+require "ostruct"
 
 module DeveloperProjectsAssociationExtension2
   def find_least_recent
@@ -43,11 +43,11 @@ class Developer < ActiveRecord::Base
         end
       end
 
-  has_and_belongs_to_many :special_projects, :join_table => 'developers_projects', :association_foreign_key => 'project_id'
+  has_and_belongs_to_many :special_projects, :join_table => "developers_projects", :association_foreign_key => "project_id"
   has_and_belongs_to_many :sym_special_projects,
                           :join_table => :developers_projects,
-                          :association_foreign_key => 'project_id',
-                          :class_name => 'SpecialProject'
+                          :association_foreign_key => "project_id",
+                          :class_name => "SpecialProject"
 
   has_many :audit_logs
   has_many :contracts
@@ -59,7 +59,7 @@ class Developer < ActiveRecord::Base
   belongs_to :firm
   has_many :contracted_projects, class_name: "Project"
 
-  scope :jamises, -> { where(:name => 'Jamis') }
+  scope :jamises, -> { where(:name => "Jamis") }
 
   validates_inclusion_of :salary, :in => 50000..200000
   validates_length_of    :name, :within => 3..20
@@ -69,7 +69,7 @@ class Developer < ActiveRecord::Base
   end
 
   attr_accessor :last_name
-  define_attribute_method 'last_name'
+  define_attribute_method "last_name"
 
   def log=(message)
     audit_logs.build :message => message
@@ -88,12 +88,12 @@ end
 
 class AuditLog < ActiveRecord::Base
   belongs_to :developer, :validate => true
-  belongs_to :unvalidated_developer, :class_name => 'Developer'
+  belongs_to :unvalidated_developer, :class_name => "Developer"
 end
 
 class DeveloperWithBeforeDestroyRaise < ActiveRecord::Base
-  self.table_name = 'developers'
-  has_and_belongs_to_many :projects, :join_table => 'developers_projects', :foreign_key => 'developer_id'
+  self.table_name = "developers"
+  has_and_belongs_to_many :projects, :join_table => "developers_projects", :foreign_key => "developer_id"
   before_destroy :raise_if_projects_empty!
 
   def raise_if_projects_empty!
@@ -102,63 +102,63 @@ class DeveloperWithBeforeDestroyRaise < ActiveRecord::Base
 end
 
 class DeveloperWithSelect < ActiveRecord::Base
-  self.table_name = 'developers'
-  default_scope { select('name') }
+  self.table_name = "developers"
+  default_scope { select("name") }
 end
 
 class DeveloperWithIncludes < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
   has_many :audit_logs, :foreign_key => :developer_id
   default_scope { includes(:audit_logs) }
 end
 
 class DeveloperFilteredOnJoins < ActiveRecord::Base
-  self.table_name = 'developers'
-  has_and_belongs_to_many :projects, -> { order('projects.id') }, :foreign_key => 'developer_id', :join_table => 'developers_projects'
+  self.table_name = "developers"
+  has_and_belongs_to_many :projects, -> { order("projects.id") }, :foreign_key => "developer_id", :join_table => "developers_projects"
 
   def self.default_scope
-    joins(:projects).where(:projects => { :name => 'Active Controller' })
+    joins(:projects).where(:projects => { :name => "Active Controller" })
   end
 end
 
 class DeveloperOrderedBySalary < ActiveRecord::Base
-  self.table_name = 'developers'
-  default_scope { order('salary DESC') }
+  self.table_name = "developers"
+  default_scope { order("salary DESC") }
 
-  scope :by_name, -> { order('name DESC') }
+  scope :by_name, -> { order("name DESC") }
 end
 
 class DeveloperCalledDavid < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
   default_scope { where("name = 'David'") }
 end
 
 class LazyLambdaDeveloperCalledDavid < ActiveRecord::Base
-  self.table_name = 'developers'
-  default_scope lambda { where(:name => 'David') }
+  self.table_name = "developers"
+  default_scope lambda { where(:name => "David") }
 end
 
 class LazyBlockDeveloperCalledDavid < ActiveRecord::Base
-  self.table_name = 'developers'
-  default_scope { where(:name => 'David') }
+  self.table_name = "developers"
+  default_scope { where(:name => "David") }
 end
 
 class CallableDeveloperCalledDavid < ActiveRecord::Base
-  self.table_name = 'developers'
-  default_scope OpenStruct.new(:call => where(:name => 'David'))
+  self.table_name = "developers"
+  default_scope OpenStruct.new(:call => where(:name => "David"))
 end
 
 class ClassMethodDeveloperCalledDavid < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
   def self.default_scope
-    where(:name => 'David')
+    where(:name => "David")
   end
 end
 
 class ClassMethodReferencingScopeDeveloperCalledDavid < ActiveRecord::Base
-  self.table_name = 'developers'
-  scope :david, -> { where(:name => 'David') }
+  self.table_name = "developers"
+  scope :david, -> { where(:name => "David") }
 
   def self.default_scope
     david
@@ -166,36 +166,36 @@ class ClassMethodReferencingScopeDeveloperCalledDavid < ActiveRecord::Base
 end
 
 class LazyBlockReferencingScopeDeveloperCalledDavid < ActiveRecord::Base
-  self.table_name = 'developers'
-  scope :david, -> { where(:name => 'David') }
+  self.table_name = "developers"
+  scope :david, -> { where(:name => "David") }
   default_scope { david }
 end
 
 class DeveloperCalledJamis < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
-  default_scope { where(:name => 'Jamis') }
-  scope :poor, -> { where('salary < 150000') }
+  default_scope { where(:name => "Jamis") }
+  scope :poor, -> { where("salary < 150000") }
   scope :david, -> { where name: "David" }
   scope :david2, -> { unscoped.where name: "David" }
 end
 
 class PoorDeveloperCalledJamis < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
-  default_scope -> { where(:name => 'Jamis', :salary => 50000) }
+  default_scope -> { where(:name => "Jamis", :salary => 50000) }
 end
 
 class InheritedPoorDeveloperCalledJamis < DeveloperCalledJamis
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
   default_scope -> { where(:salary => 50000) }
 end
 
 class MultiplePoorDeveloperCalledJamis < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
-  default_scope -> { where(:name => 'Jamis') }
+  default_scope -> { where(:name => "Jamis") }
   default_scope -> { where(:salary => 50000) }
 end
 
@@ -206,21 +206,21 @@ module SalaryDefaultScope
 end
 
 class ModuleIncludedPoorDeveloperCalledJamis < DeveloperCalledJamis
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
   include SalaryDefaultScope
 end
 
 class EagerDeveloperWithDefaultScope < ActiveRecord::Base
-  self.table_name = 'developers'
-  has_and_belongs_to_many :projects, -> { order('projects.id') }, :foreign_key => 'developer_id', :join_table => 'developers_projects'
+  self.table_name = "developers"
+  has_and_belongs_to_many :projects, -> { order("projects.id") }, :foreign_key => "developer_id", :join_table => "developers_projects"
 
   default_scope { includes(:projects) }
 end
 
 class EagerDeveloperWithClassMethodDefaultScope < ActiveRecord::Base
-  self.table_name = 'developers'
-  has_and_belongs_to_many :projects, -> { order('projects.id') }, :foreign_key => 'developer_id', :join_table => 'developers_projects'
+  self.table_name = "developers"
+  has_and_belongs_to_many :projects, -> { order("projects.id") }, :foreign_key => "developer_id", :join_table => "developers_projects"
 
   def self.default_scope
     includes(:projects)
@@ -228,28 +228,28 @@ class EagerDeveloperWithClassMethodDefaultScope < ActiveRecord::Base
 end
 
 class EagerDeveloperWithLambdaDefaultScope < ActiveRecord::Base
-  self.table_name = 'developers'
-  has_and_belongs_to_many :projects, -> { order('projects.id') }, :foreign_key => 'developer_id', :join_table => 'developers_projects'
+  self.table_name = "developers"
+  has_and_belongs_to_many :projects, -> { order("projects.id") }, :foreign_key => "developer_id", :join_table => "developers_projects"
 
   default_scope lambda { includes(:projects) }
 end
 
 class EagerDeveloperWithBlockDefaultScope < ActiveRecord::Base
-  self.table_name = 'developers'
-  has_and_belongs_to_many :projects, -> { order('projects.id') }, :foreign_key => 'developer_id', :join_table => 'developers_projects'
+  self.table_name = "developers"
+  has_and_belongs_to_many :projects, -> { order("projects.id") }, :foreign_key => "developer_id", :join_table => "developers_projects"
 
   default_scope { includes(:projects) }
 end
 
 class EagerDeveloperWithCallableDefaultScope < ActiveRecord::Base
-  self.table_name = 'developers'
-  has_and_belongs_to_many :projects, -> { order('projects.id') }, :foreign_key => 'developer_id', :join_table => 'developers_projects'
+  self.table_name = "developers"
+  has_and_belongs_to_many :projects, -> { order("projects.id") }, :foreign_key => "developer_id", :join_table => "developers_projects"
 
   default_scope OpenStruct.new(:call => includes(:projects))
 end
 
 class ThreadsafeDeveloper < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
   def self.default_scope
     sleep 0.05 if Thread.current[:long_default_scope]
diff --git a/activerecord/test/models/doubloon.rb b/activerecord/test/models/doubloon.rb
index 2b11d128e2..7272504666 100644
--- a/activerecord/test/models/doubloon.rb
+++ b/activerecord/test/models/doubloon.rb
@@ -8,5 +8,5 @@ end
 class Doubloon < AbstractDoubloon
   # This uses an abstract class that defines attributes and associations.
 
-  self.table_name = 'doubloons'
+  self.table_name = "doubloons"
 end
diff --git a/activerecord/test/models/edge.rb b/activerecord/test/models/edge.rb
index 55e0c31fcb..1de4756b28 100644
--- a/activerecord/test/models/edge.rb
+++ b/activerecord/test/models/edge.rb
@@ -1,5 +1,5 @@
 # This class models an edge in a directed graph.
 class Edge < ActiveRecord::Base
-  belongs_to :source, :class_name => 'Vertex', :foreign_key => 'source_id'
-  belongs_to :sink,   :class_name => 'Vertex', :foreign_key => 'sink_id'
+  belongs_to :source, :class_name => "Vertex", :foreign_key => "source_id"
+  belongs_to :sink,   :class_name => "Vertex", :foreign_key => "sink_id"
 end
diff --git a/activerecord/test/models/engine.rb b/activerecord/test/models/engine.rb
index 851ff8c22b..c30502e3ea 100644
--- a/activerecord/test/models/engine.rb
+++ b/activerecord/test/models/engine.rb
@@ -1,4 +1,4 @@
 class Engine < ActiveRecord::Base
-  belongs_to :my_car, :class_name => 'Car', :foreign_key => 'car_id',  :counter_cache => :engines_count
+  belongs_to :my_car, :class_name => "Car", :foreign_key => "car_id",  :counter_cache => :engines_count
 end
 
diff --git a/activerecord/test/models/face.rb b/activerecord/test/models/face.rb
index af76fea52c..5f33372b16 100644
--- a/activerecord/test/models/face.rb
+++ b/activerecord/test/models/face.rb
@@ -4,6 +4,6 @@ class Face < ActiveRecord::Base
   # Oracle identifier length is limited to 30 bytes or less, `polymorphic` renamed `poly`
   belongs_to :poly_man_without_inverse, :polymorphic => true
   # These is a "broken" inverse_of for the purposes of testing
-  belongs_to :horrible_man, :class_name => 'Man', :inverse_of => :horrible_face
+  belongs_to :horrible_man, :class_name => "Man", :inverse_of => :horrible_face
   belongs_to :horrible_polymorphic_man, :polymorphic => true, :inverse_of => :horrible_polymorphic_face
 end
diff --git a/activerecord/test/models/friendship.rb b/activerecord/test/models/friendship.rb
index 4b411ca8e0..578382b494 100644
--- a/activerecord/test/models/friendship.rb
+++ b/activerecord/test/models/friendship.rb
@@ -1,6 +1,6 @@
 class Friendship < ActiveRecord::Base
-  belongs_to :friend, class_name: 'Person'
+  belongs_to :friend, class_name: "Person"
   # friend_too exists to test a bug, and probably shouldn't be used elsewhere
-  belongs_to :friend_too, foreign_key: 'friend_id', class_name: 'Person', counter_cache: :friends_too_count
-  belongs_to :follower, class_name: 'Person'
+  belongs_to :friend_too, foreign_key: "friend_id", class_name: "Person", counter_cache: :friends_too_count
+  belongs_to :follower, class_name: "Person"
 end
diff --git a/activerecord/test/models/hotel.rb b/activerecord/test/models/hotel.rb
index 9c90ffcff4..203e384c76 100644
--- a/activerecord/test/models/hotel.rb
+++ b/activerecord/test/models/hotel.rb
@@ -1,8 +1,8 @@
 class Hotel < ActiveRecord::Base
   has_many :departments
   has_many :chefs, through: :departments
-  has_many :cake_designers, source_type: 'CakeDesigner', source: :employable, through: :chefs
-  has_many :drink_designers, source_type: 'DrinkDesigner', source: :employable, through: :chefs
+  has_many :cake_designers, source_type: "CakeDesigner", source: :employable, through: :chefs
+  has_many :drink_designers, source_type: "DrinkDesigner", source: :employable, through: :chefs
 
   has_many :chef_lists, as: :employable_list
   has_many :mocktail_designers, through: :chef_lists, source: :employable, :source_type => "MocktailDesigner"
diff --git a/activerecord/test/models/job.rb b/activerecord/test/models/job.rb
index f7b0e787b1..267f73bd6f 100644
--- a/activerecord/test/models/job.rb
+++ b/activerecord/test/models/job.rb
@@ -1,7 +1,7 @@
 class Job < ActiveRecord::Base
   has_many :references
   has_many :people, :through => :references
-  belongs_to :ideal_reference, :class_name => 'Reference'
+  belongs_to :ideal_reference, :class_name => "Reference"
 
   has_many :agents, :through => :people
 end
diff --git a/activerecord/test/models/joke.rb b/activerecord/test/models/joke.rb
index edda4655dc..eeb5818a1f 100644
--- a/activerecord/test/models/joke.rb
+++ b/activerecord/test/models/joke.rb
@@ -1,7 +1,7 @@
 class Joke < ActiveRecord::Base
-  self.table_name = 'funny_jokes'
+  self.table_name = "funny_jokes"
 end
 
 class GoodJoke < ActiveRecord::Base
-  self.table_name = 'funny_jokes'
+  self.table_name = "funny_jokes"
 end
diff --git a/activerecord/test/models/keyboard.rb b/activerecord/test/models/keyboard.rb
index 39347e274e..bcede53ec9 100644
--- a/activerecord/test/models/keyboard.rb
+++ b/activerecord/test/models/keyboard.rb
@@ -1,3 +1,3 @@
 class Keyboard < ActiveRecord::Base
-  self.primary_key = 'key_number'
+  self.primary_key = "key_number"
 end
diff --git a/activerecord/test/models/man.rb b/activerecord/test/models/man.rb
index 4fbb6b226b..797c46dcbe 100644
--- a/activerecord/test/models/man.rb
+++ b/activerecord/test/models/man.rb
@@ -1,11 +1,11 @@
 class Man < ActiveRecord::Base
   has_one :face, :inverse_of => :man
-  has_one :polymorphic_face, :class_name => 'Face', :as => :polymorphic_man, :inverse_of => :polymorphic_man
-  has_one :polymorphic_face_without_inverse, :class_name => 'Face', :as => :poly_man_without_inverse
+  has_one :polymorphic_face, :class_name => "Face", :as => :polymorphic_man, :inverse_of => :polymorphic_man
+  has_one :polymorphic_face_without_inverse, :class_name => "Face", :as => :poly_man_without_inverse
   has_many :interests, :inverse_of => :man
-  has_many :polymorphic_interests, :class_name => 'Interest', :as => :polymorphic_man, :inverse_of => :polymorphic_man
+  has_many :polymorphic_interests, :class_name => "Interest", :as => :polymorphic_man, :inverse_of => :polymorphic_man
   # These are "broken" inverse_of associations for the purposes of testing
-  has_one :dirty_face, :class_name => 'Face', :inverse_of => :dirty_man
-  has_many :secret_interests, :class_name => 'Interest', :inverse_of => :secret_man
+  has_one :dirty_face, :class_name => "Face", :inverse_of => :dirty_man
+  has_many :secret_interests, :class_name => "Interest", :inverse_of => :secret_man
   has_one :mixed_case_monkey
 end
diff --git a/activerecord/test/models/matey.rb b/activerecord/test/models/matey.rb
index 47b0baa974..1badaede0a 100644
--- a/activerecord/test/models/matey.rb
+++ b/activerecord/test/models/matey.rb
@@ -1,4 +1,4 @@
 class Matey < ActiveRecord::Base
   belongs_to :pirate
-  belongs_to :target, :class_name => 'Pirate'
+  belongs_to :target, :class_name => "Pirate"
 end
diff --git a/activerecord/test/models/member.rb b/activerecord/test/models/member.rb
index 7693c6e515..dd90d3e92b 100644
--- a/activerecord/test/models/member.rb
+++ b/activerecord/test/models/member.rb
@@ -27,7 +27,7 @@ class Member < ActiveRecord::Base
   has_many :clubs, :through => :current_memberships
 
   has_many :tenant_memberships
-  has_many :tenant_clubs, through: :tenant_memberships, class_name: 'Club', source: :club
+  has_many :tenant_clubs, through: :tenant_memberships, class_name: "Club", source: :club
 
   has_one :club_through_many, :through => :current_memberships, :source => :club
 
diff --git a/activerecord/test/models/membership.rb b/activerecord/test/models/membership.rb
index e181ba1f11..2c3ad230a7 100644
--- a/activerecord/test/models/membership.rb
+++ b/activerecord/test/models/membership.rb
@@ -9,7 +9,7 @@ class CurrentMembership < Membership
 end
 
 class SuperMembership < Membership
-  belongs_to :member, -> { order('members.id DESC') }
+  belongs_to :member, -> { order("members.id DESC") }
   belongs_to :club
 end
 
diff --git a/activerecord/test/models/node.rb b/activerecord/test/models/node.rb
index 07dd2dbccb..459ea8cf95 100644
--- a/activerecord/test/models/node.rb
+++ b/activerecord/test/models/node.rb
@@ -1,5 +1,5 @@
 class Node < ActiveRecord::Base
   belongs_to :tree, touch: true
-  belongs_to :parent,   class_name: 'Node', touch: true, optional: true
-  has_many   :children, class_name: 'Node', foreign_key: :parent_id, dependent: :destroy
+  belongs_to :parent,   class_name: "Node", touch: true, optional: true
+  has_many   :children, class_name: "Node", foreign_key: :parent_id, dependent: :destroy
 end
diff --git a/activerecord/test/models/order.rb b/activerecord/test/models/order.rb
index e838c0b70d..4ec7198c88 100644
--- a/activerecord/test/models/order.rb
+++ b/activerecord/test/models/order.rb
@@ -1,4 +1,4 @@
 class Order < ActiveRecord::Base
-  belongs_to :billing, :class_name => 'Customer', :foreign_key => 'billing_customer_id'
-  belongs_to :shipping, :class_name => 'Customer', :foreign_key => 'shipping_customer_id'
+  belongs_to :billing, :class_name => "Customer", :foreign_key => "billing_customer_id"
+  belongs_to :shipping, :class_name => "Customer", :foreign_key => "shipping_customer_id"
 end
diff --git a/activerecord/test/models/organization.rb b/activerecord/test/models/organization.rb
index f3e92f3067..1858351dd1 100644
--- a/activerecord/test/models/organization.rb
+++ b/activerecord/test/models/organization.rb
@@ -10,5 +10,5 @@ class Organization < ActiveRecord::Base
 
   has_many :posts, :through => :author, :source => :posts
 
-  scope :clubs, -> { from('clubs') }
+  scope :clubs, -> { from("clubs") }
 end
diff --git a/activerecord/test/models/owner.rb b/activerecord/test/models/owner.rb
index ce8242cf2f..45508a7f67 100644
--- a/activerecord/test/models/owner.rb
+++ b/activerecord/test/models/owner.rb
@@ -1,10 +1,10 @@
 class Owner < ActiveRecord::Base
   self.primary_key = :owner_id
-  has_many :pets, -> { order 'pets.name desc' }
+  has_many :pets, -> { order "pets.name desc" }
   has_many :toys, through: :pets
   has_many :persons, through: :pets
 
-  belongs_to :last_pet, class_name: 'Pet'
+  belongs_to :last_pet, class_name: "Pet"
   scope :including_last_pet, -> {
     select(%q[
       owners.*, (
diff --git a/activerecord/test/models/parrot.rb b/activerecord/test/models/parrot.rb
index ddc9dcaf29..9ee9670da9 100644
--- a/activerecord/test/models/parrot.rb
+++ b/activerecord/test/models/parrot.rb
@@ -19,5 +19,5 @@ class LiveParrot < Parrot
 end
 
 class DeadParrot < Parrot
-  belongs_to :killer, :class_name => 'Pirate', foreign_key: :killer_id
+  belongs_to :killer, :class_name => "Pirate", foreign_key: :killer_id
 end
diff --git a/activerecord/test/models/person.rb b/activerecord/test/models/person.rb
index a4a9c6b0d4..a33b4dca6b 100644
--- a/activerecord/test/models/person.rb
+++ b/activerecord/test/models/person.rb
@@ -5,19 +5,19 @@ class Person < ActiveRecord::Base
 
   has_many :posts, :through => :readers
   has_many :secure_posts, :through => :secure_readers
-  has_many :posts_with_no_comments, -> { includes(:comments).where('comments.id is null').references(:comments) },
+  has_many :posts_with_no_comments, -> { includes(:comments).where("comments.id is null").references(:comments) },
                                     :through => :readers, :source => :post
 
-  has_many :friendships, foreign_key: 'friend_id'
+  has_many :friendships, foreign_key: "friend_id"
   # friends_too exists to test a bug, and probably shouldn't be used elsewhere
-  has_many :friends_too, foreign_key: 'friend_id', class_name: 'Friendship'
+  has_many :friends_too, foreign_key: "friend_id", class_name: "Friendship"
   has_many :followers, through: :friendships
 
   has_many :references
   has_many :bad_references
-  has_many :fixed_bad_references, -> { where :favourite => true }, :class_name => 'BadReference'
-  has_one  :favourite_reference, -> { where 'favourite=?', true }, :class_name => 'Reference'
-  has_many :posts_with_comments_sorted_by_comment_id, -> { includes(:comments).order('comments.id') }, :through => :readers, :source => :post
+  has_many :fixed_bad_references, -> { where :favourite => true }, :class_name => "BadReference"
+  has_one  :favourite_reference, -> { where "favourite=?", true }, :class_name => "Reference"
+  has_many :posts_with_comments_sorted_by_comment_id, -> { includes(:comments).order("comments.id") }, :through => :readers, :source => :post
   has_many :first_posts, -> { where(id: [1, 2]) }, through: :readers
 
   has_many :jobs, :through => :references
@@ -25,10 +25,10 @@ class Person < ActiveRecord::Base
   has_many :jobs_with_dependent_delete_all, :source => :job, :through => :references, :dependent => :delete_all
   has_many :jobs_with_dependent_nullify,    :source => :job, :through => :references, :dependent => :nullify
 
-  belongs_to :primary_contact, :class_name => 'Person'
-  has_many :agents, :class_name => 'Person', :foreign_key => 'primary_contact_id'
+  belongs_to :primary_contact, :class_name => "Person"
+  has_many :agents, :class_name => "Person", :foreign_key => "primary_contact_id"
   has_many :agents_of_agents, :through => :agents, :source => :agents
-  belongs_to :number1_fan, :class_name => 'Person'
+  belongs_to :number1_fan, :class_name => "Person"
 
   has_many :personal_legacy_things, :dependent => :destroy
 
@@ -36,25 +36,25 @@ class Person < ActiveRecord::Base
   has_many :agents_posts_authors, :through => :agents_posts, :source => :author
   has_many :essays, primary_key: "first_name", foreign_key: "writer_id"
 
-  scope :males,   -> { where(:gender => 'M') }
+  scope :males,   -> { where(:gender => "M") }
 end
 
 class PersonWithDependentDestroyJobs < ActiveRecord::Base
-  self.table_name = 'people'
+  self.table_name = "people"
 
   has_many :references, :foreign_key => :person_id
   has_many :jobs, :source => :job, :through => :references, :dependent => :destroy
 end
 
 class PersonWithDependentDeleteAllJobs < ActiveRecord::Base
-  self.table_name = 'people'
+  self.table_name = "people"
 
   has_many :references, :foreign_key => :person_id
   has_many :jobs, :source => :job, :through => :references, :dependent => :delete_all
 end
 
 class PersonWithDependentNullifyJobs < ActiveRecord::Base
-  self.table_name = 'people'
+  self.table_name = "people"
 
   has_many :references, :foreign_key => :person_id
   has_many :jobs, :source => :job, :through => :references, :dependent => :nullify
@@ -62,12 +62,12 @@ end
 
 
 class LoosePerson < ActiveRecord::Base
-  self.table_name = 'people'
+  self.table_name = "people"
   self.abstract_class = true
 
-  has_one    :best_friend,    :class_name => 'LoosePerson', :foreign_key => :best_friend_id
-  belongs_to :best_friend_of, :class_name => 'LoosePerson', :foreign_key => :best_friend_of_id
-  has_many   :best_friends,   :class_name => 'LoosePerson', :foreign_key => :best_friend_id
+  has_one    :best_friend,    :class_name => "LoosePerson", :foreign_key => :best_friend_id
+  belongs_to :best_friend_of, :class_name => "LoosePerson", :foreign_key => :best_friend_of_id
+  has_many   :best_friends,   :class_name => "LoosePerson", :foreign_key => :best_friend_id
 
   accepts_nested_attributes_for :best_friend, :best_friend_of, :best_friends
 end
@@ -75,11 +75,11 @@ end
 class LooseDescendant < LoosePerson; end
 
 class TightPerson < ActiveRecord::Base
-  self.table_name = 'people'
+  self.table_name = "people"
 
-  has_one    :best_friend,    :class_name => 'TightPerson', :foreign_key => :best_friend_id
-  belongs_to :best_friend_of, :class_name => 'TightPerson', :foreign_key => :best_friend_of_id
-  has_many   :best_friends,   :class_name => 'TightPerson', :foreign_key => :best_friend_id
+  has_one    :best_friend,    :class_name => "TightPerson", :foreign_key => :best_friend_id
+  belongs_to :best_friend_of, :class_name => "TightPerson", :foreign_key => :best_friend_of_id
+  has_many   :best_friends,   :class_name => "TightPerson", :foreign_key => :best_friend_id
 
   accepts_nested_attributes_for :best_friend, :best_friend_of, :best_friends
 end
@@ -87,9 +87,9 @@ end
 class TightDescendant < TightPerson; end
 
 class RichPerson < ActiveRecord::Base
-  self.table_name = 'people'
+  self.table_name = "people"
 
-  has_and_belongs_to_many :treasures, :join_table => 'peoples_treasures'
+  has_and_belongs_to_many :treasures, :join_table => "peoples_treasures"
 
   before_validation :run_before_create, on: :create
   before_validation :run_before_validation
@@ -97,18 +97,18 @@ class RichPerson < ActiveRecord::Base
   private
 
   def run_before_create
-    self.first_name = first_name.to_s + 'run_before_create'
+    self.first_name = first_name.to_s + "run_before_create"
   end
 
   def run_before_validation
-    self.first_name = first_name.to_s + 'run_before_validation'
+    self.first_name = first_name.to_s + "run_before_validation"
   end
 end
 
 class NestedPerson < ActiveRecord::Base
-  self.table_name = 'people'
+  self.table_name = "people"
 
-  has_one :best_friend, :class_name => 'NestedPerson', :foreign_key => :best_friend_id
+  has_one :best_friend, :class_name => "NestedPerson", :foreign_key => :best_friend_id
   accepts_nested_attributes_for :best_friend, :update_only => true
 
   def comments=(new_comments)
@@ -136,7 +136,7 @@ class Insure
 end
 
 class SerializedPerson < ActiveRecord::Base
-  self.table_name = 'people'
+  self.table_name = "people"
 
   serialize :insures, Insure
 end
diff --git a/activerecord/test/models/pet.rb b/activerecord/test/models/pet.rb
index 53489fa1b3..06170837b6 100644
--- a/activerecord/test/models/pet.rb
+++ b/activerecord/test/models/pet.rb
@@ -6,7 +6,7 @@ class Pet < ActiveRecord::Base
   has_many :toys
   has_many :pet_treasures
   has_many :treasures, through: :pet_treasures
-  has_many :persons, through: :treasures, source: :looter, source_type: 'Person'
+  has_many :persons, through: :treasures, source: :looter, source_type: "Person"
 
   class << self
     attr_accessor :after_destroy_output
diff --git a/activerecord/test/models/pirate.rb b/activerecord/test/models/pirate.rb
index 30545bdcd7..7cb602f445 100644
--- a/activerecord/test/models/pirate.rb
+++ b/activerecord/test/models/pirate.rb
@@ -1,8 +1,8 @@
 class Pirate < ActiveRecord::Base
   belongs_to :parrot, :validate => true
-  belongs_to :non_validated_parrot, :class_name => 'Parrot'
-  has_and_belongs_to_many :parrots, -> { order('parrots.id ASC') }, :validate => true
-  has_and_belongs_to_many :non_validated_parrots, :class_name => 'Parrot'
+  belongs_to :non_validated_parrot, :class_name => "Parrot"
+  has_and_belongs_to_many :parrots, -> { order("parrots.id ASC") }, :validate => true
+  has_and_belongs_to_many :non_validated_parrots, :class_name => "Parrot"
   has_and_belongs_to_many :parrots_with_method_callbacks, :class_name => "Parrot",
     :before_add    => :log_before_add,
     :after_add     => :log_after_add,
@@ -19,9 +19,9 @@ class Pirate < ActiveRecord::Base
   has_many :treasure_estimates, :through => :treasures, :source => :price_estimates
 
   has_one :ship
-  has_one :update_only_ship, :class_name => 'Ship'
-  has_one :non_validated_ship, :class_name => 'Ship'
-  has_many :birds, -> { order('birds.id ASC') }
+  has_one :update_only_ship, :class_name => "Ship"
+  has_one :non_validated_ship, :class_name => "Ship"
+  has_many :birds, -> { order("birds.id ASC") }
   has_many :birds_with_method_callbacks, :class_name => "Bird",
     :before_add    => :log_before_add,
     :after_add     => :log_after_add,
@@ -34,7 +34,7 @@ class Pirate < ActiveRecord::Base
     :after_remove   => proc {|p,b| p.ship_log << "after_removing_proc_bird_#{b.id}"}
   has_many :birds_with_reject_all_blank, :class_name => "Bird"
 
-  has_one :foo_bulb, -> { where :name => 'foo' }, :foreign_key => :car_id, :class_name => "Bulb"
+  has_one :foo_bulb, -> { where :name => "foo" }, :foreign_key => :car_id, :class_name => "Bulb"
 
   accepts_nested_attributes_for :parrots, :birds, :allow_destroy => true, :reject_if => proc(&:empty?)
   accepts_nested_attributes_for :ship, :allow_destroy => true, :reject_if => proc(&:empty?)
@@ -50,7 +50,7 @@ class Pirate < ActiveRecord::Base
   end
 
   def reject_empty_ships_on_create(attributes)
-    attributes.delete('_reject_me_if_new').present? && !persisted?
+    attributes.delete("_reject_me_if_new").present? && !persisted?
   end
 
   attr_accessor :cancel_save_from_callback, :parrots_limit
@@ -82,11 +82,11 @@ class Pirate < ActiveRecord::Base
 end
 
 class DestructivePirate < Pirate
-  has_one :dependent_ship, :class_name => 'Ship', :foreign_key => :pirate_id, :dependent => :destroy
+  has_one :dependent_ship, :class_name => "Ship", :foreign_key => :pirate_id, :dependent => :destroy
 end
 
 class FamousPirate < ActiveRecord::Base
-  self.table_name = 'pirates'
+  self.table_name = "pirates"
   has_many :famous_ships
   validates_presence_of :catchphrase, on: :conference
 end
diff --git a/activerecord/test/models/possession.rb b/activerecord/test/models/possession.rb
index ddf759113b..0226336c16 100644
--- a/activerecord/test/models/possession.rb
+++ b/activerecord/test/models/possession.rb
@@ -1,3 +1,3 @@
 class Possession < ActiveRecord::Base
-  self.table_name = 'having'
+  self.table_name = "having"
 end
diff --git a/activerecord/test/models/post.rb b/activerecord/test/models/post.rb
index bf3079a1df..395ba37e0b 100644
--- a/activerecord/test/models/post.rb
+++ b/activerecord/test/models/post.rb
@@ -7,7 +7,7 @@ class Post < ActiveRecord::Base
 
   module NamedExtension
     def author
-      'lifo'
+      "lifo"
     end
   end
 
@@ -31,11 +31,11 @@ class Post < ActiveRecord::Base
   def first_comment
     super.body
   end
-  has_one :first_comment, -> { order('id ASC') }, :class_name => 'Comment'
-  has_one :last_comment, -> { order('id desc') }, :class_name => 'Comment'
+  has_one :first_comment, -> { order("id ASC") }, :class_name => "Comment"
+  has_one :last_comment, -> { order("id desc") }, :class_name => "Comment"
 
-  scope :with_special_comments, -> { joins(:comments).where(:comments => {:type => 'SpecialComment'}) }
-  scope :with_very_special_comments, -> { joins(:comments).where(:comments => {:type => 'VerySpecialComment'}) }
+  scope :with_special_comments, -> { joins(:comments).where(:comments => {:type => "SpecialComment"}) }
+  scope :with_very_special_comments, -> { joins(:comments).where(:comments => {:type => "VerySpecialComment"}) }
   scope :with_post, ->(post_id) { joins(:comments).where(:comments => { :post_id => post_id }) }
 
   scope :with_comments, -> { preload(:comments) }
@@ -77,60 +77,60 @@ class Post < ActiveRecord::Base
 
   has_one  :very_special_comment
   has_one  :very_special_comment_with_post, -> { includes(:post) }, :class_name => "VerySpecialComment"
-  has_one :very_special_comment_with_post_with_joins, -> { joins(:post).order('posts.id') }, class_name: "VerySpecialComment"
+  has_one :very_special_comment_with_post_with_joins, -> { joins(:post).order("posts.id") }, class_name: "VerySpecialComment"
   has_many :special_comments
-  has_many :nonexistent_comments, -> { where 'comments.id < 0' }, :class_name => 'Comment'
+  has_many :nonexistent_comments, -> { where "comments.id < 0" }, :class_name => "Comment"
 
   has_many :special_comments_ratings, :through => :special_comments, :source => :ratings
   has_many :special_comments_ratings_taggings, :through => :special_comments_ratings, :source => :taggings
 
-  has_many :category_posts, :class_name => 'CategoryPost'
+  has_many :category_posts, :class_name => "CategoryPost"
   has_many :scategories, through: :category_posts, source: :category
   has_and_belongs_to_many :categories
-  has_and_belongs_to_many :special_categories, :join_table => "categories_posts", :association_foreign_key => 'category_id'
+  has_and_belongs_to_many :special_categories, :join_table => "categories_posts", :association_foreign_key => "category_id"
 
   has_many :taggings, :as => :taggable, :counter_cache => :tags_count
   has_many :tags, :through => :taggings do
     def add_joins_and_select
-      select('tags.*, authors.id as author_id')
-        .joins('left outer join posts on taggings.taggable_id = posts.id left outer join authors on posts.author_id = authors.id')
+      select("tags.*, authors.id as author_id")
+        .joins("left outer join posts on taggings.taggable_id = posts.id left outer join authors on posts.author_id = authors.id")
         .to_a
     end
   end
 
-  has_many :taggings_with_delete_all, :class_name => 'Tagging', :as => :taggable, :dependent => :delete_all, counter_cache: :taggings_with_delete_all_count
-  has_many :taggings_with_destroy, :class_name => 'Tagging', :as => :taggable, :dependent => :destroy, counter_cache: :taggings_with_destroy_count
+  has_many :taggings_with_delete_all, :class_name => "Tagging", :as => :taggable, :dependent => :delete_all, counter_cache: :taggings_with_delete_all_count
+  has_many :taggings_with_destroy, :class_name => "Tagging", :as => :taggable, :dependent => :destroy, counter_cache: :taggings_with_destroy_count
 
   has_many :tags_with_destroy, :through => :taggings, :source => :tag, :dependent => :destroy, counter_cache: :tags_with_destroy_count
   has_many :tags_with_nullify, :through => :taggings, :source => :tag, :dependent => :nullify, counter_cache: :tags_with_nullify_count
 
-  has_many :misc_tags, -> { where :tags => { :name => 'Misc' } }, :through => :taggings, :source => :tag
+  has_many :misc_tags, -> { where :tags => { :name => "Misc" } }, :through => :taggings, :source => :tag
   has_many :funky_tags, :through => :taggings, :source => :tag
   has_many :super_tags, :through => :taggings
   has_many :tags_with_primary_key, :through => :taggings, :source => :tag_with_primary_key
   has_one :tagging, :as => :taggable
 
-  has_many :first_taggings, -> { where :taggings => { :comment => 'first' } }, :as => :taggable, :class_name => 'Tagging'
-  has_many :first_blue_tags, -> { where :tags => { :name => 'Blue' } }, :through => :first_taggings, :source => :tag
+  has_many :first_taggings, -> { where :taggings => { :comment => "first" } }, :as => :taggable, :class_name => "Tagging"
+  has_many :first_blue_tags, -> { where :tags => { :name => "Blue" } }, :through => :first_taggings, :source => :tag
 
-  has_many :first_blue_tags_2, -> { where :taggings => { :comment => 'first' } }, :through => :taggings, :source => :blue_tag
+  has_many :first_blue_tags_2, -> { where :taggings => { :comment => "first" } }, :through => :taggings, :source => :blue_tag
 
-  has_many :invalid_taggings, -> { where 'taggings.id < 0' }, :as => :taggable, :class_name => "Tagging"
+  has_many :invalid_taggings, -> { where "taggings.id < 0" }, :as => :taggable, :class_name => "Tagging"
   has_many :invalid_tags, :through => :invalid_taggings, :source => :tag
 
   has_many :categorizations, :foreign_key => :category_id
   has_many :authors, :through => :categorizations
 
-  has_many :categorizations_using_author_id, :primary_key => :author_id, :foreign_key => :post_id, :class_name => 'Categorization'
+  has_many :categorizations_using_author_id, :primary_key => :author_id, :foreign_key => :post_id, :class_name => "Categorization"
   has_many :authors_using_author_id, :through => :categorizations_using_author_id, :source => :author
 
-  has_many :taggings_using_author_id, :primary_key => :author_id, :as => :taggable, :class_name => 'Tagging'
+  has_many :taggings_using_author_id, :primary_key => :author_id, :as => :taggable, :class_name => "Tagging"
   has_many :tags_using_author_id, :through => :taggings_using_author_id, :source => :tag
 
   has_many :images, :as => :imageable, :foreign_key => :imageable_identifier, :foreign_type => :imageable_class
-  has_one :main_image, :as => :imageable, :foreign_key => :imageable_identifier, :foreign_type => :imageable_class, :class_name => 'Image'
+  has_one :main_image, :as => :imageable, :foreign_key => :imageable_identifier, :foreign_type => :imageable_class, :class_name => "Image"
 
-  has_many :standard_categorizations, :class_name => 'Categorization', :foreign_key => :post_id
+  has_many :standard_categorizations, :class_name => "Categorization", :foreign_key => :post_id
   has_many :author_using_custom_pk,  :through => :standard_categorizations
   has_many :authors_using_custom_pk, :through => :standard_categorizations
   has_many :named_categories, :through => :standard_categorizations
@@ -145,14 +145,14 @@ class Post < ActiveRecord::Base
               :after_add     => lambda {|owner, reader| log(:added,   :after,  reader.first_name) },
               :before_remove => lambda {|owner, reader| log(:removed, :before, reader.first_name) },
               :after_remove  => lambda {|owner, reader| log(:removed, :after,  reader.first_name) }
-  has_many :skimmers, -> { where :skimmer => true }, :class_name => 'Reader'
+  has_many :skimmers, -> { where :skimmer => true }, :class_name => "Reader"
   has_many :impatient_people, :through => :skimmers, :source => :person
 
   has_many :lazy_readers
-  has_many :lazy_readers_skimmers_or_not, -> { where(skimmer: [ true, false ]) }, :class_name => 'LazyReader'
+  has_many :lazy_readers_skimmers_or_not, -> { where(skimmer: [ true, false ]) }, :class_name => "LazyReader"
 
   has_many :lazy_people, :through => :lazy_readers, :source => :person
-  has_many :lazy_readers_unscope_skimmers, -> { skimmers_or_not }, :class_name => 'LazyReader'
+  has_many :lazy_readers_unscope_skimmers, -> { skimmers_or_not }, :class_name => "LazyReader"
   has_many :lazy_people_unscope_skimmers, :through => :lazy_readers_unscope_skimmers, :source => :person
 
   def self.top(limit)
@@ -186,7 +186,7 @@ end
 
 class FirstPost < ActiveRecord::Base
   self.inheritance_column = :disabled
-  self.table_name = 'posts'
+  self.table_name = "posts"
   default_scope { where(:id => 1) }
 
   has_many :comments, :foreign_key => :post_id
@@ -195,47 +195,47 @@ end
 
 class PostWithDefaultInclude < ActiveRecord::Base
   self.inheritance_column = :disabled
-  self.table_name = 'posts'
+  self.table_name = "posts"
   default_scope { includes(:comments) }
   has_many :comments, :foreign_key => :post_id
 end
 
 class PostWithSpecialCategorization < Post
   has_many :categorizations, :foreign_key => :post_id
-  default_scope { where(:type => 'PostWithSpecialCategorization').joins(:categorizations).where(:categorizations => { :special => true }) }
+  default_scope { where(:type => "PostWithSpecialCategorization").joins(:categorizations).where(:categorizations => { :special => true }) }
 end
 
 class PostWithDefaultScope < ActiveRecord::Base
   self.inheritance_column = :disabled
-  self.table_name = 'posts'
+  self.table_name = "posts"
   default_scope { order(:title) }
 end
 
 class PostWithPreloadDefaultScope < ActiveRecord::Base
-  self.table_name = 'posts'
+  self.table_name = "posts"
 
-  has_many :readers, foreign_key: 'post_id'
+  has_many :readers, foreign_key: "post_id"
 
   default_scope { preload(:readers) }
 end
 
 class PostWithIncludesDefaultScope < ActiveRecord::Base
-  self.table_name = 'posts'
+  self.table_name = "posts"
 
-  has_many :readers, foreign_key: 'post_id'
+  has_many :readers, foreign_key: "post_id"
 
   default_scope { includes(:readers) }
 end
 
 class SpecialPostWithDefaultScope < ActiveRecord::Base
   self.inheritance_column = :disabled
-  self.table_name = 'posts'
+  self.table_name = "posts"
   default_scope { where(:id => [1, 5,6]) }
 end
 
 class PostThatLoadsCommentsInAnAfterSaveHook < ActiveRecord::Base
   self.inheritance_column = :disabled
-  self.table_name = 'posts'
+  self.table_name = "posts"
   has_many :comments, class_name: "CommentThatAutomaticallyAltersPostBody", foreign_key: :post_id
 
   after_save do |post|
@@ -245,7 +245,7 @@ end
 
 class PostWithAfterCreateCallback < ActiveRecord::Base
   self.inheritance_column = :disabled
-  self.table_name = 'posts'
+  self.table_name = "posts"
   has_many :comments, foreign_key: :post_id
 
   after_create do |post|
@@ -255,7 +255,7 @@ end
 
 class PostWithCommentWithDefaultScopeReferencesAssociation < ActiveRecord::Base
   self.inheritance_column = :disabled
-  self.table_name = 'posts'
+  self.table_name = "posts"
   has_many :comment_with_default_scope_references_associations, foreign_key: :post_id
   has_one :first_comment, class_name: "CommentWithDefaultScopeReferencesAssociation", foreign_key: :post_id
 end
@@ -265,7 +265,7 @@ class SerializedPost < ActiveRecord::Base
 end
 
 class ConditionalStiPost < Post
-  default_scope { where(title: 'Untitled') }
+  default_scope { where(title: "Untitled") }
 end
 
 class SubConditionalStiPost < ConditionalStiPost
diff --git a/activerecord/test/models/professor.rb b/activerecord/test/models/professor.rb
index 7654eda0ef..4dfb1a9602 100644
--- a/activerecord/test/models/professor.rb
+++ b/activerecord/test/models/professor.rb
@@ -1,4 +1,4 @@
-require_dependency 'models/arunit2_model'
+require_dependency "models/arunit2_model"
 
 class Professor < ARUnit2Model
   has_and_belongs_to_many :courses
diff --git a/activerecord/test/models/project.rb b/activerecord/test/models/project.rb
index efa8246f1e..1b3b807ee2 100644
--- a/activerecord/test/models/project.rb
+++ b/activerecord/test/models/project.rb
@@ -1,11 +1,11 @@
 class Project < ActiveRecord::Base
   belongs_to :mentor
-  has_and_belongs_to_many :developers, -> { distinct.order 'developers.name desc, developers.id desc' }
+  has_and_belongs_to_many :developers, -> { distinct.order "developers.name desc, developers.id desc" }
   has_and_belongs_to_many :readonly_developers, -> { readonly }, :class_name => "Developer"
-  has_and_belongs_to_many :non_unique_developers, -> { order 'developers.name desc, developers.id desc' }, :class_name => 'Developer'
+  has_and_belongs_to_many :non_unique_developers, -> { order "developers.name desc, developers.id desc" }, :class_name => "Developer"
   has_and_belongs_to_many :limited_developers, -> { limit 1 }, :class_name => "Developer"
   has_and_belongs_to_many :developers_named_david, -> { where("name = 'David'").distinct }, :class_name => "Developer"
-  has_and_belongs_to_many :developers_named_david_with_hash_conditions, -> { where(:name => 'David').distinct }, :class_name => "Developer"
+  has_and_belongs_to_many :developers_named_david_with_hash_conditions, -> { where(:name => "David").distinct }, :class_name => "Developer"
   has_and_belongs_to_many :salaried_developers, -> { where "salary > 0" }, :class_name => "Developer"
   has_and_belongs_to_many :developers_with_callbacks, :class_name => "Developer", :before_add => Proc.new {|o, r| o.developers_log << "before_adding#{r.id || '<new>'}"},
                             :after_add => Proc.new {|o, r| o.developers_log << "after_adding#{r.id || '<new>'}"},
diff --git a/activerecord/test/models/reader.rb b/activerecord/test/models/reader.rb
index 91afc1898c..8c7235ba9a 100644
--- a/activerecord/test/models/reader.rb
+++ b/activerecord/test/models/reader.rb
@@ -1,7 +1,7 @@
 class Reader < ActiveRecord::Base
   belongs_to :post
   belongs_to :person, :inverse_of => :readers
-  belongs_to :single_person, :class_name => 'Person', :foreign_key => :person_id, :inverse_of => :reader
+  belongs_to :single_person, :class_name => "Person", :foreign_key => :person_id, :inverse_of => :reader
   belongs_to :first_post, -> { where(id: [2, 3]) }
 end
 
diff --git a/activerecord/test/models/reference.rb b/activerecord/test/models/reference.rb
index c2f9068f57..1cf6669dce 100644
--- a/activerecord/test/models/reference.rb
+++ b/activerecord/test/models/reference.rb
@@ -17,6 +17,6 @@ class Reference < ActiveRecord::Base
 end
 
 class BadReference < ActiveRecord::Base
-  self.table_name = 'references'
+  self.table_name = "references"
   default_scope { where(:favourite => false) }
 end
diff --git a/activerecord/test/models/reply.rb b/activerecord/test/models/reply.rb
index 3e82e55d89..34b60bdef1 100644
--- a/activerecord/test/models/reply.rb
+++ b/activerecord/test/models/reply.rb
@@ -1,4 +1,4 @@
-require 'models/topic'
+require "models/topic"
 
 class Reply < Topic
   belongs_to :topic, :foreign_key => "parent_id", :counter_cache => true
@@ -7,8 +7,8 @@ class Reply < Topic
 end
 
 class UniqueReply < Reply
-  belongs_to :topic, :foreign_key => 'parent_id', :counter_cache => true
-  validates_uniqueness_of :content, :scope => 'parent_id'
+  belongs_to :topic, :foreign_key => "parent_id", :counter_cache => true
+  validates_uniqueness_of :content, :scope => "parent_id"
 end
 
 class SillyUniqueReply < UniqueReply
@@ -56,6 +56,6 @@ end
 
 module Web
   class Reply < Web::Topic
-    belongs_to :topic, :foreign_key => "parent_id", :counter_cache => true, :class_name => 'Web::Topic'
+    belongs_to :topic, :foreign_key => "parent_id", :counter_cache => true, :class_name => "Web::Topic"
   end
 end
diff --git a/activerecord/test/models/ship.rb b/activerecord/test/models/ship.rb
index e333b964ab..eae360a9eb 100644
--- a/activerecord/test/models/ship.rb
+++ b/activerecord/test/models/ship.rb
@@ -2,9 +2,9 @@ class Ship < ActiveRecord::Base
   self.record_timestamps = false
 
   belongs_to :pirate
-  belongs_to :update_only_pirate, :class_name => 'Pirate'
+  belongs_to :update_only_pirate, :class_name => "Pirate"
   belongs_to :developer, dependent: :destroy
-  has_many :parts, :class_name => 'ShipPart'
+  has_many :parts, :class_name => "ShipPart"
   has_many :treasures
 
   accepts_nested_attributes_for :parts, :allow_destroy => true
@@ -33,7 +33,7 @@ class Prisoner < ActiveRecord::Base
 end
 
 class FamousShip < ActiveRecord::Base
-  self.table_name = 'ships'
+  self.table_name = "ships"
   belongs_to :famous_pirate
   validates_presence_of :name, on: :conference
 end
diff --git a/activerecord/test/models/sponsor.rb b/activerecord/test/models/sponsor.rb
index ec3dcf8a97..5f7e47b583 100644
--- a/activerecord/test/models/sponsor.rb
+++ b/activerecord/test/models/sponsor.rb
@@ -2,6 +2,6 @@ class Sponsor < ActiveRecord::Base
   belongs_to :sponsor_club, :class_name => "Club", :foreign_key => "club_id"
   belongs_to :sponsorable, :polymorphic => true
   belongs_to :thing, :polymorphic => true, :foreign_type => :sponsorable_type, :foreign_key => :sponsorable_id
-  belongs_to :sponsorable_with_conditions, -> { where :name => 'Ernie'}, :polymorphic => true,
-             :foreign_type => 'sponsorable_type', :foreign_key => 'sponsorable_id'
+  belongs_to :sponsorable_with_conditions, -> { where :name => "Ernie"}, :polymorphic => true,
+             :foreign_type => "sponsorable_type", :foreign_key => "sponsorable_id"
 end
diff --git a/activerecord/test/models/subject.rb b/activerecord/test/models/subject.rb
index 8e28f8b86b..9b96f11c9d 100644
--- a/activerecord/test/models/subject.rb
+++ b/activerecord/test/models/subject.rb
@@ -9,7 +9,7 @@ class Subject < ActiveRecord::Base
   protected
     def set_email_address
       unless self.persisted?
-        self.author_email_address = 'test@test.com'
+        self.author_email_address = "test@test.com"
       end
     end
 
diff --git a/activerecord/test/models/subscriber.rb b/activerecord/test/models/subscriber.rb
index 76e85a0cd3..269da472cf 100644
--- a/activerecord/test/models/subscriber.rb
+++ b/activerecord/test/models/subscriber.rb
@@ -1,5 +1,5 @@
 class Subscriber < ActiveRecord::Base
-  self.primary_key = 'nick'
+  self.primary_key = "nick"
   has_many :subscriptions
   has_many :books, :through => :subscriptions
 end
diff --git a/activerecord/test/models/tag.rb b/activerecord/test/models/tag.rb
index b48b9a2155..a49affaf3f 100644
--- a/activerecord/test/models/tag.rb
+++ b/activerecord/test/models/tag.rb
@@ -3,11 +3,11 @@ class Tag < ActiveRecord::Base
   has_many :taggables, :through => :taggings
   has_one  :tagging
 
-  has_many :tagged_posts, :through => :taggings, :source => 'taggable', :source_type => 'Post'
+  has_many :tagged_posts, :through => :taggings, :source => "taggable", :source_type => "Post"
 end
 
 class OrderedTag < Tag
   self.table_name = "tags"
 
-  has_many :taggings, -> { order('taggings.id DESC') }, foreign_key: 'tag_id'
+  has_many :taggings, -> { order("taggings.id DESC") }, foreign_key: "tag_id"
 end
diff --git a/activerecord/test/models/tagging.rb b/activerecord/test/models/tagging.rb
index a6c05da26a..3ab9f50739 100644
--- a/activerecord/test/models/tagging.rb
+++ b/activerecord/test/models/tagging.rb
@@ -4,10 +4,10 @@ end
 
 class Tagging < ActiveRecord::Base
   belongs_to :tag, -> { includes(:tagging) }
-  belongs_to :super_tag,   :class_name => 'Tag', :foreign_key => 'super_tag_id'
-  belongs_to :invalid_tag, :class_name => 'Tag', :foreign_key => 'tag_id'
-  belongs_to :blue_tag, -> { where :tags => { :name => 'Blue' } }, :class_name => 'Tag', :foreign_key => :tag_id
-  belongs_to :tag_with_primary_key, :class_name => 'Tag', :foreign_key => :tag_id, :primary_key => :custom_primary_key
+  belongs_to :super_tag,   :class_name => "Tag", :foreign_key => "super_tag_id"
+  belongs_to :invalid_tag, :class_name => "Tag", :foreign_key => "tag_id"
+  belongs_to :blue_tag, -> { where :tags => { :name => "Blue" } }, :class_name => "Tag", :foreign_key => :tag_id
+  belongs_to :tag_with_primary_key, :class_name => "Tag", :foreign_key => :tag_id, :primary_key => :custom_primary_key
   belongs_to :taggable, :polymorphic => true, :counter_cache => :tags_count
   has_many :things, :through => :taggable
 end
diff --git a/activerecord/test/models/topic.rb b/activerecord/test/models/topic.rb
index 21c23ed2a2..4e35e458ca 100644
--- a/activerecord/test/models/topic.rb
+++ b/activerecord/test/models/topic.rb
@@ -2,7 +2,7 @@ class Topic < ActiveRecord::Base
   scope :base, -> { all }
   scope :written_before, lambda { |time|
     if time
-      where 'written_on < ?', time
+      where "written_on < ?", time
     end
   }
   scope :approved, -> { where(:approved => true) }
@@ -10,10 +10,10 @@ class Topic < ActiveRecord::Base
 
   scope :scope_with_lambda, lambda { all }
 
-  scope :by_lifo, -> { where(:author_name => 'lifo') }
-  scope :replied, -> { where 'replies_count > 0' }
+  scope :by_lifo, -> { where(:author_name => "lifo") }
+  scope :replied, -> { where "replies_count > 0" }
 
-  scope 'approved_as_string', -> { where(:approved => true) }
+  scope "approved_as_string", -> { where(:approved => true) }
   scope :anonymous_extension, -> { all } do
     def one
       1
@@ -33,7 +33,7 @@ class Topic < ActiveRecord::Base
   end
 
   has_many :replies, dependent: :destroy, foreign_key: "parent_id", autosave: true
-  has_many :approved_replies, -> { approved }, class_name: 'Reply', foreign_key: "parent_id", counter_cache: 'replies_count'
+  has_many :approved_replies, -> { approved }, class_name: "Reply", foreign_key: "parent_id", counter_cache: "replies_count"
 
   has_many :unique_replies, :dependent => :destroy, :foreign_key => "parent_id"
   has_many :silly_unique_replies, :dependent => :destroy, :foreign_key => "parent_id"
@@ -85,7 +85,7 @@ class Topic < ActiveRecord::Base
 
     def set_email_address
       unless self.persisted?
-        self.author_email_address = 'test@test.com'
+        self.author_email_address = "test@test.com"
       end
     end
 
@@ -113,6 +113,6 @@ end
 
 module Web
   class Topic < ActiveRecord::Base
-    has_many :replies, :dependent => :destroy, :foreign_key => "parent_id", :class_name => 'Web::Reply'
+    has_many :replies, :dependent => :destroy, :foreign_key => "parent_id", :class_name => "Web::Reply"
   end
 end
diff --git a/activerecord/test/models/treasure.rb b/activerecord/test/models/treasure.rb
index 63ff0c23ec..04c3ef662c 100644
--- a/activerecord/test/models/treasure.rb
+++ b/activerecord/test/models/treasure.rb
@@ -5,7 +5,7 @@ class Treasure < ActiveRecord::Base
   belongs_to :ship
 
   has_many :price_estimates, :as => :estimate_of
-  has_and_belongs_to_many :rich_people, join_table: 'peoples_treasures', validate: false
+  has_and_belongs_to_many :rich_people, join_table: "peoples_treasures", validate: false
 
   accepts_nested_attributes_for :looter
 end
diff --git a/activerecord/test/models/user.rb b/activerecord/test/models/user.rb
index 97107a35a0..47649e0a77 100644
--- a/activerecord/test/models/user.rb
+++ b/activerecord/test/models/user.rb
@@ -1,4 +1,4 @@
-require 'models/job'
+require "models/job"
 
 class User < ActiveRecord::Base
   has_secure_token
@@ -6,7 +6,7 @@ class User < ActiveRecord::Base
 
   has_and_belongs_to_many :jobs_pool,
     class_name: Job,
-    join_table: 'jobs_pool'
+    join_table: "jobs_pool"
 end
 
 class UserWithNotification < User
diff --git a/activerecord/test/models/vegetables.rb b/activerecord/test/models/vegetables.rb
index 1f41cde3a5..5f6a17dbb3 100644
--- a/activerecord/test/models/vegetables.rb
+++ b/activerecord/test/models/vegetables.rb
@@ -3,7 +3,7 @@ class Vegetable < ActiveRecord::Base
   validates_presence_of :name
 
   def self.inheritance_column
-    'custom_type'
+    "custom_type"
   end
 end
 
@@ -20,5 +20,5 @@ class KingCole < GreenCabbage
 end
 
 class RedCabbage < Cabbage
-  belongs_to :seller, :class_name => 'Company'
+  belongs_to :seller, :class_name => "Company"
 end
diff --git a/activerecord/test/models/vertex.rb b/activerecord/test/models/vertex.rb
index 48bb851e62..cd0ac92236 100644
--- a/activerecord/test/models/vertex.rb
+++ b/activerecord/test/models/vertex.rb
@@ -1,9 +1,9 @@
 # This class models a vertex in a directed graph.
 class Vertex < ActiveRecord::Base
-  has_many :sink_edges, :class_name => 'Edge', :foreign_key => 'source_id'
+  has_many :sink_edges, :class_name => "Edge", :foreign_key => "source_id"
   has_many :sinks, :through => :sink_edges
 
   has_and_belongs_to_many :sources,
-    :class_name => 'Vertex', :join_table => 'edges',
-    :foreign_key => 'sink_id', :association_foreign_key => 'source_id'
+    :class_name => "Vertex", :join_table => "edges",
+    :foreign_key => "sink_id", :association_foreign_key => "source_id"
 end
diff --git a/activerecord/test/schema/mysql2_specific_schema.rb b/activerecord/test/schema/mysql2_specific_schema.rb
index 5a49b38457..9a203a7293 100644
--- a/activerecord/test/schema/mysql2_specific_schema.rb
+++ b/activerecord/test/schema/mysql2_specific_schema.rb
@@ -1,8 +1,8 @@
 ActiveRecord::Schema.define do
 
-  if ActiveRecord::Base.connection.version >= '5.6.0'
+  if ActiveRecord::Base.connection.version >= "5.6.0"
     create_table :datetime_defaults, force: true do |t|
-      t.datetime :modified_datetime, default: -> { 'CURRENT_TIMESTAMP' }
+      t.datetime :modified_datetime, default: -> { "CURRENT_TIMESTAMP" }
     end
   end
 
@@ -21,18 +21,18 @@ ActiveRecord::Schema.define do
     t.index :var_binary
   end
 
-  create_table :key_tests, force: true, options: 'ENGINE=MyISAM' do |t|
+  create_table :key_tests, force: true, options: "ENGINE=MyISAM" do |t|
     t.string :awesome
     t.string :pizza
     t.string :snacks
-    t.index :awesome, type: :fulltext, name: 'index_key_tests_on_awesome'
-    t.index :pizza, using: :btree, name: 'index_key_tests_on_pizza'
-    t.index :snacks, name: 'index_key_tests_on_snack'
+    t.index :awesome, type: :fulltext, name: "index_key_tests_on_awesome"
+    t.index :pizza, using: :btree, name: "index_key_tests_on_pizza"
+    t.index :snacks, name: "index_key_tests_on_snack"
   end
 
   create_table :collation_tests, id: false, force: true do |t|
-    t.string :string_cs_column, limit: 1, collation: 'utf8_bin'
-    t.string :string_ci_column, limit: 1, collation: 'utf8_general_ci'
+    t.string :string_cs_column, limit: 1, collation: "utf8_bin"
+    t.string :string_ci_column, limit: 1, collation: "utf8_general_ci"
     t.binary :binary_column,    limit: 1
   end
 
diff --git a/activerecord/test/schema/postgresql_specific_schema.rb b/activerecord/test/schema/postgresql_specific_schema.rb
index 030ad73621..f00b858ea6 100644
--- a/activerecord/test/schema/postgresql_specific_schema.rb
+++ b/activerecord/test/schema/postgresql_specific_schema.rb
@@ -1,6 +1,6 @@
 ActiveRecord::Schema.define do
 
-  enable_extension!('uuid-ossp', ActiveRecord::Base.connection)
+  enable_extension!("uuid-ossp", ActiveRecord::Base.connection)
 
   create_table :uuid_parents, id: :uuid, force: true do |t|
     t.string :name
@@ -12,16 +12,16 @@ ActiveRecord::Schema.define do
   end
 
   create_table :defaults, force: true do |t|
-    t.date :modified_date, default: -> { 'CURRENT_DATE' }
-    t.date :modified_date_function, default: -> { 'now()' }
-    t.date :fixed_date, default: '2004-01-01'
-    t.datetime :modified_time, default: -> { 'CURRENT_TIMESTAMP' }
-    t.datetime :modified_time_function, default: -> { 'now()' }
-    t.datetime :fixed_time, default: '2004-01-01 00:00:00.000000-00'
-    t.column :char1, 'char(1)', default: 'Y'
-    t.string :char2, limit: 50, default: 'a varchar field'
-    t.text :char3, default: 'a text field'
-    t.bigint :bigint_default, default: -> { '0::bigint' }
+    t.date :modified_date, default: -> { "CURRENT_DATE" }
+    t.date :modified_date_function, default: -> { "now()" }
+    t.date :fixed_date, default: "2004-01-01"
+    t.datetime :modified_time, default: -> { "CURRENT_TIMESTAMP" }
+    t.datetime :modified_time_function, default: -> { "now()" }
+    t.datetime :fixed_time, default: "2004-01-01 00:00:00.000000-00"
+    t.column :char1, "char(1)", default: "Y"
+    t.string :char2, limit: 50, default: "a varchar field"
+    t.text :char3, default: "a text field"
+    t.bigint :bigint_default, default: -> { "0::bigint" }
     t.text :multiline_default, default: '--- []
 
 '
@@ -32,12 +32,12 @@ ActiveRecord::Schema.define do
     drop_table table_name, if_exists: true
   end
 
-  execute 'DROP SEQUENCE IF EXISTS companies_nonstd_seq CASCADE'
-  execute 'CREATE SEQUENCE companies_nonstd_seq START 101 OWNED BY companies.id'
+  execute "DROP SEQUENCE IF EXISTS companies_nonstd_seq CASCADE"
+  execute "CREATE SEQUENCE companies_nonstd_seq START 101 OWNED BY companies.id"
   execute "ALTER TABLE companies ALTER COLUMN id SET DEFAULT nextval('companies_nonstd_seq')"
-  execute 'DROP SEQUENCE IF EXISTS companies_id_seq'
+  execute "DROP SEQUENCE IF EXISTS companies_id_seq"
 
-  execute 'DROP FUNCTION IF EXISTS partitioned_insert_trigger()'
+  execute "DROP FUNCTION IF EXISTS partitioned_insert_trigger()"
 
   %w(accounts_id_seq developers_id_seq projects_id_seq topics_id_seq customers_id_seq orders_id_seq).each do |seq_name|
     execute "SELECT setval('#{seq_name}', 100)"
diff --git a/activerecord/test/schema/schema.rb b/activerecord/test/schema/schema.rb
index a5155e9cdb..558c21b8d2 100644
--- a/activerecord/test/schema/schema.rb
+++ b/activerecord/test/schema/schema.rb
@@ -21,7 +21,7 @@ ActiveRecord::Schema.define do
     t.string :settings, null: true, limit: 1024
     # MySQL does not allow default values for blobs. Fake it out with a
     # big varchar below.
-    t.string :preferences, null: true, default: '', limit: 1024
+    t.string :preferences, null: true, default: "", limit: 1024
     t.string :json_data, null: true, limit: 1024
     t.string :json_data_empty, null: true, default: "", limit: 1024
     t.text :params
@@ -98,7 +98,7 @@ ActiveRecord::Schema.define do
     t.column :author_visibility, :integer, default: 0
     t.column :illustrator_visibility, :integer, default: 0
     t.column :font_size, :integer, default: 0
-    t.column :cover, :string, default: 'hard'
+    t.column :cover, :string, default: "hard"
   end
 
   create_table :booleans, force: true do |t|
@@ -198,8 +198,8 @@ ActiveRecord::Schema.define do
     t.string :description, default: ""
     t.index [:firm_id, :type, :rating], name: "company_index"
     t.index [:firm_id, :type], name: "company_partial_index", where: "rating > 10"
-    t.index :name, name: 'company_name_index', using: :btree
-    t.index 'lower(name)', name: "company_expression_index" if supports_expression_index?
+    t.index :name, name: "company_name_index", using: :btree
+    t.index "lower(name)", name: "company_expression_index" if supports_expression_index?
   end
 
   create_table :content, force: true do |t|
@@ -298,7 +298,7 @@ ActiveRecord::Schema.define do
   create_table :edges, force: true, id: false do |t|
     t.column :source_id, :integer, null: false
     t.column :sink_id,   :integer, null: false
-    t.index [:source_id, :sink_id], unique: true, name: 'unique_edge_index'
+    t.index [:source_id, :sink_id], unique: true, name: "unique_edge_index"
   end
 
   create_table :engines, force: true do |t|
@@ -894,7 +894,7 @@ ActiveRecord::Schema.define do
     t.column :label, :string
   end
 
-  create_table 'warehouse-things', force: true do |t|
+  create_table "warehouse-things", force: true do |t|
     t.integer :value
   end
 
@@ -934,11 +934,11 @@ ActiveRecord::Schema.define do
     t.string :title
   end
 
-  create_table :countries, force: true, id: false, primary_key: 'country_id' do |t|
+  create_table :countries, force: true, id: false, primary_key: "country_id" do |t|
     t.string :country_id
     t.string :name
   end
-  create_table :treaties, force: true, id: false, primary_key: 'treaty_id' do |t|
+  create_table :treaties, force: true, id: false, primary_key: "treaty_id" do |t|
     t.string :treaty_id
     t.string :name
   end
@@ -959,9 +959,9 @@ ActiveRecord::Schema.define do
     t.string :name
   end
   create_table :weirds, force: true do |t|
-    t.string 'a$b'
-    t.string 'なまえ'
-    t.string 'from'
+    t.string "a$b"
+    t.string "なまえ"
+    t.string "from"
   end
 
   create_table :nodes, force: true do |t|
@@ -1015,7 +1015,7 @@ ActiveRecord::Schema.define do
     t.float :overloaded_float, default: 500
     t.float :unoverloaded_float
     t.string :overloaded_string_with_limit, limit: 255
-    t.string :string_with_default, default: 'the original default'
+    t.string :string_with_default, default: "the original default"
   end
 
   create_table :users, force: true do |t|
diff --git a/activerecord/test/support/config.rb b/activerecord/test/support/config.rb
index 6d123688a3..d0717f7b34 100644
--- a/activerecord/test/support/config.rb
+++ b/activerecord/test/support/config.rb
@@ -1,7 +1,7 @@
-require 'yaml'
-require 'erubis'
-require 'fileutils'
-require 'pathname'
+require "yaml"
+require "erubis"
+require "fileutils"
+require "pathname"
 
 module ARTest
   class << self
@@ -12,12 +12,12 @@ module ARTest
     private
 
     def config_file
-      Pathname.new(ENV['ARCONFIG'] || TEST_ROOT + '/config.yml')
+      Pathname.new(ENV["ARCONFIG"] || TEST_ROOT + "/config.yml")
     end
 
     def read_config
       unless config_file.exist?
-        FileUtils.cp TEST_ROOT + '/config.example.yml', config_file
+        FileUtils.cp TEST_ROOT + "/config.example.yml", config_file
       end
 
       erb = Erubis::Eruby.new(config_file.read)
@@ -25,15 +25,15 @@ module ARTest
     end
 
     def expand_config(config)
-      config['connections'].each do |adapter, connection|
-        dbs = [['arunit', 'activerecord_unittest'], ['arunit2', 'activerecord_unittest2']]
+      config["connections"].each do |adapter, connection|
+        dbs = [["arunit", "activerecord_unittest"], ["arunit2", "activerecord_unittest2"]]
         dbs.each do |name, dbname|
           unless connection[name].is_a?(Hash)
-            connection[name] = { 'database' => connection[name] }
+            connection[name] = { "database" => connection[name] }
           end
 
-          connection[name]['database'] ||= dbname
-          connection[name]['adapter']  ||= adapter
+          connection[name]["database"] ||= dbname
+          connection[name]["adapter"]  ||= adapter
         end
       end
 
diff --git a/activerecord/test/support/connection.rb b/activerecord/test/support/connection.rb
index c5334e8596..c9260398e2 100644
--- a/activerecord/test/support/connection.rb
+++ b/activerecord/test/support/connection.rb
@@ -1,15 +1,15 @@
-require 'active_support/logger'
-require 'models/college'
-require 'models/course'
-require 'models/professor'
+require "active_support/logger"
+require "models/college"
+require "models/course"
+require "models/professor"
 
 module ARTest
   def self.connection_name
-    ENV['ARCONN'] || config['default_connection']
+    ENV["ARCONN"] || config["default_connection"]
   end
 
   def self.connection_config
-    config['connections'][connection_name]
+    config["connections"][connection_name]
   end
 
   def self.connect