schemathesis 4.0.0a10__py3-none-any.whl → 4.0.0a11__py3-none-any.whl

schemathesis/cli/commands/run/loaders.py

@@ -6,42 +6,28 @@ supporting both GraphQL and OpenAPI specifications.
 
 from __future__ import annotations
 
+import os
 import warnings
-from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Callable
 
 from schemathesis import graphql, openapi
-from schemathesis.core import NOT_SET, NotSet
+from schemathesis.config import ProjectConfig
 from schemathesis.core.errors import LoaderError, LoaderErrorKind
 from schemathesis.core.fs import file_exists
-from schemathesis.core.output import OutputConfig
-from schemathesis.generation import GenerationConfig
 
 if TYPE_CHECKING:
-    from schemathesis.engine.config import NetworkConfig
     from schemathesis.schemas import BaseSchema
 
-Loader = Callable[["AutodetectConfig"], "BaseSchema"]
+Loader = Callable[["ProjectConfig"], "BaseSchema"]
 
 
-@dataclass
-class AutodetectConfig:
-    location: str
-    network: NetworkConfig
-    wait_for_schema: float | None
-    base_url: str | None | NotSet = NOT_SET
-    rate_limit: str | None | NotSet = NOT_SET
-    generation: GenerationConfig | NotSet = NOT_SET
-    output: OutputConfig | NotSet = NOT_SET
-
-
-def load_schema(config: AutodetectConfig) -> BaseSchema:
+def load_schema(location: str, config: ProjectConfig) -> BaseSchema:
     """Load API schema automatically based on the provided configuration."""
-    if is_probably_graphql(config.location):
+    if is_probably_graphql(location):
         # Try GraphQL first, then fallback to Open API
-        return _try_load_schema(config, graphql, openapi)
+        return _try_load_schema(location, config, graphql, openapi)
     # Try Open API first, then fallback to GraphQL
-    return _try_load_schema(config, openapi, graphql)
+    return _try_load_schema(location, config, openapi, graphql)
 
 
 def should_try_more(exc: LoaderError) -> bool:
@@ -60,27 +46,28 @@ def should_try_more(exc: LoaderError) -> bool:
     )
 
 
-def detect_loader(schema_or_location: str | dict[str, Any], module: Any) -> Callable:
+def detect_loader(location: str, module: Any) -> Callable:
     """Detect API schema loader."""
-    if isinstance(schema_or_location, str):
-        if file_exists(schema_or_location):
-            return module.from_path  # type: ignore
-        return module.from_url  # type: ignore
-    raise NotImplementedError
+    if file_exists(location):
+        return module.from_path  # type: ignore
+    return module.from_url  # type: ignore
 
 
-def _try_load_schema(config: AutodetectConfig, first_module: Any, second_module: Any) -> BaseSchema:
+def _try_load_schema(location: str, config: ProjectConfig, first_module: Any, second_module: Any) -> BaseSchema:
     """Try to load schema with fallback option."""
     from urllib3.exceptions import InsecureRequestWarning
 
     with warnings.catch_warnings():
         warnings.simplefilter("ignore", InsecureRequestWarning)
         try:
-            return _load_schema(config, first_module)
+            return _load_schema(location, config, first_module)
         except LoaderError as exc:
+            # If this was the OpenAPI loader on an explicit OpenAPI file, don't fallback
+            if first_module is openapi and is_openapi_file(location):
+                raise exc
             if should_try_more(exc):
                 try:
-                    return _load_schema(config, second_module)
+                    return _load_schema(location, config, second_module)
                 except Exception as second_exc:
                     if is_specific_exception(second_exc):
                         raise second_exc
@@ -88,26 +75,23 @@ def _try_load_schema(config: AutodetectConfig, first_module: Any, second_module:
             raise exc
 
 
-def _load_schema(config: AutodetectConfig, module: Any) -> BaseSchema:
+def _load_schema(location: str, config: ProjectConfig, module: Any) -> BaseSchema:
     """Unified schema loader for both GraphQL and OpenAPI."""
-    loader = detect_loader(config.location, module)
+    loader = detect_loader(location, module)
 
     kwargs: dict = {}
     if loader is module.from_url:
         if config.wait_for_schema is not None:
             kwargs["wait_for_schema"] = config.wait_for_schema
-        kwargs["verify"] = config.network.tls_verify
-        if config.network.cert:
-            kwargs["cert"] = config.network.cert
-        if config.network.auth:
-            kwargs["auth"] = config.network.auth
-
-    return loader(config.location, **kwargs).configure(
-        base_url=config.base_url,
-        rate_limit=config.rate_limit,
-        output=config.output,
-        generation=config.generation,
-    )
+        kwargs["verify"] = config.tls_verify
+        request_cert = config.request_cert_for()
+        if request_cert:
+            kwargs["cert"] = request_cert
+        auth = config.auth_for()
+        if auth is not None:
+            kwargs["auth"] = auth
+
+    return loader(location, config=config._parent, **kwargs)
 
 
 def is_specific_exception(exc: Exception) -> bool:
@@ -120,10 +104,11 @@ def is_specific_exception(exc: Exception) -> bool:
     )
 
 
-def is_probably_graphql(schema_or_location: str | dict[str, Any]) -> bool:
+def is_probably_graphql(location: str) -> bool:
     """Detect whether it is likely that the given location is a GraphQL endpoint."""
-    if isinstance(schema_or_location, str):
-        return schema_or_location.endswith(("/graphql", "/graphql/", ".graphql", ".gql"))
-    return "__schema" in schema_or_location or (
-        "data" in schema_or_location and "__schema" in schema_or_location["data"]
-    )
+    return location.endswith(("/graphql", "/graphql/", ".graphql", ".gql"))
+
+
+def is_openapi_file(location: str) -> bool:
+    name = os.path.basename(location).lower()
+    return any(name == f"{base}{ext}" for base in ("openapi", "swagger") for ext in (".json", ".yaml", ".yml"))

schemathesis/cli/commands/run/validation.py

@@ -2,24 +2,21 @@ from __future__ import annotations
 
 import codecs
 import operator
-import os
 import pathlib
-import re
 from contextlib import contextmanager
-from functools import partial, reduce
-from typing import Callable, Generator, Sequence
+from functools import reduce
+from typing import Callable, Generator
 from urllib.parse import urlparse
 
 import click
 
-from schemathesis import errors, experimental
-from schemathesis.cli.commands.run.reports import ReportFormat
-from schemathesis.cli.constants import DEFAULT_WORKERS
-from schemathesis.core import rate_limit, string_to_boolean
+from schemathesis.config import ReportFormat, get_workers_count
+from schemathesis.core import errors, rate_limit, string_to_boolean
 from schemathesis.core.fs import file_exists
-from schemathesis.core.validation import contains_unicode_surrogate_pair, has_invalid_characters, is_latin_1_encodable
+from schemathesis.core.validation import has_invalid_characters, is_latin_1_encodable
+from schemathesis.filters import expression_to_filter_function
 from schemathesis.generation import GenerationMode
-from schemathesis.generation.overrides import Override
+from schemathesis.generation.targets import TargetFunction
 
 INVALID_DERANDOMIZE_MESSAGE = (
     "`--generation-deterministic` implies no database, so passing `--generation-database` too is invalid."
@@ -35,27 +32,24 @@ INVALID_BASE_URL_MESSAGE = (
     "The provided base URL is invalid. This URL serves as a prefix for all API endpoints you want to test. "
     "Make sure it is a properly formatted URL."
 )
-MISSING_BASE_URL_MESSAGE = "The `--url` option is required when specifying a schema via a file."
 MISSING_REQUEST_CERT_MESSAGE = "The `--request-cert` option must be specified if `--request-cert-key` is used."
 
 
-def validate_schema(schema: str, base_url: str | None) -> None:
+def validate_schema_location(ctx: click.core.Context, param: click.core.Parameter, location: str) -> str:
     try:
-        netloc = urlparse(schema).netloc
+        netloc = urlparse(location).netloc
         if netloc:
-            validate_url(schema)
-            return None
+            validate_url(location)
+            return location
     except ValueError as exc:
         raise click.UsageError(INVALID_SCHEMA_MESSAGE) from exc
-    if "\x00" in schema or not schema:
+    if "\x00" in location or not location:
         raise click.UsageError(INVALID_SCHEMA_MESSAGE)
-    exists = file_exists(schema)
-    if exists or bool(pathlib.Path(schema).suffix):
+    exists = file_exists(location)
+    if exists or bool(pathlib.Path(location).suffix):
         if not exists:
             raise click.UsageError(FILE_DOES_NOT_EXIST_MESSAGE)
-        if base_url is None:
-            raise click.UsageError(MISSING_BASE_URL_MESSAGE)
-        return None
+        return location
     raise click.UsageError(INVALID_SCHEMA_MESSAGE)
 
 
@@ -122,82 +116,31 @@ def validate_auth(
     return None
 
 
-def validate_auth_overlap(auth: tuple[str, str] | None, headers: dict[str, str], override: Override) -> None:
+def validate_auth_overlap(auth: tuple[str, str] | None, headers: dict[str, str]) -> None:
     auth_is_set = auth is not None
     header_is_set = "authorization" in {header.lower() for header in headers}
-    override_is_set = "authorization" in {header.lower() for header in override.headers}
-    if len([is_set for is_set in (auth_is_set, header_is_set, override_is_set) if is_set]) > 1:
+    if len([is_set for is_set in (auth_is_set, header_is_set) if is_set]) > 1:
         message = "The "
         used = []
         if auth_is_set:
             used.append("`--auth`")
         if header_is_set:
             used.append("`--header`")
-        if override_is_set:
-            used.append("`--set-header`")
         message += " and ".join(used)
         message += " options were both used to set the 'Authorization' header, which is not permitted."
         raise click.BadParameter(message)
 
 
-def _validate_and_build_multiple_options(
-    values: tuple[str, ...], name: str, callback: Callable[[str, str], None]
-) -> dict[str, str]:
-    output = {}
-    for raw in values:
+def validate_filter_expression(
+    ctx: click.core.Context, param: click.core.Parameter, raw_value: str | None
+) -> Callable | None:
+    if raw_value:
         try:
-            key, value = raw.split("=", maxsplit=1)
-        except ValueError as exc:
-            raise click.BadParameter(f"Expected NAME=VALUE format, received {raw}.") from exc
-        key = key.strip()
-        if not key:
-            raise click.BadParameter(f"{name} parameter name should not be empty.")
-        if key in output:
-            raise click.BadParameter(f"{name} parameter {key} is specified multiple times.")
-        value = value.strip()
-        callback(key, value)
-        output[key] = value
-    return output
-
-
-def validate_unique_filter(values: Sequence[str], arg_name: str) -> None:
-    if len(values) != len(set(values)):
-        duplicates = ",".join(sorted({value for value in values if values.count(value) > 1}))
-        raise click.UsageError(f"Duplicate values are not allowed for `{arg_name}`: {duplicates}")
-
-
-def _validate_set_query(_: str, value: str) -> None:
-    if contains_unicode_surrogate_pair(value):
-        raise click.BadParameter("Query parameter value should not contain surrogates.")
-
-
-def validate_set_query(
-    ctx: click.core.Context, param: click.core.Parameter, raw_value: tuple[str, ...]
-) -> dict[str, str]:
-    return _validate_and_build_multiple_options(raw_value, "Query", _validate_set_query)
-
-
-def validate_set_header(
-    ctx: click.core.Context, param: click.core.Parameter, raw_value: tuple[str, ...]
-) -> dict[str, str]:
-    return _validate_and_build_multiple_options(raw_value, "Header", partial(_validate_header, where="Header"))
-
-
-def validate_set_cookie(
-    ctx: click.core.Context, param: click.core.Parameter, raw_value: tuple[str, ...]
-) -> dict[str, str]:
-    return _validate_and_build_multiple_options(raw_value, "Cookie", partial(_validate_header, where="Cookie"))
-
-
-def _validate_set_path(_: str, value: str) -> None:
-    if contains_unicode_surrogate_pair(value):
-        raise click.BadParameter("Path parameter value should not contain surrogates.")
-
-
-def validate_set_path(
-    ctx: click.core.Context, param: click.core.Parameter, raw_value: tuple[str, ...]
-) -> dict[str, str]:
-    return _validate_and_build_multiple_options(raw_value, "Path", _validate_set_path)
+            return expression_to_filter_function(raw_value)
+        except ValueError:
+            arg_name = param.opts[0]
+            raise click.UsageError(f"Invalid expression for {arg_name}: {raw_value}") from None
+    return None
 
 
 def _validate_header(key: str, value: str, where: str) -> None:
@@ -225,15 +168,6 @@ def validate_headers(
     return headers
 
 
-def validate_regex(ctx: click.core.Context, param: click.core.Parameter, raw_value: tuple[str, ...]) -> tuple[str, ...]:
-    for value in raw_value:
-        try:
-            re.compile(value)
-        except (re.error, OverflowError, RuntimeError) as exc:
-            raise click.BadParameter(f"Invalid regex: {exc.args[0]}.")  # noqa: B904
-    return raw_value
-
-
 def validate_request_cert_key(
     ctx: click.core.Context, param: click.core.Parameter, raw_value: str | None
 ) -> str | None:
@@ -256,68 +190,21 @@ def validate_preserve_bytes(ctx: click.core.Context, param: click.core.Parameter
     return True
 
 
-def convert_experimental(
-    ctx: click.core.Context, param: click.core.Parameter, value: tuple[str, ...]
-) -> list[experimental.Experiment]:
-    return [
-        feature
-        for feature in experimental.GLOBAL_EXPERIMENTS.available
-        if feature.label in value or feature.is_env_var_set
-    ]
-
-
-def reduce_list(ctx: click.core.Context, param: click.core.Parameter, value: tuple[list[str]]) -> list[str]:
-    return reduce(operator.iadd, value, [])
-
-
-def convert_http_methods(
-    ctx: click.core.Context, param: click.core.Parameter, value: list[str] | None
-) -> set[str] | None:
-    if value is None:
-        return value
-    return {item.lower() for item in value}
-
-
-def convert_status_codes(
-    ctx: click.core.Context, param: click.core.Parameter, value: list[str] | None
+def reduce_list(
+    ctx: click.core.Context, param: click.core.Parameter, value: tuple[list[str]] | None
 ) -> list[str] | None:
     if not value:
-        return value
-
-    invalid = []
-
-    for code in value:
-        if len(code) != 3:
-            invalid.append(code)
-            continue
-
-        if code[0] not in {"1", "2", "3", "4", "5"}:
-            invalid.append(code)
-            continue
-
-        upper_code = code.upper()
+        return None
+    return reduce(operator.iadd, value, [])
 
-        if "X" in upper_code:
-            if (
-                upper_code[1:] == "XX"
-                or (upper_code[1] == "X" and upper_code[2].isdigit())
-                or (upper_code[1].isdigit() and upper_code[2] == "X")
-            ):
-                continue
-            else:
-                invalid.append(code)
-                continue
 
-        if not code.isnumeric():
-            invalid.append(code)
+def convert_maximize(
+    ctx: click.core.Context, param: click.core.Parameter, value: tuple[list[str]]
+) -> list[TargetFunction]:
+    from schemathesis.generation.targets import TARGETS
 
-    if invalid:
-        raise click.UsageError(
-            f"Invalid status code(s): {', '.join(invalid)}. "
-            "Use valid 3-digit codes between 100 and 599, "
-            "or wildcards (e.g., 2XX, 2X0, 20X), where X is a wildcard digit."
-        )
-    return value
+    names: list[str] = reduce(operator.iadd, value, [])
+    return TARGETS.get_by_names(names)
 
 
 def convert_generation_mode(ctx: click.core.Context, param: click.core.Parameter, value: str) -> list[GenerationMode]:
@@ -338,18 +225,6 @@ def reraise_format_error(raw_value: str) -> Generator[None, None, None]:
         raise click.BadParameter(f"Expected KEY:VALUE format, received {raw_value}.") from exc
 
 
-def get_workers_count() -> int:
-    """Detect the number of available CPUs for the current process, if possible.
-
-    Use ``DEFAULT_WORKERS`` if not possible to detect.
-    """
-    if hasattr(os, "sched_getaffinity"):
-        # In contrast with `os.cpu_count` this call respects limits on CPU resources on some Unix systems
-        return len(os.sched_getaffinity(0))
-    # Number of CPUs in the system, or 1 if undetermined
-    return os.cpu_count() or DEFAULT_WORKERS
-
-
 def convert_workers(ctx: click.core.Context, param: click.core.Parameter, value: str) -> int:
     if value == "auto":
         return get_workers_count()

schemathesis/cli/core.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 import shutil
 
@@ -9,9 +11,9 @@ def get_terminal_width() -> int:
     return shutil.get_terminal_size((80, 24)).columns
 
 
-def ensure_color(ctx: click.Context, no_color: bool, force_color: bool) -> None:
-    if force_color:
+def ensure_color(ctx: click.Context, color: bool | None) -> None:
+    if color:
         ctx.color = True
-    elif no_color or "NO_COLOR" in os.environ:
+    elif color is False or "NO_COLOR" in os.environ:
         ctx.color = False
         os.environ["NO_COLOR"] = "1"

schemathesis/cli/ext/fs.py

@@ -1,14 +1,16 @@
+from pathlib import Path
+
 import click
 
 from schemathesis.core.fs import ensure_parent
 
 
-def open_file(file: click.utils.LazyFile) -> None:
+def open_file(file: Path) -> None:
     try:
-        ensure_parent(file.name, fail_silently=False)
+        ensure_parent(file, fail_silently=False)
     except OSError as exc:
         raise click.BadParameter(f"'{file.name}': {exc.strerror}") from exc
     try:
-        file.open()
-    except click.FileError as exc:
-        raise click.BadParameter(exc.format_message()) from exc
+        file.open("w", encoding="utf-8")
+    except OSError as exc:
+        raise click.BadParameter(f"Could not open file {file.name}: {exc}") from exc

schemathesis/cli/ext/options.py

@@ -5,7 +5,6 @@ from typing import Any, NoReturn
 
 import click
 
-from schemathesis.core import NOT_SET, NotSet
 from schemathesis.core.registries import Registry
 
 
@@ -64,13 +63,6 @@ class CsvEnumChoice(BaseCsvChoice):
         self.fail_on_invalid_options(invalid_options, selected)
 
 
-class CsvListChoice(click.ParamType):
-    def convert(  # type: ignore[return]
-        self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None
-    ) -> list[str]:
-        return [item for item in value.split(",") if item]
-
-
 class RegistryChoice(BaseCsvChoice):
     def __init__(self, registry: Registry, with_all: bool = False) -> None:
         self.registry = registry
@@ -91,16 +83,3 @@ class RegistryChoice(BaseCsvChoice):
         if not invalid_options and selected:
             return selected
         self.fail_on_invalid_options(invalid_options, selected)
-
-
-class OptionalInt(click.types.IntRange):
-    def convert(  # type: ignore
-        self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None
-    ) -> int | NotSet:
-        if value.lower() == "none":
-            return NOT_SET
-        try:
-            int(value)
-            return super().convert(value, param, ctx)
-        except ValueError:
-            self.fail(f"{value} is not a valid integer or None.", param, ctx)