schemathesis 3.36.3__tar.gz → 3.36.4__tar.gz

{schemathesis-3.36.3 → schemathesis-3.36.4}/.github/workflows/build.yml

@@ -25,7 +25,7 @@ jobs:
     name: Generic pre-commit checks
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4.1.7
+      - uses: actions/checkout@v4.2.0
         with:
           fetch-depth: 1
 
@@ -41,7 +41,7 @@ jobs:
     name: Documentation
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4.1.7
+      - uses: actions/checkout@v4.2.0
         with:
           fetch-depth: 1
       - uses: ammaraskar/sphinx-action@master
@@ -63,7 +63,7 @@ jobs:
     name: Tests (Python ${{ matrix.python }} on ${{ matrix.os }} ${{ matrix.tox_env }})
     runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v4.1.7
+      - uses: actions/checkout@v4.2.0
         with:
           fetch-depth: 1
 
@@ -93,7 +93,7 @@ jobs:
     name: Test piping output to a file with CP1252 encoding on ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v4.1.7
+      - uses: actions/checkout@v4.2.0
         with:
           fetch-depth: 1
 

{schemathesis-3.36.3 → schemathesis-3.36.4}/.github/workflows/codeql-analysis.yml

@@ -30,7 +30,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4.1.7
+        uses: actions/checkout@v4.2.0
         with:
           # We must fetch at least the immediate parents so that if this is
           # a pull request then we can checkout the head.
@@ -38,7 +38,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3.26.8
+        uses: github/codeql-action/init@v3.26.9
         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.26.8
+        uses: github/codeql-action/autobuild@v3.26.9
 
       # ℹ️ 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.26.8
+        uses: github/codeql-action/analyze@v3.26.9

{schemathesis-3.36.3 → schemathesis-3.36.4}/.github/workflows/codspeed.yml

@@ -7,11 +7,14 @@ on:
   pull_request:
   workflow_dispatch:
 
+env:
+  SCHEMATHESIS_BENCHMARK_SEED: "42"
+
 jobs:
   benchmarks:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4.1.7
+      - uses: actions/checkout@v4.2.0
       - uses: actions/setup-python@v5
         with:
           # Python 3.12 for flamegraph support

{schemathesis-3.36.3 → schemathesis-3.36.4}/.github/workflows/commit.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - name: Check out code
-        uses: actions/checkout@v4.1.7
+        uses: actions/checkout@v4.2.0
         with:
           fetch-depth: 0
       - name: Run commitsar

{schemathesis-3.36.3 → schemathesis-3.36.4}/.github/workflows/example-build.yml

@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-22.04
 
     steps:
-      - uses: actions/checkout@v4.1.7
+      - uses: actions/checkout@v4.2.0
 
       - name: Start containers
         run: docker compose up -d --build

{schemathesis-3.36.3 → schemathesis-3.36.4}/.github/workflows/master_update.yml

@@ -20,7 +20,7 @@ jobs:
             tag: "latest-bookworm"
 
     steps:
-      - uses: actions/checkout@v4.1.7
+      - uses: actions/checkout@v4.2.0
 
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v3

{schemathesis-3.36.3 → schemathesis-3.36.4}/.github/workflows/release.yml

@@ -19,7 +19,7 @@ jobs:
             tag-suffix: "-bookworm"
 
     steps:
-      - uses: actions/checkout@v4.1.7
+      - uses: actions/checkout@v4.2.0
 
       - name: Docker meta
         id: meta
@@ -68,7 +68,7 @@ jobs:
     name: Build and publish package to pypi.org
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4.1.7
+      - uses: actions/checkout@v4.2.0
         with:
           fetch-depth: 1
 

{schemathesis-3.36.3 → schemathesis-3.36.4}/.github/workflows/test-corpus.yml

@@ -12,7 +12,7 @@ jobs:
     name: Default corpus tests
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4.1.7
+      - uses: actions/checkout@v4.2.0
         with:
           fetch-depth: 1
           submodules: true
@@ -29,7 +29,7 @@ jobs:
     name: Corpus tests for the coverage phase
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4.1.7
+      - uses: actions/checkout@v4.2.0
         with:
           fetch-depth: 1
           submodules: true

{schemathesis-3.36.3 → schemathesis-3.36.4}/.github/workflows/test-hypothesis.yml

@@ -11,7 +11,7 @@ jobs:
     name: Hypothesis tests with CI profile
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4.1.7
+      - uses: actions/checkout@v4.2.0
         with:
           fetch-depth: 1
 

{schemathesis-3.36.3 → schemathesis-3.36.4}/.github/workflows/update-pre-commit.yml

@@ -10,7 +10,7 @@ jobs:
     name: Update pre-commit
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4.1.7
+      - uses: actions/checkout@v4.2.0
         with:
           fetch-depth: 1
           submodules: true

{schemathesis-3.36.3 → schemathesis-3.36.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemathesis
-Version: 3.36.3
+Version: 3.36.4
 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.36.4/benches/coverage_phase.py

@@ -0,0 +1,133 @@
+"""Benchmarks for the coverage phase."""
+
+import pytest
+
+from schemathesis.generation.coverage import cover_schema_iter, CoverageContext
+
+CONTEXTS = [CoverageContext.with_positive(), CoverageContext.with_negative()]
+CONTEXT_NAMES = [",".join([m.value for m in ctx.data_generation_methods]) for ctx in CONTEXTS]
+
+BASIC_TYPES = [
+    {"type": "string"},
+    {"type": "integer"},
+    {"type": "number"},
+    {"type": "boolean"},
+    {"type": "null"},
+]
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize("ctx", CONTEXTS, ids=CONTEXT_NAMES)
+@pytest.mark.parametrize("schema", BASIC_TYPES, ids=lambda x: f"basic-{x['type']}")
+def test_basic_types(benchmark, ctx, schema):
+    benchmark(lambda: list(cover_schema_iter(ctx, schema)))
+
+
+STRING_CONSTRAINTS = [
+    {"type": "string", "minLength": 5},
+    {"type": "string", "maxLength": 10},
+    {"type": "string", "pattern": "^[a-z]+$"},
+    {"type": "string", "format": "email"},
+]
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize("ctx", CONTEXTS, ids=CONTEXT_NAMES)
+@pytest.mark.parametrize("schema", STRING_CONSTRAINTS, ids=lambda x: f"string-{list(x.keys())[1]}")
+def test_string_constraints(benchmark, ctx, schema):
+    benchmark(lambda: list(cover_schema_iter(ctx, schema)))
+
+
+NUMBER_CONSTRAINTS = [
+    {"type": "number", "minimum": 0, "maximum": 100},
+    {"type": "integer", "multipleOf": 5},
+    {"type": "number", "exclusiveMinimum": 0, "exclusiveMaximum": 1},
+]
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize("ctx", CONTEXTS, ids=CONTEXT_NAMES)
+@pytest.mark.parametrize("schema", NUMBER_CONSTRAINTS, ids=lambda x: f"number-{list(x.keys())[1]}")
+def test_number_constraints(benchmark, ctx, schema):
+    benchmark(lambda: list(cover_schema_iter(ctx, schema)))
+
+
+ARRAY_CONSTRAINTS = [
+    {"type": "array", "items": {"type": "string"}},
+    {"type": "array", "minItems": 2, "maxItems": 5},
+    {"type": "array", "uniqueItems": True},
+]
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize("ctx", CONTEXTS, ids=CONTEXT_NAMES)
+@pytest.mark.parametrize("schema", ARRAY_CONSTRAINTS, ids=lambda x: f"array-{list(x.keys())[1]}")
+def test_array_constraints(benchmark, ctx, schema):
+    benchmark(lambda: list(cover_schema_iter(ctx, schema)))
+
+
+OBJECT_CONSTRAINTS = [
+    {"type": "object", "properties": {"name": {"type": "string"}, "age": {"type": "integer"}}},
+    {"type": "object", "required": ["id"], "properties": {"id": {"type": "string"}}},
+    {"type": "object", "additionalProperties": False, "properties": {"key": {"type": "string"}}},
+]
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize("ctx", CONTEXTS, ids=CONTEXT_NAMES)
+@pytest.mark.parametrize("schema", OBJECT_CONSTRAINTS, ids=lambda x: f"object-{list(x.keys())[1]}")
+def test_object_constraints(benchmark, ctx, schema):
+    benchmark(lambda: list(cover_schema_iter(ctx, schema)))
+
+
+# Combined schemas
+COMBINED_SCHEMAS = [
+    {"anyOf": [{"type": "string"}, {"type": "integer"}]},
+    {"oneOf": [{"type": "number", "multipleOf": 5}, {"type": "number", "multipleOf": 3}]},
+    {"allOf": [{"type": "string"}, {"minLength": 5}]},
+]
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize("ctx", CONTEXTS, ids=CONTEXT_NAMES)
+@pytest.mark.parametrize("schema", COMBINED_SCHEMAS, ids=lambda x: f"combined-{list(x.keys())[0]}")
+def test_combined_schemas(benchmark, ctx, schema):
+    benchmark(lambda: list(cover_schema_iter(ctx, schema)))
+
+
+COMPLEX_NESTED_SCHEMAS = [
+    {
+        "type": "object",
+        "properties": {
+            "user": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string"},
+                    "age": {"type": "integer", "minimum": 18},
+                    "emails": {"type": "array", "items": {"type": "string", "format": "email"}},
+                },
+                "required": ["name", "age"],
+            }
+        },
+    },
+    {
+        "type": "array",
+        "items": {
+            "type": "object",
+            "properties": {
+                "id": {"type": "integer"},
+                "tags": {"type": "array", "items": {"type": "string"}, "uniqueItems": True},
+            },
+            "required": ["id"],
+        },
+        "minItems": 1,
+        "maxItems": 10,
+    },
+]
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize("ctx", CONTEXTS, ids=CONTEXT_NAMES)
+@pytest.mark.parametrize("schema", COMPLEX_NESTED_SCHEMAS, ids=lambda x: f"complex-{x['type']}")
+def test_complex_nested_schemas(benchmark, ctx, schema):
+    benchmark(lambda: list(cover_schema_iter(ctx, schema)))

{schemathesis-3.36.3 → schemathesis-3.36.4}/docs/changelog.rst

@@ -1,9 +1,24 @@
 Changelog
 =========
 
-:version:`Unreleased <v3.36.3...HEAD>` - TBD
+:version:`Unreleased <v3.36.4...HEAD>` - TBD
 --------------------------------------------
 
+.. _v3.36.4:
+
+:version:`3.36.4 <v3.36.3...v3.36.4>` - 2024-10-05
+--------------------------------------------------
+
+**Fixed**
+
+- False positive for ``ignored_auth`` when used in stateful test runner. :issue:`2482`
+- Open Api 3.1 spec using ``$ref`` in a path is incorrectly validated as invalid. :issue:`2484`
+- Properly serialize ``seed`` in cassettes if ``--hypothesis-derandomize`` is present.
+
+**Performance**
+
+- Improvements for the coverage phase.
+
 .. _v3.36.3:
 
 :version:`3.36.3 <v3.36.2...v3.36.3>` - 2024-09-29

{schemathesis-3.36.3 → schemathesis-3.36.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "3.36.3"
+version = "3.36.4"
 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.36.3 → schemathesis-3.36.4}/src/schemathesis/cli/cassettes.py

@@ -79,24 +79,18 @@ class CassetteWriter(EventHandler):
     def handle_event(self, context: ExecutionContext, event: events.ExecutionEvent) -> None:
         if isinstance(event, events.Initialized):
             # In the beginning we write metadata and start `http_interactions` list
-            self.queue.put(Initialize())
+            self.queue.put(Initialize(seed=event.seed))
         elif isinstance(event, events.AfterExecution):
-            # Seed is always present at this point, the original Optional[int] type is there because `TestResult`
-            # instance is created before `seed` is generated on the hypothesis side
-            seed = cast(int, event.result.seed)
             self.queue.put(
                 Process(
-                    seed=seed,
                     correlation_id=event.correlation_id,
                     thread_id=event.thread_id,
                     interactions=event.result.interactions,
                 )
             )
         elif isinstance(event, events.AfterStatefulExecution):
-            seed = cast(int, event.result.seed)
             self.queue.put(
                 Process(
-                    seed=seed,
                     # Correlation ID is not used in stateful testing
                     correlation_id="",
                     thread_id=event.thread_id,
@@ -118,12 +112,13 @@ class CassetteWriter(EventHandler):
 class Initialize:
     """Start up, the first message to make preparations before proceeding the input data."""
 
+    seed: int | None
+
 
 @dataclass
 class Process:
     """A new chunk of data should be processed."""
 
-    seed: int
     correlation_id: str
     thread_id: int
     interactions: list[SerializedInteraction]
@@ -219,9 +214,11 @@ def vcr_writer(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: boo
                 )
                 write_double_quoted(output, string)
 
+    seed = "null"
     while True:
         item = queue.get()
         if isinstance(item, Initialize):
+            seed = f"'{item.seed}'"
             stream.write(
                 f"""command: '{get_command_representation()}'
 recorded_with: 'Schemathesis {SCHEMATHESIS_VERSION}'
@@ -235,7 +232,7 @@ http_interactions:"""
                 stream.write(
                     f"""\n- id: '{current_id}'
   status: '{status}'
-  seed: '{item.seed}'
+  seed: {seed}
   thread_id: {item.thread_id}
   correlation_id: '{item.correlation_id}'
   data_generation_method: '{interaction.data_generation_method.value}'

{schemathesis-3.36.3 → schemathesis-3.36.4}/src/schemathesis/generation/_hypothesis.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 from functools import lru_cache, reduce
 from operator import or_
 from typing import TYPE_CHECKING, TypeVar
@@ -8,6 +9,8 @@ if TYPE_CHECKING:
     from hypothesis import settings
     from hypothesis import strategies as st
 
+SCHEMATHESIS_BENCHMARK_SEED = os.environ.get("SCHEMATHESIS_BENCHMARK_SEED")
+
 
 @lru_cache
 def default_settings() -> settings:
@@ -33,13 +36,16 @@ def get_single_example(strategy: st.SearchStrategy[T]) -> T:  # type: ignore[typ
 
 
 def add_single_example(strategy: st.SearchStrategy[T], examples: list[T]) -> None:
-    from hypothesis import given
+    from hypothesis import given, seed
 
     @given(strategy)  # type: ignore
     @default_settings()  # type: ignore
     def example_generating_inner_function(ex: T) -> None:
         examples.append(ex)
 
+    if SCHEMATHESIS_BENCHMARK_SEED is not None:
+        example_generating_inner_function = seed(SCHEMATHESIS_BENCHMARK_SEED)(example_generating_inner_function)
+
     example_generating_inner_function()
 
 

{schemathesis-3.36.3 → schemathesis-3.36.4}/src/schemathesis/generation/coverage.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import json
+import functools
 from contextlib import contextmanager, suppress
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from functools import lru_cache
 from itertools import combinations
 from typing import Any, Generator, Iterator, TypeVar, cast
@@ -18,12 +19,20 @@ from schemathesis.constants import NOT_SET
 from ._hypothesis import get_single_example
 from ._methods import DataGenerationMethod
 
+
+def _replace_zero_with_nonzero(x: float) -> float:
+    return x or 0.0
+
+
+def json_recursive_strategy(strategy: st.SearchStrategy) -> st.SearchStrategy:
+    return st.lists(strategy, max_size=3) | st.dictionaries(st.text(), strategy, max_size=3)
+
+
 BUFFER_SIZE = 8 * 1024
-FLOAT_STRATEGY: st.SearchStrategy = st.floats(allow_nan=False, allow_infinity=False).map(lambda x: x or 0.0)
+FLOAT_STRATEGY: st.SearchStrategy = st.floats(allow_nan=False, allow_infinity=False).map(_replace_zero_with_nonzero)
 NUMERIC_STRATEGY: st.SearchStrategy = st.integers() | FLOAT_STRATEGY
 JSON_STRATEGY: st.SearchStrategy = st.recursive(
-    st.none() | st.booleans() | NUMERIC_STRATEGY | st.text(),
-    lambda strategy: st.lists(strategy, max_size=3) | st.dictionaries(st.text(), strategy, max_size=3),
+    st.none() | st.booleans() | NUMERIC_STRATEGY | st.text(), json_recursive_strategy
 )
 ARRAY_STRATEGY: st.SearchStrategy = st.lists(JSON_STRATEGY)
 OBJECT_STRATEGY: st.SearchStrategy = st.dictionaries(st.text(), JSON_STRATEGY)
@@ -60,7 +69,14 @@ def cached_draw(strategy: st.SearchStrategy) -> Any:
 
 @dataclass
 class CoverageContext:
-    data_generation_methods: list[DataGenerationMethod] = field(default_factory=DataGenerationMethod.all)
+    data_generation_methods: list[DataGenerationMethod]
+
+    __slots__ = ("data_generation_methods",)
+
+    def __init__(self, data_generation_methods: list[DataGenerationMethod] | None = None) -> None:
+        self.data_generation_methods = (
+            data_generation_methods if data_generation_methods is not None else DataGenerationMethod.all()
+        )
 
     @classmethod
     def with_positive(cls) -> CoverageContext:
@@ -70,12 +86,8 @@ class CoverageContext:
     def with_negative(cls) -> CoverageContext:
         return CoverageContext(data_generation_methods=[DataGenerationMethod.negative])
 
-    def generate_from(self, strategy: st.SearchStrategy, cached: bool = False) -> Any:
-        if cached:
-            value = cached_draw(strategy)
-        else:
-            value = get_single_example(strategy)
-        return value
+    def generate_from(self, strategy: st.SearchStrategy) -> Any:
+        return cached_draw(strategy)
 
     def generate_from_schema(self, schema: dict) -> Any:
         return self.generate_from(from_schema(schema))
@@ -554,9 +566,12 @@ def select_combinations(optional: list[str]) -> Iterator[tuple[str, ...]]:
 
 
 def _negative_enum(ctx: CoverageContext, value: list) -> Generator[GeneratedValue, None, None]:
-    strategy = JSON_STRATEGY.filter(lambda x: x not in value)
+    def is_not_in_value(x: Any) -> bool:
+        return x not in value
+
+    strategy = JSON_STRATEGY.filter(is_not_in_value)
     # The exact negative value is not important here
-    yield NegativeValue(ctx.generate_from(strategy, cached=True), description="Invalid enum value")
+    yield NegativeValue(ctx.generate_from(strategy), description="Invalid enum value")
 
 
 def _negative_properties(
@@ -573,7 +588,7 @@ def _negative_properties(
 
 def _negative_pattern(ctx: CoverageContext, pattern: str) -> Generator[GeneratedValue, None, None]:
     yield NegativeValue(
-        ctx.generate_from(st.text().filter(lambda x: x != pattern), cached=True),
+        ctx.generate_from(st.text().filter(pattern.__ne__)),
         description=f"Value not matching the '{pattern}' pattern",
     )
 
@@ -606,19 +621,31 @@ def _negative_required(
         )
 
 
+def _is_invalid_hostname(v: Any) -> bool:
+    return v == "" or not jsonschema.Draft202012Validator.FORMAT_CHECKER.conforms(v, "hostname")
+
+
+def _is_invalid_format(v: Any, format: str) -> bool:
+    return not jsonschema.Draft202012Validator.FORMAT_CHECKER.conforms(v, format)
+
+
 def _negative_format(ctx: CoverageContext, schema: dict, format: str) -> Generator[GeneratedValue, None, None]:
     # Hypothesis-jsonschema does not canonicalise it properly right now, which leads to unsatisfiable schema
     without_format = {k: v for k, v in schema.items() if k != "format"}
     without_format.setdefault("type", "string")
     strategy = from_schema(without_format)
     if format in jsonschema.Draft202012Validator.FORMAT_CHECKER.checkers:
-        strategy = strategy.filter(
-            lambda v: (format == "hostname" and v == "")
-            or not jsonschema.Draft202012Validator.FORMAT_CHECKER.conforms(v, format)
-        )
+        if format == "hostname":
+            strategy = strategy.filter(_is_invalid_hostname)
+        else:
+            strategy = strategy.filter(functools.partial(_is_invalid_format, format=format))
     yield NegativeValue(ctx.generate_from(strategy), description=f"Value not matching the '{format}' format")
 
 
+def _is_non_integer_float(x: float) -> bool:
+    return x != int(x)
+
+
 def _negative_type(ctx: CoverageContext, seen: set, ty: str | list[str]) -> Generator[GeneratedValue, None, None]:
     strategies = {
         "integer": st.integers(),
@@ -638,9 +665,9 @@ def _negative_type(ctx: CoverageContext, seen: set, ty: str | list[str]) -> Gene
     if "number" in types:
         del strategies["integer"]
     if "integer" in types:
-        strategies["number"] = FLOAT_STRATEGY.filter(lambda x: x != int(x))
+        strategies["number"] = FLOAT_STRATEGY.filter(_is_non_integer_float)
     for strat in strategies.values():
-        value = ctx.generate_from(strat, cached=True)
+        value = ctx.generate_from(strat)
         hashed = _to_hashable_key(value)
         if hashed in seen:
             continue

{schemathesis-3.36.3 → schemathesis-3.36.4}/src/schemathesis/internal/checks.py

@@ -6,6 +6,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Callable, Optional
 
 if TYPE_CHECKING:
+    from requests.auth import HTTPDigestAuth
     from requests.structures import CaseInsensitiveDict
 
     from ..models import Case
@@ -23,7 +24,7 @@ class CheckContext:
     Provides access to broader test execution data beyond individual test cases.
     """
 
-    auth: RawAuth | None = None
+    auth: HTTPDigestAuth | RawAuth | None = None
     headers: CaseInsensitiveDict | None = None