schemathesis 3.35.0__py3-none-any.whl → 3.35.1__py3-none-any.whl

schemathesis/_hypothesis.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import json
 import warnings
 from typing import Any, Callable, Generator, Mapping, Optional, Tuple
 
@@ -19,9 +20,10 @@ from .exceptions import OperationSchemaError, SerializationNotPossible
 from .experimental import COVERAGE_PHASE
 from .generation import DataGenerationMethod, GenerationConfig, combine_strategies, coverage, get_single_example
 from .hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher
-from .models import APIOperation, Case
+from .models import APIOperation, Case, GenerationMetadata, TestPhase
 from .transports.content_types import parse_content_type
 from .transports.headers import has_invalid_characters, is_latin_1_encodable
+from .types import NotSet
 from .utils import GivenInput
 
 # Forcefully initializes Hypothesis' global PRNG to avoid races that initilize it
@@ -215,39 +217,63 @@ def _iter_coverage_cases(
     from .specs.openapi.constants import LOCATION_TO_CONTAINER
 
     ctx = coverage.CoverageContext(data_generation_methods=data_generation_methods)
-    generators: dict[tuple[str, str], Generator] = {}
+    meta = GenerationMetadata(
+        query=None, path_parameters=None, headers=None, cookies=None, body=None, phase=TestPhase.COVERAGE
+    )
+    generators: dict[tuple[str, str], Generator[coverage.GeneratedValue, None, None]] = {}
     template: dict[str, Any] = {}
+    template_generation_method = DataGenerationMethod.positive
     for parameter in operation.iter_parameters():
         schema = parameter.as_json_schema(operation)
         gen = coverage.cover_schema_iter(ctx, schema)
         value = next(gen, NOT_SET)
-        if value is NOT_SET:
+        if isinstance(value, NotSet):
             continue
         location = parameter.location
         name = parameter.name
         container = template.setdefault(LOCATION_TO_CONTAINER[location], {})
-        container[name] = value
+        if location in ("header", "cookie") and not isinstance(value.value, str):
+            container[name] = json.dumps(value.value)
+        else:
+            container[name] = value.value
+        template_generation_method = value.data_generation_method
         generators[(location, name)] = gen
     if operation.body:
         for body in operation.body:
             schema = body.as_json_schema(operation)
             gen = coverage.cover_schema_iter(ctx, schema)
             value = next(gen, NOT_SET)
-            if value is NOT_SET:
+            if isinstance(value, NotSet):
                 continue
             if "body" not in template:
-                template["body"] = value
+                template["body"] = value.value
                 template["media_type"] = body.media_type
-            yield operation.make_case(**{**template, "body": value, "media_type": body.media_type})
+            case = operation.make_case(**{**template, "body": value.value, "media_type": body.media_type})
+            case.data_generation_method = value.data_generation_method
+            case.meta = meta
+            yield case
             for next_value in gen:
-                yield operation.make_case(**{**template, "body": next_value, "media_type": body.media_type})
+                case = operation.make_case(**{**template, "body": next_value.value, "media_type": body.media_type})
+                case.data_generation_method = next_value.data_generation_method
+                case.meta = meta
+                yield case
     else:
-        yield operation.make_case(**template)
+        case = operation.make_case(**template)
+        case.data_generation_method = template_generation_method
+        case.meta = meta
+        yield case
     for (location, name), gen in generators.items():
         container_name = LOCATION_TO_CONTAINER[location]
         container = template[container_name]
         for value in gen:
-            yield operation.make_case(**{**template, container_name: {**container, name: value}})
+            if location in ("header", "cookie") and not isinstance(value.value, str):
+                generated = json.dumps(value.value)
+            else:
+                generated = value.value
+            case = operation.make_case(**{**template, container_name: {**container, name: generated}})
+            case.data_generation_method = value.data_generation_method
+            case.meta = meta
+            yield case
 
 
 def find_invalid_headers(headers: Mapping) -> Generator[Tuple[str, str], None, None]:

schemathesis/cli/cassettes.py

@@ -226,6 +226,7 @@ http_interactions:"""
             for interaction in item.interactions:
                 status = interaction.status.name.upper()
                 # Body payloads are handled via separate `stream.write` calls to avoid some allocations
+                phase = f"'{interaction.phase.value}'" if interaction.phase is not None else "null"
                 stream.write(
                     f"""\n- id: '{current_id}'
   status: '{status}'
@@ -233,6 +234,7 @@ http_interactions:"""
   thread_id: {item.thread_id}
   correlation_id: '{item.correlation_id}'
   data_generation_method: '{interaction.data_generation_method.value}'
+  phase: {phase}
   elapsed: '{interaction.response.elapsed}'
   recorded_at: '{interaction.recorded_at}'
   checks:

schemathesis/generation/coverage.py

@@ -1,17 +1,19 @@
 from __future__ import annotations
 
 import json
-from contextlib import suppress
+from contextlib import contextmanager, suppress
 from dataclasses import dataclass, field
 from functools import lru_cache
-from typing import Any, Generator, Set, TypeVar, cast
+from typing import Any, Generator, Set, Type, TypeVar, cast
 
 import jsonschema
 from hypothesis import strategies as st
-from hypothesis.errors import Unsatisfiable
+from hypothesis.errors import InvalidArgument, Unsatisfiable
 from hypothesis_jsonschema import from_schema
 from hypothesis_jsonschema._canonicalise import canonicalish
 
+from schemathesis.constants import NOT_SET
+
 from ._hypothesis import combine_strategies, get_single_example
 from ._methods import DataGenerationMethod
 
@@ -29,6 +31,26 @@ UNKNOWN_PROPERTY_KEY = "x-schemathesis-unknown-property"
 UNKNOWN_PROPERTY_VALUE = 42
 
 
+@dataclass
+class GeneratedValue:
+    value: Any
+    data_generation_method: DataGenerationMethod
+
+    __slots__ = ("value", "data_generation_method")
+
+    @classmethod
+    def with_positive(cls, value: Any) -> GeneratedValue:
+        return cls(value, DataGenerationMethod.positive)
+
+    @classmethod
+    def with_negative(cls, value: Any) -> GeneratedValue:
+        return cls(value, DataGenerationMethod.negative)
+
+
+PositiveValue = GeneratedValue.with_positive
+NegativeValue = GeneratedValue.with_negative
+
+
 @lru_cache(maxsize=128)
 def cached_draw(strategy: st.SearchStrategy) -> Any:
     return get_single_example(strategy)
@@ -67,11 +89,9 @@ def _to_hashable_key(value: T) -> T | tuple[type, str]:
     return value
 
 
-def cover_schema(ctx: CoverageContext, schema: dict) -> list:
-    return list(cover_schema_iter(ctx, schema))
-
-
-def _cover_positive_for_type(ctx: CoverageContext, schema: dict, ty: str | None) -> Generator:
+def _cover_positive_for_type(
+    ctx: CoverageContext, schema: dict, ty: str | None
+) -> Generator[GeneratedValue, None, None]:
     if ty == "object" or ty == "array":
         template_schema = _get_template_schema(schema, ty)
         template = ctx.generate_from_schema(template_schema)
@@ -79,8 +99,8 @@ def _cover_positive_for_type(ctx: CoverageContext, schema: dict, ty: str | None)
         template = None
     if DataGenerationMethod.positive in ctx.data_generation_methods:
         ctx = ctx.with_positive()
-        enum = schema.get("enum")
-        const = schema.get("const")
+        enum = schema.get("enum", NOT_SET)
+        const = schema.get("const", NOT_SET)
         for key in ("anyOf", "oneOf"):
             sub_schemas = schema.get(key)
             if sub_schemas is not None:
@@ -91,43 +111,70 @@ def _cover_positive_for_type(ctx: CoverageContext, schema: dict, ty: str | None)
             if len(all_of) == 1:
                 yield from cover_schema_iter(ctx, all_of[0])
             else:
-                canonical = canonicalish(schema)
-                yield from cover_schema_iter(ctx, canonical)
-        if enum is not None:
-            yield from enum
-        elif const is not None:
-            yield const
+                with suppress(jsonschema.SchemaError):
+                    canonical = canonicalish(schema)
+                    yield from cover_schema_iter(ctx, canonical)
+        if enum is not NOT_SET:
+            for value in enum:
+                yield PositiveValue(value)
+        elif const is not NOT_SET:
+            yield PositiveValue(const)
         elif ty is not None:
             if ty == "null":
-                yield None
-            if ty == "boolean":
-                yield True
-                yield False
-            if ty == "string":
+                yield PositiveValue(None)
+            elif ty == "boolean":
+                yield PositiveValue(True)
+                yield PositiveValue(False)
+            elif ty == "string":
                 yield from _positive_string(ctx, schema)
-            if ty == "integer" or ty == "number":
+            elif ty == "integer" or ty == "number":
                 yield from _positive_number(ctx, schema)
-            if ty == "array":
+            elif ty == "array":
                 yield from _positive_array(ctx, schema, cast(list, template))
-            if ty == "object":
+            elif ty == "object":
                 yield from _positive_object(ctx, schema, cast(dict, template))
 
 
-def cover_schema_iter(ctx: CoverageContext, schema: dict) -> Generator:
-    types = schema.get("type", [])
+@contextmanager
+def _ignore_unfixable(
+    *,
+    # Cache exception types here as `jsonschema` uses a custom `__getattr__` on the module level
+    # and it may cause errors during the interpreter shutdown
+    ref_error: Type[Exception] = jsonschema.RefResolutionError,
+    schema_error: Type[Exception] = jsonschema.SchemaError,
+) -> Generator:
+    try:
+        yield
+    except (Unsatisfiable, ref_error, schema_error):
+        pass
+    except InvalidArgument as exc:
+        message = str(exc)
+        if "Cannot create non-empty" not in message and "is not in the specified alphabet" not in message:
+            raise
+    except TypeError as exc:
+        if "first argument must be string or compiled pattern" not in str(exc):
+            raise
+
+
+def cover_schema_iter(ctx: CoverageContext, schema: dict | bool) -> Generator[GeneratedValue, None, None]:
+    if isinstance(schema, bool):
+        types = ["null", "boolean", "string", "number", "array", "object"]
+        schema = {}
+    else:
+        types = schema.get("type", [])
     if not isinstance(types, list):
-        types = [types]
+        types = [types]  # type: ignore[unreachable]
     if not types:
-        with suppress(Unsatisfiable, jsonschema.RefResolutionError):
+        with _ignore_unfixable():
             yield from _cover_positive_for_type(ctx, schema, None)
     for ty in types:
-        with suppress(Unsatisfiable, jsonschema.RefResolutionError):
+        with _ignore_unfixable():
             yield from _cover_positive_for_type(ctx, schema, ty)
     if DataGenerationMethod.negative in ctx.data_generation_methods:
         template = None
         seen: Set[Any | tuple[type, str]] = set()
         for key, value in schema.items():
-            with suppress(Unsatisfiable, jsonschema.RefResolutionError):
+            with _ignore_unfixable():
                 if key == "enum":
                     yield from _negative_enum(ctx, value)
                 elif key == "const":
@@ -143,21 +190,27 @@ def cover_schema_iter(ctx: CoverageContext, schema: dict) -> Generator:
                     yield from _negative_format(ctx, schema, value)
                 elif key == "maximum":
                     next = value + 1
-                    yield next
+                    yield NegativeValue(next)
                     seen.add(next)
                 elif key == "minimum":
                     next = value - 1
-                    yield next
+                    yield NegativeValue(next)
                     seen.add(next)
                 elif key == "exclusiveMaximum" or key == "exclusiveMinimum" and value not in seen:
-                    yield value
+                    yield NegativeValue(value)
                     seen.add(value)
                 elif key == "multipleOf":
                     yield from _negative_multiple_of(ctx, schema, value)
                 elif key == "minLength" and 0 < value < BUFFER_SIZE and "pattern" not in schema:
-                    yield ctx.generate_from_schema({**schema, "minLength": value - 1, "maxLength": value - 1})
+                    with suppress(InvalidArgument):
+                        yield NegativeValue(
+                            ctx.generate_from_schema({**schema, "minLength": value - 1, "maxLength": value - 1})
+                        )
                 elif key == "maxLength" and value < BUFFER_SIZE and "pattern" not in schema:
-                    yield ctx.generate_from_schema({**schema, "minLength": value + 1, "maxLength": value + 1})
+                    with suppress(InvalidArgument):
+                        yield NegativeValue(
+                            ctx.generate_from_schema({**schema, "minLength": value + 1, "maxLength": value + 1})
+                        )
                 elif key == "uniqueItems" and value:
                     yield from _negative_unique_items(ctx, schema)
                 elif key == "required":
@@ -165,14 +218,15 @@ def cover_schema_iter(ctx: CoverageContext, schema: dict) -> Generator:
                     yield from _negative_required(ctx, template, value)
                 elif key == "additionalProperties" and not value:
                     template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
-                    yield {**template, UNKNOWN_PROPERTY_KEY: UNKNOWN_PROPERTY_VALUE}
+                    yield NegativeValue({**template, UNKNOWN_PROPERTY_KEY: UNKNOWN_PROPERTY_VALUE})
                 elif key == "allOf":
                     nctx = ctx.with_negative()
                     if len(value) == 1:
                         yield from cover_schema_iter(nctx, value[0])
                     else:
-                        canonical = canonicalish(schema)
-                        yield from cover_schema_iter(nctx, canonical)
+                        with _ignore_unfixable():
+                            canonical = canonicalish(schema)
+                            yield from cover_schema_iter(nctx, canonical)
                 elif key == "anyOf" or key == "oneOf":
                     nctx = ctx.with_negative()
                     # NOTE: Other sub-schemas are not filtered out
@@ -189,14 +243,14 @@ def _get_template_schema(schema: dict, ty: str) -> dict:
                 "required": list(properties),
                 "type": ty,
                 "properties": {
-                    k: _get_template_schema(v, "object") if v.get("type") == "object" else v
+                    k: _get_template_schema(v, "object") if isinstance(v, dict) and v.get("type") == "object" else v
                     for k, v in properties.items()
                 },
             }
     return {**schema, "type": ty}
 
 
-def _positive_string(ctx: CoverageContext, schema: dict) -> Generator:
+def _positive_string(ctx: CoverageContext, schema: dict) -> Generator[GeneratedValue, None, None]:
     """Generate positive string values."""
     # Boundary and near boundary values
     min_length = schema.get("minLength")
@@ -204,25 +258,25 @@ def _positive_string(ctx: CoverageContext, schema: dict) -> Generator:
 
     if not min_length and not max_length:
         # Default positive value
-        yield ctx.generate_from_schema(schema)
+        yield PositiveValue(ctx.generate_from_schema(schema))
 
     seen = set()
 
     if min_length is not None and min_length < BUFFER_SIZE and "pattern" not in schema:
         # Exactly the minimum length
-        yield ctx.generate_from_schema({**schema, "maxLength": min_length})
+        yield PositiveValue(ctx.generate_from_schema({**schema, "maxLength": min_length}))
         seen.add(min_length)
 
         # One character more than minimum if possible
         larger = min_length + 1
         if larger < BUFFER_SIZE and larger not in seen and (not max_length or larger <= max_length):
-            yield ctx.generate_from_schema({**schema, "minLength": larger, "maxLength": larger})
+            yield PositiveValue(ctx.generate_from_schema({**schema, "minLength": larger, "maxLength": larger}))
             seen.add(larger)
 
     if max_length is not None and "pattern" not in schema:
         # Exactly the maximum length
         if max_length < BUFFER_SIZE and max_length not in seen:
-            yield ctx.generate_from_schema({**schema, "minLength": max_length})
+            yield PositiveValue(ctx.generate_from_schema({**schema, "minLength": max_length}))
             seen.add(max_length)
 
         # One character less than maximum if possible
@@ -232,7 +286,7 @@ def _positive_string(ctx: CoverageContext, schema: dict) -> Generator:
             and smaller not in seen
             and (smaller > 0 and (min_length is None or smaller >= min_length))
         ):
-            yield ctx.generate_from_schema({**schema, "minLength": smaller, "maxLength": smaller})
+            yield PositiveValue(ctx.generate_from_schema({**schema, "minLength": smaller, "maxLength": smaller}))
             seen.add(smaller)
 
 
@@ -244,7 +298,7 @@ def closest_multiple_greater_than(y: int, x: int) -> int:
     return x * (quotient + 1)
 
 
-def _positive_number(ctx: CoverageContext, schema: dict) -> Generator:
+def _positive_number(ctx: CoverageContext, schema: dict) -> Generator[GeneratedValue, None, None]:
     """Generate positive integer values."""
     # Boundary and near boundary values
     minimum = schema.get("minimum")
@@ -259,7 +313,7 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator:
 
     if not minimum and not maximum:
         # Default positive value
-        yield ctx.generate_from_schema(schema)
+        yield PositiveValue(ctx.generate_from_schema(schema))
 
     seen = set()
 
@@ -270,7 +324,7 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator:
         else:
             smallest = minimum
         seen.add(smallest)
-        yield smallest
+        yield PositiveValue(smallest)
 
         # One more than minimum if possible
         if multiple_of is not None:
@@ -279,7 +333,7 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator:
             larger = minimum + 1
         if larger not in seen and (not maximum or larger <= maximum):
             seen.add(larger)
-            yield larger
+            yield PositiveValue(larger)
 
     if maximum is not None:
         # Exactly the maximum
@@ -289,7 +343,7 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator:
             largest = maximum
         if largest not in seen:
             seen.add(largest)
-            yield largest
+            yield PositiveValue(largest)
 
         # One less than maximum if possible
         if multiple_of is not None:
@@ -298,12 +352,12 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator:
             smaller = maximum - 1
         if smaller not in seen and (smaller > 0 and (minimum is None or smaller >= minimum)):
             seen.add(smaller)
-            yield smaller
+            yield PositiveValue(smaller)
 
 
-def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Generator:
+def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Generator[GeneratedValue, None, None]:
     seen = set()
-    yield template
+    yield PositiveValue(template)
     seen.add(len(template))
 
     # Boundary and near-boundary sizes
@@ -315,99 +369,99 @@ 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 ctx.generate_from_schema({**schema, "minItems": larger, "maxItems": larger})
+            yield PositiveValue(ctx.generate_from_schema({**schema, "minItems": larger, "maxItems": larger}))
             seen.add(larger)
 
     if max_items is not None:
-        if max_items not in seen:
-            yield ctx.generate_from_schema({**schema, "minItems": max_items})
+        if max_items < BUFFER_SIZE and max_items not in seen:
+            yield PositiveValue(ctx.generate_from_schema({**schema, "minItems": max_items}))
             seen.add(max_items)
 
         # One item smaller than maximum if possible
         smaller = max_items - 1
-        if smaller > 0 and smaller not in seen and (min_items is None or smaller >= min_items):
-            yield ctx.generate_from_schema({**schema, "minItems": smaller, "maxItems": smaller})
+        if (
+            smaller < BUFFER_SIZE
+            and smaller > 0
+            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}))
             seen.add(smaller)
 
 
-def _positive_object(ctx: CoverageContext, schema: dict, template: dict) -> Generator:
-    yield template
+def _positive_object(ctx: CoverageContext, schema: dict, template: dict) -> Generator[GeneratedValue, None, None]:
+    yield PositiveValue(template)
     # Only required properties
     properties = schema.get("properties", {})
     if set(properties) != set(schema.get("required", {})):
         only_required = {k: v for k, v in template.items() if k in schema.get("required", [])}
-        yield only_required
+        yield PositiveValue(only_required)
     seen = set()
     for name, sub_schema in properties.items():
         seen.add(_to_hashable_key(template.get(name)))
         for new in cover_schema_iter(ctx, sub_schema):
-            key = _to_hashable_key(new)
+            key = _to_hashable_key(new.value)
             if key not in seen:
-                yield {**template, name: new}
+                yield PositiveValue({**template, name: new.value})
                 seen.add(key)
         seen.clear()
 
 
-@lru_cache(maxsize=128)
-def _get_negative_enum_strategy(value: tuple) -> st.SearchStrategy:
-    return JSON_STRATEGY.filter(lambda x: x not in value)
-
-
-def _negative_enum(ctx: CoverageContext, value: list) -> Generator:
-    try:
-        strategy = _get_negative_enum_strategy(tuple(value))
-    except TypeError:
-        # The value is not hashable
-        strategy = JSON_STRATEGY.filter(lambda x: x not in value)
+def _negative_enum(ctx: CoverageContext, value: list) -> Generator[GeneratedValue, None, None]:
+    strategy = JSON_STRATEGY.filter(lambda x: x not in value)
     # The exact negative value is not important here
-    yield ctx.generate_from(strategy, cached=True)
+    yield NegativeValue(ctx.generate_from(strategy, cached=True))
 
 
-def _negative_properties(ctx: CoverageContext, template: dict, properties: dict) -> Generator:
+def _negative_properties(
+    ctx: CoverageContext, template: dict, properties: dict
+) -> Generator[GeneratedValue, None, None]:
     nctx = ctx.with_negative()
     for key, sub_schema in properties.items():
         for value in cover_schema_iter(nctx, sub_schema):
-            yield {**template, key: value}
-
-
-@lru_cache(maxsize=128)
-def _get_negative_pattern_strategy(value: str) -> st.SearchStrategy:
-    return st.text().filter(lambda x: x != value)
+            yield NegativeValue({**template, key: value.value})
 
 
-def _negative_pattern(ctx: CoverageContext, pattern: str) -> Generator:
-    yield ctx.generate_from(_get_negative_pattern_strategy(pattern), cached=True)
+def _negative_pattern(ctx: CoverageContext, pattern: str) -> Generator[GeneratedValue, None, None]:
+    yield NegativeValue(ctx.generate_from(st.text().filter(lambda x: x != pattern), cached=True))
 
 
 def _with_negated_key(schema: dict, key: str, value: Any) -> dict:
     return {"allOf": [{k: v for k, v in schema.items() if k != key}, {"not": {key: value}}]}
 
 
-def _negative_multiple_of(ctx: CoverageContext, schema: dict, multiple_of: int | float) -> Generator:
-    yield ctx.generate_from_schema(_with_negated_key(schema, "multipleOf", multiple_of))
+def _negative_multiple_of(
+    ctx: CoverageContext, schema: dict, multiple_of: int | float
+) -> Generator[GeneratedValue, None, None]:
+    yield NegativeValue(ctx.generate_from_schema(_with_negated_key(schema, "multipleOf", multiple_of)))
 
 
-def _negative_unique_items(ctx: CoverageContext, schema: dict) -> Generator:
+def _negative_unique_items(ctx: CoverageContext, schema: dict) -> Generator[GeneratedValue, None, None]:
     unique = ctx.generate_from_schema({**schema, "type": "array", "minItems": 1, "maxItems": 1})
-    yield unique + unique
+    yield NegativeValue(unique + unique)
 
 
-def _negative_required(ctx: CoverageContext, template: dict, required: list[str]) -> Generator:
+def _negative_required(
+    ctx: CoverageContext, template: dict, required: list[str]
+) -> Generator[GeneratedValue, None, None]:
     for key in required:
-        yield {k: v for k, v in template.items() if k != key}
+        yield NegativeValue({k: v for k, v in template.items() if k != key})
 
 
-def _negative_format(ctx: CoverageContext, schema: dict, format: str) -> Generator:
+def _negative_format(ctx: CoverageContext, schema: dict, format: str) -> Generator[GeneratedValue, None, None]:
     # Hypothesis-jsonschema does not canonicalise it properly right now, which leads to unsatisfiable schema
     without_format = {k: v for k, v in schema.items() if k != "format"}
     without_format.setdefault("type", "string")
     strategy = from_schema(without_format)
     if format in jsonschema.Draft202012Validator.FORMAT_CHECKER.checkers:
-        strategy = strategy.filter(lambda v: not jsonschema.Draft202012Validator.FORMAT_CHECKER.conforms(v, format))
-    yield ctx.generate_from(strategy)
+        strategy = strategy.filter(
+            lambda v: (format == "hostname" and v == "")
+            or not jsonschema.Draft202012Validator.FORMAT_CHECKER.conforms(v, format)
+        )
+    yield NegativeValue(ctx.generate_from(strategy))
 
 
-def _negative_type(ctx: CoverageContext, seen: set, ty: str | list[str]) -> Generator:
+def _negative_type(ctx: CoverageContext, seen: set, ty: str | list[str]) -> Generator[GeneratedValue, None, None]:
     strategies = {
         "integer": st.integers(),
         "number": NUMERIC_STRATEGY,
@@ -429,5 +483,5 @@ def _negative_type(ctx: CoverageContext, seen: set, ty: str | list[str]) -> Gene
         strategies["number"] = FLOAT_STRATEGY.filter(lambda x: x != int(x))
     negative_strategy = combine_strategies(tuple(strategies.values())).filter(lambda x: _to_hashable_key(x) not in seen)
     value = ctx.generate_from(negative_strategy, cached=True)
-    yield value
+    yield NegativeValue(value)
     seen.add(_to_hashable_key(value))

schemathesis/models.py

@@ -125,6 +125,15 @@ def prepare_request_data(kwargs: dict[str, Any]) -> PreparedRequestData:
     )
 
 
+@dataclass
+class TestPhase(Enum):
+    __test__ = False
+
+    EXPLICIT = "explicit"
+    COVERAGE = "coverage"
+    GENERATE = "generate"
+
+
 @dataclass
 class GenerationMetadata:
     """Stores various information about how data is generated."""
@@ -134,8 +143,9 @@ class GenerationMetadata:
     headers: DataGenerationMethod | None
     cookies: DataGenerationMethod | None
     body: DataGenerationMethod | None
+    phase: TestPhase
 
-    __slots__ = ("query", "path_parameters", "headers", "cookies", "body")
+    __slots__ = ("query", "path_parameters", "headers", "cookies", "body", "phase")
 
 
 @dataclass(repr=False)
@@ -968,6 +978,7 @@ class Interaction:
     checks: list[Check]
     status: Status
     data_generation_method: DataGenerationMethod
+    phase: TestPhase | None
     recorded_at: str = field(default_factory=lambda: datetime.datetime.now(TIMEZONE).isoformat())
 
     @classmethod
@@ -978,6 +989,7 @@ class Interaction:
             status=status,
             checks=checks,
             data_generation_method=cast(DataGenerationMethod, case.data_generation_method),
+            phase=case.meta.phase if case.meta is not None else None,
         )
 
     @classmethod
@@ -1000,6 +1012,7 @@ class Interaction:
             status=status,
             checks=checks,
             data_generation_method=cast(DataGenerationMethod, case.data_generation_method),
+            phase=case.meta.phase if case.meta is not None else None,
         )
 
 

schemathesis/runner/serialization.py

@@ -28,7 +28,7 @@ from ..exceptions import (
     make_unique_by_key,
 )
 from ..generation import DataGenerationMethod
-from ..models import Case, Check, Interaction, Request, Response, Status, TestResult
+from ..models import Case, Check, Interaction, Request, Response, Status, TestPhase, TestResult
 from ..transports import deserialize_payload, serialize_payload
 
 if TYPE_CHECKING:
@@ -385,6 +385,7 @@ class SerializedInteraction:
     checks: list[SerializedCheck]
     status: Status
     data_generation_method: DataGenerationMethod
+    phase: TestPhase | None
     recorded_at: str
 
     @classmethod
@@ -395,6 +396,7 @@ class SerializedInteraction:
             checks=[SerializedCheck.from_check(check) for check in interaction.checks],
             status=interaction.status,
             data_generation_method=interaction.data_generation_method,
+            phase=interaction.phase,
             recorded_at=interaction.recorded_at,
         )
 

schemathesis/specs/openapi/_hypothesis.py

@@ -25,7 +25,7 @@ from ...generation import DataGenerationMethod, GenerationConfig
 from ...hooks import HookContext, HookDispatcher, apply_to_all_dispatchers
 from ...internal.copy import fast_deepcopy
 from ...internal.validation import is_illegal_surrogate
-from ...models import APIOperation, Case, GenerationMetadata, cant_serialize
+from ...models import APIOperation, Case, GenerationMetadata, TestPhase, cant_serialize
 from ...serializers import Binary
 from ...transports.content_types import parse_content_type
 from ...transports.headers import has_invalid_characters, is_latin_1_encodable
@@ -123,6 +123,7 @@ def get_case_strategy(
     body: Any = NOT_SET,
     media_type: str | None = None,
     skip_on_not_negated: bool = True,
+    phase: TestPhase = TestPhase.GENERATE,
 ) -> Any:
     """A strategy that creates `Case` instances.
 
@@ -213,6 +214,7 @@ def get_case_strategy(
             headers=headers_.generator,
             cookies=cookies_.generator,
             body=body_.generator,
+            phase=phase,
         ),
     )
     auth_context = auths.AuthContext(

schemathesis/specs/openapi/examples.py

@@ -13,7 +13,7 @@ from hypothesis_jsonschema import from_schema
 from ...constants import DEFAULT_RESPONSE_TIMEOUT
 from ...generation import get_single_example
 from ...internal.copy import fast_deepcopy
-from ...models import APIOperation, Case
+from ...models import APIOperation, Case, TestPhase
 from ._hypothesis import get_case_strategy, get_default_format_strategies
 from .constants import LOCATION_TO_CONTAINER
 from .formats import STRING_FORMATS
@@ -67,6 +67,8 @@ def get_strategies_from_examples(
     examples = list(extract_top_level(operation))
     # Add examples from parameter's schemas
     examples.extend(extract_from_schemas(operation))
+    as_strategy_kwargs = as_strategy_kwargs or {}
+    as_strategy_kwargs["phase"] = TestPhase.EXPLICIT
     return [
         get_case_strategy(operation=operation, **{**parameters, **(as_strategy_kwargs or {})}).map(serialize_components)
         for parameters in produce_combinations(examples)

{schemathesis-3.35.0.dist-info → schemathesis-3.35.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemathesis
-Version: 3.35.0
+Version: 3.35.1
 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-3.35.0.dist-info → schemathesis-3.35.1.dist-info}/RECORD

@@ -1,7 +1,7 @@
 schemathesis/__init__.py,sha256=pNaTfaC3NSdediNQuH9QAcuIx3U-MmSydvhS65FZrxw,1984
 schemathesis/_compat.py,sha256=y4RZd59i2NCnZ91VQhnKeMn_8t3SgvLOk2Xm8nymUHY,1837
 schemathesis/_dependency_versions.py,sha256=pjEkkGAfOQJYNb-9UOo84V8nj_lKHr_TGDVdFwY2UU0,816
-schemathesis/_hypothesis.py,sha256=eLDbqhG2fBJ6DuTxXlRfadnHhFc3JE2P5zf0YS9UonQ,12782
+schemathesis/_hypothesis.py,sha256=eRbPWW9WwFJBEsb3nkhZGSYisKfwTJscNlh6x5s5Yvo,14055
 schemathesis/_lazy_import.py,sha256=aMhWYgbU2JOltyWBb32vnWBb6kykOghucEzI_F70yVE,470
 schemathesis/_override.py,sha256=3CbA7P9Q89W3ymaYxiOV5Xpv1yhoBqroLK4YRpYMjX4,1630
 schemathesis/_rate_limiter.py,sha256=q_XWst5hzuAyXQRiZc4s_bx7-JlPYZM_yKDmeavt3oo,242
@@ -17,7 +17,7 @@ schemathesis/graphql.py,sha256=YkoKWY5K8lxp7H3ikAs-IsoDbiPwJvChG7O8p3DgwtI,229
 schemathesis/hooks.py,sha256=Uv9rZHqM2bpb_uYBjf4kqsMeu7XdLOHpRWSaN43xIgw,14774
 schemathesis/lazy.py,sha256=hGwSuWe5tDaGpjZTV4Mj8zqdrHDYHxR22N2p5h2yh1g,18897
 schemathesis/loaders.py,sha256=OtCD1o0TVmSNAUF7dgHpouoAXtY6w9vEtsRVGv4lE0g,4588
-schemathesis/models.py,sha256=WpF-W592_MVWnMZ8t7wt_A2fr3YNLEwPX3r-jwW8GpY,44266
+schemathesis/models.py,sha256=ZA-neOIY3Q6-BLvX9B3TLUO6E-coHCkqcz4S8uDoSAM,44600
 schemathesis/parameters.py,sha256=PndmqQRlEYsCt1kWjSShPsFf6vj7X_7FRdz_-A95eNg,2258
 schemathesis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/sanitization.py,sha256=_qSt04f_XcHrgguyUnowvdfj-b6u409Ubu07i0ivQUQ,9011
@@ -30,7 +30,7 @@ schemathesis/utils.py,sha256=bYvB3l1iMxiUNHu7_1qhOj5gJf_8QUssL4Uoqgrux9A,4878
 schemathesis/cli/__init__.py,sha256=O2VIpE9EWFrklWlVTTFUQGShxN8Ij9nbaOJFslDEmHY,73976
 schemathesis/cli/__main__.py,sha256=MWaenjaUTZIfNPFzKmnkTiawUri7DVldtg3mirLwzU8,92
 schemathesis/cli/callbacks.py,sha256=PJs64n6qGrGC5Yv_yl3fGm797cvN6pp2enFLmSljGKs,15127
-schemathesis/cli/cassettes.py,sha256=lKKKKLjoVT8VnZXjCOCmDYhvLKn1XSrCXCMF9EeftHA,18498
+schemathesis/cli/cassettes.py,sha256=KyODNf0r1ieLe3A-CGcU2EEkQYr0fgVut27AOl54MOM,18615
 schemathesis/cli/constants.py,sha256=wk-0GsoJIel8wFFerQ6Kf_6eAYUtIWkwMFwyAqv3yj4,1635
 schemathesis/cli/context.py,sha256=6OYpSbeRobkdyDGvSj_2_zwEelM9K6fXpUCUjVC2sQM,2243
 schemathesis/cli/debug.py,sha256=_YA-bX1ujHl4bqQDEum7M-I2XHBTEGbvgkhvcvKhmgU,658
@@ -60,7 +60,7 @@ schemathesis/fixups/utf8_bom.py,sha256=lWT9RNmJG8i-l5AXIpaCT3qCPUwRgzXPW3eoOjmZE
 schemathesis/generation/__init__.py,sha256=IzldWIswXBjCUaVInvXDoaXIrUbtZIU5cisnWcg2IX8,1609
 schemathesis/generation/_hypothesis.py,sha256=Qel0mBsZV6tOEspRGfbJKFZevaMgHJjzY1F0Oo1bP_Y,1408
 schemathesis/generation/_methods.py,sha256=jCK09f4sedDfePrS-6BIiE-CcEE8fJ4ZHxq1BHoTltQ,1101
-schemathesis/generation/coverage.py,sha256=_g4jcuNTZ7emudQklcHcnkwNZeP1QBo1smNkGZHeCMo,17176
+schemathesis/generation/coverage.py,sha256=A-U4qHT6y9oBjuLxDvRZd7l227zLh-c15ai14pifUxo,19642
 schemathesis/internal/__init__.py,sha256=93HcdG3LF0BbQKbCteOsFMa1w6nXl8yTmx87QLNJOik,161
 schemathesis/internal/copy.py,sha256=DcL56z-d69kKR_5u8mlHvjSL1UTyUKNMAwexrwHFY1s,1031
 schemathesis/internal/datetime.py,sha256=zPLBL0XXLNfP-KYel3H2m8pnsxjsA_4d-zTOhJg2EPQ,136
@@ -74,7 +74,7 @@ schemathesis/internal/validation.py,sha256=G7i8jIMUpAeOnDsDF_eWYvRZe_yMprRswx0QA
 schemathesis/runner/__init__.py,sha256=-aedUaRBCiTiaooC0OsBbdi4XP8APFOpj6eOzwt5nQ8,21366
 schemathesis/runner/events.py,sha256=F3TizErDI490cDakpyeCbyK9IOecWpuToQ1HGXvBXzo,11531
 schemathesis/runner/probes.py,sha256=no5AfO3kse25qvHevjeUfB0Q3C860V2AYzschUW3QMQ,5688
-schemathesis/runner/serialization.py,sha256=erbXEHyI8rIlkQ42AwgmlH7aAbh313EPqCEfrGKxUls,20040
+schemathesis/runner/serialization.py,sha256=C8F_2KiszQx16DkWm37viN_AJqLi-MF3YyvkdaFSmCs,20116
 schemathesis/runner/impl/__init__.py,sha256=1E2iME8uthYPBh9MjwVBCTFV-P3fi7AdphCCoBBspjs,199
 schemathesis/runner/impl/core.py,sha256=H4sYY59kMXQPeOD4BH3j47Ymvix71FSgyQh36flrQxM,45605
 schemathesis/runner/impl/solo.py,sha256=N7-pUL6nWGiSRUC4Zqy1T4h99vbeQowP6b6cMnobOow,3042
@@ -102,12 +102,12 @@ schemathesis/specs/graphql/schemas.py,sha256=L7u73YXnmqypghWhmj5FaGUAmU57IporT9N
 schemathesis/specs/graphql/validation.py,sha256=uINIOt-2E7ZuQV2CxKzwez-7L9tDtqzMSpnVoRWvxy0,1635
 schemathesis/specs/openapi/__init__.py,sha256=HDcx3bqpa6qWPpyMrxAbM3uTo0Lqpg-BUNZhDJSJKnw,279
 schemathesis/specs/openapi/_cache.py,sha256=PAiAu4X_a2PQgD2lG5H3iisXdyg4SaHpU46bRZvfNkM,4320
-schemathesis/specs/openapi/_hypothesis.py,sha256=XtC-rYiH-GHvWykdSSzPFVK7jHNNL7NtibjSEeIZDQw,24122
+schemathesis/specs/openapi/_hypothesis.py,sha256=XgKq36ONJIWM-8ASnDpzOgcCcVz-uUQw74bOxcUC3n8,24201
 schemathesis/specs/openapi/checks.py,sha256=LiwoL5W_qK40j-JFSc9hfM8IGSszMBUWe71YZJ5FBzw,19931
 schemathesis/specs/openapi/constants.py,sha256=JqM_FHOenqS_MuUE9sxVQ8Hnw0DNM8cnKDwCwPLhID4,783
 schemathesis/specs/openapi/converter.py,sha256=TaYgc5BBHPdkN-n0lqpbeVgLu3eL3L8Wu3y_Vo3TJaQ,2800
 schemathesis/specs/openapi/definitions.py,sha256=Z186F0gNBSCmPg-Kk7Q-n6XxEZHIOzgUyeqixlC62XE,94058
-schemathesis/specs/openapi/examples.py,sha256=aE1OsR4X6OBSgRnFD0mVB2aQ3mWe65xiL2YsLb6xkeU,16169
+schemathesis/specs/openapi/examples.py,sha256=_6vqwVfGuPaJ9GTqmlk6siiS0pikk5wxelLsFQJlaEc,16283
 schemathesis/specs/openapi/formats.py,sha256=JmmkQWNAj5XreXb7Edgj4LADAf4m86YulR_Ec8evpJ4,1220
 schemathesis/specs/openapi/links.py,sha256=DCOu14VOFqKYYFbQJHWICDpmTBzJfeP2v2FXBwW3vBI,17531
 schemathesis/specs/openapi/loaders.py,sha256=AcpvTK8qdirSRcHcinCjQbwfSQSx448LAh_GvFML1C0,25515
@@ -147,8 +147,8 @@ schemathesis/transports/auth.py,sha256=yELjkEkfx4g74hNrd0Db9aFf0xDJDRIwhg2vzKOTZ
 schemathesis/transports/content_types.py,sha256=VrcRQvF5T_TUjrCyrZcYF2LOwKfs3IrLcMtkVSp1ImI,2189
 schemathesis/transports/headers.py,sha256=hr_AIDOfUxsJxpHfemIZ_uNG3_vzS_ZeMEKmZjbYiBE,990
 schemathesis/transports/responses.py,sha256=6-gvVcRK0Ho_lSydUysBNFWoJwZEiEgf6Iv-GWkQGd8,1675
-schemathesis-3.35.0.dist-info/METADATA,sha256=hljiaQNfbUOdt0Dt5mIuOUzyd_Qn4gkFJDWhW2gIev8,19287
-schemathesis-3.35.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-schemathesis-3.35.0.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
-schemathesis-3.35.0.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
-schemathesis-3.35.0.dist-info/RECORD,,
+schemathesis-3.35.1.dist-info/METADATA,sha256=LSbI2JYysmP_4r_z_-lan3zPZW1ymjSoooGoQ81W0R0,19287
+schemathesis-3.35.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+schemathesis-3.35.1.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
+schemathesis-3.35.1.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
+schemathesis-3.35.1.dist-info/RECORD,,