ibm_db 3.0.4 → 5.0.4

data/test/cases/attribute_set_test.rb

@@ -29,7 +29,7 @@ module ActiveRecord
       assert_equal :bar, attributes[:bar].name
     end
 
-    test "duping creates a new hash and dups each attribute" do
+    test "duping creates a new hash, but does not dup the attributes" do
       builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::String.new)
       attributes = builder.build_from_database(foo: 1, bar: 'foo')
 
@@ -41,6 +41,24 @@ module ActiveRecord
       duped.write_from_database(:foo, 2)
       duped[:bar].value << 'bar'
 
+      assert_equal 1, attributes[:foo].value
+      assert_equal 2, duped[:foo].value
+      assert_equal 'foobar', attributes[:bar].value
+      assert_equal 'foobar', duped[:bar].value
+    end
+
+    test "deep_duping creates a new hash and dups each attribute" do
+      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::String.new)
+      attributes = builder.build_from_database(foo: 1, bar: 'foo')
+
+      # Ensure the type cast value is cached
+      attributes[:foo].value
+      attributes[:bar].value
+
+      duped = attributes.deep_dup
+      duped.write_from_database(:foo, 2)
+      duped[:bar].value << 'bar'
+
       assert_equal 1, attributes[:foo].value
       assert_equal 2, duped[:foo].value
       assert_equal 'foo', attributes[:bar].value
@@ -142,7 +160,8 @@ module ActiveRecord
     end
 
     test "the primary_key is always initialized" do
-      builder = AttributeSet::Builder.new({ foo: Type::Integer.new }, :foo)
+      defaults = { foo: Attribute.from_user(:foo, nil, nil) }
+      builder = AttributeSet::Builder.new({ foo: Type::Integer.new }, defaults)
       attributes = builder.build_from_database
 
       assert attributes.key?(:foo)
@@ -151,15 +170,18 @@ module ActiveRecord
     end
 
     class MyType
-      def type_cast_from_user(value)
+      def cast(value)
         return if value.nil?
         value + " from user"
       end
 
-      def type_cast_from_database(value)
+      def deserialize(value)
         return if value.nil?
         value + " from database"
       end
+
+      def assert_valid_value(*)
+      end
     end
 
     test "write_from_database sets the attribute with database typecasting" do
@@ -196,5 +218,53 @@ module ActiveRecord
       attributes.freeze
       assert_equal({ foo: "1" }, attributes.to_hash)
     end
+
+    test "marshaling dump/load legacy materialized attribute hash" do
+      builder = AttributeSet::Builder.new(foo: Type::String.new)
+      attributes = builder.build_from_database(foo: "1")
+
+      attributes.instance_variable_get(:@attributes).instance_eval do
+        class << self
+          def marshal_dump
+            materialize
+          end
+        end
+      end
+
+      attributes = Marshal.load(Marshal.dump(attributes))
+      assert_equal({ foo: "1" }, attributes.to_hash)
+    end
+
+    test "#accessed_attributes returns only attributes which have been read" do
+      builder = AttributeSet::Builder.new(foo: Type::Value.new, bar: Type::Value.new)
+      attributes = builder.build_from_database(foo: "1", bar: "2")
+
+      assert_equal [], attributes.accessed
+
+      attributes.fetch_value(:foo)
+
+      assert_equal [:foo], attributes.accessed
+    end
+
+    test "#map returns a new attribute set with the changes applied" do
+      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Integer.new)
+      attributes = builder.build_from_database(foo: "1", bar: "2")
+      new_attributes = attributes.map do |attr|
+        attr.with_cast_value(attr.value + 1)
+      end
+
+      assert_equal 2, new_attributes.fetch_value(:foo)
+      assert_equal 3, new_attributes.fetch_value(:bar)
+    end
+
+    test "comparison for equality is correctly implemented" do
+      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Integer.new)
+      attributes = builder.build_from_database(foo: "1", bar: "2")
+      attributes2 = builder.build_from_database(foo: "1", bar: "2")
+      attributes3 = builder.build_from_database(foo: "2", bar: "2")
+
+      assert_equal attributes, attributes2
+      assert_not_equal attributes2, attributes3
+    end
   end
 end

data/test/cases/attribute_test.rb

@@ -1,5 +1,4 @@
 require 'cases/helper'
-require 'minitest/mock'
 
 module ActiveRecord
   class AttributeTest < ActiveRecord::TestCase
@@ -12,7 +11,7 @@ module ActiveRecord
     end
 
     test "from_database + read type casts from database" do
-      @type.expect(:type_cast_from_database, 'type cast from database', ['a value'])
+      @type.expect(:deserialize, 'type cast from database', ['a value'])
       attribute = Attribute.from_database(nil, 'a value', @type)
 
       type_cast_value = attribute.value
@@ -21,7 +20,7 @@ module ActiveRecord
     end
 
     test "from_user + read type casts from user" do
-      @type.expect(:type_cast_from_user, 'type cast from user', ['a value'])
+      @type.expect(:cast, 'type cast from user', ['a value'])
       attribute = Attribute.from_user(nil, 'a value', @type)
 
       type_cast_value = attribute.value
@@ -30,7 +29,7 @@ module ActiveRecord
     end
 
     test "reading memoizes the value" do
-      @type.expect(:type_cast_from_database, 'from the database', ['whatever'])
+      @type.expect(:deserialize, 'from the database', ['whatever'])
       attribute = Attribute.from_database(nil, 'whatever', @type)
 
       type_cast_value = attribute.value
@@ -41,7 +40,7 @@ module ActiveRecord
     end
 
     test "reading memoizes falsy values" do
-      @type.expect(:type_cast_from_database, false, ['whatever'])
+      @type.expect(:deserialize, false, ['whatever'])
       attribute = Attribute.from_database(nil, 'whatever', @type)
 
       attribute.value
@@ -57,27 +56,27 @@ module ActiveRecord
     end
 
     test "from_database + read_for_database type casts to and from database" do
-      @type.expect(:type_cast_from_database, 'read from database', ['whatever'])
-      @type.expect(:type_cast_for_database, 'ready for database', ['read from database'])
+      @type.expect(:deserialize, 'read from database', ['whatever'])
+      @type.expect(:serialize, 'ready for database', ['read from database'])
       attribute = Attribute.from_database(nil, 'whatever', @type)
 
-      type_cast_for_database = attribute.value_for_database
+      serialize = attribute.value_for_database
 
-      assert_equal 'ready for database', type_cast_for_database
+      assert_equal 'ready for database', serialize
     end
 
     test "from_user + read_for_database type casts from the user to the database" do
-      @type.expect(:type_cast_from_user, 'read from user', ['whatever'])
-      @type.expect(:type_cast_for_database, 'ready for database', ['read from user'])
+      @type.expect(:cast, 'read from user', ['whatever'])
+      @type.expect(:serialize, 'ready for database', ['read from user'])
       attribute = Attribute.from_user(nil, 'whatever', @type)
 
-      type_cast_for_database = attribute.value_for_database
+      serialize = attribute.value_for_database
 
-      assert_equal 'ready for database', type_cast_for_database
+      assert_equal 'ready for database', serialize
     end
 
     test "duping dups the value" do
-      @type.expect(:type_cast_from_database, 'type cast', ['a value'])
+      @type.expect(:deserialize, 'type cast', ['a value'])
       attribute = Attribute.from_database(nil, 'a value', @type)
 
       value_from_orig = attribute.value
@@ -89,7 +88,7 @@ module ActiveRecord
     end
 
     test "duping does not dup the value if it is not dupable" do
-      @type.expect(:type_cast_from_database, false, ['a value'])
+      @type.expect(:deserialize, false, ['a value'])
       attribute = Attribute.from_database(nil, 'a value', @type)
 
       assert_same attribute.value, attribute.dup.value
@@ -101,13 +100,16 @@ module ActiveRecord
     end
 
     class MyType
-      def type_cast_from_user(value)
+      def cast(value)
         value + " from user"
       end
 
-      def type_cast_from_database(value)
+      def deserialize(value)
         value + " from database"
       end
+
+      def assert_valid_value(*)
+      end
     end
 
     test "with_value_from_user returns a new attribute with the value from the user" do
@@ -169,12 +171,76 @@ module ActiveRecord
       assert_not_equal first, second
     end
 
+    test "an attribute has not been read by default" do
+      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
+      assert_not attribute.has_been_read?
+    end
+
+    test "an attribute has been read when its value is calculated" do
+      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
+      attribute.value
+      assert attribute.has_been_read?
+    end
+
+    test "an attribute is not changed if it hasn't been assigned or mutated" do
+      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
+
+      refute attribute.changed?
+    end
+
+    test "an attribute is changed if it's been assigned a new value" do
+      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
+      changed = attribute.with_value_from_user(2)
+
+      assert changed.changed?
+    end
+
+    test "an attribute is not changed if it's assigned the same value" do
+      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
+      unchanged = attribute.with_value_from_user(1)
+
+      refute unchanged.changed?
+    end
+
     test "an attribute can not be mutated if it has not been read,
       and skips expensive calculations" do
       type_which_raises_from_all_methods = Object.new
       attribute = Attribute.from_database(:foo, "bar", type_which_raises_from_all_methods)
 
-      assert_not attribute.changed_in_place_from?("bar")
+      assert_not attribute.changed_in_place?
+    end
+
+    test "an attribute is changed if it has been mutated" do
+      attribute = Attribute.from_database(:foo, "bar", Type::String.new)
+      attribute.value << "!"
+
+      assert attribute.changed_in_place?
+      assert attribute.changed?
+    end
+
+    test "an attribute can forget its changes" do
+      attribute = Attribute.from_database(:foo, "bar", Type::String.new)
+      changed = attribute.with_value_from_user("foo")
+      forgotten = changed.forgetting_assignment
+
+      assert changed.changed? # sanity check
+      refute forgotten.changed?
+    end
+
+    test "with_value_from_user validates the value" do
+      type = Type::Value.new
+      type.define_singleton_method(:assert_valid_value) do |value|
+        if value == 1
+          raise ArgumentError
+        end
+      end
+
+      attribute = Attribute.from_database(:foo, 1, type)
+      assert_equal 1, attribute.value
+      assert_equal 2, attribute.with_value_from_user(2).value
+      assert_raises ArgumentError do
+        attribute.with_value_from_user(1)
+      end
     end
   end
 end

data/test/cases/attributes_test.rb

@@ -1,17 +1,17 @@
 require 'cases/helper'
 
 class OverloadedType < ActiveRecord::Base
-  attribute :overloaded_float, Type::Integer.new
-  attribute :overloaded_string_with_limit, Type::String.new(limit: 50)
-  attribute :non_existent_decimal, Type::Decimal.new
-  attribute :string_with_default, Type::String.new, default: 'the overloaded default'
+  attribute :overloaded_float, :integer
+  attribute :overloaded_string_with_limit, :string, limit: 50
+  attribute :non_existent_decimal, :decimal
+  attribute :string_with_default, :string, default: 'the overloaded default'
 end
 
 class ChildOfOverloadedType < OverloadedType
 end
 
 class GrandchildOfOverloadedType < ChildOfOverloadedType
-  attribute :overloaded_float, Type::Float.new
+  attribute :overloaded_float, :float
 end
 
 class UnoverloadedType < ActiveRecord::Base
@@ -38,7 +38,7 @@ module ActiveRecord
       data.reload
 
       assert_equal 2, data.overloaded_float
-      assert_kind_of Fixnum, OverloadedType.last.overloaded_float
+      assert_kind_of Integer, OverloadedType.last.overloaded_float
       assert_equal 2.0, UnoverloadedType.last.overloaded_float
       assert_kind_of Float, UnoverloadedType.last.overloaded_float
     end
@@ -50,8 +50,8 @@ module ActiveRecord
     end
 
     test "overloaded properties with limit" do
-      assert_equal 50, OverloadedType.columns_hash['overloaded_string_with_limit'].limit
-      assert_equal 255, UnoverloadedType.columns_hash['overloaded_string_with_limit'].limit
+      assert_equal 50, OverloadedType.type_for_attribute('overloaded_string_with_limit').limit
+      assert_equal 255, UnoverloadedType.type_for_attribute('overloaded_string_with_limit').limit
     end
 
     test "nonexistent attribute" do
@@ -63,6 +63,15 @@ module ActiveRecord
       end
     end
 
+    test "model with nonexistent attribute with default value can be saved" do
+      klass = Class.new(OverloadedType) do
+        attribute :non_existent_string_with_default, :string, default: 'nonexistent'
+      end
+
+      model = klass.new
+      assert model.save
+    end
+
     test "changing defaults" do
       data = OverloadedType.new
       unoverloaded_data = UnoverloadedType.new
@@ -87,50 +96,158 @@ module ActiveRecord
       assert_equal 4.4, data.overloaded_float
     end
 
-    test "overloading properties does not change column order" do
-      column_names = OverloadedType.column_names
-      assert_equal %w(id overloaded_float unoverloaded_float overloaded_string_with_limit string_with_default non_existent_decimal), column_names
+    test "overloading properties does not attribute method order" do
+      attribute_names = OverloadedType.attribute_names
+      assert_equal %w(id overloaded_float unoverloaded_float overloaded_string_with_limit string_with_default non_existent_decimal), attribute_names
     end
 
     test "caches are cleared" do
       klass = Class.new(OverloadedType)
 
-      assert_equal 6, klass.columns.length
-      assert_not klass.columns_hash.key?('wibble')
-      assert_equal 6, klass.column_types.length
+      assert_equal 6, klass.attribute_types.length
       assert_equal 6, klass.column_defaults.length
-      assert_not klass.column_names.include?('wibble')
-      assert_equal 5, klass.content_columns.length
+      assert_not klass.attribute_types.include?('wibble')
 
       klass.attribute :wibble, Type::Value.new
 
-      assert_equal 7, klass.columns.length
-      assert klass.columns_hash.key?('wibble')
-      assert_equal 7, klass.column_types.length
+      assert_equal 7, klass.attribute_types.length
       assert_equal 7, klass.column_defaults.length
-      assert klass.column_names.include?('wibble')
-      assert_equal 6, klass.content_columns.length
+      assert klass.attribute_types.include?('wibble')
     end
 
-    test "non string/integers use custom types for queries" do
-      klass = Class.new(OverloadedType)
-      type = Type::Value.new
-      def type.cast_value(value)
-        !!value
+    test "the given default value is cast from user" do
+      custom_type = Class.new(Type::Value) do
+        def cast(*)
+          "from user"
+        end
+
+        def deserialize(*)
+          "from database"
+        end
+      end
+
+      klass = Class.new(OverloadedType) do
+        attribute :wibble, custom_type.new, default: "default"
+      end
+      model = klass.new
+
+      assert_equal "from user", model.wibble
+    end
+
+    test "procs for default values" do
+      klass = Class.new(OverloadedType) do
+        @@counter = 0
+        attribute :counter, :integer, default: -> { @@counter += 1 }
+      end
+
+      assert_equal 1, klass.new.counter
+      assert_equal 2, klass.new.counter
+    end
+
+    test "procs are memoized before type casting" do
+      klass = Class.new(OverloadedType) do
+        @@counter = 0
+        attribute :counter, :integer, default: -> { @@counter += 1 }
+      end
+
+      model = klass.new
+      assert_equal 1, model.counter_before_type_cast
+      assert_equal 1, model.counter_before_type_cast
+    end
+
+    test "user provided defaults are persisted even if unchanged" do
+      model = OverloadedType.create!
+
+      assert_equal "the overloaded default", model.reload.string_with_default
+    end
+
+    if current_adapter?(:PostgreSQLAdapter)
+      test "array types can be specified" do
+        klass = Class.new(OverloadedType) do
+          attribute :my_array, :string, limit: 50, array: true
+          attribute :my_int_array, :integer, array: true
+        end
+
+        string_array = ConnectionAdapters::PostgreSQL::OID::Array.new(
+          Type::String.new(limit: 50))
+        int_array = ConnectionAdapters::PostgreSQL::OID::Array.new(
+          Type::Integer.new)
+        assert_not_equal string_array, int_array
+        assert_equal string_array, klass.type_for_attribute("my_array")
+        assert_equal int_array, klass.type_for_attribute("my_int_array")
       end
 
-      def type.type_cast_for_database(value)
-        if value
-          "Y"
-        else
-          "N"
+      test "range types can be specified" do
+        klass = Class.new(OverloadedType) do
+          attribute :my_range, :string, limit: 50, range: true
+          attribute :my_int_range, :integer, range: true
         end
+
+        string_range = ConnectionAdapters::PostgreSQL::OID::Range.new(
+          Type::String.new(limit: 50))
+        int_range = ConnectionAdapters::PostgreSQL::OID::Range.new(
+          Type::Integer.new)
+        assert_not_equal string_range, int_range
+        assert_equal string_range, klass.type_for_attribute("my_range")
+        assert_equal int_range, klass.type_for_attribute("my_int_range")
+      end
+    end
+
+    test "attributes added after subclasses load are inherited" do
+      parent = Class.new(ActiveRecord::Base) do
+        self.table_name = "topics"
+      end
+
+      child = Class.new(parent)
+      child.new # => force a schema load
+
+      parent.attribute(:foo, Type::Value.new)
+
+      assert_equal(:bar, child.new(foo: :bar).foo)
+    end
+
+    test "attributes not backed by database columns are not dirty when unchanged" do
+      refute OverloadedType.new.non_existent_decimal_changed?
+    end
+
+    test "attributes not backed by database columns are always initialized" do
+      OverloadedType.create!
+      model = OverloadedType.first
+
+      assert_nil model.non_existent_decimal
+      model.non_existent_decimal = "123"
+      assert_equal 123, model.non_existent_decimal
+    end
+
+    test "attributes not backed by database columns return the default on models loaded from database" do
+      child = Class.new(OverloadedType) do
+        attribute :non_existent_decimal, :decimal, default: 123
       end
+      child.create!
+      model = child.first
+
+      assert_equal 123, model.non_existent_decimal
+    end
+
+    test "attributes not backed by database columns properly interact with mutation and dirty" do
+      child = Class.new(ActiveRecord::Base) do
+        self.table_name = "topics"
+        attribute :foo, :string, default: "lol"
+      end
+      child.create!
+      model = child.first
+
+      assert_equal "lol", model.foo
+
+      model.foo << "asdf"
+      assert_equal "lolasdf", model.foo
+      assert model.foo_changed?
 
-      klass.attribute(:string_with_default, type, default: false)
-      klass.create!(string_with_default: true)
+      model.reload
+      assert_equal "lol", model.foo
 
-      assert_equal 1, klass.where(string_with_default: true).count
+      model.foo = "lol"
+      refute model.changed?
     end
   end
 end