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

schemathesis/engine/phases/__init__.py

@@ -77,6 +77,11 @@ class Phase:
         """Determine if phase should run based on context & configuration."""
         return self.is_enabled and not ctx.has_to_stop
 
+    def enable(self) -> None:
+        """Enable this test phase."""
+        self.is_enabled = True
+        self.skip_reason = None
+
 
 def execute(ctx: EngineContext, phase: Phase) -> EventGenerator:
     from urllib3.exceptions import InsecureRequestWarning

schemathesis/engine/phases/probes.py

@@ -42,9 +42,15 @@ def execute(ctx: EngineContext, phase: Phase) -> EventGenerator:
     for result in probes:
         if isinstance(result.probe, NullByteInHeader) and result.is_failure:
             from schemathesis.specs.openapi import formats
-            from schemathesis.specs.openapi.formats import HEADER_FORMAT, header_values
-
-            formats.register(HEADER_FORMAT, header_values(exclude_characters="\n\r\x00"))
+            from schemathesis.specs.openapi.formats import (
+                DEFAULT_HEADER_EXCLUDE_CHARACTERS,
+                HEADER_FORMAT,
+                header_values,
+            )
+
+            formats.register(
+                HEADER_FORMAT, header_values(exclude_characters=DEFAULT_HEADER_EXCLUDE_CHARACTERS + "\x00")
+            )
         payload = Ok(ProbePayload(probes=probes))
     yield events.PhaseFinished(phase=phase, status=status, payload=payload)
 

schemathesis/engine/phases/stateful/_executor.py

@@ -330,10 +330,18 @@ def validate_response(
         if stateful_ctx.is_seen_in_suite(failure) or stateful_ctx.is_seen_in_run(failure):
             return
         failure_data = recorder.find_failure_data(parent_id=case.id, failure=failure)
+
+        # Collect the whole chain of cURL commands
+        commands = []
+        parent = recorder.find_parent(case_id=failure_data.case.id)
+        while parent is not None:
+            commands.append(parent.as_curl_command(headers=failure_data.headers, verify=failure_data.verify))
+            parent = recorder.find_parent(case_id=parent.id)
+        commands.append(failure_data.case.as_curl_command(headers=failure_data.headers, verify=failure_data.verify))
         recorder.record_check_failure(
             name=name,
             case_id=failure_data.case.id,
-            code_sample=failure_data.case.as_curl_command(headers=failure_data.headers, verify=failure_data.verify),
+            code_sample="\n".join(commands),
             failure=failure,
         )
         control.count_failure()

schemathesis/engine/phases/unit/__init__.py

@@ -76,6 +76,7 @@ def execute(engine: EngineContext, phase: Phase) -> events.EventGenerator:
                                 status = event.status
                             if event.status in (Status.ERROR, Status.FAILURE):
                                 engine.control.count_failure()
+                            engine.record_observations(event.recorder)
                         if isinstance(event, events.Interrupted) or engine.is_interrupted:
                             status = Status.INTERRUPTED
                             engine.stop()

schemathesis/engine/phases/unit/_executor.py

@@ -49,6 +49,7 @@ from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis.builder import (
     InvalidHeadersExampleMark,
     InvalidRegexMark,
+    MissingPathParameters,
     NonSerializableMark,
     UnsatisfiableExampleMark,
 )
@@ -73,6 +74,7 @@ def run_test(
     yield scenario_started
     errors: list[Exception] = []
     skip_reason = None
+    error: Exception
     test_start_time = time.monotonic()
     recorder = ScenarioRecorder(label=operation.label)
     state = TestingState()
@@ -227,11 +229,15 @@ def run_test(
         and any(check.status == Status.FAILURE for checks in recorder.checks.values() for check in checks)
     ):
         status = Status.FAILURE
+
+    # Check for various errors during generation (tests may still have been generated)
+
     if UnsatisfiableExampleMark.is_set(test_function):
         status = Status.ERROR
         yield non_fatal_error(
             hypothesis.errors.Unsatisfiable("Failed to generate test cases from examples for this API operation")
         )
+
     non_serializable = NonSerializableMark.get(test_function)
     if non_serializable is not None and status != Status.ERROR:
         status = Status.ERROR
@@ -248,10 +254,17 @@ def run_test(
     if invalid_regex is not None and status != Status.ERROR:
         status = Status.ERROR
         yield non_fatal_error(InvalidRegexPattern.from_schema_error(invalid_regex, from_examples=True))
+
     invalid_headers = InvalidHeadersExampleMark.get(test_function)
     if invalid_headers:
         status = Status.ERROR
         yield non_fatal_error(InvalidHeadersExample.from_headers(invalid_headers))
+
+    missing_path_parameters = MissingPathParameters.get(test_function)
+    if missing_path_parameters:
+        status = Status.ERROR
+        yield non_fatal_error(missing_path_parameters)
+
     for error in deduplicate_errors(errors):
         yield non_fatal_error(error)
 

schemathesis/filters.py

@@ -175,6 +175,10 @@ class FilterSet:
         """Whether the filter set does not contain any filters."""
         return not self._includes and not self._excludes
 
+    def clear(self) -> None:
+        self._includes.clear()
+        self._excludes.clear()
+
     def include(
         self,
         func: MatcherFunc | None = None,

schemathesis/generation/case.py

@@ -200,7 +200,7 @@ class Case:
 
         """
         hook_context = HookContext(operation=self.operation)
-        dispatch("before_call", hook_context, self, **kwargs)
+        dispatch("before_call", hook_context, self, _with_dual_style_kwargs=True, **kwargs)
         if self.operation.app is not None:
             kwargs.setdefault("app", self.operation.app)
         if "app" in kwargs:

schemathesis/generation/coverage.py

@@ -6,7 +6,18 @@ from contextlib import contextmanager, suppress
 from dataclasses import dataclass
 from functools import lru_cache, partial
 from itertools import combinations
-from json.encoder import _make_iterencode, c_make_encoder, encode_basestring_ascii  # type: ignore
+
+try:
+    from json.encoder import _make_iterencode  # type: ignore[attr-defined]
+except ImportError:
+    _make_iterencode = None
+
+try:
+    from json.encoder import c_make_encoder  # type: ignore[attr-defined]
+except ImportError:
+    c_make_encoder = None
+
+from json.encoder import JSONEncoder, encode_basestring_ascii  # type: ignore
 from typing import Any, Callable, Generator, Iterator, TypeVar, cast
 from urllib.parse import quote_plus
 
@@ -285,10 +296,13 @@ T = TypeVar("T")
 
 if c_make_encoder is not None:
     _iterencode = c_make_encoder(None, None, encode_basestring_ascii, None, ":", ",", True, False, False)
-else:
+elif _make_iterencode is not None:
     _iterencode = _make_iterencode(
         None, None, encode_basestring_ascii, None, float.__repr__, ":", ",", True, False, True
     )
+else:
+    encoder = JSONEncoder(skipkeys=False, sort_keys=False, indent=None, separators=(":", ","))
+    _iterencode = encoder.iterencode
 
 
 def _encode(o: Any) -> str:

schemathesis/generation/hypothesis/builder.py

@@ -20,7 +20,7 @@ from requests.models import CaseInsensitiveDict
 from schemathesis import auths
 from schemathesis.auths import AuthStorage, AuthStorageMark
 from schemathesis.config import GenerationConfig, ProjectConfig
-from schemathesis.core import NOT_SET, NotSet, SpecificationFeature, media_types
+from schemathesis.core import INJECTED_PATH_PARAMETER_KEY, NOT_SET, NotSet, SpecificationFeature, media_types
 from schemathesis.core.errors import InvalidSchema, SerializationNotPossible
 from schemathesis.core.marks import Mark
 from schemathesis.core.transforms import deepclone
@@ -185,6 +185,18 @@ def create_test(
             generation_config=generation,
         )
 
+    injected_path_parameter_names = [
+        parameter.name
+        for parameter in operation.path_parameters
+        if parameter.definition.get(INJECTED_PATH_PARAMETER_KEY)
+    ]
+    if injected_path_parameter_names:
+        names = ", ".join(f"'{name}'" for name in injected_path_parameter_names)
+        plural = "s" if len(injected_path_parameter_names) > 1 else ""
+        verb = "are" if len(injected_path_parameter_names) > 1 else "is"
+        error = InvalidSchema(f"Path parameter{plural} {names} {verb} not defined")
+        MissingPathParameters.set(hypothesis_test, error)
+
     setattr(hypothesis_test, SETTINGS_ATTRIBUTE_NAME, settings)
 
     return hypothesis_test
@@ -902,3 +914,4 @@ UnsatisfiableExampleMark = Mark[Unsatisfiable](attr_name="unsatisfiable_example"
 NonSerializableMark = Mark[SerializationNotPossible](attr_name="non_serializable")
 InvalidRegexMark = Mark[SchemaError](attr_name="invalid_regex")
 InvalidHeadersExampleMark = Mark[dict[str, str]](attr_name="invalid_example_header")
+MissingPathParameters = Mark[InvalidSchema](attr_name="missing_path_parameters")

schemathesis/hooks.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 
 import inspect
 from collections import defaultdict
+from contextlib import contextmanager
 from dataclasses import dataclass, field
 from enum import Enum, unique
-from functools import partial
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, cast
+from functools import lru_cache, partial
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Generator, cast
 
 from schemathesis.core.marks import Mark
 from schemathesis.core.transport import Response
@@ -54,18 +55,28 @@ def to_filterable_hook(dispatcher: HookDispatcher) -> Callable:
     filter_used = False
     filter_set = FilterSet()
 
+    @contextmanager
+    def _reset_on_error() -> Generator:
+        try:
+            yield
+        except Exception:
+            filter_set.clear()
+            raise
+
     def register(hook: str | Callable) -> Callable:
         nonlocal filter_set
 
         if filter_used:
-            validate_filterable_hook(hook)
+            with _reset_on_error():
+                validate_filterable_hook(hook)
 
         if isinstance(hook, str):
 
             def decorator(func: Callable) -> Callable:
                 hook_name = cast(str, hook)
                 if filter_used:
-                    validate_filterable_hook(hook)
+                    with _reset_on_error():
+                        validate_filterable_hook(hook)
                 func.filter_set = filter_set  # type: ignore[attr-defined]
                 return dispatcher.register_hook_with_name(func, hook_name)
 
@@ -86,13 +97,15 @@ def to_filterable_hook(dispatcher: HookDispatcher) -> Callable:
             nonlocal filter_used
 
             filter_used = True
-            filter_set.include(*args, **kwargs)
+            with _reset_on_error():
+                filter_set.include(*args, **kwargs)
 
         def exclude(*args: Any, **kwargs: Any) -> None:
             nonlocal filter_used
 
             filter_used = True
-            filter_set.exclude(*args, **kwargs)
+            with _reset_on_error():
+                filter_set.exclude(*args, **kwargs)
 
         attach_filter_chain(target, "apply_to", include)
         attach_filter_chain(target, "skip_for", exclude)
@@ -113,11 +126,9 @@ class HookDispatcher:
     _hooks: defaultdict[str, list[Callable]] = field(default_factory=lambda: defaultdict(list))
     _specs: ClassVar[dict[str, RegisteredHook]] = {}
 
-    def __post_init__(self) -> None:
-        self.hook = to_filterable_hook(self)  # type: ignore[method-assign]
-
-    def hook(self, hook: str | Callable) -> Callable:
-        raise NotImplementedError
+    @property
+    def hook(self) -> Callable:
+        return to_filterable_hook(self)
 
     def apply(self, hook: Callable, *, name: str | None = None) -> Callable[[Callable], Callable]:
         """Register hook to run only on one test function.
@@ -201,6 +212,9 @@ class HookDispatcher:
         """Get a list of hooks registered for a name."""
         return self._hooks.get(name, [])
 
+    def get_all(self) -> dict[str, list[Callable]]:
+        return self._hooks
+
     def apply_to_container(
         self, strategy: st.SearchStrategy, container: str, context: HookContext
     ) -> st.SearchStrategy:
@@ -225,12 +239,18 @@ class HookDispatcher:
             strategy = strategy.flatmap(hook)
         return strategy
 
-    def dispatch(self, name: str, context: HookContext, *args: Any, **kwargs: Any) -> None:
+    def dispatch(
+        self, name: str, context: HookContext, *args: Any, _with_dual_style_kwargs: bool = False, **kwargs: Any
+    ) -> None:
         """Run all hooks for the given name."""
         for hook in self.get_all_by_name(name):
             if _should_skip_hook(hook, context):
                 continue
-            hook(context, *args, **kwargs)
+            # NOTE: It is a backward-compat shim to support calling `before_call` with `**kwargs` OR with `kwargs`.
+            if _with_dual_style_kwargs and not has_var_keyword(hook):
+                hook(context, *args, kwargs)
+            else:
+                hook(context, *args, **kwargs)
 
     def unregister(self, hook: Callable) -> None:
         """Unregister a specific hook."""
@@ -246,6 +266,12 @@ class HookDispatcher:
         self._hooks = defaultdict(list)
 
 
+@lru_cache(maxsize=16)
+def has_var_keyword(hook: Callable) -> bool:
+    """Check if hook function accepts **kwargs."""
+    return any(p.kind == inspect.Parameter.VAR_KEYWORD for p in inspect.signature(hook).parameters.values())
+
+
 def _should_skip_hook(hook: Callable, ctx: HookContext) -> bool:
     filter_set = getattr(hook, "filter_set", None)
     return filter_set is not None and ctx.operation is not None and not filter_set.match(ctx)
@@ -349,7 +375,7 @@ def before_init_operation(context: HookContext, operation: APIOperation) -> None
 
 
 @HookDispatcher.register_spec([HookScope.GLOBAL])
-def before_call(context: HookContext, case: Case, **kwargs: Any) -> None:
+def before_call(context: HookContext, case: Case, kwargs: dict[str, Any]) -> None:
     """Called before every network call in CLI tests.
 
     Use cases:

schemathesis/openapi/loaders.py

@@ -282,7 +282,7 @@ def load_content(content: str, content_type: ContentType) -> dict[str, Any]:
     # If type is unknown, try JSON first, then YAML
     try:
         return _load_json(content)
-    except json.JSONDecodeError:
+    except LoaderError:
         return _load_yaml(content)
 
 

schemathesis/pytest/plugin.py

@@ -298,6 +298,7 @@ def pytest_pyfunc_call(pyfuncitem):  # type:ignore
     from schemathesis.generation.hypothesis.builder import (
         InvalidHeadersExampleMark,
         InvalidRegexMark,
+        MissingPathParameters,
         NonSerializableMark,
         UnsatisfiableExampleMark,
     )
@@ -333,8 +334,13 @@ def pytest_pyfunc_call(pyfuncitem):  # type:ignore
             pytest.skip(exc.args[0])
         except SchemaError as exc:
             raise InvalidRegexPattern.from_schema_error(exc, from_examples=False) from exc
+
         invalid_headers = InvalidHeadersExampleMark.get(pyfuncitem.obj)
         if invalid_headers is not None:
             raise InvalidHeadersExample.from_headers(invalid_headers) from None
+
+        missing_path_parameters = MissingPathParameters.get(pyfuncitem.obj)
+        if missing_path_parameters:
+            raise missing_path_parameters from None
     else:
         yield

schemathesis/schemas.py

@@ -27,7 +27,7 @@ from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis import strategies
 from schemathesis.generation.hypothesis.given import GivenInput, given_proxy
 from schemathesis.generation.meta import CaseMetadata
-from schemathesis.hooks import HookDispatcherMark
+from schemathesis.hooks import HookDispatcherMark, _should_skip_hook
 
 from .auths import AuthStorage
 from .filters import (
@@ -712,14 +712,22 @@ class APIOperation(Generic[P]):
         def _apply_hooks(dispatcher: HookDispatcher, _strategy: SearchStrategy[Case]) -> SearchStrategy[Case]:
             context = HookContext(operation=self)
             for hook in dispatcher.get_all_by_name("before_generate_case"):
+                if _should_skip_hook(hook, context):
+                    continue
                 _strategy = hook(context, _strategy)
             for hook in dispatcher.get_all_by_name("filter_case"):
+                if _should_skip_hook(hook, context):
+                    continue
                 hook = partial(hook, context)
                 _strategy = _strategy.filter(hook)
             for hook in dispatcher.get_all_by_name("map_case"):
+                if _should_skip_hook(hook, context):
+                    continue
                 hook = partial(hook, context)
                 _strategy = _strategy.map(hook)
             for hook in dispatcher.get_all_by_name("flatmap_case"):
+                if _should_skip_hook(hook, context):
+                    continue
                 hook = partial(hook, context)
                 _strategy = _strategy.flatmap(hook)
             return _strategy

schemathesis/specs/openapi/_hypothesis.py

@@ -36,7 +36,13 @@ from ... import auths
 from ...generation import GenerationMode
 from ...hooks import HookContext, HookDispatcher, apply_to_all_dispatchers
 from .constants import LOCATION_TO_CONTAINER
-from .formats import HEADER_FORMAT, STRING_FORMATS, get_default_format_strategies, header_values
+from .formats import (
+    DEFAULT_HEADER_EXCLUDE_CHARACTERS,
+    HEADER_FORMAT,
+    STRING_FORMATS,
+    get_default_format_strategies,
+    header_values,
+)
 from .media_types import MEDIA_TYPES
 from .negative import negative_schema
 from .negative.utils import can_negate
@@ -410,10 +416,17 @@ def jsonify_python_specific_types(value: dict[str, Any]) -> dict[str, Any]:
 
 def _build_custom_formats(generation_config: GenerationConfig) -> dict[str, st.SearchStrategy]:
     custom_formats = {**get_default_format_strategies(), **STRING_FORMATS}
+    header_values_kwargs = {}
     if generation_config.exclude_header_characters is not None:
-        custom_formats[HEADER_FORMAT] = header_values(exclude_characters=generation_config.exclude_header_characters)
+        header_values_kwargs["exclude_characters"] = generation_config.exclude_header_characters
+        if not generation_config.allow_x00:
+            header_values_kwargs["exclude_characters"] += "\x00"
     elif not generation_config.allow_x00:
-        custom_formats[HEADER_FORMAT] = header_values(exclude_characters="\n\r\x00")
+        header_values_kwargs["exclude_characters"] = DEFAULT_HEADER_EXCLUDE_CHARACTERS + "\x00"
+    if generation_config.codec is not None:
+        header_values_kwargs["codec"] = generation_config.codec
+    if header_values_kwargs:
+        custom_formats[HEADER_FORMAT] = header_values(**header_values_kwargs)
     return custom_formats
 
 

schemathesis/specs/openapi/checks.py

@@ -366,7 +366,10 @@ def use_after_free(ctx: CheckContext, response: Response, case: Case) -> bool |
 
     if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
-    if response.status_code == 404 or response.status_code >= 500:
+
+    # Only check for use-after-free on successful responses (2xx) or redirects (3xx)
+    # Other status codes indicate request-level issues / server errors, not successful resource access
+    if not (200 <= response.status_code < 400):
         return None
 
     for related_case in ctx._find_related(case_id=case.id):

schemathesis/specs/openapi/formats.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import platform
 import string
 from base64 import b64encode
 from functools import lru_cache
@@ -11,7 +12,15 @@ if TYPE_CHECKING:
     from hypothesis import strategies as st
 
 
+IS_PYPY = platform.python_implementation() == "PyPy"
 STRING_FORMATS: dict[str, st.SearchStrategy] = {}
+# For some reason PyPy can't send header values with codepoints > 128, while CPython can
+if IS_PYPY:
+    MAX_HEADER_CODEPOINT = 128
+    DEFAULT_HEADER_EXCLUDE_CHARACTERS = "\n\r\x1f\x1e\x1d\x1c"
+else:
+    MAX_HEADER_CODEPOINT = 255
+    DEFAULT_HEADER_EXCLUDE_CHARACTERS = "\n\r"
 
 
 def register_string_format(name: str, strategy: st.SearchStrategy) -> None:
@@ -65,11 +74,15 @@ def unregister_string_format(name: str) -> None:
         raise ValueError(f"Unknown Open API format: {name}") from exc
 
 
-def header_values(exclude_characters: str = "\n\r") -> st.SearchStrategy[str]:
+def header_values(
+    codec: str | None = None, exclude_characters: str = DEFAULT_HEADER_EXCLUDE_CHARACTERS
+) -> st.SearchStrategy[str]:
     from hypothesis import strategies as st
 
     return st.text(
-        alphabet=st.characters(min_codepoint=0, max_codepoint=255, exclude_characters=exclude_characters)
+        alphabet=st.characters(
+            min_codepoint=0, max_codepoint=MAX_HEADER_CODEPOINT, codec=codec, exclude_characters=exclude_characters
+        )
         # Header values with leading non-visible chars can't be sent with `requests`
     ).map(str.lstrip)
 

schemathesis/specs/openapi/schemas.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import itertools
+import string
 from collections import defaultdict
 from contextlib import ExitStack, contextmanager, suppress
 from dataclasses import dataclass, field
@@ -29,7 +30,7 @@ from requests.exceptions import InvalidHeader
 from requests.structures import CaseInsensitiveDict
 from requests.utils import check_header_validity
 
-from schemathesis.core import NOT_SET, NotSet, Specification, deserialization, media_types
+from schemathesis.core import INJECTED_PATH_PARAMETER_KEY, NOT_SET, NotSet, Specification, deserialization, media_types
 from schemathesis.core.compat import RefResolutionError
 from schemathesis.core.errors import InternalError, InvalidSchema, LoaderError, LoaderErrorKind, OperationNotFound
 from schemathesis.core.failures import Failure, FailureGroup, MalformedJson
@@ -89,6 +90,17 @@ def check_header(parameter: dict[str, Any]) -> None:
         raise InvalidSchema(f"Invalid header name: {name}")
 
 
+def get_template_fields(template: str) -> set[str]:
+    """Extract named placeholders from a string template."""
+    try:
+        parameters = {name for _, name, _, _ in string.Formatter().parse(template) if name is not None}
+        # Check for malformed params to avoid injecting them - they will be checked later on in the workflow
+        template.format(**dict.fromkeys(parameters, ""))
+        return parameters
+    except (ValueError, IndexError):
+        return set()
+
+
 @dataclass(eq=False, repr=False)
 class BaseOpenAPISchema(BaseSchema):
     nullable_name: ClassVar[str] = ""
@@ -100,6 +112,7 @@ class BaseOpenAPISchema(BaseSchema):
     # excessive resolving
     _inline_reference_cache_lock: RLock = field(default_factory=RLock)
     component_locations: ClassVar[tuple[tuple[str, ...], ...]] = ()
+    _path_parameter_template: ClassVar[dict[str, Any]] = None  # type: ignore
 
     @property
     def specification(self) -> Specification:
@@ -232,7 +245,7 @@ class BaseOpenAPISchema(BaseSchema):
 
         return statistic
 
-    def _operation_iter(self) -> Generator[dict[str, Any], None, None]:
+    def _operation_iter(self) -> Iterator[tuple[str, str, dict[str, Any]]]:
         try:
             paths = self.raw_schema["paths"]
         except KeyError:
@@ -243,13 +256,11 @@ class BaseOpenAPISchema(BaseSchema):
             try:
                 if "$ref" in path_item:
                     _, path_item = resolve(path_item["$ref"])
-                # Straightforward iteration is faster than converting to a set & calculating length.
                 for method, definition in path_item.items():
                     if should_skip(path, method, definition):
                         continue
-                    yield definition
+                    yield (method, path, definition)
             except SCHEMA_PARSING_ERRORS:
-                # Ignore errors
                 continue
 
     def _resolve_until_no_references(self, value: dict[str, Any]) -> dict[str, Any]:
@@ -393,7 +404,6 @@ class BaseOpenAPISchema(BaseSchema):
         resolved: dict[str, Any],
         scope: str,
     ) -> APIOperation:
-        """Create JSON schemas for the query, body, etc from Swagger parameters definitions."""
         __tracebackhide__ = True
         base_url = self.get_base_url()
         operation: APIOperation[OpenAPIParameter] = APIOperation(
@@ -406,6 +416,14 @@ class BaseOpenAPISchema(BaseSchema):
         )
         for parameter in parameters:
             operation.add_parameter(parameter)
+        # Inject unconstrained path parameters if any is missing
+        missing_parameter_names = get_template_fields(operation.path) - {
+            parameter.name for parameter in operation.path_parameters
+        }
+        for name in missing_parameter_names:
+            definition = {"name": name, INJECTED_PATH_PARAMETER_KEY: True, **deepclone(self._path_parameter_template)}
+            for parameter in self.collect_parameters([definition], resolved):
+                operation.add_parameter(parameter)
         config = self.config.generation_for(operation=operation)
         if config.with_security_parameters:
             self.security.process_definitions(self.raw_schema, operation, self.resolver)
@@ -837,6 +855,7 @@ class SwaggerV20(BaseOpenAPISchema):
     security = SwaggerSecurityProcessor()
     component_locations: ClassVar[tuple[tuple[str, ...], ...]] = (("definitions",),)
     links_field = "x-links"
+    _path_parameter_template = {"in": "path", "required": True, "type": "string"}
 
     @property
     def specification(self) -> Specification:
@@ -1005,6 +1024,7 @@ class OpenApi30(SwaggerV20):
     security = OpenAPISecurityProcessor()
     component_locations = (("components", "schemas"),)
     links_field = "links"
+    _path_parameter_template = {"in": "path", "required": True, "schema": {"type": "string"}}
 
     @property
     def specification(self) -> Specification: