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

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/cli/context.py

@@ -4,7 +4,7 @@ import os
 import shutil
 from dataclasses import dataclass, field
 from queue import Queue
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Generator
 
 from ..code_samples import CodeSampleStyle
 from ..internal.deprecation import deprecated_property
@@ -60,11 +60,15 @@ class ExecutionContext:
     analysis: Result[AnalysisResult, Exception] | None = None
     output_config: OutputConfig = field(default_factory=OutputConfig)
     state_machine_sink: StateMachineSink | None = None
-    summary_lines: list[str] = field(default_factory=list)
+    initialization_lines: list[str | Generator[str, None, None]] = field(default_factory=list)
+    summary_lines: list[str | Generator[str, None, None]] = field(default_factory=list)
 
     @deprecated_property(removed_in="4.0", replacement="show_trace")
     def show_errors_tracebacks(self) -> bool:
         return self.show_trace
 
-    def add_summary_line(self, line: str) -> None:
+    def add_initialization_line(self, line: str | Generator[str, None, None]) -> None:
+        self.initialization_lines.append(line)
+
+    def add_summary_line(self, line: str | Generator[str, None, None]) -> None:
         self.summary_lines.append(line)

schemathesis/cli/output/default.py

@@ -7,6 +7,7 @@ import textwrap
 import time
 from importlib import metadata
 from queue import Queue
+from types import GeneratorType
 from typing import TYPE_CHECKING, Any, Generator, Literal, cast
 
 import click
@@ -776,6 +777,8 @@ def handle_initialized(context: ExecutionContext, event: events.Initialized) ->
     click.secho(f"Collected API links: {links_count}", bold=True)
     if isinstance(context.report, ServiceReportContext):
         click.secho("Report to Schemathesis.io: ENABLED", bold=True)
+    if context.initialization_lines:
+        _print_lines(context.initialization_lines)
 
 
 def handle_before_probing(context: ExecutionContext, event: events.BeforeProbing) -> None:
@@ -852,12 +855,20 @@ def handle_finished(context: ExecutionContext, event: events.Finished) -> None:
     display_statistic(context, event)
     if context.summary_lines:
         click.echo()
-        for line in context.summary_lines:
-            click.echo(line)
+        _print_lines(context.summary_lines)
     click.echo()
     display_summary(event)
 
 
+def _print_lines(lines: list[str | Generator[str, None, None]]) -> None:
+    for entry in lines:
+        if isinstance(entry, str):
+            click.echo(entry)
+        elif isinstance(entry, GeneratorType):
+            for line in entry:
+                click.echo(line)
+
+
 def handle_interrupted(context: ExecutionContext, event: events.Interrupted) -> None:
     click.echo()
     _handle_interrupted(context)

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
@@ -180,6 +234,15 @@ def cover_schema_iter(ctx: CoverageContext, schema: dict) -> Generator:
                         yield from cover_schema_iter(nctx, sub_schema)
 
 
+def _get_properties(schema: dict | bool) -> dict | bool:
+    if isinstance(schema, dict):
+        if "example" in schema:
+            return {"const": schema["example"]}
+        if schema.get("type") == "object":
+            return _get_template_schema(schema, "object")
+    return schema
+
+
 def _get_template_schema(schema: dict, ty: str) -> dict:
     if ty == "object":
         properties = schema.get("properties")
@@ -188,41 +251,40 @@ def _get_template_schema(schema: dict, ty: str) -> dict:
                 **schema,
                 "required": list(properties),
                 "type": ty,
-                "properties": {
-                    k: _get_template_schema(v, "object") if v.get("type") == "object" else v
-                    for k, v in properties.items()
-                },
+                "properties": {k: _get_properties(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")
     max_length = schema.get("maxLength")
 
-    if not min_length and not max_length:
+    if "example" in schema:
+        yield PositiveValue(schema["example"])
+    elif 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 +294,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 +306,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")
@@ -257,9 +319,11 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator:
         maximum = exclusive_maximum - 1
     multiple_of = schema.get("multipleOf")
 
-    if not minimum and not maximum:
+    if "example" in schema:
+        yield PositiveValue(schema["example"])
+    elif 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 +334,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 +343,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 +353,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 +362,15 @@ 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
+    if "example" in schema:
+        yield PositiveValue(schema["example"])
+    else:
+        yield PositiveValue(template)
     seen.add(len(template))
 
     # Boundary and near-boundary sizes
@@ -315,99 +382,102 @@ 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]:
+    if "example" in schema:
+        yield PositiveValue(schema["example"])
+    else:
+        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 +499,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/events.py

@@ -14,7 +14,7 @@ from .serialization import SerializedError, SerializedTestResult
 
 if TYPE_CHECKING:
     from ..models import APIOperation, Status, TestResult, TestResultSet
-    from ..schemas import BaseSchema
+    from ..schemas import BaseSchema, Specification
     from ..service.models import AnalysisResult
     from ..stateful import events
     from . import probes
@@ -39,6 +39,7 @@ class Initialized(ExecutionEvent):
     """Runner is initialized, settings are prepared, requests session is ready."""
 
     schema: dict[str, Any]
+    specification: Specification
     # Total number of operations in the schema
     operations_count: int | None
     # Total number of links in the schema
@@ -71,6 +72,7 @@ class Initialized(ExecutionEvent):
         """Computes all needed data from a schema instance."""
         return cls(
             schema=schema.raw_schema,
+            specification=schema.specification,
             operations_count=schema.operations_count if count_operations else None,
             links_count=schema.links_count if count_links else None,
             location=schema.location,