schemathesis 3.38.5__tar.gz → 3.38.6__tar.gz

{schemathesis-3.38.5 → schemathesis-3.38.6}/.github/workflows/codeql-analysis.yml

@@ -38,7 +38,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3.26.13
+        uses: github/codeql-action/init@v3.27.1
         with:
           languages: ${{ matrix.language }}
           # If you wish to specify custom queries, you can do so here or in a config file.
@@ -49,7 +49,7 @@ jobs:
       # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
       # If this step fails, then you should remove it and run the build manually (see below)
       - name: Autobuild
-        uses: github/codeql-action/autobuild@v3.26.13
+        uses: github/codeql-action/autobuild@v3.27.1
 
       # ℹ️ Command-line programs to run using the OS shell.
       # 📚 https://git.io/JvXDl
@@ -63,4 +63,4 @@ jobs:
       #   make release
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3.26.13
+        uses: github/codeql-action/analyze@v3.27.1

{schemathesis-3.38.5 → schemathesis-3.38.6}/.pre-commit-config.yaml

@@ -38,12 +38,12 @@ repos:
         additional_dependencies: [types-click, types-requests, types-PyYAML]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.7.1
+    rev: v0.7.3
     hooks:
       - id: ruff-format
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.7.1
+    rev: v0.7.3
     hooks:
       - id: ruff
 

{schemathesis-3.38.5 → schemathesis-3.38.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemathesis
-Version: 3.38.5
+Version: 3.38.6
 Summary: Property-based testing framework for Open API and GraphQL based apps
 Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
 Project-URL: Changelog, https://schemathesis.readthedocs.io/en/stable/changelog.html
@@ -9,8 +9,7 @@ Project-URL: Funding, https://github.com/sponsors/Stranger6667
 Project-URL: Source Code, https://github.com/schemathesis/schemathesis
 Author-email: Dmitry Dygalo <dmitry@dygalo.dev>
 Maintainer-email: Dmitry Dygalo <dmitry@dygalo.dev>
-License-Expression: MIT
-License-File: LICENSE
+License: MIT
 Keywords: graphql,hypothesis,openapi,pytest,testing
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console

{schemathesis-3.38.5 → schemathesis-3.38.6}/docs/changelog.rst

@@ -1,9 +1,28 @@
 Changelog
 =========
 
-:version:`Unreleased <v3.38.5...HEAD>` - TBD
+:version:`Unreleased <v3.38.6...HEAD>` - TBD
 --------------------------------------------
 
+.. _v3.38.6:
+
+:version:`3.38.6 <v3.38.5...v3.38.6>` - 2024-11-12
+--------------------------------------------------
+
+**Added**
+
+- Support arrays for headers & path parameters during the coverage phase.
+
+**Changed**
+
+- Make the ``ignored_auth`` stricter by always checking for the 401 status exactly instead of any non-200.
+
+**Fixed**
+
+- Missed generating booleans in some cases during the coverage phase.
+- Populate ``meta.parameter`` in more cases during the coverage phase.
+- Incorrect quantifiers merging for some regex patterns.
+
 .. _v3.38.5:
 
 :version:`3.38.5 <v3.38.4...v3.38.5>` - 2024-10-30

{schemathesis-3.38.5 → schemathesis-3.38.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "3.38.5"
+version = "3.38.6"
 description = "Property-based testing framework for Open API and GraphQL based apps"
 keywords = ["pytest", "hypothesis", "openapi", "graphql", "testing"]
 authors = [{ name = "Dmitry Dygalo", email = "dmitry@dygalo.dev" }]

{schemathesis-3.38.5 → schemathesis-3.38.6}/src/schemathesis/_hypothesis.py

@@ -224,6 +224,12 @@ def _iter_coverage_cases(
     from .specs.openapi.constants import LOCATION_TO_CONTAINER
     from .specs.openapi.examples import find_in_responses, find_matching_in_responses
 
+    def _stringify_value(val: Any) -> str:
+        if isinstance(val, list):
+            # use comma-separated values style for arrays
+            return ",".join(json.dumps(sub) for sub in val)
+        return json.dumps(val)
+
     generators: dict[tuple[str, str], Generator[coverage.GeneratedValue, None, None]] = {}
     template: dict[str, Any] = {}
     responses = find_in_responses(operation)
@@ -240,8 +246,8 @@ def _iter_coverage_cases(
         location = parameter.location
         name = parameter.name
         container = template.setdefault(LOCATION_TO_CONTAINER[location], {})
-        if location in ("header", "cookie") and not isinstance(value.value, str):
-            container[name] = json.dumps(value.value)
+        if location in ("header", "cookie", "path") and not isinstance(value.value, str):
+            container[name] = _stringify_value(value.value)
         else:
             container[name] = value.value
         generators[(location, name)] = gen
@@ -286,12 +292,13 @@ def _iter_coverage_cases(
         case.data_generation_method = DataGenerationMethod.positive
         case.meta = _make_meta(description="Default positive test case")
         yield case
+
     for (location, name), gen in generators.items():
         container_name = LOCATION_TO_CONTAINER[location]
         container = template[container_name]
         for value in gen:
-            if location in ("header", "cookie") and not isinstance(value.value, str):
-                generated = json.dumps(value.value)
+            if location in ("header", "cookie", "path") and not isinstance(value.value, str):
+                generated = _stringify_value(value.value)
             else:
                 generated = value.value
             case = operation.make_case(**{**template, container_name: {**container, name: generated}})
@@ -340,10 +347,13 @@ def _iter_coverage_cases(
         optional = sorted(all_params - required)
 
         # Helper function to create and yield a case
-        def make_case(container_values: dict, description: str, _location: str, _container_name: str) -> Case:
-            if _location in ("header", "cookie"):
+        def make_case(
+            container_values: dict, description: str, _location: str, _container_name: str, _parameter: str | None
+        ) -> Case:
+            if _location in ("header", "cookie", "path"):
                 container = {
-                    name: json.dumps(val) if not isinstance(val, str) else val for name, val in container_values.items()
+                    name: _stringify_value(val) if not isinstance(val, str) else val
+                    for name, val in container_values.items()
                 }
             else:
                 container = container_values
@@ -353,6 +363,7 @@ def _iter_coverage_cases(
             case.meta = _make_meta(
                 description=description,
                 location=_location,
+                parameter=_parameter,
                 parameter_location=_location,
             )
             return case
@@ -377,12 +388,12 @@ def _iter_coverage_cases(
                 coverage.CoverageContext(data_generation_methods=[DataGenerationMethod.negative]),
                 subschema,
             ):
-                yield make_case(more.value, more.description, _location, _container_name)
+                yield make_case(more.value, more.description, _location, _container_name, more.parameter)
 
         # 1. Generate only required properties
         if required and all_params != required:
             only_required = {k: v for k, v in base_container.items() if k in required}
-            yield make_case(only_required, "Only required properties", location, container_name)
+            yield make_case(only_required, "Only required properties", location, container_name, None)
             if DataGenerationMethod.negative in data_generation_methods:
                 subschema = _combination_schema(only_required, required, parameter_set)
                 yield from _yield_negative(subschema, location, container_name)
@@ -391,7 +402,9 @@ def _iter_coverage_cases(
         for opt_param in optional:
             combo = {k: v for k, v in base_container.items() if k in required or k == opt_param}
             if combo != base_container:
-                yield make_case(combo, f"All required properties and optional '{opt_param}'", location, container_name)
+                yield make_case(
+                    combo, f"All required properties and optional '{opt_param}'", location, container_name, None
+                )
                 if DataGenerationMethod.negative in data_generation_methods:
                     subschema = _combination_schema(combo, required, parameter_set)
                     yield from _yield_negative(subschema, location, container_name)
@@ -402,7 +415,9 @@ def _iter_coverage_cases(
                 for combination in combinations(optional, size):
                     combo = {k: v for k, v in base_container.items() if k in required or k in combination}
                     if combo != base_container:
-                        yield make_case(combo, f"All required and {size} optional properties", location, container_name)
+                        yield make_case(
+                            combo, f"All required and {size} optional properties", location, container_name, None
+                        )
 
 
 def _make_meta(

{schemathesis-3.38.5 → schemathesis-3.38.6}/src/schemathesis/generation/coverage.py

@@ -39,7 +39,7 @@ NUMERIC_STRATEGY: st.SearchStrategy = st.integers() | FLOAT_STRATEGY
 JSON_STRATEGY: st.SearchStrategy = st.recursive(
     st.none() | st.booleans() | NUMERIC_STRATEGY | st.text(), json_recursive_strategy
 )
-ARRAY_STRATEGY: st.SearchStrategy = st.lists(JSON_STRATEGY)
+ARRAY_STRATEGY: st.SearchStrategy = st.lists(JSON_STRATEGY, min_size=2)
 OBJECT_STRATEGY: st.SearchStrategy = st.dictionaries(st.text(), JSON_STRATEGY)
 
 
@@ -63,23 +63,31 @@ class GeneratedValue:
     value: Any
     data_generation_method: DataGenerationMethod
     description: str
+    parameter: str | None
     location: str | None
 
-    __slots__ = ("value", "data_generation_method", "description", "location")
+    __slots__ = ("value", "data_generation_method", "description", "parameter", "location")
 
     @classmethod
     def with_positive(cls, value: Any, *, description: str) -> GeneratedValue:
         return cls(
-            value=value, data_generation_method=DataGenerationMethod.positive, description=description, location=None
+            value=value,
+            data_generation_method=DataGenerationMethod.positive,
+            description=description,
+            location=None,
+            parameter=None,
         )
 
     @classmethod
-    def with_negative(cls, value: Any, *, description: str, location: str) -> GeneratedValue:
+    def with_negative(
+        cls, value: Any, *, description: str, location: str, parameter: str | None = None
+    ) -> GeneratedValue:
         return cls(
             value=value,
             data_generation_method=DataGenerationMethod.negative,
             description=description,
             location=location,
+            parameter=parameter,
         )
 
 
@@ -218,11 +226,11 @@ def _encode(o: Any) -> str:
     return "".join(_iterencode(o, 0))
 
 
-def _to_hashable_key(value: T, _encode: Callable = _encode) -> T | tuple[type, str]:
+def _to_hashable_key(value: T, _encode: Callable = _encode) -> tuple[type, str | T]:
     if isinstance(value, (dict, list)):
         serialized = _encode(value)
         return (type(value), serialized)
-    return value
+    return (type(value), value)
 
 
 def _cover_positive_for_type(
@@ -425,7 +433,8 @@ def cover_schema_iter(
                 elif key == "allOf":
                     nctx = ctx.with_negative()
                     if len(value) == 1:
-                        yield from cover_schema_iter(nctx, value[0], seen)
+                        with nctx.location(0):
+                            yield from cover_schema_iter(nctx, value[0], seen)
                     else:
                         with _ignore_unfixable():
                             canonical = canonicalish(schema)
@@ -755,6 +764,7 @@ def _negative_properties(
                     {**template, key: value.value},
                     description=f"Object with invalid '{key}' value: {value.description}",
                     location=nctx.current_location,
+                    parameter=key,
                 )
 
 

{schemathesis-3.38.5 → schemathesis-3.38.6}/src/schemathesis/specs/openapi/checks.py

@@ -391,14 +391,14 @@ def ignored_auth(ctx: CheckContext, response: GenericResponse, case: Case) -> bo
             # Check if invalid auth will give an error
             _remove_auth_from_case(case, security_parameters)
             new_response = case.operation.schema.transport.send(case)
-            if 200 <= new_response.status_code < 300:
+            if new_response.status_code != 401:
                 _update_response(response, new_response)
                 _raise_no_auth_error(new_response, case.operation.verbose_name, "that requires authentication")
             # Try to set invalid auth and check if it succeeds
             for parameter in security_parameters:
                 _set_auth_for_case(case, parameter)
                 new_response = case.operation.schema.transport.send(case)
-                if 200 <= new_response.status_code < 300:
+                if new_response.status_code != 401:
                     _update_response(response, new_response)
                     _raise_no_auth_error(new_response, case.operation.verbose_name, "with any auth")
                 _remove_auth_from_case(case, security_parameters)

{schemathesis-3.38.5 → schemathesis-3.38.6}/src/schemathesis/specs/openapi/patterns.py

@@ -44,21 +44,38 @@ def _handle_parsed_pattern(parsed: list, pattern: str, min_length: int | None, m
         if parsed[0][0] == ANCHOR:
             # Starts with an anchor
             op, value = parsed[1]
-            leading_anchor = pattern[0]
-            return leading_anchor + _update_quantifier(op, value, pattern[1:], min_length, max_length)
+            anchor_length = _get_anchor_length(parsed[0][1])
+            leading_anchor = pattern[:anchor_length]
+            return leading_anchor + _update_quantifier(op, value, pattern[anchor_length:], min_length, max_length)
         if parsed[1][0] == ANCHOR:
             # Ends with an anchor
             op, value = parsed[0]
-            trailing_anchor = pattern[-1]
-            return _update_quantifier(op, value, pattern[:-1], min_length, max_length) + trailing_anchor
+            anchor_length = _get_anchor_length(parsed[1][1])
+            trailing_anchor = pattern[-anchor_length:]
+            return _update_quantifier(op, value, pattern[:-anchor_length], min_length, max_length) + trailing_anchor
     elif len(parsed) == 3 and parsed[0][0] == ANCHOR and parsed[2][0] == ANCHOR:
         op, value = parsed[1]
-        leading_anchor = pattern[0]
-        trailing_anchor = pattern[-1]
-        return leading_anchor + _update_quantifier(op, value, pattern[1:-1], min_length, max_length) + trailing_anchor
+        leading_anchor_length = _get_anchor_length(parsed[0][1])
+        trailing_anchor_length = _get_anchor_length(parsed[2][1])
+        leading_anchor = pattern[:leading_anchor_length]
+        trailing_anchor = pattern[-trailing_anchor_length:]
+        return (
+            leading_anchor
+            + _update_quantifier(
+                op, value, pattern[leading_anchor_length:-trailing_anchor_length], min_length, max_length
+            )
+            + trailing_anchor
+        )
     return pattern
 
 
+def _get_anchor_length(node_type: int) -> int:
+    """Determine the length of the anchor based on its type."""
+    if node_type in {sre.AT_BEGINNING_STRING, sre.AT_END_STRING, sre.AT_BOUNDARY, sre.AT_NON_BOUNDARY}:
+        return 2  # \A, \Z, \b, or \B
+    return 1  # ^ or $ or their multiline/locale/unicode variants
+
+
 def _update_quantifier(op: int, value: tuple, pattern: str, min_length: int | None, max_length: int | None) -> str:
     """Update the quantifier based on the operation type and given constraints."""
     if op in REPEATS:
@@ -113,7 +130,7 @@ def _strip_quantifier(pattern: str) -> str:
         return pattern[:-2]
     if pattern.endswith(("?", "*", "+")):
         pattern = pattern[:-1]
-    if pattern.endswith("}"):
+    if pattern.endswith("}") and "{" in pattern:
         # Find the start of the exact quantifier and drop everything since that index
         idx = pattern.rfind("{")
         pattern = pattern[:idx]

{schemathesis-3.38.5 → schemathesis-3.38.6}/test/coverage/test_combinations.py

@@ -17,6 +17,11 @@ PATTERN = "^\\d+$"
 
 
 def cover_schema(ctx: CoverageContext, schema: dict) -> list:
+    output = []
+    for value in cover_schema_iter(ctx, schema):
+        print(value)
+        output.append(value.value)
+    return output
     return [value.value for value in cover_schema_iter(ctx, schema)]
 
 
@@ -29,7 +34,7 @@ def assert_unique(values: list):
             serialized = json.dumps(value, sort_keys=True)
             key = (type(value), serialized)
         else:
-            key = value
+            key = (type(value), value)
         assert key not in seen
         seen.add(key)
 
@@ -108,9 +113,9 @@ class AnyNumber:
 @pytest.mark.parametrize(
     ("schema", "expected"),
     [
-        ({"type": "null"}, [0, "", [], {}]),
-        ({"type": "boolean"}, [0, None, "", [], {}]),
-        ({"type": ["boolean", "null"]}, [0, "", [], {}]),
+        ({"type": "null"}, [0, False, "", [None, None], {}]),
+        ({"type": "boolean"}, [0, None, "", [None, None], {}]),
+        ({"type": ["boolean", "null"]}, [0, "", [None, None], {}]),
         ({"enum": [1, 2]}, [None]),
         ({"enum": [1, 2, {}]}, [None]),
         ({"const": 42}, [None]),
@@ -167,13 +172,16 @@ def test_positive_string(ctx, schema, lengths):
 @pytest.mark.parametrize(
     ("schema", "expected"),
     [
-        ({"type": "string"}, [0, None, [], {}]),
-        ({"type": "string", "minLength": 5}, [0, None, [], {}, "0000"]),
-        ({"type": "string", "maxLength": 10}, [0, None, [], {}, "00000000000"]),
-        ({"type": "string", "minLength": 5, "maxLength": 10}, [0, None, [], {}, "0000", "00000000000"]),
-        ({"type": "string", "pattern": "^[0-9]", "minLength": 1}, [0, None, [], {}, AnyString(), ""]),
-        ({"type": "string", "pattern": "^[0-9]"}, [0, None, [], {}, AnyString()]),
-        ({"type": "string", "format": "date-time"}, [0, None, [], {}, ""]),
+        ({"type": "string"}, [0, False, None, [None, None], {}]),
+        ({"type": "string", "minLength": 5}, [0, False, None, [None, None], {}, "0000"]),
+        ({"type": "string", "maxLength": 10}, [0, False, None, [None, None], {}, "00000000000"]),
+        (
+            {"type": "string", "minLength": 5, "maxLength": 10},
+            [0, False, None, [None, None], {}, "0000", "00000000000"],
+        ),
+        ({"type": "string", "pattern": "^[0-9]", "minLength": 1}, [0, False, None, [None, None], {}, AnyString(), ""]),
+        ({"type": "string", "pattern": "^[0-9]"}, [0, False, None, [None, None], {}, AnyString()]),
+        ({"type": "string", "format": "date-time"}, [0, False, None, [None, None], {}, ""]),
     ],
 )
 def test_negative_string(nctx, schema, expected):
@@ -191,7 +199,7 @@ def test_negative_string_with_pattern(nctx):
         "pattern": r"^[\da-z]+$",
     }
     covered = cover_schema(nctx, schema)
-    assert covered == [0, None, [], {}, "0000", "000000000", AnyString()]
+    assert covered == [0, False, None, [None, None], {}, "0000", "000000000", AnyString()]
     assert_unique(covered)
     assert_not_conform(covered, schema)
 
@@ -252,6 +260,7 @@ def test_positive_number(ctx, schema, multiple_of, values, with_multiple_of):
                 {"foo": ANY},
                 {"foo": ANY},
                 {"foo": ANY},
+                {"foo": ANY},
             ],
         ),
         (
@@ -425,15 +434,15 @@ def test_positive_number(ctx, schema, multiple_of, values, with_multiple_of):
                 "required": ["req1", "req2"],
             },
             [
-                {"req1": "", "req2": 0, "opt1": "", "opt2": 0.0, "opt3": [], "opt4": False},
+                {"req1": "", "req2": 0, "opt1": "", "opt2": 0.0, "opt3": [None, None], "opt4": False},
                 {"req1": "", "req2": 0, "opt1": ""},
                 {"req1": "", "req2": 0, "opt2": 0.0},
-                {"req1": "", "req2": 0, "opt3": []},
+                {"req1": "", "req2": 0, "opt3": [None, None]},
                 {"req1": "", "req2": 0, "opt4": False},
                 {"req1": "", "req2": 0, "opt1": "", "opt2": 0.0},
-                {"req1": "", "req2": 0, "opt1": "", "opt2": 0.0, "opt3": []},
+                {"req1": "", "req2": 0, "opt1": "", "opt2": 0.0, "opt3": [None, None]},
                 {"req1": "", "req2": 0},
-                {"opt1": "", "opt2": 0.0, "opt3": [], "opt4": True, "req1": "", "req2": 0},
+                {"opt1": "", "opt2": 0.0, "opt3": [None, None], "opt4": True, "req1": "", "req2": 0},
             ],
         ),
         # Nested object with optional properties
@@ -736,13 +745,17 @@ def test_positive_other(pctx, schema, expected):
                     "foo": 0,
                     "bar": "",
                 },
+                {
+                    "foo": False,
+                    "bar": "",
+                },
                 {
                     "bar": "",
                     "foo": None,
                 },
                 {
                     "bar": "",
-                    "foo": [],
+                    "foo": [None, None],
                 },
                 {
                     "bar": "",
@@ -752,12 +765,16 @@ def test_positive_other(pctx, schema, expected):
                     "bar": 0,
                     "foo": "",
                 },
+                {
+                    "bar": False,
+                    "foo": "",
+                },
                 {
                     "bar": None,
                     "foo": "",
                 },
                 {
-                    "bar": [],
+                    "bar": [None, None],
                     "foo": "",
                 },
                 {
@@ -784,13 +801,17 @@ def test_positive_other(pctx, schema, expected):
                     "bar": "",
                     "foo": 0,
                 },
+                {
+                    "bar": "",
+                    "foo": False,
+                },
                 {
                     "bar": "",
                     "foo": None,
                 },
                 {
                     "bar": "",
-                    "foo": [],
+                    "foo": [None, None],
                 },
                 {
                     "bar": "",
@@ -800,12 +821,16 @@ def test_positive_other(pctx, schema, expected):
                     "bar": 0,
                     "foo": "",
                 },
+                {
+                    "bar": False,
+                    "foo": "",
+                },
                 {
                     "bar": None,
                     "foo": "",
                 },
                 {
-                    "bar": [],
+                    "bar": [None, None],
                     "foo": "",
                 },
                 {
@@ -825,11 +850,14 @@ def test_positive_other(pctx, schema, expected):
                 {
                     "foo": 0,
                 },
+                {
+                    "foo": False,
+                },
                 {
                     "foo": None,
                 },
                 {
-                    "foo": [],
+                    "foo": [None, None],
                 },
                 {
                     "foo": {},
@@ -936,7 +964,7 @@ def test_negative_pattern_with_incompatible_length(nctx):
                     {"minimum": 5},
                 ],
             },
-            [4, AnyNumber(), False, None, "", [], {}],
+            [4, AnyNumber(), False, None, "", [None, None], {}],
         ),
         (
             {
@@ -945,7 +973,7 @@ def test_negative_pattern_with_incompatible_length(nctx):
                     {"type": "string"},
                 ],
             },
-            [4, 0, None, [], {}],
+            [4, 0, False, None, [None, None], {}],
         ),
         (
             {
@@ -956,15 +984,17 @@ def test_negative_pattern_with_incompatible_length(nctx):
                     },
                     {
                         "anyOf": [
-                            {
-                                "maxLength": 10,
-                            },
+                            {"maxLength": 10},
                             {"type": "null"},
                         ]
                     },
                 ]
             },
-            [ANY, "00000000000", 0, None, ANY],
+            (
+                # The first item could be `{}` or `[]`, so it will prevent the same value at the end
+                [ANY, "00000000000", 0, False, None, ANY, ANY],
+                [ANY, "00000000000", 0, False, None, ANY],
+            ),
         ),
         (
             {
@@ -979,9 +1009,13 @@ def test_negative_pattern_with_incompatible_length(nctx):
 )
 def test_negative_combinators(nctx, schema, expected):
     covered = cover_schema(nctx, schema)
-    assert covered == expected
-    assert_unique(covered)
-    assert_not_conform(covered, schema)
+    for exp in expected if isinstance(expected, tuple) else (expected,):
+        if covered == exp:
+            assert_unique(covered)
+            assert_not_conform(covered, schema)
+            break
+    else:
+        pytest.fail("Expected value didn't match")
 
 
 @pytest.mark.parametrize(
@@ -993,7 +1027,7 @@ def test_negative_combinators(nctx, schema, expected):
 )
 def test_unsupported_patterns(nctx, pattern):
     covered = cover_schema(nctx, {"type": "string", "pattern": pattern})
-    assert covered == [0, None, [], {}]
+    assert covered == [0, False, None, [None, None], {}]
     assert not cover_schema(nctx, {"patternProperties": {pattern: {"type": "string"}}})