ibm_db 3.0.5-x86-mingw32 → 5.0.5-x86-mingw32

data/test/cases/type/adapter_specific_registry_test.rb

@@ -0,0 +1,133 @@
+require "cases/helper"
+
+module ActiveRecord
+  class AdapterSpecificRegistryTest < ActiveRecord::TestCase
+    test "a class can be registered for a symbol" do
+      registry = Type::AdapterSpecificRegistry.new
+      registry.register(:foo, ::String)
+      registry.register(:bar, ::Array)
+
+      assert_equal "", registry.lookup(:foo)
+      assert_equal [], registry.lookup(:bar)
+    end
+
+    test "a block can be registered" do
+      registry = Type::AdapterSpecificRegistry.new
+      registry.register(:foo) do |*args|
+        [*args, "block for foo"]
+      end
+      registry.register(:bar) do |*args|
+        [*args, "block for bar"]
+      end
+
+      assert_equal [:foo, 1, "block for foo"], registry.lookup(:foo, 1)
+      assert_equal [:foo, 2, "block for foo"], registry.lookup(:foo, 2)
+      assert_equal [:bar, 1, 2, 3, "block for bar"], registry.lookup(:bar, 1, 2, 3)
+    end
+
+    test "filtering by adapter" do
+      registry = Type::AdapterSpecificRegistry.new
+      registry.register(:foo, String, adapter: :sqlite3)
+      registry.register(:foo, Array, adapter: :postgresql)
+
+      assert_equal "", registry.lookup(:foo, adapter: :sqlite3)
+      assert_equal [], registry.lookup(:foo, adapter: :postgresql)
+    end
+
+    test "an error is raised if both a generic and adapter specific type match" do
+      registry = Type::AdapterSpecificRegistry.new
+      registry.register(:foo, String)
+      registry.register(:foo, Array, adapter: :postgresql)
+
+      assert_raises TypeConflictError do
+        registry.lookup(:foo, adapter: :postgresql)
+      end
+      assert_equal "", registry.lookup(:foo, adapter: :sqlite3)
+    end
+
+    test "a generic type can explicitly override an adapter specific type" do
+      registry = Type::AdapterSpecificRegistry.new
+      registry.register(:foo, String, override: true)
+      registry.register(:foo, Array, adapter: :postgresql)
+
+      assert_equal "", registry.lookup(:foo, adapter: :postgresql)
+      assert_equal "", registry.lookup(:foo, adapter: :sqlite3)
+    end
+
+    test "a generic type can explicitly allow an adapter type to be used instead" do
+      registry = Type::AdapterSpecificRegistry.new
+      registry.register(:foo, String, override: false)
+      registry.register(:foo, Array, adapter: :postgresql)
+
+      assert_equal [], registry.lookup(:foo, adapter: :postgresql)
+      assert_equal "", registry.lookup(:foo, adapter: :sqlite3)
+    end
+
+    test "a reasonable error is given when no type is found" do
+      registry = Type::AdapterSpecificRegistry.new
+
+      e = assert_raises(ArgumentError) do
+        registry.lookup(:foo)
+      end
+
+      assert_equal "Unknown type :foo", e.message
+    end
+
+    test "construct args are passed to the type" do
+      type = Struct.new(:args)
+      registry = Type::AdapterSpecificRegistry.new
+      registry.register(:foo, type)
+
+      assert_equal type.new, registry.lookup(:foo)
+      assert_equal type.new(:ordered_arg), registry.lookup(:foo, :ordered_arg)
+      assert_equal type.new(keyword: :arg), registry.lookup(:foo, keyword: :arg)
+      assert_equal type.new(keyword: :arg), registry.lookup(:foo, keyword: :arg, adapter: :postgresql)
+    end
+
+    test "registering a modifier" do
+      decoration = Struct.new(:value)
+      registry = Type::AdapterSpecificRegistry.new
+      registry.register(:foo, String)
+      registry.register(:bar, Hash)
+      registry.add_modifier({ array: true }, decoration)
+
+      assert_equal decoration.new(""), registry.lookup(:foo, array: true)
+      assert_equal decoration.new({}), registry.lookup(:bar, array: true)
+      assert_equal "", registry.lookup(:foo)
+    end
+
+    test "registering multiple modifiers" do
+      decoration = Struct.new(:value)
+      other_decoration = Struct.new(:value)
+      registry = Type::AdapterSpecificRegistry.new
+      registry.register(:foo, String)
+      registry.add_modifier({ array: true }, decoration)
+      registry.add_modifier({ range: true }, other_decoration)
+
+      assert_equal "", registry.lookup(:foo)
+      assert_equal decoration.new(""), registry.lookup(:foo, array: true)
+      assert_equal other_decoration.new(""), registry.lookup(:foo, range: true)
+      assert_equal(
+        decoration.new(other_decoration.new("")),
+        registry.lookup(:foo, array: true, range: true)
+      )
+    end
+
+    test "registering adapter specific modifiers" do
+      decoration = Struct.new(:value)
+      type = Struct.new(:args)
+      registry = Type::AdapterSpecificRegistry.new
+      registry.register(:foo, type)
+      registry.add_modifier({ array: true }, decoration, adapter: :postgresql)
+
+      assert_equal(
+        decoration.new(type.new(keyword: :arg)),
+        registry.lookup(:foo, array: true, adapter: :postgresql, keyword: :arg)
+      )
+      assert_equal(
+        type.new(array: true),
+        registry.lookup(:foo, array: true, adapter: :sqlite3)
+      )
+    end
+  end
+end

data/test/cases/type/date_time_test.rb

@@ -0,0 +1,14 @@
+require "cases/helper"
+require "models/task"
+
+module ActiveRecord
+  module Type
+    class IntegerTest < ActiveRecord::TestCase
+      def test_datetime_seconds_precision_applied_to_timestamp
+        skip "This test is invalid if subsecond precision isn't supported" unless subsecond_precision_supported?
+        p = Task.create!(starting: ::Time.now)
+        assert_equal p.starting.usec, p.reload.starting.usec
+      end
+    end
+  end
+end

data/test/cases/type/integer_test.rb

@@ -4,110 +4,16 @@ require "models/company"
 module ActiveRecord
   module Type
     class IntegerTest < ActiveRecord::TestCase
-      test "simple values" do
-        type = Type::Integer.new
-        assert_equal 1, type.type_cast_from_user(1)
-        assert_equal 1, type.type_cast_from_user('1')
-        assert_equal 1, type.type_cast_from_user('1ignore')
-        assert_equal 0, type.type_cast_from_user('bad1')
-        assert_equal 0, type.type_cast_from_user('bad')
-        assert_equal 1, type.type_cast_from_user(1.7)
-        assert_equal 0, type.type_cast_from_user(false)
-        assert_equal 1, type.type_cast_from_user(true)
-        assert_nil type.type_cast_from_user(nil)
-      end
-
-      test "random objects cast to nil" do
-        type = Type::Integer.new
-        assert_nil type.type_cast_from_user([1,2])
-        assert_nil type.type_cast_from_user({1 => 2})
-        assert_nil type.type_cast_from_user((1..2))
-      end
-
       test "casting ActiveRecord models" do
         type = Type::Integer.new
         firm = Firm.create(:name => 'Apple')
-        assert_nil type.type_cast_from_user(firm)
-      end
-
-      test "casting objects without to_i" do
-        type = Type::Integer.new
-        assert_nil type.type_cast_from_user(::Object.new)
-      end
-
-      test "casting nan and infinity" do
-        type = Type::Integer.new
-        assert_nil type.type_cast_from_user(::Float::NAN)
-        assert_nil type.type_cast_from_user(1.0/0.0)
-      end
-
-      test "changed?" do
-        type = Type::Integer.new
-
-        assert type.changed?(5, 5, '5wibble')
-        assert_not type.changed?(5, 5, '5')
-        assert_not type.changed?(5, 5, '5.0')
-        assert_not type.changed?(-5, -5, '-5')
-        assert_not type.changed?(-5, -5, '-5.0')
-        assert_not type.changed?(nil, nil, nil)
-      end
-
-      test "values below int min value are out of range" do
-        assert_raises(::RangeError) do
-          Integer.new.type_cast_for_database(-2147483649)
-        end
-      end
-
-      test "values above int max value are out of range" do
-        assert_raises(::RangeError) do
-          Integer.new.type_cast_for_database(2147483648)
-        end
-      end
-
-      test "very small numbers are out of range" do
-        assert_raises(::RangeError) do
-          Integer.new.type_cast_for_database(-9999999999999999999999999999999)
-        end
-      end
-
-      test "very large numbers are out of range" do
-        assert_raises(::RangeError) do
-          Integer.new.type_cast_for_database(9999999999999999999999999999999)
-        end
-      end
-
-      test "normal numbers are in range" do
-        type = Integer.new
-        assert_equal(0, type.type_cast_for_database(0))
-        assert_equal(-1, type.type_cast_for_database(-1))
-        assert_equal(1, type.type_cast_for_database(1))
-      end
-
-      test "int max value is in range" do
-        assert_equal(2147483647, Integer.new.type_cast_for_database(2147483647))
-      end
-
-      test "int min value is in range" do
-        assert_equal(-2147483648, Integer.new.type_cast_for_database(-2147483648))
-      end
-
-      test "columns with a larger limit have larger ranges" do
-        type = Integer.new(limit: 8)
-
-        assert_equal(9223372036854775807, type.type_cast_for_database(9223372036854775807))
-        assert_equal(-9223372036854775808, type.type_cast_for_database(-9223372036854775808))
-        assert_raises(::RangeError) do
-          type.type_cast_for_database(-9999999999999999999999999999999)
-        end
-        assert_raises(::RangeError) do
-          type.type_cast_for_database(9999999999999999999999999999999)
-        end
+        assert_nil type.cast(firm)
       end
 
       test "values which are out of range can be re-assigned" do
         klass = Class.new(ActiveRecord::Base) do
           self.table_name = 'posts'
-          attribute :foo, Type::Integer.new
+          attribute :foo, :integer
         end
         model = klass.new
 

data/test/cases/type/string_test.rb

@@ -2,20 +2,6 @@ require 'cases/helper'
 
 module ActiveRecord
   class StringTypeTest < ActiveRecord::TestCase
-    test "type casting" do
-      type = Type::String.new
-      assert_equal "t", type.type_cast_from_user(true)
-      assert_equal "f", type.type_cast_from_user(false)
-      assert_equal "123", type.type_cast_from_user(123)
-    end
-
-    test "values are duped coming out" do
-      s = "foo"
-      type = Type::String.new
-      assert_not_same s, type.type_cast_from_user(s)
-      assert_not_same s, type.type_cast_from_database(s)
-    end
-
     test "string mutations are detected" do
       klass = Class.new(Base)
       klass.table_name = 'authors'

data/test/cases/type_test.rb

@@ -0,0 +1,39 @@
+require "cases/helper"
+
+class TypeTest < ActiveRecord::TestCase
+  setup do
+    @old_registry = ActiveRecord::Type.registry
+    ActiveRecord::Type.registry = ActiveRecord::Type::AdapterSpecificRegistry.new
+  end
+
+  teardown do
+    ActiveRecord::Type.registry = @old_registry
+  end
+
+  test "registering a new type" do
+    type = Struct.new(:args)
+    ActiveRecord::Type.register(:foo, type)
+
+    assert_equal type.new(:arg), ActiveRecord::Type.lookup(:foo, :arg)
+  end
+
+  test "looking up a type for a specific adapter" do
+    type = Struct.new(:args)
+    pgtype = Struct.new(:args)
+    ActiveRecord::Type.register(:foo, type, override: false)
+    ActiveRecord::Type.register(:foo, pgtype, adapter: :postgresql)
+
+    assert_equal type.new, ActiveRecord::Type.lookup(:foo, adapter: :sqlite)
+    assert_equal pgtype.new, ActiveRecord::Type.lookup(:foo, adapter: :postgresql)
+  end
+
+  test "lookup defaults to the current adapter" do
+    current_adapter = ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+    type = Struct.new(:args)
+    adapter_type = Struct.new(:args)
+    ActiveRecord::Type.register(:foo, type, override: false)
+    ActiveRecord::Type.register(:foo, adapter_type, adapter: current_adapter)
+
+    assert_equal adapter_type.new, ActiveRecord::Type.lookup(:foo)
+  end
+end

data/test/cases/types_test.rb

@@ -3,126 +3,9 @@ require "cases/helper"
 module ActiveRecord
   module ConnectionAdapters
     class TypesTest < ActiveRecord::TestCase
-      def test_type_cast_boolean
-        type = Type::Boolean.new
-        assert type.type_cast_from_user('').nil?
-        assert type.type_cast_from_user(nil).nil?
-
-        assert type.type_cast_from_user(true)
-        assert type.type_cast_from_user(1)
-        assert type.type_cast_from_user('1')
-        assert type.type_cast_from_user('t')
-        assert type.type_cast_from_user('T')
-        assert type.type_cast_from_user('true')
-        assert type.type_cast_from_user('TRUE')
-        assert type.type_cast_from_user('on')
-        assert type.type_cast_from_user('ON')
-
-        # explicitly check for false vs nil
-        assert_equal false, type.type_cast_from_user(false)
-        assert_equal false, type.type_cast_from_user(0)
-        assert_equal false, type.type_cast_from_user('0')
-        assert_equal false, type.type_cast_from_user('f')
-        assert_equal false, type.type_cast_from_user('F')
-        assert_equal false, type.type_cast_from_user('false')
-        assert_equal false, type.type_cast_from_user('FALSE')
-        assert_equal false, type.type_cast_from_user('off')
-        assert_equal false, type.type_cast_from_user('OFF')
-        assert_deprecated do
-          assert_equal false, type.type_cast_from_user(' ')
-          assert_equal false, type.type_cast_from_user("\u3000\r\n")
-          assert_equal false, type.type_cast_from_user("\u0000")
-          assert_equal false, type.type_cast_from_user('SOMETHING RANDOM')
-        end
-      end
-
-      def test_type_cast_float
-        type = Type::Float.new
-        assert_equal 1.0, type.type_cast_from_user("1")
-      end
-
-      def test_changing_float
-        type = Type::Float.new
-
-        assert type.changed?(5.0, 5.0, '5wibble')
-        assert_not type.changed?(5.0, 5.0, '5')
-        assert_not type.changed?(5.0, 5.0, '5.0')
-        assert_not type.changed?(nil, nil, nil)
-      end
-
-      def test_type_cast_binary
-        type = Type::Binary.new
-        assert_equal nil, type.type_cast_from_user(nil)
-        assert_equal "1", type.type_cast_from_user("1")
-        assert_equal 1, type.type_cast_from_user(1)
-      end
-
-      def test_type_cast_time
-        type = Type::Time.new
-        assert_equal nil, type.type_cast_from_user(nil)
-        assert_equal nil, type.type_cast_from_user('')
-        assert_equal nil, type.type_cast_from_user('ABC')
-
-        time_string = Time.now.utc.strftime("%T")
-        assert_equal time_string, type.type_cast_from_user(time_string).strftime("%T")
-      end
-
-      def test_type_cast_datetime_and_timestamp
-        type = Type::DateTime.new
-        assert_equal nil, type.type_cast_from_user(nil)
-        assert_equal nil, type.type_cast_from_user('')
-        assert_equal nil, type.type_cast_from_user('  ')
-        assert_equal nil, type.type_cast_from_user('ABC')
-
-        datetime_string = Time.now.utc.strftime("%FT%T")
-        assert_equal datetime_string, type.type_cast_from_user(datetime_string).strftime("%FT%T")
-      end
-
-      def test_type_cast_date
-        type = Type::Date.new
-        assert_equal nil, type.type_cast_from_user(nil)
-        assert_equal nil, type.type_cast_from_user('')
-        assert_equal nil, type.type_cast_from_user(' ')
-        assert_equal nil, type.type_cast_from_user('ABC')
-
-        date_string = Time.now.utc.strftime("%F")
-        assert_equal date_string, type.type_cast_from_user(date_string).strftime("%F")
-      end
-
-      def test_type_cast_duration_to_integer
-        type = Type::Integer.new
-        assert_equal 1800, type.type_cast_from_user(30.minutes)
-        assert_equal 7200, type.type_cast_from_user(2.hours)
-      end
-
-      def test_string_to_time_with_timezone
-        [:utc, :local].each do |zone|
-          with_timezone_config default: zone do
-            type = Type::DateTime.new
-            assert_equal Time.utc(2013, 9, 4, 0, 0, 0), type.type_cast_from_user("Wed, 04 Sep 2013 03:00:00 EAT")
-          end
-        end
-      end
-
-      def test_type_equality
-        assert_equal Type::Value.new, Type::Value.new
-        assert_not_equal Type::Value.new, Type::Integer.new
-        assert_not_equal Type::Value.new(precision: 1), Type::Value.new(precision: 2)
-      end
-
-      if current_adapter?(:SQLite3Adapter)
-        def test_binary_encoding
-          type = SQLite3Binary.new
-          utf8_string = "a string".encode(Encoding::UTF_8)
-          type_cast = type.type_cast_from_user(utf8_string)
-
-          assert_equal Encoding::ASCII_8BIT, type_cast.encoding
-        end
-      end
-
       def test_attributes_which_are_invalid_for_database_can_still_be_reassigned
         type_which_cannot_go_to_the_database = Type::Value.new
-        def type_which_cannot_go_to_the_database.type_cast_for_database(*)
+        def type_which_cannot_go_to_the_database.serialize(*)
           raise
         end
         klass = Class.new(ActiveRecord::Base) do