schemathesis 4.0.26__py3-none-any.whl → 4.1.1__py3-none-any.whl

schemathesis/cli/commands/run/__init__.py

@@ -217,6 +217,12 @@ DEFAULT_PHASES = ["examples", "coverage", "fuzzing", "stateful"]
     type=str,
     callback=validation.validate_rate_limit,
 )
+@grouped_option(
+    "--max-redirects",
+    help="Maximum number of redirects to follow for each request",
+    type=click.IntRange(min=0),
+    show_default=True,
+)
 @grouped_option(
     "--request-timeout",
     help="Timeout limit, in seconds, for each network request during tests",
@@ -448,6 +454,7 @@ def run(
     suppress_health_check: list[HealthCheck] | None,
     warnings: bool | list[SchemathesisWarning] | None,
     rate_limit: str | None = None,
+    max_redirects: int | None = None,
     request_timeout: int | None = None,
     request_tls_verify: bool | None = None,
     request_cert: str | None = None,
@@ -528,6 +535,7 @@ def run(
         workers=workers,
         continue_on_failure=continue_on_failure,
         rate_limit=rate_limit,
+        max_redirects=max_redirects,
         request_timeout=request_timeout,
         tls_verify=request_tls_verify,
         request_cert=request_cert,

schemathesis/cli/commands/run/handlers/cassettes.py

@@ -454,6 +454,7 @@ def har_writer(path: Path, config: SchemathesisConfig, queue: Queue) -> None:
                     )
             elif isinstance(item, Finalize):
                 break
+    har.flush()
 
 
 HARFILE_NO_RESPONSE = harfile.Response(

schemathesis/cli/commands/run/handlers/output.py

@@ -592,6 +592,7 @@ class StatefulProgressManager:
     console: Console
     title: str
     links_selected: int
+    links_inferred: int
     links_total: int
     start_time: float
 
@@ -616,6 +617,7 @@ class StatefulProgressManager:
         "console",
         "title",
         "links_selected",
+        "links_inferred",
         "links_total",
         "start_time",
         "title_progress",
@@ -631,13 +633,16 @@ class StatefulProgressManager:
         "is_interrupted",
     )
 
-    def __init__(self, *, console: Console, title: str, links_selected: int, links_total: int) -> None:
+    def __init__(
+        self, *, console: Console, title: str, links_selected: int, links_inferred: int, links_total: int
+    ) -> None:
         from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
         from rich.style import Style
 
         self.console = console
         self.title = title
         self.links_selected = links_selected
+        self.links_inferred = links_inferred
         self.links_total = links_total
         self.start_time = time.monotonic()
 
@@ -686,9 +691,10 @@ class StatefulProgressManager:
 
         # Initialize progress displays
         self.title_task_id = self.title_progress.add_task("Stateful")
-        self.progress_task_id = self.progress_bar.add_task(
-            "", scenarios=0, links=f"0 covered / {self.links_selected} selected / {self.links_total} total links"
-        )
+        links = f"0 covered / {self.links_selected} selected / {self.links_total} total"
+        if self.links_inferred:
+            links += f" ({self.links_inferred} inferred)"
+        self.progress_task_id = self.progress_bar.add_task("", scenarios=0, links=links)
 
         # Create live display
         group = Group(
@@ -720,11 +726,10 @@ class StatefulProgressManager:
     def _update_progress_display(self) -> None:
         """Update the progress display."""
         assert self.progress_task_id is not None
-        self.progress_bar.update(
-            self.progress_task_id,
-            scenarios=self.scenarios,
-            links=f"{len(self.links_covered)} covered / {self.links_selected} selected / {self.links_total} total links",
-        )
+        links = f"{len(self.links_covered)} covered / {self.links_selected} selected / {self.links_total} total"
+        if self.links_inferred:
+            links += f" ({self.links_inferred} inferred)"
+        self.progress_bar.update(self.progress_task_id, scenarios=self.scenarios, links=links)
 
     def _get_stats_message(self) -> str:
         """Get formatted stats message."""
@@ -888,7 +893,7 @@ class OutputHandler(EventHandler):
         elif phase.name in [PhaseName.EXAMPLES, PhaseName.COVERAGE, PhaseName.FUZZING] and phase.is_enabled:
             self._start_unit_tests(phase.name)
         elif phase.name == PhaseName.STATEFUL_TESTING and phase.is_enabled and phase.skip_reason is None:
-            self._start_stateful_tests()
+            self._start_stateful_tests(event)
 
     def _start_probing(self) -> None:
         self.probing_manager = ProbingProgressManager(console=self.console)
@@ -904,13 +909,18 @@ class OutputHandler(EventHandler):
         )
         self.unit_tests_manager.start()
 
-    def _start_stateful_tests(self) -> None:
+    def _start_stateful_tests(self, event: events.PhaseStarted) -> None:
         assert self.statistic is not None
+        assert event.payload is not None
+        # Total number of links - original ones + inferred during tests
+        links_selected = self.statistic.links.selected + event.payload.inferred_links
+        links_total = self.statistic.links.total + event.payload.inferred_links
         self.stateful_tests_manager = StatefulProgressManager(
             console=self.console,
             title="Stateful",
-            links_selected=self.statistic.links.selected,
-            links_total=self.statistic.links.total,
+            links_selected=links_selected,
+            links_inferred=event.payload.inferred_links,
+            links_total=links_total,
         )
         self.stateful_tests_manager.start()
 
@@ -990,10 +1000,10 @@ class OutputHandler(EventHandler):
             table.add_column("Field", style=Style(color="bright_white", bold=True))
             table.add_column("Value", style="cyan")
             table.add_row("Scenarios:", f"{self.stateful_tests_manager.scenarios}")
-            table.add_row(
-                "API Links:",
-                f"{len(self.stateful_tests_manager.links_covered)} covered / {self.stateful_tests_manager.links_selected} selected / {self.stateful_tests_manager.links_total} total",
-            )
+            message = f"{len(self.stateful_tests_manager.links_covered)} covered / {self.stateful_tests_manager.links_selected} selected / {self.stateful_tests_manager.links_total} total"
+            if self.stateful_tests_manager.links_inferred:
+                message += f" ({self.stateful_tests_manager.links_inferred} inferred)"
+            table.add_row("API Links:", message)
 
             self.console.print()
             self.console.print(Padding(table, BLOCK_PADDING))

schemathesis/config/_operations.py

@@ -199,6 +199,7 @@ class OperationConfig(DiffBase):
     continue_on_failure: bool | None
     tls_verify: bool | str | None
     rate_limit: Limiter | None
+    max_redirects: int | None
     request_timeout: float | int | None
     request_cert: str | None
     request_cert_key: str | None
@@ -218,6 +219,7 @@ class OperationConfig(DiffBase):
         "tls_verify",
         "rate_limit",
         "_rate_limit",
+        "max_redirects",
         "request_timeout",
         "request_cert",
         "request_cert_key",
@@ -239,6 +241,7 @@ class OperationConfig(DiffBase):
         continue_on_failure: bool | None = None,
         tls_verify: bool | str | None = None,
         rate_limit: str | None = None,
+        max_redirects: int | None = None,
         request_timeout: float | int | None = None,
         request_cert: str | None = None,
         request_cert_key: str | None = None,
@@ -260,6 +263,7 @@ class OperationConfig(DiffBase):
         else:
             self.rate_limit = rate_limit
         self._rate_limit = rate_limit
+        self.max_redirects = max_redirects
         self.request_timeout = request_timeout
         self.request_cert = request_cert
         self.request_cert_key = request_cert_key
@@ -308,6 +312,7 @@ class OperationConfig(DiffBase):
             continue_on_failure=data.get("continue-on-failure", None),
             tls_verify=resolve(data.get("tls-verify")),
             rate_limit=resolve(data.get("rate-limit")),
+            max_redirects=data.get("max-redirects"),
             request_timeout=data.get("request-timeout"),
             request_cert=resolve(data.get("request-cert")),
             request_cert_key=resolve(data.get("request-cert-key")),

schemathesis/config/_phases.py

@@ -109,14 +109,40 @@ class CoveragePhaseConfig(DiffBase):
         )
 
 
+@dataclass(repr=False)
+class InferenceConfig(DiffBase):
+    algorithms: list[str]
+
+    __slots__ = ("algorithms",)
+
+    def __init__(
+        self,
+        *,
+        algorithms: list[str] | None = None,
+    ) -> None:
+        self.algorithms = algorithms if algorithms is not None else ["location-headers"]
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> InferenceConfig:
+        return cls(
+            algorithms=data.get("algorithms", ["location-headers"]),
+        )
+
+    @property
+    def is_enabled(self) -> bool:
+        """Inference is enabled if any algorithms are configured."""
+        return bool(self.algorithms)
+
+
 @dataclass(repr=False)
 class StatefulPhaseConfig(DiffBase):
     enabled: bool
     generation: GenerationConfig
     checks: ChecksConfig
     max_steps: int
+    inference: InferenceConfig
 
-    __slots__ = ("enabled", "generation", "checks", "max_steps")
+    __slots__ = ("enabled", "generation", "checks", "max_steps", "inference")
 
     def __init__(
         self,
@@ -125,11 +151,13 @@ class StatefulPhaseConfig(DiffBase):
         generation: GenerationConfig | None = None,
         checks: ChecksConfig | None = None,
         max_steps: int | None = None,
+        inference: InferenceConfig | None = None,
     ) -> None:
         self.enabled = enabled
         self.max_steps = max_steps or DEFAULT_STATEFUL_STEP_COUNT
         self.generation = generation or GenerationConfig()
         self.checks = checks or ChecksConfig()
+        self.inference = inference or InferenceConfig()
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> StatefulPhaseConfig:
@@ -138,6 +166,7 @@ class StatefulPhaseConfig(DiffBase):
             max_steps=data.get("max-steps"),
             generation=GenerationConfig.from_dict(data.get("generation", {})),
             checks=ChecksConfig.from_dict(data.get("checks", {})),
+            inference=InferenceConfig.from_dict(data.get("inference", {})),
         )
 
 
@@ -173,11 +202,20 @@ class PhasesConfig(DiffBase):
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> PhasesConfig:
+        # Use the outer "enabled" value as default for all phases.
+        default_enabled = data.get("enabled", None)
+
+        def merge(sub: dict[str, Any]) -> dict[str, Any]:
+            # Merge the default enabled flag with the sub-dict; the sub-dict takes precedence.
+            if default_enabled is not None:
+                return {"enabled": default_enabled, **sub}
+            return sub
+
         return cls(
-            examples=ExamplesPhaseConfig.from_dict(data.get("examples", {})),
-            coverage=CoveragePhaseConfig.from_dict(data.get("coverage", {})),
-            fuzzing=PhaseConfig.from_dict(data.get("fuzzing", {})),
-            stateful=StatefulPhaseConfig.from_dict(data.get("stateful", {})),
+            examples=ExamplesPhaseConfig.from_dict(merge(data.get("examples", {}))),
+            coverage=CoveragePhaseConfig.from_dict(merge(data.get("coverage", {}))),
+            fuzzing=PhaseConfig.from_dict(merge(data.get("fuzzing", {}))),
+            stateful=StatefulPhaseConfig.from_dict(merge(data.get("stateful", {}))),
         )
 
     def update(self, *, phases: list[str]) -> None:

schemathesis/config/_projects.py

@@ -54,6 +54,7 @@ class ProjectConfig(DiffBase):
     continue_on_failure: bool | None
     tls_verify: bool | str | None
     rate_limit: Limiter | None
+    max_redirects: int | None
     request_timeout: float | int | None
     request_cert: str | None
     request_cert_key: str | None
@@ -76,6 +77,7 @@ class ProjectConfig(DiffBase):
         "tls_verify",
         "rate_limit",
         "_rate_limit",
+        "max_redirects",
         "request_timeout",
         "request_cert",
         "request_cert_key",
@@ -100,6 +102,7 @@ class ProjectConfig(DiffBase):
         continue_on_failure: bool | None = None,
         tls_verify: bool | str = True,
         rate_limit: str | None = None,
+        max_redirects: int | None = None,
         request_timeout: float | int | None = None,
         request_cert: str | None = None,
         request_cert_key: str | None = None,
@@ -133,6 +136,7 @@ class ProjectConfig(DiffBase):
         else:
             self.rate_limit = rate_limit
         self._rate_limit = rate_limit
+        self.max_redirects = max_redirects
         self.request_timeout = request_timeout
         self.request_cert = request_cert
         self.request_cert_key = request_cert_key
@@ -157,6 +161,7 @@ class ProjectConfig(DiffBase):
             continue_on_failure=data.get("continue-on-failure", None),
             tls_verify=resolve(data.get("tls-verify", True)),
             rate_limit=resolve(data.get("rate-limit")),
+            max_redirects=data.get("max-redirects"),
             request_timeout=data.get("request-timeout"),
             request_cert=resolve(data.get("request-cert")),
             request_cert_key=resolve(data.get("request-cert-key")),
@@ -188,6 +193,7 @@ class ProjectConfig(DiffBase):
         workers: int | Literal["auto"] | None = None,
         continue_on_failure: bool | None = None,
         rate_limit: str | None = None,
+        max_redirects: int | None = None,
         request_timeout: float | int | None = None,
         tls_verify: bool | str | None = None,
         request_cert: str | None = None,
@@ -221,6 +227,9 @@ class ProjectConfig(DiffBase):
         if rate_limit is not None:
             self.rate_limit = build_limiter(rate_limit)
 
+        if max_redirects is not None:
+            self.max_redirects = max_redirects
+
         if request_timeout is not None:
             self.request_timeout = request_timeout
 
@@ -264,6 +273,15 @@ class ProjectConfig(DiffBase):
                 headers.update(config.headers)
         return headers
 
+    def max_redirects_for(self, *, operation: APIOperation | None = None) -> int | None:
+        if operation is not None:
+            config = self.operations.get_for_operation(operation=operation)
+            if config.max_redirects is not None:
+                return config.max_redirects
+        if self.max_redirects is not None:
+            return self.max_redirects
+        return None
+
     def request_timeout_for(self, *, operation: APIOperation | None = None) -> float | int | None:
         if operation is not None:
             config = self.operations.get_for_operation(operation=operation)

schemathesis/config/schema.json

@@ -119,6 +119,10 @@
     "rate-limit": {
       "type": "string"
     },
+    "max-redirects": {
+      "type": "integer",
+      "minimum": 0
+    },
     "request-timeout": {
       "type": "number",
       "minimum": 0
@@ -251,6 +255,9 @@
       "type": "object",
       "additionalProperties": false,
       "properties": {
+        "enabled": {
+          "type": "boolean"
+        },
         "examples": {
           "$ref": "#/$defs/ExamplesPhaseConfig"
         },
@@ -309,6 +316,22 @@
           "type": "integer",
           "minimum": 2
         },
+        "inference": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "algorithms": {
+              "type": "array",
+              "items": {
+                "type": "string",
+                "enum": [
+                  "location-headers"
+                ]
+              },
+              "uniqueItems": true
+            }
+          }
+        },
         "generation": {
           "$ref": "#/$defs/GenerationConfig"
         },
@@ -523,6 +546,10 @@
         "rate-limit": {
           "type": "string"
         },
+        "max-redirects": {
+          "type": "integer",
+          "minimum": 0
+        },
         "request-timeout": {
           "type": "number",
           "minimum": 0
@@ -590,6 +617,10 @@
         "rate-limit": {
           "type": "string"
         },
+        "max-redirects": {
+          "type": "integer",
+          "minimum": 0
+        },
         "request-timeout": {
           "type": "number",
           "minimum": 0

schemathesis/core/__init__.py

@@ -7,6 +7,7 @@ SCHEMATHESIS_TEST_CASE_HEADER = "X-Schemathesis-TestCaseId"
 HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER = ":memory:"
 INTERNAL_BUFFER_SIZE = 32 * 1024
 DEFAULT_STATEFUL_STEP_COUNT = 6
+INJECTED_PATH_PARAMETER_KEY = "x-schemathesis-injected"
 
 
 class NotSet: ...

schemathesis/core/failures.py

@@ -310,6 +310,7 @@ def format_failures(
         output += "\n    <NO RESPONSE>"
 
     # cURL
-    output += "\n" + formatter(MessageBlock.CURL, f"\nReproduce with: \n\n    {curl}")
+    _curl = "\n".join(f"    {line}" for line in curl.splitlines())
+    output += "\n" + formatter(MessageBlock.CURL, f"\nReproduce with: \n\n{_curl}")
 
     return output

schemathesis/engine/context.py

@@ -6,16 +6,18 @@ from typing import TYPE_CHECKING, Any
 
 from schemathesis.config import ProjectConfig
 from schemathesis.core import NOT_SET, NotSet
+from schemathesis.engine.control import ExecutionControl
+from schemathesis.engine.observations import Observations
 from schemathesis.generation.case import Case
 from schemathesis.schemas import APIOperation, BaseSchema
 
-from .control import ExecutionControl
-
 if TYPE_CHECKING:
     import threading
 
     import requests
 
+    from schemathesis.engine.recorder import ScenarioRecorder
+
 
 @dataclass
 class EngineContext:
@@ -25,20 +27,31 @@ class EngineContext:
     control: ExecutionControl
     outcome_cache: dict[int, BaseException | None]
     start_time: float
-
-    __slots__ = ("schema", "control", "outcome_cache", "start_time", "_session", "_transport_kwargs_cache")
+    observations: Observations | None
+
+    __slots__ = (
+        "schema",
+        "control",
+        "outcome_cache",
+        "start_time",
+        "observations",
+        "_session",
+        "_transport_kwargs_cache",
+    )
 
     def __init__(
         self,
         *,
         schema: BaseSchema,
         stop_event: threading.Event,
+        observations: Observations | None = None,
         session: requests.Session | None = None,
     ) -> None:
         self.schema = schema
         self.control = ExecutionControl(stop_event=stop_event, max_failures=schema.config.max_failures)
         self.outcome_cache = {}
         self.start_time = time.monotonic()
+        self.observations = observations
         self._session = session
         self._transport_kwargs_cache: dict[str | None, dict[str, Any]] = {}
 
@@ -65,6 +78,27 @@ class EngineContext:
     def has_reached_the_failure_limit(self) -> bool:
         return self.control.has_reached_the_failure_limit
 
+    def record_observations(self, recorder: ScenarioRecorder) -> None:
+        """Add new observations from a scenario."""
+        if self.observations is not None:
+            self.observations.extract_observations_from(recorder)
+
+    def inject_links(self) -> int:
+        """Inject inferred OpenAPI links into API operations based on collected observations."""
+        injected = 0
+        if self.observations is not None and self.observations.location_headers:
+            from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
+            from schemathesis.specs.openapi.stateful.inference import LinkInferencer
+
+            assert isinstance(self.schema, BaseOpenAPISchema)
+
+            # Generate links from collected Location headers
+            inferencer = LinkInferencer.from_schema(self.schema)
+            for operation, entries in self.observations.location_headers.items():
+                injected += inferencer.inject_links(operation.definition.raw, entries)
+
+        return injected
+
     def stop(self) -> None:
         self.control.stop()
 
@@ -107,6 +141,7 @@ class EngineContext:
         kwargs: dict[str, Any] = {
             "session": self.get_session(operation=operation),
             "headers": config.headers_for(operation=operation),
+            "max_redirects": config.max_redirects_for(operation=operation),
             "timeout": config.request_timeout_for(operation=operation),
             "verify": config.tls_verify_for(operation=operation),
             "cert": config.request_cert_for(operation=operation),

schemathesis/engine/core.py

@@ -2,15 +2,15 @@ from __future__ import annotations
 
 import threading
 from dataclasses import dataclass
-from typing import Sequence
 
-from schemathesis.auths import unregister as unregister_auth
+from schemathesis import auths
 from schemathesis.core import SpecificationFeature
 from schemathesis.engine import Status, events, phases
+from schemathesis.engine.observations import Observations
 from schemathesis.schemas import BaseSchema
 
 from .context import EngineContext
-from .events import EventGenerator
+from .events import EventGenerator, StatefulPhasePayload
 from .phases import Phase, PhaseName, PhaseSkipReason
 
 
@@ -24,10 +24,20 @@ class Engine:
         """Execute all test phases."""
         # Unregister auth if explicitly provided
         if self.schema.config.auth.is_defined:
-            unregister_auth()
+            auths.unregister()
 
-        ctx = EngineContext(schema=self.schema, stop_event=threading.Event())
         plan = self._create_execution_plan()
+
+        observations = None
+        for phase in plan.phases:
+            if (
+                phase.name == PhaseName.STATEFUL_TESTING
+                and phase.skip_reason in (None, PhaseSkipReason.NOT_APPLICABLE)
+                and self.schema.config.phases.stateful.inference.is_enabled
+            ):
+                observations = Observations()
+
+        ctx = EngineContext(schema=self.schema, stop_event=threading.Event(), observations=observations)
         return EventStream(plan.execute(ctx), ctx.control.stop_event)
 
     def _create_execution_plan(self) -> ExecutionPlan:
@@ -103,7 +113,7 @@ class Engine:
 class ExecutionPlan:
     """Manages test execution phases."""
 
-    phases: Sequence[Phase]
+    phases: list[Phase]
 
     __slots__ = ("phases",)
 
@@ -120,9 +130,8 @@ class ExecutionPlan:
 
             # Run main phases
             for phase in self.phases:
-                if engine.has_reached_the_failure_limit:
-                    phase.skip_reason = PhaseSkipReason.FAILURE_LIMIT_REACHED
-                yield events.PhaseStarted(phase=phase)
+                payload = self._adapt_execution(engine, phase)
+                yield events.PhaseStarted(phase=phase, payload=payload)
                 if phase.should_execute(engine):
                     yield from phases.execute(engine, phase)
                 else:
@@ -143,6 +152,18 @@ class ExecutionPlan:
         """Finish the test run."""
         yield events.EngineFinished(running_time=ctx.running_time)
 
+    def _adapt_execution(self, engine: EngineContext, phase: Phase) -> StatefulPhasePayload | None:
+        if engine.has_reached_the_failure_limit:
+            phase.skip_reason = PhaseSkipReason.FAILURE_LIMIT_REACHED
+        # Phase can be enabled if certain conditions are met
+        if phase.name == PhaseName.STATEFUL_TESTING:
+            inferred = engine.inject_links()
+            # Enable stateful testing if we successfully generated any links
+            if inferred:
+                phase.enable()
+            return StatefulPhasePayload(inferred_links=inferred)
+        return None
+
 
 @dataclass
 class EventStream:

schemathesis/engine/events.py

@@ -45,16 +45,26 @@ class PhaseEvent(EngineEvent):
     phase: Phase
 
 
+@dataclass
+class StatefulPhasePayload:
+    inferred_links: int
+
+    __slots__ = ("inferred_links",)
+
+
 @dataclass
 class PhaseStarted(PhaseEvent):
     """Start of an execution phase."""
 
-    __slots__ = ("id", "timestamp", "phase")
+    payload: StatefulPhasePayload | None
+
+    __slots__ = ("id", "timestamp", "phase", "payload")
 
-    def __init__(self, *, phase: Phase) -> None:
+    def __init__(self, *, phase: Phase, payload: StatefulPhasePayload | None) -> None:
         self.id = uuid.uuid4()
         self.timestamp = time.time()
         self.phase = phase
+        self.payload = payload
 
 
 @dataclass

schemathesis/engine/observations.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass
+
+from schemathesis.engine.recorder import ScenarioRecorder
+from schemathesis.schemas import APIOperation
+
+
+@dataclass
+class LocationHeaderEntry:
+    """Value of `Location` coming from API response with a given status code."""
+
+    status_code: int
+    value: str
+
+    __slots__ = ("status_code", "value")
+
+
+@dataclass
+class Observations:
+    """Repository for observations collected during test execution."""
+
+    location_headers: dict[APIOperation, list[LocationHeaderEntry]]
+
+    __slots__ = ("location_headers",)
+
+    def __init__(self) -> None:
+        self.location_headers = {}
+
+    def extract_observations_from(self, recorder: ScenarioRecorder) -> None:
+        """Extract observations from completed test scenario."""
+        for id, interaction in recorder.interactions.items():
+            response = interaction.response
+            if response is not None:
+                location = response.headers.get("location")
+                if location:
+                    # Group location headers by the operation that produced them
+                    entries = self.location_headers.setdefault(recorder.cases[id].value.operation, [])
+                    entries.append(
+                        LocationHeaderEntry(
+                            status_code=response.status_code,
+                            value=location[0],
+                        )
+                    )