schemathesis 4.0.0a8__py3-none-any.whl → 4.0.0a9__py3-none-any.whl

schemathesis/generation/coverage.py

@@ -37,6 +37,8 @@ def json_recursive_strategy(strategy: st.SearchStrategy) -> st.SearchStrategy:
 
 
 BUFFER_SIZE = 8 * 1024
+NEGATIVE_MODE_MAX_LENGTH_WITH_PATTERN = 100
+NEGATIVE_MODE_MAX_ITEMS = 15
 FLOAT_STRATEGY: st.SearchStrategy = st.floats(allow_nan=False, allow_infinity=False).map(_replace_zero_with_nonzero)
 NUMERIC_STRATEGY: st.SearchStrategy = st.integers() | FLOAT_STRATEGY
 JSON_STRATEGY: st.SearchStrategy = st.recursive(
@@ -257,6 +259,9 @@ def _cover_positive_for_type(
     if ty == "object" or ty == "array":
         template_schema = _get_template_schema(schema, ty)
         template = ctx.generate_from_schema(template_schema)
+    elif "properties" in schema or "required" in schema:
+        template_schema = _get_template_schema(schema, "object")
+        template = ctx.generate_from_schema(template_schema)
     else:
         template = None
     if GenerationMode.POSITIVE in ctx.generation_modes:
@@ -295,6 +300,8 @@ def _cover_positive_for_type(
                 yield from _positive_array(ctx, schema, cast(list, template))
             elif ty == "object":
                 yield from _positive_object(ctx, schema, cast(dict, template))
+        elif "properties" in schema or "required" in schema:
+            yield from _positive_object(ctx, schema, cast(dict, template))
 
 
 @contextmanager
@@ -387,41 +394,58 @@ def cover_schema_iter(
                             yield value_
                             seen.add(k)
                 elif key == "minLength" and 0 < value < BUFFER_SIZE:
-                    with suppress(InvalidArgument):
-                        min_length = max_length = value - 1
-                        new_schema = {**schema, "minLength": min_length, "maxLength": max_length}
-                        new_schema.setdefault("type", "string")
-                        if "pattern" in new_schema:
-                            new_schema["pattern"] = update_quantifier(schema["pattern"], min_length, max_length)
-                            if new_schema["pattern"] == schema["pattern"]:
-                                # Pattern wasn't updated, try to generate a valid value then shrink the string to the required length
-                                del new_schema["minLength"]
-                                del new_schema["maxLength"]
-                                value = ctx.generate_from_schema(new_schema)[:max_length]
-                            else:
-                                value = ctx.generate_from_schema(new_schema)
-                        else:
-                            value = ctx.generate_from_schema(new_schema)
+                    if value == 1:
+                        # In this case, the only possible negative string is an empty one
+                        # The `pattern` value may require an non-empty one and the generation will fail
+                        # However, it is fine to violate `pattern` here as it is negative string generation anyway
+                        value = ""
                         k = _to_hashable_key(value)
                         if k not in seen:
                             yield NegativeValue(
                                 value, description="String smaller than minLength", location=ctx.current_path
                             )
                             seen.add(k)
+                    else:
+                        with suppress(InvalidArgument):
+                            min_length = max_length = value - 1
+                            new_schema = {**schema, "minLength": min_length, "maxLength": max_length}
+                            new_schema.setdefault("type", "string")
+                            if "pattern" in new_schema:
+                                new_schema["pattern"] = update_quantifier(schema["pattern"], min_length, max_length)
+                                if new_schema["pattern"] == schema["pattern"]:
+                                    # Pattern wasn't updated, try to generate a valid value then shrink the string to the required length
+                                    del new_schema["minLength"]
+                                    del new_schema["maxLength"]
+                                    value = ctx.generate_from_schema(new_schema)[:max_length]
+                                else:
+                                    value = ctx.generate_from_schema(new_schema)
+                            else:
+                                value = ctx.generate_from_schema(new_schema)
+                            k = _to_hashable_key(value)
+                            if k not in seen:
+                                yield NegativeValue(
+                                    value, description="String smaller than minLength", location=ctx.current_path
+                                )
+                                seen.add(k)
                 elif key == "maxLength" and value < BUFFER_SIZE:
                     try:
                         min_length = max_length = value + 1
                         new_schema = {**schema, "minLength": min_length, "maxLength": max_length}
                         new_schema.setdefault("type", "string")
                         if "pattern" in new_schema:
-                            new_schema["pattern"] = update_quantifier(schema["pattern"], min_length, max_length)
-                            if new_schema["pattern"] == schema["pattern"]:
-                                # Pattern wasn't updated, try to generate a valid value then extend the string to the required length
-                                del new_schema["minLength"]
-                                del new_schema["maxLength"]
-                                value = ctx.generate_from_schema(new_schema).ljust(max_length, "0")
-                            else:
+                            if value > NEGATIVE_MODE_MAX_LENGTH_WITH_PATTERN:
+                                # Large `maxLength` value can be extremely slow to generate when combined with `pattern`
+                                del new_schema["pattern"]
                                 value = ctx.generate_from_schema(new_schema)
+                            else:
+                                new_schema["pattern"] = update_quantifier(schema["pattern"], min_length, max_length)
+                                if new_schema["pattern"] == schema["pattern"]:
+                                    # Pattern wasn't updated, try to generate a valid value then extend the string to the required length
+                                    del new_schema["minLength"]
+                                    del new_schema["maxLength"]
+                                    value = ctx.generate_from_schema(new_schema).ljust(max_length, "0")
+                                else:
+                                    value = ctx.generate_from_schema(new_schema)
                         else:
                             value = ctx.generate_from_schema(new_schema)
                         k = _to_hashable_key(value)
@@ -438,10 +462,22 @@ def cover_schema_iter(
                     template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
                     yield from _negative_required(ctx, template, value)
                 elif key == "maxItems" and isinstance(value, int) and value < BUFFER_SIZE:
-                    try:
-                        # Force the array to have one more item than allowed
-                        new_schema = {**schema, "minItems": value + 1, "maxItems": value + 1, "type": "array"}
+                    if value > NEGATIVE_MODE_MAX_ITEMS:
+                        # It could be extremely slow to generate large arrays
+                        # Generate values up to the limit and reuse them to construct the final array
+                        new_schema = {
+                            **schema,
+                            "minItems": NEGATIVE_MODE_MAX_ITEMS,
+                            "maxItems": NEGATIVE_MODE_MAX_ITEMS,
+                            "type": "array",
+                        }
                         array_value = ctx.generate_from_schema(new_schema)
+                        # Extend the array to be of length value + 1 by repeating its own elements
+                        diff = value + 1 - len(array_value)
+                        if diff > 0:
+                            array_value += (
+                                array_value * (diff // len(array_value)) + array_value[: diff % len(array_value)]
+                            )
                         k = _to_hashable_key(array_value)
                         if k not in seen:
                             yield NegativeValue(
@@ -450,8 +486,21 @@ def cover_schema_iter(
                                 location=ctx.current_path,
                             )
                             seen.add(k)
-                    except (InvalidArgument, Unsatisfiable):
-                        pass
+                    else:
+                        try:
+                            # Force the array to have one more item than allowed
+                            new_schema = {**schema, "minItems": value + 1, "maxItems": value + 1, "type": "array"}
+                            array_value = ctx.generate_from_schema(new_schema)
+                            k = _to_hashable_key(array_value)
+                            if k not in seen:
+                                yield NegativeValue(
+                                    array_value,
+                                    description="Array with more items than allowed by maxItems",
+                                    location=ctx.current_path,
+                                )
+                                seen.add(k)
+                        except (InvalidArgument, Unsatisfiable):
+                            pass
                 elif key == "minItems" and isinstance(value, int) and value > 0:
                     try:
                         # Force the array to have one less item than the minimum
@@ -683,19 +732,22 @@ def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Gener
 
     if example or examples or default:
         if example:
+            seen.add(_to_hashable_key(example))
             yield PositiveValue(example, description="Example value")
         if examples:
             for example in examples:
+                seen.add(_to_hashable_key(example))
                 yield PositiveValue(example, description="Example value")
         if (
             default
             and not (example is not None and default == example)
             and not (examples is not None and any(default == ex for ex in examples))
         ):
+            seen.add(_to_hashable_key(default))
             yield PositiveValue(default, description="Default value")
     else:
         yield PositiveValue(template, description="Valid array")
-    seen.add(len(template))
+    seen.add(_to_hashable_key(template))
 
     # Boundary and near-boundary sizes
     min_items = schema.get("minItems")
@@ -706,19 +758,19 @@ def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Gener
         # One item more than minimum if possible
         larger = min_items + 1
         if larger not in seen and (max_items is None or larger <= max_items):
-            yield PositiveValue(
-                ctx.generate_from_schema({**schema, "minItems": larger, "maxItems": larger}),
-                description="Near-boundary items array",
-            )
-            seen.add(larger)
+            value = ctx.generate_from_schema({**schema, "minItems": larger, "maxItems": larger})
+            key = _to_hashable_key(value)
+            if key not in seen:
+                seen.add(key)
+                yield PositiveValue(value, description="Near-boundary items array")
 
     if max_items is not None:
         if max_items < BUFFER_SIZE and max_items not in seen:
-            yield PositiveValue(
-                ctx.generate_from_schema({**schema, "minItems": max_items}),
-                description="Maximum items array",
-            )
-            seen.add(max_items)
+            value = ctx.generate_from_schema({**schema, "minItems": max_items})
+            key = _to_hashable_key(value)
+            if key not in seen:
+                seen.add(key)
+                yield PositiveValue(value, description="Maximum items array")
 
         # One item smaller than maximum if possible
         smaller = max_items - 1
@@ -728,11 +780,26 @@ def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Gener
             and smaller not in seen
             and (min_items is None or smaller >= min_items)
         ):
-            yield PositiveValue(
-                ctx.generate_from_schema({**schema, "minItems": smaller, "maxItems": smaller}),
-                description="Near-boundary items array",
-            )
-            seen.add(smaller)
+            value = ctx.generate_from_schema({**schema, "minItems": smaller, "maxItems": smaller})
+            key = _to_hashable_key(value)
+            if key not in seen:
+                seen.add(key)
+                yield PositiveValue(value, description="Near-boundary items array")
+
+    if "items" in schema and "enum" in schema["items"] and isinstance(schema["items"]["enum"], list) and max_items != 0:
+        # Ensure there is enough items to pass `minItems` if it is specified
+        length = min_items or 1
+        for variant in schema["items"]["enum"]:
+            value = [variant] * length
+            key = _to_hashable_key(value)
+            if key not in seen:
+                seen.add(key)
+                yield PositiveValue(value, description="Enum value from available for items array")
+    elif min_items is None and max_items is None and "items" in schema and isinstance(schema["items"], dict):
+        # Otherwise only an empty array is generated
+        sub_schema = schema["items"]
+        for item in cover_schema_iter(ctx, sub_schema):
+            yield PositiveValue([item.value], description=f"Single-item array: {item.description}")
 
 
 def _positive_object(ctx: CoverageContext, schema: dict, template: dict) -> Generator[GeneratedValue, None, None]:

schemathesis/generation/hypothesis/builder.py

@@ -1,17 +1,18 @@
 from __future__ import annotations
 
 import asyncio
+import os
 from dataclasses import dataclass, field
 from enum import Enum
 from functools import wraps
 from itertools import combinations
-import os
 from time import perf_counter
 from typing import Any, Callable, Generator, Mapping
 
 import hypothesis
 from hypothesis import Phase
 from hypothesis import strategies as st
+from hypothesis._settings import all_settings
 from hypothesis.errors import Unsatisfiable
 from jsonschema.exceptions import SchemaError
 
@@ -98,7 +99,11 @@ def create_test(
         # Merge the user-provided settings with the current ones
         settings = hypothesis.settings(
             settings,
-            **{item: value for item, value in config.settings.__dict__.items() if value != getattr(default, item)},
+            **{
+                item: getattr(config.settings, item)
+                for item in all_settings
+                if getattr(config.settings, item) != getattr(default, item)
+            },
         )
 
     if Phase.explain in settings.phases:

schemathesis/specs/openapi/patterns.py

@@ -69,13 +69,18 @@ def _handle_parsed_pattern(parsed: list, pattern: str, min_length: int | None, m
         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
-        )
+        # Special case for patterns canonicalisation. Some frameworks generate `\\w\\W` instead of `.`
+        # Such patterns lead to significantly slower data generation
+        if op == sre.IN and _matches_anything(value):
+            op = sre.ANY
+            value = None
+            inner_pattern = "."
+        elif op in REPEATS and len(value[2]) == 1 and value[2][0][0] == sre.IN and _matches_anything(value[2][0][1]):
+            value = (value[0], value[1], [(sre.ANY, None)], *value[3:])
+            inner_pattern = "."
+        else:
+            inner_pattern = pattern[leading_anchor_length:-trailing_anchor_length]
+        return leading_anchor + _update_quantifier(op, value, inner_pattern, min_length, max_length) + trailing_anchor
     elif (
         len(parsed) > 3
         and parsed[0][0] == ANCHOR
@@ -86,6 +91,19 @@ def _handle_parsed_pattern(parsed: list, pattern: str, min_length: int | None, m
     return pattern
 
 
+def _matches_anything(value: list) -> bool:
+    """Check if the given pattern is equivalent to '.' (match any character)."""
+    # Common forms: [\w\W], [\s\S], etc.
+    return value in (
+        [(sre.CATEGORY, sre.CATEGORY_WORD), (sre.CATEGORY, sre.CATEGORY_NOT_WORD)],
+        [(sre.CATEGORY, sre.CATEGORY_SPACE), (sre.CATEGORY, sre.CATEGORY_NOT_SPACE)],
+        [(sre.CATEGORY, sre.CATEGORY_DIGIT), (sre.CATEGORY, sre.CATEGORY_NOT_DIGIT)],
+        [(sre.CATEGORY, sre.CATEGORY_NOT_WORD), (sre.CATEGORY, sre.CATEGORY_WORD)],
+        [(sre.CATEGORY, sre.CATEGORY_NOT_SPACE), (sre.CATEGORY, sre.CATEGORY_SPACE)],
+        [(sre.CATEGORY, sre.CATEGORY_NOT_DIGIT), (sre.CATEGORY, sre.CATEGORY_DIGIT)],
+    )
+
+
 def _handle_anchored_pattern(parsed: list, pattern: str, min_length: int | None, max_length: int | None) -> str:
     """Update regex pattern with multiple quantified patterns to satisfy length constraints."""
     # Extract anchors
@@ -269,15 +287,28 @@ def _get_anchor_length(node_type: int) -> int:
     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:
+def _update_quantifier(
+    op: int, value: tuple | None, 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:
+    if op in REPEATS and value is not None:
         return _handle_repeat_quantifier(value, pattern, min_length, max_length)
     if op in (LITERAL, IN) and max_length != 0:
         return _handle_literal_or_in_quantifier(pattern, min_length, max_length)
+    if op == sre.ANY and value is None:
+        # Equivalent to `.` which is in turn is the same as `.{1}`
+        return _handle_repeat_quantifier(
+            SINGLE_ANY,
+            pattern,
+            min_length,
+            max_length,
+        )
     return pattern
 
 
+SINGLE_ANY = sre_parse.parse(".{1}")[0][1]
+
+
 def _handle_repeat_quantifier(
     value: tuple[int, int, tuple], pattern: str, min_length: int | None, max_length: int | None
 ) -> str:

schemathesis/specs/openapi/schemas.py

@@ -1195,7 +1195,11 @@ class OpenApi30(SwaggerV20):
         files = []
         definition = operation.definition.raw
         if "$ref" in definition["requestBody"]:
-            body = self.resolver.resolve_all(definition["requestBody"], RECURSION_DEPTH_LIMIT)
+            self.resolver.push_scope(operation.definition.scope)
+            try:
+                body = self.resolver.resolve_all(definition["requestBody"], RECURSION_DEPTH_LIMIT)
+            finally:
+                self.resolver.pop_scope()
         else:
             body = definition["requestBody"]
         content = body["content"]

{schemathesis-4.0.0a8.dist-info → schemathesis-4.0.0a9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.0.0a8
+Version: 4.0.0a9
 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

{schemathesis-4.0.0a8.dist-info → schemathesis-4.0.0a9.dist-info}/RECORD

@@ -74,13 +74,13 @@ schemathesis/engine/phases/unit/_pool.py,sha256=9OgmFd-ov1AAvcZGquK40PXkGLp7f2qC
 schemathesis/experimental/__init__.py,sha256=jYY3Mq6okqTRTMudPzcaT0JVjzJW5IN_ZVJdGU0stBs,2011
 schemathesis/generation/__init__.py,sha256=sWTRPTh-qDNkSfpM9rYI3v8zskH8_wFKUuPRg18fZI8,1627
 schemathesis/generation/case.py,sha256=Rt5MCUtPVYVQzNyjUx8magocPJpHV1svyuqQSTwUE-I,7306
-schemathesis/generation/coverage.py,sha256=vv2dbj_KAaqo8PCwMdyDWLyyAssk-YL5oTU3aCkgB1s,41185
+schemathesis/generation/coverage.py,sha256=YQHmC_wVQ9WBuThNr62LFort9WqHM1DHUtexk-ALSV8,45471
 schemathesis/generation/meta.py,sha256=36h6m4E7jzLGa8TCvl7eBl_xUWLiRul3qxzexl5cB58,2515
 schemathesis/generation/modes.py,sha256=t_EvKr2aOXYMsEfdMu4lLF4KCGcX1LVVyvzTkcpJqhk,663
 schemathesis/generation/overrides.py,sha256=FhqcFoliEvgW6MZyFPYemfLgzKt3Miy8Cud7OMOCb7g,3045
 schemathesis/generation/targets.py,sha256=_rN2qgxTE2EfvygiN-Fy3WmDnRH0ERohdx3sKRDaYhU,2120
 schemathesis/generation/hypothesis/__init__.py,sha256=Rl7QwvMBMJI7pBqTydplX6bXC420n0EGQHVm-vZgaYQ,1204
-schemathesis/generation/hypothesis/builder.py,sha256=cSgFWQG-apIHNdW-PpIBDBjLw4RorihfZ4e_Ln3j2-w,30341
+schemathesis/generation/hypothesis/builder.py,sha256=QDfZRpFjQ0KYFPgu2BVSlxop0TQL7fQc201jOMR4rSQ,30472
 schemathesis/generation/hypothesis/examples.py,sha256=6eGaKUEC3elmKsaqfKj1sLvM8EHc-PWT4NRBq4NI0Rs,1409
 schemathesis/generation/hypothesis/given.py,sha256=sTZR1of6XaHAPWtHx2_WLlZ50M8D5Rjux0GmWkWjDq4,2337
 schemathesis/generation/hypothesis/reporting.py,sha256=uDVow6Ya8YFkqQuOqRsjbzsbyP4KKfr3jA7ZaY4FuKY,279
@@ -121,9 +121,9 @@ schemathesis/specs/openapi/examples.py,sha256=Xvjp60QUcLaeGsJRbi2i6XM15_4uO0ceVo
 schemathesis/specs/openapi/formats.py,sha256=ViVF3aFeFI1ctwGQbiRDXhU3so82P0BCaF2aDDbUUm8,2816
 schemathesis/specs/openapi/media_types.py,sha256=ADedOaNWjbAtAekyaKmNj9fY6zBTeqcNqBEjN0EWNhI,1014
 schemathesis/specs/openapi/parameters.py,sha256=tVL61gDe9A8_jwoVKZZvpXKPerMyq7vkAvwdMsi44TI,14622
-schemathesis/specs/openapi/patterns.py,sha256=NLnGybcana_kYLVKVEjkEyAzdClAV0xKe4Oy4NVayMI,12834
+schemathesis/specs/openapi/patterns.py,sha256=EQdf4net9QtwngKv36FEr7l0-3_afIMrrBdpKUWGWGc,14382
 schemathesis/specs/openapi/references.py,sha256=c8Ufa8hp6Dyf-gPn5lpmyqF_GtqXIBWoKkj3bk3WaPA,8871
-schemathesis/specs/openapi/schemas.py,sha256=zfGPFWnaI9_W8F8E8qCTzuYQRE5yDuGx7WGW4EH-QgI,55020
+schemathesis/specs/openapi/schemas.py,sha256=dL1uLz_twgJZUdYBcs2JJ3b8ZlQH3nrGUg1p78pm9Os,55169
 schemathesis/specs/openapi/security.py,sha256=6UWYMhL-dPtkTineqqBFNKca1i4EuoTduw-EOLeE0aQ,7149
 schemathesis/specs/openapi/serialization.py,sha256=VdDLmeHqxlWM4cxQQcCkvrU6XurivolwEEaT13ohelA,11972
 schemathesis/specs/openapi/utils.py,sha256=ER4vJkdFVDIE7aKyxyYatuuHVRNutytezgE52pqZNE8,900
@@ -146,8 +146,8 @@ schemathesis/transport/prepare.py,sha256=qQ6zXBw5NN2AIM0bzLAc5Ryc3dmMb0R6xN14lnR
 schemathesis/transport/requests.py,sha256=j5wI1Uo_PnVuP1eV8l6ddsXosyxAPQ1mLSyWEZmTI9I,8747
 schemathesis/transport/serialization.py,sha256=jIMra1LqRGav0OX3Hx7mvORt38ll4cd2DKit2D58FN0,10531
 schemathesis/transport/wsgi.py,sha256=RWSuUXPrl91GxAy8a4jyNNozOWVMRBxKx_tljlWA_Lo,5697
-schemathesis-4.0.0a8.dist-info/METADATA,sha256=hdJd_ASqgZ75dZ1EW27p3mL6CAG179nTb-cm1zVtQqk,10427
-schemathesis-4.0.0a8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-4.0.0a8.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
-schemathesis-4.0.0a8.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
-schemathesis-4.0.0a8.dist-info/RECORD,,
+schemathesis-4.0.0a9.dist-info/METADATA,sha256=xL00zLDR06C2Jth4cyLvr-lrNBb5mDkognESM0xvJfI,10427
+schemathesis-4.0.0a9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.0.0a9.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.0.0a9.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
+schemathesis-4.0.0a9.dist-info/RECORD,,