ibm_db 5.6.1 → 5.7.0

data/test/cases/type/date_time_test.rb

@@ -7,10 +7,16 @@ module ActiveRecord
   module Type
     class DateTimeTest < ActiveRecord::TestCase
       def test_datetime_seconds_precision_applied_to_timestamp
-        skip "This test is invalid if subsecond precision isn't supported" unless supports_datetime_with_precision?
         p = Task.create!(starting: ::Time.now)
         assert_equal p.starting.usec, p.reload.starting.usec
       end
+
+      test "serialize_cast_value is equivalent to serialize after cast" do
+        type = Type::DateTime.new(precision: 1)
+        value = type.cast("1999-12-31 12:34:56.789 -1000")
+
+        assert_equal type.serialize(value), type.serialize_cast_value(value)
+      end
     end
   end
 end

data/test/cases/type/time_test.rb

@@ -23,6 +23,15 @@ module ActiveRecord
         assert_equal expected_time, topic.bonus_time
         assert_instance_of ::Time, topic.bonus_time
       end
+
+      test "serialize_cast_value is equivalent to serialize after cast" do
+        type = Type::Time.new(precision: 1)
+        value = type.cast("1999-12-31T12:34:56.789-10:00")
+
+        assert_equal type.serialize(value), type.serialize_cast_value(value)
+        assert_instance_of type.serialize(value).class, type.serialize_cast_value(value)
+        assert_instance_of type.serialize(nil).class, type.serialize_cast_value(nil)
+      end
     end
   end
 end

data/test/cases/type/type_map_test.rb

@@ -4,16 +4,60 @@ require "cases/helper"
 
 module ActiveRecord
   module Type
-    class TypeMapTest < ActiveRecord::TestCase
+    module TypeMapSharedTests
       def test_default_type
-        mapping = TypeMap.new
+        mapping = klass.new
 
         assert_kind_of Value, mapping.lookup(:undefined)
       end
 
+      def test_requires_value_or_block
+        mapping = klass.new
+
+        assert_raises(ArgumentError) do
+          mapping.register_type(/only key/i)
+        end
+      end
+
+      def test_fetch
+        mapping = klass.new
+        mapping.register_type(1, "string")
+
+        assert_equal "string", mapping.fetch(1) { "int" }
+        assert_equal "int", mapping.fetch(2) { "int" }
+      end
+
+      def test_fetch_memoizes
+        mapping = klass.new
+
+        looked_up = false
+        mapping.register_type(1) do
+          fail if looked_up
+          looked_up = true
+          "string"
+        end
+
+        assert_equal "string", mapping.fetch(1)
+        assert_equal "string", mapping.fetch(1)
+      end
+
+      def test_register_clears_cache
+        mapping = klass.new
+
+        mapping.register_type(1, "string")
+        mapping.lookup(1)
+        mapping.register_type(1, "int")
+
+        assert_equal "int", mapping.lookup(1)
+      end
+    end
+
+    class TypeMapTest < ActiveRecord::TestCase
+      include TypeMapSharedTests
+
       def test_registering_types
         boolean = Boolean.new
-        mapping = TypeMap.new
+        mapping = klass.new
 
         mapping.register_type(/boolean/i, boolean)
 
@@ -23,7 +67,7 @@ module ActiveRecord
       def test_overriding_registered_types
         time = Time.new
         timestamp = DateTime.new
-        mapping = TypeMap.new
+        mapping = klass.new
 
         mapping.register_type(/time/i, time)
         mapping.register_type(/time/i, timestamp)
@@ -31,18 +75,9 @@ module ActiveRecord
         assert_equal mapping.lookup("time"), timestamp
       end
 
-      def test_fuzzy_lookup
-        string = +""
-        mapping = TypeMap.new
-
-        mapping.register_type(/varchar/i, string)
-
-        assert_equal mapping.lookup("varchar(20)"), string
-      end
-
       def test_aliasing_types
         string = +""
-        mapping = TypeMap.new
+        mapping = klass.new
 
         mapping.register_type(/string/i, string)
         mapping.alias_type(/varchar/i, "string")
@@ -53,29 +88,38 @@ module ActiveRecord
       def test_changing_type_changes_aliases
         time = Time.new
         timestamp = DateTime.new
-        mapping = TypeMap.new
+        mapping = klass.new
 
         mapping.register_type(/timestamp/i, time)
         mapping.alias_type(/datetime/i, "timestamp")
         mapping.register_type(/timestamp/i, timestamp)
 
-        assert_equal mapping.lookup("datetime"), timestamp
+        assert_equal timestamp, mapping.lookup("datetime")
       end
 
       def test_aliases_keep_metadata
-        mapping = TypeMap.new
+        mapping = klass.new
 
         mapping.register_type(/decimal/i) { |sql_type| sql_type }
         mapping.alias_type(/number/i, "decimal")
 
-        assert_equal mapping.lookup("number(20)"), "decimal(20)"
-        assert_equal mapping.lookup("number"), "decimal"
+        assert_equal "decimal(20)", mapping.lookup("number(20)")
+        assert_equal "decimal", mapping.lookup("number")
+      end
+
+      def test_fuzzy_lookup
+        string = +""
+        mapping = klass.new
+
+        mapping.register_type(/varchar/i, string)
+
+        assert_equal mapping.lookup("varchar(20)"), string
       end
 
       def test_register_proc
         string = +""
         binary = Binary.new
-        mapping = TypeMap.new
+        mapping = klass.new
 
         mapping.register_type(/varchar/i) do |type|
           if type.include?("(")
@@ -89,29 +133,47 @@ module ActiveRecord
         assert_equal mapping.lookup("varchar"), binary
       end
 
+      def test_parent_fallback
+        boolean = Boolean.new
+
+        parent = klass.new
+        parent.register_type(/boolean/i, boolean)
+
+        mapping = klass.new(parent)
+        assert_equal boolean, mapping.lookup("boolean")
+      end
+
+      def test_parent_fallback_for_default_type
+        parent = klass.new
+        mapping = klass.new(parent)
+
+        assert_kind_of Value, mapping.lookup(:undefined)
+      end
+
+      private
+        def klass
+          TypeMap
+        end
+    end
+
+    class HashLookupTypeMapTest < ActiveRecord::TestCase
+      include TypeMapSharedTests
+
       def test_additional_lookup_args
-        mapping = TypeMap.new
+        mapping = HashLookupTypeMap.new
 
-        mapping.register_type(/varchar/i) do |type, limit|
+        mapping.register_type("varchar") do |type, limit|
           if limit > 255
             "text"
           else
             "string"
           end
         end
-        mapping.alias_type(/string/i, "varchar")
-
-        assert_equal mapping.lookup("varchar", 200), "string"
-        assert_equal mapping.lookup("varchar", 400), "text"
-        assert_equal mapping.lookup("string", 400), "text"
-      end
-
-      def test_requires_value_or_block
-        mapping = TypeMap.new
+        mapping.alias_type("string", "varchar")
 
-        assert_raises(ArgumentError) do
-          mapping.register_type(/only key/i)
-        end
+        assert_equal "string", mapping.lookup("varchar", 200)
+        assert_equal "text", mapping.lookup("varchar", 400)
+        assert_equal "text", mapping.lookup("string", 400)
       end
 
       def test_lookup_non_strings
@@ -121,58 +183,31 @@ module ActiveRecord
         mapping.register_type(2, "int")
         mapping.alias_type(3, 1)
 
-        assert_equal mapping.lookup(1), "string"
-        assert_equal mapping.lookup(2), "int"
-        assert_equal mapping.lookup(3), "string"
+        assert_equal "string", mapping.lookup(1)
+        assert_equal "int", mapping.lookup(2)
+        assert_equal "string", mapping.lookup(3)
         assert_kind_of Type::Value, mapping.lookup(4)
       end
 
-      def test_fetch
-        mapping = TypeMap.new
-        mapping.register_type(1, "string")
+      def test_fetch_memoizes_on_args
+        mapping = HashLookupTypeMap.new
+        mapping.register_type("foo") { |*args| args.join("-") }
 
-        assert_equal "string", mapping.fetch(1) { "int" }
-        assert_equal "int", mapping.fetch(2) { "int" }
+        assert_equal "foo-1-2-3", mapping.fetch("foo", 1, 2, 3) { |*args| args.join("-") }
+        assert_equal "foo-2-3-4", mapping.fetch("foo", 2, 3, 4) { |*args| args.join("-") }
       end
 
       def test_fetch_yields_args
-        mapping = TypeMap.new
+        mapping = klass.new
 
         assert_equal "foo-1-2-3", mapping.fetch("foo", 1, 2, 3) { |*args| args.join("-") }
         assert_equal "bar-1-2-3", mapping.fetch("bar", 1, 2, 3) { |*args| args.join("-") }
       end
 
-      def test_fetch_memoizes
-        mapping = TypeMap.new
-
-        looked_up = false
-        mapping.register_type(1) do
-          fail if looked_up
-          looked_up = true
-          "string"
+      private
+        def klass
+          HashLookupTypeMap
         end
-
-        assert_equal "string", mapping.fetch(1)
-        assert_equal "string", mapping.fetch(1)
-      end
-
-      def test_fetch_memoizes_on_args
-        mapping = TypeMap.new
-        mapping.register_type("foo") { |*args| args.join("-") }
-
-        assert_equal "foo-1-2-3", mapping.fetch("foo", 1, 2, 3) { |*args| args.join("-") }
-        assert_equal "foo-2-3-4", mapping.fetch("foo", 2, 3, 4) { |*args| args.join("-") }
-      end
-
-      def test_register_clears_cache
-        mapping = TypeMap.new
-
-        mapping.register_type(1, "string")
-        mapping.lookup(1)
-        mapping.register_type(1, "int")
-
-        assert_equal "int", mapping.lookup(1)
-      end
     end
   end
 end

data/test/cases/type/unsigned_integer_test.rb

@@ -14,6 +14,18 @@ module ActiveRecord
           UnsignedInteger.new.serialize(-1)
         end
       end
+
+      test "serialize_cast_value enforces range" do
+        type = UnsignedInteger.new
+
+        assert_raises(ActiveModel::RangeError) do
+          type.serialize_cast_value(-1)
+        end
+
+        assert_raises(ActiveModel::RangeError) do
+          type.serialize_cast_value(4294967296)
+        end
+      end
     end
   end
 end

data/test/cases/type_caster/connection_test.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/developer"
+
+module ActiveRecord
+  module TypeCaster
+    class ConnectionTest < ActiveSupport::TestCase
+      test "#type_for_attribute is not aware of custom types" do
+        type_caster = Connection.new(AttributedDeveloper, "developers")
+
+        type = type_caster.type_for_attribute(:name)
+
+        assert_not_equal DeveloperName, type.class
+        assert_equal ActiveRecord::Type::String, type.class
+      end
+    end
+  end
+end

data/test/cases/type_test.rb

@@ -30,7 +30,7 @@ class TypeTest < ActiveRecord::TestCase
   end
 
   test "lookup defaults to the current adapter" do
-    current_adapter = ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+    current_adapter = ActiveRecord::Type.adapter_name_from(ActiveRecord::Base)
     type = Struct.new(:args)
     adapter_type = Struct.new(:args)
     ActiveRecord::Type.register(:foo, type, override: false)

data/test/cases/unconnected_test.rb

@@ -9,8 +9,8 @@ class TestUnconnectedAdapter < ActiveRecord::TestCase
   self.use_transactional_tests = false
 
   def setup
-    @underlying = ActiveRecord::Base.connection
-    @specification = ActiveRecord::Base.remove_connection
+    @underlying = ActiveRecord::Base.lease_connection
+    @connection_name = ActiveRecord::Base.remove_connection
 
     # Clear out connection info from other pids (like a fork parent) too
     ActiveRecord::ConnectionAdapters::PoolConfig.discard_pools!
@@ -18,26 +18,26 @@ class TestUnconnectedAdapter < ActiveRecord::TestCase
 
   teardown do
     @underlying = nil
-    ActiveRecord::Base.establish_connection(@specification)
+    ActiveRecord::Base.establish_connection(@connection_name)
     load_schema if in_memory_db?
   end
 
   def test_connection_no_longer_established
-    assert_raise(ActiveRecord::ConnectionNotEstablished) do
+    assert_raise(ActiveRecord::ConnectionNotDefined) do
       TestRecord.find(1)
     end
 
-    assert_raise(ActiveRecord::ConnectionNotEstablished) do
+    assert_raise(ActiveRecord::ConnectionNotDefined) do
       TestRecord.new.save
     end
   end
 
   def test_error_message_when_connection_not_established
-    error = assert_raise(ActiveRecord::ConnectionNotEstablished) do
+    error = assert_raise(ActiveRecord::ConnectionNotDefined) do
       TestRecord.find(1)
     end
 
-    assert_equal "No connection pool for 'ActiveRecord::Base' found.", error.message
+    assert_equal "No database connection defined.", error.message
   end
 
   def test_underlying_adapter_no_longer_active

data/test/cases/unsafe_raw_sql_test.rb

@@ -74,8 +74,7 @@ class UnsafeRawSqlTest < ActiveRecord::TestCase
   test "order: allows quoted table and column names" do
     ids_expected = Post.order(Arel.sql("title")).pluck(:id)
 
-    quoted_title = Post.connection.quote_table_name("posts.title")
-    ids = Post.order(quoted_title).pluck(:id)
+    ids = Post.order(quote_table_name("posts.title")).pluck(:id)
 
     assert_equal ids_expected, ids
   end
@@ -166,12 +165,37 @@ class UnsafeRawSqlTest < ActiveRecord::TestCase
     assert_equal ids_expected, ids
   end
 
-  test "order: logs deprecation warning for unrecognized column" do
+  test "order: allows valid arguments with COLLATE" do
+    skip "IBM DB does not support column-level COLLATE in ORDER BY" if current_adapter?(:IBM_DBAdapter)
+
+    collation_name = {
+      "PostgreSQL" => "C",
+      "Mysql2" => "utf8mb4_bin",
+      "Trilogy" => "utf8mb4_bin",
+      "SQLite" => "binary"
+    }[ActiveRecord::Base.lease_connection.adapter_name]
+
+    ids_expected = Post.order(Arel.sql(%Q'author_id, title COLLATE "#{collation_name}" DESC')).pluck(:id)
+
+    ids = Post.order(["author_id", %Q'title COLLATE "#{collation_name}" DESC']).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows nested functions" do
+    ids_expected = Post.order(Arel.sql("author_id, length(trim(title))")).pluck(:id)
+
+    ids = Post.order("author_id, length(trim(title))").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: disallows dangerous query method" do
     e = assert_raises(ActiveRecord::UnknownAttributeReference) do
       Post.order("REPLACE(title, 'misc', 'zzzz')")
     end
 
-    assert_match(/Query method called with non-attribute argument\(s\):/, e.message)
+    assert_match(/Dangerous query method \(method whose arguments are used as raw SQL\) called with non-attribute argument\(s\):/, e.message)
   end
 
   test "pluck: allows string column name" do
@@ -233,12 +257,19 @@ class UnsafeRawSqlTest < ActiveRecord::TestCase
   test "pluck: allows quoted table and column names" do
     titles_expected = Post.pluck(Arel.sql("title"))
 
-    quoted_title = Post.connection.quote_table_name("posts.title")
-    titles = Post.pluck(quoted_title)
+    titles = Post.pluck(quote_table_name("posts.title"))
 
     assert_equal titles_expected, titles
   end
 
+  test "pluck: allows nested functions" do
+    title_lengths_expected = Post.pluck(Arel.sql("length(trim(title))"))
+
+    title_lengths = Post.pluck("length(trim(title))")
+
+    assert_equal title_lengths_expected, title_lengths
+  end
+
   test "pluck: disallows invalid column name" do
     assert_raises(ActiveRecord::UnknownAttributeReference) do
       Post.pluck("REPLACE(title, 'misc', 'zzzz')")
@@ -264,11 +295,11 @@ class UnsafeRawSqlTest < ActiveRecord::TestCase
     assert_equal excepted_values, values
   end
 
-  test "pluck: logs deprecation warning" do
+  test "pluck: disallows dangerous query method" do
     e = assert_raises(ActiveRecord::UnknownAttributeReference) do
       Post.includes(:comments).pluck(:title, "REPLACE(title, 'misc', 'zzzz')")
     end
 
-    assert_match(/Query method called with non-attribute argument\(s\):/, e.message)
+    assert_match(/Dangerous query method \(method whose arguments are used as raw SQL\) called with non-attribute argument\(s\):/, e.message)
   end
 end

data/test/cases/validations/absence_validation_test.rb

@@ -28,7 +28,7 @@ class AbsenceValidationTest < ActiveRecord::TestCase
     assert_equal 1, boy.errors[:face].size, "should only add one error"
 
     boy.face.mark_for_destruction
-    assert boy.valid?, "should be valid if association is marked for destruction"
+    assert_predicate boy, :valid?, "should be valid if association is marked for destruction"
   end
 
   def test_has_many_marked_for_destruction

data/test/cases/validations/association_validation_test.rb

@@ -49,7 +49,7 @@ class AssociationValidationTest < ActiveRecord::TestCase
 
   def test_validates_associated_without_marked_for_destruction
     reply = Class.new do
-      def valid?
+      def valid?(context = nil)
         true
       end
     end
@@ -84,7 +84,7 @@ class AssociationValidationTest < ActiveRecord::TestCase
       Interest.validates_presence_of(:human)
       human = Human.new(name: "John")
       interest = human.interests.build(topic: "Airplanes")
-      assert interest.valid?, "Expected interest to be valid, but was not. Interest should have a human object associated"
+      assert_predicate interest, :valid?, "Expected interest to be valid, but was not. Interest should have a human object associated"
     end
   end
 
@@ -93,7 +93,29 @@ class AssociationValidationTest < ActiveRecord::TestCase
       Interest.validates_presence_of(:human)
       human = Human.create!(name: "John")
       interest = human.interests.build(topic: "Airplanes")
-      assert interest.valid?, "Expected interest to be valid, but was not. Interest should have a human object associated"
+      assert_predicate interest, :valid?, "Expected interest to be valid, but was not. Interest should have a human object associated"
     end
   end
+
+  def test_validates_associated_with_custom_context
+    Reply.validates_associated :topic, on: :custom
+    Topic.validates_presence_of :content, on: :custom
+    r = Reply.create("title" => "A reply", "content" => "with content!")
+    r.topic = Topic.create("title" => "uhohuhoh")
+    assert_predicate r, :valid?
+    assert_not r.valid?(:custom)
+    assert_equal ["is invalid"], r.errors[:topic]
+  end
+
+  def test_validates_associated_with_create_context
+    Reply.validates_associated :topic, on: :create
+    Topic.validates_presence_of :content, on: :create
+    t = Topic.create(title: "uhoh", content: "stuff")
+    t.update!(content: nil)
+    # NOTE: Does not pass along :create context from reply to Topic validation.
+    r = t.replies.create(title: "A reply", content: "with content!")
+
+    assert_predicate t, :valid?
+    assert_predicate r, :valid?
+  end
 end

data/test/cases/validations/numericality_validation_test.rb

@@ -111,14 +111,9 @@ class NumericalityValidationTest < ActiveRecord::TestCase
 
     subject = model_class.new(virtual_decimal_number: 123.455)
 
-    if 123.455.to_d(5) == BigDecimal("123.46")
-      # BigDecimal's to_d behavior changed in BigDecimal 3.0.1, see https://github.com/ruby/bigdecimal/issues/70
-      # TODO: replace this with a check against BigDecimal::VERSION, currently
-      # we just check the behaviour because both versions of BigDecimal report "3.0.0"
-      assert_not_predicate subject, :valid?
-    else
-      assert_predicate subject, :valid?
-    end
+    # BigDecimal's to_d behavior changed in BigDecimal 3.1.0, see https://github.com/ruby/bigdecimal/issues/70
+    # Since BigDecimal 3.1.4 or higher is installed as an Active Support dependency, we just check the behavior of BigDecimal 3.1.0+.
+    assert_not_predicate subject, :valid?
   end
 
   def test_virtual_attribute_with_precision_round_up
@@ -152,7 +147,6 @@ class NumericalityValidationTest < ActiveRecord::TestCase
     ["99.994", 99.994, BigDecimal("99.994")].each do |raw_value|
       subject = model_class.new(virtual_decimal_number: raw_value)
       assert_equal BigDecimal("99.99"), subject.virtual_decimal_number
-      puts "subject = #{subject.attributes}"
       assert_predicate subject, :valid?
     end
 

data/test/cases/validations/presence_validation_test.rb

@@ -24,7 +24,7 @@ class PresenceValidationTest < ActiveRecord::TestCase
   def test_validates_presence_of_has_one
     Boy.validates_presence_of(:face)
     b = Boy.new
-    assert b.invalid?, "should not be valid if has_one association missing"
+    assert_predicate b, :invalid?, "should not be valid if has_one association missing"
     assert_equal 1, b.errors[:face].size, "validates_presence_of should only add one error"
   end