schemathesis 3.19.7__py3-none-any.whl → 3.20.1__py3-none-any.whl

schemathesis/exceptions.py

@@ -1,11 +1,12 @@
-from dataclasses import dataclass
+import enum
+import json
+from dataclasses import dataclass, field
 from hashlib import sha1
 from json import JSONDecodeError
 from typing import TYPE_CHECKING, Any, Callable, Dict, Generator, List, NoReturn, Optional, Tuple, Type, Union
 
 import hypothesis.errors
-import requests
-from jsonschema import ValidationError
+from jsonschema import RefResolutionError, ValidationError
 
 from .constants import SERIALIZERS_SUGGESTION_MESSAGE
 from .failures import FailureContext
@@ -139,8 +140,11 @@ def get_timeout_error(deadline: Union[float, int]) -> Type[CheckFailed]:
     return _get_hashed_exception("TimeoutError", str(deadline))
 
 
+SCHEMA_ERROR_SUGGESTION = "Ensure that the definition complies with the OpenAPI specification"
+
+
 @dataclass
-class InvalidSchema(Exception):
+class OperationSchemaError(Exception):
     """Schema associated with an API operation contains an error."""
 
     __module__ = "builtins"
@@ -149,6 +153,44 @@ class InvalidSchema(Exception):
     method: Optional[str] = None
     full_path: Optional[str] = None
 
+    @classmethod
+    def from_jsonschema_error(
+        cls, error: ValidationError, path: Optional[str], method: Optional[str], full_path: Optional[str]
+    ) -> "OperationSchemaError":
+        if error.absolute_path:
+            part = error.absolute_path[-1]
+            if isinstance(part, int) and len(error.absolute_path) > 1:
+                parent = error.absolute_path[-2]
+                message = f"Invalid definition for element at index {part} in `{parent}`"
+            else:
+                message = f"Invalid `{part}` definition"
+        else:
+            message = "Invalid schema definition"
+        error_path = " -> ".join((str(entry) for entry in error.path)) or "[root]"
+        message += f"\n\nLocation:\n    {error_path}"
+        instance = truncated_json(error.instance)
+        message += f"\n\nProblematic definition:\n{instance}"
+        message += "\n\nError details:\n    "
+        # This default message contains the instance which we already printed
+        if "is not valid under any of the given schemas" in error.message:
+            message += "The provided definition doesn't match any of the expected formats or types."
+        else:
+            message += error.message
+        message += f"\n\n{SCHEMA_ERROR_SUGGESTION}"
+        return cls(message, path=path, method=method, full_path=full_path)
+
+    @classmethod
+    def from_reference_resolution_error(
+        cls, error: RefResolutionError, path: Optional[str], method: Optional[str], full_path: Optional[str]
+    ) -> "OperationSchemaError":
+        message = "Unresolvable JSON pointer in the schema"
+        # Get the pointer value from "Unresolvable JSON pointer: 'components/UnknownParameter'"
+        pointer = str(error).split(": ", 1)[-1]
+        message += f"\n\nError details:\n    JSON pointer: {pointer}"
+        message += "\n    This typically means that the schema is referencing a component that doesn't exist."
+        message += f"\n\n{SCHEMA_ERROR_SUGGESTION}"
+        return cls(message, path=path, method=method, full_path=full_path)
+
     def as_failing_test_function(self) -> Callable:
         """Create a test function that will fail.
 
@@ -162,6 +204,26 @@ class InvalidSchema(Exception):
         return actual_test
 
 
+def truncated_json(data: Any, max_lines: int = 10, max_width: int = 80) -> str:
+    # Convert JSON to string with indentation
+    indent = 4
+    serialized = json.dumps(data, indent=indent)
+
+    # Split string by lines
+
+    lines = [line[: max_width - 3] + "..." if len(line) > max_width else line for line in serialized.split("\n")]
+
+    if len(lines) <= max_lines:
+        return "\n".join(lines)
+
+    truncated_lines = lines[: max_lines - 1]
+    indentation = " " * indent
+    truncated_lines.append(f"{indentation}// Output truncated...")
+    truncated_lines.append(lines[-1])
+
+    return "\n".join(truncated_lines)
+
+
 class DeadlineExceeded(Exception):
     """Test took too long to run."""
 
@@ -176,9 +238,46 @@ class DeadlineExceeded(Exception):
         )
 
 
-class SchemaLoadingError(ValueError):
+@enum.unique
+class SchemaErrorType(enum.Enum):
+    # Connection related issues
+    CONNECTION_SSL = "connection_ssl"
+    CONNECTION_OTHER = "connection_other"
+    NETWORK_OTHER = "network_other"
+
+    # HTTP error codes
+    HTTP_SERVER_ERROR = "http_server_error"
+    HTTP_CLIENT_ERROR = "http_client_error"
+    HTTP_NOT_FOUND = "http_not_found"
+    HTTP_FORBIDDEN = "http_forbidden"
+
+    # Content decoding issues
+    UNEXPECTED_CONTENT_TYPE = "unexpected_content_type"
+    YAML_NUMERIC_STATUS_CODES = "yaml_numeric_status_codes"
+    YAML_NON_STRING_KEYS = "yaml_non_string_keys"
+
+    # Open API validation
+    OPEN_API_INVALID_SCHEMA = "open_api_invalid_schema"
+    OPEN_API_UNSPECIFIED_VERSION = "open_api_unspecified_version"
+    OPEN_API_UNSUPPORTED_VERSION = "open_api_unsupported_version"
+
+    # Unclassified
+    UNCLASSIFIED = "unclassified"
+
+
+@dataclass
+class SchemaError(RuntimeError):
     """Failed to load an API schema."""
 
+    type: SchemaErrorType
+    message: str
+    url: Optional[str] = None
+    response: Optional["GenericResponse"] = None
+    extras: List[str] = field(default_factory=list)
+
+    def __str__(self) -> str:
+        return self.message
+
 
 class NonCheckError(Exception):
     """An error happened in side the runner, but is not related to failed checks.
@@ -205,13 +304,35 @@ class SkipTest(BaseException):
 SERIALIZATION_NOT_POSSIBLE_MESSAGE = (
     f"Schemathesis can't serialize data to any of the defined media types: {{}} \n{SERIALIZERS_SUGGESTION_MESSAGE}"
 )
+NAMESPACE_DEFINITION_URL = "https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.3.md#xmlNamespace"
+UNBOUND_PREFIX_MESSAGE_TEMPLATE = (
+    "Unbound prefix: `{prefix}`. "
+    "You need to define this namespace in your API schema via the `xml.namespace` keyword. "
+    f"See more at {NAMESPACE_DEFINITION_URL}"
+)
 
 SERIALIZATION_FOR_TYPE_IS_NOT_POSSIBLE_MESSAGE = (
     f"Schemathesis can't serialize data to {{}} \n{SERIALIZERS_SUGGESTION_MESSAGE}"
 )
 
 
-class SerializationNotPossible(Exception):
+class SerializationError(Exception):
+    """Serialization can not be done."""
+
+    __module__ = "builtins"
+
+
+class UnboundPrefixError(SerializationError):
+    """XML serialization error.
+
+    It happens when the schema does not define a namespace that is used by some of its parts.
+    """
+
+    def __init__(self, prefix: str):
+        super().__init__(UNBOUND_PREFIX_MESSAGE_TEMPLATE.format(prefix=prefix))
+
+
+class SerializationNotPossible(SerializationError):
     """Not possible to serialize to any of the media types defined for some API operation.
 
     Usually, there is still `application/json` along with less common ones, but this error happens when there is no
@@ -233,25 +354,5 @@ class InvalidRegularExpression(Exception):
     __module__ = "builtins"
 
 
-@dataclass
-class HTTPError(Exception):
-    response: "GenericResponse"
-    url: str
-
-    @classmethod
-    def raise_for_status(cls, response: requests.Response) -> None:
-        try:
-            response.raise_for_status()
-        except requests.HTTPError as exc:
-            raise cls(response=response, url=response.url) from exc
-
-    @classmethod
-    def check_response(cls, response: requests.Response, schema_path: str) -> None:
-        # Raising exception to provide unified behavior
-        # E.g. it will be handled in CLI - a proper error message will be shown
-        if 400 <= response.status_code < 600:
-            raise cls(response=response, url=schema_path)
-
-
 class UsageError(Exception):
     """Incorrect usage of Schemathesis functions."""

schemathesis/experimental/__init__.py

@@ -0,0 +1,85 @@
+import threading
+from dataclasses import dataclass, field
+
+
+@dataclass(eq=False)
+class Experiment:
+    name: str
+    verbose_name: str
+    env_var: str
+    description: str
+    discussion_url: str
+    _storage: "ExperimentSet" = field(repr=False)
+
+    def enable(self) -> None:
+        self._storage.enable(self)
+
+    def disable(self) -> None:
+        self._storage.disable(self)
+
+    @property
+    def is_enabled(self) -> bool:
+        return self._storage.is_enabled(self)
+
+
+@dataclass
+class ExperimentSet:
+    _local_data: threading.local = field(default_factory=threading.local, repr=False)
+
+    def __post_init__(self) -> None:
+        self.available = set()
+        self.enabled = set()
+
+    @property
+    def available(self) -> set:
+        return self._local_data.available
+
+    @available.setter
+    def available(self, value: set) -> None:
+        self._local_data.available = value
+
+    @property
+    def enabled(self) -> set:
+        return self._local_data.enabled
+
+    @enabled.setter
+    def enabled(self, value: set) -> None:
+        self._local_data.enabled = value
+
+    def create_experiment(
+        self, name: str, verbose_name: str, env_var: str, description: str, discussion_url: str
+    ) -> Experiment:
+        instance = Experiment(
+            name=name,
+            verbose_name=verbose_name,
+            env_var=f"{ENV_PREFIX}_{env_var}",
+            description=description,
+            discussion_url=discussion_url,
+            _storage=self,
+        )
+        self.available.add(instance)
+        return instance
+
+    def enable(self, feature: Experiment) -> None:
+        self.enabled.add(feature)
+
+    def disable(self, feature: Experiment) -> None:
+        self.enabled.discard(feature)
+
+    def disable_all(self) -> None:
+        self.enabled.clear()
+
+    def is_enabled(self, feature: Experiment) -> bool:
+        return feature in self.enabled
+
+
+ENV_PREFIX = "SCHEMATHESIS_EXPERIMENTAL"
+GLOBAL_EXPERIMENTS = ExperimentSet()
+
+OPEN_API_3_1 = GLOBAL_EXPERIMENTS.create_experiment(
+    name="openapi-3.1",
+    verbose_name="OpenAPI 3.1",
+    env_var="OPENAPI_3_1",
+    description="Support for response validation",
+    discussion_url="https://github.com/schemathesis/schemathesis/discussions/1822",
+)

schemathesis/extra/pytest_plugin.py

@@ -14,7 +14,7 @@ from hypothesis_jsonschema._canonicalise import HypothesisRefResolutionError
 
 from .._hypothesis import create_test
 from ..constants import IS_PYTEST_ABOVE_7, IS_PYTEST_ABOVE_54, RECURSIVE_REFERENCE_ERROR_MESSAGE
-from ..exceptions import InvalidSchema, SkipTest
+from ..exceptions import OperationSchemaError, SkipTest
 from ..models import APIOperation
 from ..utils import (
     PARAMETRIZE_MARKER,
@@ -87,7 +87,9 @@ class SchemathesisCase(PyCollector):
     def _get_test_name(self, operation: APIOperation) -> str:
         return f"{self.name}[{operation.verbose_name}]"
 
-    def _gen_items(self, result: Result[APIOperation, InvalidSchema]) -> Generator[SchemathesisFunction, None, None]:
+    def _gen_items(
+        self, result: Result[APIOperation, OperationSchemaError]
+    ) -> Generator[SchemathesisFunction, None, None]:
         """Generate all tests for the given API operation.
 
         Could produce more than one test item if
@@ -183,7 +185,11 @@ class SchemathesisCase(PyCollector):
         """Generate different test items for all API operations available in the given schema."""
         try:
             items = [
-                item for operation in self.schemathesis_case.get_all_operations() for item in self._gen_items(operation)
+                item
+                for operation in self.schemathesis_case.get_all_operations(
+                    hooks=getattr(self.test_function, "_schemathesis_hooks", None)
+                )
+                for item in self._gen_items(operation)
             ]
             if not items:
                 fail_on_no_matches(self.nodeid)
@@ -234,7 +240,7 @@ def pytest_pyfunc_call(pyfuncitem):  # type:ignore
         try:
             outcome.get_result()
         except InvalidArgument as exc:
-            raise InvalidSchema(exc.args[0]) from None
+            raise OperationSchemaError(exc.args[0]) from None
         except HypothesisRefResolutionError:
             pytest.skip(RECURSIVE_REFERENCE_ERROR_MESSAGE)
         except SkipTest as exc:

schemathesis/fixups/__init__.py

@@ -3,6 +3,7 @@ from typing import Iterable, Optional
 from . import fast_api, utf8_bom
 
 ALL_FIXUPS = {"fast_api": fast_api, "utf8_bom": utf8_bom}
+ALL_FIXUP_NAMES = list(ALL_FIXUPS.keys())
 
 
 def install(fixups: Optional[Iterable[str]] = None) -> None:
@@ -12,7 +13,7 @@ def install(fixups: Optional[Iterable[str]] = None) -> None:
 
     :param fixups: Names of fixups to install.
     """
-    fixups = fixups or list(ALL_FIXUPS.keys())
+    fixups = fixups or ALL_FIXUP_NAMES
     for name in fixups:
         ALL_FIXUPS[name].install()  # type: ignore
 
@@ -24,6 +25,11 @@ def uninstall(fixups: Optional[Iterable[str]] = None) -> None:
 
     :param fixups: Names of fixups to uninstall.
     """
-    fixups = fixups or list(ALL_FIXUPS.keys())
+    fixups = fixups or ALL_FIXUP_NAMES
     for name in fixups:
         ALL_FIXUPS[name].uninstall()  # type: ignore
+
+
+def is_installed(name: str) -> bool:
+    """Check whether fixup is installed."""
+    return ALL_FIXUPS[name].is_installed()

schemathesis/fixups/fast_api.py

@@ -1,6 +1,8 @@
 from typing import Any, Dict
 
-from ..hooks import HookContext, register, unregister
+from ..hooks import HookContext
+from ..hooks import is_installed as global_is_installed
+from ..hooks import register, unregister
 from ..utils import traverse_schema
 
 
@@ -12,7 +14,15 @@ def uninstall() -> None:
     unregister(before_load_schema)
 
 
+def is_installed() -> bool:
+    return global_is_installed("before_load_schema", before_load_schema)
+
+
 def before_load_schema(context: HookContext, schema: Dict[str, Any]) -> None:
+    adjust_schema(schema)
+
+
+def adjust_schema(schema: Dict[str, Any]) -> None:
     traverse_schema(schema, _handle_boundaries)
 
 

schemathesis/fixups/utf8_bom.py

@@ -3,7 +3,9 @@ from typing import TYPE_CHECKING
 import requests
 
 from ..constants import BOM_MARK
-from ..hooks import HookContext, register, unregister
+from ..hooks import HookContext
+from ..hooks import is_installed as global_is_installed
+from ..hooks import register, unregister
 
 if TYPE_CHECKING:
     from .. import Case, GenericResponse
@@ -17,6 +19,10 @@ def uninstall() -> None:
     unregister(after_call)
 
 
+def is_installed() -> bool:
+    return global_is_installed("after_call", after_call)
+
+
 def after_call(context: HookContext, case: "Case", response: "GenericResponse") -> None:
     if isinstance(response, requests.Response) and response.encoding == "utf-8" and response.text[0:1] == BOM_MARK:
         response.encoding = "utf-8-sig"

schemathesis/hooks.py

@@ -3,6 +3,7 @@ from collections import defaultdict
 from copy import deepcopy
 from dataclasses import dataclass, field
 from enum import Enum, unique
+from functools import partial
 from typing import TYPE_CHECKING, Any, Callable, ClassVar, DefaultDict, Dict, List, Optional, Union, cast
 
 from hypothesis import strategies as st
@@ -178,6 +179,28 @@ class HookDispatcher:
         """Get a list of hooks registered for a name."""
         return self._hooks.get(name, [])
 
+    def is_installed(self, name: str, needle: Callable) -> bool:
+        for hook in self.get_all_by_name(name):
+            if hook is needle:
+                return True
+        return False
+
+    def apply_to_container(
+        self, strategy: st.SearchStrategy, container: str, context: HookContext
+    ) -> st.SearchStrategy:
+        for hook in self.get_all_by_name(f"before_generate_{container}"):
+            strategy = hook(context, strategy)
+        for hook in self.get_all_by_name(f"filter_{container}"):
+            hook = partial(hook, context)
+            strategy = strategy.filter(hook)
+        for hook in self.get_all_by_name(f"map_{container}"):
+            hook = partial(hook, context)
+            strategy = strategy.map(hook)
+        for hook in self.get_all_by_name(f"flatmap_{container}"):
+            hook = partial(hook, context)
+            strategy = strategy.flatmap(hook)
+        return strategy
+
     def dispatch(self, name: str, context: HookContext, *args: Any, **kwargs: Any) -> None:
         """Run all hooks for the given name."""
         for hook in self.get_all_by_name(name):
@@ -200,9 +223,43 @@ class HookDispatcher:
         self._hooks = defaultdict(list)
 
 
+def apply_to_all_dispatchers(
+    operation: "APIOperation",
+    context: HookContext,
+    hooks: Optional[HookDispatcher],
+    strategy: st.SearchStrategy,
+    container: str,
+) -> st.SearchStrategy:
+    """Apply all hooks related to the given location."""
+    strategy = GLOBAL_HOOK_DISPATCHER.apply_to_container(strategy, container, context)
+    strategy = operation.schema.hooks.apply_to_container(strategy, container, context)
+    if hooks is not None:
+        strategy = hooks.apply_to_container(strategy, container, context)
+    return strategy
+
+
+def should_skip_operation(dispatcher: HookDispatcher, context: HookContext) -> bool:
+    for hook in dispatcher.get_all_by_name("filter_operations"):
+        if not hook(context):
+            return True
+    return False
+
+
 all_scopes = HookDispatcher.register_spec(list(HookScope))
 
 
+for action in ("filter", "map", "flatmap"):
+    for target in ("path_parameters", "query", "headers", "cookies", "body", "case"):
+        exec(
+            f"""
+@all_scopes
+def {action}_{target}(context: HookContext, {target}: Any) -> Any:
+    pass
+""",
+            globals(),
+        )
+
+
 @all_scopes
 def before_generate_path_parameters(context: HookContext, strategy: st.SearchStrategy) -> st.SearchStrategy:
     """Called on a strategy that generates values for ``path_parameters``."""
@@ -238,6 +295,11 @@ def before_process_path(context: HookContext, path: str, methods: Dict[str, Any]
     """Called before API path is processed."""
 
 
+@all_scopes
+def filter_operations(context: HookContext) -> Optional[bool]:
+    """Decide whether testing of this particular API operation should be skipped or not."""
+
+
 @HookDispatcher.register_spec([HookScope.GLOBAL])
 def before_load_schema(context: HookContext, raw_schema: Dict[str, Any]) -> None:
     """Called before schema instance is created."""
@@ -294,6 +356,7 @@ def after_call(context: HookContext, case: "Case", response: GenericResponse) ->
 GLOBAL_HOOK_DISPATCHER = HookDispatcher(scope=HookScope.GLOBAL)
 dispatch = GLOBAL_HOOK_DISPATCHER.dispatch
 get_all_by_name = GLOBAL_HOOK_DISPATCHER.get_all_by_name
+is_installed = GLOBAL_HOOK_DISPATCHER.is_installed
 collect_statistic = GLOBAL_HOOK_DISPATCHER.collect_statistic
 register = GLOBAL_HOOK_DISPATCHER.register
 unregister = GLOBAL_HOOK_DISPATCHER.unregister

schemathesis/lazy.py

@@ -13,8 +13,9 @@ from pytest_subtests import SubTests, nullcontext
 
 from ._compat import MultipleFailures
 from .auths import AuthStorage
-from .constants import FLAKY_FAILURE_MESSAGE, CodeSampleStyle
-from .exceptions import CheckFailed, InvalidSchema, SkipTest, get_grouped_exception
+from .code_samples import CodeSampleStyle
+from .constants import FLAKY_FAILURE_MESSAGE
+from .exceptions import CheckFailed, OperationSchemaError, SkipTest, get_grouped_exception
 from .hooks import HookDispatcher, HookScope
 from .models import APIOperation
 from .schemas import BaseSchema
@@ -49,6 +50,7 @@ class LazySchema:
     data_generation_methods: Union[DataGenerationMethodInput, NotSet] = NOT_SET
     code_sample_style: CodeSampleStyle = CodeSampleStyle.default()
     rate_limiter: Optional[Limiter] = None
+    sanitize_output: bool = True
 
     def hook(self, hook: Union[str, Callable]) -> Callable:
         return self.hooks.register(hook)
@@ -115,12 +117,13 @@ class LazySchema:
                     code_sample_style=_code_sample_style,
                     app=self.app,
                     rate_limiter=self.rate_limiter,
+                    sanitize_output=self.sanitize_output,
                 )
                 fixtures = get_fixtures(test, request, given_kwargs)
                 # Changing the node id is required for better reporting - the method and path will appear there
                 node_id = request.node._nodeid
                 settings = getattr(wrapped_test, "_hypothesis_internal_use_settings", None)
-                tests = list(schema.get_all_tests(test, settings, _given_kwargs=given_kwargs))
+                tests = list(schema.get_all_tests(test, settings, hooks=self.hooks, _given_kwargs=given_kwargs))
                 if not tests:
                     fail_on_no_matches(node_id)
                 request.session.testscollected += len(tests)
@@ -244,7 +247,7 @@ def run_subtest(
 SEPARATOR = "\n===================="
 
 
-def _schema_error(subtests: SubTests, error: InvalidSchema, node_id: str) -> None:
+def _schema_error(subtests: SubTests, error: OperationSchemaError, node_id: str) -> None:
     """Run a failing test, that will show the underlying problem."""
     sub_test = error.as_failing_test_function()
     # `full_path` is always available in this case
@@ -252,6 +255,7 @@ def _schema_error(subtests: SubTests, error: InvalidSchema, node_id: str) -> Non
     if error.method:
         kwargs["method"] = error.method.upper()
     subtests.item._nodeid = _get_partial_node_name(node_id, **kwargs)
+    __tracebackhide__ = True
     with subtests.test(**kwargs):
         sub_test()
 
@@ -274,6 +278,7 @@ def get_schema(
     data_generation_methods: Union[DataGenerationMethodInput, NotSet] = NOT_SET,
     code_sample_style: CodeSampleStyle,
     rate_limiter: Optional[Limiter],
+    sanitize_output: bool,
 ) -> BaseSchema:
     """Loads a schema from the fixture."""
     schema = request.getfixturevalue(name)
@@ -294,6 +299,7 @@ def get_schema(
         data_generation_methods=data_generation_methods,
         code_sample_style=code_sample_style,
         rate_limiter=rate_limiter,
+        sanitize_output=sanitize_output,
     )
 
 

schemathesis/loaders.py

@@ -0,0 +1,57 @@
+import http.client
+import re
+from typing import Callable, TypeVar, cast
+
+import requests
+
+from .exceptions import SchemaError, SchemaErrorType
+from .utils import GenericResponse
+
+R = TypeVar("R", bound=GenericResponse)
+
+
+def remove_ssl_line_number(text: str) -> str:
+    return re.sub(r"\(_ssl\.c:\d+\)", "", text)
+
+
+def load_schema_from_url(loader: Callable[[], R]) -> R:
+    try:
+        response = loader()
+    except requests.RequestException as exc:
+        request = cast(requests.PreparedRequest, exc.request)
+        if isinstance(exc, requests.exceptions.SSLError):
+            message = "SSL verification problem"
+            type_ = SchemaErrorType.CONNECTION_SSL
+            reason = str(exc.args[0].reason)
+            extra = [remove_ssl_line_number(reason)]
+        elif isinstance(exc, requests.exceptions.ConnectionError):
+            message = "Connection failed"
+            type_ = SchemaErrorType.CONNECTION_OTHER
+            _, reason = exc.args[0].reason.args[0].split(":", maxsplit=1)
+            extra = [reason.strip()]
+        else:
+            message = "Network problem"
+            type_ = SchemaErrorType.NETWORK_OTHER
+            extra = []
+        raise SchemaError(message=message, type=type_, url=request.url, response=exc.response, extras=extra) from exc
+    _raise_for_status(response)
+    return response
+
+
+def _raise_for_status(response: GenericResponse) -> None:
+    status_code = response.status_code
+    reason = http.client.responses.get(status_code, "Unknown")
+    if status_code >= 500:
+        message = f"Failed to load schema due to server error (HTTP {status_code} {reason})"
+        type_ = SchemaErrorType.HTTP_SERVER_ERROR
+    elif status_code >= 400:
+        message = f"Failed to load schema due to client error (HTTP {status_code} {reason})"
+        if status_code == 403:
+            type_ = SchemaErrorType.HTTP_FORBIDDEN
+        elif status_code == 404:
+            type_ = SchemaErrorType.HTTP_NOT_FOUND
+        else:
+            type_ = SchemaErrorType.HTTP_CLIENT_ERROR
+    else:
+        return None
+    raise SchemaError(message=message, type=type_, url=response.request.url, response=response, extras=[])