schemathesis 4.3.15__py3-none-any.whl → 4.3.17__py3-none-any.whl

schemathesis/auths.py

@@ -17,7 +17,7 @@ from typing import (
     runtime_checkable,
 )
 
-from schemathesis.core.errors import IncorrectUsage
+from schemathesis.core.errors import AuthenticationError, IncorrectUsage
 from schemathesis.core.marks import Mark
 from schemathesis.filters import FilterSet, FilterValue, MatcherFunc, attach_filter_chain
 from schemathesis.generation.case import Case
@@ -128,6 +128,7 @@ class CachingAuthProvider(Generic[Auth]):
 
     def get(self, case: Case, context: AuthContext) -> Auth | None:
         """Get cached auth value."""
+        __tracebackhide__ = True
         cache_entry = self._get_cache_entry(case, context)
         if cache_entry is None or self.timer() >= cache_entry.expires:
             with self._refresh_lock:
@@ -136,7 +137,11 @@ class CachingAuthProvider(Generic[Auth]):
                     # Another thread updated the cache
                     return cache_entry.data
                 # We know that optional auth is possible only inside a higher-level wrapper
-                data: Auth = self.provider.get(case, context)  # type: ignore[assignment]
+                try:
+                    data: Auth = self.provider.get(case, context)  # type: ignore[assignment]
+                except Exception as exc:
+                    provider_name = self.provider.__class__.__name__
+                    raise AuthenticationError(provider_name, "get", str(exc)) from exc
                 self._set_cache_entry(data, case, context)
                 return data
         return cache_entry.data
@@ -270,11 +275,25 @@ class SelectiveAuthProvider(Generic[Auth]):
     filter_set: FilterSet
 
     def get(self, case: Case, context: AuthContext) -> Auth | None:
+        __tracebackhide__ = True
         if self.filter_set.match(context):
-            return self.provider.get(case, context)
+            try:
+                return self.provider.get(case, context)
+            except AuthenticationError:
+                # Already wrapped, re-raise as-is
+                raise
+            except Exception as exc:
+                # Need to unwrap to get the actual provider class name
+                provider = self.provider
+                # Unwrap caching providers
+                while isinstance(provider, (CachingAuthProvider, KeyedCachingAuthProvider)):
+                    provider = provider.provider
+                provider_name = provider.__class__.__name__
+                raise AuthenticationError(provider_name, "get", str(exc)) from exc
         return None
 
     def set(self, case: Case, data: Auth, context: AuthContext) -> None:
+        __tracebackhide__ = True
         self.provider.set(case, data, context)
 
 
@@ -418,6 +437,7 @@ class AuthStorage(Generic[Auth]):
 
     def set(self, case: Case, context: AuthContext) -> None:
         """Set authentication data on a generated test case."""
+        __tracebackhide__ = True
         if not self.is_defined:
             raise IncorrectUsage("No auth provider is defined.")
         for provider in self.providers:
@@ -433,6 +453,7 @@ def set_on_case(case: Case, context: AuthContext, auth_storage: AuthStorage | No
 
     If there is no auth defined, then this function is no-op.
     """
+    __tracebackhide__ = True
     if auth_storage is not None:
         auth_storage.set(case, context)
     elif case.operation.schema.auth.is_defined:

schemathesis/checks.py

@@ -93,7 +93,7 @@ CHECKS = Registry[CheckFunction]()
 
 def load_all_checks() -> None:
     # NOTE: Trigger registering all Open API checks
-    from schemathesis.specs.openapi.checks import status_code_conformance  # noqa: F401, F403
+    from schemathesis.specs.openapi.checks import status_code_conformance  # noqa: F401
 
 
 def check(func: CheckFunction) -> CheckFunction:

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

@@ -123,8 +123,7 @@ def vcr_writer(output: TextOutput, config: ProjectConfig, queue: Queue) -> None:
     current_id = 1
 
     def write_header_values(stream: IO, values: list[str]) -> None:
-        for v in values:
-            stream.write(f"      - {json.dumps(v)}\n")
+        stream.writelines(f"      - {json.dumps(v)}\n" for v in values)
 
     if config.output.sanitization.enabled:
         sanitization_keys = config.output.sanitization.keys_to_sanitize

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

@@ -20,13 +20,14 @@ from schemathesis.config import ProjectConfig, ReportFormat, SchemathesisWarning
 from schemathesis.core.errors import LoaderError, LoaderErrorKind, format_exception, split_traceback
 from schemathesis.core.failures import MessageBlock, Severity, format_failures
 from schemathesis.core.output import prepare_response_payload
+from schemathesis.core.parameters import ParameterLocation
 from schemathesis.core.result import Ok
 from schemathesis.core.version import SCHEMATHESIS_VERSION
 from schemathesis.engine import Status, events
 from schemathesis.engine.phases import PhaseName, PhaseSkipReason
 from schemathesis.engine.phases.probes import ProbeOutcome
 from schemathesis.engine.recorder import Interaction, ScenarioRecorder
-from schemathesis.generation.meta import CoveragePhaseData
+from schemathesis.generation.meta import CoveragePhaseData, CoverageScenario
 from schemathesis.generation.modes import GenerationMode
 from schemathesis.schemas import ApiStatistic
 
@@ -1079,7 +1080,9 @@ class OutputHandler(EventHandler):
             return bool(
                 case.meta
                 and isinstance(case.meta.phase.data, CoveragePhaseData)
-                and case.meta.phase.data.description == "Missing `Authorization` at header"
+                and case.meta.phase.data.scenario == CoverageScenario.MISSING_PARAMETER
+                and case.meta.phase.data.parameter == "Authorization"
+                and case.meta.phase.data.parameter_location == ParameterLocation.HEADER
             )
 
         if SchemathesisWarning.MISSING_AUTH in warnings:

schemathesis/config/_error.py

@@ -142,7 +142,7 @@ def _format_anyof_error(error: ValidationError) -> str:
         )
     elif list(error.schema_path) == ["properties", "workers", "anyOf"]:
         return (
-            f"Invalid value for 'workers': {repr(error.instance)}\n\n"
+            f"Invalid value for 'workers': {error.instance!r}\n\n"
             f"Expected either:\n"
             f"  - A positive integer (e.g., workers = 4)\n"
             f'  - The string "auto" for automatic detection (workers = "auto")'

schemathesis/core/errors.py

@@ -161,6 +161,8 @@ class InvalidSchema(SchemathesisError):
             message += "\n    File reference could not be resolved. Check that the file exists."
         elif reference.startswith(("#/components", "#/definitions")):
             message += "\n    Component does not exist in the schema."
+        elif isinstance(error.__cause__, RemoteDocumentError):
+            message += f"\n    {error.__cause__}"
         return cls(message, path=path, method=method)
 
     def as_failing_test_function(self) -> Callable:
@@ -176,6 +178,13 @@ class InvalidSchema(SchemathesisError):
         return actual_test
 
 
+class RemoteDocumentError(SchemathesisError):
+    """Remote reference resolution failed.
+
+    This exception carries more context than the default one in `jsonschema`.
+    """
+
+
 class HookError(SchemathesisError):
     """Happens during hooks loading."""
 
@@ -316,6 +325,27 @@ class IncorrectUsage(SchemathesisError):
     """Indicates incorrect usage of Schemathesis' public API."""
 
 
+class AuthenticationError(SchemathesisError):
+    """Error during authentication provider execution.
+
+    This error wraps exceptions that occur when obtaining or setting
+    authentication data via custom auth providers.
+    """
+
+    def __init__(self, provider_name: str, method: str, message: str) -> None:
+        self.provider_name = provider_name
+        self.method = method
+        self.message = message
+        super().__init__(
+            f"Error in '{provider_name}.{method}()': {message}\n\n"
+            f"Common causes:\n"
+            f"  - Auth endpoint returned an error response\n"
+            f"  - Response format doesn't match expectations (text vs JSON)\n"
+            f"  - Network or connection issues\n"
+            f"  - Logic error in the authentication provider implementation"
+        )
+
+
 class NoLinksFound(IncorrectUsage):
     """Raised when no valid links are available for stateful testing."""
 

schemathesis/engine/errors.py

@@ -16,6 +16,7 @@ from hypothesis import HealthCheck
 
 from schemathesis import errors
 from schemathesis.core.errors import (
+    AuthenticationError,
     InfiniteRecursiveReference,
     InvalidTransition,
     SerializationNotPossible,
@@ -105,6 +106,7 @@ class EngineErrorInfo:
             RuntimeErrorKind.HYPOTHESIS_UNSUPPORTED_GRAPHQL_SCALAR: "Unknown GraphQL Scalar",
             RuntimeErrorKind.SERIALIZATION_UNBOUNDED_PREFIX: "XML serialization error",
             RuntimeErrorKind.SERIALIZATION_NOT_POSSIBLE: "Serialization not possible",
+            RuntimeErrorKind.AUTHENTICATION_ERROR: "Authentication Error",
         }.get(self._kind, "Runtime Error")
 
     @property
@@ -165,6 +167,9 @@ class EngineErrorInfo:
 
     @cached_property
     def traceback(self) -> str:
+        # For AuthenticationError, show only the original exception's traceback
+        if isinstance(self._error, AuthenticationError) and self._error.__cause__ is not None:
+            return format_exception(self._error.__cause__, with_traceback=True)
         return format_exception(self._error, with_traceback=True)
 
     def format(self, *, bold: Callable[[str], str] = str, indent: str = "    ") -> str:
@@ -254,6 +259,9 @@ class RuntimeErrorKind(str, enum.Enum):
     CONNECTION_OTHER = "connection_other"
     NETWORK_OTHER = "network_other"
 
+    # Authentication issues
+    AUTHENTICATION_ERROR = "authentication_error"
+
     # Hypothesis issues
     HYPOTHESIS_UNSATISFIABLE = "hypothesis_unsatisfiable"
     HYPOTHESIS_UNSUPPORTED_GRAPHQL_SCALAR = "hypothesis_unsupported_graphql_scalar"
@@ -281,6 +289,10 @@ def _classify(*, error: Exception) -> RuntimeErrorKind:
     import requests
     from hypothesis import HealthCheck
 
+    # Authentication errors
+    if isinstance(error, AuthenticationError):
+        return RuntimeErrorKind.AUTHENTICATION_ERROR
+
     # Network-related errors
     if isinstance(error, requests.RequestException):
         if isinstance(error, requests.exceptions.SSLError):

schemathesis/engine/phases/unit/__init__.py

@@ -11,7 +11,7 @@ import warnings
 from queue import Queue
 from typing import TYPE_CHECKING, Any
 
-from schemathesis.core.errors import InvalidSchema
+from schemathesis.core.errors import AuthenticationError, InvalidSchema
 from schemathesis.core.result import Ok
 from schemathesis.engine import Status, events
 from schemathesis.engine.phases import PhaseName, PhaseSkipReason
@@ -182,7 +182,7 @@ def worker_task(
                                 as_strategy_kwargs=as_strategy_kwargs,
                             ),
                         )
-                    except (InvalidSchema, InvalidArgument) as exc:
+                    except (InvalidSchema, InvalidArgument, AuthenticationError) as exc:
                         on_error(exc, method=operation.method, path=operation.path)
                         continue
 

schemathesis/engine/phases/unit/_executor.py

@@ -19,6 +19,7 @@ from schemathesis.core.compat import BaseExceptionGroup
 from schemathesis.core.control import SkipTest
 from schemathesis.core.errors import (
     SERIALIZERS_SUGGESTION_MESSAGE,
+    AuthenticationError,
     InternalError,
     InvalidHeadersExample,
     InvalidRegexPattern,
@@ -173,6 +174,9 @@ def run_test(
         # We need more clear error message here
         status = Status.ERROR
         yield non_fatal_error(build_unsatisfiable_error(operation, with_tip=False))
+    except AuthenticationError as exc:
+        status = Status.ERROR
+        yield non_fatal_error(exc)
     except KeyboardInterrupt:
         yield scenario_finished(Status.INTERRUPTED)
         yield events.Interrupted(phase=phase)