orionis 0.443.0__py3-none-any.whl → 0.444.0__py3-none-any.whl

orionis/console/args/argument.py

@@ -0,0 +1,343 @@
+import argparse
+from dataclasses import dataclass, field
+from typing import Any, Optional, List, Type, Union, Dict
+from orionis.console.args.enums.actions import ArgumentAction
+from orionis.console.exceptions.cli_orionis_value_error import CLIOrionisValueError
+
+@dataclass(kw_only=True, frozen=True, slots=True)
+class CLIArgument:
+    """
+    Represents a command-line argument for argparse.
+
+    This class encapsulates all the properties and validation logic needed to create
+    a command-line argument that can be added to an argparse ArgumentParser. It provides
+    automatic validation, type checking, and smart defaults for common argument patterns.
+
+    Attributes
+    ----------
+    flags : List[str]
+        List of flags for the argument (e.g., ['--export', '-e']). Must contain at least one flag.
+    type : Type
+        Data type of the argument. Can be any Python type or custom type.
+    help : str
+        Description of the argument. If not provided, will be auto-generated from the primary flag.
+    default : Any, optional
+        Default value for the argument.
+    choices : List[Any], optional
+        List of valid values for the argument. All choices must match the specified type.
+    required : bool, default False
+        Whether the argument is required. Only applies to optional arguments.
+    metavar : str, optional
+        Metavar for displaying in help messages. Auto-generated from primary flag if not provided.
+    dest : str, optional
+        Destination name for the argument in the namespace. Auto-generated from primary flag if not provided.
+    action : Union[str, ArgumentAction], default ArgumentAction.STORE
+        Action to perform with the argument when it's encountered.
+    nargs : Union[int, str], optional
+        Number of arguments expected (e.g., 1, 2, '+', '*').
+    const : Any, optional
+        Constant value for store_const or append_const actions.
+
+    Raises
+    ------
+    CLIOrionisValueError
+        If any validation fails during initialization.
+    """
+
+    # Required fields
+    flags: List[str] = None
+    type: Type = None
+    help: str = None
+
+    default: Any = field(
+        default_factory = None,
+        metadata = {
+            "description": "Default value for the argument.",
+            "default": None
+        }
+    )
+
+    choices: Optional[List[Any]] = field(
+        default_factory = None,
+        metadata = {
+            "description": "List of valid choices for the argument.",
+            "default": None
+        }
+    )
+
+    required: bool = field(
+        default_factory = False,
+        metadata = {
+            "description": "Indicates if the argument is required.",
+            "default": False
+        }
+    )
+
+    metavar: Optional[str] = field(
+        default_factory = None,
+        metadata = {
+            "description": "Metavar for displaying in help messages.",
+            "default": None
+        }
+    )
+
+    dest: Optional[str] = field(
+        default_factory = None,
+        metadata = {
+            "description": "Destination name for the argument in the namespace.",
+            "default": None
+        }
+    )
+
+    action: Union[str, ArgumentAction] = field(
+        default_factory = ArgumentAction.STORE,
+        metadata = {
+            "description": "Action to perform with the argument.",
+            "default": ArgumentAction.STORE.value
+        }
+    )
+
+    nargs: Optional[Union[int, str]] = field(
+        default_factory = None,
+        metadata = {
+            "description": "Number of arguments expected (e.g., 1, 2, '+', '*').",
+            "default": None
+        }
+    )
+
+    const: Any = field(
+        default_factory = None,
+        metadata = {
+            "description": "Constant value for store_const or append_const actions.",
+            "default": None
+        }
+    )
+
+    def __post_init__(self):
+        """
+        Validate and normalize all argument attributes after initialization.
+
+        This method performs comprehensive validation of all argument attributes
+        and applies smart defaults where appropriate. It ensures the argument
+        configuration is valid for use with argparse.
+
+        Raises
+        ------
+        CLIOrionisValueError
+            If any validation fails or invalid values are provided.
+        """
+
+        # Validate flags - must be provided and non-empty
+        if not self.flags:
+            raise CLIOrionisValueError(
+                "Flags list cannot be empty. Please provide at least one flag (e.g., ['--export', '-e'])"
+            )
+
+        # Convert single string flag to list for consistency
+        if isinstance(self.flags, str):
+            object.__setattr__(self, 'flags', [self.flags])
+
+        # Ensure flags is a list
+        if not isinstance(self.flags, list):
+            raise CLIOrionisValueError("Flags must be a string or a list of strings")
+
+        # Validate each flag format and ensure they're strings
+        for flag in self.flags:
+            if not isinstance(flag, str):
+                raise CLIOrionisValueError("All flags must be strings")
+
+        # Check for duplicate flags
+        if len(set(self.flags)) != len(self.flags):
+            raise CLIOrionisValueError("Duplicate flags are not allowed in the flags list")
+
+        # Determine primary flag (longest one, or first if only one)
+        primary_flag = max(self.flags, key=len) if len(self.flags) > 1 else self.flags[0]
+
+        # Validate type is actually a type
+        if not isinstance(self.type, type):
+            raise CLIOrionisValueError("Type must be a valid Python type or custom type class")
+
+        # Auto-generate help if not provided
+        if self.help is None:
+            object.__setattr__(self, 'help', f"Argument for {primary_flag}")
+
+        # Ensure help is a string
+        if not isinstance(self.help, str):
+            raise CLIOrionisValueError("Help text must be a string")
+
+        # Validate choices if provided
+        if self.choices is not None:
+            # Ensure choices is a list
+            if not isinstance(self.choices, list):
+                raise CLIOrionisValueError("Choices must be provided as a list")
+
+            # Ensure all choices match the specified type
+            if self.type and not all(isinstance(choice, self.type) for choice in self.choices):
+                raise CLIOrionisValueError(
+                    f"All choices must be of type {self.type.__name__}"
+                )
+
+        # Validate required is boolean
+        if not isinstance(self.required, bool):
+            raise CLIOrionisValueError("Required field must be a boolean value (True or False)")
+
+        # Auto-generate metavar if not provided
+        if self.metavar is None:
+            metavar = primary_flag.lstrip('-').upper().replace('-', '_')
+            object.__setattr__(self, 'metavar', metavar)
+
+        # Ensure metavar is a string
+        if not isinstance(self.metavar, str):
+            raise CLIOrionisValueError("Metavar must be a string")
+
+        # Auto-generate dest if not provided
+        if self.dest is None:
+            dest = primary_flag.lstrip('-').replace('-', '_')
+            object.__setattr__(self, 'dest', dest)
+
+        # Ensure dest is a string
+        if not isinstance(self.dest, str):
+            raise CLIOrionisValueError("Destination (dest) must be a string")
+
+        # Ensure dest is a valid Python identifier
+        if not self.dest.isidentifier():
+            raise CLIOrionisValueError(f"Destination '{self.dest}' is not a valid Python identifier")
+
+        # Normalize action value
+        if self.action is None:
+            object.__setattr__(self, 'action', ArgumentAction.STORE.value)
+        elif isinstance(self.action, str):
+            try:
+                action_enum = ArgumentAction(self.action)
+                object.__setattr__(self, 'action', action_enum.value)
+            except ValueError:
+                raise CLIOrionisValueError(f"Invalid action '{self.action}'. Please use a valid ArgumentAction value")
+        elif isinstance(self.action, ArgumentAction):
+            object.__setattr__(self, 'action', self.action.value)
+        else:
+            raise CLIOrionisValueError("Action must be a string or an ArgumentAction enum value")
+
+        # Special handling for boolean types
+        if self.type is bool:
+
+            # Auto-configure action based on default value
+            action = ArgumentAction.STORE_TRUE.value if not self.default else ArgumentAction.STORE_FALSE.value
+            object.__setattr__(self, 'action', action)
+
+            # argparse ignores type with store_true/false actions
+            object.__setattr__(self, 'type', None)
+
+        # Special handling for list types
+        if self.type is list and self.nargs is None:
+
+            # Auto-configure for accepting multiple values
+            object.__setattr__(self, 'nargs', '+')
+            object.__setattr__(self, 'type', str)
+
+    def addToParser(self, parser: argparse.ArgumentParser) -> None:
+        """
+        Add this argument to an argparse ArgumentParser instance.
+
+        This method integrates the CLIArgument configuration with an argparse
+        ArgumentParser by building the appropriate keyword arguments and adding
+        the argument with all its flags and options. The method handles all
+        necessary conversions and validations to ensure compatibility with
+        argparse's expected format.
+
+        Parameters
+        ----------
+        parser : argparse.ArgumentParser
+            The ArgumentParser instance to which this argument will be added.
+            The parser must be a valid argparse.ArgumentParser object.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It modifies the provided
+            parser by adding the argument configuration to it.
+
+        Raises
+        ------
+        CLIOrionisValueError
+            If there's an error adding the argument to the parser, such as
+            conflicting argument names, invalid configurations, or argparse
+            internal errors during argument registration.
+        """
+
+        # Build the keyword arguments dictionary for argparse compatibility
+        # This filters out None values and handles special argument types
+        kwargs = self._buildParserKwargs()
+
+        # Attempt to add the argument to the parser with all flags and options
+        try:
+            # Use unpacking to pass all flags as positional arguments
+            # and all configuration options as keyword arguments
+            parser.add_argument(*self.flags, **kwargs)
+
+        # Catch any exception that occurs during argument addition
+        # and wrap it in our custom exception for consistent error handling
+        except Exception as e:
+            raise CLIOrionisValueError(f"Error adding argument {self.flags}: {e}")
+
+    def _buildParserKwargs(self) -> Dict[str, Any]:
+        """
+        Build the keyword arguments dictionary for argparse compatibility.
+
+        This private method constructs a dictionary of keyword arguments that will be
+        passed to argparse's add_argument method. It handles the conversion from
+        CLIArgument attributes to argparse-compatible parameters, filtering out None
+        values and applying special handling for different argument types (optional
+        vs positional arguments).
+
+        The method ensures that the resulting kwargs dictionary contains only valid
+        argparse parameters with appropriate values, preventing errors during argument
+        registration with the ArgumentParser.
+
+        Returns
+        -------
+        Dict[str, Any]
+            A dictionary containing keyword arguments ready to be unpacked and passed
+            to argparse.ArgumentParser.add_argument(). The dictionary includes only
+            non-None values and excludes parameters that are invalid for the specific
+            argument type (e.g., 'required' parameter for positional arguments).
+
+        Notes
+        -----
+        This method distinguishes between optional arguments (those starting with '-')
+        and positional arguments, applying different validation rules for each type.
+        Positional arguments cannot use the 'required' parameter, so it's automatically
+        removed from the kwargs if present.
+        """
+
+        # Determine argument type by checking if any flag starts with a dash
+        # Optional arguments have flags like '--export' or '-e'
+        # Positional arguments have flags without dashes like 'filename'
+        is_optional = any(flag.startswith('-') for flag in self.flags)
+        is_positional = not is_optional
+
+        # Build the base kwargs dictionary with all possible argparse parameters
+        # Each key corresponds to a parameter accepted by argparse.add_argument()
+        kwargs = {
+            "help": self.help,                          # Help text displayed in usage messages
+            "default": self.default,                    # Default value when argument not provided
+            "required": self.required and is_optional,  # Whether argument is mandatory
+            "metavar": self.metavar,                    # Name displayed in help messages
+            "dest": self.dest,                          # Attribute name in the parsed namespace
+            "choices": self.choices,                    # List of valid values for the argument
+            "action": self.action,                      # Action to take when argument is encountered
+            "nargs": self.nargs,                        # Number of command-line arguments expected
+            "type": self.type,                          # Type to convert the argument to
+            "const": self.const                         # Constant value for certain actions
+        }
+
+        # Filter out None values to prevent passing invalid parameters to argparse
+        # argparse will raise errors if None values are explicitly passed for certain parameters
+        kwargs = {k: v for k, v in kwargs.items() if v is not None}
+
+        # Remove 'required' parameter for positional arguments since it's not supported
+        # Positional arguments are inherently required by argparse's design
+        if is_positional and 'required' in kwargs:
+            del kwargs['required']
+
+        # Return the cleaned and validated kwargs dictionary
+        return kwargs

orionis/console/args/enums/actions.py

@@ -0,0 +1,43 @@
+from enum import Enum
+
+class ArgumentAction(Enum):
+    """
+    Enumeration for valid argparse action types.
+
+    This enum provides a comprehensive list of all standard action types
+    that can be used with Python's argparse module when defining command
+    line arguments. Each enum member corresponds to a specific behavior
+    for how argument values should be processed and stored.
+
+    Returns
+    -------
+    str
+        The string value representing the argparse action type.
+    """
+
+    # Store the argument value directly
+    STORE = "store"
+
+    # Store a constant value when the argument is specified
+    STORE_CONST = "store_const"
+
+    # Store True when the argument is specified
+    STORE_TRUE = "store_true"
+
+    # Store False when the argument is specified
+    STORE_FALSE = "store_false"
+
+    # Append each argument value to a list
+    APPEND = "append"
+
+    # Append a constant value to a list when the argument is specified
+    APPEND_CONST = "append_const"
+
+    # Count the number of times the argument is specified
+    COUNT = "count"
+
+    # Display help message and exit
+    HELP = "help"
+
+    # Display version information and exit
+    VERSION = "version"

orionis/console/commands/version.py

@@ -15,17 +15,32 @@ class VersionCommand(BaseCommand):
 
     def handle(self) -> None:
         """
-        Execute the version command.
+        Executes the version command to display the current Orionis framework version.
 
-        This method retrieves and prints the version of the Orionis framework.
+        This method retrieves the version number from the framework metadata and prints it
+        in a formatted, bold, and successful style to the console. If an unexpected error occurs
+        during execution, it raises a CLIOrionisRuntimeError with the original exception message.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method does not return any value. It outputs the version information to the console.
 
         Raises
         ------
-        ValueError
-            If an unexpected error occurs during execution, a ValueError is raised
+        CLIOrionisRuntimeError
+            If an unexpected error occurs during execution, a CLIOrionisRuntimeError is raised
             with the original exception message.
         """
+
+        # Print the Orionis framework version in a bold, success style
         try:
             self.textSuccessBold(f"Orionis Framework v{VERSION}")
+
+        # Raise a custom runtime error if any exception occurs
         except Exception as e:
             raise CLIOrionisRuntimeError(f"An unexpected error occurred: {e}") from e

orionis/foundation/providers/testing_provider.py

@@ -1,6 +1,8 @@
 from orionis.container.providers.service_provider import ServiceProvider
 from orionis.test.contracts.unit_test import IUnitTest
 from orionis.test.core.unit_test import UnitTest
+from orionis.foundation.config.testing.entities.testing import Testing
+import os
 
 class TestingProvider(ServiceProvider):
     """
@@ -28,7 +30,39 @@ class TestingProvider(ServiceProvider):
         None
         """
 
-        self.app.singleton(IUnitTest, UnitTest, alias="core.orionis.testing")
+        # Create a Testing configuration instance from the application config
+        config = Testing(**self.app.config('testing'))
+
+        # Create a UnitTest instance
+        unit_test = UnitTest(
+            app=self.app,
+            storage=self.app.path('storage_testing')
+        )
+
+        # Configure the UnitTest instance with settings from the Testing configuration
+        unit_test.configure(
+            verbosity=config.verbosity,
+            execution_mode=config.execution_mode,
+            max_workers=config.max_workers,
+            fail_fast=config.fail_fast,
+            print_result=config.print_result,
+            throw_exception=config.throw_exception,
+            persistent=config.persistent,
+            persistent_driver=config.persistent_driver,
+            web_report=config.web_report
+        )
+
+        # Discover tests based on the configuration
+        unit_test.discoverTests(
+            base_path=config.base_path,
+            folder_path=config.folder_path,
+            pattern=config.pattern,
+            test_name_pattern=config.test_name_pattern,
+            tags=config.tags
+        )
+
+        # Register the UnitTest instance in the application container
+        self.app.instance(IUnitTest, unit_test, alias="core.orionis.testing")
 
     def boot(self) -> None:
         """
@@ -42,4 +76,7 @@ class TestingProvider(ServiceProvider):
         None
         """
 
-        pass
+        # Ensure directory for testing storage exists
+        storage_path = self.app.path('storage_testing')
+        if not os.path.exists(storage_path):
+            os.makedirs(storage_path, exist_ok=True)

orionis/metadata/framework.py

@@ -5,7 +5,7 @@
 NAME = "orionis"
 
 # Current version of the framework
-VERSION = "0.443.0"
+VERSION = "0.444.0"
 
 # Full name of the author or maintainer of the project
 AUTHOR = "Raul Mauricio Uñate Castro"

orionis/test/core/unit_test.py

@@ -1,5 +1,6 @@
 import io
 import json
+from os import walk
 import re
 import time
 import traceback
@@ -9,6 +10,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 orionis.app import Orionis
 from orionis.container.resolver.resolver import Resolver
 from orionis.foundation.config.testing.enums.drivers import PersistentDrivers
 from orionis.foundation.config.testing.enums.mode import ExecutionMode
@@ -102,7 +104,9 @@ class UnitTest(IUnitTest):
     """
 
     def __init__(
-        self
+        self,
+        app: Optional[IApplication] = None,
+        storage: Optional[str] = None
     ) -> None:
         """
         Initialize a UnitTest instance with default configuration and internal state.
@@ -113,11 +117,11 @@ class UnitTest(IUnitTest):
         -------
         None
         """
-        # Application instance for dependency injection (set via __setApp)
-        self.__app: Optional[IApplication] = None
+        # Application instance for dependency injection
+        self.__app: Optional[IApplication] = app or Orionis()
 
-        # Storage path for test results (set via __setApp)
-        self.__storage: Optional[str] = None
+        # Storage path for test results
+        self.__storage: Optional[str] = storage or self.__app.path('storage_testing')
 
         # Configuration values (set via configure)
         self.__verbosity: Optional[int] = None
@@ -220,6 +224,100 @@ class UnitTest(IUnitTest):
         # Return the instance to allow method chaining
         return self
 
+    def discoverTests(
+        self,
+        base_path: str | Path,
+        folder_path: str | List[str],
+        pattern: str,
+        test_name_pattern: Optional[str] = None,
+        tags: Optional[List[str]] = None
+    ) -> 'UnitTest':
+        """
+        Discover test cases from specified folders using flexible path discovery.
+
+        This method provides a convenient way to discover and load test cases from multiple folders
+        based on various path specifications. It supports wildcard discovery, single folder loading,
+        and multiple folder loading. The method automatically resolves paths relative to the base
+        directory and discovers all folders containing files matching the specified pattern.
+
+        Parameters
+        ----------
+        base_path : str or Path
+            Base directory path for resolving relative folder paths. This serves as the root
+            directory from which all folder searches are conducted.
+        folder_path : str or list of str
+            Specification of folders to search for test cases. Can be:
+            - '*' : Discover all folders containing matching files within base_path
+            - str : Single folder path relative to base_path
+            - list of str : Multiple folder paths relative to base_path
+        pattern : str
+            File name pattern to match test files, supporting wildcards (* and ?).
+            Examples: 'test_*.py', '*_test.py', 'test*.py'
+        test_name_pattern : str, optional
+            Regular expression pattern to filter test method names. Only tests whose
+            names match this pattern will be included. Default is None (no filtering).
+        tags : list of str, optional
+            List of tags to filter tests. Only tests decorated with matching tags
+            will be included. Default is None (no tag filtering).
+
+        Returns
+        -------
+        UnitTest
+            The current UnitTest instance with discovered tests added to the suite,
+            enabling method chaining.
+
+        Notes
+        -----
+        - All paths are resolved as absolute paths relative to the base_path
+        - When folder_path is '*', the method searches recursively through all subdirectories
+        - The method uses the existing discoverTestsInFolder method for actual test discovery
+        - Duplicate folders are automatically eliminated using a set data structure
+        - The method does not validate the existence of specified folders; validation
+          occurs during the actual test discovery process
+        """
+        # Resolve the base path as an absolute path from the current working directory
+        base_path = (Path.cwd() / base_path).resolve()
+
+        # Use a set to store discovered folders and automatically eliminate duplicates
+        discovered_folders = set()
+
+        # Handle wildcard discovery: search all folders containing matching files
+        if folder_path == '*':
+
+            # Search recursively through the entire base path for folders with matching files
+            discovered_folders.update(self.__listMatchingFolders(base_path, base_path, pattern))
+
+        # Handle multiple folder paths: process each folder in the provided list
+        elif isinstance(folder_path, list):
+            for custom in folder_path:
+                # Resolve each custom folder path relative to the base path
+                custom_path = (base_path / custom).resolve()
+                # Add all matching folders found within this custom path
+                discovered_folders.update(self.__listMatchingFolders(base_path, custom_path, pattern))
+
+        # Handle single folder path: process the single specified folder
+        else:
+
+            # Resolve the single folder path relative to the base path
+            custom_path = (base_path / folder_path).resolve()
+            # Add all matching folders found within this single path
+            discovered_folders.update(self.__listMatchingFolders(base_path, custom_path, pattern))
+
+        # Iterate through all discovered folders and perform test discovery
+        for folder in discovered_folders:
+
+            # Use the existing discoverTestsInFolder method to actually discover and load tests
+            self.discoverTestsInFolder(
+                base_path=base_path,
+                folder_path=folder,
+                pattern=pattern,
+                test_name_pattern=test_name_pattern or None,
+                tags=tags or None
+            )
+
+        # Return the current instance to enable method chaining
+        return self
+
     def discoverTestsInFolder(
         self,
         *,
@@ -1342,6 +1440,37 @@ class UnitTest(IUnitTest):
         # Return the suite containing only the filtered tests
         return filtered_suite
 
+    def __listMatchingFolders(
+        self,
+        base_path: Path,
+        custom_path: Path,
+        pattern: str
+    ) -> List[str]:
+        """
+        List folders within a given path containing files matching a pattern.
+
+        Parameters
+        ----------
+        base_path : Path
+            The base directory path for calculating relative paths.
+        custom_path : Path
+            The directory path to search for matching files.
+        pattern : str
+            The filename pattern to match, supporting '*' and '?' wildcards.
+
+        Returns
+        -------
+        List[str]
+            List of relative folder paths containing files matching the pattern.
+        """
+        regex = re.compile('^' + pattern.replace('*', '.*').replace('?', '.') + '$')
+        matched_folders = set()
+        for root, _, files in walk(str(custom_path)):
+            if any(regex.fullmatch(file) for file in files):
+                rel_path = Path(root).relative_to(base_path).as_posix()
+                matched_folders.add(rel_path)
+        return list(matched_folders)
+
     def getTestNames(
         self
     ) -> List[str]:

orionis/test/kernel.py

@@ -1,9 +1,4 @@
-from pathlib import Path
-import re
-from typing import List
-from os import walk
 from orionis.console.output.contracts.console import IConsole
-from orionis.foundation.config.testing.entities.testing import Testing
 from orionis.foundation.contracts.application import IApplication
 from orionis.test.contracts.kernel import ITestKernel
 from orionis.test.contracts.unit_test import IUnitTest
@@ -18,115 +13,67 @@ class TestKernel(ITestKernel):
         """
         Initialize the TestKernel with the provided application instance.
 
+        This constructor sets up the test kernel by validating the application
+        instance and resolving required dependencies for testing operations.
+
         Parameters
         ----------
         app : IApplication
-            Application instance implementing the IApplication contract.
+            The application instance that provides dependency injection
+            and service resolution capabilities.
 
         Raises
         ------
         OrionisTestConfigException
-            If the provided app is not an instance of IApplication.
+            If the provided app parameter is not an instance of IApplication.
+
+        Returns
+        -------
+        None
+            This is a constructor method and does not return a value.
         """
+        # Validate that the provided app parameter is an IApplication instance
         if not isinstance(app, IApplication):
             raise OrionisTestConfigException(
                 f"Failed to initialize TestKernel: expected IApplication, got {type(app).__module__}.{type(app).__name__}."
             )
 
-        self.__config = Testing(**app.config('testing'))
+        # Resolve the unit test service from the application container
         self.__unit_test: IUnitTest = app.make('core.orionis.testing')
-        self.__unit_test._UnitTest__app = app
-        self.__unit_test._UnitTest__storage = app.path('storage_testing')
-        self.__console: IConsole = app.make('core.orionis.console')
-
-    def __listMatchingFolders(
-        self,
-        base_path: Path,
-        custom_path: Path,
-        pattern: str
-    ) -> List[str]:
-        """
-        List folders within a given path containing files matching a pattern.
-
-        Parameters
-        ----------
-        base_path : Path
-            The base directory path for calculating relative paths.
-        custom_path : Path
-            The directory path to search for matching files.
-        pattern : str
-            The filename pattern to match, supporting '*' and '?' wildcards.
 
-        Returns
-        -------
-        List[str]
-            List of relative folder paths containing files matching the pattern.
-        """
-        regex = re.compile('^' + pattern.replace('*', '.*').replace('?', '.') + '$')
-        matched_folders = set()
-        for root, _, files in walk(str(custom_path)):
-            if any(regex.fullmatch(file) for file in files):
-                rel_path = Path(root).relative_to(base_path).as_posix()
-                matched_folders.add(rel_path)
-        return list(matched_folders)
+        # Resolve the console service from the application container
+        self.__console: IConsole = app.make('core.orionis.console')
 
     def handle(self) -> IUnitTest:
         """
-        Configure, discover, and execute unit tests based on the current configuration.
+        Execute the unit test suite and handle any exceptions that occur during testing.
+
+        This method serves as the main entry point for running tests through the test kernel.
+        It executes the unit test suite via the injected unit test service and provides
+        comprehensive error handling for both expected test failures and unexpected errors.
+        The method ensures graceful termination of the application in case of any failures.
 
         Returns
         -------
         IUnitTest
-            The configured and executed unit test instance.
+            The unit test service instance after successful test execution. This allows
+            for potential chaining of operations or access to test results.
 
         Raises
         ------
-        OrionisTestFailureException
-            If test execution fails.
-        Exception
-            If an unexpected error occurs during test execution.
+        SystemExit
+            Indirectly raised through console.exitError() when test failures or
+            unexpected errors occur during test execution.
         """
-        try:
-            self.__unit_test.configure(
-                verbosity=self.__config.verbosity,
-                execution_mode=self.__config.execution_mode,
-                max_workers=self.__config.max_workers,
-                fail_fast=self.__config.fail_fast,
-                print_result=self.__config.print_result,
-                throw_exception=self.__config.throw_exception,
-                persistent=self.__config.persistent,
-                persistent_driver=self.__config.persistent_driver,
-                web_report=self.__config.web_report
-            )
-
-            base_path = (Path.cwd() / self.__config.base_path).resolve()
-            folder_path = self.__config.folder_path
-            pattern = self.__config.pattern
-            discovered_folders = set()
-
-            if folder_path == '*':
-                discovered_folders.update(self.__listMatchingFolders(base_path, base_path, pattern))
-            elif isinstance(folder_path, list):
-                for custom in folder_path:
-                    custom_path = (base_path / custom).resolve()
-                    discovered_folders.update(self.__listMatchingFolders(base_path, custom_path, pattern))
-            else:
-                custom_path = (base_path / folder_path).resolve()
-                discovered_folders.update(self.__listMatchingFolders(base_path, custom_path, pattern))
-
-            for folder in discovered_folders:
-                self.__unit_test.discoverTestsInFolder(
-                    folder_path=folder,
-                    base_path=self.__config.base_path,
-                    pattern=pattern,
-                    test_name_pattern=self.__config.test_name_pattern or None,
-                    tags=self.__config.tags or None
-                )
 
+        # Execute the unit test suite through the injected unit test service
+        try:
             return self.__unit_test.run()
 
+        # Handle expected test failures with a descriptive error message
         except OrionisTestFailureException as e:
             self.__console.exitError(f"Test execution failed: {e}")
 
+        # Handle any unexpected errors that occur during test execution
         except Exception as e:
             self.__console.exitError(f"An unexpected error occurred: {e}")

orionis/test/validators/workers.py

@@ -1,4 +1,4 @@
-from orionis.support.facades.workers import Workers
+from orionis.services.system.workers import Workers
 from orionis.test.exceptions import OrionisTestValueError
 
 class __ValidWorkers:
@@ -25,7 +25,7 @@ class __ValidWorkers:
         OrionisTestValueError
             If `max_workers` is not a positive integer within the allowed range.
         """
-        max_allowed = Workers.calculate()
+        max_allowed = Workers().calculate()
         if not isinstance(max_workers, int) or max_workers < 1 or max_workers > max_allowed:
             raise OrionisTestValueError(
                 f"Invalid max_workers: Expected a positive integer between 1 and {max_allowed}, got '{max_workers}' ({type(max_workers).__name__})."

{orionis-0.443.0.dist-info → orionis-0.444.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orionis
-Version: 0.443.0
+Version: 0.444.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro

{orionis-0.443.0.dist-info → orionis-0.444.0.dist-info}/RECORD

@@ -2,13 +2,16 @@ orionis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/app.py,sha256=b69fOzj2J8Aw5g0IldWZXixUDeeTO9vcHc_Njses9HU,603
 orionis/console/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console/kernel.py,sha256=1CuBCLR6KItRt0_m50YQXirJUMX6lJf4Z4vvOjBqaUU,856
-orionis/console/arguments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/console/arguments/parser.py,sha256=WRaeyRjqnwXKBLn56sK2jubS_DAPbfVQ2rtfUGluA8A,101
+orionis/console/args/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/console/args/argument.py,sha256=ZbY8Gbxbk6pvORRL1evzXB9qGesepD0zdbMsbqfcFjw,14688
+orionis/console/args/parser.py,sha256=WRaeyRjqnwXKBLn56sK2jubS_DAPbfVQ2rtfUGluA8A,101
+orionis/console/args/enums/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/console/args/enums/actions.py,sha256=S3T-vWS6DJSGtANrq3od3-90iYAjPvJwaOZ2V02y34c,1222
 orionis/console/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console/base/command.py,sha256=2kKyTaEzI16Up-XCUeNeJmDWPLN-CweQm3EgrN9U8NQ,3027
 orionis/console/base/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console/base/contracts/command.py,sha256=s9yjma-s1URkVm0EbVvSkETAm-N8xX7OnZS43P8pvk8,1957
-orionis/console/commands/version.py,sha256=TfiuMCcESdlNuhnbl_h9qbOb8aYDXcc5X1J5LfD1v7M,1041
+orionis/console/commands/version.py,sha256=kR8xzyc-Wisk7AXqg3Do7M9xTg_CxJgAtESPGrbRtpI,1673
 orionis/console/contracts/kernel.py,sha256=mh4LlhEYHh3FuGZZQ0GBhD6ZLa5YQvaNj2r01IIHI5Y,826
 orionis/console/core/reactor.py,sha256=lNfj-L4MKZhBn07l4H5L5dVW2xBRiq6-kyIuqnUNawQ,73
 orionis/console/dumper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -173,10 +176,10 @@ orionis/foundation/providers/inspirational_provider.py,sha256=ZIsuEq2Sif7C1b1hYC
 orionis/foundation/providers/logger_provider.py,sha256=PvwMxP5TKmn9DP8H8nJfyr16XgiJaGHyxPSMOpFgv84,1448
 orionis/foundation/providers/path_resolver_provider.py,sha256=s44Mg68RsUNPlilQlXMBE7onVexa7kyDmVQmci1JL4g,1342
 orionis/foundation/providers/progress_bar_provider.py,sha256=P__zpCyC29WCwErYGbh5dgcMRxw3XYmHzaUkzms9vPM,1345
-orionis/foundation/providers/testing_provider.py,sha256=o47qiK8Xoz4hfsxw4jMnMxEbSseJFIdJT-WqxGurqGc,1426
+orionis/foundation/providers/testing_provider.py,sha256=fSZfwKnScTxGlGrcEPReGIiOPs8XkoEaNNARN1wC6LU,2939
 orionis/foundation/providers/workers_provider.py,sha256=YMRLdq_YQnR1unnoYvDpYQZbLli04f0CckuR6Q--wKg,1379
 orionis/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/metadata/framework.py,sha256=0H0j_EmQM8BHWnt2ncNF6rkR_4bAOwUryKoXQsKlZ_M,4088
+orionis/metadata/framework.py,sha256=Que9Q_spu-gld9CNZt90yTGnUPDQBWf87yrjBiveqPQ,4088
 orionis/metadata/package.py,sha256=k7Yriyp5aUcR-iR8SK2ec_lf0_Cyc-C7JczgXa-I67w,16039
 orionis/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/asynchrony/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -302,7 +305,7 @@ orionis/support/standard/exceptions/value.py,sha256=rsyWFQweImaJGTJa7Id7RhPlwWJ4
 orionis/support/wrapper/__init__.py,sha256=jGoWoIGYuRYqMYQKlrX7Dpcbg-AGkHoB_aM2xhu73yc,62
 orionis/support/wrapper/dot_dict.py,sha256=T8xWwwOhBZHNeXRwE_CxvOwG9UFxsLqNmOJjV2CNIrc,7284
 orionis/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/test/kernel.py,sha256=OXsrfm0wLdm8eg1dvmE6kqK_0xXI6RcZJ5HUaGteGas,5185
+orionis/test/kernel.py,sha256=nJJDN2xusp9VZzezfocIvoenT2BheverjSovYCbRECg,3229
 orionis/test/cases/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/cases/asynchronous.py,sha256=3e1Y3qzIxVU7i7lbLFEVyJ89IA74JsB7famx71W-p2E,1974
 orionis/test/cases/synchronous.py,sha256=S5jhuDEZ5I9wosrTFaCtowkD5r5HzJH6mKPOdEJcDJE,1734
@@ -315,7 +318,7 @@ orionis/test/contracts/render.py,sha256=wpDQzUtT0r8KFZ7zPcxWHXQ1EVNKxzA_rZ6ZKUcZ
 orionis/test/contracts/test_result.py,sha256=SNXJ2UerkweYn7uCT0i0HmMGP0XBrL_9KJs-0ZvIYU4,4002
 orionis/test/contracts/unit_test.py,sha256=PSnjEyM-QGQ3Pm0ZOqaa8QdPOtilGBVO4R87JYdVa-8,5386
 orionis/test/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/test/core/unit_test.py,sha256=NiFk1u_a69JjQXBkXIzvlswoOniNm4YV4_dDGajRqQk,57400
+orionis/test/core/unit_test.py,sha256=IIpPLM4pXZKCpKAZ-0PPatGuWjBXxgjKQxB8IJLB1zY,63310
 orionis/test/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/entities/result.py,sha256=IMAd1AiwOf2z8krTDBFMpQe_1PG4YJ5Z0qpbr9xZwjg,4507
 orionis/test/enums/__init__.py,sha256=M3imAgMvKFTKg55FbtVoY3zxj7QRY9AfaUWxiSZVvn4,66
@@ -346,10 +349,10 @@ orionis/test/validators/tags.py,sha256=Qv-p8XFyAjY7OI861s52eADGf3LqzOWYfKt4L1cpo
 orionis/test/validators/throw_exception.py,sha256=PLtM94BArQf11VJhxfBHJSHARZSia-Q8ePixctU2JwQ,893
 orionis/test/validators/verbosity.py,sha256=rADzM82cPcJ2_6crszpobJuwb5WihWNQf6i4M_yrCpw,1785
 orionis/test/validators/web_report.py,sha256=n9BfzOZz6aEiNTypXcwuWbFRG0OdHNSmCNusHqc02R8,853
-orionis/test/validators/workers.py,sha256=HcZ3cnrk6u7cvM1xZpn_lsglHAq69_jx9RcTSvLrdb0,1204
+orionis/test/validators/workers.py,sha256=rWcdRexINNEmGaO7mnc1MKUxkHKxrTsVuHgbnIfJYgc,1206
 orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/view/render.py,sha256=f-zNhtKSg9R5Njqujbg2l2amAs2-mRVESneLIkWOZjU,4082
-orionis-0.443.0.dist-info/licenses/LICENCE,sha256=JhC-z_9mbpUrCfPjcl3DhDA8trNDMzb57cvRSam1avc,1463
+orionis-0.444.0.dist-info/licenses/LICENCE,sha256=JhC-z_9mbpUrCfPjcl3DhDA8trNDMzb57cvRSam1avc,1463
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -495,8 +498,8 @@ tests/testing/validators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 tests/testing/validators/test_testing_validators.py,sha256=WPo5GxTP6xE-Dw3X1vZoqOMpb6HhokjNSbgDsDRDvy4,16588
 tests/testing/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/testing/view/test_render.py,sha256=tnnMBwS0iKUIbogLvu-7Rii50G6Koddp3XT4wgdFEYM,1050
-orionis-0.443.0.dist-info/METADATA,sha256=O2L-DtPlApeU58Vi-0VNQlTpec1YZ6R7QCzdNjFBm0M,4772
-orionis-0.443.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-orionis-0.443.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.443.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-orionis-0.443.0.dist-info/RECORD,,
+orionis-0.444.0.dist-info/METADATA,sha256=YgxccCDNizNHssu-14sVeL6dVMvkTMfvdfd3UcB1SeY,4772
+orionis-0.444.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orionis-0.444.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.444.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.444.0.dist-info/RECORD,,