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

schemathesis/cli/commands/run/executor.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import sys
-from dataclasses import dataclass
 from typing import Any, Callable
 
 import click
@@ -13,15 +12,13 @@ from schemathesis.cli.commands.run.handlers.base import EventHandler
 from schemathesis.cli.commands.run.handlers.cassettes import CassetteWriter
 from schemathesis.cli.commands.run.handlers.junitxml import JunitXMLHandler
 from schemathesis.cli.commands.run.handlers.output import OutputHandler
-from schemathesis.cli.commands.run.loaders import AutodetectConfig, load_schema
-from schemathesis.cli.commands.run.reports import ReportConfig, ReportFormat
+from schemathesis.cli.commands.run.loaders import load_schema
 from schemathesis.cli.ext.fs import open_file
+from schemathesis.config import ProjectConfig, ReportFormat
 from schemathesis.core.errors import LoaderError
-from schemathesis.core.output import OutputConfig
+from schemathesis.core.fs import file_exists
 from schemathesis.engine import from_schema
-from schemathesis.engine.config import EngineConfig
 from schemathesis.engine.events import EventGenerator, FatalError, Interrupted
-from schemathesis.filters import FilterSet
 
 CUSTOM_HANDLERS: list[type[EventHandler]] = []
 
@@ -35,41 +32,34 @@ def handler() -> Callable[[type], None]:
     return _wrapper
 
 
-@dataclass
-class RunConfig:
-    location: str
-    base_url: str | None
-    filter_set: FilterSet
-    engine: EngineConfig
-    wait_for_schema: float | None
-    rate_limit: str | None
-    output: OutputConfig
-    report: ReportConfig | None
-    args: list[str]
-    params: dict[str, Any]
-
-
-def execute(config: RunConfig) -> None:
-    event_stream = into_event_stream(config)
-    _execute(event_stream, config)
-
-
-def into_event_stream(config: RunConfig) -> EventGenerator:
-    loader_config = AutodetectConfig(
-        location=config.location,
-        network=config.engine.network,
-        wait_for_schema=config.wait_for_schema,
-        base_url=config.base_url,
-        rate_limit=config.rate_limit,
-        output=config.output,
-        generation=config.engine.execution.generation,
-    )
-    loading_started = LoadingStarted(location=config.location)
+def execute(
+    *,
+    location: str,
+    config: ProjectConfig,
+    filter_set: dict[str, Any],
+    args: list[str],
+    params: dict[str, Any],
+) -> None:
+    event_stream = into_event_stream(location=location, config=config, filter_set=filter_set)
+    _execute(event_stream, config=config, args=args, params=params)
+
+
+MISSING_BASE_URL_MESSAGE = "The `--url` option is required when specifying a schema via a file."
+
+
+def into_event_stream(*, location: str, config: ProjectConfig, filter_set: dict[str, Any]) -> EventGenerator:
+    # The whole engine idea is that it communicates with the outside via events, so handlers can react to them
+    # For this reason, even schema loading is done via a separate set of events.
+    loading_started = LoadingStarted(location=location)
     yield loading_started
 
     try:
-        schema = load_schema(loader_config)
-        schema.filter_set = config.filter_set
+        schema = load_schema(location=location, config=config)
+        # Schemas don't (yet?) use configs for deciding what operations should be tested, so
+        # a separate FilterSet passed there. It combines both config file filters + CLI options
+        schema.filter_set = schema.config.operations.create_filter_set(**filter_set)
+        if file_exists(location) and schema.config.base_url is None:
+            raise click.UsageError(MISSING_BASE_URL_MESSAGE)
     except KeyboardInterrupt:
         yield Interrupted(phase=None)
         return
@@ -78,73 +68,75 @@ def into_event_stream(config: RunConfig) -> EventGenerator:
         return
 
     yield LoadingFinished(
-        location=config.location,
+        location=location,
         start_time=loading_started.timestamp,
         base_url=schema.get_base_url(),
         specification=schema.specification,
         statistic=schema.statistic,
         schema=schema.raw_schema,
+        config=schema.config,
         base_path=schema.base_path,
+        find_operation_by_label=schema.find_operation_by_label,
     )
 
     try:
-        yield from from_schema(schema, config=config.engine).execute()
+        yield from from_schema(schema).execute()
     except Exception as exc:
         yield FatalError(exception=exc)
 
 
-def initialize_handlers(config: RunConfig) -> list[EventHandler]:
+def initialize_handlers(
+    *,
+    config: ProjectConfig,
+    args: list[str],
+    params: dict[str, Any],
+) -> list[EventHandler]:
     """Create event handlers based on run configuration."""
     handlers: list[EventHandler] = []
 
-    if config.report is not None:
-        if ReportFormat.JUNIT in config.report.formats:
-            path = config.report.get_path(ReportFormat.JUNIT)
+    if config.reports.junit.enabled:
+        path = config.reports.get_path(ReportFormat.JUNIT)
+        open_file(path)
+        handlers.append(JunitXMLHandler(path))
+    for format, report in (
+        (ReportFormat.VCR, config.reports.vcr),
+        (ReportFormat.HAR, config.reports.har),
+    ):
+        if report.enabled:
+            path = config.reports.get_path(format)
             open_file(path)
-            handlers.append(JunitXMLHandler(path))
-
-        for format in (ReportFormat.VCR, ReportFormat.HAR):
-            if format in config.report.formats:
-                path = config.report.get_path(format)
-                open_file(path)
-                handlers.append(
-                    CassetteWriter(
-                        format=format,
-                        path=path,
-                        sanitize_output=config.report.sanitize_output,
-                        preserve_bytes=config.report.preserve_bytes,
-                    )
-                )
+            handlers.append(CassetteWriter(format=format, path=path, config=config))
 
     for custom_handler in CUSTOM_HANDLERS:
-        handlers.append(custom_handler(*config.args, **config.params))
-
-    handlers.append(
-        OutputHandler(
-            workers_num=config.engine.execution.workers_num,
-            seed=config.engine.execution.seed,
-            rate_limit=config.rate_limit,
-            wait_for_schema=config.wait_for_schema,
-            engine_config=config.engine,
-            report_config=config.report,
-        )
-    )
+        handlers.append(custom_handler(*args, **params))
+
+    handlers.append(OutputHandler(config=config))
 
     return handlers
 
 
-def _execute(event_stream: EventGenerator, config: RunConfig) -> None:
-    handlers = initialize_handlers(config)
-    ctx = ExecutionContext(output_config=config.output, seed=config.engine.execution.seed)
+def _execute(
+    event_stream: EventGenerator,
+    *,
+    config: ProjectConfig,
+    args: list[str],
+    params: dict[str, Any],
+) -> None:
+    handlers: list[EventHandler] = []
+    ctx: ExecutionContext | None = None
 
     def shutdown() -> None:
-        for _handler in handlers:
-            _handler.shutdown(ctx)
-
-    for handler in handlers:
-        handler.start(ctx)
+        if ctx is not None:
+            for _handler in handlers:
+                _handler.shutdown(ctx)
 
     try:
+        handlers = initialize_handlers(config=config, args=args, params=params)
+        ctx = ExecutionContext(config=config)
+
+        for handler in handlers:
+            handler.start(ctx)
+
         for event in event_stream:
             ctx.on_event(event)
             for handler in handlers:

schemathesis/cli/commands/run/filters.py

@@ -1,13 +1,11 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
-from typing import Any, Callable, Literal, Sequence
+from functools import partial
+from typing import Callable, Literal
 
 import click
 
 from schemathesis.cli.ext.groups import grouped_option
-from schemathesis.core.errors import IncorrectUsage
-from schemathesis.filters import FilterSet, expression_to_filter_function, is_deprecated
 
 
 def _with_filter(*, by: str, mode: Literal["include", "exclude"], modifier: Literal["regex"] | None) -> Callable:
@@ -18,19 +16,32 @@ def _with_filter(*, by: str, mode: Literal["include", "exclude"], modifier: Lite
         "operation-id": "ID",
         "name": "Operation name",
     }.get(by, by.capitalize())
+    callback = None
     if modifier:
         param += f"-{modifier}"
         prop += " pattern"
+    else:
+        callback = partial(validate_filter, arg_name=param)
     help_text = f"{prop} to {action} testing."
     return grouped_option(
         param,
         help=help_text,
         type=str,
         multiple=modifier is None,
+        callback=callback,
         hidden=True,
     )
 
 
+def validate_filter(
+    ctx: click.core.Context, param: click.core.Parameter, raw_value: list[str], arg_name: str
+) -> list[str]:
+    if len(raw_value) != len(set(raw_value)):
+        duplicates = ",".join(sorted({value for value in raw_value if raw_value.count(value) > 1}))
+        raise click.UsageError(f"Duplicate values are not allowed for `{arg_name}`: {duplicates}")
+    return raw_value
+
+
 _BY_VALUES = ("operation-id", "tag", "name", "method", "path")
 
 
@@ -40,164 +51,3 @@ def with_filters(command: Callable) -> Callable:
             for modifier in ("regex", None):
                 command = _with_filter(by=by, mode=mode, modifier=modifier)(command)  # type: ignore[arg-type]
     return command
-
-
-@dataclass
-class FilterArguments:
-    include_path: Sequence[str]
-    include_method: Sequence[str]
-    include_name: Sequence[str]
-    include_tag: Sequence[str]
-    include_operation_id: Sequence[str]
-    include_path_regex: str | None
-    include_method_regex: str | None
-    include_name_regex: str | None
-    include_tag_regex: str | None
-    include_operation_id_regex: str | None
-
-    exclude_path: Sequence[str]
-    exclude_method: Sequence[str]
-    exclude_name: Sequence[str]
-    exclude_tag: Sequence[str]
-    exclude_operation_id: Sequence[str]
-    exclude_path_regex: str | None
-    exclude_method_regex: str | None
-    exclude_name_regex: str | None
-    exclude_tag_regex: str | None
-    exclude_operation_id_regex: str | None
-
-    include_by: str | None
-    exclude_by: str | None
-    exclude_deprecated: bool
-
-    __slots__ = (
-        "include_path",
-        "include_method",
-        "include_name",
-        "include_tag",
-        "include_operation_id",
-        "include_path_regex",
-        "include_method_regex",
-        "include_name_regex",
-        "include_tag_regex",
-        "include_operation_id_regex",
-        "exclude_path",
-        "exclude_method",
-        "exclude_name",
-        "exclude_tag",
-        "exclude_operation_id",
-        "exclude_path_regex",
-        "exclude_method_regex",
-        "exclude_name_regex",
-        "exclude_tag_regex",
-        "exclude_operation_id_regex",
-        "include_by",
-        "exclude_by",
-        "exclude_deprecated",
-    )
-
-    def into(self) -> FilterSet:
-        # Validate unique filter arguments
-        for values, arg_name in (
-            (self.include_path, "--include-path"),
-            (self.include_method, "--include-method"),
-            (self.include_name, "--include-name"),
-            (self.include_tag, "--include-tag"),
-            (self.include_operation_id, "--include-operation-id"),
-            (self.exclude_path, "--exclude-path"),
-            (self.exclude_method, "--exclude-method"),
-            (self.exclude_name, "--exclude-name"),
-            (self.exclude_tag, "--exclude-tag"),
-            (self.exclude_operation_id, "--exclude-operation-id"),
-        ):
-            validate_unique_filter(values, arg_name)
-
-        # Convert include/exclude expressions to functions
-        include_by_function = _filter_by_expression_to_func(self.include_by, "--include-by")
-        exclude_by_function = _filter_by_expression_to_func(self.exclude_by, "--exclude-by")
-
-        filter_set = FilterSet()
-
-        # Apply include filters
-        if include_by_function:
-            filter_set.include(include_by_function)
-        for name_ in self.include_name:
-            filter_set.include(name=name_)
-        for method in self.include_method:
-            filter_set.include(method=method)
-        for path in self.include_path:
-            filter_set.include(path=path)
-        for tag in self.include_tag:
-            filter_set.include(tag=tag)
-        for operation_id in self.include_operation_id:
-            filter_set.include(operation_id=operation_id)
-        if (
-            self.include_name_regex
-            or self.include_method_regex
-            or self.include_path_regex
-            or self.include_tag_regex
-            or self.include_operation_id_regex
-        ):
-            filter_set.include(
-                name_regex=self.include_name_regex,
-                method_regex=self.include_method_regex,
-                path_regex=self.include_path_regex,
-                tag_regex=self.include_tag_regex,
-                operation_id_regex=self.include_operation_id_regex,
-            )
-
-        # Apply exclude filters
-        if exclude_by_function:
-            filter_set.exclude(exclude_by_function)
-        for name_ in self.exclude_name:
-            apply_exclude_filter(filter_set, "name", name=name_)
-        for method in self.exclude_method:
-            apply_exclude_filter(filter_set, "method", method=method)
-        for path in self.exclude_path:
-            apply_exclude_filter(filter_set, "path", path=path)
-        for tag in self.exclude_tag:
-            apply_exclude_filter(filter_set, "tag", tag=tag)
-        for operation_id in self.exclude_operation_id:
-            apply_exclude_filter(filter_set, "operation-id", operation_id=operation_id)
-        for key, value, name in (
-            ("name_regex", self.exclude_name_regex, "name-regex"),
-            ("method_regex", self.exclude_method_regex, "method-regex"),
-            ("path_regex", self.exclude_path_regex, "path-regex"),
-            ("tag_regex", self.exclude_tag_regex, "tag-regex"),
-            ("operation_id_regex", self.exclude_operation_id_regex, "operation-id-regex"),
-        ):
-            if value:
-                apply_exclude_filter(filter_set, name, **{key: value})
-
-        # Exclude deprecated operations
-        if self.exclude_deprecated:
-            filter_set.exclude(is_deprecated)
-
-        return filter_set
-
-
-def apply_exclude_filter(filter_set: FilterSet, option_name: str, **kwargs: Any) -> None:
-    """Apply an exclude filter with proper error handling."""
-    try:
-        filter_set.exclude(**kwargs)
-    except IncorrectUsage as e:
-        if str(e) == "Filter already exists":
-            raise click.UsageError(
-                f"Filter for {option_name} already exists. You can't simultaneously include and exclude the same thing."
-            ) from None
-        raise click.UsageError(str(e)) from None
-
-
-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 _filter_by_expression_to_func(value: str | None, arg_name: str) -> Callable | None:
-    if value:
-        try:
-            return expression_to_filter_function(value)
-        except ValueError:
-            raise click.UsageError(f"Invalid expression for {arg_name}: {value}") from None
-    return None