ibm_db 5.2.0-x86-mingw32 → 5.4.0-x86-mingw32

data/test/cases/schema_dumper_test.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 class SchemaDumperTest < ActiveRecord::TestCase
   include SchemaDumpingHelper
@@ -26,33 +28,16 @@ class SchemaDumperTest < ActiveRecord::TestCase
   def test_dump_schema_information_outputs_lexically_ordered_versions
     versions = %w{ 20100101010101 20100201010101 20100301010101 }
     versions.reverse_each do |v|
-      ActiveRecord::SchemaMigration.create!(:version => v)
+      ActiveRecord::SchemaMigration.create!(version: v)
     end
 
     schema_info = ActiveRecord::Base.connection.dump_schema_information
     assert_match(/20100201010101.*20100301010101/m, schema_info)
+    assert_includes schema_info, "20100101010101"
   ensure
     ActiveRecord::SchemaMigration.delete_all
   end
 
-  if current_adapter?(:SQLite3Adapter)
-    %w{3.7.8 3.7.11 3.7.12}.each do |version_string|
-      test "dumps schema version for sqlite version #{version_string}" do
-        version = ActiveRecord::ConnectionAdapters::SQLite3Adapter::Version.new(version_string)
-        ActiveRecord::Base.connection.stubs(:sqlite_version).returns(version)
-
-        versions = %w{ 20100101010101 20100201010101 20100301010101 }
-        versions.reverse_each do |v|
-          ActiveRecord::SchemaMigration.create!(:version => v)
-        end
-
-        schema_info = ActiveRecord::Base.connection.dump_schema_information
-        assert_match(/20100201010101.*20100301010101/m, schema_info)
-        ActiveRecord::SchemaMigration.delete_all
-      end
-    end
-  end
-
   def test_schema_dump
     output = standard_dump
     assert_match %r{create_table "accounts"}, output
@@ -64,7 +49,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
 
   def test_schema_dump_uses_force_cascade_on_create_table
     output = dump_table_schema "authors"
-    assert_match %r{create_table "authors", force: :cascade}, output
+    assert_match %r{create_table "authors",.* force: :cascade}, output
   end
 
   def test_schema_dump_excludes_sqlite_sequence
@@ -74,46 +59,38 @@ class SchemaDumperTest < ActiveRecord::TestCase
 
   def test_schema_dump_includes_camelcase_table_name
     output = standard_dump
-    if current_adapter?(:IBM_DBAdapter)
-      #DB2 is case insensitive
-      assert_match %r{create_table "camelcase"}, output
-    else
-      assert_match %r{create_table "CamelCase"}, output
-    end
+    assert_match %r{create_table "CamelCase"}, output
   end
 
-  def assert_line_up(lines, pattern, required = false)
+  def assert_no_line_up(lines, pattern)
     return assert(true) if lines.empty?
     matches = lines.map { |line| line.match(pattern) }
-    assert matches.all? if required
     matches.compact!
     return assert(true) if matches.empty?
-    assert_equal 1, matches.map{ |match| match.offset(0).first }.uniq.length
+    line_matches = lines.map { |line| [line, line.match(pattern)] }.select { |line, match| match }
+    assert line_matches.all? { |line, match|
+      start = match.offset(0).first
+      line[start - 2..start - 1] == ", "
+    }
   end
 
   def column_definition_lines(output = standard_dump)
-    output.scan(/^( *)create_table.*?\n(.*?)^\1end/m).map{ |m| m.last.split(/\n/) }
+    output.scan(/^( *)create_table.*?\n(.*?)^\1end/m).map { |m| m.last.split(/\n/) }
   end
 
-  def test_types_line_up
+  def test_types_no_line_up
     column_definition_lines.each do |column_set|
       next if column_set.empty?
 
-      lengths = column_set.map do |column|
-        if match = column.match(/\bt\.\w+\s+(?="\w+?")/)
-          match[0].length
-        end
-      end.compact
-
-      assert_equal 1, lengths.uniq.length
+      assert column_set.all? { |column| !column.match(/\bt\.\w+\s{2,}/) }
     end
   end
 
-  def test_arguments_line_up
+  def test_arguments_no_line_up
     column_definition_lines.each do |column_set|
-      assert_line_up(column_set, /default: /)
-      assert_line_up(column_set, /limit: /)
-      assert_line_up(column_set, /null: /)
+      assert_no_line_up(column_set, /default: /)
+      assert_no_line_up(column_set, /limit: /)
+      assert_no_line_up(column_set, /null: /)
     end
   end
 
@@ -130,44 +107,29 @@ class SchemaDumperTest < ActiveRecord::TestCase
   def test_schema_dump_includes_limit_constraint_for_integer_columns
     output = dump_all_table_schema([/^(?!integer_limits)/])
 
-    assert_match %r{c_int_without_limit}, output
+    assert_match %r{"c_int_without_limit"(?!.*limit)}, output
 
     if current_adapter?(:PostgreSQLAdapter)
-      assert_no_match %r{c_int_without_limit.*limit:}, output
-
       assert_match %r{c_int_1.*limit: 2}, output
       assert_match %r{c_int_2.*limit: 2}, output
 
       # int 3 is 4 bytes in postgresql
-      assert_match %r{c_int_3.*}, output
-      assert_no_match %r{c_int_3.*limit:}, output
-
-      assert_match %r{c_int_4.*}, output
-      assert_no_match %r{c_int_4.*limit:}, output
+      assert_match %r{"c_int_3"(?!.*limit)}, output
+      assert_match %r{"c_int_4"(?!.*limit)}, output
     elsif current_adapter?(:Mysql2Adapter)
-      assert_match %r{c_int_without_limit"$}, output
-
       assert_match %r{c_int_1.*limit: 1}, output
       assert_match %r{c_int_2.*limit: 2}, output
       assert_match %r{c_int_3.*limit: 3}, output
 
-      assert_match %r{c_int_4.*}, output
-      assert_no_match %r{c_int_4.*:limit}, output
+      assert_match %r{"c_int_4"(?!.*limit)}, output
     elsif current_adapter?(:SQLite3Adapter)
-      assert_no_match %r{c_int_without_limit.*limit:}, output
-
       assert_match %r{c_int_1.*limit: 1}, output
       assert_match %r{c_int_2.*limit: 2}, output
       assert_match %r{c_int_3.*limit: 3}, output
       assert_match %r{c_int_4.*limit: 4}, output
     end
 
-    if current_adapter?(:SQLite3Adapter)
-      assert_match %r{c_int_5.*limit: 5}, output
-      assert_match %r{c_int_6.*limit: 6}, output
-      assert_match %r{c_int_7.*limit: 7}, output
-      assert_match %r{c_int_8.*limit: 8}, output
-    elsif current_adapter?(:OracleAdapter)
+    if current_adapter?(:SQLite3Adapter, :OracleAdapter)
       assert_match %r{c_int_5.*limit: 5}, output
       assert_match %r{c_int_6.*limit: 6}, output
       assert_match %r{c_int_7.*limit: 7}, output
@@ -181,7 +143,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
   end
 
   def test_schema_dump_with_string_ignored_table
-    output = dump_all_table_schema(['accounts'])
+    output = dump_all_table_schema(["accounts"])
     assert_no_match %r{create_table "accounts"}, output
     assert_match %r{create_table "authors"}, output
     assert_no_match %r{create_table "schema_migrations"}, output
@@ -197,29 +159,58 @@ class SchemaDumperTest < ActiveRecord::TestCase
   end
 
   def test_schema_dumps_index_columns_in_right_order
-    index_definition = standard_dump.split(/\n/).grep(/t\.index.*company_index/).first.strip
-    if current_adapter?(:PostgreSQLAdapter)
-      assert_equal 't.index ["firm_id", "type", "rating"], name: "company_index", order: { rating: :desc }, using: :btree', index_definition
-    elsif current_adapter?(:Mysql2Adapter)
-      assert_equal 't.index ["firm_id", "type", "rating"], name: "company_index", length: { type: 10 }, using: :btree', index_definition
+    index_definition = dump_table_schema("companies").split(/\n/).grep(/t\.index.*company_index/).first.strip
+    if current_adapter?(:Mysql2Adapter)
+      if ActiveRecord::Base.connection.supports_index_sort_order?
+        assert_equal 't.index ["firm_id", "type", "rating"], name: "company_index", length: { type: 10 }, order: { rating: :desc }', index_definition
+      else
+        assert_equal 't.index ["firm_id", "type", "rating"], name: "company_index", length: { type: 10 }', index_definition
+      end
+    elsif ActiveRecord::Base.connection.supports_index_sort_order?
+      assert_equal 't.index ["firm_id", "type", "rating"], name: "company_index", order: { rating: :desc }', index_definition
     else
       assert_equal 't.index ["firm_id", "type", "rating"], name: "company_index"', index_definition
     end
   end
 
   def test_schema_dumps_partial_indices
-    index_definition = standard_dump.split(/\n/).grep(/t\.index.*company_partial_index/).first.strip
-    if current_adapter?(:PostgreSQLAdapter)
-      assert_equal 't.index ["firm_id", "type"], name: "company_partial_index", where: "(rating > 10)", using: :btree', index_definition
-    elsif current_adapter?(:Mysql2Adapter)
-      assert_equal 't.index ["firm_id", "type"], name: "company_partial_index", using: :btree', index_definition
-    elsif current_adapter?(:SQLite3Adapter) && ActiveRecord::Base.connection.supports_partial_index?
-      assert_equal 't.index ["firm_id", "type"], name: "company_partial_index", where: "rating > 10"', index_definition
+    index_definition = dump_table_schema("companies").split(/\n/).grep(/t\.index.*company_partial_index/).first.strip
+    if ActiveRecord::Base.connection.supports_partial_index?
+      assert_equal 't.index ["firm_id", "type"], name: "company_partial_index", where: "(rating > 10)"', index_definition
     else
       assert_equal 't.index ["firm_id", "type"], name: "company_partial_index"', index_definition
     end
   end
 
+  def test_schema_dumps_index_sort_order
+    index_definition = dump_table_schema("companies").split(/\n/).grep(/t\.index.*_name_and_rating/).first.strip
+    if ActiveRecord::Base.connection.supports_index_sort_order?
+      assert_equal 't.index ["name", "rating"], name: "index_companies_on_name_and_rating", order: :desc', index_definition
+    else
+      assert_equal 't.index ["name", "rating"], name: "index_companies_on_name_and_rating"', index_definition
+    end
+  end
+
+  def test_schema_dumps_index_length
+    index_definition = dump_table_schema("companies").split(/\n/).grep(/t\.index.*_name_and_description/).first.strip
+    if current_adapter?(:Mysql2Adapter)
+      assert_equal 't.index ["name", "description"], name: "index_companies_on_name_and_description", length: 10', index_definition
+    else
+      assert_equal 't.index ["name", "description"], name: "index_companies_on_name_and_description"', index_definition
+    end
+  end
+
+  if ActiveRecord::Base.connection.supports_check_constraints?
+    def test_schema_dumps_check_constraints
+      constraint_definition = dump_table_schema("products").split(/\n/).grep(/t.check_constraint.*products_price_check/).first.strip
+      if current_adapter?(:Mysql2Adapter)
+        assert_equal 't.check_constraint "`price` > `discounted_price`", name: "products_price_check"', constraint_definition
+      else
+        assert_equal 't.check_constraint "price > discounted_price", name: "products_price_check"', constraint_definition
+      end
+    end
+  end
+
   def test_schema_dump_should_honor_nonstandard_primary_keys
     output = standard_dump
     match = output.match(%r{create_table "movies"(.*)do})
@@ -228,43 +219,76 @@ class SchemaDumperTest < ActiveRecord::TestCase
   end
 
   def test_schema_dump_should_use_false_as_default
-    output = standard_dump
+    output = dump_table_schema "booleans"
     assert_match %r{t\.boolean\s+"has_fun",.+default: false}, output
   end
 
-  if current_adapter?(:Mysql2Adapter)
-    def test_schema_dump_should_add_default_value_for_mysql_text_field
-      output = standard_dump
-      assert_match %r{t\.text\s+"body",\s+limit: 65535,\s+null: false$}, output
+  def test_schema_dump_does_not_include_limit_for_text_field
+    output = dump_table_schema "admin_users"
+    assert_match %r{t\.text\s+"params"}, output
+  end
+
+  def test_schema_dump_does_not_include_limit_for_binary_field
+    output = dump_table_schema "binaries"
+    assert_match %r{t\.binary\s+"data"$}, output
+  end
+
+  def test_schema_dump_does_not_include_limit_for_float_field
+    output = dump_table_schema "numeric_data"
+    assert_match %r{t\.float\s+"temperature"}, output
+  end
+
+  if ActiveRecord::Base.connection.supports_expression_index?
+    def test_schema_dump_expression_indices
+      index_definition = dump_table_schema("companies").split(/\n/).grep(/t\.index.*company_expression_index/).first.strip
+      index_definition.sub!(/, name: "company_expression_index"\z/, "")
+
+      if current_adapter?(:PostgreSQLAdapter)
+        assert_match %r{CASE.+lower\(\(name\)::text\).+END\) DESC"\z}i, index_definition
+      elsif current_adapter?(:Mysql2Adapter)
+        assert_match %r{CASE.+lower\(`name`\).+END\) DESC"\z}i, index_definition
+      elsif current_adapter?(:SQLite3Adapter)
+        assert_match %r{CASE.+lower\(name\).+END\) DESC"\z}i, index_definition
+      else
+        assert false
+      end
     end
+  end
 
+  if current_adapter?(:Mysql2Adapter)
     def test_schema_dump_includes_length_for_mysql_binary_fields
-      output = standard_dump
+      output = dump_table_schema "binary_fields"
       assert_match %r{t\.binary\s+"var_binary",\s+limit: 255$}, output
       assert_match %r{t\.binary\s+"var_binary_large",\s+limit: 4095$}, output
     end
 
     def test_schema_dump_includes_length_for_mysql_blob_and_text_fields
-      output = standard_dump
-      assert_match %r{t\.blob\s+"tiny_blob",\s+limit: 255$}, output
-      assert_match %r{t\.binary\s+"normal_blob",\s+limit: 65535$}, output
-      assert_match %r{t\.binary\s+"medium_blob",\s+limit: 16777215$}, output
-      assert_match %r{t\.binary\s+"long_blob",\s+limit: 4294967295$}, output
-      assert_match %r{t\.text\s+"tiny_text",\s+limit: 255$}, output
-      assert_match %r{t\.text\s+"normal_text",\s+limit: 65535$}, output
-      assert_match %r{t\.text\s+"medium_text",\s+limit: 16777215$}, output
-      assert_match %r{t\.text\s+"long_text",\s+limit: 4294967295$}, output
+      output = dump_table_schema "binary_fields"
+      assert_match %r{t\.binary\s+"tiny_blob",\s+size: :tiny$}, output
+      assert_match %r{t\.binary\s+"normal_blob"$}, output
+      assert_match %r{t\.binary\s+"medium_blob",\s+size: :medium$}, output
+      assert_match %r{t\.binary\s+"long_blob",\s+size: :long$}, output
+      assert_match %r{t\.text\s+"tiny_text",\s+size: :tiny$}, output
+      assert_match %r{t\.text\s+"normal_text"$}, output
+      assert_match %r{t\.text\s+"medium_text",\s+size: :medium$}, output
+      assert_match %r{t\.text\s+"long_text",\s+size: :long$}, output
+      assert_match %r{t\.binary\s+"tiny_blob_2",\s+size: :tiny$}, output
+      assert_match %r{t\.binary\s+"medium_blob_2",\s+size: :medium$}, output
+      assert_match %r{t\.binary\s+"long_blob_2",\s+size: :long$}, output
+      assert_match %r{t\.text\s+"tiny_text_2",\s+size: :tiny$}, output
+      assert_match %r{t\.text\s+"medium_text_2",\s+size: :medium$}, output
+      assert_match %r{t\.text\s+"long_text_2",\s+size: :long$}, output
     end
 
     def test_schema_does_not_include_limit_for_emulated_mysql_boolean_fields
-      output = standard_dump
+      output = dump_table_schema "booleans"
       assert_no_match %r{t\.boolean\s+"has_fun",.+limit: 1}, output
     end
 
     def test_schema_dumps_index_type
-      output = standard_dump
-      assert_match %r{t\.index \["awesome"\], name: "index_key_tests_on_awesome", type: :fulltext}, output
-      assert_match %r{t\.index \["pizza"\], name: "index_key_tests_on_pizza", using: :btree}, output
+      output = dump_table_schema "key_tests"
+      assert_match %r{t\.index \["awesome"\], name: "index_key_tests_on_awesome", type: :fulltext$}, output
+      assert_match %r{t\.index \["pizza"\], name: "index_key_tests_on_pizza"$}, output
     end
   end
 
@@ -275,40 +299,62 @@ class SchemaDumperTest < ActiveRecord::TestCase
 
   if current_adapter?(:PostgreSQLAdapter)
     def test_schema_dump_includes_bigint_default
-      output = standard_dump
+      output = dump_table_schema "defaults"
       assert_match %r{t\.bigint\s+"bigint_default",\s+default: 0}, output
     end
 
     def test_schema_dump_includes_limit_on_array_type
-      output = standard_dump
+      output = dump_table_schema "bigint_array"
       assert_match %r{t\.bigint\s+"big_int_data_points\",\s+array: true}, output
     end
 
     def test_schema_dump_allows_array_of_decimal_defaults
-      output = standard_dump
+      output = dump_table_schema "bigint_array"
       assert_match %r{t\.decimal\s+"decimal_array_default",\s+default: \["1.23", "3.45"\],\s+array: true}, output
     end
 
-    def test_schema_dump_expression_indices
-      index_definition = standard_dump.split(/\n/).grep(/t\.index.*company_expression_index/).first.strip
-      assert_equal 't.index "lower((name)::text)", name: "company_expression_index", using: :btree', index_definition
+    def test_schema_dump_interval_type
+      output = dump_table_schema "postgresql_times"
+      assert_match %r{t\.interval\s+"time_interval"$}, output
+      assert_match %r{t\.interval\s+"scaled_time_interval",\s+precision: 6$}, output
+    end
+
+    def test_schema_dump_oid_type
+      output = dump_table_schema "postgresql_oids"
+      assert_match %r{t\.oid\s+"obj_id"$}, output
     end
 
-    if ActiveRecord::Base.connection.supports_extensions?
-      def test_schema_dump_includes_extensions
-        connection = ActiveRecord::Base.connection
+    def test_schema_dump_includes_extensions
+      connection = ActiveRecord::Base.connection
 
-        connection.stubs(:extensions).returns(['hstore'])
+      connection.stub(:extensions, ["hstore"]) do
         output = perform_schema_dump
         assert_match "# These are extensions that must be enabled", output
         assert_match %r{enable_extension "hstore"}, output
+      end
 
-        connection.stubs(:extensions).returns([])
+      connection.stub(:extensions, []) do
         output = perform_schema_dump
         assert_no_match "# These are extensions that must be enabled", output
         assert_no_match %r{enable_extension}, output
       end
     end
+
+    def test_schema_dump_includes_extensions_in_alphabetic_order
+      connection = ActiveRecord::Base.connection
+
+      connection.stub(:extensions, ["hstore", "uuid-ossp", "xml2"]) do
+        output = perform_schema_dump
+        enabled_extensions = output.scan(%r{enable_extension "(.+)"}).flatten
+        assert_equal ["hstore", "uuid-ossp", "xml2"], enabled_extensions
+      end
+
+      connection.stub(:extensions, ["uuid-ossp", "xml2", "hstore"]) do
+        output = perform_schema_dump
+        enabled_extensions = output.scan(%r{enable_extension "(.+)"}).flatten
+        assert_equal ["hstore", "uuid-ossp", "xml2"], enabled_extensions
+      end
+    end
   end
 
   def test_schema_dump_keeps_large_precision_integer_columns_as_decimal
@@ -316,11 +362,8 @@ class SchemaDumperTest < ActiveRecord::TestCase
     # Oracle supports precision up to 38 and it identifies decimals with scale 0 as integers
     if current_adapter?(:OracleAdapter)
       assert_match %r{t\.integer\s+"atoms_in_universe",\s+precision: 38}, output
-	elsif current_adapter?(:IBM_DBAdapter)
-      # DB2 supports precision up to 31
-      assert_match %r{t.decimal\s+"atoms_in_universe",\s+precision: 31,\s+scale: 0}, output    
-    elsif current_adapter?(:FbAdapter)
-      assert_match %r{t\.integer\s+"atoms_in_universe",\s+precision: 18}, output
+    elsif current_adapter?(:IBM_DBAdapter)
+      assert_match %r{t\.decimal\s+"atoms_in_universe",\s+precision: 31}, output
     else
       assert_match %r{t\.decimal\s+"atoms_in_universe",\s+precision: 55}, output
     end
@@ -336,7 +379,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
 
   def test_schema_dump_keeps_id_false_when_id_is_false_and_unique_not_null_column_added
     output = standard_dump
-    assert_match %r{create_table "subscribers", id: false}, output
+    assert_match %r{create_table "string_key_objects", id: false}, output
   end
 
   if ActiveRecord::Base.connection.supports_foreign_keys?
@@ -358,9 +401,9 @@ class SchemaDumperTest < ActiveRecord::TestCase
 
       create_table("dogs") do |t|
         t.column :name, :string
-        t.column :owner_id, :integer
+        t.references :owner
         t.index [:name]
-        t.foreign_key :dog_owners, column: "owner_id" if supports_foreign_keys?
+        t.foreign_key :dog_owners, column: "owner_id"
       end
     end
     def down
@@ -371,8 +414,8 @@ class SchemaDumperTest < ActiveRecord::TestCase
 
   def test_schema_dump_with_table_name_prefix_and_suffix
     original, $stdout = $stdout, StringIO.new
-    ActiveRecord::Base.table_name_prefix = 'foo_'
-    ActiveRecord::Base.table_name_suffix = '_bar'
+    ActiveRecord::Base.table_name_prefix = "foo_"
+    ActiveRecord::Base.table_name_suffix = "_bar"
 
     migration = CreateDogMigration.new
     migration.migrate(:up)
@@ -390,7 +433,32 @@ class SchemaDumperTest < ActiveRecord::TestCase
   ensure
     migration.migrate(:down)
 
-    ActiveRecord::Base.table_name_suffix = ActiveRecord::Base.table_name_prefix = ''
+    ActiveRecord::Base.table_name_suffix = ActiveRecord::Base.table_name_prefix = ""
+    $stdout = original
+  end
+
+  def test_schema_dump_with_table_name_prefix_and_suffix_regexp_escape
+    original, $stdout = $stdout, StringIO.new
+    ActiveRecord::Base.table_name_prefix = "foo$"
+    ActiveRecord::Base.table_name_suffix = "$bar"
+
+    migration = CreateDogMigration.new
+    migration.migrate(:up)
+
+    output = perform_schema_dump
+    assert_no_match %r{create_table "foo\$.+\$bar"}, output
+    assert_no_match %r{add_index "foo\$.+\$bar"}, output
+    assert_no_match %r{create_table "schema_migrations"}, output
+    assert_no_match %r{create_table "ar_internal_metadata"}, output
+
+    if ActiveRecord::Base.connection.supports_foreign_keys?
+      assert_no_match %r{add_foreign_key "foo\$.+\$bar"}, output
+      assert_no_match %r{add_foreign_key "[^"]+", "foo\$.+\$bar"}, output
+    end
+  ensure
+    migration.migrate(:down)
+
+    ActiveRecord::Base.table_name_suffix = ActiveRecord::Base.table_name_prefix = ""
     $stdout = original
   end
 
@@ -408,7 +476,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
 
     original_table_name_prefix = ActiveRecord::Base.table_name_prefix
     original_schema_dumper_ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
-    ActiveRecord::Base.table_name_prefix = 'omg_'
+    ActiveRecord::Base.table_name_prefix = "omg_"
     ActiveRecord::SchemaDumper.ignore_tables = ["cats"]
     migration = create_cat_migration.new
     migration.migrate(:up)
@@ -417,7 +485,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
     output = ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream).string
 
     assert_match %r{create_table "omg_cats"}, output
-    refute_match %r{create_table "cats"}, output
+    assert_no_match %r{create_table "cats"}, output
   ensure
     migration.migrate(:down)
     ActiveRecord::Base.table_name_prefix = original_table_name_prefix
@@ -432,26 +500,51 @@ class SchemaDumperDefaultsTest < ActiveRecord::TestCase
 
   setup do
     @connection = ActiveRecord::Base.connection
-    @connection.create_table :defaults, force: true do |t|
+    @connection.create_table :dump_defaults, force: true do |t|
       t.string   :string_with_default,   default: "Hello!"
-      t.date     :date_with_default,     default: '2014-06-05'
+      t.date     :date_with_default,     default: "2014-06-05"
       t.datetime :datetime_with_default, default: "2014-06-05 07:17:04"
       t.time     :time_with_default,     default: "07:17:04"
+      t.decimal  :decimal_with_default,  default: "1234567890.0123456789", precision: 20, scale: 10
+      t.text :text_with_default, default: "John' Doe" if supports_text_column_with_default?
+    end
+
+    if current_adapter?(:PostgreSQLAdapter)
+      @connection.create_table :infinity_defaults, force: true do |t|
+        t.float    :float_with_inf_default,    default: Float::INFINITY
+        t.float    :float_with_nan_default,    default: Float::NAN
+        t.datetime :beginning_of_time,         default: "-infinity"
+        t.datetime :end_of_time,               default: "infinity"
+      end
     end
   end
 
   teardown do
-    return unless @connection
-    @connection.drop_table 'defaults'
-	#, if_exists: true
+    @connection.drop_table "dump_defaults", if_exists: true
   end
 
   def test_schema_dump_defaults_with_universally_supported_types
-    output = dump_table_schema('defaults')
+    output = dump_table_schema("dump_defaults")
 
     assert_match %r{t\.string\s+"string_with_default",.*?default: "Hello!"}, output
-    assert_match %r{t\.date\s+"date_with_default",\s+default: '2014-06-05'}, output
-    assert_match %r{t\.datetime\s+"datetime_with_default",\s+default: '2014-06-05 07:17:04'}, output
-    assert_match %r{t\.time\s+"time_with_default",\s+default: '2000-01-01 07:17:04'}, output
+    assert_match %r{t\.date\s+"date_with_default",\s+default: "2014-06-05"}, output
+    assert_match %r{t\.datetime\s+"datetime_with_default",\s+precision: 6,\s+default: "2014-06-05 07:17:04"}, output
+    assert_match %r{t\.time\s+"time_with_default",\s+default: "2000-01-01 07:17:04"}, output
+    assert_match %r{t\.decimal\s+"decimal_with_default",\s+precision: 20,\s+scale: 10,\s+default: "1234567890.0123456789"}, output
+  end
+
+  def test_schema_dump_with_text_column
+    output = dump_table_schema("dump_defaults")
+
+    assert_match %r{t\.text\s+"text_with_default",.*?default: "John' Doe"}, output
+  end if supports_text_column_with_default?
+
+  def test_schema_dump_with_column_infinity_default
+    skip unless current_adapter?(:PostgreSQLAdapter)
+    output = dump_table_schema("infinity_defaults")
+    assert_match %r{t\.float\s+"float_with_inf_default",\s+default: ::Float::INFINITY}, output
+    assert_match %r{t\.float\s+"float_with_nan_default",\s+default: ::Float::NAN}, output
+    assert_match %r{t\.datetime\s+"beginning_of_time",\s+default: -::Float::INFINITY}, output
+    assert_match %r{t\.datetime\s+"end_of_time",\s+default: ::Float::INFINITY}, output
   end
 end

data/test/cases/schema_loading_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module SchemaLoadCounter
@@ -8,7 +10,7 @@ module SchemaLoadCounter
 
     def load_schema!
       self.load_schema_calls ||= 0
-      self.load_schema_calls +=1
+      self.load_schema_calls += 1
       super
     end
   end
@@ -41,7 +43,6 @@ class SchemaLoadingTest < ActiveRecord::TestCase
   end
 
   private
-
     def define_model
       Class.new(ActiveRecord::Base) do
         include SchemaLoadCounter