feat(spack_operation): implement setup_spack_env functionality

Following changes have been incorporated:

• SpackOperation.py: The handle_result and trust_gpg_key methods were specifically updated with tests and docstrings. Also modified the add_mirror method as per the changes.
• SpackOperationUseCache.py: Similar to SpackOperation.py, this file also got enhanced tests and docstrings, specifically for the setup_spack_env method. The focus is on setting up the environment for a user spack cache setup along with testing of the caching behavior and improving documentation.
• BuildCacheManager.py: This file saw improvements in its test suite and the addition of docstrings. The tests likely cover various cache operations, and the docstrings explain the purpose and usage of the cache management methods. The get_public_key_from_cache, download, _log_warning_if_needed, and other methods were updated with tests and docstrings.
• .gitlab-ci.yml: Changes likely include adding or modifying stages for running the new pytest tests and generating coverage reports.
• pyproject.toml: This file was modified to add testing dependencies required for the enhanced test suite. Specifically, pytest, pytest-mock, pytest-ordering, and coverage were added under the test extra. This change enables running the new tests and generating coverage reports.

The commands folder implements a command execution and management system, especially for Spack, using these key components and patterns:

• Command Definitions (Enum/Constants): command_enum.py likely defines an enumeration (or constants) representing different commands. This promotes type safety and avoids stringly-typed code.

• Command Sequence Builder: command_sequence_builder.py implements the Builder Pattern to construct CommandSequence objects (from command_sequence.py). This allows for flexible and readable creation of complex command sequences.

• Command Sequence: command_sequence.py represents a sequence of commands to be executed. It encapsulates the order and configuration of commands.

• Spack Command Factory: spack_command_sequence_factory.py uses the Factory Pattern to create Spack-specific CommandSequence objects. This centralizes the creation logic for different Spack commands and simplifies their usage. It likely uses command_sequence_builder.py internally.

• Generic Command Runner: A command_runner.py (implied, not explicitly mentioned in the diff) likely handles the actual execution of commands, possibly using subprocesses. This abstracts the execution details from the command sequence logic.

• Bash Command Executor: Executes a sequence of commands in a Bash shell, handling various potential errors and returning the output and error message (if any).

• Focus on Spack: The structure strongly suggests a focus on managing Spack environments and packages. The factory and command definitions likely reflect common Spack operations.

Patterns used:

• Enum/Constants Pattern: Used for defining distinct command types.
• Builder Pattern: Used for constructing command sequences.
• Factory Pattern: Used for creating Spack-specific command sequences.
• Command Pattern: A close variant of the Command Pattern for encapsulating command execution. Abstraction of shell commands along with an invoker (command_runner) been implemented

Parent artefact: https://tvb-projects.atlassian.net/browse/VT-70

dedal/build_cache/BuildCacheManager.py

+import glob
 import os
-import time
+from os.path import join
+from pathlib import Path
 
 import oras.client
-from pathlib import Path
 
 from dedal.build_cache.BuildCacheManagerInterface import BuildCacheManagerInterface
 from dedal.logger.logger_builder import get_logger
-from dedal.utils.utils import clean_up
 
 
 class BuildCacheManager(BuildCacheManagerInterface):
@@ -113,7 +113,49 @@ class BuildCacheManager(BuildCacheManagerInterface):
         if tags is not None:
             try:
                 self._client.delete_tags(self._oci_registry_path, tags)
-                self._logger.info(f"Successfully deleted all artifacts form OCI registry.")
+                self._logger.info("Successfully deleted all artifacts form OCI registry.")
             except RuntimeError as e:
                 self._logger.error(
                     f"Failed to delete artifacts: {e}")
+
+    def __log_warning_if_needed(self, warn_message: str, items: list[str]) -> None:
+        """Logs a warning message if the number of items is greater than 1. (Private function)
+
+            This method logs a warning message using the provided message and items if the list of items has more than one element.
+
+        Args:
+            warn_message (str): The warning message to log.
+            items (list[str]): The list of items to include in the log message.
+        """
+        if len(items) > 1:
+            self._logger.warning(warn_message, items, items[0])
+
+    def get_public_key_from_cache(self, build_cache_dir: str | None) -> str | None:
+        """Retrieves the public key from the build cache.
+
+            This method searches for the public key within the specified build cache directory.
+
+        Args:
+            build_cache_dir (str | None): The path to the build cache directory.
+
+        Returns:
+            str | None: The path to the public key file if found, otherwise None.
+        """
+
+        if not build_cache_dir or not os.path.exists(build_cache_dir):
+            self._logger.warning("Build cache directory does not exist!")
+            return None
+        pgp_folders = glob.glob(f"{build_cache_dir}/**/_pgp", recursive=True)
+        if not pgp_folders:
+            self._logger.warning("No _pgp folder found in the build cache!")
+            return None
+        self.__log_warning_if_needed(
+            "More than one PGP folders found in the build cache: %s, using the first one in the list: %s", pgp_folders)
+        pgp_folder = pgp_folders[0]
+        key_files = glob.glob(join(pgp_folder, "**"))
+        if not key_files:
+            self._logger.warning("No PGP key files found in the build cache!")
+            return None
+        self.__log_warning_if_needed(
+            "More than one PGP key files found in the build cache: %s, using the first one in the list: %s", key_files)
+        return key_files[0]