schemathesis 3.35.0__py3-none-any.whl → 3.35.2__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,61 @@ 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] = {}
     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
         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})
-    else:
-        yield operation.make_case(**template)
+                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
+    elif DataGenerationMethod.positive in data_generation_methods:
+        case = operation.make_case(**template)
+        case.data_generation_method = DataGenerationMethod.positive
+        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]: