1 files changed, 82 insertions, 73 deletions

diff --git a/activerecord/test/cases/defaults_test.rb b/activerecord/test/cases/defaults_test.rb
index 67fddebf45..3d11b573f1 100644
--- a/activerecord/test/cases/defaults_test.rb
+++ b/activerecord/test/cases/defaults_test.rb
@@ -1,20 +1,16 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/default'
-require 'models/entrant'
+require "support/schema_dumping_helper"
+require "models/default"
+require "models/entrant"
 
 class DefaultTest < ActiveRecord::TestCase
   def test_nil_defaults_for_not_null_columns
-    column_defaults =
-      if current_adapter?(:MysqlAdapter) && (Mysql.client_version < 50051 || (50100..50122).include?(Mysql.client_version))
-        { 'id' => nil, 'name' => '',  'course_id' => nil }
-      else
-        { 'id' => nil, 'name' => nil, 'course_id' => nil }
-      end
-
-    column_defaults.each do |name, default|
+    %w(id name course_id).each do |name|
       column = Entrant.columns_hash[name]
       assert !column.null, "#{name} column should be NOT NULL"
-      assert_equal default, column.default, "#{name} column should be DEFAULT #{default.inspect}"
+      assert_not column.default, "#{name} column should be DEFAULT 'nil'"
     end
   end
 
@@ -57,7 +53,7 @@ class DefaultNumbersTest < ActiveRecord::TestCase
 
   def test_default_decimal_number
     record = DefaultNumber.new
-    assert_equal BigDecimal.new("2.78"), record.decimal_number
+    assert_equal BigDecimal("2.78"), record.decimal_number
     assert_equal "2.78", record.decimal_number_before_type_cast
   end
 end
@@ -87,7 +83,47 @@ class DefaultStringsTest < ActiveRecord::TestCase
   end
 end
 
-if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
+if current_adapter?(:PostgreSQLAdapter)
+  class PostgresqlDefaultExpressionTest < ActiveRecord::TestCase
+    include SchemaDumpingHelper
+
+    test "schema dump includes default expression" do
+      output = dump_table_schema("defaults")
+      if ActiveRecord::Base.connection.postgresql_version >= 100000
+        assert_match %r/t\.date\s+"modified_date",\s+default: -> { "CURRENT_DATE" }/, output
+        assert_match %r/t\.datetime\s+"modified_time",\s+default: -> { "CURRENT_TIMESTAMP" }/, output
+      else
+        assert_match %r/t\.date\s+"modified_date",\s+default: -> { "\('now'::text\)::date" }/, output
+        assert_match %r/t\.datetime\s+"modified_time",\s+default: -> { "now\(\)" }/, output
+      end
+      assert_match %r/t\.date\s+"modified_date_function",\s+default: -> { "now\(\)" }/, output
+      assert_match %r/t\.datetime\s+"modified_time_function",\s+default: -> { "now\(\)" }/, output
+    end
+  end
+end
+
+if current_adapter?(:Mysql2Adapter)
+  class MysqlDefaultExpressionTest < ActiveRecord::TestCase
+    include SchemaDumpingHelper
+
+    if ActiveRecord::Base.connection.version >= "5.6.0"
+      test "schema dump datetime includes default expression" do
+        output = dump_table_schema("datetime_defaults")
+        assert_match %r/t\.datetime\s+"modified_datetime",\s+default: -> { "CURRENT_TIMESTAMP" }/, output
+      end
+    end
+
+    test "schema dump timestamp includes default expression" do
+      output = dump_table_schema("timestamp_defaults")
+      assert_match %r/t\.timestamp\s+"modified_timestamp",\s+default: -> { "CURRENT_TIMESTAMP" }/, output
+    end
+
+    test "schema dump timestamp without default expression" do
+      output = dump_table_schema("timestamp_defaults")
+      assert_match %r/t\.timestamp\s+"nullable_timestamp"$/, output
+    end
+  end
+
   class DefaultsTestWithoutTransactionalFixtures < ActiveRecord::TestCase
     # ActiveRecord::Base#create! (and #save and other related methods) will
     # open a new transaction. When in transactional tests mode, this will
@@ -108,93 +144,66 @@ if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
       ActiveRecord::Base.establish_connection connection
     end
 
-    # MySQL cannot have defaults on text/blob columns. It reports the
-    # default value as null.
-    #
-    # Despite this, in non-strict mode, MySQL will use an empty string
-    # as the default value of the field, if no other value is
-    # specified.
+    # Strict mode controls how MySQL handles invalid or missing values
+    # in data-change statements such as INSERT or UPDATE. A value can be
+    # invalid for several reasons. For example, it might have the wrong
+    # data type for the column, or it might be out of range. A value is
+    # missing when a new row to be inserted does not contain a value for
+    # a non-NULL column that has no explicit DEFAULT clause in its definition.
+    # (For a NULL column, NULL is inserted if the value is missing.)
     #
-    # Therefore, in non-strict mode, we want column.default to report
-    # an empty string as its default, to be consistent with that.
+    # If strict mode is not in effect, MySQL inserts adjusted values for
+    # invalid or missing values and produces warnings. In strict mode,
+    # you can produce this behavior by using INSERT IGNORE or UPDATE IGNORE.
     #
-    # In strict mode, column.default should be nil.
-    def test_mysql_text_not_null_defaults_non_strict
+    # https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sql-mode-strict
+    def test_mysql_not_null_defaults_non_strict
       using_strict(false) do
-        with_text_blob_not_null_table do |klass|
+        with_mysql_not_null_table do |klass|
           record = klass.new
-          assert_equal '', record.non_null_blob
-          assert_equal '', record.non_null_text
-
-          assert_nil record.null_blob
-          assert_nil record.null_text
+          assert_nil record.non_null_integer
+          assert_nil record.non_null_string
+          assert_nil record.non_null_text
+          assert_nil record.non_null_blob
 
           record.save!
           record.reload
 
-          assert_equal '', record.non_null_text
-          assert_equal '', record.non_null_blob
-
-          assert_nil record.null_text
-          assert_nil record.null_blob
+          assert_equal 0,  record.non_null_integer
+          assert_equal "", record.non_null_string
+          assert_equal "", record.non_null_text
+          assert_equal "", record.non_null_blob
         end
       end
     end
 
-    def test_mysql_text_not_null_defaults_strict
+    def test_mysql_not_null_defaults_strict
       using_strict(true) do
-        with_text_blob_not_null_table do |klass|
+        with_mysql_not_null_table do |klass|
           record = klass.new
-          assert_nil record.non_null_blob
+          assert_nil record.non_null_integer
+          assert_nil record.non_null_string
           assert_nil record.non_null_text
-          assert_nil record.null_blob
-          assert_nil record.null_text
+          assert_nil record.non_null_blob
 
-          assert_raises(ActiveRecord::StatementInvalid) { klass.create }
+          assert_raises(ActiveRecord::NotNullViolation) { klass.create }
         end
       end
     end
 
-    def with_text_blob_not_null_table
+    def with_mysql_not_null_table
       klass = Class.new(ActiveRecord::Base)
-      klass.table_name = 'test_mysql_text_not_null_defaults'
+      klass.table_name = "test_mysql_not_null_defaults"
       klass.connection.create_table klass.table_name do |t|
-        t.column :non_null_text, :text, :null => false
-        t.column :non_null_blob, :blob, :null => false
-        t.column :null_text, :text, :null => true
-        t.column :null_blob, :blob, :null => true
+        t.integer :non_null_integer, null: false
+        t.string  :non_null_string,  null: false
+        t.text    :non_null_text,    null: false
+        t.blob    :non_null_blob,    null: false
       end
 
       yield klass
     ensure
       klass.connection.drop_table(klass.table_name) rescue nil
     end
-
-    # MySQL uses an implicit default 0 rather than NULL unless in strict mode.
-    # We use an implicit NULL so schema.rb is compatible with other databases.
-    def test_mysql_integer_not_null_defaults
-      klass = Class.new(ActiveRecord::Base)
-      klass.table_name = 'test_integer_not_null_default_zero'
-      klass.connection.create_table klass.table_name do |t|
-        t.column :zero, :integer, :null => false, :default => 0
-        t.column :omit, :integer, :null => false
-      end
-
-      assert_equal '0', klass.columns_hash['zero'].default
-      assert !klass.columns_hash['zero'].null
-      # 0 in MySQL 4, nil in 5.
-      assert [0, nil].include?(klass.columns_hash['omit'].default)
-      assert !klass.columns_hash['omit'].null
-
-      assert_raise(ActiveRecord::StatementInvalid) { klass.create! }
-
-      assert_nothing_raised do
-        instance = klass.create!(:omit => 1)
-        assert_equal 0, instance.zero
-        assert_equal 1, instance.omit
-      end
-    ensure
-      klass.connection.drop_table(klass.table_name) rescue nil
-    end
   end
 end