1 files changed, 144 insertions, 115 deletions

diff --git a/activemodel/test/cases/errors_test.rb b/activemodel/test/cases/errors_test.rb
index f6d171bec6..185b5a24ae 100644
--- a/activemodel/test/cases/errors_test.rb
+++ b/activemodel/test/cases/errors_test.rb
@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "yaml"
 
 class ErrorsTest < ActiveModel::TestCase
   class Person
@@ -11,7 +14,7 @@ class ErrorsTest < ActiveModel::TestCase
     attr_reader   :errors
 
     def validate!
-      errors.add(:name, "cannot be nil") if name == nil
+      errors.add(:name, :blank, message: "cannot be nil") if name == nil
     end
 
     def read_attribute_for_validation(attr)
@@ -29,45 +32,48 @@ class ErrorsTest < ActiveModel::TestCase
 
   def test_delete
     errors = ActiveModel::Errors.new(self)
-    errors[:foo] << 'omg'
-    errors.delete(:foo)
+    errors[:foo] << "omg"
+    errors.delete("foo")
     assert_empty errors[:foo]
   end
 
   def test_include?
     errors = ActiveModel::Errors.new(self)
-    errors[:foo] << 'omg'
-    assert errors.include?(:foo), 'errors should include :foo'
+    errors[:foo] << "omg"
+    assert_includes errors, :foo, "errors should include :foo"
+    assert_includes errors, "foo", "errors should include 'foo' as :foo"
   end
 
   def test_dup
     errors = ActiveModel::Errors.new(self)
-    errors[:foo] << 'bar'
+    errors[:foo] << "bar"
     errors_dup = errors.dup
-    errors_dup[:bar] << 'omg'
+    errors_dup[:bar] << "omg"
     assert_not_same errors_dup.messages, errors.messages
   end
 
   def test_has_key?
     errors = ActiveModel::Errors.new(self)
-    errors[:foo] << 'omg'
-    assert_equal true, errors.has_key?(:foo), 'errors should have key :foo'
+    errors[:foo] << "omg"
+    assert_equal true, errors.has_key?(:foo), "errors should have key :foo"
+    assert_equal true, errors.has_key?("foo"), "errors should have key 'foo' as :foo"
   end
 
   def test_has_no_key
     errors = ActiveModel::Errors.new(self)
-    assert_equal false, errors.has_key?(:name), 'errors should not have key :name'
+    assert_equal false, errors.has_key?(:name), "errors should not have key :name"
   end
 
   def test_key?
     errors = ActiveModel::Errors.new(self)
-    errors[:foo] << 'omg'
-    assert_equal true, errors.key?(:foo), 'errors should have key :foo'
+    errors[:foo] << "omg"
+    assert_equal true, errors.key?(:foo), "errors should have key :foo"
+    assert_equal true, errors.key?("foo"), "errors should have key 'foo' as :foo"
   end
 
   def test_no_key
     errors = ActiveModel::Errors.new(self)
-    assert_equal false, errors.key?(:name), 'errors should not have key :name'
+    assert_equal false, errors.key?(:name), "errors should not have key :name"
   end
 
   test "clear errors" do
@@ -76,25 +82,7 @@ class ErrorsTest < ActiveModel::TestCase
 
     assert_equal 1, person.errors.count
     person.errors.clear
-    assert person.errors.empty?
-  end
-
-  test "get returns the errors for the provided key" do
-    errors = ActiveModel::Errors.new(self)
-    errors[:foo] << "omg"
-
-    assert_deprecated do
-      assert_equal ["omg"], errors.get(:foo)
-    end
-  end
-
-  test "sets the error with the provided key" do
-    errors = ActiveModel::Errors.new(self)
-    assert_deprecated do
-      errors.set(:foo, "omg")
-    end
-
-    assert_equal({ foo: "omg" }, errors.messages)
+    assert_empty person.errors
   end
 
   test "error access is indifferent" do
@@ -112,6 +100,14 @@ class ErrorsTest < ActiveModel::TestCase
     assert_equal ["omg", "zomg"], errors.values
   end
 
+  test "values returns an empty array after try to get a message only" do
+    errors = ActiveModel::Errors.new(self)
+    errors.messages[:foo]
+    errors.messages[:baz]
+
+    assert_equal [], errors.values
+  end
+
   test "keys returns the error keys" do
     errors = ActiveModel::Errors.new(self)
     errors.messages[:foo] << "omg"
@@ -120,12 +116,27 @@ class ErrorsTest < ActiveModel::TestCase
     assert_equal [:foo, :baz], errors.keys
   end
 
+  test "keys returns an empty array after try to get a message only" do
+    errors = ActiveModel::Errors.new(self)
+    errors.messages[:foo]
+    errors.messages[:baz]
+
+    assert_equal [], errors.keys
+  end
+
   test "detecting whether there are errors with empty?, blank?, include?" do
     person = Person.new
     person.errors[:foo]
-    assert person.errors.empty?
-    assert person.errors.blank?
-    assert !person.errors.include?(:foo)
+    assert_empty person.errors
+    assert_predicate person.errors, :blank?
+    assert_not_includes person.errors, :foo
+  end
+
+  test "include? does not add a key to messages hash" do
+    person = Person.new
+    person.errors.include?(:foo)
+
+    assert_not person.errors.messages.key?(:foo)
   end
 
   test "adding errors using conditionals with Person#validate!" do
@@ -135,14 +146,6 @@ class ErrorsTest < ActiveModel::TestCase
     assert_equal ["cannot be nil"], person.errors[:name]
   end
 
-  test "assign error" do
-    person = Person.new
-    assert_deprecated do
-      person.errors[:name] = 'should not be nil'
-    end
-    assert_equal ["should not be nil"], person.errors[:name]
-  end
-
   test "add an error message on a specific attribute" do
     person = Person.new
     person.errors.add(:name, "cannot be blank")
@@ -169,10 +172,11 @@ class ErrorsTest < ActiveModel::TestCase
     assert_equal ["cannot be blank"], person.errors[:name]
   end
 
-  test "added? detects if a specific error was added to the object" do
+  test "added? detects indifferent if a specific error was added to the object" do
     person = Person.new
     person.errors.add(:name, "cannot be blank")
     assert person.errors.added?(:name, "cannot be blank")
+    assert person.errors.added?("name", "cannot be blank")
   end
 
   test "added? handles symbol message" do
@@ -181,6 +185,12 @@ class ErrorsTest < ActiveModel::TestCase
     assert person.errors.added?(:name, :blank)
   end
 
+  test "added? returns true when string attribute is used with a symbol message" do
+    person = Person.new
+    person.errors.add(:name, :blank)
+    assert person.errors.added?("name", :blank)
+  end
+
   test "added? handles proc messages" do
     person = Person.new
     message = Proc.new { "cannot be blank" }
@@ -203,13 +213,36 @@ class ErrorsTest < ActiveModel::TestCase
 
   test "added? returns false when no errors are present" do
     person = Person.new
-    assert !person.errors.added?(:name)
+    assert_not person.errors.added?(:name)
   end
 
   test "added? returns false when checking a nonexisting error and other errors are present for the given attribute" do
     person = Person.new
     person.errors.add(:name, "is invalid")
-    assert !person.errors.added?(:name, "cannot be blank")
+    assert_not person.errors.added?(:name, "cannot be blank")
+  end
+
+  test "added? returns false when checking for an error, but not providing message arguments" do
+    person = Person.new
+    person.errors.add(:name, "cannot be blank")
+    assert_not person.errors.added?(:name)
+  end
+
+  test "added? returns false when checking for an error with an incorrect or missing option" do
+    person = Person.new
+    person.errors.add :name, :too_long, count: 25
+
+    assert person.errors.added? :name, :too_long, count: 25
+    assert_not person.errors.added? :name, :too_long, count: 24
+    assert_not person.errors.added? :name, :too_long
+    assert_not person.errors.added? :name, "is too long"
+  end
+
+  test "added? returns false when checking for an error by symbol and a different error with same message is present" do
+    I18n.backend.store_translations("en", errors: { attributes: { name: { wrong: "is wrong", used: "is wrong" } } })
+    person = Person.new
+    person.errors.add(:name, :wrong)
+    assert_not person.errors.added?(:name, :used)
   end
 
   test "size calculates the number of error messages" do
@@ -237,6 +270,16 @@ class ErrorsTest < ActiveModel::TestCase
     assert_equal({ name: ["cannot be blank"] }, person.errors.to_hash)
   end
 
+  test "to_hash returns a hash without default proc" do
+    person = Person.new
+    assert_nil person.errors.to_hash.default_proc
+  end
+
+  test "as_json returns a hash without default proc" do
+    person = Person.new
+    assert_nil person.errors.as_json.default_proc
+  end
+
   test "full_messages creates a list of error messages with the attribute name included" do
     person = Person.new
     person.errors.add(:name, "cannot be blank")
@@ -244,7 +287,7 @@ class ErrorsTest < ActiveModel::TestCase
     assert_equal ["name cannot be blank", "name cannot be nil"], person.errors.full_messages
   end
 
-  test "full_messages_for contains all the error messages for the given attribute" do
+  test "full_messages_for contains all the error messages for the given attribute indifferent" do
     person = Person.new
     person.errors.add(:name, "cannot be blank")
     person.errors.add(:name, "cannot be nil")
@@ -256,6 +299,7 @@ class ErrorsTest < ActiveModel::TestCase
     person.errors.add(:name, "cannot be blank")
     person.errors.add(:email, "cannot be blank")
     assert_equal ["name cannot be blank"], person.errors.full_messages_for(:name)
+    assert_equal ["name cannot be blank"], person.errors.full_messages_for("name")
   end
 
   test "full_messages_for returns an empty list in case there are no errors for the given attribute" do
@@ -291,78 +335,12 @@ class ErrorsTest < ActiveModel::TestCase
 
   test "generate_message works without i18n_scope" do
     person = Person.new
-    assert !Person.respond_to?(:i18n_scope)
+    assert_not_respond_to Person, :i18n_scope
     assert_nothing_raised {
       person.errors.generate_message(:name, :blank)
     }
   end
 
-  test "add_on_empty generates message" do
-    person = Person.new
-    assert_called_with(person.errors, :generate_message, [:name, :empty, {}]) do
-      assert_deprecated do
-        person.errors.add_on_empty :name
-      end
-    end
-  end
-
-  test "add_on_empty generates message for multiple attributes" do
-    person = Person.new
-    expected_calls = [ [:name, :empty, {}], [:age, :empty, {}] ]
-    assert_called_with(person.errors, :generate_message, expected_calls) do
-      assert_deprecated do
-        person.errors.add_on_empty [:name, :age]
-      end
-    end
-  end
-
-  test "add_on_empty generates message with custom default message" do
-    person = Person.new
-    assert_called_with(person.errors, :generate_message, [:name, :empty, { message: 'custom' }]) do
-      assert_deprecated do
-        person.errors.add_on_empty :name, message: 'custom'
-      end
-    end
-  end
-
-  test "add_on_empty generates message with empty string value" do
-    person = Person.new
-    person.name = ''
-    assert_called_with(person.errors, :generate_message, [:name, :empty, {}]) do
-      assert_deprecated do
-        person.errors.add_on_empty :name
-      end
-    end
-  end
-
-  test "add_on_blank generates message" do
-    person = Person.new
-    assert_called_with(person.errors, :generate_message, [:name, :blank, {}]) do
-      assert_deprecated do
-        person.errors.add_on_blank :name
-      end
-    end
-  end
-
-  test "add_on_blank generates message for multiple attributes" do
-    person = Person.new
-    expected_calls = [ [:name, :blank, {}], [:age, :blank, {}] ]
-    assert_called_with(person.errors, :generate_message, expected_calls) do
-      assert_deprecated do
-        person.errors.add_on_blank [:name, :age]
-      end
-    end
-  end
-
-  test "add_on_blank generates message with custom default message" do
-    person = Person.new
-    assert_called_with(person.errors, :generate_message, [:name, :blank, { message: 'custom' }]) do
-      assert_deprecated do
-        person.errors.add_on_blank :name, message: 'custom'
-      end
-    end
-  end
-
   test "details returns added error detail" do
     person = Person.new
     person.errors.add(:name, :invalid)
@@ -408,6 +386,57 @@ class ErrorsTest < ActiveModel::TestCase
 
     assert_equal 1, person.errors.details.count
     person.errors.clear
-    assert person.errors.details.empty?
+    assert_empty person.errors.details
+  end
+
+  test "copy errors" do
+    errors = ActiveModel::Errors.new(Person.new)
+    errors.add(:name, :invalid)
+    person = Person.new
+    person.errors.copy!(errors)
+
+    assert_equal [:name], person.errors.messages.keys
+    assert_equal [:name], person.errors.details.keys
+  end
+
+  test "merge errors" do
+    errors = ActiveModel::Errors.new(Person.new)
+    errors.add(:name, :invalid)
+
+    person = Person.new
+    person.errors.add(:name, :blank)
+    person.errors.merge!(errors)
+
+    assert_equal({ name: ["can't be blank", "is invalid"] }, person.errors.messages)
+    assert_equal({ name: [{ error: :blank }, { error: :invalid }] }, person.errors.details)
+  end
+
+  test "errors are marshalable" do
+    errors = ActiveModel::Errors.new(Person.new)
+    errors.add(:name, :invalid)
+    serialized = Marshal.load(Marshal.dump(errors))
+
+    assert_equal errors.messages, serialized.messages
+    assert_equal errors.details, serialized.details
+  end
+
+  test "errors are backward compatible with the Rails 4.2 format" do
+    yaml = <<~CODE
+    --- !ruby/object:ActiveModel::Errors
+    base: &1 !ruby/object:ErrorsTest::Person
+      errors: !ruby/object:ActiveModel::Errors
+        base: *1
+        messages: {}
+    messages: {}
+    CODE
+
+    errors = YAML.load(yaml)
+    errors.add(:name, :invalid)
+    assert_equal({ name: ["is invalid"] }, errors.messages)
+    assert_equal({ name: [{ error: :invalid }] }, errors.details)
+
+    errors.clear
+    assert_equal({}, errors.messages)
+    assert_equal({}, errors.details)
   end
 end