1 files changed, 65 insertions, 20 deletions

diff --git a/activerecord/test/cases/attributes_test.rb b/activerecord/test/cases/attributes_test.rb
index 4ddf6e7ba0..a753e8b74e 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
@@ -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
@@ -87,29 +87,74 @@ 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 "the given default value is cast from user" do
+      custom_type = Class.new(Type::Value) do
+        def type_cast_from_user(*)
+          "from user"
+        end
+
+        def type_cast_from_database(*)
+          "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