schemathesis 4.0.0a1__py3-none-any.whl → 4.0.0a3__py3-none-any.whl

schemathesis/checks.py

@@ -4,6 +4,7 @@ import json
 from typing import TYPE_CHECKING, Any, Callable, Iterable, Iterator, Optional
 
 from schemathesis.core.failures import (
+    CustomFailure,
     Failure,
     FailureGroup,
     MalformedJson,
@@ -72,7 +73,7 @@ class CheckContext:
 
     def record_case(self, *, parent_id: str, case: Case) -> None:
         if self.recorder is not None:
-            self.recorder.record_case(parent_id=parent_id, case=case)
+            self.recorder.record_case(parent_id=parent_id, transition=None, case=case)
 
     def record_response(self, *, case_id: str, response: Response) -> None:
         if self.recorder is not None:
@@ -135,10 +136,11 @@ def run_checks(
         except Failure as failure:
             on_failure(name, collected, failure.with_traceback(None))
         except AssertionError as exc:
-            custom_failure = Failure.from_assertion(
-                name=name,
+            custom_failure = CustomFailure(
                 operation=case.operation.label,
-                exc=exc,
+                title=f"Custom check failed: `{name}`",
+                message=str(exc),
+                exception=exc,
             )
             on_failure(name, collected, custom_failure)
         except FailureGroup as group:

schemathesis/cli/__init__.py

@@ -1,11 +1,22 @@
 from __future__ import annotations
 
 from schemathesis.cli.commands import Group, run, schemathesis
+from schemathesis.cli.commands.run.context import ExecutionContext
+from schemathesis.cli.commands.run.events import LoadingFinished, LoadingStarted
 from schemathesis.cli.commands.run.executor import handler
 from schemathesis.cli.commands.run.handlers import EventHandler
 from schemathesis.cli.ext.groups import GROUPS
 
-__all__ = ["schemathesis", "run", "EventHandler", "add_group", "handler"]
+__all__ = [
+    "schemathesis",
+    "run",
+    "EventHandler",
+    "ExecutionContext",
+    "LoadingStarted",
+    "LoadingFinished",
+    "add_group",
+    "handler",
+]
 
 
 def add_group(name: str, *, index: int | None = None) -> Group:

schemathesis/cli/commands/run/__init__.py

@@ -91,7 +91,7 @@ DEFAULT_PHASES = ("unit", "stateful")
     help="Comma-separated list of checks to run against API responses",
     type=RegistryChoice(CHECKS, with_all=True),
     default=("not_a_server_error",),
-    callback=validation.convert_checks,
+    callback=validation.reduce_list,
     show_default=True,
     metavar="",
 )
@@ -102,7 +102,7 @@ DEFAULT_PHASES = ("unit", "stateful")
     help="Comma-separated list of checks to skip during testing",
     type=RegistryChoice(CHECKS, with_all=True),
     default=(),
-    callback=validation.convert_checks,
+    callback=validation.reduce_list,
     show_default=True,
     metavar="",
 )
@@ -356,7 +356,7 @@ DEFAULT_PHASES = ("unit", "stateful")
     help="Guide input generation to values more likely to expose bugs via targeted property-based testing",
     type=RegistryChoice(TARGETS),
     default=None,
-    callback=validation.convert_checks,
+    callback=validation.reduce_list,
     show_default=True,
     metavar="TARGET",
 )
@@ -588,7 +588,7 @@ def run(
         max_response_time=max_response_time,
     ).into()
 
-    if exit_first:
+    if exit_first and max_failures is None:
         max_failures = 1
 
     cassette_config = None

schemathesis/cli/commands/run/events.py

@@ -3,7 +3,7 @@ import uuid
 
 from schemathesis.core import Specification
 from schemathesis.engine import events
-from schemathesis.schemas import ApiOperationsCount
+from schemathesis.schemas import ApiStatistic
 
 
 class LoadingStarted(events.EngineEvent):
@@ -16,15 +16,28 @@ class LoadingStarted(events.EngineEvent):
 
 
 class LoadingFinished(events.EngineEvent):
-    __slots__ = ("id", "timestamp", "location", "duration", "base_url", "specification", "operations_count")
+    __slots__ = (
+        "id",
+        "timestamp",
+        "location",
+        "duration",
+        "base_url",
+        "base_path",
+        "specification",
+        "statistic",
+        "schema",
+    )
 
     def __init__(
         self,
+        *,
         location: str,
         start_time: float,
         base_url: str,
+        base_path: str,
         specification: Specification,
-        operations_count: ApiOperationsCount,
+        statistic: ApiStatistic,
+        schema: dict,
     ) -> None:
         self.id = uuid.uuid4()
         self.timestamp = time.time()
@@ -32,4 +45,6 @@ class LoadingFinished(events.EngineEvent):
         self.duration = self.timestamp - start_time
         self.base_url = base_url
         self.specification = specification
-        self.operations_count = operations_count
+        self.statistic = statistic
+        self.schema = schema
+        self.base_path = base_path

schemathesis/cli/commands/run/executor.py

@@ -19,7 +19,7 @@ from schemathesis.core.errors import LoaderError
 from schemathesis.core.output import OutputConfig
 from schemathesis.engine import from_schema
 from schemathesis.engine.config import EngineConfig
-from schemathesis.engine.events import EventGenerator, FatalError
+from schemathesis.engine.events import EventGenerator, FatalError, Interrupted
 from schemathesis.filters import FilterSet
 
 CUSTOM_HANDLERS: list[type[EventHandler]] = []
@@ -70,6 +70,9 @@ def into_event_stream(config: RunConfig) -> EventGenerator:
     try:
         schema = load_schema(loader_config)
         schema.filter_set = config.filter_set
+    except KeyboardInterrupt:
+        yield Interrupted(phase=None)
+        return
     except LoaderError as exc:
         yield FatalError(exception=exc)
         return
@@ -79,7 +82,9 @@ def into_event_stream(config: RunConfig) -> EventGenerator:
         start_time=loading_started.timestamp,
         base_url=schema.get_base_url(),
         specification=schema.specification,
-        operations_count=schema.count_operations(),
+        statistic=schema.statistic,
+        schema=schema.raw_schema,
+        base_path=schema.base_path,
     )
 
     try:
@@ -101,6 +106,7 @@ def _execute(event_stream: EventGenerator, config: RunConfig) -> None:
     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,
             cassette_config=config.cassette,
@@ -112,7 +118,7 @@ def _execute(event_stream: EventGenerator, config: RunConfig) -> None:
 
     def shutdown() -> None:
         for _handler in handlers:
-            _handler.shutdown()
+            _handler.shutdown(ctx)
 
     for handler in handlers:
         handler.start(ctx)

schemathesis/cli/commands/run/filters.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Callable, Literal, Sequence
+from typing import Any, Callable, Literal, Sequence
 
 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
 
 
@@ -148,29 +149,24 @@ class FilterArguments:
         if exclude_by_function:
             filter_set.exclude(exclude_by_function)
         for name_ in self.exclude_name:
-            filter_set.exclude(name=name_)
+            apply_exclude_filter(filter_set, "name", name=name_)
         for method in self.exclude_method:
-            filter_set.exclude(method=method)
+            apply_exclude_filter(filter_set, "method", method=method)
         for path in self.exclude_path:
-            filter_set.exclude(path=path)
+            apply_exclude_filter(filter_set, "path", path=path)
         for tag in self.exclude_tag:
-            filter_set.exclude(tag=tag)
+            apply_exclude_filter(filter_set, "tag", tag=tag)
         for operation_id in self.exclude_operation_id:
-            filter_set.exclude(operation_id=operation_id)
-        if (
-            self.exclude_name_regex
-            or self.exclude_method_regex
-            or self.exclude_path_regex
-            or self.exclude_tag_regex
-            or self.exclude_operation_id_regex
+            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"),
         ):
-            filter_set.exclude(
-                name_regex=self.exclude_name_regex,
-                method_regex=self.exclude_method_regex,
-                path_regex=self.exclude_path_regex,
-                tag_regex=self.exclude_tag_regex,
-                operation_id_regex=self.exclude_operation_id_regex,
-            )
+            if value:
+                apply_exclude_filter(filter_set, name, **{key: value})
 
         # Exclude deprecated operations
         if self.exclude_deprecated:
@@ -179,6 +175,18 @@ class FilterArguments:
         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}))

schemathesis/cli/commands/run/handlers/base.py

@@ -15,4 +15,4 @@ class EventHandler:
 
     def start(self, ctx: ExecutionContext) -> None: ...
 
-    def shutdown(self) -> None: ...
+    def shutdown(self, ctx: ExecutionContext) -> None: ...

schemathesis/cli/commands/run/handlers/cassettes.py

@@ -77,10 +77,8 @@ class CassetteWriter(EventHandler):
     def handle_event(self, ctx: ExecutionContext, event: events.EngineEvent) -> None:
         if isinstance(event, events.ScenarioFinished):
             self.queue.put(Process(recorder=event.recorder))
-        elif isinstance(event, events.EngineFinished):
-            self.shutdown()
 
-    def shutdown(self) -> None:
+    def shutdown(self, ctx: ExecutionContext) -> None:
         self.queue.put(Finalize())
         self._stop_worker()