orionis 0.314.0__py3-none-any.whl → 0.316.0__py3-none-any.whl

orionis/test/suite/test_unit.py

@@ -11,13 +11,7 @@ from contextlib import redirect_stdout, redirect_stderr
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
-from rich.console import Console as RichConsole
-from rich.live import Live
-from rich.panel import Panel
-from rich.syntax import Syntax
-from rich.table import Table
-from rich.text import Text
-from orionis.console.output.console import Console
+from orionis.services.system.workers import Workers
 from orionis.test.entities.test_result import TestResult
 from orionis.test.enums.test_mode import ExecutionMode
 from orionis.test.enums.test_status import TestStatus
@@ -26,484 +20,575 @@ from orionis.test.exceptions.test_persistence_error import OrionisTestPersistenc
 from orionis.test.exceptions.test_value_error import OrionisTestValueError
 from orionis.test.logs.history import TestHistory
 from orionis.test.contracts.test_unit import IUnitTest
+from orionis.test.output.printer import TestPrinter
 from orionis.test.view.render import TestingResultRender
 
 class UnitTest(IUnitTest):
     """
-    UnitTest is a comprehensive testing utility class for discovering, configuring, and executing unit tests.
-
-    This class supports both sequential and parallel test execution, customizable verbosity, fail-fast behavior,
-    and rich output formatting using the `rich` library.
-
-    Attributes
-    ----------
-    loader : unittest.TestLoader
-        The test loader used to discover and load tests.
-    suite : unittest.TestSuite
-        The test suite containing the discovered tests.
-    test_results : list of TestResult
-        A list to store the results of executed tests.
-    start_time : float
-        The start time of the test execution.
-    print_result : bool
-        Flag to determine whether to print test results.
-    verbosity : int
-        The verbosity level for test output.
-    execution_mode : str
-        The mode of test execution (e.g., 'SEQUENTIAL' or 'PARALLEL').
-    max_workers : int
-        The maximum number of workers for parallel execution.
-    fail_fast : bool
-        Flag to stop execution on the first failure.
-    rich_console : RichConsole
-        Console for rich text output.
-    orionis_console : Console
-        Console for standard output.
-    discovered_tests : list
-        A list to store discovered test cases.
-    width_output_component : int
-        The width of the table for displaying results.
-    throw_exception : bool
-        Flag to determine whether to throw exceptions on test failures.
-    persistent : bool
-        Flag to determine whether to persist test results in a database.
-    base_path : str
-        The base directory for test discovery and persistence.
+    Orionis UnitTest
+
+    The main class of the Orionis framework for advanced unit test management.
+
+    This class provides a comprehensive solution for discovering, executing, and reporting unit tests in a flexible and configurable way, surpassing the usual limitations of traditional frameworks.
+    It supports sequential or parallel execution, filtering by name or tags, and detailed result capture, including timings, errors, and tracebacks.
+
+    It includes persistence options in multiple formats (SQLite or JSON) and generates rich reports both in the console and on the web.
+    Its intuitive interface and high degree of customization make it easy to integrate into CI/CD pipelines and adapt to the specific needs of any project.
+
+    This is an especially suitable choice for those seeking greater robustness, traceability, and visibility in their automated testing processes, offering advantages often missing from other alternatives.
     """
 
     def __init__(self) -> None:
         """
-        Initialize the UnitTest instance with default configurations.
+        Initializes the test suite configuration and supporting components.
 
         Parameters
         ----------
-        self : UnitTest
-            The instance of the UnitTest class.
+        None
 
         Attributes
         ----------
-        loader : unittest.TestLoader
-            The test loader used to discover tests.
-        suite : unittest.TestSuite
-            The test suite to hold the discovered tests.
-        test_results : list of TestResult
-            A list to store the results of executed tests.
-        start_time : float
-            The start time of the test execution.
-        print_result : bool
-            Flag to determine whether to print test results.
         verbosity : int
-            The verbosity level for test output.
+            Level of verbosity for test output.
         execution_mode : str
-            The mode of test execution (e.g., 'SEQUENTIAL' or 'PARALLEL').
+            Mode in which tests are executed.
         max_workers : int
-            The maximum number of workers for parallel execution.
+            Maximum number of worker threads/processes.
         fail_fast : bool
-            Flag to stop execution on the first failure.
-        rich_console : RichConsole
-            Console for rich text output.
-        orionis_console : Console
-            Console for standard output.
-        discovered_tests : list
-            A list to store discovered test cases.
-        width_output_component : int
-            The width of the table for displaying results.
+            Whether to stop on the first test failure.
+        print_result : bool
+            Whether to print test results to the console.
         throw_exception : bool
-            Flag to determine whether to throw exceptions on test failures.
+            Whether to raise exceptions on test failures.
         persistent : bool
-            Flag to determine whether to persist test results in a database.
+            Whether to use persistent storage for test results.
+        persistent_driver : str
+            Driver used for persistent storage.
+        web_report : bool
+            Whether to generate a web-based report.
+        full_path : Optional[str]
+            Full path for test discovery.
+        folder_path : str
+            Folder path for test discovery.
         base_path : str
-            The base directory for test discovery and persistence.
+            Base path for test discovery.
+        pattern : str
+            Pattern to match test files.
+        test_name_pattern : Optional[str]
+            Pattern to match test names.
+        tags : Optional[List[str]]
+            Tags to filter tests.
+        module_name : str
+            Name of the module for test discovery.
+        loader : unittest.TestLoader
+            Loader for discovering tests.
+        suite : unittest.TestSuite
+            Test suite to hold discovered tests.
+        discovered_tests : list
+            List of discovered tests.
+        printer : TestPrinter
+            Utility for printing test results to the console.
+        __output_buffer
+            Buffer for capturing standard output during tests.
+        __error_buffer
+            Buffer for capturing error output during tests.
+        __result
+            Result of the test execution.
         """
+
+        # Values for configuration
+        self.verbosity: int
+        self.execution_mode: str
+        self.max_workers: int
+        self.fail_fast: bool
+        self.print_result: bool
+        self.throw_exception: bool
+        self.persistent: bool
+        self.persistent_driver: str
+        self.web_report: bool
+
+        # Values for discovering tests in folders
+        self.full_path: Optional[str]
+        self.folder_path: str
+        self.base_path: str
+        self.pattern: str
+        self.test_name_pattern: Optional[str]
+        self.tags: Optional[List[str]]
+
+        # Values for discovering tests in modules
+        self.module_name: str
+        self.test_name_pattern: Optional[str]
+
+        # Initialize the test loader and suite
         self.loader = unittest.TestLoader()
         self.suite = unittest.TestSuite()
-        self.test_results: List[TestResult] = []
-        self.start_time: float = 0.0
-        self.print_result: bool = True
-        self.verbosity: int = 2
-        self.execution_mode: str = ExecutionMode.SEQUENTIAL.value
-        self.max_workers: int = 4
-        self.fail_fast: bool = False
-        self.rich_console = RichConsole()
-        self.orionis_console = Console()
         self.discovered_tests: List = []
-        self.width_output_component: int = int(self.rich_console.width * 0.75)
-        self.throw_exception: bool = False
-        self.persistent: bool = False
-        self.persistent_driver: str = 'sqlite'
-        self.web_report: bool = False
-        self.base_path: str = "tests"
-        self.withliveconsole: bool = True
+
+        # Initialize the class for printing in the console
+        self.printer = TestPrinter()
+
+        # Variables for capturing output and error streams
         self.__output_buffer = None
         self.__error_buffer = None
+
+        # Result of the test execution
         self.__result = None
 
     def configure(
             self,
             *,
-            verbosity: int = None,
-            execution_mode: str | ExecutionMode = None,
-            max_workers: int = None,
-            fail_fast: bool = None,
-            print_result: bool = None,
+            verbosity: int = 2,
+            execution_mode: str | ExecutionMode = ExecutionMode.SEQUENTIAL,
+            max_workers: int = Workers().calculate(),
+            fail_fast: bool = False,
+            print_result: bool = True,
             throw_exception: bool = False,
             persistent: bool = False,
             persistent_driver: str = 'sqlite',
             web_report: bool = False
         ) -> 'UnitTest':
         """
-        Configures the UnitTest instance with the specified parameters.
+        Configure the UnitTest instance with various execution and reporting options.
 
         Parameters
         ----------
         verbosity : int, optional
-            The verbosity level for test output. If None, the current setting is retained.
+            Level of output verbosity.
         execution_mode : str or ExecutionMode, optional
-            The mode in which the tests will be executed ('SEQUENTIAL' or 'PARALLEL'). If None, the current setting is retained.
+            Test execution mode.
         max_workers : int, optional
-            The maximum number of workers to use for parallel execution. If None, the current setting is retained.
+            Maximum number of worker threads/processes for parallel execution. Must be a positive integer.
         fail_fast : bool, optional
-            Whether to stop execution upon the first failure. If None, the current setting is retained.
+            If True, stop execution on first failure.
         print_result : bool, optional
-            Whether to print the test results after execution. If None, the current setting is retained.
-        throw_exception : bool, optional
-            Whether to throw an exception if any test fails. Defaults to False.
-        persistent : bool, optional
-            Whether to persist the test results in a database. Defaults to False.
-        persistent_driver : str, optional
-            The driver to use for persistent storage. Defaults to 'sqlite'.
+            If True, print test results to the console.
+        throw_exception : bool, default: False
+            If True, raise exceptions on test failures.
+        persistent : bool, default: False
+            If True, enable persistent storage of test results.
+        persistent_driver : str, default: 'sqlite'
+            Backend for persistent storage. Must be 'sqlite' or 'json'.
+        web_report : bool, default: False
+            If True, enable web-based reporting.
 
         Returns
         -------
         UnitTest
             The configured UnitTest instance.
+
+        Raises
+        ------
+        OrionisTestValueError
+            If any parameter value is invalid.
         """
+
+        # Validate and set verbosity
         if verbosity is not None:
-            self.verbosity = verbosity
+            if isinstance(verbosity, int) and verbosity in [0, 1, 2]:
+                self.verbosity = verbosity
+            else:
+                raise OrionisTestValueError("Verbosity must be an integer: 0 (quiet), 1 (default), or 2 (verbose).")
 
+        # Validate and set execution mode
         if execution_mode is not None and isinstance(execution_mode, ExecutionMode):
             self.execution_mode = execution_mode.value
         else:
-            self.execution_mode = execution_mode
+            if isinstance(execution_mode, str) and execution_mode in [ExecutionMode.SEQUENTIAL.value, ExecutionMode.PARALLEL.value]:
+                self.execution_mode = execution_mode
+            else:
+                raise OrionisTestValueError("Execution mode must be 'SEQUENTIAL' or 'PARALLEL'.")
 
+        # Validate and set max_workers
         if max_workers is not None:
-            self.max_workers = max_workers
+            if isinstance(max_workers, int) and max_workers > 0:
+                self.max_workers = max_workers
+            else:
+                raise OrionisTestValueError("Max workers must be a positive integer.")
 
+        # Validate and set other parameters
         if fail_fast is not None:
-            self.fail_fast = fail_fast
+            if isinstance(fail_fast, bool):
+                self.fail_fast = fail_fast
+            else:
+                raise OrionisTestValueError("Fail fast must be a boolean value.")
 
+        # Validate and set print_result
         if print_result is not None:
-            self.print_result = print_result
+            if isinstance(print_result, bool):
+                self.print_result = print_result
+            else:
+                raise OrionisTestValueError("Print result must be a boolean value.")
 
+        # Validate and set throw_exception
         if throw_exception is not None:
-            self.throw_exception = throw_exception
+            if isinstance(throw_exception, bool):
+                self.throw_exception = throw_exception
+            else:
+                raise OrionisTestValueError("Throw exception must be a boolean value.")
 
+        # Validate and set persistent and persistent_driver
         if persistent is not None:
-            self.persistent = persistent
+            if isinstance(persistent, bool):
+                self.persistent = persistent
+            else:
+                raise OrionisTestValueError("Persistent must be a boolean value.")
 
+        # Validate and set persistent_driver
         if persistent_driver is not None:
-            self.persistent_driver = persistent_driver
+            if isinstance(persistent_driver, str) and persistent_driver in ['sqlite', 'json']:
+                self.persistent_driver = persistent_driver
+            else:
+                raise OrionisTestValueError("Persistent driver must be 'sqlite' or 'json'.")
 
+        # Validate and set web_report
         if web_report is not None:
-            self.web_report = web_report
+            if isinstance(web_report, bool):
+                self.web_report = web_report
+            else:
+                raise OrionisTestValueError("Web report must be a boolean value.")
 
+        # Return the configured instance
         return self
 
     def discoverTestsInFolder(
         self,
         *,
-        folder_path: str,
         base_path: str = "tests",
+        folder_path: str,
         pattern: str = "test_*.py",
         test_name_pattern: Optional[str] = None,
         tags: Optional[List[str]] = None
     ) -> 'UnitTest':
         """
+        Discover and add unit tests from a specified folder to the test suite.
+
+        Searches for test files in the given folder path, optionally filtering by file name pattern,
+        test name pattern, and tags. Discovered tests are added to the suite, and information about
+        the discovery is recorded.
+
         Parameters
         ----------
-        folder_path : str
-            The relative path to the folder containing the tests.
         base_path : str, optional
-            The base directory where the test folder is located. Defaults to "tests".
+            The base directory to search for tests. Defaults to "tests".
+        folder_path : str
+            The relative path to the folder containing test files.
         pattern : str, optional
-            The filename pattern to match test files. Defaults to "test_*.py".
-        test_name_pattern : str or None, optional
+            The file name pattern to match test files. Defaults to "test_*.py".
+        test_name_pattern : Optional[str], optional
             A pattern to filter test names. Defaults to None.
-        tags : list of str or None, optional
+        tags : Optional[List[str]], optional
             A list of tags to filter tests. Defaults to None.
 
         Returns
         -------
         UnitTest
-            The current instance of the UnitTest class with the discovered tests added.
+            The current instance with discovered tests added to the suite.
 
         Raises
         ------
         OrionisTestValueError
-            If the test folder does not exist, no tests are found, or an error occurs during test discovery.
-
-        Notes
-        -----
-        This method updates the internal test suite with the discovered tests and tracks the number of tests found.
+            If any argument is invalid, the folder does not exist, no tests are found,
+            or if there are import or discovery errors.
         """
+
+        # Validate folder_path
+        if folder_path is None or not isinstance(folder_path, str):
+            raise OrionisTestValueError(
+                f"Invalid folder_path: Expected a non-empty string, got '{folder_path}' ({type(folder_path).__name__})."
+            )
+        self.folder_path = folder_path
+
+        # Validate base_path and set value
+        if base_path is None or not isinstance(base_path, str):
+            raise OrionisTestValueError(
+                f"Invalid base_path: Expected a non-empty string, got '{base_path}' ({type(base_path).__name__})."
+            )
+        self.base_path = base_path
+
+        # Validate pattern
+        if pattern is None or not isinstance(pattern, str):
+            raise OrionisTestValueError(
+                f"Invalid pattern: Expected a non-empty string, got '{pattern}' ({type(pattern).__name__})."
+            )
+        self.pattern = pattern
+
+        # Validate test_name_pattern
+        if test_name_pattern is not None:
+            if not isinstance(test_name_pattern, str):
+                raise OrionisTestValueError(
+                    f"Invalid test_name_pattern: Expected a string, got '{test_name_pattern}' ({type(test_name_pattern).__name__})."
+                )
+            self.test_name_pattern = test_name_pattern
+
+        # Validate tags
+        if tags is not None:
+            if not isinstance(tags, list) or not all(isinstance(tag, str) for tag in tags):
+                raise OrionisTestValueError(
+                    f"Invalid tags: Expected a list of strings, got '{tags}' ({type(tags).__name__})."
+                )
+            self.tags = tags
+
+        # Try to discover tests in the specified folder
         try:
-            self.base_path = base_path
 
-            full_path = Path(base_path) / folder_path
+            # Ensure the folder path is absolute
+            full_path = Path(self.base_path) / self.folder_path
             if not full_path.exists():
-                raise OrionisTestValueError(f"Test folder not found: {full_path}")
+                raise OrionisTestValueError(
+                    f"Test folder not found at the specified path: '{full_path}'. "
+                    "Please verify that the path is correct and the folder exists."
+                )
+            self.full_path = str(full_path.resolve())
 
+            # Discover tests using the unittest TestLoader
             tests = self.loader.discover(
                 start_dir=str(full_path),
                 pattern=pattern,
                 top_level_dir=None
             )
 
+            # If name pattern is provided, filter tests by name
             if test_name_pattern:
-                tests = self._filterTestsByName(tests, test_name_pattern)
+                tests = self.__filterTestsByName(
+                    suite=tests,
+                    pattern=test_name_pattern
+                )
 
+            # If tags are provided, filter tests by tags
             if tags:
-                tests = self._filterTestsByTags(tests, tags)
+                tests = self.__filterTestsByTags(
+                    suite=tests,
+                    tags=tags
+                )
 
+            # If no tests are found, raise an error
             if not list(tests):
-                raise OrionisTestValueError(f"No tests found in '{full_path}' matching pattern '{pattern}'")
+                raise OrionisTestValueError(
+                    f"No tests were found in the path '{full_path}' matching the file pattern '{pattern}'"
+                    + (f" and the test name pattern '{test_name_pattern}'" if test_name_pattern else "")
+                    + (f" and the tags {tags}" if tags else "") +
+                    ".\nPlease ensure that test files exist and that the patterns and tags are correct."
+                )
 
+            # Add discovered tests to the suite
             self.suite.addTests(tests)
 
-            test_count = len(list(self._flattenTestSuite(tests)))
+            # Count the number of tests discovered
+            # Using __flattenTestSuite to ensure we count all individual test cases
+            test_count = len(list(self.__flattenTestSuite(tests)))
+
+            # Append the discovered tests information
             self.discovered_tests.append({
                 "folder": str(full_path),
                 "test_count": test_count,
             })
 
+            # Rereturn the current instance
             return self
 
         except ImportError as e:
-            raise OrionisTestValueError(f"Error importing tests from '{full_path}': {str(e)}")
+
+            # Raise a specific error if the import fails
+            raise OrionisTestValueError(
+                f"Error importing tests from path '{full_path}': {str(e)}.\n"
+                "Please verify that the directory and test modules are accessible and correct."
+            )
         except Exception as e:
-            raise OrionisTestValueError(f"Unexpected error discovering tests: {str(e)}")
 
-    def discoverTestsInModule(self, *, module_name: str, test_name_pattern: Optional[str] = None) -> 'UnitTest':
+            # Raise a general error for unexpected issues
+            raise OrionisTestValueError(
+                f"Unexpected error while discovering tests in '{full_path}': {str(e)}.\n"
+                "Ensure that the test files are valid and that there are no syntax errors or missing dependencies."
+            )
+
+    def discoverTestsInModule(
+        self,
+        *,
+        module_name: str,
+        test_name_pattern: Optional[str] = None
+    ) -> 'UnitTest':
         """
-        Discovers and loads tests from a specified module, optionally filtering by a test name pattern, and adds them to the test suite.
+        Discover and add unit tests from a specified module to the test suite.
 
         Parameters
         ----------
         module_name : str
-            Name of the module from which to discover tests.
-        test_name_pattern : str, optional
-            Pattern to filter test names. Only tests matching this pattern will be included. Defaults to None.
+            The name of the module from which to discover tests. Must be a non-empty string.
+        test_name_pattern : Optional[str], optional
+            A pattern to filter test names. If provided, only tests matching this pattern will be included.
 
         Returns
         -------
         UnitTest
-            The current instance of the UnitTest class, allowing method chaining.
+            The current instance with the discovered tests added to the suite.
 
-        Exceptions
-        ----------
+        Raises
+        ------
         OrionisTestValueError
-            If the specified module cannot be imported.
+            If the module_name is invalid, the test_name_pattern is invalid, the module cannot be imported,
+            or any unexpected error occurs during test discovery.
+
+        Notes
+        -----
+        - The method validates the input parameters before attempting to discover tests.
+        - If a test_name_pattern is provided, only tests matching the pattern are included.
+        - Information about the discovered tests is appended to the 'discovered_tests' attribute.
         """
+
+        # Validate module_name
+        if not module_name or not isinstance(module_name, str):
+            raise OrionisTestValueError(
+                f"Invalid module_name: Expected a non-empty string, got '{module_name}' ({type(module_name).__name__})."
+            )
+        self.module_name = module_name
+
+        # Validate test_name_pattern
+        if test_name_pattern is not None and not isinstance(test_name_pattern, str):
+            raise OrionisTestValueError(
+                f"Invalid test_name_pattern: Expected a string, got '{test_name_pattern}' ({type(test_name_pattern).__name__})."
+            )
+        self.test_name_pattern = test_name_pattern
+
+        # Try to load tests from the specified module
         try:
 
-            tests = self.loader.loadTestsFromName(module_name)
+            # Load the tests from the specified module
+            tests = self.loader.loadTestsFromName(
+                name=module_name
+            )
 
+            # If test_name_pattern provided
             if test_name_pattern:
-                tests = self._filterTestsByName(tests, test_name_pattern)
+                tests = self.__filterTestsByName(
+                    suite=tests,
+                    pattern=test_name_pattern
+                )
 
+            # Add the discovered tests to the suite
             self.suite.addTests(tests)
 
-            test_count = len(list(self._flattenTestSuite(tests)))
+            # Count the number of tests discovered
+            test_count = len(list(self.__flattenTestSuite(tests)))
+
+            # Append the discovered tests information
             self.discovered_tests.append({
                 "module": module_name,
                 "test_count": test_count,
             })
 
+            # Return the current instance
             return self
-        except ImportError as e:
-            raise OrionisTestValueError(f"Error importing module '{module_name}': {str(e)}")
 
-    def _startMessage(self) -> None:
-        """
-        Prints a formatted message indicating the start of the test suite execution.
-
-        Parameters
-        ----------
-        self : UnitTest
-            The instance of the UnitTest class.
-
-        Notes
-        -----
-        This method displays details about the test suite, including the total number of tests,
-        the execution mode (parallel or sequential), and the start time. The message is styled
-        and displayed using the `rich` library.
+        except ImportError as e:
 
-        Attributes Used
-        --------------
-        print_result : bool
-            Determines whether the message should be printed.
-        suite : unittest.TestSuite
-            The test suite containing the tests to be executed.
-        max_workers : int
-            The number of workers used in parallel execution mode.
-        execution_mode : str
-            The mode of execution ('SEQUENTIAL' or 'PARALLEL').
-        orionis_console : Console
-            The console object for handling standard output.
-        rich_console : RichConsole
-            The rich console object for styled output.
-        width_output_component : int
-            The calculated width of the message panel for formatting.
-        """
-        if self.print_result:
-            test_count = len(list(self._flattenTestSuite(self.suite)))
-            mode_text = f"[stat]Parallel with {self.max_workers} workers[/stat]" if self.execution_mode == ExecutionMode.PARALLEL.value else "Sequential"
-            textlines = [
-                f"[bold]Total Tests:[/bold] [dim]{test_count}[/dim]",
-                f"[bold]Mode:[/bold] [dim]{mode_text}[/dim]",
-                f"[bold]Started at:[/bold] [dim]{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}[/dim]"
-            ]
-
-            self.orionis_console.newLine()
-            self.rich_console.print(
-                Panel(
-                    str('\n').join(textlines),
-                    border_style="blue",
-                    title="🧪 Orionis Framework - Component Test Suite",
-                    title_align="center",
-                    width=self.width_output_component,
-                    padding=(0, 1)
-                )
+            # Raise a specific error if the import fails
+            raise OrionisTestValueError(
+                f"Error importing tests from module '{module_name}': {str(e)}.\n"
+                "Please verify that the module exists, is accessible, and contains valid test cases."
             )
-            self.orionis_console.newLine()
-
-    def run(self, print_result: bool = None, throw_exception: bool = None) -> Dict[str, Any]:
-        """
-        Executes the test suite and processes the results.
-
-        Parameters
-        ----------
-        print_result : bool, optional
-            If provided, overrides the instance's `print_result` attribute to determine whether to print results.
-        throw_exception : bool, optional
-            If True, raises an exception if any test failures or errors are detected.
-
-        Returns
-        -------
-        dict
-            A summary of the test execution, including details such as execution time, results, and timestamp.
-
-        Raises
-        ------
-        OrionisTestFailureException
-            If `throw_exception` is True and there are test failures or errors.
-        """
+        except Exception as e:
 
-        # Check if required print_result and throw_exception
-        if print_result is not None:
-            self.print_result = print_result
-        if throw_exception is not None:
-            self.throw_exception = throw_exception
+            # Raise a general error for unexpected issues
+            raise OrionisTestValueError(
+                f"Unexpected error while discovering tests in module '{module_name}': {str(e)}.\n"
+                "Ensure that the module name is correct, the test methods are valid, and there are no syntax errors or missing dependencies."
+            )
 
-        # Dynamically determine if live console should be enabled based on test code usage
-        self._withLiveConsole()
+    def run(
+        self
+    ) -> Dict[str, Any]:
 
         # Start the timer and print the start message
-        self.start_time = time.time()
-        self._startMessage()
-
-        # Prepare the running message based on whether live console is enabled
-        if self.print_result:
-            message = "[bold yellow]⏳ Running tests...[/bold yellow]\n"
-            message += "[dim]This may take a few seconds. Please wait...[/dim]" if self.withliveconsole else "[dim]Please wait, results will appear below...[/dim]"
-
-            # Panel for running message
-            running_panel = Panel(
-                message,
-                border_style="yellow",
-                title="In Progress",
-                title_align="left",
-                width=self.width_output_component,
-                padding=(1, 2)
-            )
+        start_time = time.time()
+
+        # Print the start message
+        self.printer.startMessage(
+            print_result=self.print_result,
+            length_tests=len(list(self.__flattenTestSuite(self.suite))),
+            execution_mode=self.execution_mode,
+            max_workers=self.max_workers
+        )
 
-            # Elegant "running" message using Rich Panel
-            if self.withliveconsole:
-                with Live(running_panel, console=self.rich_console, refresh_per_second=4, transient=True):
-                    result, output_buffer, error_buffer = self._runSuite()
-            else:
-                self.rich_console.print(running_panel)
-                result, output_buffer, error_buffer = self._runSuite()
-        else:
-            # If not printing results, run the suite without live console
-            result, output_buffer, error_buffer = self._runSuite()
+        # Execute the test suite and capture the results
+        result, output_buffer, error_buffer = self.printer.executePanel(
+            print_result=self.print_result,
+            flatten_test_suite= self.__flattenTestSuite(self.suite),
+            callable=self.__runSuite
+        )
 
         # Save Outputs
         self.__output_buffer = output_buffer.getvalue()
         self.__error_buffer = error_buffer.getvalue()
 
         # Process results
-        execution_time = time.time() - self.start_time
-        summary = self._generateSummary(result, execution_time)
+        execution_time = time.time() - start_time
+        summary = self.__generateSummary(result, execution_time)
 
         # Print captured output
-        if self.print_result:
-            self._displayResults(summary)
+        self.printer.displayResults(
+            print_result=self.print_result,
+            summary=summary
+        )
 
         # Print Execution Time
         if not result.wasSuccessful() and self.throw_exception:
             raise OrionisTestFailureException(result)
 
+        # Print the final summary message
+        self.printer.finishMessage(
+            print_result=self.print_result,
+            summary=summary
+        )
+
         # Return the summary of the test results
-        self.__result = summary
         return summary
 
-    def _withLiveConsole(self) -> None:
+    def __flattenTestSuite(
+        self,
+        suite: unittest.TestSuite
+    ) -> List[unittest.TestCase]:
         """
-        Determines if the live console should be used based on the presence of debug or dump calls in the test code.
+        Recursively flattens a nested unittest.TestSuite into a list of unique unittest.TestCase instances.
+
+        Parameters
+        ----------
+        suite : unittest.TestSuite
+            The test suite to flatten, which may contain nested suites or test cases.
 
         Returns
         -------
-        bool
-            True if the live console should be used, False otherwise.
-        """
-        if self.withliveconsole:
-
-            try:
-
-                # Flatten the test suite to get all test cases
-                for test_case in self._flattenTestSuite(self.suite):
-
-                    # Get the source code of the test case class
-                    source = inspect.getsource(test_case.__class__)
-
-                    # Only match if the keyword is not inside a comment
-                    for keyword in ('self.dd', 'self.dump'):
-
-                        # Find all lines containing the keyword
-                        for line in source.splitlines():
-                            if keyword in line:
-
-                                # Remove leading/trailing whitespace
-                                stripped = line.strip()
-
-                                # Ignore lines that start with '#' (comments)
-                                if not stripped.startswith('#') and not re.match(r'^\s*#', line):
-                                    self.withliveconsole = False
-                                    break
+        List[unittest.TestCase]
+            A list containing all unique TestCase instances extracted from the suite.
 
-                        # If we found a keyword, no need to check further
-                        if not self.withliveconsole:
-                            break
+        Notes
+        -----
+        This method traverses the given TestSuite recursively, collecting all TestCase instances
+        and ensuring that each test appears only once in the resulting list.
+        """
+        tests = []
+        seen_ids = set()
 
-                    # If we found a keyword in any test case, no need to check further
-                    if not self.withliveconsole:
-                        break
+        def _flatten(item):
+            if isinstance(item, unittest.TestSuite):
+                for sub_item in item:
+                    _flatten(sub_item)
+            elif hasattr(item, "id"):
+                test_id = item.id()
+                parts = test_id.split('.')
+                if len(parts) >= 2:
+                    short_id = '.'.join(parts[-2:])
+                else:
+                    short_id = test_id
+                if short_id not in seen_ids:
+                    seen_ids.add(short_id)
+                    tests.append(item)
 
-            except Exception:
-                pass
+        _flatten(suite)
+        return tests
 
-    def _runSuite(self):
+    def __runSuite(
+        self
+    ):
         """
         Run the test suite according to the selected execution mode (parallel or sequential),
         capturing standard output and error streams during execution.
@@ -525,14 +610,29 @@ class UnitTest(IUnitTest):
 
         # Execute tests based on selected mode
         if self.execution_mode == ExecutionMode.PARALLEL.value:
-            result = self._runTestsInParallel(output_buffer, error_buffer)
+
+            # Run tests in parallel
+            result = self.__runTestsInParallel(
+                output_buffer,
+                error_buffer
+            )
+
         else:
-            result = self._runTestsSequentially(output_buffer, error_buffer)
+
+            # Run tests sequentially
+            result = self.__runTestsSequentially(
+                output_buffer,
+                error_buffer
+            )
 
         # Return the result along with captured output and error streams
         return result, output_buffer, error_buffer
 
-    def _runTestsSequentially(self, output_buffer: io.StringIO, error_buffer: io.StringIO) -> unittest.TestResult:
+    def __runTestsSequentially(
+        self,
+        output_buffer: io.StringIO,
+        error_buffer: io.StringIO
+    ) -> unittest.TestResult:
         """
         Executes the test suite sequentially, capturing the output and error streams.
 
@@ -549,18 +649,28 @@ class UnitTest(IUnitTest):
             The result of the test suite execution, containing information about
             passed, failed, and skipped tests.
         """
+
+        # Flatten the suite to avoid duplicate tests
+        flattened_suite = unittest.TestSuite(self.__flattenTestSuite(self.suite))
+
+        # Create a custom result class to capture detailed test results
         with redirect_stdout(output_buffer), redirect_stderr(error_buffer):
             runner = unittest.TextTestRunner(
                 stream=output_buffer,
                 verbosity=self.verbosity,
                 failfast=self.fail_fast,
-                resultclass=self._createCustomResultClass()
+                resultclass=self.__customResultClass()
             )
-            result = runner.run(self.suite)
+            result = runner.run(flattened_suite)
 
+        # Return the result object containing test outcomes
         return result
 
-    def _runTestsInParallel(self, output_buffer: io.StringIO, error_buffer: io.StringIO) -> unittest.TestResult:
+    def __runTestsInParallel(
+        self,
+        output_buffer: io.StringIO,
+        error_buffer: io.StringIO
+    ) -> unittest.TestResult:
         """
         Runs all test cases in the provided test suite concurrently using a thread pool,
         aggregating the results into a single result object. Standard output and error
@@ -585,10 +695,10 @@ class UnitTest(IUnitTest):
         """
 
         # Flatten the test suite to get individual test cases
-        test_cases = list(self._flattenTestSuite(self.suite))
+        test_cases = list(self.__flattenTestSuite(self.suite))
 
         # Create a custom result instance to collect all results
-        result_class = self._createCustomResultClass()
+        result_class = self.__customResultClass()
         combined_result = result_class(io.StringIO(), descriptions=True, verbosity=self.verbosity)
 
         # Helper function to run a single test and return its result.
@@ -602,22 +712,34 @@ class UnitTest(IUnitTest):
             )
             return runner.run(unittest.TestSuite([test]))
 
+        # Use ThreadPoolExecutor to run tests concurrently
         with redirect_stdout(output_buffer), redirect_stderr(error_buffer):
+
+            # Create a ThreadPoolExecutor to run tests in parallel
             with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+
+                # Submit all test cases to the executor
                 futures = [executor.submit(run_single_test, test) for test in test_cases]
 
+                # Process the results as they complete
                 for future in as_completed(futures):
                     test_result = future.result()
-                    self._mergeTestResults(combined_result, test_result)
+                    self.__mergeTestResults(combined_result, test_result)
 
+                    # If fail_fast is enabled and a test failed, cancel remaining futures
                     if self.fail_fast and not combined_result.wasSuccessful():
                         for f in futures:
                             f.cancel()
                         break
 
+        # Return the combined result object
         return combined_result
 
-    def _mergeTestResults(self, combined_result: unittest.TestResult, individual_result: unittest.TestResult) -> None:
+    def __mergeTestResults(
+        self,
+        combined_result: unittest.TestResult,
+        individual_result: unittest.TestResult
+    ) -> None:
         """
         Merge the results of two unittest.TestResult objects.
 
@@ -637,6 +759,8 @@ class UnitTest(IUnitTest):
         -------
         None
         """
+
+        # Update the combined result with counts and lists from the individual result
         combined_result.testsRun += individual_result.testsRun
         combined_result.failures.extend(individual_result.failures)
         combined_result.errors.extend(individual_result.errors)
@@ -650,24 +774,26 @@ class UnitTest(IUnitTest):
                 combined_result.test_results = []
             combined_result.test_results.extend(individual_result.test_results)
 
-    def _createCustomResultClass(self) -> type:
+    def __customResultClass(
+        self
+    ) -> type:
         """
         Creates a custom test result class for enhanced test tracking.
-        This method dynamically generates an `EnhancedTestResult` class that extends
+        This method dynamically generates an `OrionisTestResult` class that extends
         `unittest.TextTestResult`. The custom class provides advanced functionality for
         tracking test execution details, including timings, statuses, and error information.
 
         Returns
         -------
         type
-            A dynamically created class `EnhancedTestResult` that overrides methods to handle
+            A dynamically created class `OrionisTestResult` that overrides methods to handle
             test results, including success, failure, error, and skipped tests. The class
             collects detailed information about each test, such as execution time, error
             messages, traceback, and file path.
 
         Notes
         -----
-        The `EnhancedTestResult` class includes the following method overrides:
+        The `OrionisTestResult` class includes the following method overrides:
         The method uses the `this` reference to access the outer class's methods, such as
         `_extractErrorInfo`, for extracting and formatting error information.
         """
@@ -676,7 +802,7 @@ class UnitTest(IUnitTest):
         this = self
 
         # Define the custom test result class
-        class EnhancedTestResult(unittest.TextTestResult):
+        class OrionisTestResult(unittest.TextTestResult):
             def __init__(self, *args, **kwargs):
                 super().__init__(*args, **kwargs)
                 self.test_results = []
@@ -769,10 +895,65 @@ class UnitTest(IUnitTest):
                     )
                 )
 
-        # Return the dynamically created EnhancedTestResult class
-        return EnhancedTestResult
+        # Return the dynamically created OrionisTestResult class
+        return OrionisTestResult
+
+    def _extractErrorInfo(
+        self,
+        traceback_str: str
+    ) -> Tuple[Optional[str], Optional[str]]:
+        """
+        Extract error information from a traceback string.
+        This method processes a traceback string to extract the file path of the Python file where the error occurred and
+        cleans up the traceback by removing framework internals and irrelevant noise.
+
+        Parameters
+        ----------
+        traceback_str : str
+            The traceback string to process.
+
+        Returns
+        -------
+        Tuple[Optional[str], Optional[str]]
+            A tuple containing:
+
+        Notes
+        -----
+        Framework internals and lines containing 'unittest/', 'lib/python', or 'site-packages' are removed from the traceback.
+        The cleaned traceback starts from the first occurrence of the test file path.
+        """
+        # Extract file path
+        file_matches = re.findall(r'File ["\'](.*?.py)["\']', traceback_str)
+        file_path = file_matches[-1] if file_matches else None
+
+        # Clean up traceback by removing framework internals and noise
+        tb_lines = traceback_str.split('\n')
+        clean_lines = []
+        relevant_lines_started = False
+
+        # Iterate through each line in the traceback
+        for line in tb_lines:
+
+            # Skip framework internal lines
+            if any(s in line for s in ['unittest/', 'lib/python', 'site-packages']):
+                continue
+
+            # Start capturing when we hit the test file
+            if file_path and file_path in line and not relevant_lines_started:
+                relevant_lines_started = True
+
+            if relevant_lines_started:
+                clean_lines.append(line)
+
+        clean_tb = str('\n').join(clean_lines) if clean_lines else traceback_str
+
+        return file_path, clean_tb
 
-    def _generateSummary(self, result: unittest.TestResult, execution_time: float) -> Dict[str, Any]:
+    def __generateSummary(
+        self,
+        result: unittest.TestResult,
+        execution_time: float
+    ) -> Dict[str, Any]:
         """
         Generate a summary of the test results, including statistics and details for each test.
 
@@ -842,7 +1023,7 @@ class UnitTest(IUnitTest):
         success_rate = (passed / result.testsRun * 100) if result.testsRun > 0 else 100.0
 
         # Create a summary report
-        report = {
+        self.__result = {
             "total_tests": result.testsRun,
             "passed": passed,
             "failed": len(result.failures),
@@ -856,33 +1037,19 @@ class UnitTest(IUnitTest):
 
         # Handle persistence of the report
         if self.persistent:
-            self._persistTestResults(report)
+            self.__handlePersistResults(self.__result)
 
         # Handle Web Report Rendering
         if self.web_report:
-
-            # Generate the web report and get the path
-            path = self._webReport(report)
-
-            # Elegant invitation to view the results, with underlined path
-            invite_text = Text("Test results saved. ", style="green")
-            invite_text.append("View report: ", style="bold green")
-            invite_text.append(str(path), style="underline blue")
-            self.rich_console.print(invite_text)
+            self.__handleWebReport(self.__result)
 
         # Return the summary
-        return {
-            "total_tests": result.testsRun,
-            "passed": passed,
-            "failed": len(result.failures),
-            "errors": len(result.errors),
-            "skipped": len(result.skipped),
-            "total_time": float(execution_time),
-            "success_rate": success_rate,
-            "test_details": test_details
-        }
+        return self.__result
 
-    def _webReport(self, summary: Dict[str, Any]) -> None:
+    def __handleWebReport(
+        self,
+        summary: Dict[str, Any]
+    ) -> None:
         """
         Generates a web report for the test results summary.
 
@@ -903,6 +1070,7 @@ class UnitTest(IUnitTest):
         - If persistence is enabled and the driver is 'sqlite', the report is marked as persistent.
         - Returns the path to the generated report for further use.
         """
+
         # Determine the absolute path for storing results
         project = os.path.basename(os.getcwd())
         storage_path = os.path.abspath(os.path.join(os.getcwd(), self.base_path))
@@ -918,10 +1086,13 @@ class UnitTest(IUnitTest):
             persist=self.persistent and self.persistent_driver == 'sqlite'
         )
 
-        # Render the report and return the path
-        return render.render()
+        # Render the report and print the web report link
+        self.printer.linkWebReport(render.render())
 
-    def _persistTestResults(self, summary: Dict[str, Any]) -> None:
+    def __handlePersistResults(
+        self,
+        summary: Dict[str, Any]
+    ) -> None:
         """
         Persist the test results summary using the configured persistent driver.
 
@@ -945,6 +1116,7 @@ class UnitTest(IUnitTest):
         """
 
         try:
+
             # Determine the absolute path for storing results
             project = os.getcwd().split(os.sep)[-1]
             storage_path = None
@@ -977,64 +1149,22 @@ class UnitTest(IUnitTest):
                 # Write the summary to the JSON file
                 with open(log_path, 'w', encoding='utf-8') as log:
                     json.dump(summary, log, indent=4)
+
         except OSError as e:
-            raise OSError(f"Error creating directories or writing files: {str(e)}")
-        except Exception as e:
-            raise OrionisTestPersistenceError(f"Error persisting test results: {str(e)}")
 
-    def _printSummaryTable(self, summary: Dict[str, Any]) -> None:
-        """
-        Prints a summary table of test results using the Rich library.
+            # Raise an OSError if there is an issue with file or directory operations
+            raise OSError(f"Error creating directories or writing files: {str(e)}")
 
-        Parameters
-        ----------
-        summary : dict
-            Dictionary with the test summary data. Must contain the following keys:
-            total_tests : int
-                Total number of tests executed.
-            passed : int
-                Number of tests that passed.
-            failed : int
-                Number of tests that failed.
-            errors : int
-                Number of tests that had errors.
-            skipped : int
-                Number of tests that were skipped.
-            total_time : float
-                Total duration of the test execution in seconds.
-            success_rate : float
-                Percentage of tests that passed.
+        except Exception as e:
 
-        Returns
-        -------
-        None
-        """
-        table = Table(
-            show_header=True,
-            header_style="bold white",
-            width=self.width_output_component,
-            border_style="blue"
-        )
-        table.add_column("Total", justify="center")
-        table.add_column("Passed", justify="center")
-        table.add_column("Failed", justify="center")
-        table.add_column("Errors", justify="center")
-        table.add_column("Skipped", justify="center")
-        table.add_column("Duration", justify="center")
-        table.add_column("Success Rate", justify="center")
-        table.add_row(
-            str(summary["total_tests"]),
-            str(summary["passed"]),
-            str(summary["failed"]),
-            str(summary["errors"]),
-            str(summary["skipped"]),
-            f"{summary['total_time']:.2f}s",
-            f"{summary['success_rate']:.2f}%"
-        )
-        self.rich_console.print(table)
-        self.orionis_console.newLine()
+            # Raise a general exception for any other issues during persistence
+            raise OrionisTestPersistenceError(f"Error persisting test results: {str(e)}")
 
-    def _filterTestsByName(self, suite: unittest.TestSuite, pattern: str) -> unittest.TestSuite:
+    def __filterTestsByName(
+        self,
+        suite: unittest.TestSuite,
+        pattern: str
+    ) -> unittest.TestSuite:
         """
         Filters tests in a given test suite based on a specified name pattern.
         Parameters
@@ -1054,19 +1184,33 @@ class UnitTest(IUnitTest):
         Notes
         -----
         """
+
+        # Initialize an empty TestSuite to hold the filtered tests
         filtered_suite = unittest.TestSuite()
+
+        # Validate the pattern
         try:
             regex = re.compile(pattern)
         except re.error as e:
-            raise OrionisTestValueError(f"Invalid test name pattern: {str(e)}")
+            raise OrionisTestValueError(
+                f"The provided test name pattern is invalid: '{pattern}'. "
+                f"Regular expression compilation error: {str(e)}. "
+                "Please check the pattern syntax and try again."
+            )
 
-        for test in self._flattenTestSuite(suite):
+        # Iterate through all tests in the suite and filter by the regex pattern
+        for test in self.__flattenTestSuite(suite):
             if regex.search(test.id()):
                 filtered_suite.addTest(test)
 
+        # Return the filtered suite containing only tests that match the pattern
         return filtered_suite
 
-    def _filterTestsByTags(self, suite: unittest.TestSuite, tags: List[str]) -> unittest.TestSuite:
+    def __filterTestsByTags(
+        self,
+        suite: unittest.TestSuite,
+        tags: List[str]
+    ) -> unittest.TestSuite:
         """
         Filter tests in a unittest TestSuite by specified tags.
 
@@ -1091,7 +1235,7 @@ class UnitTest(IUnitTest):
         filtered_suite = unittest.TestSuite()
         tag_set = set(tags)
 
-        for test in self._flattenTestSuite(suite):
+        for test in self.__flattenTestSuite(suite):
 
             # Get test method if this is a TestCase instance
             test_method = getattr(test, test._testMethodName, None)
@@ -1111,250 +1255,9 @@ class UnitTest(IUnitTest):
         # Return the filtered suite containing only tests with matching tags
         return filtered_suite
 
-    def _flattenTestSuite(self, suite: unittest.TestSuite) -> List[unittest.TestCase]:
-        """
-        Recursively flattens a nested unittest.TestSuite into a list of unique unittest.TestCase instances.
-
-        Parameters
-        ----------
-        suite : unittest.TestSuite
-            The test suite to flatten, which may contain nested suites or test cases.
-
-        Returns
-        -------
-        List[unittest.TestCase]
-            A list containing all unique TestCase instances extracted from the suite.
-
-        Notes
-        -----
-        This method traverses the given TestSuite recursively, collecting all TestCase instances
-        and ensuring that each test appears only once in the resulting list.
-        """
-        tests = []
-        seen_ids = set()
-
-        def _flatten(item):
-            if isinstance(item, unittest.TestSuite):
-                for sub_item in item:
-                    _flatten(sub_item)
-            elif hasattr(item, "id"):
-                test_id = item.id()
-                parts = test_id.split('.')
-                if len(parts) >= 2:
-                    short_id = '.'.join(parts[-2:])
-                else:
-                    short_id = test_id
-                if short_id not in seen_ids:
-                    seen_ids.add(short_id)
-                    tests.append(item)
-
-        _flatten(suite)
-        return tests
-
-    def _sanitizeTraceback(self, test_path: str, traceback_test: str) -> str:
-        """
-        Sanitize a traceback string to extract and display the most relevant parts
-        related to a specific test file.
-
-        Parameters
-        ----------
-        test_path : str
-            The file path of the test file being analyzed.
-        traceback_test : str
-            The full traceback string to be sanitized.
-
-        Returns
-        -------
-        str
-            A sanitized traceback string containing only the relevant parts related to the test file.
-            If no relevant parts are found, the full traceback is returned.
-            If the traceback is empty, a default message "No traceback available for this test." is returned.
-        """
-        if not traceback_test:
-            return "No traceback available for this test."
-
-        # Try to extract the test file name
-        file_match = re.search(r'([^/\\]+)\.py', test_path)
-        file_name = file_match.group(1) if file_match else None
-
-        if not file_name:
-            return traceback_test
-
-        # Process traceback to show most relevant parts
-        lines = traceback_test.splitlines()
-        relevant_lines = []
-        found_test_file = False if file_name in traceback_test else True
-
-        for line in lines:
-            if file_name in line and not found_test_file:
-                found_test_file = True
-            if found_test_file:
-                if 'File' in line:
-                    relevant_lines.append(line.strip())
-                elif line.strip() != '':
-                    relevant_lines.append(line)
-
-        # If we didn't find the test file, return the full traceback
-        if not relevant_lines:
-            return traceback_test
-
-        # Remove any lines that are not relevant to the test file
-        return str('\n').join(relevant_lines)
-
-    def _displayResults(self, summary: Dict[str, Any]) -> None:
-        """
-        Display the results of the test execution, including a summary table and detailed
-        information about failed or errored tests grouped by their test classes.
-
-        Parameters
-        ----------
-        summary : dict
-            Dictionary containing the summary of the test execution, including test details,
-            statuses, and execution times.
-
-        Notes
-        -----
-        - Prints a summary table of the test results.
-        - Groups failed and errored tests by their test class and displays them in a structured
-          format using panels.
-        - For each failed or errored test, displays the traceback in a syntax-highlighted panel
-          with additional metadata such as the test method name and execution time.
-        - Uses different icons and border colors to distinguish between failed and errored tests.
-        - Calls a finishing message method after displaying all results.
-        """
-
-        # Print summary table
-        self._printSummaryTable(summary)
-
-        # Group failures and errors by test class
-        failures_by_class = {}
-        for test in summary["test_details"]:
-            if test["status"] in (TestStatus.FAILED.name, TestStatus.ERRORED.name):
-                class_name = test["class"]
-                if class_name not in failures_by_class:
-                    failures_by_class[class_name] = []
-                failures_by_class[class_name].append(test)
-
-        # Display grouped failures
-        for class_name, tests in failures_by_class.items():
-
-            class_panel = Panel.fit(f"[bold]{class_name}[/bold]", border_style="red", padding=(0, 2))
-            self.rich_console.print(class_panel)
-
-            for test in tests:
-                traceback_str = self._sanitizeTraceback(test['file_path'], test['traceback'])
-                syntax = Syntax(
-                    traceback_str,
-                    lexer="python",
-                    line_numbers=False,
-                    background_color="default",
-                    word_wrap=True,
-                    theme="monokai"
-                )
-
-                icon = "❌" if test["status"] == TestStatus.FAILED.name else "💥"
-                border_color = "yellow" if test["status"] == TestStatus.FAILED.name else "red"
-
-                # Ensure execution time is never zero for display purposes
-                if not test['execution_time'] or test['execution_time'] == 0:
-                    test['execution_time'] = 0.001
-
-                panel = Panel(
-                    syntax,
-                    title=f"{icon} {test['method']}",
-                    subtitle=f"Duration: {test['execution_time']:.3f}s",
-                    border_style=border_color,
-                    title_align="left",
-                    padding=(1, 1),
-                    subtitle_align="right",
-                    width=self.width_output_component
-                )
-                self.rich_console.print(panel)
-                self.orionis_console.newLine()
-
-        self._finishMessage(summary)
-
-    def _extractErrorInfo(self, traceback_str: str) -> Tuple[Optional[str], Optional[str]]:
-        """
-        Extract error information from a traceback string.
-        This method processes a traceback string to extract the file path of the Python file where the error occurred and
-        cleans up the traceback by removing framework internals and irrelevant noise.
-
-        Parameters
-        ----------
-        traceback_str : str
-            The traceback string to process.
-
-        Returns
-        -------
-        Tuple[Optional[str], Optional[str]]
-            A tuple containing:
-
-        Notes
-        -----
-        Framework internals and lines containing 'unittest/', 'lib/python', or 'site-packages' are removed from the traceback.
-        The cleaned traceback starts from the first occurrence of the test file path.
-        """
-        # Extract file path
-        file_matches = re.findall(r'File ["\'](.*?.py)["\']', traceback_str)
-        file_path = file_matches[-1] if file_matches else None
-
-        # Clean up traceback by removing framework internals and noise
-        tb_lines = traceback_str.split('\n')
-        clean_lines = []
-        relevant_lines_started = False
-
-        for line in tb_lines:
-            # Skip framework internal lines
-            if any(s in line for s in ['unittest/', 'lib/python', 'site-packages']):
-                continue
-
-            # Start capturing when we hit the test file
-            if file_path and file_path in line and not relevant_lines_started:
-                relevant_lines_started = True
-
-            if relevant_lines_started:
-                clean_lines.append(line)
-
-        clean_tb = str('\n').join(clean_lines) if clean_lines else traceback_str
-
-        return file_path, clean_tb
-
-    def _finishMessage(self, summary: Dict[str, Any]) -> None:
-        """
-        Display a summary message for the test suite execution.
-
-        Parameters
-        ----------
-        summary : dict
-            Dictionary containing the test suite summary, including keys such as
-            'failed', 'errors', and 'total_time'.
-
-        Notes
-        -----
-        - If `self.print_result` is False, the method returns without displaying anything.
-        - Shows a status icon (✅ for success, ❌ for failure) based on the presence of
-          failures or errors in the test suite.
-        - Formats and prints the message within a styled panel using the `rich` library.
-        """
-        if not self.print_result:
-            return
-
-        status_icon = "✅" if (summary['failed'] + summary['errors']) == 0 else "❌"
-        msg = f"Test suite completed in {summary['total_time']:.2f} seconds"
-        self.rich_console.print(
-            Panel(
-                msg,
-                border_style="blue",
-                title=f"{status_icon} Test Suite Finished",
-                title_align='left',
-                width=self.width_output_component,
-                padding=(0, 1)
-            )
-        )
-        self.rich_console.print()
-
-    def getTestNames(self) -> List[str]:
+    def getTestNames(
+        self
+    ) -> List[str]:
         """
         Get a list of test names (unique identifiers) from the test suite.
 
@@ -1363,9 +1266,11 @@ class UnitTest(IUnitTest):
         List[str]
             List of test names (unique identifiers) from the test suite.
         """
-        return [test.id() for test in self._flattenTestSuite(self.suite)]
+        return [test.id() for test in self.__flattenTestSuite(self.suite)]
 
-    def getTestCount(self) -> int:
+    def getTestCount(
+        self
+    ) -> int:
         """
         Returns the total number of test cases in the test suite.
 
@@ -1374,9 +1279,11 @@ class UnitTest(IUnitTest):
         int
             The total number of individual test cases in the suite.
         """
-        return len(list(self._flattenTestSuite(self.suite)))
+        return len(list(self.__flattenTestSuite(self.suite)))
 
-    def clearTests(self) -> None:
+    def clearTests(
+        self
+    ) -> None:
         """
         Clear all tests from the current test suite.
 
@@ -1384,7 +1291,9 @@ class UnitTest(IUnitTest):
         """
         self.suite = unittest.TestSuite()
 
-    def getResult(self) -> dict:
+    def getResult(
+        self
+    ) -> dict:
         """
         Returns the results of the executed test suite.
 
@@ -1395,7 +1304,9 @@ class UnitTest(IUnitTest):
         """
         return self.__result
 
-    def getOutputBuffer(self) -> int:
+    def getOutputBuffer(
+        self
+    ) -> int:
         """
         Returns the output buffer used for capturing test results.
         This method returns the internal output buffer that collects the results of the test execution.
@@ -1406,15 +1317,18 @@ class UnitTest(IUnitTest):
         """
         return self.__output_buffer
 
-    def printOutputBuffer(self) -> None:
+    def printOutputBuffer(
+        self
+    ) -> None:
         """
         Prints the contents of the output buffer to the console.
         This method retrieves the output buffer and prints its contents using the rich console.
         """
-        if self.__output_buffer:
-            print(self.__output_buffer)
+        self.printer.print(self.__output_buffer)
 
-    def getErrorBuffer(self) -> int:
+    def getErrorBuffer(
+        self
+    ) -> int:
         """
         Returns the error buffer used for capturing test errors.
         This method returns the internal error buffer that collects any errors encountered during test execution.
@@ -1425,10 +1339,11 @@ class UnitTest(IUnitTest):
         """
         return self.__error_buffer
 
-    def printErrorBuffer(self) -> None:
+    def printErrorBuffer(
+        self
+    ) -> None:
         """
         Prints the contents of the error buffer to the console.
         This method retrieves the error buffer and prints its contents using the rich console.
         """
-        if self.__error_buffer:
-            print(self.__error_buffer)
+        self.printer.print(self.__error_buffer)