schemathesis 3.18.5__py3-none-any.whl → 3.19.1__py3-none-any.whl

schemathesis/hooks.py

@@ -1,10 +1,10 @@
 import inspect
 from collections import defaultdict
 from copy import deepcopy
+from dataclasses import dataclass, field
 from enum import Enum, unique
-from typing import TYPE_CHECKING, Any, Callable, DefaultDict, Dict, List, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, DefaultDict, Dict, List, Optional, Union, cast
 
-import attr
 from hypothesis import strategies as st
 
 from .types import GenericTest
@@ -22,13 +22,13 @@ class HookScope(Enum):
     TEST = 3
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class RegisteredHook:
-    signature: inspect.Signature = attr.ib()  # pragma: no mutate
-    scopes: List[HookScope] = attr.ib()  # pragma: no mutate
+    signature: inspect.Signature
+    scopes: List[HookScope]
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class HookContext:
     """A context that is passed to some hook functions.
 
@@ -36,23 +36,23 @@ class HookContext:
                                             Might be absent in some cases.
     """
 
-    operation: Optional["APIOperation"] = attr.ib(default=None)  # pragma: no mutate
+    operation: Optional["APIOperation"] = None
 
     @deprecated_property(removed_in="4.0", replacement="operation")
     def endpoint(self) -> Optional["APIOperation"]:
         return self.operation
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class HookDispatcher:
     """Generic hook dispatcher.
 
     Provides a mechanism to extend Schemathesis in registered hook points.
     """
 
-    scope: HookScope = attr.ib()  # pragma: no mutate
-    _hooks: DefaultDict[str, List[Callable]] = attr.ib(factory=lambda: defaultdict(list))  # pragma: no mutate
-    _specs: Dict[str, RegisteredHook] = {}  # pragma: no mutate
+    scope: HookScope
+    _hooks: DefaultDict[str, List[Callable]] = field(default_factory=lambda: defaultdict(list))
+    _specs: ClassVar[Dict[str, RegisteredHook]] = {}
 
     def register(self, hook: Union[str, Callable]) -> Callable:
         """Register a new hook.

schemathesis/lazy.py

@@ -1,13 +1,14 @@
+from dataclasses import dataclass, field
 from inspect import signature
 from typing import Any, Callable, Dict, Generator, Optional, Type, Union
 
-import attr
 import pytest
 from _pytest.fixtures import FixtureRequest
 from hypothesis.core import HypothesisHandle
 from hypothesis.errors import Flaky
 from hypothesis.internal.escalation import format_exception, get_interesting_origin, get_trimmed_traceback
 from hypothesis.internal.reflection import impersonate
+from pyrate_limiter import Limiter
 from pytest_subtests import SubTests, nullcontext
 
 from ._compat import MultipleFailures
@@ -32,21 +33,22 @@ from .utils import (
 )
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class LazySchema:
-    fixture_name: str = attr.ib()  # pragma: no mutate
-    base_url: Union[Optional[str], NotSet] = attr.ib(default=NOT_SET)  # pragma: no mutate
-    method: Optional[Filter] = attr.ib(default=NOT_SET)  # pragma: no mutate
-    endpoint: Optional[Filter] = attr.ib(default=NOT_SET)  # pragma: no mutate
-    tag: Optional[Filter] = attr.ib(default=NOT_SET)  # pragma: no mutate
-    operation_id: Optional[Filter] = attr.ib(default=NOT_SET)  # pragma: no mutate
-    app: Any = attr.ib(default=NOT_SET)  # pragma: no mutate
-    hooks: HookDispatcher = attr.ib(factory=lambda: HookDispatcher(scope=HookScope.SCHEMA))  # pragma: no mutate
-    auth: AuthStorage = attr.ib(factory=AuthStorage)  # pragma: no mutate
-    validate_schema: bool = attr.ib(default=True)  # pragma: no mutate
-    skip_deprecated_operations: bool = attr.ib(default=False)  # pragma: no mutate
-    data_generation_methods: Union[DataGenerationMethodInput, NotSet] = attr.ib(default=NOT_SET)
-    code_sample_style: CodeSampleStyle = attr.ib(default=CodeSampleStyle.default())  # pragma: no mutate
+    fixture_name: str
+    base_url: Union[Optional[str], NotSet] = NOT_SET
+    method: Optional[Filter] = NOT_SET
+    endpoint: Optional[Filter] = NOT_SET
+    tag: Optional[Filter] = NOT_SET
+    operation_id: Optional[Filter] = NOT_SET
+    app: Any = NOT_SET
+    hooks: HookDispatcher = field(default_factory=lambda: HookDispatcher(scope=HookScope.SCHEMA))
+    auth: AuthStorage = field(default_factory=AuthStorage)
+    validate_schema: bool = True
+    skip_deprecated_operations: bool = False
+    data_generation_methods: Union[DataGenerationMethodInput, NotSet] = NOT_SET
+    code_sample_style: CodeSampleStyle = CodeSampleStyle.default()
+    rate_limiter: Optional[Limiter] = None
 
     def hook(self, hook: Union[str, Callable]) -> Callable:
         return self.hooks.register(hook)
@@ -105,13 +107,14 @@ class LazySchema:
                     tag=tag,
                     operation_id=operation_id,
                     hooks=self.hooks,
-                    auth=self.auth if self.auth.provider is not None else NOT_SET,
+                    auth=self.auth if self.auth.providers is not None else NOT_SET,
                     test_function=test,
                     validate_schema=validate_schema,
                     skip_deprecated_operations=skip_deprecated_operations,
                     data_generation_methods=data_generation_methods,
                     code_sample_style=_code_sample_style,
                     app=self.app,
+                    rate_limiter=self.rate_limiter,
                 )
                 fixtures = get_fixtures(test, request, given_kwargs)
                 # Changing the node id is required for better reporting - the method and path will appear there
@@ -270,6 +273,7 @@ def get_schema(
     skip_deprecated_operations: Union[bool, NotSet] = NOT_SET,
     data_generation_methods: Union[DataGenerationMethodInput, NotSet] = NOT_SET,
     code_sample_style: CodeSampleStyle,
+    rate_limiter: Optional[Limiter],
 ) -> BaseSchema:
     """Loads a schema from the fixture."""
     schema = request.getfixturevalue(name)
@@ -289,6 +293,7 @@ def get_schema(
         skip_deprecated_operations=skip_deprecated_operations,
         data_generation_methods=data_generation_methods,
         code_sample_style=code_sample_style,
+        rate_limiter=rate_limiter,
     )
 
 

schemathesis/models.py

@@ -4,6 +4,7 @@ import http
 import json
 from collections import Counter
 from contextlib import contextmanager
+from dataclasses import dataclass, field
 from enum import Enum
 from itertools import chain
 from logging import LogRecord
@@ -28,9 +29,8 @@ from typing import (
 from urllib.parse import quote, unquote, urljoin, urlparse, urlsplit, urlunsplit
 from uuid import uuid4
 
-import attr
 import curlify
-import requests
+import requests.auth
 import werkzeug
 from hypothesis import event, note, reject
 from hypothesis import strategies as st
@@ -77,13 +77,13 @@ if TYPE_CHECKING:
     from .stateful import Stateful, StatefulTest
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class CaseSource:
     """Data sources, used to generate a test case."""
 
-    case: "Case" = attr.ib()  # pragma: no mutate
-    response: GenericResponse = attr.ib()  # pragma: no mutate
-    elapsed: float = attr.ib()  # pragma: no mutate
+    case: "Case"
+    response: GenericResponse
+    elapsed: float
 
     def partial_deepcopy(self) -> "CaseSource":
         return self.__class__(
@@ -110,26 +110,27 @@ def serialize(value: Any) -> str:
     return json.dumps(value, sort_keys=True, default=_serialize_unknown)
 
 
-@attr.s(slots=True, repr=False, hash=False)  # pragma: no mutate
+@dataclass(repr=False)
 class Case:
     """A single test case parameters."""
 
-    operation: "APIOperation" = attr.ib()  # pragma: no mutate
-    path_parameters: Optional[PathParameters] = attr.ib(default=None)  # pragma: no mutate
-    headers: Optional[CaseInsensitiveDict] = attr.ib(default=None)  # pragma: no mutate
-    cookies: Optional[Cookies] = attr.ib(default=None)  # pragma: no mutate
-    query: Optional[Query] = attr.ib(default=None)  # pragma: no mutate
+    operation: "APIOperation"
+    path_parameters: Optional[PathParameters] = None
+    headers: Optional[CaseInsensitiveDict] = None
+    cookies: Optional[Cookies] = None
+    query: Optional[Query] = None
     # By default, there is no body, but we can't use `None` as the default value because it clashes with `null`
     # which is a valid payload.
-    body: Union[Body, NotSet] = attr.ib(default=NOT_SET)  # pragma: no mutate
+    body: Union[Body, NotSet] = NOT_SET
 
-    source: Optional[CaseSource] = attr.ib(default=None)  # pragma: no mutate
+    source: Optional[CaseSource] = None
     # The media type for cases with a payload. For example, "application/json"
-    media_type: Optional[str] = attr.ib(default=None)  # pragma: no mutate
+    media_type: Optional[str] = None
     # The way the case was generated (None for manually crafted ones)
-    data_generation_method: Optional[DataGenerationMethod] = attr.ib(default=None)  # pragma: no mutate
+    data_generation_method: Optional[DataGenerationMethod] = None
     # Unique test case identifier
-    id: str = attr.ib(factory=lambda: uuid4().hex, eq=False)  # pragma: no mutate
+    id: str = field(default_factory=lambda: uuid4().hex, compare=False)
+    _auth: Optional[requests.auth.AuthBase] = None
 
     def __repr__(self) -> str:
         parts = [f"{self.__class__.__name__}("]
@@ -307,7 +308,7 @@ class Case:
             if "content-type" not in {header.lower() for header in final_headers}:
                 final_headers["Content-Type"] = self.media_type
         base_url = self._get_base_url(base_url)
-        formatted_path = self.formatted_path.lstrip("/")  # pragma: no mutate
+        formatted_path = self.formatted_path.lstrip("/")
         if not base_url.endswith("/"):
             base_url += "/"
         url = unquote(urljoin(base_url, quote(formatted_path)))
@@ -318,6 +319,8 @@ class Case:
             extra = serializer.as_requests(context, self.body)
         else:
             extra = {}
+        if self._auth is not None:
+            extra["auth"] = self._auth
         additional_headers = extra.pop("headers", None)
         if additional_headers:
             # Additional headers, needed for the serializer
@@ -337,6 +340,8 @@ class Case:
         base_url: Optional[str] = None,
         session: Optional[requests.Session] = None,
         headers: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        cookies: Optional[Dict[str, Any]] = None,
         **kwargs: Any,
     ) -> requests.Response:
         """Make a network call with `requests`."""
@@ -344,6 +349,10 @@ class Case:
         dispatch("before_call", hook_context, self)
         data = self.as_requests_kwargs(base_url, headers)
         data.update(kwargs)
+        if params is not None:
+            _merge_dict_to(data, "params", params)
+        if cookies is not None:
+            _merge_dict_to(data, "cookies", cookies)
         data.setdefault("timeout", DEFAULT_RESPONSE_TIMEOUT / 1000)
         if session is None:
             validate_vanilla_requests_kwargs(data)
@@ -352,7 +361,8 @@ class Case:
         else:
             close_session = False
         try:
-            response = session.request(**data)  # type: ignore
+            with self.operation.schema.ratelimit():
+                response = session.request(**data)  # type: ignore
         except requests.Timeout as exc:
             timeout = 1000 * data["timeout"]  # It is defined and not empty, since the exception happened
             code_message = self._get_code_message(self.operation.schema.code_sample_style, exc.request)
@@ -387,7 +397,13 @@ class Case:
             **extra,
         }
 
-    def call_wsgi(self, app: Any = None, headers: Optional[Dict[str, str]] = None, **kwargs: Any) -> WSGIResponse:
+    def call_wsgi(
+        self,
+        app: Any = None,
+        headers: Optional[Dict[str, str]] = None,
+        query_string: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ) -> WSGIResponse:
         application = app or self.app
         if application is None:
             raise RuntimeError(
@@ -397,8 +413,10 @@ class Case:
         hook_context = HookContext(operation=self.operation)
         dispatch("before_call", hook_context, self)
         data = self.as_werkzeug_kwargs(headers)
+        if query_string is not None:
+            _merge_dict_to(data, "query_string", query_string)
         client = werkzeug.Client(application, WSGIResponse)
-        with cookie_handler(client, self.cookies):
+        with cookie_handler(client, self.cookies), self.operation.schema.ratelimit():
             response = client.open(**data, **kwargs)
         requests_kwargs = self.as_requests_kwargs(base_url=self.get_full_base_url(), headers=headers)
         response.request = requests.Request(**requests_kwargs).prepare()
@@ -519,6 +537,13 @@ class Case:
         )
 
 
+def _merge_dict_to(data: Dict[str, Any], data_key: str, new: Dict[str, Any]) -> None:
+    original = data[data_key] or {}
+    for key, value in new.items():
+        original[key] = value
+    data[data_key] = original
+
+
 def validate_vanilla_requests_kwargs(data: Dict[str, Any]) -> None:
     """Check arguments for `requests.Session.request`.
 
@@ -569,10 +594,10 @@ def cookie_handler(client: werkzeug.Client, cookies: Optional[Cookies]) -> Gener
 
 
 P = TypeVar("P", bound=Parameter)
-D = TypeVar("D")
+D = TypeVar("D", bound=dict)
 
 
-@attr.s  # pragma: no mutate
+@dataclass
 class OperationDefinition(Generic[P, D]):
     """A wrapper to store not resolved API operation definitions.
 
@@ -581,16 +606,25 @@ class OperationDefinition(Generic[P, D]):
     scope change to have a proper reference resolving later.
     """
 
-    raw: D = attr.ib()  # pragma: no mutate
-    resolved: D = attr.ib()  # pragma: no mutate
-    scope: str = attr.ib()  # pragma: no mutate
-    parameters: Sequence[P] = attr.ib()  # pragma: no mutate
+    raw: D
+    resolved: D
+    scope: str
+    parameters: Sequence[P]
+
+    def __contains__(self, item: Union[str, int]) -> bool:
+        return item in self.resolved
+
+    def __getitem__(self, item: Union[str, int]) -> Union[None, bool, float, str, list, Dict[str, Any]]:
+        return self.resolved[item]
+
+    def get(self, item: Union[str, int], default: Any = None) -> Union[None, bool, float, str, list, Dict[str, Any]]:
+        return self.resolved.get(item, default)
 
 
 C = TypeVar("C", bound=Case)
 
 
-@attr.s(eq=False)  # pragma: no mutate
+@dataclass(eq=False)
 class APIOperation(Generic[P, C]):
     """A single operation defined in an API.
 
@@ -606,23 +640,23 @@ class APIOperation(Generic[P, C]):
     # `path` does not contain `basePath`
     # Example <scheme>://<host>/<basePath>/users - "/users" is path
     # https://swagger.io/docs/specification/2-0/api-host-and-base-path/
-    path: str = attr.ib()  # pragma: no mutate
-    method: str = attr.ib()  # pragma: no mutate
-    definition: OperationDefinition = attr.ib(repr=False)  # pragma: no mutate
-    schema: "BaseSchema" = attr.ib()  # pragma: no mutate
-    verbose_name: str = attr.ib()  # pragma: no mutate
-    app: Any = attr.ib(default=None)  # pragma: no mutate
-    base_url: Optional[str] = attr.ib(default=None)  # pragma: no mutate
-    path_parameters: ParameterSet[P] = attr.ib(factory=ParameterSet)  # pragma: no mutate
-    headers: ParameterSet[P] = attr.ib(factory=ParameterSet)  # pragma: no mutate
-    cookies: ParameterSet[P] = attr.ib(factory=ParameterSet)  # pragma: no mutate
-    query: ParameterSet[P] = attr.ib(factory=ParameterSet)  # pragma: no mutate
-    body: PayloadAlternatives[P] = attr.ib(factory=PayloadAlternatives)  # pragma: no mutate
-    case_cls: Type[C] = attr.ib(default=Case)  # type: ignore
-
-    @verbose_name.default
-    def _verbose_name_default(self) -> str:
-        return f"{self.method.upper()} {self.full_path}"
+    path: str
+    method: str
+    definition: OperationDefinition = field(repr=False)
+    schema: "BaseSchema"
+    verbose_name: str = None  # type: ignore
+    app: Any = None
+    base_url: Optional[str] = None
+    path_parameters: ParameterSet[P] = field(default_factory=ParameterSet)
+    headers: ParameterSet[P] = field(default_factory=ParameterSet)
+    cookies: ParameterSet[P] = field(default_factory=ParameterSet)
+    query: ParameterSet[P] = field(default_factory=ParameterSet)
+    body: PayloadAlternatives[P] = field(default_factory=PayloadAlternatives)
+    case_cls: Type[C] = Case  # type: ignore
+
+    def __post_init__(self) -> None:
+        if self.verbose_name is None:
+            self.verbose_name = f"{self.method.upper()} {self.full_path}"  # type: ignore
 
     @property
     def full_path(self) -> str:
@@ -636,27 +670,35 @@ class APIOperation(Generic[P, C]):
         """Iterate over all operation's parameters."""
         return chain(self.path_parameters, self.headers, self.cookies, self.query)
 
+    def _lookup_container(self, location: str) -> Union[ParameterSet[P], PayloadAlternatives[P], None]:
+        return {
+            "path": self.path_parameters,
+            "header": self.headers,
+            "cookie": self.cookies,
+            "query": self.query,
+            "body": self.body,
+        }.get(location)
+
     def add_parameter(self, parameter: P) -> None:
         """Add a new processed parameter to an API operation.
 
         :param parameter: A parameter that will be used with this operation.
         :rtype: None
         """
-        lookup_table = {
-            "path": self.path_parameters,
-            "header": self.headers,
-            "cookie": self.cookies,
-            "query": self.query,
-            "body": self.body,
-        }
         # If the parameter has a typo, then by default, there will be an error from `jsonschema` earlier.
         # But if the user wants to skip schema validation, we choose to ignore a malformed parameter.
         # In this case, we still might generate some tests for an API operation, but without this parameter,
         # which is better than skip the whole operation from testing.
-        if parameter.location in lookup_table:
-            container = lookup_table[parameter.location]
+        container = self._lookup_container(parameter.location)
+        if container is not None:
             container.add(parameter)
 
+    def get_parameter(self, name: str, location: str) -> Optional[P]:
+        container = self._lookup_container(location)
+        if container is not None:
+            return container.get(name)
+        return None
+
     def as_strategy(
         self,
         hooks: Optional["HookDispatcher"] = None,
@@ -788,35 +830,35 @@ Endpoint = APIOperation
 class Status(str, Enum):
     """Status of an action or multiple actions."""
 
-    success = "success"  # pragma: no mutate
-    failure = "failure"  # pragma: no mutate
-    error = "error"  # pragma: no mutate
-    skip = "skip"  # pragma: no mutate
+    success = "success"
+    failure = "failure"
+    error = "error"
+    skip = "skip"
 
 
-@attr.s(slots=True, repr=False)  # pragma: no mutate
+@dataclass(repr=False)
 class Check:
     """Single check run result."""
 
-    name: str = attr.ib()  # pragma: no mutate
-    value: Status = attr.ib()  # pragma: no mutate
-    response: Optional[GenericResponse] = attr.ib()  # pragma: no mutate
-    elapsed: float = attr.ib()  # pragma: no mutate
-    example: Case = attr.ib()  # pragma: no mutate
-    message: Optional[str] = attr.ib(default=None)  # pragma: no mutate
+    name: str
+    value: Status
+    response: Optional[GenericResponse]
+    elapsed: float
+    example: Case
+    message: Optional[str] = None
     # Failure-specific context
-    context: Optional[FailureContext] = attr.ib(default=None)  # pragma: no mutate
-    request: Optional[requests.PreparedRequest] = attr.ib(default=None)  # pragma: no mutate
+    context: Optional[FailureContext] = None
+    request: Optional[requests.PreparedRequest] = None
 
 
-@attr.s(slots=True, repr=False)  # pragma: no mutate
+@dataclass(repr=False)
 class Request:
     """Request data extracted from `Case`."""
 
-    method: str = attr.ib()  # pragma: no mutate
-    uri: str = attr.ib()  # pragma: no mutate
-    body: Optional[str] = attr.ib()  # pragma: no mutate
-    headers: Headers = attr.ib()  # pragma: no mutate
+    method: str
+    uri: str
+    body: Optional[str]
+    headers: Headers
 
     @classmethod
     def from_case(cls, case: Case, session: requests.Session) -> "Request":
@@ -851,17 +893,17 @@ def serialize_payload(payload: bytes) -> str:
     return base64.b64encode(payload).decode()
 
 
-@attr.s(slots=True, repr=False)  # pragma: no mutate
+@dataclass(repr=False)
 class Response:
     """Unified response data."""
 
-    status_code: int = attr.ib()  # pragma: no mutate
-    message: str = attr.ib()  # pragma: no mutate
-    headers: Dict[str, List[str]] = attr.ib()  # pragma: no mutate
-    body: Optional[str] = attr.ib()  # pragma: no mutate
-    encoding: Optional[str] = attr.ib()  # pragma: no mutate
-    http_version: str = attr.ib()  # pragma: no mutate
-    elapsed: float = attr.ib()  # pragma: no mutate
+    status_code: int
+    message: str
+    headers: Dict[str, List[str]]
+    body: Optional[str]
+    encoding: Optional[str]
+    http_version: str
+    elapsed: float
 
     @classmethod
     def from_requests(cls, response: requests.Response) -> "Response":
@@ -911,16 +953,16 @@ class Response:
         )
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class Interaction:
     """A single interaction with the target app."""
 
-    request: Request = attr.ib()  # pragma: no mutate
-    response: Response = attr.ib()  # pragma: no mutate
-    checks: List[Check] = attr.ib()  # pragma: no mutate
-    status: Status = attr.ib()  # pragma: no mutate
-    data_generation_method: DataGenerationMethod = attr.ib()  # pragma: no mutate
-    recorded_at: str = attr.ib(factory=lambda: datetime.datetime.now().isoformat())  # pragma: no mutate
+    request: Request
+    response: Response
+    checks: List[Check]
+    status: Status
+    data_generation_method: DataGenerationMethod
+    recorded_at: str = field(default_factory=lambda: datetime.datetime.now().isoformat())
 
     @classmethod
     def from_requests(
@@ -955,28 +997,28 @@ class Interaction:
         )
 
 
-@attr.s(slots=True, repr=False)  # pragma: no mutate
+@dataclass(repr=False)
 class TestResult:
     """Result of a single test."""
 
     __test__ = False
 
-    method: str = attr.ib()  # pragma: no mutate
-    path: str = attr.ib()  # pragma: no mutate
-    verbose_name: str = attr.ib()  # pragma: no mutate
-    data_generation_method: List[DataGenerationMethod] = attr.ib()  # pragma: no mutate
-    checks: List[Check] = attr.ib(factory=list)  # pragma: no mutate
-    errors: List[Tuple[Exception, Optional[Case]]] = attr.ib(factory=list)  # pragma: no mutate
-    interactions: List[Interaction] = attr.ib(factory=list)  # pragma: no mutate
-    logs: List[LogRecord] = attr.ib(factory=list)  # pragma: no mutate
-    is_errored: bool = attr.ib(default=False)  # pragma: no mutate
-    is_flaky: bool = attr.ib(default=False)  # pragma: no mutate
-    is_skipped: bool = attr.ib(default=False)  # pragma: no mutate
-    is_executed: bool = attr.ib(default=False)  # pragma: no mutate
-    seed: Optional[int] = attr.ib(default=None)  # pragma: no mutate
+    method: str
+    path: str
+    verbose_name: str
+    data_generation_method: List[DataGenerationMethod]
+    checks: List[Check] = field(default_factory=list)
+    errors: List[Tuple[Exception, Optional[Case]]] = field(default_factory=list)
+    interactions: List[Interaction] = field(default_factory=list)
+    logs: List[LogRecord] = field(default_factory=list)
+    is_errored: bool = False
+    is_flaky: bool = False
+    is_skipped: bool = False
+    is_executed: bool = False
+    seed: Optional[int] = None
     # To show a proper reproduction code if an error happens and there is no way to get actual headers that were
     # sent over the network. Or there could be no actual requests at all
-    overridden_headers: Optional[Dict[str, Any]] = attr.ib(default=None)  # pragma: no mutate
+    overridden_headers: Optional[Dict[str, Any]] = None
 
     def mark_errored(self) -> None:
         self.is_errored = True
@@ -1052,15 +1094,15 @@ class TestResult:
         self.interactions.append(Interaction.from_wsgi(case, response, headers, elapsed, status, checks))
 
 
-@attr.s(slots=True, repr=False)  # pragma: no mutate
+@dataclass(repr=False)
 class TestResultSet:
     """Set of multiple test results."""
 
     __test__ = False
 
-    results: List[TestResult] = attr.ib(factory=list)  # pragma: no mutate
-    generic_errors: List[InvalidSchema] = attr.ib(factory=list)  # pragma: no mutate
-    warnings: List[str] = attr.ib(factory=list)  # pragma: no mutate
+    results: List[TestResult] = field(default_factory=list)
+    generic_errors: List[InvalidSchema] = field(default_factory=list)
+    warnings: List[str] = field(default_factory=list)
 
     def __iter__(self) -> Iterator[TestResult]:
         return iter(self.results)
@@ -1127,4 +1169,4 @@ class TestResultSet:
         self.warnings.append(warning)
 
 
-CheckFunction = Callable[[GenericResponse, Case], Optional[bool]]  # pragma: no mutate
+CheckFunction = Callable[[GenericResponse, Case], Optional[bool]]

schemathesis/parameters.py

@@ -2,15 +2,14 @@
 
 These are basic entities that describe what data could be sent to the API.
 """
-from typing import TYPE_CHECKING, Any, Dict, Generator, Generic, List, TypeVar
-
-import attr
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Dict, Generator, Generic, List, Optional, TypeVar
 
 if TYPE_CHECKING:
     from .models import APIOperation
 
 
-@attr.s(eq=False)  # pragma: no mutate
+@dataclass(eq=False)
 class Parameter:
     """A logically separate parameter bound to a location (e.g., to "query string").
 
@@ -19,7 +18,7 @@ class Parameter:
     """
 
     # The parameter definition in the language acceptable by the API
-    definition: Any = attr.ib()  # pragma: no mutate
+    definition: Any
 
     @property
     def location(self) -> str:
@@ -52,16 +51,22 @@ class Parameter:
 P = TypeVar("P", bound=Parameter)
 
 
-@attr.s  # pragma: no mutate
+@dataclass
 class ParameterSet(Generic[P]):
     """A set of parameters for the same location."""
 
-    items: List[P] = attr.ib(factory=list)  # pragma: no mutate
+    items: List[P] = field(default_factory=list)
 
     def add(self, parameter: P) -> None:
         """Add a new parameter."""
         self.items.append(parameter)
 
+    def get(self, name: str) -> Optional[P]:
+        for parameter in self:
+            if parameter.name == name:
+                return parameter
+        return None
+
     @property
     def example(self) -> Dict[str, Any]:
         """Composite example gathered from individual parameters."""