schemathesis 3.32.0__tar.gz → 3.32.1__tar.gz

{schemathesis-3.32.0 → schemathesis-3.32.1}/.github/workflows/codeql-analysis.yml

@@ -38,7 +38,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3.25.11
+        uses: github/codeql-action/init@v3.25.12
         with:
           languages: ${{ matrix.language }}
           # If you wish to specify custom queries, you can do so here or in a config file.
@@ -49,7 +49,7 @@ jobs:
       # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
       # If this step fails, then you should remove it and run the build manually (see below)
       - name: Autobuild
-        uses: github/codeql-action/autobuild@v3.25.11
+        uses: github/codeql-action/autobuild@v3.25.12
 
       # ℹ️ Command-line programs to run using the OS shell.
       # 📚 https://git.io/JvXDl
@@ -63,4 +63,4 @@ jobs:
       #   make release
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3.25.11
+        uses: github/codeql-action/analyze@v3.25.12

{schemathesis-3.32.0 → schemathesis-3.32.1}/.pre-commit-config.yaml

@@ -48,7 +48,7 @@ repos:
       - id: ruff
 
   - repo: https://github.com/myint/rstcheck
-    rev: v6.2.0
+    rev: v6.2.4
     hooks:
       - id: rstcheck
         additional_dependencies:

{schemathesis-3.32.0 → schemathesis-3.32.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schemathesis
-Version: 3.32.0
+Version: 3.32.1
 Summary: Property-based testing framework for Open API and GraphQL based apps
 Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
 Project-URL: Changelog, https://schemathesis.readthedocs.io/en/stable/changelog.html

{schemathesis-3.32.0 → schemathesis-3.32.1}/docs/auth.rst

@@ -237,6 +237,7 @@ Conditions:
 - ``method``: the upper-cased HTTP method of the API operation
 - ``name``: the name of the API operation, such as ``GET /users/`` or ``Query.getUsers``
 - ``tag``: the tag assigned to the API operation. For Open API it comes from the ``tags`` field.
+- ``operation_id``: the ID of an API operation. For Open API it comes from the ``operationId`` field.
 - Each condition can take either a single string or a list of options as input
 - You can also use a regular expression to match the conditions by adding ``_regex`` to the end of the condition and passing a string or a compiled regex.
 

{schemathesis-3.32.0 → schemathesis-3.32.1}/docs/changelog.rst

@@ -1,9 +1,22 @@
 Changelog
 =========
 
-:version:`Unreleased <v3.32.0...HEAD>` - TBD
+:version:`Unreleased <v3.32.1...HEAD>` - TBD
 --------------------------------------------
 
+.. _v3.32.1:
+
+:version:`3.32.1 <v3.32.0...v3.32.1>` - 2024-07-17
+--------------------------------------------------
+
+**Added**
+
+- Filtering by ``operation_id`` in conditional auth implementation.
+
+**Fixed**
+
+- Internal error when saving debug logs with ``--experimental=stateful-test-runner`` or ``--experimental=schema-analysis`` enabled. :issue:`2353`
+
 .. _v3.32.0:
 
 :version:`3.32.0 <v3.31.1...v3.32.0>` - 2024-07-14
@@ -29,7 +42,7 @@ Changelog
 - Ignoring configured data generation methods in new-style stateful tests.
 - Using constant ``data_generation_method`` value for HTTP interactions in VCR cassettes.
 - Not reporting errors with ``--experimental=stateful-only``. :issue:`2326`
-- Internal error on CRTL-C during new-style stateful tests.
+- Internal error on CTRL-C during new-style stateful tests.
 - Use ``--request-proxy`` for API probing.
 - Fill the ``seed`` field in cassettes for new-style stateful tests.
 - Ignoring remote scope when getting API operation by reference.

{schemathesis-3.32.0 → schemathesis-3.32.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "3.32.0"
+version = "3.32.1"
 description = "Property-based testing framework for Open API and GraphQL based apps"
 keywords = ["pytest", "hypothesis", "openapi", "graphql", "testing"]
 authors = [{ name = "Dmitry Dygalo", email = "dmitry@dygalo.dev" }]

{schemathesis-3.32.0 → schemathesis-3.32.1}/src/schemathesis/filters.py

@@ -8,6 +8,8 @@ from functools import partial
 from types import SimpleNamespace
 from typing import TYPE_CHECKING, Callable, List, Protocol, Union
 
+from .types import NotSet, Filter as FilterType
+
 from .exceptions import UsageError
 
 if TYPE_CHECKING:
@@ -58,7 +60,12 @@ class Matcher:
     def for_regex(cls, attribute: str, regex: RegexValue) -> Matcher:
         """Matcher that checks whether the specified attribute has the provided regex."""
         if isinstance(regex, str):
-            regex = re.compile(regex)
+            flags: re.RegexFlag | int
+            if attribute == "method":
+                flags = re.IGNORECASE
+            else:
+                flags = 0
+            regex = re.compile(regex, flags=flags)
         func = partial(by_regex, attribute=attribute, regex=regex)
         label = f"{attribute}_regex={repr(regex)}"
         return cls(func, label=label, _hash=hash(label))
@@ -71,6 +78,8 @@ class Matcher:
 def get_operation_attribute(operation: APIOperation, attribute: str) -> str | list[str] | None:
     if attribute == "tag":
         return operation.tags
+    if attribute == "operation_id":
+        return operation.definition.raw.get("operationId")
     # Just uppercase `method`
     value = getattr(operation, attribute)
     if attribute == "method":
@@ -101,8 +110,8 @@ def by_regex(ctx: HasAPIOperation, attribute: str, regex: re.Pattern) -> bool:
     if value is None:
         return False
     if isinstance(value, list):
-        return any(bool(regex.match(entry)) for entry in value)
-    return bool(regex.match(value))
+        return any(bool(regex.search(entry)) for entry in value)
+    return bool(regex.search(value))
 
 
 @dataclass(repr=False, frozen=True)
@@ -111,6 +120,8 @@ class Filter:
 
     matchers: tuple[Matcher, ...]
 
+    __slots__ = ("matchers",)
+
     def __repr__(self) -> str:
         inner = " && ".join(matcher.label for matcher in self.matchers)
         return f"<{self.__class__.__name__}: [{inner}]>"
@@ -127,8 +138,14 @@ class Filter:
 class FilterSet:
     """Combines multiple filters to apply inclusion and exclusion rules on API operations."""
 
-    _includes: set[Filter] = field(default_factory=set)
-    _excludes: set[Filter] = field(default_factory=set)
+    _includes: set[Filter]
+    _excludes: set[Filter]
+
+    __slots__ = ("_includes", "_excludes")
+
+    def __init__(self) -> None:
+        self._includes = set()
+        self._excludes = set()
 
     def apply_to(self, operations: list[APIOperation]) -> list[APIOperation]:
         """Get a filtered list of the given operations that match the filters."""
@@ -168,6 +185,8 @@ class FilterSet:
         path_regex: RegexValue | None = None,
         tag: FilterValue | None = None,
         tag_regex: RegexValue | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
     ) -> None:
         """Add a new INCLUDE filter."""
         self._add_filter(
@@ -181,6 +200,8 @@ class FilterSet:
             path_regex=path_regex,
             tag=tag,
             tag_regex=tag_regex,
+            operation_id=operation_id,
+            operation_id_regex=operation_id_regex,
         )
 
     def exclude(
@@ -195,6 +216,8 @@ class FilterSet:
         path_regex: RegexValue | None = None,
         tag: FilterValue | None = None,
         tag_regex: RegexValue | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
     ) -> None:
         """Add a new EXCLUDE filter."""
         self._add_filter(
@@ -208,6 +231,8 @@ class FilterSet:
             path_regex=path_regex,
             tag=tag,
             tag_regex=tag_regex,
+            operation_id=operation_id,
+            operation_id_regex=operation_id_regex,
         )
 
     def _add_filter(
@@ -223,6 +248,8 @@ class FilterSet:
         path_regex: RegexValue | None = None,
         tag: FilterValue | None = None,
         tag_regex: RegexValue | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
     ) -> None:
         matchers = []
         if func is not None:
@@ -232,6 +259,7 @@ class FilterSet:
             ("method", method, method_regex),
             ("path", path, path_regex),
             ("tag", tag, tag_regex),
+            ("operation_id", operation_id, operation_id_regex),
         ):
             if expected is not None and regex is not None:
                 # To match anything the regex should match the expected value, hence passing them together is useless
@@ -295,3 +323,74 @@ def attach_filter_chain(
     proxy.__name__ = attribute
 
     setattr(target, attribute, proxy)
+
+
+def filter_set_from_components(
+    *,
+    include: bool,
+    method: FilterType | None = None,
+    endpoint: FilterType | None = None,
+    tag: FilterType | None = None,
+    operation_id: FilterType | None = None,
+    skip_deprecated_operations: bool | None | NotSet = None,
+    parent: FilterSet | None = None,
+) -> FilterSet:
+    def _is_defined(x: FilterType | None) -> bool:
+        return x is not None and not isinstance(x, NotSet)
+
+    def _is_deprecated(ctx: HasAPIOperation) -> bool:
+        return ctx.operation.definition.raw.get("deprecated") is True
+
+    def _prepare_filter(filter_: FilterType | None) -> RegexValue | None:
+        if filter_ is None or isinstance(filter_, NotSet):
+            return None
+        if isinstance(filter_, str):
+            return filter_
+        return "|".join(f"({f})" for f in filter_)
+
+    new = FilterSet()
+
+    if _is_defined(method) or _is_defined(endpoint) or _is_defined(tag) or _is_defined(operation_id):
+        new._add_filter(
+            include,
+            method_regex=_prepare_filter(method),
+            path_regex=_prepare_filter(endpoint),
+            tag_regex=_prepare_filter(tag),
+            operation_id_regex=_prepare_filter(operation_id),
+        )
+    if skip_deprecated_operations is True and not any(
+        matcher.label == _is_deprecated.__name__ for exclude_ in new._excludes for matcher in exclude_.matchers
+    ):
+        new.exclude(func=_is_deprecated)
+    # Merge with the parent filter set
+    if parent is not None:
+        for include_ in parent._includes:
+            matchers = include_.matchers
+            ids = []
+            for idx, matcher in enumerate(matchers):
+                label = matcher.label
+                if (
+                    (not isinstance(method, NotSet) and label.startswith("method_regex="))
+                    or (not isinstance(endpoint, NotSet) and label.startswith("path_regex="))
+                    or (not isinstance(tag, NotSet) and matcher.label.startswith("tag_regex="))
+                    or (not isinstance(operation_id, NotSet) and matcher.label.startswith("operation_id_regex="))
+                ):
+                    ids.append(idx)
+            if ids:
+                matchers = tuple(matcher for idx, matcher in enumerate(matchers) if idx not in ids)
+            if matchers:
+                if new._includes:
+                    existing = new._includes.pop()
+                    matchers = existing.matchers + matchers
+                new._includes.add(Filter(matchers=matchers))
+        for exclude_ in parent._excludes:
+            matchers = exclude_.matchers
+            ids = []
+            for idx, matcher in enumerate(exclude_.matchers):
+                if skip_deprecated_operations is False and matcher.label == _is_deprecated.__name__:
+                    ids.append(idx)
+            if ids:
+                matchers = tuple(matcher for idx, matcher in enumerate(matchers) if idx not in ids)
+            if matchers:
+                new._excludes.add(exclude_)
+    return new

{schemathesis-3.32.0 → schemathesis-3.32.1}/src/schemathesis/lazy.py

@@ -19,6 +19,7 @@ from .auths import AuthStorage
 from .code_samples import CodeSampleStyle
 from .constants import FLAKY_FAILURE_MESSAGE, NOT_SET
 from .exceptions import CheckFailed, OperationSchemaError, SkipTest, get_grouped_exception
+from .filters import filter_set_from_components
 from .generation import DataGenerationMethodInput, GenerationConfig
 from .hooks import HookDispatcher, HookScope
 from .internal.output import OutputConfig
@@ -341,18 +342,24 @@ def get_schema(
     schema = request.getfixturevalue(name)
     if not isinstance(schema, BaseSchema):
         raise ValueError(f"The given schema must be an instance of BaseSchema, got: {type(schema)}")
-    return schema.clone(
-        base_url=base_url,
+
+    filter_set = filter_set_from_components(
+        include=True,
         method=method,
         endpoint=endpoint,
         tag=tag,
         operation_id=operation_id,
+        skip_deprecated_operations=skip_deprecated_operations,
+        parent=schema.filter_set,
+    )
+    return schema.clone(
+        base_url=base_url,
+        filter_set=filter_set,
         app=app,
         test_function=test_function,
         hooks=schema.hooks.merge(hooks),
         auth=auth,
         validate_schema=validate_schema,
-        skip_deprecated_operations=skip_deprecated_operations,
         data_generation_methods=data_generation_methods,
         generation_config=generation_config,
         output_config=output_config,

{schemathesis-3.32.0 → schemathesis-3.32.1}/src/schemathesis/runner/events.py

@@ -9,7 +9,8 @@ from typing import TYPE_CHECKING, Any
 from ..exceptions import RuntimeErrorType, SchemaError, SchemaErrorType, format_exception
 from ..generation import DataGenerationMethod
 from ..internal.datetime import current_datetime
-from ..internal.result import Result
+from ..internal.result import Err, Ok, Result
+from ..service.models import AnalysisSuccess
 from .serialization import SerializedError, SerializedTestResult
 
 if TYPE_CHECKING:
@@ -105,6 +106,23 @@ class BeforeAnalysis(ExecutionEvent):
 class AfterAnalysis(ExecutionEvent):
     analysis: Result[AnalysisResult, Exception] | None
 
+    def _serialize(self) -> dict[str, Any]:
+        data = {}
+        if isinstance(self.analysis, Ok):
+            result = self.analysis.ok()
+            if isinstance(result, AnalysisSuccess):
+                data["analysis_id"] = result.id
+            else:
+                data["error"] = result.message
+        elif isinstance(self.analysis, Err):
+            data["error"] = format_exception(self.analysis.err())
+        return data
+
+    def asdict(self, **kwargs: Any) -> dict[str, Any]:
+        data = self._serialize()
+        data["event_type"] = self.__class__.__name__
+        return data
+
 
 class CurrentOperationMixin:
     method: str
@@ -296,6 +314,9 @@ class StatefulEvent(ExecutionEvent):
 
     __slots__ = ("data",)
 
+    def asdict(self, **kwargs: Any) -> dict[str, Any]:
+        return {"data": self.data.asdict(**kwargs), "event_type": self.__class__.__name__}
+
 
 @dataclass
 class AfterStatefulExecution(ExecutionEvent):

{schemathesis-3.32.0 → schemathesis-3.32.1}/src/schemathesis/runner/serialization.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 import logging
 import re
 import textwrap
-from dataclasses import dataclass, field
+from dataclasses import asdict, dataclass, field
 from typing import TYPE_CHECKING, Any, cast
 
 from ..code_samples import get_excluded_headers
@@ -453,3 +453,72 @@ def deduplicate_failures(checks: list[SerializedCheck]) -> list[SerializedCheck]
                 unique_checks.append(check)
                 seen.add(key)
     return unique_checks
+
+
+def _serialize_case(case: SerializedCase) -> dict[str, Any]:
+    return {
+        "id": case.id,
+        "generation_time": case.generation_time,
+        "verbose_name": case.verbose_name,
+        "path_template": case.path_template,
+        "path_parameters": stringify_path_parameters(case.path_parameters),
+        "query": prepare_query(case.query),
+        "cookies": case.cookies,
+        "media_type": case.media_type,
+    }
+
+
+def _serialize_response(response: Response) -> dict[str, Any]:
+    return {
+        "status_code": response.status_code,
+        "headers": response.headers,
+        "body": response.body,
+        "encoding": response.encoding,
+        "elapsed": response.elapsed,
+    }
+
+
+def _serialize_check(check: SerializedCheck) -> dict[str, Any]:
+    return {
+        "name": check.name,
+        "value": check.value,
+        "request": {
+            "method": check.request.method,
+            "uri": check.request.uri,
+            "body": check.request.body,
+            "headers": check.request.headers,
+        },
+        "response": _serialize_response(check.response) if check.response is not None else None,
+        "example": _serialize_case(check.example),
+        "message": check.message,
+        "context": asdict(check.context) if check.context is not None else None,  # type: ignore
+        "history": [
+            {"case": _serialize_case(entry.case), "response": _serialize_response(entry.response)}
+            for entry in check.history
+        ],
+    }
+
+
+def stringify_path_parameters(path_parameters: dict[str, Any] | None) -> dict[str, str]:
+    """Cast all path parameter values to strings.
+
+    Path parameter values may be of arbitrary type, but to display them properly they should be casted to strings.
+    """
+    return {key: str(value) for key, value in (path_parameters or {}).items()}
+
+
+def prepare_query(query: dict[str, Any] | None) -> dict[str, list[str]]:
+    """Convert all query values to list of strings.
+
+    Query parameters may be generated in different shapes, including integers, strings, list of strings, etc.
+    It can also be an object, if the schema contains an object, but `style` and `explode` combo is not applicable.
+    """
+
+    def to_list_of_strings(value: Any) -> list[str]:
+        if isinstance(value, list):
+            return list(map(str, value))
+        if isinstance(value, str):
+            return [value]
+        return [str(value)]
+
+    return {key: to_list_of_strings(value) for key, value in (query or {}).items()}

{schemathesis-3.32.0 → schemathesis-3.32.1}/src/schemathesis/schemas.py

@@ -37,6 +37,7 @@ from .auths import AuthStorage
 from .code_samples import CodeSampleStyle
 from .constants import NOT_SET
 from .exceptions import OperationSchemaError, UsageError
+from .filters import FilterSet, filter_set_from_components
 from .generation import (
     DEFAULT_DATA_GENERATION_METHODS,
     DataGenerationMethod,
@@ -81,16 +82,12 @@ class BaseSchema(Mapping):
     transport: Transport
     location: str | None = None
     base_url: str | None = None
-    method: Filter | None = None
-    endpoint: Filter | None = None
-    tag: Filter | None = None
-    operation_id: Filter | None = None
+    filter_set: FilterSet = field(default_factory=FilterSet)
     app: Any = None
     hooks: HookDispatcher = field(default_factory=lambda: HookDispatcher(scope=HookScope.SCHEMA))
     auth: AuthStorage = field(default_factory=AuthStorage)
     test_function: GenericTest | None = None
     validate_schema: bool = True
-    skip_deprecated_operations: bool = False
     data_generation_methods: list[DataGenerationMethod] = field(
         default_factory=lambda: list(DEFAULT_DATA_GENERATION_METHODS)
     )
@@ -242,6 +239,16 @@ class BaseSchema(Mapping):
             CodeSampleStyle.from_str(code_sample_style) if isinstance(code_sample_style, str) else code_sample_style
         )
 
+        filter_set = filter_set_from_components(
+            include=True,
+            method=method,
+            endpoint=endpoint,
+            tag=tag,
+            operation_id=operation_id,
+            skip_deprecated_operations=skip_deprecated_operations,
+            parent=self.filter_set,
+        )
+
         def wrapper(func: GenericTest) -> GenericTest:
             if hasattr(func, PARAMETRIZE_MARKER):
 
@@ -256,13 +263,9 @@ class BaseSchema(Mapping):
             HookDispatcher.add_dispatcher(func)
             cloned = self.clone(
                 test_function=func,
-                method=method,
-                endpoint=endpoint,
-                tag=tag,
-                operation_id=operation_id,
                 validate_schema=validate_schema,
-                skip_deprecated_operations=skip_deprecated_operations,
                 data_generation_methods=data_generation_methods,
+                filter_set=filter_set,
                 code_sample_style=_code_sample_style,  # type: ignore
             )
             setattr(func, PARAMETRIZE_MARKER, cloned)
@@ -279,38 +282,26 @@ class BaseSchema(Mapping):
         *,
         base_url: str | None | NotSet = NOT_SET,
         test_function: GenericTest | None = None,
-        method: Filter | None = NOT_SET,
-        endpoint: Filter | None = NOT_SET,
-        tag: Filter | None = NOT_SET,
-        operation_id: Filter | None = NOT_SET,
         app: Any = NOT_SET,
         hooks: HookDispatcher | NotSet = NOT_SET,
         auth: AuthStorage | NotSet = NOT_SET,
         validate_schema: bool | NotSet = NOT_SET,
-        skip_deprecated_operations: bool | NotSet = NOT_SET,
         data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET,
         generation_config: GenerationConfig | NotSet = NOT_SET,
         output_config: OutputConfig | NotSet = NOT_SET,
         code_sample_style: CodeSampleStyle | NotSet = NOT_SET,
         rate_limiter: Limiter | None = NOT_SET,
         sanitize_output: bool | NotSet | None = NOT_SET,
+        filter_set: FilterSet | None = None,
     ) -> BaseSchema:
         if base_url is NOT_SET:
             base_url = self.base_url
-        if method is NOT_SET:
-            method = self.method
-        if endpoint is NOT_SET:
-            endpoint = self.endpoint
-        if tag is NOT_SET:
-            tag = self.tag
-        if operation_id is NOT_SET:
-            operation_id = self.operation_id
         if app is NOT_SET:
             app = self.app
         if validate_schema is NOT_SET:
             validate_schema = self.validate_schema
-        if skip_deprecated_operations is NOT_SET:
-            skip_deprecated_operations = self.skip_deprecated_operations
+        if filter_set is None:
+            filter_set = self.filter_set
         if hooks is NOT_SET:
             hooks = self.hooks
         if auth is NOT_SET:
@@ -332,22 +323,18 @@ class BaseSchema(Mapping):
             self.raw_schema,
             location=self.location,
             base_url=base_url,  # type: ignore
-            method=method,
-            endpoint=endpoint,
-            tag=tag,
-            operation_id=operation_id,
             app=app,
             hooks=hooks,  # type: ignore
             auth=auth,  # type: ignore
             test_function=test_function,
             validate_schema=validate_schema,  # type: ignore
-            skip_deprecated_operations=skip_deprecated_operations,  # type: ignore
             data_generation_methods=data_generation_methods,  # type: ignore
             generation_config=generation_config,  # type: ignore
             output_config=output_config,  # type: ignore
             code_sample_style=code_sample_style,  # type: ignore
             rate_limiter=rate_limiter,  # type: ignore
             sanitize_output=sanitize_output,  # type: ignore
+            filter_set=filter_set,  # type: ignore
             transport=self.transport,
         )