Make ActiveModel::Errors#add_on_blank and #add_on_empty accept an options hash and make various Validators pass their (filtered) options.

This makes it possible to pass additional options through Validators to message
generation. E.g. plugin authors want to add validates_presence_of :foo, :format
=> "some format".

Also, cleanup the :default vs :message options confusion in ActiveModel
validation message generation.

Also, deprecate ActiveModel::Errors#add_on_blank(attributes, custom_message) in
favor of ActiveModel::Errors#add_on_blank(attributes, options).

Original patch by Sven Fuchs, some minor changes and has been changed to be applicable to master again

[#4057 state:committed]

Signed-off-by: Jeremy Kemper <jeremy@bitsweat.net>

2 files changed, 73 insertions, 73 deletions

diff --git a/activemodel/test/cases/validations/i18n_generate_message_validation_test.rb b/activemodel/test/cases/validations/i18n_generate_message_validation_test.rb
index 58a8d179ad..0679e67f84 100644
--- a/activemodel/test/cases/validations/i18n_generate_message_validation_test.rb
+++ b/activemodel/test/cases/validations/i18n_generate_message_validation_test.rb
@@ -8,131 +8,131 @@ class I18nGenerateMessageValidationTest < ActiveModel::TestCase
     @person = Person.new
   end
 
-  # validates_inclusion_of: generate_message(attr_name, :inclusion, :default => configuration[:message], :value => value)
+  # validates_inclusion_of: generate_message(attr_name, :inclusion, :message => custom_message, :value => value)
   def test_generate_message_inclusion_with_default_message
-    assert_equal 'is not included in the list', @person.errors.generate_message(:title, :inclusion, :default => nil, :value => 'title')
+    assert_equal 'is not included in the list', @person.errors.generate_message(:title, :inclusion, :value => 'title')
   end
 
   def test_generate_message_inclusion_with_custom_message
-    assert_equal 'custom message title', @person.errors.generate_message(:title, :inclusion, :default => 'custom message %{value}', :value => 'title')
+    assert_equal 'custom message title', @person.errors.generate_message(:title, :inclusion, :message => 'custom message %{value}', :value => 'title')
   end
 
-  # validates_exclusion_of: generate_message(attr_name, :exclusion, :default => configuration[:message], :value => value)
+  # validates_exclusion_of: generate_message(attr_name, :exclusion, :message => custom_message, :value => value)
   def test_generate_message_exclusion_with_default_message
-    assert_equal 'is reserved', @person.errors.generate_message(:title, :exclusion, :default => nil, :value => 'title')
+    assert_equal 'is reserved', @person.errors.generate_message(:title, :exclusion, :value => 'title')
   end
 
   def test_generate_message_exclusion_with_custom_message
-    assert_equal 'custom message title', @person.errors.generate_message(:title, :exclusion, :default => 'custom message %{value}', :value => 'title')
+    assert_equal 'custom message title', @person.errors.generate_message(:title, :exclusion, :message => 'custom message %{value}', :value => 'title')
   end
 
-  # validates_format_of:  generate_message(attr_name, :invalid, :default => configuration[:message], :value => value)
+  # validates_format_of:  generate_message(attr_name, :invalid, :message => custom_message, :value => value)
   def test_generate_message_invalid_with_default_message
-    assert_equal 'is invalid', @person.errors.generate_message(:title, :invalid, :default => nil, :value => 'title')
+    assert_equal 'is invalid', @person.errors.generate_message(:title, :invalid, :value => 'title')
   end
 
   def test_generate_message_invalid_with_custom_message
-    assert_equal 'custom message title', @person.errors.generate_message(:title, :invalid, :default => 'custom message %{value}', :value => 'title')
+    assert_equal 'custom message title', @person.errors.generate_message(:title, :invalid, :message => 'custom message %{value}', :value => 'title')
   end
 
-  # validates_confirmation_of: generate_message(attr_name, :confirmation, :default => configuration[:message])
+  # validates_confirmation_of: generate_message(attr_name, :confirmation, :message => custom_message)
   def test_generate_message_confirmation_with_default_message
-    assert_equal "doesn't match confirmation", @person.errors.generate_message(:title, :confirmation, :default => nil)
+    assert_equal "doesn't match confirmation", @person.errors.generate_message(:title, :confirmation)
   end
 
   def test_generate_message_confirmation_with_custom_message
-    assert_equal 'custom message', @person.errors.generate_message(:title, :confirmation, :default => 'custom message')
+    assert_equal 'custom message', @person.errors.generate_message(:title, :confirmation, :message => 'custom message')
   end
 
-  # validates_acceptance_of: generate_message(attr_name, :accepted, :default => configuration[:message])
+  # validates_acceptance_of: generate_message(attr_name, :accepted, :message => custom_message)
   def test_generate_message_accepted_with_default_message
-    assert_equal "must be accepted", @person.errors.generate_message(:title, :accepted, :default => nil)
+    assert_equal "must be accepted", @person.errors.generate_message(:title, :accepted)
   end
 
   def test_generate_message_accepted_with_custom_message
-    assert_equal 'custom message', @person.errors.generate_message(:title, :accepted, :default => 'custom message')
+    assert_equal 'custom message', @person.errors.generate_message(:title, :accepted, :message => 'custom message')
   end
 
-  # add_on_empty: generate_message(attr, :empty, :default => custom_message)
+  # add_on_empty: generate_message(attr, :empty, :message => custom_message)
   def test_generate_message_empty_with_default_message
-    assert_equal "can't be empty", @person.errors.generate_message(:title, :empty, :default => nil)
+    assert_equal "can't be empty", @person.errors.generate_message(:title, :empty)
   end
 
   def test_generate_message_empty_with_custom_message
-    assert_equal 'custom message', @person.errors.generate_message(:title, :empty, :default => 'custom message')
+    assert_equal 'custom message', @person.errors.generate_message(:title, :empty, :message => 'custom message')
   end
 
-  # add_on_blank: generate_message(attr, :blank, :default => custom_message)
+  # add_on_blank: generate_message(attr, :blank, :message => custom_message)
   def test_generate_message_blank_with_default_message
-    assert_equal "can't be blank", @person.errors.generate_message(:title, :blank, :default => nil)
+    assert_equal "can't be blank", @person.errors.generate_message(:title, :blank)
   end
 
   def test_generate_message_blank_with_custom_message
-    assert_equal 'custom message', @person.errors.generate_message(:title, :blank, :default => 'custom message')
+    assert_equal 'custom message', @person.errors.generate_message(:title, :blank, :message => 'custom message')
   end
 
-  # validates_length_of: generate_message(attr, :too_long, :default => options[:too_long], :count => option_value.end)
+  # validates_length_of: generate_message(attr, :too_long, :message => custom_message, :count => option_value.end)
   def test_generate_message_too_long_with_default_message
-    assert_equal "is too long (maximum is 10 characters)", @person.errors.generate_message(:title, :too_long, :default => nil, :count => 10)
+    assert_equal "is too long (maximum is 10 characters)", @person.errors.generate_message(:title, :too_long, :count => 10)
   end
 
   def test_generate_message_too_long_with_custom_message
-    assert_equal 'custom message 10', @person.errors.generate_message(:title, :too_long, :default => 'custom message %{count}', :count => 10)
+    assert_equal 'custom message 10', @person.errors.generate_message(:title, :too_long, :message => 'custom message %{count}', :count => 10)
   end
 
-  # validates_length_of: generate_message(attr, :too_short, :default => options[:too_short], :count => option_value.begin)
+  # validates_length_of: generate_message(attr, :too_short, :default => custom_message, :count => option_value.begin)
   def test_generate_message_too_short_with_default_message
-    assert_equal "is too short (minimum is 10 characters)", @person.errors.generate_message(:title, :too_short, :default => nil, :count => 10)
+    assert_equal "is too short (minimum is 10 characters)", @person.errors.generate_message(:title, :too_short, :count => 10)
   end
 
   def test_generate_message_too_short_with_custom_message
-    assert_equal 'custom message 10', @person.errors.generate_message(:title, :too_short, :default => 'custom message %{count}', :count => 10)
+    assert_equal 'custom message 10', @person.errors.generate_message(:title, :too_short, :message => 'custom message %{count}', :count => 10)
   end
 
-  # validates_length_of: generate_message(attr, key, :default => custom_message, :count => option_value)
+  # validates_length_of: generate_message(attr, :wrong_length, :message => custom_message, :count => option_value)
   def test_generate_message_wrong_length_with_default_message
-    assert_equal "is the wrong length (should be 10 characters)", @person.errors.generate_message(:title, :wrong_length, :default => nil, :count => 10)
+    assert_equal "is the wrong length (should be 10 characters)", @person.errors.generate_message(:title, :wrong_length, :count => 10)
   end
 
   def test_generate_message_wrong_length_with_custom_message
-    assert_equal 'custom message 10', @person.errors.generate_message(:title, :wrong_length, :default => 'custom message %{count}', :count => 10)
+    assert_equal 'custom message 10', @person.errors.generate_message(:title, :wrong_length, :message => 'custom message %{count}', :count => 10)
   end
 
-  # validates_numericality_of: generate_message(attr_name, :not_a_number, :value => raw_value, :default => configuration[:message])
+  # validates_numericality_of: generate_message(attr_name, :not_a_number, :value => raw_value, :message => custom_message)
   def test_generate_message_not_a_number_with_default_message
-    assert_equal "is not a number", @person.errors.generate_message(:title, :not_a_number, :default => nil, :value => 'title')
+    assert_equal "is not a number", @person.errors.generate_message(:title, :not_a_number, :value => 'title')
   end
 
   def test_generate_message_not_a_number_with_custom_message
-    assert_equal 'custom message title', @person.errors.generate_message(:title, :not_a_number, :default => 'custom message %{value}', :value => 'title')
+    assert_equal 'custom message title', @person.errors.generate_message(:title, :not_a_number, :message => 'custom message %{value}', :value => 'title')
   end
 
-  # validates_numericality_of: generate_message(attr_name, option, :value => raw_value, :default => configuration[:message])
+  # validates_numericality_of: generate_message(attr_name, option, :value => raw_value, :default => custom_message)
   def test_generate_message_greater_than_with_default_message
-    assert_equal "must be greater than 10", @person.errors.generate_message(:title, :greater_than, :default => nil, :value => 'title', :count => 10)
+    assert_equal "must be greater than 10", @person.errors.generate_message(:title, :greater_than, :value => 'title', :count => 10)
   end
 
   def test_generate_message_greater_than_or_equal_to_with_default_message
-    assert_equal "must be greater than or equal to 10", @person.errors.generate_message(:title, :greater_than_or_equal_to, :default => nil, :value => 'title', :count => 10)
+    assert_equal "must be greater than or equal to 10", @person.errors.generate_message(:title, :greater_than_or_equal_to, :value => 'title', :count => 10)
   end
 
   def test_generate_message_equal_to_with_default_message
-    assert_equal "must be equal to 10", @person.errors.generate_message(:title, :equal_to, :default => nil, :value => 'title', :count => 10)
+    assert_equal "must be equal to 10", @person.errors.generate_message(:title, :equal_to, :value => 'title', :count => 10)
   end
 
   def test_generate_message_less_than_with_default_message
-    assert_equal "must be less than 10", @person.errors.generate_message(:title, :less_than, :default => nil, :value => 'title', :count => 10)
+    assert_equal "must be less than 10", @person.errors.generate_message(:title, :less_than, :value => 'title', :count => 10)
   end
 
   def test_generate_message_less_than_or_equal_to_with_default_message
-    assert_equal "must be less than or equal to 10", @person.errors.generate_message(:title, :less_than_or_equal_to, :default => nil, :value => 'title', :count => 10)
+    assert_equal "must be less than or equal to 10", @person.errors.generate_message(:title, :less_than_or_equal_to, :value => 'title', :count => 10)
   end
 
   def test_generate_message_odd_with_default_message
-    assert_equal "must be odd", @person.errors.generate_message(:title, :odd, :default => nil, :value => 'title', :count => 10)
+    assert_equal "must be odd", @person.errors.generate_message(:title, :odd, :value => 'title', :count => 10)
   end
 
   def test_generate_message_even_with_default_message
-    assert_equal "must be even", @person.errors.generate_message(:title, :even, :default => nil, :value => 'title', :count => 10)
+    assert_equal "must be even", @person.errors.generate_message(:title, :even, :value => 'title', :count => 10)
   end
 end
diff --git a/activemodel/test/cases/validations/i18n_validation_test.rb b/activemodel/test/cases/validations/i18n_validation_test.rb
index 547d80f46e..eff2b78e74 100644
--- a/activemodel/test/cases/validations/i18n_validation_test.rb
+++ b/activemodel/test/cases/validations/i18n_validation_test.rb
@@ -22,23 +22,23 @@ class I18nValidationTest < ActiveModel::TestCase
   end
 
   def test_errors_add_on_empty_generates_message
-    @person.errors.expects(:generate_message).with(:title, :empty, {:default => nil})
+    @person.errors.expects(:generate_message).with(:title, :empty, {})
     @person.errors.add_on_empty :title
   end
 
   def test_errors_add_on_empty_generates_message_with_custom_default_message
-    @person.errors.expects(:generate_message).with(:title, :empty, {:default => 'custom'})
-    @person.errors.add_on_empty :title, 'custom'
+    @person.errors.expects(:generate_message).with(:title, :empty, {:message => 'custom'})
+    @person.errors.add_on_empty :title, :message => 'custom'
   end
 
   def test_errors_add_on_blank_generates_message
-    @person.errors.expects(:generate_message).with(:title, :blank, {:default => nil})
+    @person.errors.expects(:generate_message).with(:title, :blank, {})
     @person.errors.add_on_blank :title
   end
 
   def test_errors_add_on_blank_generates_message_with_custom_default_message
-    @person.errors.expects(:generate_message).with(:title, :blank, {:default => 'custom'})
-    @person.errors.add_on_blank :title, 'custom'
+    @person.errors.expects(:generate_message).with(:title, :blank, {:message => 'custom'})
+    @person.errors.add_on_blank :title, :message => 'custom'
   end
 
   def test_full_message_encoding
@@ -66,14 +66,14 @@ class I18nValidationTest < ActiveModel::TestCase
   def test_validates_confirmation_of_generates_message
     Person.validates_confirmation_of :title
     @person.title_confirmation = 'foo'
-    @person.errors.expects(:generate_message).with(:title, :confirmation, {:default => nil})
+    @person.errors.expects(:generate_message).with(:title, :confirmation, {})
     @person.valid?
   end
 
   def test_validates_confirmation_of_generates_message_with_custom_default_message
     Person.validates_confirmation_of :title, :message => 'custom'
     @person.title_confirmation = 'foo'
-    @person.errors.expects(:generate_message).with(:title, :confirmation, {:default => 'custom'})
+    @person.errors.expects(:generate_message).with(:title, :confirmation, {:message => 'custom'})
     @person.valid?
   end
 
@@ -81,13 +81,13 @@ class I18nValidationTest < ActiveModel::TestCase
 
   def test_validates_acceptance_of_generates_message
     Person.validates_acceptance_of :title, :allow_nil => false
-    @person.errors.expects(:generate_message).with(:title, :accepted, {:default => nil})
+    @person.errors.expects(:generate_message).with(:title, :accepted, {})
     @person.valid?
   end
 
   def test_validates_acceptance_of_generates_message_with_custom_default_message
     Person.validates_acceptance_of :title, :message => 'custom', :allow_nil => false
-    @person.errors.expects(:generate_message).with(:title, :accepted, {:default => 'custom'})
+    @person.errors.expects(:generate_message).with(:title, :accepted, {:message => 'custom'})
     @person.valid?
   end
 
@@ -95,13 +95,13 @@ class I18nValidationTest < ActiveModel::TestCase
 
   def test_validates_presence_of_generates_message
     Person.validates_presence_of :title
-    @person.errors.expects(:generate_message).with(:title, :blank, {:default => nil})
+    @person.errors.expects(:generate_message).with(:title, :blank, {})
     @person.valid?
   end
 
   def test_validates_presence_of_generates_message_with_custom_default_message
     Person.validates_presence_of :title, :message => 'custom'
-    @person.errors.expects(:generate_message).with(:title, :blank, {:default => 'custom'})
+    @person.errors.expects(:generate_message).with(:title, :blank, {:message => 'custom'})
     @person.valid?
   end
 
@@ -109,27 +109,27 @@ class I18nValidationTest < ActiveModel::TestCase
 
   def test_validates_length_of_within_generates_message_with_title_too_short
     Person.validates_length_of :title, :within => 3..5
-    @person.errors.expects(:generate_message).with(:title, :too_short, {:count => 3, :default => nil})
+    @person.errors.expects(:generate_message).with(:title, :too_short, {:count => 3})
     @person.valid?
   end
 
   def test_validates_length_of_within_generates_message_with_title_too_short_and_custom_default_message
     Person.validates_length_of :title, :within => 3..5, :too_short => 'custom'
-    @person.errors.expects(:generate_message).with(:title, :too_short, {:count => 3, :default => 'custom'})
+    @person.errors.expects(:generate_message).with(:title, :too_short, {:count => 3, :message => 'custom'})
     @person.valid?
   end
 
   def test_validates_length_of_within_generates_message_with_title_too_long
     Person.validates_length_of :title, :within => 3..5
     @person.title = 'this title is too long'
-    @person.errors.expects(:generate_message).with(:title, :too_long, {:count => 5, :default => nil})
+    @person.errors.expects(:generate_message).with(:title, :too_long, {:count => 5})
     @person.valid?
   end
 
   def test_validates_length_of_within_generates_message_with_title_too_long_and_custom_default_message
     Person.validates_length_of :title, :within => 3..5, :too_long => 'custom'
     @person.title = 'this title is too long'
-    @person.errors.expects(:generate_message).with(:title, :too_long, {:count => 5, :default => 'custom'})
+    @person.errors.expects(:generate_message).with(:title, :too_long, {:count => 5, :message => 'custom'})
     @person.valid?
   end
 
@@ -137,13 +137,13 @@ class I18nValidationTest < ActiveModel::TestCase
 
   def test_validates_length_of_is_generates_message
     Person.validates_length_of :title, :is => 5
-    @person.errors.expects(:generate_message).with(:title, :wrong_length, {:count => 5, :default => nil})
+    @person.errors.expects(:generate_message).with(:title, :wrong_length, {:count => 5})
     @person.valid?
   end
 
   def test_validates_length_of_is_generates_message_with_custom_default_message
     Person.validates_length_of :title, :is => 5, :message => 'custom'
-    @person.errors.expects(:generate_message).with(:title, :wrong_length, {:count => 5, :default => 'custom'})
+    @person.errors.expects(:generate_message).with(:title, :wrong_length, {:count => 5, :message => 'custom'})
     @person.valid?
   end
 
@@ -152,14 +152,14 @@ class I18nValidationTest < ActiveModel::TestCase
   def test_validates_format_of_generates_message
     Person.validates_format_of :title, :with => /^[1-9][0-9]*$/
     @person.title = '72x'
-    @person.errors.expects(:generate_message).with(:title, :invalid, {:value => '72x', :default => nil})
+    @person.errors.expects(:generate_message).with(:title, :invalid, {:value => '72x'})
     @person.valid?
   end
 
   def test_validates_format_of_generates_message_with_custom_default_message
     Person.validates_format_of :title, :with => /^[1-9][0-9]*$/, :message => 'custom'
     @person.title = '72x'
-    @person.errors.expects(:generate_message).with(:title, :invalid, {:value => '72x', :default => 'custom'})
+    @person.errors.expects(:generate_message).with(:title, :invalid, {:value => '72x', :message => 'custom'})
     @person.valid?
   end
 
@@ -168,14 +168,14 @@ class I18nValidationTest < ActiveModel::TestCase
   def test_validates_inclusion_of_generates_message
     Person.validates_inclusion_of :title, :in => %w(a b c)
     @person.title = 'z'
-    @person.errors.expects(:generate_message).with(:title, :inclusion, {:value => 'z', :default => nil})
+    @person.errors.expects(:generate_message).with(:title, :inclusion, {:value => 'z'})
     @person.valid?
   end
 
   def test_validates_inclusion_of_generates_message_with_custom_default_message
     Person.validates_inclusion_of :title, :in => %w(a b c), :message => 'custom'
     @person.title = 'z'
-    @person.errors.expects(:generate_message).with(:title, :inclusion, {:value => 'z', :default => 'custom'})
+    @person.errors.expects(:generate_message).with(:title, :inclusion, {:value => 'z', :message => 'custom'})
     @person.valid?
   end
 
@@ -184,14 +184,14 @@ class I18nValidationTest < ActiveModel::TestCase
   def test_validates_exclusion_of_generates_message
     Person.validates_exclusion_of :title, :in => %w(a b c)
     @person.title = 'a'
-    @person.errors.expects(:generate_message).with(:title, :exclusion, {:value => 'a', :default => nil})
+    @person.errors.expects(:generate_message).with(:title, :exclusion, {:value => 'a'})
     @person.valid?
   end
 
   def test_validates_exclusion_of_generates_message_with_custom_default_message
     Person.validates_exclusion_of :title, :in => %w(a b c), :message => 'custom'
     @person.title = 'a'
-    @person.errors.expects(:generate_message).with(:title, :exclusion, {:value => 'a', :default => 'custom'})
+    @person.errors.expects(:generate_message).with(:title, :exclusion, {:value => 'a', :message => 'custom'})
     @person.valid?
   end
 
@@ -200,14 +200,14 @@ class I18nValidationTest < ActiveModel::TestCase
   def test_validates_numericality_of_generates_message
     Person.validates_numericality_of :title
     @person.title = 'a'
-    @person.errors.expects(:generate_message).with(:title, :not_a_number, {:value => 'a', :default => nil})
+    @person.errors.expects(:generate_message).with(:title, :not_a_number, {:value => 'a'})
     @person.valid?
   end
 
   def test_validates_numericality_of_generates_message_with_custom_default_message
     Person.validates_numericality_of :title, :message => 'custom'
     @person.title = 'a'
-    @person.errors.expects(:generate_message).with(:title, :not_a_number, {:value => 'a', :default => 'custom'})
+    @person.errors.expects(:generate_message).with(:title, :not_a_number, {:value => 'a', :message => 'custom'})
     @person.valid?
   end
 
@@ -216,14 +216,14 @@ class I18nValidationTest < ActiveModel::TestCase
   def test_validates_numericality_of_only_integer_generates_message
     Person.validates_numericality_of :title, :only_integer => true
     @person.title = '0.0'
-    @person.errors.expects(:generate_message).with(:title, :not_an_integer, {:value => '0.0', :default => nil})
+    @person.errors.expects(:generate_message).with(:title, :not_an_integer, {:value => '0.0'})
     @person.valid?
   end
 
   def test_validates_numericality_of_only_integer_generates_message_with_custom_default_message
     Person.validates_numericality_of :title, :only_integer => true, :message => 'custom'
     @person.title = '0.0'
-    @person.errors.expects(:generate_message).with(:title, :not_an_integer, {:value => '0.0', :default => 'custom'})
+    @person.errors.expects(:generate_message).with(:title, :not_an_integer, {:value => '0.0', :message => 'custom'})
     @person.valid?
   end
 
@@ -232,14 +232,14 @@ class I18nValidationTest < ActiveModel::TestCase
   def test_validates_numericality_of_odd_generates_message
     Person.validates_numericality_of :title, :only_integer => true, :odd => true
     @person.title = 0
-    @person.errors.expects(:generate_message).with(:title, :odd, {:value => 0, :default => nil})
+    @person.errors.expects(:generate_message).with(:title, :odd, {:value => 0})
     @person.valid?
   end
 
   def test_validates_numericality_of_odd_generates_message_with_custom_default_message
     Person.validates_numericality_of :title, :only_integer => true, :odd => true, :message => 'custom'
     @person.title = 0
-    @person.errors.expects(:generate_message).with(:title, :odd, {:value => 0, :default => 'custom'})
+    @person.errors.expects(:generate_message).with(:title, :odd, {:value => 0, :message => 'custom'})
     @person.valid?
   end
 
@@ -248,14 +248,14 @@ class I18nValidationTest < ActiveModel::TestCase
   def test_validates_numericality_of_less_than_generates_message
     Person.validates_numericality_of :title, :only_integer => true, :less_than => 0
     @person.title = 1
-    @person.errors.expects(:generate_message).with(:title, :less_than, {:value => 1, :count => 0, :default => nil})
+    @person.errors.expects(:generate_message).with(:title, :less_than, {:value => 1, :count => 0})
     @person.valid?
   end
 
   def test_validates_numericality_of_less_than_odd_generates_message_with_custom_default_message
     Person.validates_numericality_of :title, :only_integer => true, :less_than => 0, :message => 'custom'
     @person.title = 1
-    @person.errors.expects(:generate_message).with(:title, :less_than, {:value => 1, :count => 0, :default => 'custom'})
+    @person.errors.expects(:generate_message).with(:title, :less_than, {:value => 1, :count => 0, :message => 'custom'})
     @person.valid?
   end