Use actual object instead of Minitest::Mock

Using a `Minitest::Mock` makes these tests brittle.  Therefore, use an
actual object instead.

Author: jonathanhefner

activemodel/test/cases/attribute_test.rb

@@ -4,100 +4,101 @@
 
 module ActiveModel
   class AttributeTest < ActiveModel::TestCase
-    setup do
-      @type = Minitest::Mock.new
+    class InscribingType
+      def cast(value)
+        "cast(#{value})"
+      end
+
+      def serialize(value)
+        "serialize(#{value})"
+      end
+
+      def deserialize(value)
+        "deserialize(#{value})"
+      end
     end
 
-    teardown do
-      assert @type.verify
+    setup do
+      @type = InscribingType.new
     end
 
     test "from_database + read type casts from database" do
-      @type.expect(:deserialize, "type cast from database", ["a value"])
       attribute = Attribute.from_database(nil, "a value", @type)
 
-      type_cast_value = attribute.value
-
-      assert_equal "type cast from database", type_cast_value
+      assert_equal "deserialize(a value)", attribute.value
     end
 
     test "from_user + read type casts from user" do
-      @type.expect(:cast, "type cast from user", ["a value"])
       attribute = Attribute.from_user(nil, "a value", @type)
 
-      type_cast_value = attribute.value
-
-      assert_equal "type cast from user", type_cast_value
+      assert_equal "cast(a value)", attribute.value
     end
 
     test "reading memoizes the value" do
-      @type.expect(:deserialize, "from the database", ["whatever"])
-      attribute = Attribute.from_database(nil, "whatever", @type)
+      count = 0
+      @type.define_singleton_method(:deserialize) do |value|
+        count += 1
+        value
+      end
 
-      type_cast_value = attribute.value
-      second_read = attribute.value
+      attribute = Attribute.from_database(nil, "whatever", @type)
 
-      assert_equal "from the database", type_cast_value
-      assert_same type_cast_value, second_read
+      attribute.value
+      attribute.value
+      assert_equal 1, count
     end
 
     test "reading memoizes falsy values" do
-      @type.expect(:deserialize, false, ["whatever"])
+      count = 0
+      @type.define_singleton_method(:deserialize) do |value|
+        count += 1
+        false
+      end
+
       attribute = Attribute.from_database(nil, "whatever", @type)
 
       attribute.value
       attribute.value
+      assert_equal 1, count
     end
 
-    test "read_before_typecast returns the given value" do
+    test "value_before_type_cast returns the given value" do
       attribute = Attribute.from_database(nil, "raw value", @type)
 
       raw_value = attribute.value_before_type_cast
 
       assert_equal "raw value", raw_value
     end
 
-    test "from_database + read_for_database type casts to and from database" do
-      @type.expect(:deserialize, "read from database", ["whatever"])
-      @type.expect(:serialize, "ready for database", ["read from database"])
+    test "from_database + value_for_database type casts to and from database" do
       attribute = Attribute.from_database(nil, "whatever", @type)
 
-      serialize = attribute.value_for_database
-
-      assert_equal "ready for database", serialize
+      assert_equal "serialize(deserialize(whatever))", attribute.value_for_database
     end
 
-    test "from_user + read_for_database type casts from the user to the database" do
-      @type.expect(:cast, "read from user", ["whatever"])
-      @type.expect(:serialize, "ready for database", ["read from user"])
+    test "from_user + value_for_database type casts from the user to the database" do
       attribute = Attribute.from_user(nil, "whatever", @type)
 
-      serialize = attribute.value_for_database
-
-      assert_equal "ready for database", serialize
+      assert_equal "serialize(cast(whatever))", attribute.value_for_database
     end
 
     test "duping dups the value" do
-      @type.expect(:deserialize, +"type cast", ["a value"])
       attribute = Attribute.from_database(nil, "a value", @type)
 
-      value_from_orig = attribute.value
-      value_from_clone = attribute.dup.value
-      value_from_orig << " foo"
-
-      assert_equal "type cast foo", value_from_orig
-      assert_equal "type cast", value_from_clone
+      assert_not_same attribute.value, attribute.dup.value
     end
 
     test "duping does not dup the value if it is not dupable" do
-      @type.expect(:deserialize, false, ["a value"])
-      attribute = Attribute.from_database(nil, "a value", @type)
+      @type.define_singleton_method(:deserialize) { |value| value }
+      attribute = Attribute.from_database(nil, false, @type)
 
       assert_same attribute.value, attribute.dup.value
     end
 
     test "duping does not eagerly type cast if we have not yet type cast" do
+      @type.define_singleton_method(:deserialize) { flunk }
       attribute = Attribute.from_database(nil, "a value", @type)
+
       attribute.dup
     end