1 files changed, 79 insertions, 30 deletions
diff --git a/activerecord/test/cases/attributes_test.rb b/activerecord/test/cases/attributes_test.rb
index 79ef0502cb..e7b76b1cf9 100644
--- a/activerecord/test/cases/attributes_test.rb
+++ b/activerecord/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
@@ -20,7 +20,7 @@ end
 
 module ActiveRecord
   class CustomPropertiesTest < ActiveRecord::TestCase
-    def test_overloading_types
+    test "overloading types" do
       data = OverloadedType.new
 
       data.overloaded_float = "1.1"
@@ -30,7 +30,7 @@ module ActiveRecord
       assert_equal 1.1, data.unoverloaded_float
     end
 
-    def test_overloaded_properties_save
+    test "overloaded properties save" do
       data = OverloadedType.new
 
       data.overloaded_float = "2.2"
@@ -43,27 +43,27 @@ module ActiveRecord
       assert_kind_of Float, UnoverloadedType.last.overloaded_float
     end
 
-    def test_properties_assigned_in_constructor
+    test "properties assigned in constructor" do
       data = OverloadedType.new(overloaded_float: '3.3')
 
       assert_equal 3, data.overloaded_float
     end
 
-    def test_overloaded_properties_with_limit
-      assert_equal 50, OverloadedType.columns_hash['overloaded_string_with_limit'].limit
-      assert_equal 255, UnoverloadedType.columns_hash['overloaded_string_with_limit'].limit
+    test "overloaded properties with limit" do
+      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
 
-    def test_nonexistent_attribute
+    test "nonexistent attribute" do
       data = OverloadedType.new(non_existent_decimal: 1)
 
       assert_equal BigDecimal.new(1), data.non_existent_decimal
-      assert_raise ActiveRecord::UnknownAttributeError do
+      assert_raise ActiveModel::AttributeAssignment::UnknownAttributeError do
         UnoverloadedType.new(non_existent_decimal: 1)
       end
     end
 
-    def test_changing_defaults
+    test "changing defaults" do
       data = OverloadedType.new
       unoverloaded_data = UnoverloadedType.new
 
@@ -71,41 +71,90 @@ module ActiveRecord
       assert_equal 'the original default', unoverloaded_data.string_with_default
     end
 
-    def test_children_inherit_custom_properties
+    test "defaults are not touched on the columns" do
+      assert_equal 'the original default', OverloadedType.columns_hash['string_with_default'].default
+    end
+
+    test "children inherit custom properties" do
       data = ChildOfOverloadedType.new(overloaded_float: '4.4')
 
       assert_equal 4, data.overloaded_float
     end
 
-    def test_children_can_override_parents
+    test "children can override parents" do
       data = GrandchildOfOverloadedType.new(overloaded_float: '4.4')
 
       assert_equal 4.4, data.overloaded_float
     end
 
-    def test_overloading_properties_does_not_change_column_order
-      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
 
-    def test_caches_are_cleared
+    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 "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
+
+    if current_adapter?(:PostgreSQLAdapter)
+      test "arrays 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)
+        refute_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
+
+      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)
+        refute_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
   end
 end