fixed mypy

Author: alexandraBara

nodescraper/plugins/inband/cmdline/cmdline_analyzer.py

@@ -96,7 +96,7 @@ def analyze_data(
         check, missing_required, found_banned = self._compare_cmdline(
             data.cmdline, args.required_cmdline, args.banned_cmdline
         )
-        # if self._compare_cmdline(data.cmdline, args.required_cmdline, args.banned_cmdline):
+
         if check:
             self.result.message = "Kernel cmdline matches expected"
             self.result.status = ExecutionStatus.OK

nodescraper/plugins/inband/dkms/dkms_analyzer.py

@@ -67,6 +67,7 @@ def analyze_data(
         error_state = False
 
         actual_values = []
+        expected_values = []
         for check, accepted_values in check_map.items():
             actual_value = getattr(data, check)
             for accepted_value in accepted_values:
@@ -85,6 +86,7 @@ def analyze_data(
                 elif actual_value == accepted_value:
                     break
             else:
+                expected_values.append(accepted_values)
                 actual_values.append(actual_value)
                 self._log_event(
                     category=EventCategory.SW_DRIVER,
@@ -98,7 +100,7 @@ def analyze_data(
         if error_state:
             self.result.status = ExecutionStatus.ERROR
             self.result.message = (
-                f"DKMS data mismatch. Expected: {accepted_values}, actual: {actual_values}"
+                f"DKMS data mismatch. \nActual: {actual_values}.\nExpected: {expected_values}"
             )
 
         return self.result

nodescraper/resultcollators/tablesummary.py

@@ -23,6 +23,8 @@
 # SOFTWARE.
 #
 ###############################################################################
+from textwrap import wrap
+
 from nodescraper.interfaces import PluginResultCollator
 from nodescraper.models import PluginResult, TaskResult
 
@@ -40,45 +42,114 @@ def collate_results(
             connection_results (list[TaskResult]): list of connection results to collate
         """
 
-        def gen_str_table(headers: list[str], rows: list[list[str | None]]):
-            column_widths = [len(header) for header in headers]
-            for row in rows:
-                for i, cell in enumerate(row):
-                    column_widths[i] = max(
-                        column_widths[i],
-                        len(str(cell)),
-                    )
-            border = f"+{'+'.join('-' * (width + 2) for width in column_widths)}+"
+        def gen_str_table(
+            headers: list[str],
+            rows: list[list[str | None]],
+            max_widths: dict[str, int] | None = None,
+        ) -> str:
+            """
+            Wrap cells.
+            """
+            max_widths = max_widths or {}
+
+            norm_rows: list[list[str]] = [
+                ["" if c is None else str(c) for c in row] for row in rows
+            ]
+
+            ncols = len(headers)
+
+            raw_widths: list[int] = [len(h) for h in headers]
+            for norm_row in norm_rows:
+                for i, cell in enumerate(norm_row):
+                    for part in cell.splitlines() or [""]:
+                        if len(part) > raw_widths[i]:
+                            raw_widths[i] = len(part)
 
-            def gen_row(row):
-                return f"|  {' | '.join(str(cell).ljust(width) for cell, width in zip(row, column_widths, strict=False))} |"
+            target_widths: list[int] = []
+            for i, h in enumerate(headers):
+                cap = max_widths.get(h)
+                if cap is None:
+                    target_widths.append(raw_widths[i])
+                else:
+                    target_widths.append(max(len(h), min(raw_widths[i], cap)))
 
-            table = [border, gen_row(headers), border, *[gen_row(row) for row in rows], border]
-            return "\n".join(table)
+            wrapped_rows: list[list[list[str]]] = []
+            for norm_row in norm_rows:
+                wrapped_cells: list[list[str]] = []
+                for i, cell in enumerate(norm_row):
+                    cell_lines: list[str] = []
+                    paragraphs = cell.splitlines() or [""]
+                    for para in paragraphs:
+                        chunked = wrap(para, width=target_widths[i]) or [""]
+                        cell_lines.extend(chunked)
+                    wrapped_cells.append(cell_lines)
+                wrapped_rows.append(wrapped_cells)
+
+            col_widths: list[int] = []
+            for i in range(ncols):
+                widest_line = len(headers[i])
+                for wrow in wrapped_rows:
+                    for line in wrow[i]:
+                        if len(line) > widest_line:
+                            widest_line = len(line)
+                col_widths.append(widest_line)
+
+            border = "+" + "+".join("-" * (w + 2) for w in col_widths) + "+"
+
+            def render_physical_row(parts: list[str]) -> str:
+                return (
+                    "| "
+                    + " | ".join(p.ljust(w) for p, w in zip(parts, col_widths, strict=False))
+                    + " |"
+                )
+
+            table_lines: list[str] = [border, render_physical_row(headers), border]
+            for wrow in wrapped_rows:
+                height = max(len(cell_lines) for cell_lines in wrow)
+                for idx in range(height):
+                    parts = [
+                        (wrow[col][idx] if idx < len(wrow[col]) else "") for col in range(ncols)
+                    ]
+                    table_lines.append(render_physical_row(parts))
+            table_lines.append(border)
+            return "\n".join(table_lines)
 
         tables = ""
         if connection_results:
-            rows = []
+            # Allow Optional[str] elements
+            conn_rows: list[list[str | None]] = []
             for connection_result in connection_results:
-                rows.append(
+                conn_rows.append(
                     [
                         connection_result.task,
                         connection_result.status.name,
                         connection_result.message,
                     ]
                 )
 
-            table = gen_str_table(["Connection", "Status", "Message"], rows)
+            table = gen_str_table(
+                ["Connection", "Status", "Message"],
+                conn_rows,
+                max_widths={"Connection": 32, "Status": 16, "Message": 80},
+            )
             tables += f"\n\n{table}"
 
         if plugin_results:
-            rows = []
+            # Allow Optional[str] elements
+            plug_rows: list[list[str | None]] = []
             for plugin_result in plugin_results:
-                rows.append(
-                    [plugin_result.source, plugin_result.status.name, plugin_result.message]
+                plug_rows.append(
+                    [
+                        plugin_result.source,
+                        plugin_result.status.name,
+                        plugin_result.message,
+                    ]
                 )
-
-            table = gen_str_table(["Plugin", "Status", "Message"], rows)
+            table = gen_str_table(
+                ["Plugin", "Status", "Message"],
+                plug_rows,
+                max_widths={"Plugin": 32, "Status": 16, "Message": 80},
+            )
             tables += f"\n\n{table}"
 
         if tables: