schemathesis 4.3.16__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/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/core/errors.py

@@ -325,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)