Used command output instead of exceptions

Author: bajertom

tmt/package_managers/__init__.py

@@ -270,6 +270,16 @@ def check_presence(self, *installables: Installable) -> dict[Installable, bool]:
 
         raise NotImplementedError
 
+    def extract_package_name_from_package_manager_output(self, output: str) -> Iterator[str]:
+        """
+        Extract failed package names from package manager error output.
+
+        :param output: Error output (stdout or stderr) from the package manager.
+        :returns: An iterator of package names that failed to install.
+        """
+
+        raise NotImplementedError
+
     def install(
         self,
         *installables: Installable,

tmt/package_managers/apk.py

@@ -1,4 +1,5 @@
 import re
+from collections.abc import Iterator
 from typing import Optional, Union
 
 import tmt.utils
@@ -34,6 +35,11 @@
 }
 
 
+# Compiled regex patterns for APK error messages
+_UNABLE_TO_LOCATE_PATTERN = re.compile(r'unable to locate package\s+([^\s]+)', re.IGNORECASE)
+_NO_SUCH_PACKAGE_PATTERN = re.compile(r'ERROR:\s+([^\s:]+):\s+No such package', re.IGNORECASE)
+
+
 class ApkEngine(PackageManagerEngine):
     install_command = Command('add')
 
@@ -189,3 +195,11 @@ def install_debuginfo(
         options: Optional[Options] = None,
     ) -> CommandOutput:
         raise tmt.utils.GeneralError("There is no support for debuginfo packages in apk.")
+
+    def extract_package_name_from_package_manager_output(self, output: str) -> Iterator[str]:
+        """
+        Extract failed package names from APK error output.
+        """
+        for pattern in [_UNABLE_TO_LOCATE_PATTERN, _NO_SUCH_PACKAGE_PATTERN]:
+            for match in pattern.finditer(output):
+                yield match.group(1)

tmt/package_managers/apt.py

@@ -1,4 +1,5 @@
 import re
+from collections.abc import Iterator
 from typing import Optional, Union
 
 import tmt.utils
@@ -79,6 +80,13 @@
 """  # noqa: E501
 
 
+# Compiled regex patterns for APT error messages
+_UNABLE_TO_LOCATE_PATTERN = re.compile(r'Unable to locate package\s+([^\s]+)', re.IGNORECASE)
+_E_UNABLE_TO_LOCATE_PATTERN = re.compile(
+    r'E:\s+Unable to locate package\s+([^\s]+)', re.IGNORECASE
+)
+
+
 class AptEngine(PackageManagerEngine):
     install_command = Command('install')
 
@@ -281,3 +289,11 @@ def install_debuginfo(
         options: Optional[Options] = None,
     ) -> CommandOutput:
         raise tmt.utils.GeneralError("There is no support for debuginfo packages in apt.")
+
+    def extract_package_name_from_package_manager_output(self, output: str) -> Iterator[str]:
+        """
+        Extract failed package names from APT error output.
+        """
+        for pattern in [_UNABLE_TO_LOCATE_PATTERN, _E_UNABLE_TO_LOCATE_PATTERN]:
+            for match in pattern.finditer(output):
+                yield match.group(1)

tmt/package_managers/dnf.py

@@ -1,4 +1,5 @@
 import re
+from collections.abc import Iterator
 from typing import TYPE_CHECKING, Any, Optional, cast
 
 from tmt._compat.pathlib import Path
@@ -201,6 +202,13 @@ def create_repository(self, directory: Path) -> ShellScript:
         return ShellScript(f"createrepo {directory}")
 
 
+# Compiled regex patterns for DNF/YUM error messages
+_NO_PACKAGE_PROVIDES_PATTERN = re.compile(r'no package provides\s+([^\s\n]+)', re.IGNORECASE)
+_UNABLE_TO_FIND_MATCH_PATTERN = re.compile(r'Unable to find a match:\s+([^\s\n]+)', re.IGNORECASE)
+_NO_MATCH_FOR_ARGUMENT_PATTERN = re.compile(r'No match for argument:\s+([^\s\n]+)', re.IGNORECASE)
+_NO_PACKAGE_AVAILABLE_PATTERN = re.compile(r'No package\s+([^\s\n]+)\s+available', re.IGNORECASE)
+
+
 # ignore[type-arg]: TypeVar in package manager registry annotations is
 # puzzling for type checkers. And not a good idea in general, probably.
 @provides_package_manager('dnf')  # type: ignore[arg-type]
@@ -260,6 +268,19 @@ def check_presence(self, *installables: Installable) -> dict[Installable, bool]:
 
         return results
 
+    def extract_package_name_from_package_manager_output(self, output: str) -> Iterator[str]:
+        """
+        Extract failed package names from DNF/YUM error output.
+        """
+        for pattern in [
+            _NO_PACKAGE_PROVIDES_PATTERN,
+            _UNABLE_TO_FIND_MATCH_PATTERN,
+            _NO_MATCH_FOR_ARGUMENT_PATTERN,
+            _NO_PACKAGE_AVAILABLE_PATTERN,
+        ]:
+            for match in pattern.finditer(output):
+                yield match.group(1)
+
 
 class Dnf5Engine(DnfEngine):
     _base_command = Command('dnf5')

tmt/steps/discover/__init__.py

@@ -281,21 +281,24 @@ def required_tests(self) -> list[TestOrigin]:
         return tests
 
     @property
-    def dependencies_to_tests(self) -> dict[str, list[str]]:
+    def dependencies_to_tests(self) -> tuple[dict[str, list[str]], dict[str, list[str]]]:
         """
-        Dictionary mapping dependencies to tests.
+        A tuple containing two dictionaries mapping dependencies to tests (required & recommended)
         """
 
-        dependencies_to_tests: dict[str, list[str]] = {}
+        required_dependencies_to_tests: dict[str, list[str]] = {}
+        recommended_dependencies_to_tests: dict[str, list[str]] = {}
 
         for test_origin in self.tests(enabled=True):
             test = test_origin.test
             test_name = test.name
-            # Collect all dependencies (required + recommended)
-            for dependency in [*test.require, *test.recommend]:
-                dependencies_to_tests.setdefault(str(dependency), []).append(test_name)
+            # Collect dependencies separately for required and recommended
+            for dependency in test.require:
+                required_dependencies_to_tests.setdefault(str(dependency), []).append(test_name)
+            for dependency in test.recommend:
+                recommended_dependencies_to_tests.setdefault(str(dependency), []).append(test_name)
 
-        return dependencies_to_tests
+        return required_dependencies_to_tests, recommended_dependencies_to_tests
 
     def load(self) -> None:
         """

tmt/steps/prepare/__init__.py

@@ -221,61 +221,6 @@ def summary(self) -> None:
         preparations = fmf.utils.listed(self.preparations_applied, 'preparation')
         self.info('summary', f'{preparations} applied', 'green', shift=1)
 
-    def _extract_failed_packages(self, exceptions: list[Exception]) -> set[str]:
-        """
-        Extract package names from installation exceptions.
-
-        Returns a list of package names that failed to install.
-        """
-
-        failed_packages: set[str] = set()
-        import re
-
-        for exc in exceptions:
-            # Extract failed packages from RunError stderr/stdout
-            if isinstance(exc, tmt.utils.RunError):
-                error_text = ''
-                if exc.stderr:
-                    error_text += exc.stderr + '\n'
-                if exc.stdout:
-                    error_text += exc.stdout
-
-                if error_text:
-                    # dnf, dnf5, yum, apt, apk specific patterns
-                    patterns = [
-                        r'no package provides\s+([^\s\n]+)',
-                        r'Unable to find a match:\s+([^\s\n]+)',
-                        r'No match for argument:\s+([^\s\n]+)',
-                        r'No package\s+([^\s\n]+)\s+available',
-                        r'Unable to locate package\s+([^\s]+)',
-                        r'E:\s+Unable to locate package\s+([^\s]+)',
-                    ]
-
-                    for pattern in patterns:
-                        matches = re.findall(pattern, error_text, re.IGNORECASE)
-                        failed_packages.update(matches)
-
-        return failed_packages
-
-    def _show_failed_packages_with_tests(self, failed_packages: set[str]) -> None:
-        """
-        Show failed packages and which tests require them.
-        """
-
-        # Get test dependencies from discover step
-        dependencies_to_tests = self.plan.discover.dependencies_to_tests
-
-        # Show failed packages with their associated tests
-        self.info('')
-        self.info('failed packages', '', 'red', shift=1)
-
-        for failed_package in failed_packages:
-            matching_tests = []
-            if failed_package in dependencies_to_tests:
-                matching_tests = dependencies_to_tests[failed_package]
-            sorted_matching_tests = ', '.join(sorted(matching_tests))
-            self.info(failed_package, f'required by {sorted_matching_tests}', color='red', shift=2)
-
     def go(self, force: bool = False) -> None:
         """
         Prepare the guests
@@ -553,9 +498,7 @@ def _record_exception(
         self._save_results(self.results)
 
         if exceptions:
-            failed_packages = self._extract_failed_packages(exceptions)
-            if failed_packages:
-                self._show_failed_packages_with_tests(failed_packages)
+            # TODO: needs a better message...
             raise tmt.utils.PrepareError(
                 'prepare step failed',
                 causes=exceptions,