Merge lp:~zyga/linaro-python-json/schema-and-object-tracing into lp:linaro-python-json

[Zygmunt Krynicki]

This branch contains all the code necessary to make use of linaro-python-json in launch-control to validate our dashboard bundle schema.

There are two separate changes:

1) The big change is error reporting. Previously there was a rather verbose dunp of JSON and a murky message what failed to validate (previously in this branch, in launch-control it was even worse). This has been changed to have a very short and concrete message of what the failure is (most of the time it's a constant string, rarely parametrized by expected data type). To allow the user or software to look up the offending piece of data and schema there are two new properties on ValidationError: object_expr and schema_expr. Each one gives a JavaScript expression that if evaluated against the data or schema objects yields the part that failed to validate. It can be thought as extremely simple xpath query.

All existing unit tests are _extended_ (not changed) so that they inspect the ValidationError for the new_message, object_expr and schema_expr and compare them against expected good values. Reading the unit tests also gives a good overview of how the error reporting messages look like and that it's actually helpful and easy to find the relevant fragment of data.

2) The minor change that I just lumped together is minimal support for "format" schema. In particular the "data-time" format is now supported allowing us to validate data that should express JSON date time objects. The code is very small and comes with unit tests for both good and bad cases. More information about this feature is here: http://tools.ietf.org/html/draft-zyp-json-schema-02#section-5.20

[lp:~zyga/linaro-python-json/schema-and-object-tracing]

107. By Zygmunt Krynicki on 2010-11-12

Remove needless newline

[James Westby (james-w)]

review: Approve

=== modified file 'linaro_json/schema.py'
--- linaro_json/schema.py	2010-11-09 14:35:30 +0000
+++ linaro_json/schema.py	2010-11-12 14:13:07 +0000
@@ -5,6 +5,7 @@
 
 See: json-schema.org for details
 """
+import datetime
 import decimal
 import itertools
 import re
@@ -23,9 +24,33 @@
 
 class ValidationError(ValueError):
     """
-    A bug in the validated object prevents the program from working
+    A bug in the validated object prevents the program from working.
+
+    The error instance has several interesting properties:
+        :message: old and verbose message that contains less helpful
+        message and lots of JSON data (deprecated).
+        :new_message: short and concise message about the problem
+        :object_expr: a JavaScript expression that evaluates to the
+        object that failed to validate. The expression always starts
+        with a root object called 'object'.
+        :schema_expr: a JavaScript expression that evaluats to the
+        schema that was checked at the time validation failed. The
+        expression always starts with a root object called 'schema'.
     """
 
+    def __init__(self, message, new_message=None,
+                 object_expr=None, schema_expr=None):
+        self.message = message
+        self.new_message = new_message
+        self.object_expr = object_expr
+        self.schema_expr = schema_expr
+
+    def __cmp__(self, other):
+        return cmp(self.message, other.message) or cmp(self.new_message, self.other_messge)
+
+    def __repr__(self):
+        return self.message
+
 
 class Schema(object):
     """
@@ -391,7 +416,28 @@
     }
 
     def __init__(self):
-        self._obj_stack = []
+        self._schema_stack = []
+        self._object_stack = []
+
+    def _push_object(self, obj, path):
+        self._object_stack.append((obj, path))
+
+    def _pop_object(self):
+        self._object_stack.pop()
+
+    def _push_schema(self, schema, path):
+        self._schema_stack.append((schema, path))
+
+    def _pop_schema(self):
+        self._schema_stack.pop()
+
+    @property
+    def _object(self):
+        return self._object_stack[-1][0]
+
+    @property
+    def _schema(self):
+        return self._schema_stack[-1][0]
 
     @classmethod
     def validate(cls, schema, obj):
@@ -407,33 +453,91 @@
             raise ValueError(
                 "schema value {0!r} is not a Schema"
                 " object".format(schema))
-        cls()._validate_no_push(schema, obj)
+        self = cls()
+        self.validate_toplevel(schema, obj)
         return True
 
-    def _validate(self, schema, obj):
-        self._obj_stack.append(obj)
-        try:
-            self._validate_no_push(schema, obj)
-        finally:
-            self._obj_stack.pop()
-
-    def _validate_no_push(self, schema, obj):
-        self._validate_type(schema, obj)
-        self._validate_requires(schema, obj)
+    def _get_object_expression(self):
+        return "".join(map(lambda x: x[1], self._object_stack))
+
+    def _get_schema_expression(self):
+        return "".join(map(lambda x: x[1], self._schema_stack))
+
+    def validate_toplevel(self, schema, obj):
+        self._object_stack = []
+        self._schema_stack = []
+        self._push_schema(schema, "schema")
+        self._push_object(obj, "object")
+        self._validate()
+        self._pop_schema()
+        self._pop_object()
+
+    def _validate(self):
+        obj = self._object
+        self._validate_type()
+        self._validate_requires()
         if isinstance(obj, dict):
-            self._obj_stack.append(obj)
-            self._validate_properties(schema, obj)
-            self._validate_additional_properties(schema, obj)
-            self._obj_stack.pop()
+            self._validate_properties()
+            self._validate_additional_properties()
         elif isinstance(obj, list):
-            self._obj_stack.append(obj)
-            self._validate_items(schema, obj)
-            self._obj_stack.pop()
+            self._validate_items()
         else:
-            self._validate_enum(schema, obj)
-        self._report_unsupported(schema)
-
-    def _report_unsupported(self, schema):
+            self._validate_enum()
+            self._validate_format()
+        self._report_unsupported()
+
+    def _report_error(self, legacy_message, new_message=None,
+                      object_suffix=None, schema_suffix=None):
+        """
+        Report an error during validation.
+
+        There are two error messages. The legacy message is used for
+        backwards compatibility and usually contains the object
+        (possibly very large) that failed to validate. The new message
+        is much better as it contains just a short message on what went
+        wrong. User code can inspect object_expr and schema_expr to see
+        which part of the object failed to validate against which part
+        of the schema.
+
+        The schema_suffix, if provided, is appended to the schema_expr.
+        This is quite handy to specify the bit that the validator looked
+        at (such as the type or optional flag, etc). object_suffix
+        serves the same purpose but is used for object expressions
+        instead.
+        """
+        object_expr = self._get_object_expression()
+        if object_suffix:
+            object_expr += object_suffix
+        schema_expr = self._get_schema_expression()
+        if schema_suffix:
+            schema_expr += schema_suffix
+        raise ValidationError(legacy_message, new_message,
+                              object_expr, schema_expr)
+
+    def _push_property_schema(self, prop):
+        """
+        Construct a sub-schema from the value of the specified attribute
+        of the current schema.
+        """
+        schema = Schema(self._schema.properties[prop])
+        self._push_schema(schema, ".properties." + prop)
+
+    def _push_additional_property_schema(self):
+        schema = Schema(self._schema.additionalProperties)
+        self._push_schema(schema, ".additionalProperties")
+
+    def _push_array_schema(self):
+        schema = Schema(self._schema.items)
+        self._push_schema(schema, ".items")
+
+    def _push_array_item_object(self, index):
+        self._push_object(self._object[index], "[%d]" % index)
+
+    def _push_property_object(self, prop):
+        self._push_object(self._object[prop], "." + prop)
+
+    def _report_unsupported(self):
+        schema = self._schema
         if schema.minimum is not None:
             raise NotImplementedError("minimum is not supported")
         if schema.maximum is not None:
@@ -450,8 +554,6 @@
             raise NotImplementedError("minLength is not supported")
         if schema.maxLength is not None:
             raise NotImplementedError("maxLength is not supported")
-        if schema.format is not None:
-            raise NotImplementedError("format is not supported")
         if schema.contentEncoding is not None:
             raise NotImplementedError("contentEncoding is not supported")
         if schema.divisibleBy != 1:
@@ -459,7 +561,9 @@
         if schema.disallow is not None:
             raise NotImplementedError("disallow is not supported")
 
-    def _validate_type(self, schema, obj):
+    def _validate_type(self):
+        obj = self._object
+        schema = self._schema
         for json_type in schema.type:
             if json_type == "any":
                 return
@@ -468,14 +572,18 @@
                 # way to test for isinstance(something, bool) that would
                 # not catch isinstance(1, bool) :/
                 if obj is not True and obj is not False:
-                    raise ValidationError(
+                    self._report_error(
                         "{obj!r} does not match type {type!r}".format(
-                            obj=obj, type=json_type))
+                            obj=obj, type=json_type),
+                        "Object has incorrect type (expected boolean)",
+                        schema_suffix=".type")
                 break
             elif isinstance(json_type, dict):
                 # Nested type check. This is pretty odd case. Here we
                 # don't change our object stack (it's the same object).
-                self._validate_no_push(Schema(json_type), obj)
+                self._push_schema(Schema(json_type), ".type")
+                self._validate()
+                self._pop_schema()
                 break
             else:
                 # Simple type check
@@ -483,106 +591,172 @@
                     # First one that matches, wins
                     break
         else:
-            raise ValidationError(
+            self._report_error(
                 "{obj!r} does not match type {type!r}".format(
-                    obj=obj, type=json_type))
-
-    def _validate_properties(self, schema, obj):
+                    obj=obj, type=json_type),
+                "Object has incorrect type (expected {type})".format(
+                    type=json_type),
+                schema_suffix=".type")
+
+    def _validate_format(self):
+        fmt = self._schema.format
+        obj = self._object
+        if fmt is None:
+            return
+        if fmt == 'date-time':
+            try:
+                DATE_TIME_FORMAT = "%Y-%m-%dT%H:%M:%SZ"
+                datetime.datetime.strptime(obj, DATE_TIME_FORMAT)
+            except ValueError:
+                self._report_error(
+                    "{obj!r} is not a string representing JSON date-time".format(
+                        obj=obj),
+                    "Object is not a string representing JSON date-time",
+                    schema_suffix=".format")
+        else:
+            raise NotImplementedError("format {0!r} is not supported".format(format))
+
+    def _validate_properties(self):
+        obj = self._object
+        schema = self._schema
         assert isinstance(obj, dict)
-        for prop, prop_schema_data in schema.properties.iteritems():
-            prop_schema = Schema(prop_schema_data)
+        for prop in schema.properties.iterkeys():
+            self._push_property_schema(prop)
             if prop in obj:
-                self._validate(prop_schema, obj[prop])
+                self._push_property_object(prop)
+                self._validate()
+                self._pop_object()
             else:
-                if not prop_schema.optional:
-                    raise ValidationError(
-                        "{obj!r} does not have property"
-                        " {prop!r}".format( obj=obj, prop=prop))
+                if not self._schema.optional:
+                    self._report_error(
+                        "{obj!r} does not have property {prop!r}".format(
+                            obj=obj, prop=prop),
+                        "Object lacks property {prop!r}".format(
+                            prop=prop),
+                        schema_suffix=".optional")
+            self._pop_schema()
 
-    def _validate_additional_properties(self, schema, obj):
+    def _validate_additional_properties(self):
+        obj = self._object
         assert isinstance(obj, dict)
-        if schema.additionalProperties is False:
+        if self._schema.additionalProperties is False:
             # Additional properties are disallowed
             # Report exception for each unknown property
             for prop in obj.iterkeys():
-                if prop not in schema.properties:
-                    raise ValidationError(
+                if prop not in self._schema.properties:
+                    self._report_error(
                         "{obj!r} has unknown property {prop!r} and"
                         " additionalProperties is false".format(
-                            obj=obj, prop=prop))
+                            obj=obj, prop=prop),
+                        "Object has unknown property {prop!r} but"
+                        " additional properties are disallowed".format(
+                            prop=prop),
+                        schema_suffix=".additionalProperties")
         else:
-            additional_schema = Schema(schema.additionalProperties)
             # Check each property against this object
-            for prop_value in obj.itervalues(): 
-                self._validate(additional_schema, prop_value)
+            self._push_additional_property_schema()
+            for prop in obj.iterkeys():
+                self._push_property_object(prop)
+                self._validate()
+                self._pop_object()
+            self._pop_schema()
 
-    def _validate_enum(self, schema, obj):
+    def _validate_enum(self):
+        obj = self._object
+        schema = self._schema
         if schema.enum is not None:
             for allowed_value in schema.enum:
                 if obj == allowed_value:
                     break
             else:
-                raise ValidationError(
+                self._report_error(
                     "{obj!r} does not match any value in enumeration"
-                    " {enum!r}".format(obj=obj, enum=schema.enum))
+                    " {enum!r}".format(obj=obj, enum=schema.enum),
+                    "Object does not match any value in enumeration",
+                    schema_suffix=".enum")
 
-    def _validate_items(self,  schema, obj):
+    def _validate_items(self):
+        obj = self._object
+        schema = self._schema
         assert isinstance(obj, list)
         items_schema_json = schema.items
         if items_schema_json == {}:
             # default value, don't do anything
             return
         if isinstance(items_schema_json, dict):
-            items_schema = Schema(items_schema_json)
-            for item in obj:
-                self._validate(items_schema, item)
+            self._push_array_schema()
+            for index, item in enumerate(obj):
+                self._push_array_item_object(index)
+                self._validate()
+                self._pop_object()
+            self._pop_schema()
         elif isinstance(items_schema_json, list):
             if len(obj) < len(items_schema_json):
-                # If our array is shorter than the schema then
+                # If our data array is shorter than the schema then
                 # validation fails. Longer arrays are okay (during this
                 # step) as they are validated based on
                 # additionalProperties schema
-                raise ValidationError(
+                self._report_error(
                     "{obj!r} is shorter than array schema {schema!r}".
-                    format(obj=obj, schema=items_schema_json))
+                    format(obj=obj, schema=items_schema_json),
+                    "Object array is shorter than schema array",
+                    schema_suffix=".items")
             if len(obj) != len(items_schema_json) and schema.additionalProperties is False:
                 # If our array is not exactly the same size as the
                 # schema and additional properties are disallowed then
                 # validation fails
-                raise ValidationError(
+                self._report_error(
                     "{obj!r} is not of the same length as array schema"
                     " {schema!r} and additionalProperties is"
-                    " false".format(obj=obj, schema=items_schema_json))
+                    " false".format(obj=obj, schema=items_schema_json),
+                    "Object array is not of the same length as schema array",
+                    schema_suffix=".items")
             # Validate each array element using schema for the
             # corresponding array index, fill missing values (since
             # there may be more items in our array than in the schema)
             # with additionalProperties which by now is not False
-            for item, item_schema_json in itertools.izip_longest(
-                obj, items_schema_json, fillvalue=schema.additionalProperties):
+            for index, (item, item_schema_json) in enumerate(
+                itertools.izip_longest(
+                    obj, items_schema_json,
+                    fillvalue=schema.additionalProperties)):
                 item_schema = Schema(item_schema_json)
-                self._validate(item_schema, item)
+                if index < len(items_schema_json):
+                    self._push_schema(item_schema, "items[%d]" % index)
+                else:
+                    self._push_schema(item_schema, ".additionalProperties")
+                self._push_array_item_object(index)
+                self._validate()
+                self._pop_schema()
+                self._pop_object()
 
-    def _validate_requires(self, schema, obj):
+    def _validate_requires(self):
+        obj = self._object
+        schema = self._schema
         requires_json = schema.requires
         if requires_json == {}:
             # default value, don't do anything
             return
         # Find our enclosing object in the object stack
-        if len(self._obj_stack) < 2:
-            raise ValidationError(
+        if len(self._object_stack) < 2:
+            self._report_error(
                 "{obj!r} requires that enclosing object matches"
                 " schema {schema!r} but there is no enclosing"
-                " object".format(obj=obj, schema=requires_json))
+                " object".format(obj=obj, schema=requires_json),
+                "Object has no enclosing object that matches schema",
+                schema_suffix=".requires")
         # Note: Parent object can be None, (e.g. a null property)
-        parent_obj = self._obj_stack[-2]
+        parent_obj = self._object_stack[-2][0]
         if isinstance(requires_json, basestring):
             # This is a simple property test
-            if (not isinstance(parent_obj, dict) 
+            if (not isinstance(parent_obj, dict)
                 or requires_json not in parent_obj):
-                raise ValidationError(
+                self._report_error(
                     "{obj!r} requires presence of property {requires!r}"
                     " in the same object".format(
-                        obj=obj, requires=requires_json))
+                        obj=obj, requires=requires_json),
+                    "Enclosing object does not have property"
+                    " {prop!r}".format(prop=requires_json),
+                    schema_suffix=".requires")
         elif isinstance(requires_json, dict):
             # Requires designates a whole schema, the enclosing object
             # must match against that schema.
@@ -593,9 +767,11 @@
             # instantiate a new validator with a subset of our current
             # history here.
             sub_validator = Validator()
-            sub_validator._obj_stack = self._obj_stack[:-2]
-            sub_validator._validate_no_push(
-                Schema(requires_json), parent_obj)
+            sub_validator._object_stack = self._object_stack[:-1]
+            sub_validator._schema_stack = self._schema_stack[:]
+            sub_validator._push_schema(
+                Schema(requires_json), ".requires")
+            sub_validator._validate()
 
 
 def validate(schema_text, data_text):

=== modified file 'linaro_json/tests/test_schema.py'
--- linaro_json/tests/test_schema.py	2010-11-09 14:35:41 +0000
+++ linaro_json/tests/test_schema.py	2010-11-12 14:13:07 +0000
@@ -757,39 +757,52 @@
             'schema': '{"type": "string"}',
             'data': 'null',
             'raises': ValidationError(
-                "None does not match type 'string'"),
+                "None does not match type 'string'",
+                "Object has incorrect type (expected string)"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.type',
         }),
         ("type_string_got_integer", {
             'schema': '{"type": "string"}',
             'data': '5',
             'raises': ValidationError(
-                "5 does not match type 'string'"),
+                "5 does not match type 'string'",
+                "Object has incorrect type (expected string)"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.type',
         }),
         ("type_number_got_integer", {
             'schema': '{"type": "number"}',
-            'data': '1'
+            'data': '1',
         }),
         ("type_number_number_float", {
             'schema': '{"type": "number"}',
-            'data': '1.1'
+            'data': '1.1',
         }),
         ("type_number_got_null", {
             'schema': '{"type": "number"}',
             'data': 'null',
             'raises': ValidationError(
-                "None does not match type 'number'"),
+                "None does not match type 'number'",
+                "Object has incorrect type (expected number)"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.type',
         }),
         ("type_number_got_string", {
             'schema': '{"type": "number"}',
             'data': '"foobar"',
             'raises': ValidationError(
                 "'foobar' does not match type 'number'"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.type',
         }),
         ("type_number_got_string_that_looks_like_number", {
             'schema': '{"type": "number"}',
             'data': '"3"',
             'raises': ValidationError(
                 "'3' does not match type 'number'"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.type',
         }),
         ("type_integer_got_integer_one", {
             'schema': '{"type": "integer"}',
@@ -803,13 +816,19 @@
             'schema': '{"type": "integer"}',
             'data': '1.1',
             'raises': ValidationError(
-                "1.1000000000000001 does not match type 'integer'")
+                "1.1000000000000001 does not match type 'integer'",
+                "Object has incorrect type (expected integer)"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.type',
         }),
         ("type_integer_got_null", {
             'schema': '{"type": "integer"}',
             'data': 'null',
             'raises': ValidationError(
-                "None does not match type 'integer'")
+                "None does not match type 'integer'",
+                "Object has incorrect type (expected integer)"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.type',
         }),
         ("type_boolean_got_true", {
             'schema': '{"type": "boolean"}',
@@ -823,25 +842,37 @@
             'schema': '{"type": "boolean"}',
             'data': 'null',
             'raises': ValidationError(
-                "None does not match type 'boolean'"),
+                "None does not match type 'boolean'",
+                "Object has incorrect type (expected boolean)"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.type',
         }),
         ("type_boolean_got_empty_string", {
             'schema': '{"type": "boolean"}',
             'data': '""',
             'raises': ValidationError(
-                "'' does not match type 'boolean'"),
+                "'' does not match type 'boolean'",
+                "Object has incorrect type (expected boolean)"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.type',
         }),
         ("type_boolean_got_empty_list", {
             'schema': '{"type": "boolean"}',
             'data': '[]',
             'raises': ValidationError(
-                "[] does not match type 'boolean'"),
+                "[] does not match type 'boolean'",
+                "Object has incorrect type (expected boolean)"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.type',
         }),
         ("type_boolean_got_empty_object", {
             'schema': '{"type": "boolean"}',
             'data': '{}',
             'raises': ValidationError(
-                "{} does not match type 'boolean'"),
+                "{} does not match type 'boolean'",
+                "Object has incorrect type (expected boolean)"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.type',
         }),
         ("type_object_got_object", {
             'schema': '{"type": "object"}',
@@ -851,13 +882,19 @@
             'schema': '{"type": "object"}',
             'data': '1',
             'raises': ValidationError(
-                "1 does not match type 'object'")
+                "1 does not match type 'object'",
+                "Object has incorrect type (expected object)"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.type',
         }),
         ("type_object_got_null", {
             'schema': '{"type": "object"}',
             'data': 'null',
             'raises': ValidationError(
-                "None does not match type 'object'")
+                "None does not match type 'object'",
+                "Object has incorrect type (expected object)"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.type',
         }),
         ("type_array_got_array", {
             'schema': '{"type": "array"}',
@@ -867,13 +904,19 @@
             'schema': '{"type": "array"}',
             'data': 'null',
             'raises': ValidationError(
-                "None does not match type 'array'")
+                "None does not match type 'array'",
+                "Object has incorrect type (expected array)"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.type',
         }),
         ("type_array_got_integer", {
             'schema': '{"type": "array"}',
             'data': '1',
             'raises': ValidationError(
-                "1 does not match type 'array'")
+                "1 does not match type 'array'",
+                "Object has incorrect type (expected array)"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.type',
         }),
         ("type_null_got_null", {
             'schema': '{"type": "null"}',
@@ -883,25 +926,37 @@
             'schema': '{"type": "null"}',
             'data': '""',
             'raises': ValidationError(
-                "'' does not match type 'null'")
+                "'' does not match type 'null'",
+                "Object has incorrect type (expected null)"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.type',
         }),
         ("type_null_got_zero", {
             'schema': '{"type": "null"}',
             'data': '0',
             'raises': ValidationError(
-                "0 does not match type 'null'")
+                "0 does not match type 'null'",
+                "Object has incorrect type (expected null)"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.type',
         }),
         ("type_null_got_empty_list", {
             'schema': '{"type": "null"}',
             'data': '[]',
             'raises': ValidationError(
-                "[] does not match type 'null'")
+                "[] does not match type 'null'",
+                "Object has incorrect type (expected null)"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.type',
         }),
         ("type_null_got_empty_object", {
             'schema': '{"type": "null"}',
             'data': '{}',
             'raises': ValidationError(
-                "{} does not match type 'null'")
+                "{} does not match type 'null'",
+                "Object has incorrect type (expected null)"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.type',
         }),
         ("type_any_got_null", {
             'schema': '{"type": "any"}',
@@ -966,7 +1021,10 @@
             }""",
             'data': '{"foo": "foobar"}',
             'raises': ValidationError(
-                "'foobar' does not match type 'number'")
+                "'foobar' does not match type 'number'",
+                "Object has incorrect type (expected number)"),
+            'object_expr': 'object.foo',
+            'schema_expr': 'schema.properties.foo.type',
         }),
         ("property_check_ignores_missing_optional_properties", {
             'schema': """
@@ -994,7 +1052,10 @@
             }""",
             'data': '{"foo": null}',
             'raises': ValidationError(
-                "None does not match type 'number'")
+                "None does not match type 'number'",
+                "Object has incorrect type (expected number)"),
+            'object_expr': 'object.foo',
+            'schema_expr': 'schema.properties.foo.type',
         }),
         ("property_check_reports_missing_non_optional_properties", {
             'schema': """
@@ -1009,7 +1070,10 @@
             }""",
             'data': '{}',
             'raises': ValidationError(
-                "{} does not have property 'foo'")
+                "{} does not have property 'foo'",
+                "Object lacks property 'foo'"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.properties.foo.optional',
         }),
         ("property_check_reports_unknown_properties_when_additionalProperties_is_false", {
             'schema': """
@@ -1020,7 +1084,11 @@
             'data': '{"foo": 5}',
             'raises': ValidationError(
                 "{'foo': 5} has unknown property 'foo' and"
-                " additionalProperties is false")
+                " additionalProperties is false",
+                "Object has unknown property 'foo' but additional "
+                "properties are disallowed"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.additionalProperties',
         }),
         ("property_check_ignores_normal_properties_when_additionalProperties_is_false", {
             'schema': """
@@ -1053,7 +1121,10 @@
             }""",
             'data': '{"foo": "aaa", "bar": 5}',
             'raises': ValidationError(
-                "5 does not match type 'string'")
+                "5 does not match type 'string'",
+                "Object has incorrect type (expected string)"),
+            'object_expr': 'object.bar',
+            'schema_expr': 'schema.additionalProperties.type',
         }),
         ("enum_check_does_nothing_by_default", {
             'schema': '{}',
@@ -1067,7 +1138,10 @@
             'schema': '{"enum": [1, 2, 3]}',
             'data': '5',
             'raises': ValidationError(
-                '5 does not match any value in enumeration [1, 2, 3]')
+                '5 does not match any value in enumeration [1, 2, 3]',
+                "Object does not match any value in enumeration"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.enum',
         }),
         ("items_check_does_nothing_for_non_arrays", {
             'schema': '{"items": {"type": "string"}}',
@@ -1081,7 +1155,10 @@
             'schema': '{"items": {"type": "string"}}',
             'data': '["foo", null, "froz"]',
             'raises': ValidationError(
-                "None does not match type 'string'")
+                "None does not match type 'string'",
+                "Object has incorrect type (expected string)"),
+            'object_expr': 'object[1]',
+            'schema_expr': 'schema.items.type',
         }),
         ("items_with_array_schema_applies_to_corresponding_items", {
             'schema': """
@@ -1104,7 +1181,10 @@
             'data': '["foo"]',
             'raises': ValidationError(
                 "['foo'] is shorter than array schema [{'type':"
-                " 'string'}, {'type': 'boolean'}]")
+                " 'string'}, {'type': 'boolean'}]",
+                "Object array is shorter than schema array"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.items',
         }),
         ("items_with_array_schema_and_additionalProperties_of_false_checks_for_too_much_data", {
             'schema': """
@@ -1119,7 +1199,10 @@
             'raises': ValidationError(
                 "['foo', False, 5] is not of the same length as array"
                 " schema [{'type': 'string'}, {'type': 'boolean'}] and"
-                " additionalProperties is false")
+                " additionalProperties is false",
+                "Object array is not of the same length as schema array"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.items',
         }),
         ("items_with_array_schema_and_additionalProperties", {
             'schema': """
@@ -1147,7 +1230,10 @@
             }""",
             'data': '["foo", false, 5, 7.9, null]',
             'raises': ValidationError(
-                "None does not match type 'number'")
+                "None does not match type 'number'",
+                "Object has incorrect type (expected number)"),
+            'object_expr': 'object[4]',
+            'schema_expr': 'schema.additionalProperties.type',
         }),
         ("requires_with_simple_property_name_does_nothing_when_parent_property_is_not_used", {
             'schema': """
@@ -1182,7 +1268,10 @@
             'data': '{"bar": null}',
             'raises': ValidationError(
                 "None requires presence of property 'foo' in the same"
-                " object")
+                " object",
+                "Enclosing object does not have property 'foo'"),
+            'object_expr': 'object.bar',
+            'schema_expr': 'schema.properties.bar.requires',
         }),
         ("requires_with_simple_property_name_can_report_problems_while_nested", {
             'schema': """
@@ -1206,7 +1295,10 @@
             'data': '{"nested": {"bar": null}}',
             'raises': ValidationError(
                 "None requires presence of property 'foo' in the same"
-                " object")
+                " object",
+                "Enclosing object does not have property 'foo'"),
+            'object_expr': 'object.nested.bar',
+            'schema_expr': 'schema.properties.nested.properties.bar.requires',
         }),
         ("requires_with_simple_property_name_works_when_condition_satisfied", {
             'schema': """
@@ -1268,7 +1360,10 @@
             """,
             'data': '{"bar": null}',
             'raises': ValidationError(
-                "{'bar': None} does not have property 'foo'")
+                "{'bar': None} does not have property 'foo'",
+                "Object lacks property 'foo'"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.properties.bar.requires.properties.foo.optional',
         }),
         ("requires_with_schema_can_report_subtle_problems", {
             # In this test presence of "bar" requires that "foo" is
@@ -1294,9 +1389,24 @@
             """,
             'data': '{"bar": null, "foo": "not a number"}',
             'raises': ValidationError(
-                "'not a number' does not match type 'number'")
-        }),
-
+                "'not a number' does not match type 'number'",
+                "Object has incorrect type (expected number)"),
+            'object_expr': 'object.foo',
+            'schema_expr': 'schema.properties.bar.requires.properties.foo.type'
+        }),
+        ("format_date_time_works", {
+            'schema': '{"format": "date-time"}',
+            'data': '"2010-11-12T14:38:55Z"',
+        }),
+        ("format_date_time_finds_problems", {
+            'schema': '{"format": "date-time"}',
+            'data': '"broken"',
+            'raises': ValidationError(
+                "'broken' is not a string representing JSON date-time",
+                "Object is not a string representing JSON date-time"),
+            'object_expr': 'object',
+            'schema_expr': 'schema.format'
+        }),
     ]
 
     def test_validate(self):
@@ -1306,10 +1416,23 @@
             try:
                 validate(self.schema, self.data)
             except type(self.raises) as ex:
-                self.assertEqual(str(ex), str(self.raises))
+                self.assertEqual(ex.message, self.raises.message)
+                if self.raises.new_message is not None:
+                    self.assertEqual(ex.new_message, self.raises.new_message)
+                self.assertEqual(ex.object_expr, self.object_expr)
+                self.assertEqual(ex.schema_expr, self.schema_expr)
             except Exception as ex:
                 self.fail("Raised exception {0!r} instead of {1!r}".format(
                     ex, self.raises))
         else:
             self.assertEqual(
                 True, validate(self.schema, self.data))
+
+    def __str__(self):
+        """
+        Override TestCase to report the scenario name.
+
+        TODO: Replace this with TestCaseWithScenarios in subsequent pipe
+        """
+        return self.id()
+