schemathesis 4.0.0a1__py3-none-any.whl → 4.0.0a2__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/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,10 @@ 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", "specification", "statistic")
 
     def __init__(
-        self,
-        location: str,
-        start_time: float,
-        base_url: str,
-        specification: Specification,
-        operations_count: ApiOperationsCount,
+        self, location: str, start_time: float, base_url: str, specification: Specification, statistic: ApiStatistic
     ) -> None:
         self.id = uuid.uuid4()
         self.timestamp = time.time()
@@ -32,4 +27,4 @@ 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

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,7 @@ 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,
     )
 
     try:
@@ -112,7 +115,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()