Make the error message for additionals prettier

Julian · Julian · commit e169504250e7 · 2012-01-30T22:03:42.000-05:00
Also fixes an unexpected bug in additionalItems.
diff --git a/jsonschema.py b/jsonschema.py
@@ -308,7 +308,8 @@ def validate_additionalProperties(self, aP, instance, schema):
             for extra in extras:
                 self._validate(instance[extra], aP)
         elif not aP and extras:
-            self._error(u"Additional properties are not allowed")
+            error = u"Additional properties are not allowed (%s %s unexpected)"
+            self._error(error % _extras_msg(extras))
 
     def validate_items(self, items, instance, schema):
         if self._is_type(items, "object"):
@@ -325,8 +326,9 @@ def validate_additionalItems(self, aI, instance, schema):
         if self._is_type(aI, "object"):
             for item in instance[len(schema):]:
                 self._validate(item, aI)
-        elif not aI and len(instance) > len(schema):
-            self._error(u"Additional items are not allowed")
+        elif not aI and len(instance) > len(schema.get("items", [])):
+            error = u"Additional items are not allowed (%s %s unexpected)"
+            self._error(error % _extras_msg(instance[len(schema) - 1:]))
 
     def validate_minimum(self, minimum, instance, schema):
         if schema.get(u"exclusiveMinimum", False):
@@ -410,6 +412,19 @@ def validate_disallow(self, disallow, instance, schema):
             )
 
 
+def _extras_msg(extras):
+    """
+    Create an error message for extra items or properties.
+
+    """
+
+    if len(extras) == 1:
+        verb = u"was"
+    else:
+        verb = u"were"
+    return u", ".join(repr(extra) for extra in extras), verb
+
+
 def _list(thing):
     """
     Wrap ``thing`` in a list if it's a single str.
diff --git a/tests.py b/tests.py
@@ -258,6 +258,21 @@ def additionalProperties(self, aP):
     def test_additionalProperties_ignores_nonobjects(self):
         validate(None, {"additionalProperties" : False})
 
+    @parametrized(
+        ("single_extra", {"foo" : 2}, ["('foo' was unexpected)"]),
+        ("multiple_extras",
+         dict.fromkeys(["foo", "bar", "quux"]),
+         ["'bar'", "'foo'", "'quux'", "were unexpected)"],
+        ),
+    )
+    def additionalProperties_errorMessage(self, instance, errs):
+        schema = {"additionalProperties" : False}
+
+        with self.assertRaises(ValidationError) as error:
+            validate(instance, schema)
+
+        self.assertTrue(all(err in error.exception.message for err in errs))
+
     items = parametrized(
         ("", "valid", [1, 2, 3]),
         ("wrong_type", "invalid", [1, u"x"]),
@@ -293,6 +308,16 @@ def test_additionalItems_allowed_by_default(self):
     def test_additionalItems_ignores_nonarrays(self):
         validate(None, {"additionalItems" : False})
 
+    @parametrized(
+        ("single_extra", [2], "(2 was unexpected)"),
+        ("multiple_extras", [1, 2, 3], "(1, 2, 3 were unexpected)"),
+    )
+    def additionalItems_errorMessage(self, instance, err):
+        schema = {"additionalItems" : False}
+        self.assertRaisesRegexp(
+            ValidationError, err, validate, instance, schema
+        )
+
     @parametrized(
         ("false_by_default", "valid", {}, {}),
         ("false_explicit", "valid", {u"required" : False}, {}),
