schemathesis 3.25.5__py3-none-any.whl → 3.39.7__py3-none-any.whl

schemathesis/cli/junitxml.py

@@ -1,43 +1,124 @@
 from __future__ import annotations
+
 import platform
+import textwrap
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 from junit_xml import TestCase, TestSuite, to_xml_report_file
 
+from ..exceptions import RuntimeErrorType
+from ..internal.output import prepare_response_payload
 from ..models import Status
 from ..runner import events
-from ..runner.serialization import deduplicate_failures
 from .handlers import EventHandler
-
+from .reporting import TEST_CASE_ID_TITLE, get_runtime_error_suggestion, group_by_case, split_traceback
 
 if TYPE_CHECKING:
     from click.utils import LazyFile
+
+    from ..runner.serialization import SerializedCheck, SerializedError
     from .context import ExecutionContext
 
 
 @dataclass
 class JunitXMLHandler(EventHandler):
     file_handle: LazyFile
-    test_cases: list = field(default_factory=list)
+    test_cases: dict = field(default_factory=dict)
 
     def handle_event(self, context: ExecutionContext, event: events.ExecutionEvent) -> None:
-        if isinstance(event, events.AfterExecution):
-            test_case = TestCase(
-                f"{event.result.method} {event.result.path}",
-                elapsed_sec=event.elapsed_time,
-                allow_multiple_subelements=True,
-            )
-            if event.status == Status.failure:
-                checks = deduplicate_failures(event.result.checks)
-                for idx, check in enumerate(checks, 1):
-                    # `check.message` is always not empty for events with `failure` status
-                    test_case.add_failure_info(message=f"{idx}. {check.message}")
-            if event.status == Status.error:
-                test_case.add_error_info(
-                    message=event.result.errors[-1].exception, output=event.result.errors[-1].exception_with_traceback
-                )
-            self.test_cases.append(test_case)
-        if isinstance(event, events.Finished):
-            test_suites = [TestSuite("schemathesis", test_cases=self.test_cases, hostname=platform.node())]
+        if isinstance(event, (events.AfterExecution, events.AfterStatefulExecution)):
+            event_: events.AfterExecution | events.AfterStatefulExecution = event
+            if isinstance(event_, events.AfterExecution):
+                name = f"{event_.result.method} {event_.result.path}"
+            else:
+                name = event_.result.verbose_name
+            if name in self.test_cases:
+                test_case = self.test_cases[name]
+                test_case.elapsed_sec += event_.elapsed_time
+            else:
+                test_case = TestCase(name, elapsed_sec=event_.elapsed_time, allow_multiple_subelements=True)
+            if event_.status == Status.failure:
+                _add_failure(test_case, event_.result.checks, context)
+            elif event_.status == Status.error:
+                test_case.add_error_info(output=build_error_message(context, event_.result.errors[-1]))
+            elif event_.status == Status.skip:
+                test_case.add_skipped_info(output=event_.result.skip_reason)
+            self.test_cases[name] = test_case
+        elif isinstance(event, events.Finished):
+            test_suites = [
+                TestSuite("schemathesis", test_cases=list(self.test_cases.values()), hostname=platform.node())
+            ]
             to_xml_report_file(file_descriptor=self.file_handle, test_suites=test_suites, prettyprint=True)
+
+
+def _add_failure(test_case: TestCase, checks: list[SerializedCheck], context: ExecutionContext) -> None:
+    messages = []
+    for idx, (code_sample, group) in enumerate(group_by_case(checks, context.code_sample_style), 1):
+        checks = sorted(group, key=lambda c: c.name != "not_a_server_error")
+        messages.append(build_failure_message(context, idx, code_sample, checks))
+    test_case.add_failure_info(message="\n\n".join(messages))
+
+
+def build_failure_message(context: ExecutionContext, idx: int, code_sample: str, checks: list[SerializedCheck]) -> str:
+    from ..transports.responses import get_reason
+
+    message = ""
+    for check_idx, check in enumerate(checks):
+        if check_idx == 0:
+            message += f"{idx}. {TEST_CASE_ID_TITLE}: {check.example.id}\n"
+        message += f"\n- {check.title}\n"
+        formatted_message = check.formatted_message
+        if formatted_message:
+            message += f"\n{formatted_message}\n"
+        if check_idx + 1 == len(checks):
+            if check.response is not None:
+                status_code = check.response.status_code
+                reason = get_reason(status_code)
+                message += f"\n[{check.response.status_code}] {reason}:\n"
+                if check.response.body is not None:
+                    if not check.response.body:
+                        message += "\n    <EMPTY>\n"
+                    else:
+                        encoding = check.response.encoding or "utf8"
+                        try:
+                            # Checked that is not None
+                            body = cast(bytes, check.response.deserialize_body())
+                            payload = body.decode(encoding)
+                            payload = prepare_response_payload(payload, config=context.output_config)
+                            payload = textwrap.indent(f"\n`{payload}`\n", prefix="    ")
+                            message += payload
+                        except UnicodeDecodeError:
+                            message += "\n    <BINARY>\n"
+
+    message += f"\nReproduce with: \n\n    {code_sample}"
+    return message
+
+
+def build_error_message(context: ExecutionContext, error: SerializedError) -> str:
+    message = ""
+    if error.title:
+        if error.type == RuntimeErrorType.SCHEMA_GENERIC:
+            message = "Schema Error\n"
+        else:
+            message = f"{error.title}\n"
+        if error.message:
+            message += f"\n{error.message}\n"
+    elif error.message:
+        message = error.message
+    else:
+        message = error.exception
+    if error.extras:
+        extras = error.extras
+    elif context.show_trace and error.type.has_useful_traceback:
+        extras = split_traceback(error.exception_with_traceback)
+    else:
+        extras = []
+    if extras:
+        message += "\n"
+    for extra in extras:
+        message += f"    {extra}\n"
+    suggestion = get_runtime_error_suggestion(error.type, bold=str)
+    if suggestion is not None:
+        message += f"\nTip: {suggestion}"
+    return message

schemathesis/cli/options.py

@@ -1,11 +1,15 @@
 from __future__ import annotations
-from enum import Enum
-from typing import Any, NoReturn
+
+from typing import TYPE_CHECKING, Any, NoReturn
 
 import click
 
 from ..constants import NOT_SET
-from ..types import NotSet
+
+if TYPE_CHECKING:
+    from enum import Enum
+
+    from ..types import NotSet
 
 
 class CustomHelpMessageChoice(click.Choice):
@@ -54,6 +58,13 @@ class CsvChoice(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 OptionalInt(click.types.IntRange):
     def convert(  # type: ignore
         self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None
@@ -64,4 +75,4 @@ class OptionalInt(click.types.IntRange):
             int(value)
             return super().convert(value, param, ctx)
         except ValueError:
-            self.fail("%s is not a valid integer or None." % value, param, ctx)
+            self.fail(f"{value} is not a valid integer or None.", param, ctx)