schemathesis 3.25.6__py3-none-any.whl → 4.0.0a1__py3-none-any.whl

schemathesis/cli/commands/run/hypothesis.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from enum import IntEnum, unique
+from typing import TYPE_CHECKING, Any
+
+import click
+
+if TYPE_CHECKING:
+    import hypothesis
+
+PHASES_INVALID_USAGE_MESSAGE = "Can't use `--hypothesis-phases` and `--hypothesis-no-phases` simultaneously"
+HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER = ":memory:"
+
+# Importing Hypothesis is expensive, hence we re-create the enums we need in CLI commands definitions
+# Hypothesis is stable, hence it should not be a problem and adding new variants should not be automatic
+
+
+@unique
+class Phase(IntEnum):
+    explicit = 0  #: controls whether explicit examples are run.
+    reuse = 1  #: controls whether previous examples will be reused.
+    generate = 2  #: controls whether new examples will be generated.
+    target = 3  #: controls whether examples will be mutated for targeting.
+    shrink = 4  #: controls whether examples will be shrunk.
+    # The `explain` phase is not supported
+
+    def as_hypothesis(self) -> hypothesis.Phase:
+        from hypothesis import Phase
+
+        return Phase[self.name]
+
+    @staticmethod
+    def filter_from_all(variants: list[Phase]) -> list[hypothesis.Phase]:
+        from hypothesis import Phase
+
+        return list(set(Phase) - {Phase.explain} - set(variants))
+
+
+@unique
+class HealthCheck(IntEnum):
+    # We remove not relevant checks
+    data_too_large = 1
+    filter_too_much = 2
+    too_slow = 3
+    large_base_example = 7
+    all = 8
+
+    def as_hypothesis(self) -> list[hypothesis.HealthCheck]:
+        from hypothesis import HealthCheck
+
+        if self.name == "all":
+            return list(HealthCheck)
+
+        return [HealthCheck[self.name]]
+
+
+def prepare_health_checks(
+    hypothesis_suppress_health_check: list[HealthCheck] | None,
+) -> list[hypothesis.HealthCheck] | None:
+    if hypothesis_suppress_health_check is None:
+        return None
+
+    return [entry for health_check in hypothesis_suppress_health_check for entry in health_check.as_hypothesis()]
+
+
+def prepare_phases(
+    hypothesis_phases: list[Phase] | None, hypothesis_no_phases: list[Phase] | None
+) -> list[hypothesis.Phase] | None:
+    if hypothesis_phases is not None and hypothesis_no_phases is not None:
+        raise click.UsageError(PHASES_INVALID_USAGE_MESSAGE)
+    if hypothesis_phases:
+        return [phase.as_hypothesis() for phase in hypothesis_phases]
+    if hypothesis_no_phases:
+        return Phase.filter_from_all(hypothesis_no_phases)
+    return None
+
+
+def prepare_settings(
+    database: str | None = None,
+    derandomize: bool | None = None,
+    max_examples: int | None = None,
+    phases: list[hypothesis.Phase] | None = None,
+    suppress_health_check: list[hypothesis.HealthCheck] | None = None,
+) -> hypothesis.settings:
+    import hypothesis
+    from hypothesis.database import DirectoryBasedExampleDatabase, InMemoryExampleDatabase
+
+    kwargs: dict[str, Any] = {
+        key: value
+        for key, value in (
+            ("derandomize", derandomize),
+            ("max_examples", max_examples),
+            ("phases", phases),
+            ("suppress_health_check", suppress_health_check),
+        )
+        if value is not None
+    }
+    if database is not None:
+        if database.lower() == "none":
+            kwargs["database"] = None
+        elif database == HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER:
+            kwargs["database"] = InMemoryExampleDatabase()
+        else:
+            kwargs["database"] = DirectoryBasedExampleDatabase(database)
+    return hypothesis.settings(print_blob=False, deadline=None, verbosity=hypothesis.Verbosity.quiet, **kwargs)

schemathesis/cli/commands/run/loaders.py

@@ -0,0 +1,129 @@
+"""Automatic schema loading.
+
+This module handles the automatic detection and loading of API schemas,
+supporting both GraphQL and OpenAPI specifications.
+"""
+
+from __future__ import annotations
+
+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.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"]
+
+
+@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:
+    """Load API schema automatically based on the provided configuration."""
+    if is_probably_graphql(config.location):
+        # Try GraphQL first, then fallback to Open API
+        return _try_load_schema(config, graphql, openapi)
+    # Try Open API first, then fallback to GraphQL
+    return _try_load_schema(config, openapi, graphql)
+
+
+def should_try_more(exc: LoaderError) -> bool:
+    """Determine if alternative schema loading should be attempted."""
+    import requests
+    from yaml.reader import ReaderError
+
+    if isinstance(exc.__cause__, ReaderError) and "characters are not allowed" in str(exc.__cause__):
+        return False
+
+    # We should not try other loaders for cases when we can't even establish connection
+    return not isinstance(exc.__cause__, requests.exceptions.ConnectionError) and exc.kind not in (
+        LoaderErrorKind.OPEN_API_INVALID_SCHEMA,
+        LoaderErrorKind.OPEN_API_UNSPECIFIED_VERSION,
+        LoaderErrorKind.OPEN_API_UNSUPPORTED_VERSION,
+    )
+
+
+def detect_loader(schema_or_location: str | dict[str, Any], 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
+
+
+def _try_load_schema(config: AutodetectConfig, 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)
+        except LoaderError as exc:
+            if should_try_more(exc):
+                try:
+                    return _load_schema(config, second_module)
+                except Exception as second_exc:
+                    if is_specific_exception(second_exc):
+                        raise second_exc
+            # Re-raise the original error
+            raise exc
+
+
+def _load_schema(config: AutodetectConfig, module: Any) -> BaseSchema:
+    """Unified schema loader for both GraphQL and OpenAPI."""
+    loader = detect_loader(config.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,
+    )
+
+
+def is_specific_exception(exc: Exception) -> bool:
+    """Determine if alternative schema loading should be attempted."""
+    return (
+        isinstance(exc, LoaderError)
+        and exc.kind == LoaderErrorKind.GRAPHQL_INVALID_SCHEMA
+        # In some cases it is not clear that the schema is even supposed to be GraphQL, e.g. an empty input
+        and "Syntax Error: Unexpected <EOF>." not in exc.extras
+    )
+
+
+def is_probably_graphql(schema_or_location: str | dict[str, Any]) -> 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"]
+    )

schemathesis/cli/{callbacks.py → commands/run/validation.py}

@@ -1,124 +1,60 @@
 from __future__ import annotations
 
 import codecs
-import enum
+import operator
 import os
+import pathlib
 import re
-import traceback
 from contextlib import contextmanager
-from functools import partial
-from typing import Generator, TYPE_CHECKING, Callable
+from functools import partial, reduce
+from typing import Callable, Generator, Sequence
 from urllib.parse import urlparse
 
 import click
 
-from click.types import LazyFile  # type: ignore
-
-from .. import exceptions, experimental, throttling
-from ..code_samples import CodeSampleStyle
-from ..exceptions import extract_nth_traceback
-from ..generation import DataGenerationMethod
-from ..constants import TRUE_VALUES, FALSE_VALUES
-from ..internal.validation import file_exists, is_filename, is_illegal_surrogate
-from ..loaders import load_app
-from ..service.hosts import get_temporary_hosts_file
-from ..transports.headers import has_invalid_characters, is_latin_1_encodable
-from ..types import PathLike
-from .constants import DEFAULT_WORKERS
-from ..stateful import Stateful
-
-if TYPE_CHECKING:
-    import hypothesis
+from schemathesis import errors, experimental
+from schemathesis.cli.commands.run.handlers.cassettes import CassetteFormat
+from schemathesis.cli.constants import DEFAULT_WORKERS
+from schemathesis.core import 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.generation import GenerationMode
+from schemathesis.generation.overrides import Override
 
 INVALID_DERANDOMIZE_MESSAGE = (
-    "`--hypothesis-derandomize` implies no database, so passing `--hypothesis-database` too is invalid."
+    "`--generation-deterministic` implies no database, so passing `--generation-database` too is invalid."
 )
 MISSING_CASSETTE_PATH_ARGUMENT_MESSAGE = (
     "Missing argument, `--cassette-path` should be specified as well if you use `--cassette-preserve-exact-body-bytes`."
 )
-INVALID_SCHEMA_MESSAGE = "Invalid SCHEMA, must be a valid URL, file path or an API name from Schemathesis.io."
+INVALID_SCHEMA_MESSAGE = "Invalid SCHEMA, must be a valid URL or file path."
 FILE_DOES_NOT_EXIST_MESSAGE = "The specified file does not exist. Please provide a valid path to an existing file."
 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 `--base-url` option is required when specifying a schema via a file."
-WSGI_DOCUMENTATION_URL = "https://schemathesis.readthedocs.io/en/stable/python.html#asgi-wsgi-support"
-APPLICATION_MISSING_MODULE_MESSAGE = f"""Unable to import application from {{module}}.
-
-The `--app` option should follow this format:
-
-    module_path:variable_name
-
-- `module_path`: A path to an importable Python module.
-- `variable_name`: The name of the application variable within that module.
-
-Example: `st run --app=your_module:app ...`
-
-For details on working with WSGI applications, visit {WSGI_DOCUMENTATION_URL}"""
-APPLICATION_IMPORT_ERROR_MESSAGE = f"""An error occurred while loading the application from {{module}}.
-
-Traceback:
-
-{{traceback}}
-
-For details on working with WSGI applications, visit {WSGI_DOCUMENTATION_URL}"""
 MISSING_REQUEST_CERT_MESSAGE = "The `--request-cert` option must be specified if `--request-cert-key` is used."
 
 
-@enum.unique
-class SchemaInputKind(enum.Enum):
-    """Kinds of SCHEMA input."""
-
-    # Regular URL like https://example.schemathesis.io/openapi.json
-    URL = 1
-    # Local path
-    PATH = 2
-    # Relative path within a Python app
-    APP_PATH = 3
-    # A name for API created in Schemathesis.io
-    NAME = 4
-
-
-def parse_schema_kind(schema: str, app: str | None) -> SchemaInputKind:
-    """Detect what kind the input schema is."""
+def validate_schema(schema: str, base_url: str | None) -> None:
     try:
         netloc = urlparse(schema).netloc
+        if netloc:
+            validate_url(schema)
+            return None
     except ValueError as exc:
         raise click.UsageError(INVALID_SCHEMA_MESSAGE) from exc
     if "\x00" in schema or not schema:
         raise click.UsageError(INVALID_SCHEMA_MESSAGE)
-    if netloc:
-        return SchemaInputKind.URL
-    if file_exists(schema) or is_filename(schema):
-        return SchemaInputKind.PATH
-    if app is not None:
-        return SchemaInputKind.APP_PATH
-    # Assume NAME if it is not a URL or PATH or APP_PATH
-    return SchemaInputKind.NAME
-
-
-def validate_schema(
-    schema: str,
-    kind: SchemaInputKind,
-    *,
-    base_url: str | None,
-    dry_run: bool,
-    app: str | None,
-    api_name: str | None,
-) -> None:
-    if kind == SchemaInputKind.URL:
-        validate_url(schema)
-    if kind == SchemaInputKind.PATH:
-        if app is None:
-            if not file_exists(schema):
-                raise click.UsageError(FILE_DOES_NOT_EXIST_MESSAGE)
-            # Base URL is required if it is not a dry run
-            if base_url is None and not dry_run:
-                raise click.UsageError(MISSING_BASE_URL_MESSAGE)
-    if kind == SchemaInputKind.NAME:
-        if api_name is not None:
-            raise click.UsageError(f"Got unexpected extra argument ({api_name})")
+    exists = file_exists(schema)
+    if exists or bool(pathlib.Path(schema).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
+    raise click.UsageError(INVALID_SCHEMA_MESSAGE)
 
 
 def validate_url(value: str) -> None:
@@ -152,43 +88,18 @@ def validate_rate_limit(ctx: click.core.Context, param: click.core.Parameter, ra
     if raw_value is None:
         return raw_value
     try:
-        throttling.parse_units(raw_value)
+        rate_limit.parse_units(raw_value)
         return raw_value
-    except exceptions.UsageError as exc:
+    except errors.IncorrectUsage as exc:
         raise click.UsageError(exc.args[0]) from exc
 
 
-def validate_app(ctx: click.core.Context, param: click.core.Parameter, raw_value: str | None) -> str | None:
-    if raw_value is None:
-        return raw_value
-    try:
-        load_app(raw_value)
-        # String is returned instead of an app because it might be passed to a subprocess
-        # Since most app instances are not-transferable to another process, they are passed as strings and
-        # imported in a subprocess
-        return raw_value
-    except Exception as exc:
-        formatted_module_name = click.style(f"'{raw_value}'", bold=True)
-        if isinstance(exc, ModuleNotFoundError):
-            message = APPLICATION_MISSING_MODULE_MESSAGE.format(module=formatted_module_name)
-            click.echo(message)
-        else:
-            trace = extract_nth_traceback(exc.__traceback__, 2)
-            lines = traceback.format_exception(type(exc), exc, trace)
-            traceback_message = "".join(lines).strip()
-            message = APPLICATION_IMPORT_ERROR_MESSAGE.format(
-                module=formatted_module_name, traceback=click.style(traceback_message, fg="red")
-            )
-            click.echo(message)
-        raise click.exceptions.Exit(1) from None
-
-
 def validate_hypothesis_database(
     ctx: click.core.Context, param: click.core.Parameter, raw_value: str | None
 ) -> str | None:
     if raw_value is None:
         return raw_value
-    if ctx.params.get("hypothesis_derandomize"):
+    if ctx.params.get("generation_deterministic"):
         raise click.UsageError(INVALID_DERANDOMIZE_MESSAGE)
     return raw_value
 
@@ -209,6 +120,24 @@ def validate_auth(
     return None
 
 
+def validate_auth_overlap(auth: tuple[str, str] | None, headers: dict[str, str], override: Override) -> 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:
+        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]:
@@ -229,8 +158,14 @@ def _validate_and_build_multiple_options(
     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 is_illegal_surrogate(value):
+    if contains_unicode_surrogate_pair(value):
         raise click.BadParameter("Query parameter value should not contain surrogates.")
 
 
@@ -253,7 +188,7 @@ def validate_set_cookie(
 
 
 def _validate_set_path(_: str, value: str) -> None:
-    if is_illegal_surrogate(value):
+    if contains_unicode_surrogate_pair(value):
         raise click.BadParameter("Path parameter value should not contain surrogates.")
 
 
@@ -311,80 +246,74 @@ def validate_preserve_exact_body_bytes(ctx: click.core.Context, param: click.cor
     return raw_value
 
 
-def convert_verbosity(
-    ctx: click.core.Context, param: click.core.Parameter, value: str | None
-) -> hypothesis.Verbosity | None:
-    import hypothesis
-
-    if value is None:
-        return value
-    return hypothesis.Verbosity[value]
-
-
-def convert_stateful(ctx: click.core.Context, param: click.core.Parameter, value: str) -> Stateful | None:
-    if value == "none":
-        return None
-    return Stateful[value]
-
-
 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.name in value or feature.is_env_var_set
+        if feature.label in value or feature.is_env_var_set
     ]
 
 
 def convert_checks(ctx: click.core.Context, param: click.core.Parameter, value: tuple[list[str]]) -> list[str]:
-    return sum(value, [])
+    return reduce(operator.iadd, value, [])
 
 
-def convert_code_sample_style(ctx: click.core.Context, param: click.core.Parameter, value: str) -> CodeSampleStyle:
-    return CodeSampleStyle.from_str(value)
-
+def convert_status_codes(
+    ctx: click.core.Context, param: click.core.Parameter, value: list[str] | None
+) -> list[str] | None:
+    if not value:
+        return value
 
-def convert_data_generation_method(
-    ctx: click.core.Context, param: click.core.Parameter, value: str
-) -> list[DataGenerationMethod]:
-    if value == "all":
-        return DataGenerationMethod.all()
-    return [DataGenerationMethod[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()
+
+        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)
+
+    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
 
 
-def _is_usable_dir(path: PathLike) -> bool:
-    if os.path.isfile(path):
-        path = os.path.dirname(path)
-    while not os.path.exists(path):
-        path = os.path.dirname(path)
-    return os.path.isdir(path) and os.access(path, os.R_OK | os.W_OK | os.X_OK)
+def convert_cassette_format(ctx: click.core.Context, param: click.core.Parameter, value: str) -> CassetteFormat:
+    return CassetteFormat.from_str(value)
 
 
-def convert_hosts_file(ctx: click.core.Context, param: click.core.Parameter, value: PathLike) -> PathLike:
-    if not _is_usable_dir(value):
-        path = get_temporary_hosts_file()
-        click.secho(
-            "WARNING: The provided hosts.toml file location is unusable - using a temporary file for this session. "
-            f"path={str(value)!r}",
-            fg="yellow",
-        )
-        return path
-    return value
+def convert_generation_mode(ctx: click.core.Context, param: click.core.Parameter, value: str) -> list[GenerationMode]:
+    if value == "all":
+        return GenerationMode.all()
+    return [GenerationMode(value)]
 
 
 def convert_boolean_string(ctx: click.core.Context, param: click.core.Parameter, value: str) -> str | bool:
-    if value.lower() in TRUE_VALUES:
-        return True
-    if value.lower() in FALSE_VALUES:
-        return False
-    return value
-
-
-def convert_report(ctx: click.core.Context, param: click.core.Option, value: LazyFile) -> LazyFile:
-    if param.resolve_envvar_value(ctx) is not None and value.lower() in TRUE_VALUES:
-        value = param.flag_value
-    return value
+    return string_to_boolean(value)
 
 
 @contextmanager

schemathesis/cli/constants.py

@@ -1,55 +1,8 @@
-from __future__ import annotations
-from enum import IntEnum, unique
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    import hypothesis
 MIN_WORKERS = 1
 DEFAULT_WORKERS = MIN_WORKERS
 MAX_WORKERS = 64
-
-# Importing Hypothesis is expensive, hence we re-create the enums we need in CLI commands definitions
-# Hypothesis is stable, hence it should not be a problem and adding new variants should not be automatic
-
-
-@unique
-class Phase(IntEnum):
-    explicit = 0  #: controls whether explicit examples are run.
-    reuse = 1  #: controls whether previous examples will be reused.
-    generate = 2  #: controls whether new examples will be generated.
-    target = 3  #: controls whether examples will be mutated for targeting.
-    shrink = 4  #: controls whether examples will be shrunk.
-    # The `explain` phase is not supported
-
-    def as_hypothesis(self) -> hypothesis.Phase:
-        from hypothesis import Phase
-
-        return Phase[self.name]
-
-    @staticmethod
-    def filter_from_all(variants: list[Phase]) -> list[hypothesis.Phase]:
-        from hypothesis import Phase
-
-        return list(set(Phase) - {Phase.explain} - set(variants))
-
-
-@unique
-class HealthCheck(IntEnum):
-    # We remove not relevant checks
-    data_too_large = 1
-    filter_too_much = 2
-    too_slow = 3
-    large_base_example = 7
-
-    def as_hypothesis(self) -> hypothesis.HealthCheck:
-        from hypothesis import HealthCheck
-
-        return HealthCheck[self.name]
-
-
-@unique
-class Verbosity(IntEnum):
-    quiet = 0
-    normal = 1
-    verbose = 2
-    debug = 3
+ISSUE_TRACKER_URL = (
+    "https://github.com/schemathesis/schemathesis/issues/new?"
+    "labels=Status%3A%20Needs%20Triage%2C+Type%3A+Bug&template=bug_report.md&title=%5BBUG%5D"
+)
+EXTENSIONS_DOCUMENTATION_URL = "https://schemathesis.readthedocs.io/en/stable/extending.html"

schemathesis/cli/core.py

@@ -0,0 +1,17 @@
+import os
+import shutil
+
+import click
+
+
+def get_terminal_width() -> int:
+    # Some CI/CD providers (e.g. CircleCI) return a (0, 0) terminal size so provide a default
+    return shutil.get_terminal_size((80, 24)).columns
+
+
+def ensure_color(ctx: click.Context, no_color: bool, force_color: bool) -> None:
+    if force_color:
+        ctx.color = True
+    elif no_color or "NO_COLOR" in os.environ:
+        ctx.color = False
+        os.environ["NO_COLOR"] = "1"