activerecord-databasevalidations 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c54c89523b089da35cf81ac327720dc7747477e4
-  data.tar.gz: b6c0284892866070449337290b70c5f481bc1c6b
+  metadata.gz: 090f45578b6802cdbdba1069b5d37a9a36936e53
+  data.tar.gz: 8804b23a035aaa84fa334caa69fa862971bf0ffc
 SHA512:
-  metadata.gz: fa9279114bf9c478f74f52c6753ae91d4829fdf0ba4e076d20981a6c057b016da7de4dad5598ea7a541d3dcfb31d44e93017fe8fe7bbed9fa923b55c21677f2e
-  data.tar.gz: 8efe103e02f9fdceaea9aea6e8094b9b7a224d605f30eacfad0dffb08221ba48394e96c3adbabea5679d626a0d9d15c01fa0471b0240ebfb95f7d5c4fc5a2beb
+  metadata.gz: 48f4ce81a05aa5798f73b24997eea4920027318e4c48cdae4824c806a3cee5c84688058f204af0bf074b29360037108939bca38c0389b52f18cd3d3fd52ab941
+  data.tar.gz: 33774245ec628ff1b463559346e3e11699e302b4a41417676caf42ad08b5a8f07f3f613fb0d724c41edd883e7b51b90a660889e75cf4134d9e9526b909c8c438

data/lib/active_record/database_validations/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module DatabaseValidations
-    VERSION = "0.1.2"
+    VERSION = "0.1.3"
   end
 end

data/lib/active_record/validations/database_constraints.rb

@@ -23,7 +23,7 @@ module ActiveRecord
 
       attr_reader :constraints
 
-      VALID_CONSTRAINTS = Set[:size, :basic_multilingual_plane, :not_null]
+      VALID_CONSTRAINTS = Set[:size, :basic_multilingual_plane, :not_null, :range]
 
       def initialize(options = {})
         @constraints = Set.new(Array.wrap(options[:in]) + Array.wrap(options[:with]))
@@ -60,6 +60,29 @@ module ActiveRecord
         end
       end
 
+      def range_validator(klass, column)
+        return unless constraints.include?(:range)
+        return unless column.number?
+
+        unsigned = column.sql_type =~ / unsigned\z/
+        case column.type
+        when :decimal
+          args = { attributes: [column.name.to_sym], class: klass, allow_nil: true }
+          args[:less_than] = maximum = 10 ** (column.precision - column.scale)
+          if unsigned
+            args[:greater_than_or_equal_to] = 0
+          else
+            args[:greater_than] = 0 - maximum
+          end
+          ActiveModel::Validations::NumericalityValidator.new(args)
+
+        when :integer
+          maximum = unsigned ? 1 << (column.limit * 8) : 1 << (column.limit * 8 - 1)
+          minimum = unsigned ? 0 : 0 - maximum
+          ActiveModel::Validations::NumericalityValidator.new(attributes: [column.name.to_sym], class: klass, greater_than_or_equal_to: minimum, less_than: maximum, allow_nil: true, only_integer: true)
+        end
+      end
+
       def basic_multilingual_plane_validator(klass, column)
         return unless constraints.include?(:basic_multilingual_plane)
         return unless column.text? && column.collation =~ /\Autf8(?:mb3)?_/
@@ -74,6 +97,7 @@ module ActiveRecord
             not_null_validator(klass, column),
             size_validator(klass, column),
             basic_multilingual_plane_validator(klass, column),
+            range_validator(klass, column),
           ].compact
         end
       end

data/test/data_loss_test.rb

@@ -4,9 +4,19 @@ require 'test_helper'
 
 ActiveRecord::Migration.suppress_messages do
   ActiveRecord::Migration.create_table("unicorns", force: true, options: "CHARACTER SET utf8mb3") do |t|
-    t.string :string,   limit: 40
-    t.text   :tinytext, limit: 255
-    t.binary :blob
+    t.column :string,           "VARCHAR(40)"
+    t.column :tinytext,         "TINYTEXT"
+    t.column :blob,             "BLOB"
+
+    t.column :decimal,          "DECIMAL(10, 2)"
+    t.column :unsigned_decimal, "DECIMAL(5, 3) UNSIGNED"
+
+    t.column :tinyint,          "TINYINT"
+    t.column :smallint,         "SMALLINT"
+    t.column :mediumint,        "MEDIUMINT"
+    t.column :int,              "INT"
+    t.column :bigint,           "BIGINT"
+    t.column :unsigned_tinyint, "TINYINT UNSIGNED"
   end
 end
 
@@ -15,52 +25,83 @@ class Unicorn < ActiveRecord::Base
 end
 
 class DataLossTest < Minitest::Test
+  include DataLossAssertions
+
   def test_strict_mode_is_disabled
     refute Unicorn.connection.show_variable(:sql_mode).include?('STRICT_ALL_TABLES')
     refute Unicorn.connection.show_variable(:sql_mode).include?('STRICT_TRANS_TABLES')
   end
 
-  def test_bounded_string_fields_silently_loses_data_when_strict_mode_is_disabled
-    fitting_string = 'ü' * 40
-    assert Unicorn.columns_hash['string'].limit >= fitting_string.length
-    unicorn = Unicorn.create(string: fitting_string)
-    assert_equal fitting_string, unicorn.reload.string
+  def test_decimal_silently_changes_out_of_bound_values
+    maximum = BigDecimal.new(10 **  (Unicorn.columns_hash['decimal'].precision - Unicorn.columns_hash['decimal'].scale))
+    delta   = BigDecimal.new(10 ** -(Unicorn.columns_hash['decimal'].scale), Unicorn.columns_hash['decimal'].precision)
+
+    refute_data_loss Unicorn.new(decimal: maximum - delta)
+    assert_data_loss Unicorn.new(decimal: maximum)
+    refute_data_loss Unicorn.new(decimal: 0 - maximum + delta)
+    assert_data_loss Unicorn.new(decimal: 0 - maximum)
 
-    overflowing_string = 'ü' * 41
-    assert Unicorn.columns_hash['string'].limit < overflowing_string.length
-    unicorn = Unicorn.create(string: overflowing_string)
-    assert unicorn.reload.string != overflowing_string 
+
+    maximum = BigDecimal.new(10 **  (Unicorn.columns_hash['unsigned_decimal'].precision - Unicorn.columns_hash['unsigned_decimal'].scale))
+    delta   = BigDecimal.new(10 ** -(Unicorn.columns_hash['unsigned_decimal'].scale), Unicorn.columns_hash['unsigned_decimal'].precision)
+
+    refute_data_loss Unicorn.new(unsigned_decimal: maximum - delta)
+    assert_data_loss Unicorn.new(unsigned_decimal: maximum)
+    refute_data_loss Unicorn.new(unsigned_decimal: 0)
+    assert_data_loss Unicorn.new(unsigned_decimal: 0 - delta)
   end
 
-  def test_text_field_silently_loses_data_when_strict_mode_is_disabled
-    fitting_tinytext = '写' * 85
-    assert_equal 255, fitting_tinytext.bytesize
-    unicorn = Unicorn.create(tinytext: fitting_tinytext) # <= 255, the TINYTEXT limit
-    assert_equal fitting_tinytext, unicorn.reload.tinytext 
+  def test_integers_silently_change_value_outside_of_range
+    refute_data_loss Unicorn.new(tinyint:  127)
+    refute_data_loss Unicorn.new(tinyint: -128)
+    assert_data_loss Unicorn.new(tinyint:  128)
+    assert_data_loss Unicorn.new(tinyint: -129)
+
+    refute_data_loss Unicorn.new(smallint:  32_767)
+    refute_data_loss Unicorn.new(smallint: -32_768)
+    assert_data_loss Unicorn.new(smallint:  32_768)
+    assert_data_loss Unicorn.new(smallint: -32_769)
 
-    overflowing_tinytext = 'ü' * 128
-    assert_equal 256, overflowing_tinytext.bytesize # > 255, the TINYTEXT limit
-    unicorn = Unicorn.create(tinytext: overflowing_tinytext)
-    assert unicorn.reload.tinytext != overflowing_tinytext 
+    refute_data_loss Unicorn.new(mediumint:  8_388_607)
+    refute_data_loss Unicorn.new(mediumint: -8_388_608)
+    assert_data_loss Unicorn.new(mediumint:  8_388_608)
+    assert_data_loss Unicorn.new(mediumint: -8_388_609)
+
+    refute_data_loss Unicorn.new(int:  2_147_483_647)
+    refute_data_loss Unicorn.new(int: -2_147_483_648)
+    assert_data_loss Unicorn.new(int:  2_147_483_648)
+    assert_data_loss Unicorn.new(int: -2_147_483_649)
+
+    refute_data_loss Unicorn.new(bigint:  9_223_372_036_854_775_807)
+    refute_data_loss Unicorn.new(bigint: -9_223_372_036_854_775_808)
+    assert_data_loss Unicorn.new(bigint:  9_223_372_036_854_775_808)
+    assert_data_loss Unicorn.new(bigint: -9_223_372_036_854_775_809)
+
+    refute_data_loss Unicorn.new(unsigned_tinyint: 255)
+    refute_data_loss Unicorn.new(unsigned_tinyint: 0)
+    assert_data_loss Unicorn.new(unsigned_tinyint: 256)
+    assert_data_loss Unicorn.new(unsigned_tinyint: -1)
   end
 
-  def test_binary_field_silently_loses_data_when_strict_mode_is_disabled
-    fitting_blob = [].pack('x65535')
-    assert_equal 65535, fitting_blob.bytesize
-    unicorn = Unicorn.create(blob: fitting_blob) # <= 65535, the BLOB limit
-    assert_equal fitting_blob, unicorn.reload.blob 
+  def test_varchar_field_silently_drops_characters_when_over_character_limit
+    refute_data_loss Unicorn.new(string: 'ü' * 40)
+    assert_data_loss Unicorn.new(string: 'ü' * 41)
+  end
+
+  def test_text_field_silently_drops_charactars_when_when_over_bytesize_limit
+    refute_data_loss Unicorn.new(tinytext: '写' * 85) # 85 * 3 = 255 bytes => fits
+    assert_data_loss Unicorn.new(tinytext: 'ü' * 128) # 128 * 2 = 256 bytes => doesn't fit :()
+  end
 
-    overflowing_blob = [].pack('x65536')
-    assert_equal 65536, overflowing_blob.bytesize # > 65535, the BLOB limit
-    unicorn = Unicorn.create(blob: overflowing_blob)
-    assert unicorn.reload.blob != overflowing_blob 
+  def test_blob_field_silently_drops_bytes_when_when_over_bytesize_limit
+    refute_data_loss Unicorn.new(blob: [].pack('x65535')) # 65535 is bytesize limit of blob field
+    assert_data_loss Unicorn.new(blob: [].pack('x65536'))
   end
 
-  def test_unchecked_utf8mb3_field_silently_loses_data_when_strict_mode_is_disabled
+  def test_utf8mb3_field_sliently_truncates_strings_after_first_4byte_character
     emoji = '💩'
     assert_equal 1, emoji.length
     assert_equal 4, emoji.bytesize
-    unicorn = Unicorn.create(string: emoji)
-    assert unicorn.reload.string != emoji
+    assert_data_loss Unicorn.new(string: emoji)
   end
 end

data/test/database.yml

@@ -2,5 +2,5 @@ test:
   adapter: mysql2
   database: database_validations
   username: travis
-  encoding: utf8
+  encoding: utf8mb4
   strict: false

data/test/database_constraints_validator_test.rb

@@ -4,18 +4,29 @@ require 'test_helper'
 
 ActiveRecord::Migration.suppress_messages do
   ActiveRecord::Migration.create_table("foos", force: true, options: "CHARACTER SET utf8mb3") do |t|
-    t.string   :string,    limit: 40
-    t.text     :tinytext,  limit: 255
-    t.binary   :varbinary, limit: 255
+    t.string   :string,        limit: 40
+    t.text     :tinytext,      limit: 255
+    t.binary   :varbinary,     limit: 255
     t.binary   :blob
     t.text     :not_null_text, null: false
-    t.integer  :checked,       null: false, default: 0
+    t.integer  :checked,       null: false,  default: 0
     t.integer  :unchecked,     null: false
   end
 
   ActiveRecord::Migration.create_table("bars", force: true, options: "CHARACTER SET utf8mb4") do |t|
     t.string   :mb4_string
   end
+
+  ActiveRecord::Migration.create_table("nums", force: true) do |t|
+    t.column :decimal,          "DECIMAL(5,2)"
+    t.column :unsigned_decimal, "DECIMAL(5,2) UNSIGNED"
+    t.column :tinyint,          "TINYINT"
+    t.column :smallint,         "SMALLINT"
+    t.column :mediumint,        "MEDIUMINT"
+    t.column :int,              "INT"
+    t.column :bigint,           "BIGINT"
+    t.column :unsigned_int,     "INT UNSIGNED"
+  end
 end
 
 class Foo < ActiveRecord::Base
@@ -28,7 +39,13 @@ class Bar < ActiveRecord::Base
   validates :mb4_string, database_constraints: :basic_multilingual_plane
 end
 
+class Num < ActiveRecord::Base
+  validates :decimal, :unsigned_decimal, :tinyint, :smallint, :mediumint, :int, :bigint, :unsigned_int, database_constraints: :range
+end
+
 class DatabaseConstraintsValidatorTest < Minitest::Test
+  include DataLossAssertions
+
   def test_argument_validation
     assert_raises(ArgumentError) { Bar.validates(:mb4_string, database_constraints: []) }
     assert_raises(ArgumentError) { Bar.validates(:mb4_string, database_constraints: true) }
@@ -88,9 +105,99 @@ class DatabaseConstraintsValidatorTest < Minitest::Test
     refute Foo.new(checked: nil).valid?
   end
 
-  def test_should_not_create_a_validor_for_a_utf8mb4_field
-    assert Bar.new(mb4_string: '💩').valid?
-    Bar._validators[:mb4_string].first.attribute_validators(Bar, :mb4_string).empty?
+  def test_should_not_create_a_validator_for_a_utf8mb4_field
+    assert Bar._validators[:mb4_string].first.attribute_validators(Bar, :mb4_string).empty?
+    emoji = Bar.new(mb4_string: '💩')
+    assert emoji.valid?
+    refute_data_loss emoji
+  end
+
+  def test_decimal_range
+    subvalidators = Num._validators[:decimal].first.attribute_validators(Num, :decimal)
+    assert_equal 1, subvalidators.length
+    assert_kind_of ActiveModel::Validations::NumericalityValidator, subvalidators.first
+
+    inside_upper_bound = Num.new(decimal: '999.99')
+    assert inside_upper_bound.valid?
+    refute_data_loss(inside_upper_bound)
+
+    inside_lower_bound = Num.new(decimal: '-999.99')
+    assert inside_lower_bound.valid?
+    refute_data_loss(inside_lower_bound)
+
+    outside_upper_bound = Num.new(decimal: '1000.00')
+    refute outside_upper_bound.valid?
+    assert_data_loss(outside_upper_bound)
+
+    outside_lower_bound = Num.new(decimal: '-1000.00')
+    refute outside_lower_bound.valid?
+    assert_data_loss(outside_lower_bound)
+  end
+
+  def test_unsigned_decimal_range
+    subvalidators = Num._validators[:unsigned_decimal].first.attribute_validators(Num, :unsigned_decimal)
+    assert_equal 1, subvalidators.length
+    assert_kind_of ActiveModel::Validations::NumericalityValidator, subvalidators.first
+
+    inside_upper_bound = Num.new(unsigned_decimal: '999.99')
+    assert inside_upper_bound.valid?
+    refute_data_loss(inside_upper_bound)
+
+    inside_lower_bound = Num.new(unsigned_decimal: '0.00')
+    assert inside_lower_bound.valid?
+    refute_data_loss(inside_lower_bound)
+
+    outside_upper_bound = Num.new(unsigned_decimal: '1000.00')
+    refute outside_upper_bound.valid?
+    assert_data_loss(outside_upper_bound)
+
+    outside_lower_bound = Num.new(unsigned_decimal: '-0.01')
+    refute outside_lower_bound.valid?
+    assert_data_loss(outside_lower_bound)
+  end
+
+  def test_integer_range
+    subvalidators = Num._validators[:bigint].first.attribute_validators(Num, :bigint)
+    assert_equal 1, subvalidators.length
+    assert_kind_of ActiveModel::Validations::NumericalityValidator, range_validator = subvalidators.first
+
+    inside_upper_bound = Num.new(tinyint: 127)
+    assert inside_upper_bound.valid?
+    refute_data_loss(inside_upper_bound)
+
+    inside_lower_bound = Num.new(smallint: -32_768)
+    assert inside_lower_bound.valid?
+    refute_data_loss(inside_lower_bound)
+
+    outside_upper_bound = Num.new(mediumint: 8_388_608)
+    refute outside_upper_bound.valid?
+    assert_data_loss(outside_upper_bound)
+
+    outside_lower_bound = Num.new(int: -2_147_483_649)
+    refute outside_lower_bound.valid?
+    assert_data_loss(outside_lower_bound)
+  end
+
+  def unsigned_integer_range
+    subvalidators = Num._validators[:unsigned_int].first.attribute_validators(Num, :unsigned_int)
+    assert_equal 1, subvalidators.length
+    assert_kind_of ActiveModel::Validations::NumericalityValidator, range_validator = subvalidators.first
+
+    inside_upper_bound = Num.new(unsigned_int: 4_294_967_295)
+    assert inside_upper_bound.valid?
+    refute_data_loss(inside_upper_bound)
+
+    inside_lower_bound = Num.new(unsigned_int: 0)
+    assert inside_lower_bound.valid?
+    refute_data_loss(inside_lower_bound)
+
+    outside_upper_bound = Num.new(unsigned_int: 4_294_967_296)
+    refute outside_upper_bound.valid?
+    assert_data_loss(outside_upper_bound)
+
+    outside_lower_bound = Num.new(unsigned_int: -1)
+    refute outside_lower_bound.valid?
+    assert_data_loss(outside_lower_bound)
   end
 
   def test_error_messages
@@ -105,5 +212,6 @@ class DatabaseConstraintsValidatorTest < Minitest::Test
   def test_encoding_craziness
     foo = Foo.new(tinytext: ('ü' * 128).encode('ISO-8859-15'), string: ('ü' * 40).encode('ISO-8859-15'))
     assert foo.invalid?
+    assert_data_loss foo
   end
 end

data/test/test_helper.rb

@@ -9,6 +9,28 @@ require "yaml"
 
 require "active_record/database_validations"
 
+module DataLossAssertions
+  def assert_data_loss(record)
+    attributes = record.changed
+    provided_values = record.attributes.slice(*attributes)
+
+    record.save!(validate: false)
+
+    persisted_values = record.reload.attributes.slice(*attributes)
+    refute_equal provided_values, persisted_values
+  end
+
+  def refute_data_loss(record)
+    attributes = record.changed
+    provided_values = record.attributes.slice(*attributes)
+
+    record.save!(validate: false)
+
+    persisted_values = record.reload.attributes.slice(*attributes)
+    assert_equal provided_values, persisted_values
+  end
+end
+
 Minitest::Test = MiniTest::Unit::TestCase unless defined?(MiniTest::Test)
 
 database_yml = YAML.load_file(File.expand_path('../database.yml', __FILE__))

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-databasevalidations
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Willem van Bergen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-16 00:00:00.000000000 Z
+date: 2014-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord