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

data/test/cases/date_time_precision_test.rb

@@ -1,107 +1,129 @@
-require 'cases/helper'
-require 'support/schema_dumping_helper'
+# frozen_string_literal: true
 
-if subsecond_precision_supported?
-class DateTimePrecisionTest < ActiveRecord::TestCase
-  include SchemaDumpingHelper
-  self.use_transactional_tests = false
+require "cases/helper"
+require "support/schema_dumping_helper"
 
-  class Foo < ActiveRecord::Base; end
+if supports_datetime_with_precision?
+  class DateTimePrecisionTest < ActiveRecord::TestCase
+    include SchemaDumpingHelper
+    self.use_transactional_tests = false
 
-  setup do
-    @connection = ActiveRecord::Base.connection
-    Foo.reset_column_information
-  end
+    class Foo < ActiveRecord::Base; end
 
-  teardown do
-    @connection.drop_table :foos
-	#, if_exists: true
-  end
+    setup do
+      @connection = ActiveRecord::Base.connection
+      Foo.reset_column_information
+    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
+    teardown do
+      @connection.drop_table :foos, if_exists: true
+    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
+    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
 
-    time = ::Time.now.change(nsec: 123456789)
-    foo = Foo.new(created_at: time, updated_at: time)
+    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
 
-    assert_equal 0, foo.created_at.nsec
-    assert_equal 123456000, foo.updated_at.nsec
+      time = ::Time.now.change(nsec: 123456789)
+      foo = Foo.new(created_at: time, updated_at: time)
 
-    foo.save!
-    foo.reload
+      assert_equal 0, foo.created_at.nsec
+      assert_equal 123456000, foo.updated_at.nsec
 
-    assert_equal 0, foo.created_at.nsec
-    assert_equal 123456000, foo.updated_at.nsec
-  end
+      foo.save!
+      foo.reload
 
-  def test_timestamps_helper_with_custom_precision
-    @connection.create_table(:foos, force: true) do |t|
-      t.timestamps precision: 4
+      assert_equal 0, foo.created_at.nsec
+      assert_equal 123456000, foo.updated_at.nsec
     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
+    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
-    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 ActiveRecord::ActiveRecordError do
+    def test_timestamps_helper_with_custom_precision
       @connection.create_table(:foos, force: true) do |t|
-        t.timestamps precision: 7
+        t.timestamps precision: 4
       end
+      assert_equal 4, Foo.columns_hash["created_at"].precision
+      assert_equal 4, Foo.columns_hash["updated_at"].precision
     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
+    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
-    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
+    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
-    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
+    def test_formatting_datetime_according_to_precision
       @connection.create_table(:foos, force: true) do |t|
-        t.timestamps precision: 0
+        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: 0,\s+null: false$}, output
-      assert_match %r{t\.datetime\s+"updated_at",\s+precision: 0,\s+null: false$}, output
+      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
-  end
 
-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

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/topic'
-require 'models/task'
+require "models/topic"
+require "models/task"
 
 class DateTimeTest < ActiveRecord::TestCase
   include InTimeZone
 
   def test_saves_both_date_and_time
-    with_env_tz 'America/New_York' do
+    with_env_tz "America/New_York" do
       with_timezone_config default: :utc do
         time_values = [1807, 2, 10, 15, 30, 45]
         # create DateTime value with local time zone offset
@@ -25,7 +27,7 @@ class DateTimeTest < ActiveRecord::TestCase
 
   def test_assign_empty_date_time
     task = Task.new
-    task.starting = ''
+    task.starting = ""
     task.ending = nil
     assert_nil task.starting
     assert_nil task.ending
@@ -34,28 +36,41 @@ class DateTimeTest < ActiveRecord::TestCase
   def test_assign_bad_date_time_with_timezone
     in_time_zone "Pacific Time (US & Canada)" do
       task = Task.new
-      task.starting = '2014-07-01T24:59:59GMT'
+      task.starting = "2014-07-01T24:59:59GMT"
       assert_nil task.starting
     end
   end
 
   def test_assign_empty_date
     topic = Topic.new
-    topic.last_read = ''
+    topic.last_read = ""
     assert_nil topic.last_read
   end
 
   def test_assign_empty_time
     topic = Topic.new
-    topic.bonus_time = ''
+    topic.bonus_time = ""
     assert_nil topic.bonus_time
   end
 
   def test_assign_in_local_timezone
-    now = DateTime.now
+    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

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'support/schema_dumping_helper'
-require 'models/default'
-require 'models/entrant'
+require "support/schema_dumping_helper"
+require "models/default"
+require "models/entrant"
 
 class DefaultTest < ActiveRecord::TestCase
   def test_nil_defaults_for_not_null_columns
     %w(id name course_id).each do |name|
       column = Entrant.columns_hash[name]
-      assert !column.null, "#{name} column should be NOT NULL"
+      assert_not column.null, "#{name} column should be NOT NULL"
       assert_not column.default, "#{name} column should be DEFAULT 'nil'"
     end
   end
@@ -34,8 +36,7 @@ class DefaultNumbersTest < ActiveRecord::TestCase
   end
 
   teardown do
-    @connection.drop_table :default_numbers
-	#, if_exists: true
+    @connection.drop_table :default_numbers, if_exists: true
   end
 
   def test_default_positive_integer
@@ -52,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
@@ -82,15 +83,47 @@ class DefaultStringsTest < ActiveRecord::TestCase
   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")
-      assert_match %r/t\.date\s+"modified_date",\s+default: -> { "\('now'::text\)::date" }/, output
+      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",\s+default: -> { "now\(\)" }/, output
       assert_match %r/t\.datetime\s+"modified_time_function",\s+default: -> { "now\(\)" }/, output
     end
   end
@@ -100,10 +133,37 @@ if current_adapter?(:Mysql2Adapter)
   class MysqlDefaultExpressionTest < ActiveRecord::TestCase
     include SchemaDumpingHelper
 
-    if ActiveRecord::Base.connection.version >= '5.6.0'
+    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" }/, output
+        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
@@ -121,99 +181,74 @@ if current_adapter?(:Mysql2Adapter)
 
     def using_strict(strict)
       connection = ActiveRecord::Base.remove_connection
-      ActiveRecord::Base.establish_connection connection.merge(strict: strict)
+      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
 
-    # 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/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
-      assert_equal nil, 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

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