Handle invalid regex

Author: Zac-HD

CHANGELOG.md

@@ -1,5 +1,7 @@
 # Changelog
 
+- Correct handling of regex patterns which are invalid in Python (#75)
+
 #### 0.18.2 - 2020-11-22
 - Remove internal caching due to hash collisions (#71)
 - Improve performance for conditional keywords

src/hypothesis_jsonschema/_from_schema.py

@@ -4,6 +4,7 @@
 import math
 import operator
 import re
+import warnings
 from fractions import Fraction
 from functools import partial
 from typing import Any, Callable, Dict, List, NoReturn, Optional, Set, Union
@@ -388,6 +389,14 @@ def relative_json_pointers() -> st.SearchStrategy[str]:
 }
 
 
+def _warn_invalid_regex(pattern: str, err: re.error, kw: str = "pattern") -> None:
+    warnings.warn(
+        f"Got {kw}={pattern!r}, but this is not valid syntax for a Python regular "
+        f"expression ({err}) so it will not be handled by the strategy.  See https://"
+        "json-schema.org/understanding-json-schema/reference/regular_expressions.html"
+    )
+
+
 def string_schema(
     custom_formats: Dict[str, st.SearchStrategy[str]], schema: dict
 ) -> st.SearchStrategy[str]:
@@ -402,14 +411,19 @@ def string_schema(
         # See https://json-schema.org/latest/json-schema-validation.html#format
         strategy = known_formats[schema["format"]]
         if "pattern" in schema:
-            # This isn't really supported, but we'll do our best.
-            strategy = strategy.filter(re.compile(schema["pattern"]).search)
+            try:
+                # This isn't really supported, but we'll do our best with a filter.
+                strategy = strategy.filter(re.compile(schema["pattern"]).search)
+            except re.error as err:
+                _warn_invalid_regex(schema["pattern"], err)
+                return st.nothing()
     elif "pattern" in schema:
         try:
             re.compile(schema["pattern"])
             strategy = st.from_regex(schema["pattern"])
-        except re.error:
+        except re.error as err:
             # Patterns that are invalid in Python, or just malformed
+            _warn_invalid_regex(schema["pattern"], err)
             return st.nothing()
     # If we have size bounds but we're generating strings from a regex or pattern,
     # apply a filter to ensure our size bounds are respected.
@@ -524,6 +538,15 @@ def object_schema(
     additional = schema.get("additionalProperties", {})
     additional_allowed = additional != FALSEY
 
+    for key in list(patterns):
+        try:
+            re.compile(key)
+        except re.error as err:
+            _warn_invalid_regex(key, err, "patternProperties entry")
+            if min_size == 0 and not required:
+                return st.builds(dict)
+            return st.nothing()
+
     dependencies = schema.get("dependencies", {})
     dep_names = {k: v for k, v in dependencies.items() if isinstance(v, list)}
     dep_schemas = {k: v for k, v in dependencies.items() if k not in dep_names}

tests/test_from_schema.py

@@ -27,6 +27,10 @@
 )
 from hypothesis_jsonschema._from_schema import from_schema, rfc3339
 
+# We use this as a placeholder for all schemas which resolve to nothing()
+# but do not canonicalise to FALSEY
+INVALID_REGEX_SCHEMA = {"type": "string", "pattern": "["}
+
 
 @settings(
     suppress_health_check=[HealthCheck.too_slow, HealthCheck.filter_too_much],
@@ -73,6 +77,20 @@ def test_invalid_schemas_raise(schema):
         from_schema(schema).example()
 
 
+@pytest.mark.parametrize(
+    "schema",
+    [
+        INVALID_REGEX_SCHEMA,
+        {"type": "string", "pattern": "[", "format": "color"},
+        {"type": "object", "patternProperties": {"[": False}},
+        {"type": "object", "patternProperties": {"[": False}, "required": ["a"]},
+    ],
+)
+def test_invalid_regex_emit_warning(schema):
+    with pytest.warns(UserWarning):
+        from_schema(schema).validate()
+
+
 INVALID_SCHEMAS = {
     # Empty list for requires, which is invalid
     "Release Drafter configuration file",
@@ -97,6 +115,7 @@ def test_invalid_schemas_raise(schema):
     # Technically valid, but using regex patterns not supported by Python
     "draft7/ECMA 262 regex escapes control codes with \\c and lower letter",
     "draft7/ECMA 262 regex escapes control codes with \\c and upper letter",
+    "JSON Schema for mime type collections",
 }
 FLAKY_SCHEMAS = {
     # The following schemas refer to an `$id` rather than a JSON pointer.