atlas-init 0.6.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

atlas_init/cli_tf/go_test_summary.py

@@ -6,9 +6,10 @@ from collections import Counter
 from dataclasses import dataclass, field
 from datetime import date, datetime, timedelta
 from enum import StrEnum
-from functools import total_ordering
+from functools import reduce, total_ordering
 from pathlib import Path
-from typing import ClassVar
+import re
+from typing import Callable, ClassVar, TypeVar
 
 from ask_shell.rich_progress import new_task
 from model_lib import Entity
@@ -18,8 +19,15 @@ from zero_3rdparty.iter_utils import group_by_once
 
 from atlas_init.cli_tf.github_logs import summary_dir
 from atlas_init.cli_tf.go_test_run import GoTestRun, GoTestStatus
-from atlas_init.cli_tf.go_test_tf_error import GoTestError, GoTestErrorClass, GoTestErrorClassification
-from atlas_init.crud.mongo_dao import init_mongo_dao
+from atlas_init.cli_tf.go_test_tf_error import (
+    GoTestError,
+    GoTestErrorClass,
+    GoTestErrorClassification,
+    details_short_description,
+    parse_error_details,
+)
+from atlas_init.crud.mongo_dao import MongoDao, init_mongo_dao
+from atlas_init.html_out.md_export import MonthlyReportPaths
 from atlas_init.settings.env_vars import AtlasInitSettings
 
 logger = logging.getLogger(__name__)
@@ -30,6 +38,7 @@ _COMPLETE_STATUSES = {GoTestStatus.PASS, GoTestStatus.FAIL}
 class GoTestSummary(Entity):
     name: str
     results: list[GoTestRun] = Field(default_factory=list)
+    classifications: dict[str, GoTestErrorClassification] = Field(default_factory=dict)
 
     @model_validator(mode="after")
     def sort_results(self):
@@ -44,7 +53,8 @@ class GoTestSummary(Entity):
     def success_rate(self) -> float:
         total = self.total_completed
         if total == 0:
-            logger.warning(f"No results to calculate success rate for {self.name}")
+            if not self.is_skipped:
+                logger.warning(f"No results to calculate success rate for {self.name}")
             return 0
         return sum(r.status == "PASS" for r in self.results) / total
 
@@ -89,20 +99,67 @@ def summary_str(summary: GoTestSummary, start_date: datetime, end_date: datetime
     )
 
 
+def test_detail_md(summary: GoTestSummary, start_date: datetime, end_date: datetime) -> str:
+    return "\n".join(
+        [
+            f"# {summary.name} Test Details",
+            summary_line(summary.results),
+            f"Success rate: {summary.success_rate_human}",
+            "",
+            *error_table(summary),
+            "## Timeline",
+            *timeline_lines(summary, start_date, end_date),
+        ]
+    )
+
+
 def timeline_lines(summary: GoTestSummary, start_date: datetime, end_date: datetime) -> list[str]:
     lines = []
     one_day = timedelta(days=1)
     for active_date in datetime_utils.day_range(start_date.date(), (end_date + one_day).date(), one_day):
         active_tests = summary.select_tests(active_date)
         if not active_tests:
-            lines.append(f"{active_date:%Y-%m-%d}: MISSING")
+            lines.append(f"- {active_date:%Y-%m-%d}: MISSING")
             continue
-
-        tests_str = ", ".join(format_test_oneline(t) for t in active_tests)
-        lines.append(f"{active_date:%Y-%m-%d}: {tests_str}")
+        lines.append(f"- {active_date:%Y-%m-%d}")
+        if len(active_tests) == 1:
+            test = active_tests[0]
+            if test.is_failure:
+                lines.extend(_extract_error_lines(test, summary))
+            else:
+                lines[-1] += f" {format_test_oneline(test)}"
+        if len(active_tests) > 1:
+            for test in active_tests:
+                error_lines = _extract_error_lines(test, summary)
+                lines.extend(
+                    [
+                        f"  - {format_test_oneline(test)}",
+                        *error_lines,
+                    ]
+                )
     return lines
 
 
+def _error_header(test: GoTestRun) -> str:
+    return f"Error {test.ts.isoformat('T', timespec='seconds')}"
+
+
+def _extract_error_lines(test: GoTestRun, summary: GoTestSummary) -> list[str]:
+    if not test.is_failure:
+        return []
+    error_classification = summary.classifications.get(test.id)
+    classification_lines = [str(error_classification)] if error_classification else []
+    details_lines = [details_short_description(error_classification.details)] if error_classification else []
+    return [
+        "",
+        f"### {_error_header(test)}",
+        *classification_lines,
+        *details_lines,
+        f"```\n{test.output_lines_str}\n```",
+        "",
+    ]
+
+
 def failure_details(summary: GoTestSummary) -> list[str]:
     lines = ["## Failures"]
     for test in summary.results:
@@ -117,8 +174,47 @@ def failure_details(summary: GoTestSummary) -> list[str]:
     return lines
 
 
+def error_table(summary: GoTestSummary) -> list[str]:
+    error_rows: list[dict] = []
+    for test in summary.results:
+        if test.is_failure:
+            anchor = header_to_markdown_link(_error_header(test))
+            row = {
+                "Date": f"[{test.ts.strftime('%Y-%m-%d %H:%M')}]({anchor})",
+                "Env": test.env,
+                "Runtime": f"{test.run_seconds:.2f}s",
+            }
+            error_rows.append(row)
+            if error_cls := summary.classifications.get(test.id):
+                row["Error Class"] = error_cls.error_class
+                row["Details"] = details_short_description(error_cls.details)
+            elif auto_class := GoTestErrorClass.auto_classification(test.output_lines_str):
+                row["Error Class"] = auto_class
+            if "Details" not in row:
+                row["Details"] = details_short_description(parse_error_details(test))
+    if not error_rows:
+        return []
+    headers = sorted(reduce(lambda x, y: x.union(y.keys()), error_rows, set()))
+    return markdown_table_lines("Error Table", error_rows, headers, lambda row: [row.get(key, "") for key in headers])
+
+
 def format_test_oneline(test: GoTestRun) -> str:
-    return f"[{test.status} {test.runtime_human}]({test.url})"  # type: ignore
+    if job_url := test.job_url:
+        return f"[{test.status} {test.runtime_human}]({job_url})"
+    return f"{test.status} {test.runtime_human}"  # type: ignore
+
+
+def header_to_markdown_link(header: str) -> str:
+    """
+    Converts a markdown header to a markdown link anchor.
+    Example:
+        'Error 2025-05-23T00:28:50+00:00' -> '#error-2025-05-23t0028500000'
+    """
+    anchor = header.strip().lower()
+    # Remove all characters except alphanumerics, spaces, and hyphens
+    anchor = re.sub(r"[^a-z0-9 \-]", "", anchor)
+    anchor = anchor.replace(" ", "-")
+    return f"#{anchor}"
 
 
 def create_detailed_summary(
@@ -188,7 +284,7 @@ def create_test_report(
             error_details="",
         )
     envs = {run.env for run in runs if run.env}
-    lines = [summary_line(runs, errors)]
+    lines = [summary_line(runs)]
     if errors:
         env_name_str = f" in {env_name}" if env_name else ""
         lines.append(f"\n\n## Errors Overview{env_name_str}")
@@ -210,18 +306,25 @@ def create_test_report(
     )
 
 
-def summary_line(runs: list[GoTestRun], errors: list[GoTestError]):
+def run_statuses(runs: list[GoTestRun]) -> str:
+    if counter := Counter([run.status for run in runs]):
+        return " ".join(
+            f"{cls}(x {count})" if count > 1 else cls
+            for cls, count in sorted(counter.items(), key=lambda item: item[1], reverse=True)
+        )
+    return ""
+
+
+def summary_line(runs: list[GoTestRun]):
     run_delta = GoTestRun.run_delta(runs)
     envs = {run.env for run in runs if run.env}
     pkg_test_names = {run.name_with_package for run in runs}
-    skipped = sum(run.status == GoTestStatus.SKIP for run in runs)
-    passed = sum(run.status == GoTestStatus.PASS for run in runs)
     envs_str = ", ".join(sorted(envs))
     branches = {run.branch for run in runs if run.branch}
     branches_str = (
         "from " + ", ".join(sorted(branches)) + " branches" if len(branches) > 1 else f"from {branches.pop()} branch"
     )
-    return f"# Found {len(runs)} TestRuns in {envs_str} {run_delta} {branches_str}: {len(pkg_test_names)} unique tests, {len(errors)} Errors, {skipped} Skipped, {passed} Passed"
+    return f"# Found {len(runs)} TestRuns in {envs_str} {run_delta} {branches_str}: {len(pkg_test_names)} unique tests, {run_statuses(runs)}"
 
 
 def error_overview_lines(errors: list[GoTestError], single_indent: str) -> list[str]:
@@ -310,45 +413,38 @@ class TFCITestOutput(Entity):
     )
 
 
-class DailyReportIn(Entity):
-    report_date: datetime
+class RunHistoryFilter(Entity):
     run_history_start: datetime
     run_history_end: datetime
-    env_filter: list[str] = field(default_factory=list)
+    env_filter: list[str] = Field(default_factory=list)
     skip_branch_filter: bool = False
-    skip_columns: set[ErrorRowColumns] = field(default_factory=set)
 
 
-class DailyReportOut(Entity):
-    summary_md: str
-    details_md: str
+class MonthlyReportIn(Entity):
+    name: str
+    branch: str
+    history_filter: RunHistoryFilter
+    skip_columns: set[ErrorRowColumns] = Field(default_factory=set)
+    skip_rows: list[Callable[[TestRow], bool]] = Field(default_factory=list)
+    existing_details_md: dict[str, str] = Field(default_factory=dict)
+    report_paths: MonthlyReportPaths
 
+    @classmethod
+    def skip_skipped(cls, test: TestRow) -> bool:
+        return all(run.is_skipped for runs in test.last_env_runs.values() for run in runs)
 
-def create_daily_report(output: TFCITestOutput, settings: AtlasInitSettings, event: DailyReportIn) -> DailyReportOut:
-    errors = output.found_errors
-    error_classes = {cls.run_id: cls.error_class for cls in output.classified_errors}
-    one_line_summary = summary_line(output.found_tests, errors)
+    @classmethod
+    def skip_if_no_failures(cls, test: TestRow) -> bool:
+        return not any(run.is_failure for runs in test.last_env_runs.values() for run in runs)
 
-    with new_task("Daily Report"):
-        with new_task("Collecting error rows") as task:
-            failure_rows = asyncio.run(_collect_error_rows(errors, error_classes, settings, event, task))
-        if not failure_rows:
-            return DailyReportOut(summary_md=f"🎉All tests passed\n{one_line_summary}", details_md="")
-    columns = ErrorRowColumns.column_names(failure_rows, event.skip_columns)
-    summary_md = [
-        "# Daily Report",
-        one_line_summary,
-        "",
-        "## Errors Table",
-        " | ".join(columns),
-        " | ".join("---" for _ in columns),
-        *(" | ".join(row.as_row(columns)) for row in failure_rows),
-    ]
-    return DailyReportOut(summary_md="\n".join(summary_md), details_md="TODO")
+
+class MonthlyReportOut(Entity):
+    summary_md: str
+    test_details_md: dict[str, str] = Field(default_factory=dict)
 
 
 class ErrorRowColumns(StrEnum):
-    GROUP_NAME = "Group or Package"
+    GROUP_NAME = "Group with Package"
     TEST = "Test"
     ERROR_CLASS = "Error Class"
     DETAILS_SUMMARY = "Details Summary"
@@ -358,7 +454,7 @@ class ErrorRowColumns(StrEnum):
     __ENV_BASED__: ClassVar[list[str]] = [PASS_RATE, TIME_SINCE_PASS]
 
     @classmethod
-    def column_names(cls, rows: list[ErrorRow], skip_columns: set[ErrorRowColumns]) -> list[str]:
+    def column_names(cls, rows: list[TestRow], skip_columns: set[ErrorRowColumns]) -> list[str]:
         if not rows:
             return []
         envs = set()
@@ -371,16 +467,17 @@ class ErrorRowColumns(StrEnum):
 
 
 @total_ordering
-class ErrorRow(Entity):
+class TestRow(Entity):
     group_name: str
     package_url: str
+    full_name: str
     test_name: str
-    error_class: GoTestErrorClass
+    error_classes: list[GoTestErrorClass]
     details_summary: str
     last_env_runs: dict[str, list[GoTestRun]] = field(default_factory=dict)
 
     def __lt__(self, other) -> bool:
-        if not isinstance(other, ErrorRow):
+        if not isinstance(other, TestRow):
             raise TypeError
         return (self.group_name, self.test_name) < (other.group_name, other.test_name)
 
@@ -403,10 +500,20 @@ class ErrorRow(Entity):
                 time_since[env] = "never run"
                 continue
             time_since[env] = next(
-                (run.when for run in sorted(runs, reverse=True) if run.status == GoTestStatus.PASS), "never pass"
+                (run.ts.strftime("%Y-%m-%d") for run in sorted(runs, reverse=True) if run.status == GoTestStatus.PASS),
+                "never pass",
             )
         return time_since
 
+    @property
+    def error_classes_str(self) -> str:
+        if counter := Counter(self.error_classes):
+            return " ".join(
+                f"{cls}(x {count})" if count > 1 else cls
+                for cls, count in sorted(counter.items(), key=lambda item: item[1], reverse=True)
+            )
+        return "No error classes"
+
     def as_row(self, columns: list[str]) -> list[str]:
         values = []
         pass_rates = self.pass_rates
@@ -414,18 +521,23 @@ class ErrorRow(Entity):
         for col in columns:
             match col:
                 case ErrorRowColumns.GROUP_NAME:
-                    values.append(self.group_name or self.package_url or "Unknown Group")
+                    group_part = self.full_name.removesuffix(self.test_name).rstrip("/")
+                    values.append(group_part or "Unknown Group")
                 case ErrorRowColumns.TEST:
                     values.append(self.test_name)
                 case ErrorRowColumns.ERROR_CLASS:
-                    values.append(self.error_class)
+                    values.append(self.error_classes_str)
                 case ErrorRowColumns.DETAILS_SUMMARY:
                     values.append(self.details_summary)
                 case s if s.startswith(ErrorRowColumns.PASS_RATE):
                     env = s.split(" (")[-1].rstrip(")")
                     env_pass_rate = pass_rates.get(env, 0.0)
                     env_run_count = len(self.last_env_runs.get(env, []))
-                    values.append(f"{env_pass_rate:.2%} ({env_run_count} runs)" if env in pass_rates else "N/A")
+                    pass_rate_pct = f"{env_pass_rate:.2%} ({env_run_count} runs)" if env in pass_rates else "N/A"
+                    if pass_rate_pct.startswith("100.00%"):
+                        values.append("always")  # use always to avoid sorting errors, 100% showing before 2%
+                    else:
+                        values.append(pass_rate_pct)
                 case s if s.startswith(ErrorRowColumns.TIME_SINCE_PASS):
                     env = s.split(" (")[-1].rstrip(")")
                     values.append(time_since_pass.get(env, "never passed"))
@@ -435,43 +547,183 @@ class ErrorRow(Entity):
         return values
 
 
-async def _collect_error_rows(
+def create_monthly_report(settings: AtlasInitSettings, event: MonthlyReportIn) -> MonthlyReportOut:
+    with new_task(f"Monthly Report for {event.name} on {event.branch}"):
+        test_rows, detail_files_md = asyncio.run(_collect_monthly_test_rows_and_summaries(settings, event))
+        assert test_rows, "No error rows found for monthly report"
+    columns = ErrorRowColumns.column_names(test_rows, event.skip_columns)
+    skip_rows = (
+        []
+        if event.skip_rows == []
+        else [
+            "",
+            "## Skip Test Filters",
+            *[f"- {method.__name__}" for method in event.skip_rows],
+            "",
+        ]
+    )
+    summary_md = [
+        f"# Monthly Report for {event.name} on {event.branch} from {event.history_filter.run_history_start:%Y-%m-%d} to {event.history_filter.run_history_end:%Y-%m-%d} Found {len(test_rows)} unique Tests",
+        *skip_rows,
+        *markdown_table_lines("Test Run Table", test_rows, columns, lambda row: row.as_row(columns)),
+    ]
+    return MonthlyReportOut(
+        summary_md="\n".join(summary_md),
+        test_details_md=detail_files_md,
+    )
+
+
+class DailyReportIn(Entity):
+    report_date: datetime
+    history_filter: RunHistoryFilter
+    skip_columns: set[ErrorRowColumns] = Field(default_factory=set)
+    row_modifier: Callable[[TestRow, dict[str, str]], dict[str, str]] | None = Field(
+        default=None, description=f"Use the {ErrorRowColumns} to access column-->value mapping"
+    )
+
+
+class DailyReportOut(Entity):
+    summary_md: str
+    details_md: str
+
+
+T = TypeVar("T")
+
+
+def markdown_table_lines(
+    header: str, rows: list[T], columns: list[str], row_to_line: Callable[[T], list[str]], *, header_level: int = 2
+) -> list[str]:
+    if not rows:
+        return []
+    return [
+        f"{'#' * header_level} {header}",
+        "",
+        " | ".join(columns),
+        " | ".join("---" for _ in columns),
+        *(" | ".join(row_to_line(row)) for row in rows),
+        "",
+    ]
+
+
+def create_daily_report(output: TFCITestOutput, settings: AtlasInitSettings, event: DailyReportIn) -> DailyReportOut:
+    errors = output.found_errors
+    error_classes = {cls.run_id: cls.error_class for cls in output.classified_errors}
+    one_line_summary = summary_line(output.found_tests)
+
+    with new_task("Daily Report"):
+        with new_task("Collecting error rows") as task:
+            failure_rows = asyncio.run(
+                _collect_daily_error_rows(errors, error_classes, settings, event.history_filter, task)
+            )
+        if not failure_rows:
+            return DailyReportOut(summary_md=f"🎉All tests passed\n{one_line_summary}", details_md="")
+    columns = ErrorRowColumns.column_names(failure_rows, event.skip_columns)
+
+    def as_md_row(row: TestRow) -> list[str]:
+        if row_modifier := event.row_modifier:
+            row_dict = dict(zip(columns, row.as_row(columns)))
+            row_dict = row_modifier(row, row_dict)
+            return [row_dict[col] for col in columns]
+        return row.as_row(columns)
+
+    summary_md = [
+        f"# Daily Report on {event.report_date:%Y-%m-%d}",
+        one_line_summary,
+        "",
+        *markdown_table_lines("Errors Table", failure_rows, columns, as_md_row),
+    ]
+    return DailyReportOut(summary_md="\n".join(summary_md), details_md="TODO")
+
+
+async def _collect_daily_error_rows(
     errors: list[GoTestError],
     error_classes: dict[str, GoTestErrorClass],
     settings: AtlasInitSettings,
-    event: DailyReportIn,
+    event: RunHistoryFilter,
     task: new_task,
-) -> list[ErrorRow]:
-    error_rows: list[ErrorRow] = []
+) -> list[TestRow]:
+    error_rows: list[TestRow] = []
     dao = await init_mongo_dao(settings)
     for error in errors:
-        package_url = error.run.package_url
-        group_name = error.run.group_name
-        package_url = error.run.package_url or ""
+        test_run = error.run
         error_class = error_classes[error.run_id]
-        branch = error.run.branch
-        branch_filter = []
-        if branch and not event.skip_branch_filter:
-            branch_filter.append(branch)
-        run_history = await dao.read_run_history(
-            test_name=error.run_name,
-            package_url=package_url,
-            group_name=group_name,
-            start_date=event.run_history_start,
-            end_date=event.run_history_end,
-            envs=event.env_filter,
-            branches=branch_filter,
-        )
-        last_env_runs = group_by_once(run_history, key=lambda run: run.env or "unknown-env")
-        error_rows.append(
-            ErrorRow(
-                group_name=group_name,
-                package_url=package_url,
-                test_name=error.run_name,
-                error_class=error_class,
-                details_summary=error.short_description,
-                last_env_runs=last_env_runs,
-            )
-        )
+        summary = error.short_description
+        error_row, _ = await _create_test_row(event, dao, test_run, error_class, summary)
+        error_rows.append(error_row)
         task.update(advance=1)
     return sorted(error_rows)
+
+
+async def _collect_monthly_test_rows_and_summaries(
+    settings: AtlasInitSettings,
+    event: MonthlyReportIn,
+) -> tuple[list[TestRow], dict[str, str]]:
+    dao = await init_mongo_dao(settings)
+    branch = event.branch
+    history_filter = event.history_filter
+    summary_name = event.name
+    skip_rows = event.skip_rows
+    last_day_test_names = await dao.read_tf_tests_for_day(branch, history_filter.run_history_end)
+    test_runs_by_name: dict[str, GoTestRun] = {run.full_name: run for run in last_day_test_names}
+    test_rows = []
+    detail_files_md: dict[str, str] = {}
+    with new_task("Collecting monthly error rows", total=len(last_day_test_names)) as task:
+        for name_with_group, test_run in test_runs_by_name.items():
+            test_row, runs = await _create_test_row(
+                history_filter,
+                dao,
+                test_run,
+            )
+            if any(skip(test_row) for skip in skip_rows):
+                continue
+            test_rows.append(test_row)
+            run_ids = [run.id for run in runs]
+            classifications = await dao.read_error_classifications(run_ids)
+            test_row.error_classes = [cls.error_class for cls in classifications.values()]
+            test_row.details_summary = (
+                f"[{run_statuses(runs)}]({settings.github_ci_summary_details_rel_path(summary_name, name_with_group)})"
+            )
+            if name_with_group not in event.existing_details_md:
+                summary = GoTestSummary(name=name_with_group, results=runs, classifications=classifications)
+                detail_files_md[name_with_group] = test_detail_md(
+                    summary, history_filter.run_history_start, history_filter.run_history_end
+                )
+            task.update(advance=1)
+    return sorted(test_rows), detail_files_md
+
+
+async def _create_test_row(
+    history_filter: RunHistoryFilter,
+    dao: MongoDao,
+    test_run: GoTestRun,
+    error_class: GoTestErrorClass | None = None,
+    summary: str = "",
+) -> tuple[TestRow, list[GoTestRun]]:
+    package_url = test_run.package_url
+    group_name = test_run.group_name
+    package_url = test_run.package_url or ""
+    branch = test_run.branch
+    branch_filter = []
+    test_name = test_run.name
+    if branch and not history_filter.skip_branch_filter:
+        branch_filter.append(branch)
+    run_history = await dao.read_run_history(
+        test_name=test_name,
+        package_url=package_url,
+        group_name=group_name,
+        start_date=history_filter.run_history_start,
+        end_date=history_filter.run_history_end,
+        envs=history_filter.env_filter,
+        branches=branch_filter,
+    )
+    last_env_runs = group_by_once(run_history, key=lambda run: run.env or "unknown-env")
+    error_classes = [error_class] if error_class else []
+    return TestRow(
+        full_name=test_run.full_name,
+        group_name=group_name,
+        package_url=package_url,
+        test_name=test_name,
+        error_classes=error_classes,
+        details_summary=summary,
+        last_env_runs=last_env_runs,
+    ), run_history

atlas_init/cli_tf/go_test_tf_error.py

@@ -23,6 +23,7 @@ class GoTestErrorClass(StrEnum):
     FLAKY_400 = "flaky_400"
     FLAKY_500 = "flaky_500"
     FLAKY_CHECK = "flaky_check"
+    FLAKY_CLIENT = "flaky_client"
     OUT_OF_CAPACITY = "out_of_capacity"
     PROJECT_LIMIT_EXCEEDED = "project_limit_exceeded"
     DANGLING_RESOURCE = "dangling_resource"
@@ -36,6 +37,7 @@ class GoTestErrorClass(StrEnum):
         FLAKY_400: "retry",
         FLAKY_500: "retry",
         FLAKY_CHECK: "retry",
+        FLAKY_CLIENT: "retry",
         PROVIDER_DOWNLOAD: "retry",
         OUT_OF_CAPACITY: "retry_later",
         PROJECT_LIMIT_EXCEEDED: "clean_project",
@@ -46,7 +48,8 @@ class GoTestErrorClass(StrEnum):
     }
     __CONTAINS_MAPPING__ = {
         OUT_OF_CAPACITY: ("OUT_OF_CAPACITY",),
-        FLAKY_500: ("HTTP 500", "UNEXPECTED_ERROR"),
+        FLAKY_500: ("HTTP 500", "UNEXPECTED_ERROR", "503 Service Unavailable"),
+        FLAKY_CLIENT: ("dial tcp: lookup", "i/o timeout"),
         PROVIDER_DOWNLOAD: [
             "mongodbatlas: failed to retrieve authentication checksums for provider",
             "Error: Failed to install provider github.com: bad response",
@@ -65,7 +68,7 @@ class GoTestErrorClass(StrEnum):
             (
                 error_class
                 for error_class, contains_list in cls.__CONTAINS_MAPPING__.items()
-                if all(contains(output, contains_part) for contains_part in contains_list)
+                if any(contains(output, contains_part) for contains_part in contains_list)
             ),
             None,
         )  # type: ignore
@@ -311,16 +314,8 @@ class GoTestError(Entity):
 
     @property
     def short_description(self) -> str:
-        match self.details:
-            case GoTestGeneralCheckError():
-                return str(self.details)
-            case GoTestResourceCheckError():
-                return f"CheckFailure for {self.details.tf_resource_type}.{self.details.tf_resource_name} at Step: {self.details.step_nr} Checks: {self.details.check_numbers_str}"
-            case GoTestAPIError(api_path_normalized=api_path_normalized) if api_path_normalized:
-                return f"API Error {self.details.api_error_code_str} {api_path_normalized}"
-            case GoTestAPIError(api_path=api_path):
-                return f"{self.details.api_error_code_str} {api_path}"
-        return ""
+        details = self.details
+        return details_short_description(details) if details else ""
 
     def header(self, use_ticks: bool = False) -> str:
         name_with_ticks = f"`{self.run.name_with_package}`" if use_ticks else self.run.name_with_package
@@ -329,6 +324,19 @@ class GoTestError(Entity):
         return f"{name_with_ticks}"
 
 
+def details_short_description(details: ErrorDetailsT) -> str:
+    match details:
+        case GoTestGeneralCheckError():
+            return str(details)
+        case GoTestResourceCheckError():
+            return f"CheckFailure for {details.tf_resource_type}.{details.tf_resource_name} at Step: {details.step_nr} Checks: {details.check_numbers_str}"
+        case GoTestAPIError(api_path_normalized=api_path_normalized) if api_path_normalized:
+            return f"API Error {details.api_error_code_str} {api_path_normalized}"
+        case GoTestAPIError(api_path=api_path):
+            return f"{details.api_error_code_str} {api_path}"
+    return ""
+
+
 one_of_methods = "|".join(API_METHODS)