orionis 0.245.0__py3-none-any.whl → 0.246.0__py3-none-any.whl

orionis/framework.py

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

orionis/luminate/config/contracts/config.py

@@ -0,0 +1,27 @@
+from abc import ABC
+from dataclasses import dataclass
+
+@dataclass
+class EmptyData:
+    """
+    A placeholder dataclass that can be used as a default or empty configuration.
+    This class doesn't have any fields or data, but serves as a default value
+    for the 'config' attribute in classes implementing IConfig.
+    """
+    pass
+
+class IConfig(ABC):
+    """
+    An abstract base class that defines an interface for classes that must have
+    a `config` attribute.
+
+    The subclass is required to implement the `config` attribute, which should be
+    a dataclass instance representing the configuration data.
+
+    Attributes
+    ----------
+    config : object
+        A dataclass instance representing the configuration.
+    """
+
+    config = EmptyData()

orionis/luminate/config/entities/testing.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass
+from typing import List
+
+@dataclass(frozen=True, kw_only=True)
+class Testing:
+    """
+    Testing is a dataclass that holds configuration options for running tests.
+
+    Attributes:
+        verbosity (int): The verbosity level of the test output. Default is 2.
+            - 0: Silent
+            - 1: Minimal output
+            - 2: Detailed output (default)
+        execution_mode (ExecutionMode): The mode of test execution. Default is ExecutionMode.SEQUENTIAL.
+            - ExecutionMode.SEQUENTIAL: Tests are executed one after another.
+            - ExecutionMode.PARALLEL: Tests are executed in parallel.
+        max_workers (int): The maximum number of worker threads/processes to use when running tests in parallel. Default is 4.
+        fail_fast (bool): Whether to stop execution after the first test failure. Default is False.
+        print_result (bool): Whether to print the test results to the console. Default is True.
+        throw_exception (bool): Whether to throw an exception if a test fails. Default is False.
+        base_path (str): The base directory where tests are located. Default is 'tests'.
+        folder_path (str): The folder path pattern to search for tests. Default is '*'.
+        pattern (str): The filename pattern to identify test files. Default is 'test_*.py'.
+        test_name_pattern (str | None): A pattern to match specific test names. Default is None.
+        tags (List[str] | None): A list of tags to filter tests. Default is None.
+    """
+    verbosity: int = 2
+    execution_mode: str = 'sequential'
+    max_workers: int = 4
+    fail_fast: bool = False
+    print_result: bool = True
+    throw_exception: bool = False
+    base_path: str = 'tests'
+    folder_path: str = '*'
+    pattern: str = 'test_*.py'
+    test_name_pattern: str | None = None,
+    tags: List[str] | None = None

orionis/luminate/support/environment/env.py

@@ -8,6 +8,7 @@ from orionis.luminate.support.environment.functions import (
     _serialize_value,
     _delete_file
 )
+from orionis.luminate.support.patterns.singleton import SingletonMeta
 
 class Env(IEnv):
     """

orionis/luminate/support/introspection/abstracts/entities/abstract_class_attributes.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+from typing import Any, Dict
+
+@dataclass(frozen=True, kw_only=True)
+class AbstractClassAttributes:
+    """
+    A class to represent the attributes of an entity.
+    """
+    public: Dict[str, Any]
+    private: Dict[str, Any]
+    protected: Dict[str, Any]

orionis/luminate/support/introspection/abstracts/reflect_abstract.py

@@ -3,11 +3,11 @@ import ast
 import inspect
 import types
 from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Type, TypeVar
-from orionis.luminate.support.introspection.contracts.reflexion_abstract import IReflexionAbstract
+from orionis.luminate.support.introspection.abstracts.entities.abstract_class_attributes import AbstractClassAttributes
 
 ABC = TypeVar('ABC', bound=abc.ABC)
 
-class ReflexionAbstract(IReflexionAbstract):
+class ReflexionAbstract:
     """A reflection object encapsulating an abstract class.
 
     Parameters
@@ -64,7 +64,7 @@ class ReflexionAbstract(IReflexionAbstract):
         """
         return self._abstract.__module__
 
-    def getAllAttributes(self) -> Dict[str, Any]:
+    def getAllAttributes(self) -> AbstractClassAttributes:
         """
         Get all attributes of the abstract class.
 
@@ -93,11 +93,161 @@ class ReflexionAbstract(IReflexionAbstract):
             else:
                 public[attr] = value
 
-        return {"public": public, "protected": protected, "private": private}
+        return AbstractClassAttributes(
+            public=public,
+            private=private,
+            protected=protected
+        )
 
+    def getAttributes(self) -> Dict[str, Any]:
+        """
+        Get all attributes of the instance.
 
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary of attribute names and their values
+        """
+        attr = self.getAllAttributes()
+        return {**attr.public, **attr.private, **attr.protected}
 
+    def getPublicAttributes(self) -> Dict[str, Any]:
+        """
+        Get all public attributes of the instance.
 
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary of public attribute names and their values
+        """
+        attr = self.getAllAttributes()
+        return attr.public
+
+    def getPrivateAttributes(self) -> Dict[str, Any]:
+        """
+        Get all private attributes of the instance.
+
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary of private attribute names and their values
+        """
+        attr = self.getAllAttributes()
+        return attr.private
+
+    def getProtectedAttributes(self) -> Dict[str, Any]:
+        """
+        Get all Protected attributes of the instance.
+
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary of Protected attribute names and their values
+        """
+        attr = self.getAllAttributes()
+        return attr.protected
+
+    def getAllMethods(self) -> Dict[str, List[str]]:
+        """
+        Categorize all methods and relevant members of the abstract class into public, private, protected,
+        static, asynchronous, synchronous, class methods, magic methods, abstract methods, and properties.
+
+        Returns
+        -------
+        Dict[str, List[str]]
+            A dictionary categorizing methods and attributes into various types.
+        """
+        class_name = self.getClassName()
+        private_prefix = f"_{class_name}"
+        attributes = set(self.getAttributes().keys()) | {attr for attr in dir(self._abstract) if attr.startswith('_abc_')}
+
+        result = {
+            "public": [],
+            "private": [],
+            "protected": [],
+            "static": [],
+            "asynchronous": [],
+            "synchronous": [],
+            "class_methods": [],
+            "asynchronous_static": [],
+            "synchronous_static": [],
+            "magic": [],
+            "abstract": [],
+            "abstract_class_methods": [],
+            "abstract_static_methods": []
+        }
+
+        # Precompute all members once
+        members = inspect.getmembers(self._abstract)
+        static_attrs = {}
+
+        # First pass to collect all relevant information
+        for name, attr in members:
+            if name in attributes:
+                continue
+
+            # Get static attribute once
+            static_attr = inspect.getattr_static(self._abstract, name)
+            static_attrs[name] = static_attr
+
+            # Magic methods
+            if name.startswith("__") and name.endswith("__"):
+                result["magic"].append(name)
+                continue
+
+            # Static and class methods
+            if isinstance(static_attr, staticmethod):
+                result["static"].append(name)
+            elif isinstance(static_attr, classmethod):
+                result["class_methods"].append(name)
+
+            # Private, protected, public
+            if name.startswith(private_prefix):
+                clean_name = name.replace(private_prefix, "")
+                result["private"].append(clean_name)
+            elif name.startswith("_"):
+                result["protected"].append(name)
+            else:
+                result["public"].append(name)
+
+            # Async methods
+            if inspect.iscoroutinefunction(attr):
+                clean_name = name.replace(private_prefix, "")
+                if name in result["static"]:
+                    result["asynchronous_static"].append(clean_name)
+                else:
+                    result["asynchronous"].append(clean_name)
+
+        # Second pass for synchronous methods (needs info from first pass)
+        for name, attr in members:
+            if name in attributes or name in result["magic"] or name in result["class_methods"] or name in result["static"]:
+                continue
+
+            if inspect.isfunction(attr):
+                clean_name = name.replace(private_prefix, "")
+                if clean_name not in result["asynchronous"]:
+                    result["synchronous"].append(clean_name)
+
+        # Synchronous static methods
+        for name in result["static"]:
+            if name not in attributes and name not in result["asynchronous_static"] and name not in result["class_methods"]:
+                result["synchronous_static"].append(name)
+
+        # Abstract methods
+        abstract_methods = getattr(self._abstract, "__abstractmethods__", set())
+        for name in abstract_methods:
+            if name in attributes:
+                continue
+
+            static_attr = static_attrs.get(name, inspect.getattr_static(self._abstract, name))
+            if isinstance(static_attr, staticmethod):
+                result["abstract_static_methods"].append(name)
+            elif isinstance(static_attr, classmethod):
+                result["abstract_class_methods"].append(name)
+            elif not isinstance(static_attr, property):
+                result["abstract"].append(name)
+
+        return result
 
 
 
@@ -109,19 +259,7 @@ class ReflexionAbstract(IReflexionAbstract):
 
 
 
-    def getAbstractMethods(self) -> Set[str]:
-        """Get all abstract method names required by the class.
 
-        Returns
-        -------
-        Set[str]
-            Set of abstract method names
-        """
-        methods = []
-        for method in self._abstract.__abstractmethods__:
-            if not isinstance(getattr(self._abstract, method), property):
-                methods.append(method)
-        return set(methods)
 
     def getAbstractProperties(self) -> Set[str]:
         """Get all abstract property names required by the class.

orionis/luminate/support/introspection/instances/reflection_instance.py

@@ -171,8 +171,8 @@ class ReflectionInstance(IReflectionInstance):
     def getAllMethods(self):
         """
         Retrieves and categorizes all methods of the instance's class into various classifications.
-        This method inspects the instance's class and its methods, categorizing them into public, private, 
-        protected, static, asynchronous, synchronous, class methods, asynchronous static, synchronous static, 
+        This method inspects the instance's class and its methods, categorizing them into public, private,
+        protected, static, asynchronous, synchronous, class methods, asynchronous static, synchronous static,
         and magic methods.
         Returns
         -------

orionis/luminate/test/core/contracts/test_unit.py

@@ -1,82 +1,122 @@
-from typing import Any, Dict, Optional
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+from orionis.luminate.test.enums.test_mode import ExecutionMode
 
-class IUnitTest:
-    """
-    Advanced unit testing utility for discovering, executing, and reporting test results
-    with support for folder-based discovery, regex filtering, and customizable output.
+class IUnitTest(ABC):
 
-    Attributes
-    ----------
-    loader : unittest.TestLoader
-        Internal loader for test discovery.
-    suite : unittest.TestSuite
-        The aggregated test suite to be executed.
-    test_results : List[TestResult]
-        List of captured results per test, including status and errors.
-    start_time : float
-        Timestamp when the test execution started.
-    """
+    @abstractmethod
+    def configure(
+            self,
+            verbosity: int = None,
+            execution_mode: ExecutionMode = None,
+            max_workers: int = None,
+            fail_fast: bool = None,
+            print_result: bool = None
+        ):
+        """
+        Configures the UnitTest instance with the specified parameters.
+
+        Parameters:
+            verbosity (int, optional): The verbosity level for test output. Defaults to None.
+            execution_mode (ExecutionMode, optional): The mode in which the tests will be executed. Defaults to None.
+            max_workers (int, optional): The maximum number of workers to use for parallel execution. Defaults to None.
+            fail_fast (bool, optional): Whether to stop execution upon the first failure. Defaults to None.
+            print_result (bool, optional): Whether to print the test results after execution. Defaults to None.
+
+        Returns:
+            UnitTest: The configured UnitTest instance.
+        """
+        pass
 
+    @abstractmethod
     def discoverTestsInFolder(
         self,
         folder_path: str,
         base_path: str = "tests",
         pattern: str = "test_*.py",
-        test_name_pattern: Optional[str] = None
+        test_name_pattern: Optional[str] = None,
+        tags: Optional[List[str]] = None
     ):
         """
-        Discover and add test cases from a given folder to the test suite.
+        Discovers and loads unit tests from a specified folder.
+        Args:
+            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".
+            pattern (str, optional): The filename 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 (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.
+        Raises:
+            ValueError: If the test folder does not exist, no tests are found, or an error occurs during test discovery.
+        """
+        pass
+
+    @abstractmethod
+    def discoverTestsInModule(self, module_name: str, test_name_pattern: Optional[str] = None):
+        """
+        Discovers and loads tests from a specified module, optionally filtering them
+        by a test name pattern, and adds them to the test suite.
+        Args:
+            module_name (str): The name of the module to discover tests from.
+            test_name_pattern (Optional[str]): A pattern to filter test names. Only
+                tests matching this pattern will be included. Defaults to None.
+        Returns:
+            UnitTest: The current instance of the UnitTest class, allowing method chaining.
+        Raises:
+            ValueError: If the specified module cannot be imported.
+        """
+        pass
+
+    @abstractmethod
+    def run(self, print_result: bool = None, throw_exception: bool = False) -> Dict[str, Any]:
+        """
+        Executes the test suite and processes the results.
+        Args:
+            print_result (bool, optional): If provided, overrides the instance's
+                `print_result` attribute to determine whether to print the test results.
+            throw_exception (bool, optional): If True, raises an exception if any
+                test failures or errors are detected.
+        Returns:
+            Dict[str, Any]: A summary of the test execution, including details such as
+            execution time, test results, and a timestamp.
+        Raises:
+            OrionisTestFailureException: If `throw_exception` is True and there are
+            test failures or errors.
+        """
+        pass
 
-        Parameters
-        ----------
-        folder_path : str
-            Relative path to the folder containing test files.
-        base_path : str, default="tests"
-            Base path used to resolve full path to test modules.
-        pattern : str, default="test_*.py"
-            Glob pattern to match test filenames.
-        test_name_pattern : Optional[str], optional
-            Regex pattern to filter discovered test method names.
+    @abstractmethod
+    def getTestNames(self) -> List[str]:
+        """
+        Retrieves a list of test names from the test suite.
 
-        Returns
-        -------
-        UnitTest
-            Self instance for chaining.
+        This method flattens the test suite and extracts the unique identifier
+        (`id`) of each test case.
 
-        Raises
-        ------
-        ValueError
-            If folder is invalid or no tests are found.
+        Returns:
+            List[str]: A list of test names (unique identifiers) from the test suite.
         """
         pass
 
-    def run(self, print_result:bool = True, throw_exception:bool = False) -> Dict[str, Any]:
+    @abstractmethod
+    def getTestCount(self) -> int:
         """
-        Run all added tests and return a summary of the results.
+        Calculate the total number of tests in the test suite.
 
-        Parameters
-        ----------
-        print_result : bool, default=True
-            Whether to print a formatted report to the console.
-        throw_exception : bool, default=False
-            Raise an exception if there are failures or errors.
+        This method flattens the test suite structure and counts the total
+        number of individual test cases.
 
-        Returns
-        -------
-        Dict[str, Any]
-            Summary including:
-            - total_tests : int
-            - passed : int
-            - failed : int
-            - errors : int
-            - skipped : int
-            - total_time : str (e.g., '1.234 seconds')
-            - success_rate : str (e.g., '87.5%')
-            - test_details : List[Dict[str, Any]]
+        Returns:
+            int: The total number of test cases in the test suite.
+        """
+        pass
+
+    @abstractmethod
+    def clearTests(self) -> None:
+        """
+        Clears the current test suite by reinitializing it to an empty `unittest.TestSuite`.
 
-        Raises
-        ------
-        OrionisTestFailureException
-            If any test fails or errors occur and `throw_exception=True`.
+        This method is used to reset the test suite, removing any previously added tests.
         """
         pass

orionis/luminate/test/core/test_suite.py

@@ -1,53 +1,61 @@
 import re
 from os import walk
-from orionis.luminate.test.core.contracts.test_suite import ITestSuite
-from orionis.luminate.test.core.test_unit import UnitTest as UnitTestClass
+from orionis.luminate.config.entities.testing import Testing
+from orionis.luminate.test.core.test_unit import UnitTest
+from orionis.luminate.test.exceptions.test_config_exception import OrionisTestConfigException
 
-class TestSuite(ITestSuite):
-    """
-    A class containing test utility methods.
-    """
+class TestSuite:
 
     @staticmethod
-    def load(
-        base_path: str = 'tests',
-        folder_path: list | str = '*',
-        pattern: str = 'test_*.py'
-    ) -> UnitTestClass:
+    def config(config:Testing) -> UnitTest:
+        """
+            Configures and initializes a test suite based on the provided configuration.
+            Args:
+                config (Testing): An instance of the `Testing` class containing configuration
+                                  parameters for the test suite.
+            Returns:
+                UnitTest: An initialized test suite configured with the provided settings.
+            Raises:
+                OrionisTestConfigException: If the `config` parameter is not an instance of
+                                            the `Testing` class.
+            The function performs the following steps:
+            1. Validates that the `config` parameter is an instance of the `Testing` class.
+            2. Initializes a `UnitTest` object and assigns configuration values to it.
+            3. Extracts configuration values such as `base_path`, `folder_path`, and `pattern`.
+            4. Discovers folders matching the specified `folder_path` and `pattern`:
+               - If `folder_path` is '*', all matching folders in the `base_path` are discovered.
+               - If `folder_path` is a list, matching folders in each path are discovered.
+               - Otherwise, matching folders in the specified `folder_path` are discovered.
+            5. Adds discovered folders to the test suite by calling `discoverTestsInFolder`.
+            Notes:
+                - The `list_matching_folders` helper function is used to find folders matching
+                  the specified pattern.
+                - The `pattern` supports wildcard characters (`*` and `?`) for flexible matching.
+                - The `test_name_pattern` and `tags` from the `config` are used when adding
+                  folders to the test suite.
         """
-        Discover and initialize a test suite from the specified folder(s).
 
-        This method scans the provided folder(s) for test files matching the given pattern
-        and initializes a test suite with the discovered files.
+        # Check if the config is an instance of Testing
+        if not isinstance(config, Testing):
+            raise OrionisTestConfigException("The config parameter must be an instance of the Testing class.")
 
-        Parameters
-        ----------
-        base_path : str, optional
-            The base path for the tests. Defaults to 'tests'.
-        folder_path : str or list of str, optional
-            Path(s) to the folder(s) containing test files. Use '*' to scan all folders
-            under the base path. Defaults to '*'.
-        pattern : str, optional
-            File pattern to match test files. Defaults to 'test_*.py'.
+        # Initialize the test suite
+        tests = UnitTest()
 
-        Returns
-        -------
-        UnitTestClass
-            An initialized test suite containing the discovered test files.
+        # Assign config values to the test suite
+        tests.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
+        )
 
-        Raises
-        ------
-        TypeError
-            If `base_path` is not a string, `folder_path` is not a string or list, or
-            `pattern` is not a string.
-        """
-        # Validate parameters
-        if not isinstance(base_path, str):
-            raise TypeError("base_path must be a string")
-        if not isinstance(folder_path, (str, list)):
-            raise TypeError("folder_path must be a string or a list")
-        if not isinstance(pattern, str):
-            raise TypeError("pattern must be a string")
+        # Extract configuration values
+        base_path = config.base_path
+        folder_path = config.folder_path
+        pattern = config.pattern
 
         # Helper function to list folders matching the pattern
         def list_matching_folders(custom_path: str, pattern: str):
@@ -70,15 +78,14 @@ class TestSuite(ITestSuite):
         else:
             discovered_folders.extend(list_matching_folders(folder_path, pattern))
 
-        # Initialize the test suite
-        tests = UnitTestClass()
-
         # Add discovered folders to the test suite
         for folder in discovered_folders:
             tests.discoverTestsInFolder(
-                base_path=base_path,
                 folder_path=folder,
-                pattern=pattern
+                base_path=base_path,
+                pattern=pattern,
+                test_name_pattern=config.test_name_pattern if config.test_name_pattern else None,
+                tags=config.tags if config.tags else None
             )
 
         # Return the initialized test suite