some fixes to accomodate for user input + printout fixes to package analyzer

Author: alexandraBara

nodescraper/plugins/inband/bios/bios_analyzer.py

@@ -75,7 +75,7 @@ def analyze_data(
                     self.result.message = "Bios data matches expected"
                     self.result.status = ExecutionStatus.OK
                     return self.result
-            elif data.bios_version == bios_version:
+            elif data.bios_version == str(bios_version).strip():
                 self.result.message = "Bios data matches expected"
                 self.result.status = ExecutionStatus.OK
                 return self.result

nodescraper/plugins/inband/dkms/dkms_analyzer.py

@@ -83,7 +83,7 @@ def analyze_data(
                         )
                     if regex_data.match(actual_value):
                         break
-                elif actual_value == accepted_value:
+                elif actual_value == str(accepted_value).strip():
                     break
             else:
                 expected_values.append(accepted_values)

nodescraper/plugins/inband/kernel/kernel_analyzer.py

@@ -72,7 +72,7 @@ def analyze_data(
                     self.result.message = "Kernel matches expected"
                     self.result.status = ExecutionStatus.OK
                     return self.result
-            elif data.kernel_version == kernel:
+            elif data.kernel_version == str(kernel).strip():
                 self.result.message = "Kernel matches expected"
                 self.result.status = ExecutionStatus.OK
                 return self.result

nodescraper/plugins/inband/os/os_analyzer.py

@@ -54,8 +54,8 @@ def analyze_data(self, data: OsDataModel, args: Optional[OsAnalyzerArgs] = None)
             return self.result
 
         for os_name in args.exp_os:
-            if (os_name == data.os_name and args.exact_match) or (
-                os_name in data.os_name and not args.exact_match
+            if (str(os_name).strip() == data.os_name and args.exact_match) or (
+                str(os_name).strip() in data.os_name and not args.exact_match
             ):
                 self.result.message = "OS name matches expected"
                 self.result.status = ExecutionStatus.OK

nodescraper/plugins/inband/package/package_analyzer.py

@@ -58,6 +58,7 @@ def regex_version_data(
 
         value_found = False
         for name, version in package_data.items():
+            self.logger.debug("Package data: %s, %s", name, version)
             key_search_res = key_search.search(name)
             if key_search_res:
                 value_found = True
@@ -79,16 +80,16 @@ def regex_version_data(
         return value_found
 
     def package_regex_search(
-        self, package_data: dict[str, str], exp_packge_data: dict[str, Optional[str]]
+        self, package_data: dict[str, str], exp_package_data: dict[str, Optional[str]]
     ):
         """Searches the package data for the expected package and version using regex
 
         Args:
             package_data (dict[str, str]): a dictionary of package names and versions
-            exp_packge_data (dict[str, Optional[str]]): a dictionary of expected package names and versions
+            exp_package_data (dict[str, Optional[str]]): a dictionary of expected package names and versions
         """
         not_found_keys = []
-        for exp_key, exp_value in exp_packge_data.items():
+        for exp_key, exp_value in exp_package_data.items():
             try:
                 if exp_value is not None:
                     value_search = re.compile(exp_value)
@@ -125,44 +126,46 @@ def package_regex_search(
         return not_found_keys
 
     def package_exact_match(
-        self, package_data: dict[str, str], exp_packge_data: dict[str, Optional[str]]
+        self, package_data: dict[str, str], exp_package_data: dict[str, Optional[str]]
     ):
         """Checks the package data for the expected package and version using exact match
 
         Args:
             package_data (dict[str, str]): a dictionary of package names and versions
-            exp_packge_data (dict[str, Optional[str]]): a dictionary of expected package names and versions
+            exp_package_data (dict[str, Optional[str]]): a dictionary of expected package names and versions
         """
         not_found_match = []
         not_found_version = []
-        for exp_key, exp_value in exp_packge_data.items():
-            self.logger.info(exp_key)
+        for exp_key, exp_value in exp_package_data.items():
+            self.logger.info("Expected value: %s, %s", exp_key, exp_value)
             version = package_data.get(exp_key)
-            if exp_value is None:
+            self.logger.info("Found version: %s", version)
+            if version is None:
+                # package not found
+                not_found_version.append((exp_key, exp_value))
+                self._log_event(
+                    EventCategory.APPLICATION,
+                    f"Package {exp_key} not found in the package list",
+                    EventPriority.ERROR,
+                    {
+                        "expected_package": exp_key,
+                        "found_package": None,
+                        "expected_version": exp_value,
+                        "found_version": None,
+                    },
+                )
+            elif exp_value is None:
                 # allow any version when expected version is None
-                if version is None:
-                    # package not found
-                    not_found_version.append((exp_key, version))
-                    self._log_event(
-                        EventCategory.APPLICATION,
-                        f"Package {exp_key} not found in the package list",
-                        EventPriority.ERROR,
-                        {
-                            "expected_package": exp_key,
-                            "found_package": None,
-                            "expected_version": exp_value,
-                            "found_version": None,
-                        },
-                    )
-            elif version != exp_value:
+                continue
+            elif version != str(exp_value).strip():
                 not_found_match.append((exp_key, version))
                 self._log_event(
                     EventCategory.APPLICATION,
-                    f"Package {exp_key} Version Mismatch, Expected {exp_key} but found {version}",
+                    f"Package {exp_key} Version Mismatch, Expected {exp_value} but found {version}",
                     EventPriority.ERROR,
                     {
                         "expected_package": exp_key,
-                        "found_package": exp_key if version else None,
+                        "found_package": exp_key,
                         "expected_version": exp_value,
                         "found_version": version,
                     },
@@ -191,6 +194,7 @@ def analyze_data(
             self.result.message = f"Packages not found: {not_found_keys}"
             self.result.status = ExecutionStatus.ERROR
         else:
+            self.logger.info("Expected packages: %s", list(args.exp_package_ver.keys()))
             not_found_match, not_found_version = self.package_exact_match(
                 data.version_info, args.exp_package_ver
             )

nodescraper/plugins/inband/rocm/rocm_analyzer.py

@@ -58,13 +58,13 @@ def analyze_data(
             return self.result
 
         for rocm_version in args.exp_rocm:
-            if data.rocm_version == rocm_version:
+            if data.rocm_version == str(rocm_version).strip():
                 self.result.message = "ROCm version matches expected"
                 self.result.status = ExecutionStatus.OK
                 return self.result
 
         self.result.message = (
-            f"ROCm version mismatch! Expected: {rocm_version}, actual: {args.exp_rocm}"
+            f"ROCm version mismatch! Expected: {args.exp_rocm}, actual: {data.rocm_version}"
         )
         self.result.status = ExecutionStatus.ERROR
         self._log_event(

nodescraper/plugins/inband/storage/storage_analyzer.py

@@ -66,7 +66,7 @@ def _matches_device_filter(
                     continue
                 if device_regex.match(device_name):
                     return True
-            elif device_name == exp_device:
+            elif device_name == str(exp_device).strip():
                 return True
         return False