ibm_db 5.6.1-arm64-darwin-24

data/test/cases/date_test.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+
+class DateTest < ActiveRecord::TestCase
+  def test_date_with_time_value
+    time_value = Time.new(2016, 05, 11, 19, 0, 0)
+    topic = Topic.create(last_read: time_value)
+    assert_equal topic, Topic.find_by(last_read: time_value)
+  end
+
+  def test_date_with_string_value
+    string_value = "2016-05-11 19:00:00"
+    topic = Topic.create(last_read: string_value)
+    assert_equal topic, Topic.find_by(last_read: string_value)
+  end
+
+  def test_assign_valid_dates
+    valid_dates = [[2007, 11, 30], [1993, 2, 28], [2008, 2, 29]]
+
+    invalid_dates = [[2007, 11, 31], [1993, 2, 29], [2007, 2, 29]]
+
+    valid_dates.each do |date_src|
+      topic = Topic.new("last_read(1i)" => date_src[0].to_s, "last_read(2i)" => date_src[1].to_s, "last_read(3i)" => date_src[2].to_s)
+      assert_equal(topic.last_read, Date.new(*date_src))
+    end
+
+    invalid_dates.each do |date_src|
+      assert_nothing_raised do
+        topic = Topic.new("last_read(1i)" => date_src[0].to_s, "last_read(2i)" => date_src[1].to_s, "last_read(3i)" => date_src[2].to_s)
+        assert_equal(topic.last_read, Time.local(*date_src).to_date, "The date should be modified according to the behavior of the Time object")
+      end
+    end
+  end
+end

data/test/cases/date_time_precision_test.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+if supports_datetime_with_precision?
+  class DateTimePrecisionTest < ActiveRecord::TestCase
+    include SchemaDumpingHelper
+    self.use_transactional_tests = false
+
+    class Foo < ActiveRecord::Base; end
+
+    setup do
+      @connection = ActiveRecord::Base.connection
+      Foo.reset_column_information
+    end
+
+    teardown do
+      @connection.drop_table :foos, if_exists: true
+    end
+
+    def test_datetime_data_type_with_precision
+      @connection.create_table(:foos, force: true)
+      @connection.add_column :foos, :created_at, :datetime, precision: 0
+      @connection.add_column :foos, :updated_at, :datetime, precision: 5
+      assert_equal 0, Foo.columns_hash["created_at"].precision
+      assert_equal 5, Foo.columns_hash["updated_at"].precision
+    end
+
+    def test_datetime_precision_is_truncated_on_assignment
+      @connection.create_table(:foos, force: true)
+      @connection.add_column :foos, :created_at, :datetime, precision: 0
+      @connection.add_column :foos, :updated_at, :datetime, precision: 6
+
+      time = ::Time.now.change(nsec: 123456789)
+      foo = Foo.new(created_at: time, updated_at: time)
+
+      assert_equal 0, foo.created_at.nsec
+      assert_equal 123456000, foo.updated_at.nsec
+
+      foo.save!
+      foo.reload
+
+      assert_equal 0, foo.created_at.nsec
+      assert_equal 123456000, foo.updated_at.nsec
+    end
+
+    unless current_adapter?(:Mysql2Adapter, :IBM_DBAdapter)
+      def test_no_datetime_precision_isnt_truncated_on_assignment
+        @connection.create_table(:foos, force: true)
+        @connection.add_column :foos, :created_at, :datetime
+        @connection.add_column :foos, :updated_at, :datetime, precision: 6
+
+        time = ::Time.now.change(nsec: 123)
+        foo = Foo.new(created_at: time, updated_at: time)
+
+        assert_equal 123, foo.created_at.nsec
+        assert_equal 0, foo.updated_at.nsec
+
+        foo.save!
+        foo.reload
+
+        assert_equal 0, foo.created_at.nsec
+        assert_equal 0, foo.updated_at.nsec
+      end
+    end
+
+    def test_timestamps_helper_with_custom_precision
+      @connection.create_table(:foos, force: true) do |t|
+        t.timestamps precision: 4
+      end
+      assert_equal 4, Foo.columns_hash["created_at"].precision
+      assert_equal 4, Foo.columns_hash["updated_at"].precision
+    end
+
+    def test_passing_precision_to_datetime_does_not_set_limit
+      @connection.create_table(:foos, force: true) do |t|
+        t.timestamps precision: 4
+      end
+      assert_nil Foo.columns_hash["created_at"].limit
+      assert_nil Foo.columns_hash["updated_at"].limit
+    end
+
+    def test_invalid_datetime_precision_raises_error
+      assert_raises ArgumentError do
+        @connection.create_table(:foos, force: true) do |t|
+          t.timestamps precision: 13
+        end
+      end
+    end
+
+    def test_formatting_datetime_according_to_precision
+      @connection.create_table(:foos, force: true) do |t|
+        t.datetime :created_at, precision: 0
+        t.datetime :updated_at, precision: 4
+      end
+
+      date = ::Time.utc(2014, 8, 17, 12, 30, 0, 999999)
+      Foo.create!(created_at: date, updated_at: date)
+
+      assert foo = Foo.find_by(created_at: date)
+      assert_equal 1, Foo.where(updated_at: date).count
+      assert_equal date.to_s, foo.created_at.to_s
+      assert_equal date.to_s, foo.updated_at.to_s
+      assert_equal 000000, foo.created_at.usec
+      assert_equal 999900, foo.updated_at.usec
+    end
+
+    def test_schema_dump_includes_datetime_precision
+      @connection.create_table(:foos, force: true) do |t|
+        t.timestamps precision: 6
+      end
+      output = dump_table_schema("foos")
+      assert_match %r{t\.datetime\s+"created_at",\s+precision: 6,\s+null: false$}, output
+      assert_match %r{t\.datetime\s+"updated_at",\s+precision: 6,\s+null: false$}, output
+    end
+
+    if current_adapter?(:PostgreSQLAdapter, :SQLServerAdapter)
+      def test_datetime_precision_with_zero_should_be_dumped
+        @connection.create_table(:foos, force: true) do |t|
+          t.timestamps precision: 0
+        end
+        output = dump_table_schema("foos")
+        assert_match %r{t\.datetime\s+"created_at",\s+precision: 0,\s+null: false$}, output
+        assert_match %r{t\.datetime\s+"updated_at",\s+precision: 0,\s+null: false$}, output
+      end
+    end
+  end
+end

data/test/cases/date_time_test.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+require "models/task"
+
+class DateTimeTest < ActiveRecord::TestCase
+  include InTimeZone
+
+  def test_saves_both_date_and_time
+    with_env_tz "America/New_York" do
+      with_timezone_config default: :utc do
+        time_values = [1807, 2, 10, 15, 30, 45]
+        # create DateTime value with local time zone offset
+        local_offset = Rational(Time.local(*time_values).utc_offset, 86400)
+        now = DateTime.civil(*(time_values + [local_offset]))
+
+        task = Task.new
+        task.starting = now
+        task.save!
+
+        # check against Time.local, since some platforms will return a Time instead of a DateTime
+        assert_equal Time.local(*time_values), Task.find(task.id).starting
+      end
+    end
+  end
+
+  def test_assign_empty_date_time
+    task = Task.new
+    task.starting = ""
+    task.ending = nil
+    assert_nil task.starting
+    assert_nil task.ending
+  end
+
+  def test_assign_bad_date_time_with_timezone
+    in_time_zone "Pacific Time (US & Canada)" do
+      task = Task.new
+      task.starting = "2014-07-01T24:59:59GMT"
+      assert_nil task.starting
+    end
+  end
+
+  def test_assign_empty_date
+    topic = Topic.new
+    topic.last_read = ""
+    assert_nil topic.last_read
+  end
+
+  def test_assign_empty_time
+    topic = Topic.new
+    topic.bonus_time = ""
+    assert_nil topic.bonus_time
+  end
+
+  def test_assign_in_local_timezone
+    now = DateTime.civil(2017, 3, 1, 12, 0, 0)
+    with_timezone_config default: :local do
+      task = Task.new starting: now
+      assert_equal now, task.starting
+    end
+  end
+
+  def test_date_time_with_string_value_with_subsecond_precision
+    skip unless supports_datetime_with_precision?
+    string_value = "2017-07-04 14:19:00.5"
+    topic = Topic.create(written_on: string_value)
+    assert_equal topic, Topic.find_by(written_on: string_value)
+  end
+
+  def test_date_time_with_string_value_with_non_iso_format
+    string_value = "04/07/2017 2:19pm"
+    topic = Topic.create(written_on: string_value)
+    assert_equal topic, Topic.find_by(written_on: string_value)
+  end
+end

data/test/cases/defaults_test.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+require "models/default"
+require "models/entrant"
+
+class DefaultTest < ActiveRecord::TestCase
+  def test_nil_defaults_for_not_null_columns
+    %w(id name course_id).each do |name|
+      column = Entrant.columns_hash[name]
+      assert_not column.null, "#{name} column should be NOT NULL"
+      assert_not column.default, "#{name} column should be DEFAULT 'nil'"
+    end
+  end
+
+  if current_adapter?(:PostgreSQLAdapter)
+    def test_multiline_default_text
+      record = Default.new
+      # older postgres versions represent the default with escapes ("\\012" for a newline)
+      assert("--- []\n\n" == record.multiline_default || "--- []\\012\\012" == record.multiline_default)
+    end
+  end
+end
+
+class DefaultNumbersTest < ActiveRecord::TestCase
+  class DefaultNumber < ActiveRecord::Base; end
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table :default_numbers do |t|
+      t.integer :positive_integer, default: 7
+      t.integer :negative_integer, default: -5
+      t.decimal :decimal_number, default: "2.78", precision: 5, scale: 2
+    end
+  end
+
+  teardown do
+    @connection.drop_table :default_numbers, if_exists: true
+  end
+
+  def test_default_positive_integer
+    record = DefaultNumber.new
+    assert_equal 7, record.positive_integer
+    assert_equal "7", record.positive_integer_before_type_cast
+  end
+
+  def test_default_negative_integer
+    record = DefaultNumber.new
+    assert_equal (-5), record.negative_integer
+    assert_equal "-5", record.negative_integer_before_type_cast
+  end
+
+  def test_default_decimal_number
+    record = DefaultNumber.new
+    assert_equal BigDecimal("2.78"), record.decimal_number
+    assert_equal "2.78", record.decimal_number_before_type_cast
+  end
+end
+
+class DefaultStringsTest < ActiveRecord::TestCase
+  class DefaultString < ActiveRecord::Base; end
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table :default_strings do |t|
+      t.string :string_col, default: "Smith"
+      t.string :string_col_with_quotes, default: "O'Connor"
+    end
+    DefaultString.reset_column_information
+  end
+
+  def test_default_strings
+    assert_equal "Smith", DefaultString.new.string_col
+  end
+
+  def test_default_strings_containing_single_quotes
+    assert_equal "O'Connor", DefaultString.new.string_col_with_quotes
+  end
+
+  teardown do
+    @connection.drop_table :default_strings
+  end
+end
+
+if supports_text_column_with_default?
+  class DefaultTextTest < ActiveRecord::TestCase
+    class DefaultText < ActiveRecord::Base; end
+
+    setup do
+      @connection = ActiveRecord::Base.connection
+      @connection.create_table :default_texts do |t|
+        t.text :text_col, default: "Smith"
+        t.text :text_col_with_quotes, default: "O'Connor"
+      end
+      DefaultText.reset_column_information
+    end
+
+    def test_default_texts
+      assert_equal "Smith", DefaultText.new.text_col
+    end
+
+    def test_default_texts_containing_single_quotes
+      assert_equal "O'Connor", DefaultText.new.text_col_with_quotes
+    end
+
+    teardown do
+      @connection.drop_table :default_texts
+    end
+  end
+end
+
+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.database_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 supports_default_expression?
+      test "schema dump includes default expression" do
+        output = dump_table_schema("defaults")
+        assert_match %r/t\.binary\s+"uuid",\s+limit: 36,\s+default: -> { "\(uuid\(\)\)" }/i, output
+      end
+    end
+
+    if supports_datetime_with_precision?
+      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(?:\(\))?" }/i, output
+      end
+
+      test "schema dump datetime includes precise default expression" do
+        output = dump_table_schema("datetime_defaults")
+        assert_match %r/t\.datetime\s+"precise_datetime",.+default: -> { "CURRENT_TIMESTAMP\(6\)" }/i, output
+      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(?:\(\))?" }/i, output
+      end
+
+      test "schema dump timestamp includes precise default expression" do
+        output = dump_table_schema("timestamp_defaults")
+        assert_match %r/t\.timestamp\s+"precise_timestamp",.+default: -> { "CURRENT_TIMESTAMP\(6\)" }/i, 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
+  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
+    # cause Active Record to create a new savepoint. However, since MySQL doesn't
+    # support DDL transactions, creating a table will result in any created
+    # savepoints to be automatically released. This in turn causes the savepoint
+    # release code in AbstractAdapter#transaction to fail.
+    #
+    # We don't want that to happen, so we disable transactional tests here.
+    self.use_transactional_tests = false
+
+    def using_strict(strict)
+      connection = ActiveRecord::Base.remove_connection
+      conn_hash = connection.configuration_hash
+      ActiveRecord::Base.establish_connection conn_hash.merge(strict: strict)
+      yield
+    ensure
+      ActiveRecord::Base.remove_connection
+      ActiveRecord::Base.establish_connection connection
+    end
+
+    # 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.)
+    #
+    # 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.
+    #
+    # https://dev.mysql.com/doc/refman/en/sql-mode.html#sql-mode-strict
+    def test_mysql_not_null_defaults_non_strict
+      using_strict(false) do
+        with_mysql_not_null_table do |klass|
+          record = klass.new
+          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 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_not_null_defaults_strict
+      using_strict(true) do
+        with_mysql_not_null_table do |klass|
+          record = klass.new
+          assert_nil record.non_null_integer
+          assert_nil record.non_null_string
+          assert_nil record.non_null_text
+          assert_nil record.non_null_blob
+
+          assert_raises(ActiveRecord::NotNullViolation) { klass.create }
+        end
+      end
+    end
+
+    def with_mysql_not_null_table
+      klass = Class.new(ActiveRecord::Base)
+      klass.table_name = "test_mysql_not_null_defaults"
+      klass.connection.create_table klass.table_name do |t|
+        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
+  end
+end

data/test/cases/delegated_type_test.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/entry"
+require "models/message"
+require "models/comment"
+
+class DelegatedTypeTest < ActiveRecord::TestCase
+  fixtures :comments
+
+  setup do
+    @entry_with_message = Entry.create! entryable: Message.new(subject: "Hello world!")
+    @entry_with_comment = Entry.create! entryable: comments(:greetings)
+  end
+
+  test "delegated class" do
+    assert_equal Message, @entry_with_message.entryable_class
+    assert_equal Comment, @entry_with_comment.entryable_class
+  end
+
+  test "delegated type name" do
+    assert_equal "message", @entry_with_message.entryable_name
+    assert @entry_with_message.entryable_name.message?
+
+    assert_equal "comment", @entry_with_comment.entryable_name
+    assert @entry_with_comment.entryable_name.comment?
+  end
+
+  test "delegated type predicates" do
+    assert @entry_with_message.message?
+    assert_not @entry_with_message.comment?
+
+    assert @entry_with_comment.comment?
+    assert_not @entry_with_comment.message?
+  end
+
+  test "scope" do
+    assert Entry.messages.first.message?
+    assert Entry.comments.first.comment?
+  end
+
+  test "accessor" do
+    assert @entry_with_message.message.is_a?(Message)
+    assert_nil @entry_with_message.comment
+
+    assert @entry_with_comment.comment.is_a?(Comment)
+    assert_nil @entry_with_comment.message
+  end
+
+  test "association id" do
+    assert_equal @entry_with_message.entryable_id, @entry_with_message.message_id
+    assert_nil @entry_with_message.comment_id
+
+    assert_equal @entry_with_comment.entryable_id, @entry_with_comment.comment_id
+    assert_nil @entry_with_comment.message_id
+  end
+end