Add option to disable fast fail and return all the errors

Author: horejsek

Makefile

@@ -29,7 +29,7 @@ jsonschemasuitcases:
 	git submodule update
 
 test: venv jsonschemasuitcases
-	${PYTHON} -m pytest -W default --benchmark-skip #tests/json_schema/test_draft07.py
+	${PYTHON} -m pytest -W default --benchmark-skip #tests/test_fast_fail.py
 test-lf: venv jsonschemasuitcases
 	${PYTHON} -m pytest -W default --benchmark-skip --last-failed
 

fastjsonschema/__init__.py

@@ -110,22 +110,23 @@
 from .draft04 import CodeGeneratorDraft04
 from .draft06 import CodeGeneratorDraft06
 from .draft07 import CodeGeneratorDraft07
-from .exceptions import JsonSchemaException, JsonSchemaValueException, JsonSchemaDefinitionException
+from .exceptions import JsonSchemaException, JsonSchemaValueException, JsonSchemaValuesException, JsonSchemaDefinitionException
 from .ref_resolver import RefResolver
 from .version import VERSION
 
 __all__ = (
     'VERSION',
     'JsonSchemaException',
     'JsonSchemaValueException',
+    'JsonSchemaValuesException',
     'JsonSchemaDefinitionException',
     'validate',
     'compile',
     'compile_to_code',
 )
 
 
-def validate(definition, data, handlers={}, formats={}, use_default=True, use_formats=True, detailed_exceptions=True):
+def validate(definition, data, handlers={}, formats={}, use_default=True, use_formats=True, detailed_exceptions=True, fast_fail=True):
     """
     Validation function for lazy programmers or for use cases when you need
     to call validation only once, so you do not have to compile it first.
@@ -141,12 +142,12 @@ def validate(definition, data, handlers={}, formats={}, use_default=True, use_fo
 
     Preferred is to use :any:`compile` function.
     """
-    return compile(definition, handlers, formats, use_default, use_formats, detailed_exceptions)(data)
+    return compile(definition, handlers, formats, use_default, use_formats, detailed_exceptions, fast_fail)(data)
 
 
 #TODO: Change use_default to False when upgrading to version 3.
 # pylint: disable=redefined-builtin,dangerous-default-value,exec-used
-def compile(definition, handlers={}, formats={}, use_default=True, use_formats=True, detailed_exceptions=True):
+def compile(definition, handlers={}, formats={}, use_default=True, use_formats=True, detailed_exceptions=True, fast_fail=True):
     """
     Generates validation function for validating JSON schema passed in ``definition``.
     Example:
@@ -205,13 +206,20 @@ def compile(definition, handlers={}, formats={}, use_default=True, use_formats=T
     If you don't need detailed exceptions, you can turn the details off and gain
     additional performance by passing `detailed_exceptions=False`.
 
+    By default, the execution stops with the first validation error. If you need
+    to collect all the errors, turn this off by passing `fast_fail=False`.
+
     Exception :any:`JsonSchemaDefinitionException` is raised when generating the
     code fails (bad definition).
 
     Exception :any:`JsonSchemaValueException` is raised from generated function when
     validation fails (data do not follow the definition).
+
+    Exception :any:`JsonSchemaValuesException` is raised from generated function when
+    validation fails (data do not follow the definition) contatining all the errors
+    (when fast_fail is set to `False`).
     """
-    resolver, code_generator = _factory(definition, handlers, formats, use_default, use_formats, detailed_exceptions)
+    resolver, code_generator = _factory(definition, handlers, formats, use_default, use_formats, detailed_exceptions, fast_fail)
     global_state = code_generator.global_state
     # Do not pass local state so it can recursively call itself.
     exec(code_generator.func_code, global_state)
@@ -222,7 +230,7 @@ def compile(definition, handlers={}, formats={}, use_default=True, use_formats=T
 
 
 # pylint: disable=dangerous-default-value
-def compile_to_code(definition, handlers={}, formats={}, use_default=True, use_formats=True, detailed_exceptions=True):
+def compile_to_code(definition, handlers={}, formats={}, use_default=True, use_formats=True, detailed_exceptions=True, fast_fail=True):
     """
     Generates validation code for validating JSON schema passed in ``definition``.
     Example:
@@ -245,15 +253,15 @@ def compile_to_code(definition, handlers={}, formats={}, use_default=True, use_f
     Exception :any:`JsonSchemaDefinitionException` is raised when generating the
     code fails (bad definition).
     """
-    _, code_generator = _factory(definition, handlers, formats, use_default, use_formats, detailed_exceptions)
+    _, code_generator = _factory(definition, handlers, formats, use_default, use_formats, detailed_exceptions, fast_fail)
     return (
         'VERSION = "' + VERSION + '"\n' +
         code_generator.global_state_code + '\n' +
         code_generator.func_code
     )
 
 
-def _factory(definition, handlers, formats={}, use_default=True, use_formats=True, detailed_exceptions=True):
+def _factory(definition, handlers, formats={}, use_default=True, use_formats=True, detailed_exceptions=True, fast_fail=True):
     resolver = RefResolver.from_schema(definition, handlers=handlers, store={})
     code_generator = _get_code_generator_class(definition)(
         definition,
@@ -262,6 +270,7 @@ def _factory(definition, handlers, formats={}, use_default=True, use_formats=Tru
         use_default=use_default,
         use_formats=use_formats,
         detailed_exceptions=detailed_exceptions,
+        fast_fail=fast_fail,
     )
     return resolver, code_generator
 

fastjsonschema/draft04.py

@@ -34,8 +34,8 @@ class CodeGeneratorDraft04(CodeGenerator):
         'uri': r'^\w+:(\/?\/?)[^\s]+\Z',
     }
 
-    def __init__(self, definition, resolver=None, formats={}, use_default=True, use_formats=True, detailed_exceptions=True):
-        super().__init__(definition, resolver, detailed_exceptions)
+    def __init__(self, definition, resolver=None, formats={}, use_default=True, use_formats=True, detailed_exceptions=True, fast_fail=True):
+        super().__init__(definition, resolver, detailed_exceptions, fast_fail)
         self._custom_formats = formats
         self._use_formats = use_formats
         self._use_default = use_default

fastjsonschema/draft06.py

@@ -16,8 +16,8 @@ class CodeGeneratorDraft06(CodeGeneratorDraft04):
         ),
     })
 
-    def __init__(self, definition, resolver=None, formats={}, use_default=True, use_formats=True, detailed_exceptions=True):
-        super().__init__(definition, resolver, formats, use_default, use_formats, detailed_exceptions)
+    def __init__(self, definition, resolver=None, formats={}, use_default=True, use_formats=True, detailed_exceptions=True, fast_fail=True):
+        super().__init__(definition, resolver, formats, use_default, use_formats, detailed_exceptions, fast_fail)
         self._json_keywords_to_function.update((
             ('exclusiveMinimum', self.generate_exclusive_minimum),
             ('exclusiveMaximum', self.generate_exclusive_maximum),

fastjsonschema/draft07.py

@@ -17,8 +17,8 @@ class CodeGeneratorDraft07(CodeGeneratorDraft06):
         ),
     })
 
-    def __init__(self, definition, resolver=None, formats={}, use_default=True, use_formats=True, detailed_exceptions=True):
-        super().__init__(definition, resolver, formats, use_default, use_formats, detailed_exceptions)
+    def __init__(self, definition, resolver=None, formats={}, use_default=True, use_formats=True, detailed_exceptions=True, fast_fail=True):
+        super().__init__(definition, resolver, formats, use_default, use_formats, detailed_exceptions, fast_fail)
         # pylint: disable=duplicate-code
         self._json_keywords_to_function.update((
             ('if', self.generate_if_then_else),

fastjsonschema/exceptions.py

@@ -45,6 +45,16 @@ def rule_definition(self):
         return self.definition.get(self.rule)
 
 
+class JsonSchemaValuesException(JsonSchemaException):
+    """
+    Exception raised by validation function. It is a collection of all errors.
+    """
+
+    def __init__(self, errors):
+        super().__init__()
+        self.errors = errors
+
+
 class JsonSchemaDefinitionException(JsonSchemaException):
     """
     Exception raised by generator of validation function.

fastjsonschema/generator.py

@@ -2,7 +2,7 @@
 from decimal import Decimal
 import re
 
-from .exceptions import JsonSchemaValueException, JsonSchemaDefinitionException
+from .exceptions import JsonSchemaValueException, JsonSchemaValuesException, JsonSchemaDefinitionException
 from .indent import indent
 from .ref_resolver import RefResolver
 
@@ -29,11 +29,12 @@ class CodeGenerator:
 
     INDENT = 4  # spaces
 
-    def __init__(self, definition, resolver=None, detailed_exceptions=True):
+    def __init__(self, definition, resolver=None, detailed_exceptions=True, fast_fail=True):
         self._code = []
         self._compile_regexps = {}
         self._custom_formats = {}
         self._detailed_exceptions = detailed_exceptions
+        self._fast_fail = fast_fail
 
         # Any extra library should be here to be imported only once.
         # Lines are imports to be printed in the file and objects
@@ -91,6 +92,7 @@ def global_state(self):
             REGEX_PATTERNS=self._compile_regexps,
             re=re,
             JsonSchemaValueException=JsonSchemaValueException,
+            JsonSchemaValuesException=JsonSchemaValuesException,
         )
 
     @property
@@ -103,13 +105,13 @@ def global_state_code(self):
 
         if not self._compile_regexps:
             return '\n'.join(self._extra_imports_lines + [
-                'from fastjsonschema import JsonSchemaValueException',
+                'from fastjsonschema import JsonSchemaValueException, JsonSchemaValuesException',
                 '',
                 '',
             ])
         return '\n'.join(self._extra_imports_lines + [
             'import re',
-            'from fastjsonschema import JsonSchemaValueException',
+            'from fastjsonschema import JsonSchemaValueException, JsonSchemaValuesException',
             '',
             '',
             'REGEX_PATTERNS = ' + serialize_regexes(self._compile_regexps),
@@ -143,7 +145,11 @@ def generate_validation_function(self, uri, name):
         self.l('')
         with self._resolver.resolving(uri) as definition:
             with self.l('def {}(data, custom_formats={{}}, name_prefix=None):', name):
+                if not self._fast_fail:
+                    self.l('errors = []')
                 self.generate_func_code_block(definition, 'data', 'data', clear_variables=True)
+                if not self._fast_fail:
+                    self.l('if errors: raise JsonSchemaValuesException(errors)')
                 self.l('return data')
 
     def generate_func_code_block(self, definition, variable, variable_name, clear_variables=False):
@@ -268,13 +274,20 @@ def exc(self, msg, *args, append_to_msg=None, rule=None):
         Short-cut for creating raising exception in the code.
         """
         if not self._detailed_exceptions:
-            self.l('raise JsonSchemaValueException("'+msg+'")', *args)
+            if self._fast_fail:
+                self.l('raise JsonSchemaValueException("'+msg+'")', *args)
+            else:
+                self.l('errors.append(JsonSchemaValueException("'+msg+'"))', *args)
             return
 
         arg = '"'+msg+'"'
         if append_to_msg:
             arg += ' + (' + append_to_msg + ')'
-        msg = 'raise JsonSchemaValueException('+arg+', value={variable}, name="{name}", definition={definition}, rule={rule})'
+        msg = (
+            'raise JsonSchemaValueException('+arg+', value={variable}, name="{name}", definition={definition}, rule={rule})'
+            if self._fast_fail else
+            'errors.append(JsonSchemaValueException('+arg+', value={variable}, name="{name}", definition={definition}, rule={rule}))'
+        )
         definition = self._expand_refs(self._definition)
         definition_rule = self.e(definition.get(rule) if isinstance(definition, dict) else None)
         self.l(msg, *args, definition=repr(definition), rule=repr(rule), definition_rule=definition_rule)

tests/test_fast_fail.py

@@ -0,0 +1,47 @@
+import pytest
+
+from fastjsonschema import JsonSchemaValueException, JsonSchemaValuesException, compile
+
+
+def test_fast_fail():
+    validator = compile({
+        'type': 'object',
+        'properties': {
+            'string': {
+                'type': 'string',
+            },
+            'number': {
+                'type': 'number',
+            },
+        },
+    })
+
+    with pytest.raises(JsonSchemaValueException) as exc_info:
+        validator({
+            'string': 1,
+            'number': 'a',
+        })
+    assert exc_info.value.message == 'data.string must be string'
+
+
+def test_captures_all_errors():
+    validator = compile({
+        'type': 'object',
+        'properties': {
+            'string': {
+                'type': 'string',
+            },
+            'number': {
+                'type': 'number',
+            },
+        },
+    }, fast_fail=False)
+
+    with pytest.raises(JsonSchemaValuesException) as exc_info:
+        validator({
+            'string': 1,
+            'number': 'a',
+        })
+    assert len(exc_info.value.errors) == 2
+    assert exc_info.value.errors[0].message == 'data.string must be string'
+    assert exc_info.value.errors[1].message == 'data.number must be number'