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.

36 files changed, 561 insertions, 561 deletions

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