Gen empty lists if we must

Author: Zac-HD

CHANGELOG.md

@@ -1,5 +1,7 @@
 # Changelog
 
+#### 0.19.0 - 2021-01-06
+- Generate empty lists when `maxItems > 0` but no elements are allowed (#75)
 - Correct handling of regex patterns which are invalid in Python (#75)
 
 #### 0.18.2 - 2020-11-22

src/hypothesis_jsonschema/__init__.py

@@ -3,7 +3,7 @@
 The only public API is `from_schema`; check the docstring for details.
 """
 
-__version__ = "0.18.2"
+__version__ = "0.19.0"
 __all__ = ["from_schema"]
 
 from ._from_schema import from_schema

src/hypothesis_jsonschema/_from_schema.py

@@ -464,6 +464,14 @@ def array_schema(
             if contains_additional is not None:
                 additional_items_strat |= _from_schema_(contains_additional)
 
+        # Hypothesis raises InvalidArgument for empty elements and non-None
+        # max_size, because the user has asked for a possibility which will
+        # never happen... but we can work around that here.
+        if additional_items_strat.is_empty:
+            if min_size >= 1:
+                return st.nothing()
+            max_size = 0
+
         if unique:
 
             @st.composite  # type: ignore
@@ -477,6 +485,8 @@ def not_seen(elem: JSONType) -> bool:
                 for strat in items_strats:
                     elems.append(draw(strat.filter(not_seen)))
                     seen.add(encode_canonical_json(elems[-1]))
+                if max_size == 0:
+                    return elems
                 extra_items = st.lists(
                     additional_items_strat.filter(not_seen),
                     min_size=min_size,
@@ -487,6 +497,8 @@ def not_seen(elem: JSONType) -> bool:
                 return elems + more_elems
 
             strat = compose_lists_with_filter()
+        elif max_size == 0:
+            strat = st.tuples(*items_strats).map(list)
         else:
             strat = st.builds(
                 operator.add,
@@ -504,7 +516,9 @@ def not_seen(elem: JSONType) -> bool:
                 # heterogeneous) and hope it works out anyway.
                 contains_strat = contains_strat.filter(make_validator(items).is_valid)
             items_strat |= contains_strat
-
+        elif items_strat.is_empty and min_size == 0 and max_size is not None:
+            # As above, work around a Hypothesis check for unsatisfiable max_size.
+            return st.builds(list)
         strat = st.lists(
             items_strat,
             min_size=min_size,

tests/corpus-reported.json

@@ -302,6 +302,27 @@
         "format": "Unknown formats should be treated as annotations and pass validation",
         "type": "string"
     },
+    "unique array with list-items and required additionalItems": {
+        "additionalItems": {
+            "const": 2
+        },
+        "items": [
+            {
+                "const": 1
+            }
+        ],
+        "minItems": 2,
+        "type": "array",
+        "uniqueItems": true
+    },
+    "unique array with list-items without additionalItems": {
+        "items": [
+            {}
+        ],
+        "maxItems": 1,
+        "type": "array",
+        "uniqueItems": true
+    },
     "unmergable allOf schema can still be resolved": {
         "allOf": [
             {

tests/test_from_schema.py

@@ -2,6 +2,7 @@
 
 import json
 import re
+import warnings
 from pathlib import Path
 
 import jsonschema
@@ -388,6 +389,19 @@ def test_impossible_multiplier(type_):
     assert strategy.is_empty
 
 
+def test_unsatisfiable_array_returns_nothing():
+    schema = {
+        "type": "array",
+        "items": [],
+        "additionalItems": INVALID_REGEX_SCHEMA,
+        "minItems": 1,
+    }
+    with pytest.warns(UserWarning):
+        strategy = from_schema(schema)
+    strategy.validate()
+    assert strategy.is_empty
+
+
 ALLOF_CONTAINS = {
     "type": "array",
     "items": {"type": "string"},
@@ -444,3 +458,26 @@ def test_allowed_custom_format(num):
 def test_allowed_unknown_custom_format(string):
     assert string == "hello world"
     assert "not registered" not in jsonschema.FormatChecker().checkers
+
+
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore", UserWarning)
+
+    @given(
+        from_schema({"type": "array", "items": INVALID_REGEX_SCHEMA, "maxItems": 10})
+    )
+    def test_can_generate_empty_list_with_max_size_and_no_allowed_items(val):
+        assert val == []
+
+    @given(
+        from_schema(
+            {
+                "type": "array",
+                "items": [{"const": 1}, {"const": 2}, {"const": 3}],
+                "additionalItems": INVALID_REGEX_SCHEMA,
+                "maxItems": 10,
+            }
+        )
+    )
+    def test_can_generate_list_with_max_size_and_no_allowed_additional_items(val):
+        assert val == [1, 2, 3]