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

orionis/luminate/test/entities/test_result.py

@@ -1,30 +1,31 @@
 from dataclasses import dataclass
-from typing import Optional
+from typing import Any, Optional
 from orionis.luminate.test.enums.test_status import TestStatus
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, kw_only=True)
 class TestResult:
     """
-    Data class containing detailed information about a test result.
+    Represents the result of a test execution.
 
-    Attributes
-    ----------
-    name : str
-        The name of the test.
-    status : TestStatus
-        The status of the test, indicating whether it passed, failed, or was skipped.
-    execution_time : float
-        The time taken to execute the test, in seconds.
-    error_message : str, optional
-        The error message if the test failed, by default None.
-    traceback : str, optional
-        The traceback information if the test failed, by default None.
-    file_path : str, optional
-        The file path where the test is located, by default None.
+    Attributes:
+        id (Any): Unique identifier for the test result.
+        name (str): Name of the test.
+        status (TestStatus): Status of the test execution (e.g., passed, failed).
+        execution_time (float): Time taken to execute the test, in seconds.
+        error_message (Optional[str]): Error message if the test failed, otherwise None.
+        traceback (Optional[str]): Traceback information if an error occurred, otherwise None.
+        class_name (Optional[str]): Name of the class containing the test, if applicable.
+        method (Optional[str]): Name of the method representing the test, if applicable.
+        module (Optional[str]): Name of the module containing the test, if applicable.
+        file_path (Optional[str]): Path to the file containing the test, if applicable.
     """
+    id: Any
     name: str
     status: TestStatus
     execution_time: float
     error_message: Optional[str] = None
     traceback: Optional[str] = None
-    file_path: Optional[str] = None
+    class_name : Optional[str] = None
+    method : Optional[str] = None
+    module : Optional[str] = None
+    file_path: Optional[str] = None

orionis/luminate/test/enums/test_mode.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+class ExecutionMode(Enum):
+    """
+    ExecutionMode is an enumeration that defines the modes of execution
+    for a process or task.
+
+    Attributes
+    ----------
+    SEQUENTIAL : str
+        Represents sequential execution mode, where tasks are executed one after another.
+    PARALLEL : str
+        Represents parallel execution mode, where tasks are executed concurrently.
+    """
+    SEQUENTIAL = "sequential"
+    PARALLEL = "parallel"

orionis/luminate/test/exceptions/test_config_exception.py

@@ -0,0 +1,28 @@
+class OrionisTestConfigException(Exception):
+    """
+    Custom exception for test configuration errors in the Orionis framework.
+
+    This exception is raised when there is an issue with the test configuration,
+    providing a clear and descriptive error message to aid in debugging.
+    """
+
+    def __init__(self, msg: str):
+        """
+        Initializes the OrionisTestConfigException with a specific error message.
+
+        Args:
+            msg (str): A descriptive error message explaining the cause of the exception.
+        """
+        super().__init__(msg)
+
+    def __str__(self) -> str:
+        """
+        Returns a formatted string representation of the exception.
+
+        The string includes the exception name and the error message, providing
+        a clear and concise description of the issue.
+
+        Returns:
+            str: A formatted string describing the exception.
+        """
+        return f"{self.__class__.__name__}: {self.args[0]}"

orionis/luminate/test/exceptions/test_exception.py

@@ -1,45 +1,52 @@
+import unittest
+
 class OrionisTestFailureException(Exception):
     """
-    Custom exception raised when test execution results in one or more failures.
-
-    This exception is used to indicate that a test suite run has encountered failures.
-    It stores a response message detailing the number of failed tests or other relevant
-    error information.
-
-    Parameters
-    ----------
-    response : str
-        A message describing the reason for the test failure.
-
-    Attributes
-    ----------
-    response : str
-        Stores the response message describing the failure.
-
-    Methods
-    -------
-    __str__() -> str
-        Returns a string representation of the exception, including the response message.
+    OrionisTestFailureException is a custom exception class used to handle test failures and errors
+    in a structured manner. It provides detailed information about the failed and errored tests,
+    including their IDs and formatted error messages.
+    Methods:
+        __init__(result: unittest.TestResult):
+        __str__() -> str:
     """
 
-    def __init__(self, response: str):
+    def __init__(self, result: unittest.TestResult):
         """
-        Initializes the exception with a response message.
-
-        Parameters
-        ----------
-        response : str
-            The message describing the test failure.
+        Initializes the exception with details about failed and errored tests.
+        Args:
+            result (unittest.TestResult): The test result object containing information
+                about test failures and errors.
+        Attributes:
+            failed_tests (list): A list of IDs for tests that failed.
+            errored_tests (list): A list of IDs for tests that encountered errors.
+            error_messages (list): A list of formatted error messages for failed and errored tests.
+            text (str): A formatted string summarizing the test failures and errors.
+        Raises:
+            Exception: An exception with a message summarizing the number of failed
+                and errored tests along with their details.
         """
-        super().__init__(response)
+        failed_tests = [test.id() for test, _ in result.failures]
+        errored_tests = [test.id() for test, _ in result.errors]
+
+        error_messages = []
+        for test in failed_tests:
+            error_messages.append(f"Test Fail: {test}")
+        for test in errored_tests:
+            error_messages.append(f"Test Error: {test}")
+
+        text = "\n".join(error_messages)
+
+        super().__init__(f"{len(failed_tests) + len(errored_tests)} test(s) failed or errored:\n{text}")
 
     def __str__(self) -> str:
         """
-        Returns a human-readable string representation of the exception.
+        Returns a string representation of the exception.
+
+        The string includes the exception name and the first argument
+        passed to the exception, providing a clear description of the
+        test failure.
 
-        Returns
-        -------
-        str
-            A formatted string containing the exception name and response message.
+        Returns:
+            str: A formatted string describing the exception.
         """
-        return f"OrionisTestFailureException: {self.args[0]}"
+        return f"{self.__class__.__name__}: {self.args[0]}"

orionis/luminate/test/output/contracts/test_std_out.py

@@ -1,17 +1,28 @@
-from typing import Any
-
-class ITestStdOut:
+from abc import ABC, abstractmethod
+class ITestStdOut(ABC):
     """
-    Utility for printing debug info during tests, including caller context (file, line, method).
+    Interface for standard output debugging utilities.
+    This interface defines methods for dumping debugging information, capturing the caller's file, method, and line number, and utilizing a Debug class to output the information. Implementations should provide mechanisms to output or log the provided arguments for debugging purposes
     """
 
-    @staticmethod
-    def print(*args: Any) -> None:
+    @abstractmethod
+    def dd(self, *args):
+        """
+        Dumps debugging information using the Debug class.
+        This method captures the caller's file, method, and line number,
+        and uses the Debug class to output debugging information.
+        Args:
+            *args: Variable length argument list to be dumped.
         """
-        Print arguments to the console with file, line, and method of the caller.
+        pass
 
-        Parameters
-        ----------
-        *args : Any
-            Any values to print. The first argument is ignored (typically the class or context).
+    @abstractmethod
+    def dump(self, *args):
+        """
+        Dumps debugging information using the Debug class.
+        This method captures the caller's file, method, and line number,
+        and uses the Debug class to output debugging information.
+        Args:
+            *args: Variable length argument list to be dumped.
         """
+        pass

orionis/luminate/test/output/test_std_out.py

@@ -1,66 +1,97 @@
 import os
 import sys
-from orionis.luminate.console.output.console import Console
 from orionis.luminate.test.output.contracts.test_std_out import ITestStdOut
+from orionis.luminate.console.dumper.dump_die import Debug
 
 class TestStdOut(ITestStdOut):
     """
-    A utility class for printing debug information during testing. This class temporarily
-    redirects the standard output and error streams to their original states to ensure
-    proper console output, and provides contextual information about the file and line
-    number where the print call was made.
-    Methods
-    -------
-    print(*args)
-        Prints the provided arguments to the console with contextual information
-        about the file and line number of the caller. If no arguments are provided,
-        the method does nothing.
+    TestStdOut provides utility methods for debugging and outputting information during test execution.
+    This class implements methods to determine if an object is a test case instance and to output debugging
+    information using the Debug class. It ensures that standard output and error streams are properly managed
+    during debugging dumps, and captures the caller's file and line number for context.
     """
 
-    def print(*args):
+    def __isTestCaseClass(self, value):
         """
-        Prints the provided arguments to the console with contextual information
-        about the file and line number of the caller. The output is formatted with
-        muted text decorations for better readability.
-        Parameters
-        ----------
-        *args : tuple
-            The arguments to be printed. The first argument is ignored, and the
-            remaining arguments are printed. If no arguments are provided, the
-            method does nothing.
-        Notes
-        -----
-        - The method temporarily redirects `sys.stdout` and `sys.stderr` to their
-          original states (`sys.__stdout__` and `sys.__stderr__`) to ensure proper
-          console output.
-        - The contextual information includes the file path and line number of the
-          caller, which is displayed in a muted text format.
-        - After printing, the method restores the original `sys.stdout` and
-          `sys.stderr` streams.
+        Determines if the given value is an instance of a test case class.
+        This method checks whether the provided value is an instance of one of the
+        predefined test case classes: AsyncTestCase, TestCase, or SyncTestCase.
+        If the value is None or an ImportError occurs during the import of the
+        test case classes, the method returns False.
+        Args:
+            value: The object to be checked.
+        Returns:
+            bool: True if the value is an instance of AsyncTestCase, TestCase,
+            or SyncTestCase; False otherwise.
         """
+        try:
+            if value is None:
+                return False
+            from orionis.luminate.test.cases.test_async import AsyncTestCase
+            from orionis.luminate.test.cases.test_case import TestCase
+            from orionis.luminate.test.cases.test_sync import SyncTestCase
+            return isinstance(value, (AsyncTestCase, TestCase, SyncTestCase))
+        except Exception:
+            return False
 
-        # Check if the first argument is a string and remove it from the args tuple
-        if len(args) == 0:
+    def dd(self, *args):
+        """
+        Dumps debugging information using the Debug class.
+        This method captures the caller's file, method, and line number,
+        and uses the Debug class to output debugging information.
+        Args:
+            *args: Variable length argument list to be dumped.
+        """
+        if not args:
+            return
+
+        original_stdout = sys.stdout
+        original_stderr = sys.stderr
+
+        try:
+            sys.stdout = sys.__stdout__
+            sys.stderr = sys.__stderr__
+
+            caller_frame = sys._getframe(1)
+            _file = os.path.abspath(caller_frame.f_code.co_filename)
+            _line = caller_frame.f_lineno
+
+            dumper = Debug(f"{_file}:{_line}")
+            if self.__isTestCaseClass(args[0]):
+                dumper.dd(*args[1:])
+            else:
+                dumper.dd(*args)
+        finally:
+            sys.stdout = original_stdout
+            sys.stderr = original_stderr
+
+    def dump(self, *args):
+        """
+        Dumps debugging information using the Debug class.
+        This method captures the caller's file, method, and line number,
+        and uses the Debug class to output debugging information.
+        Args:
+            *args: Variable length argument list to be dumped.
+        """
+        if not args:
             return
 
-        # Change the output stream to the original stdout and stderr
-        # to avoid any issues with the console output
         original_stdout = sys.stdout
         original_stderr = sys.stderr
-        sys.stdout = sys.__stdout__
-        sys.stderr = sys.__stderr__
 
-        # Get the file name and line number of the caller
-        # using sys._getframe(1) to access the caller's frame
-        _file = os.path.relpath(sys._getframe(1).f_code.co_filename, start=os.getcwd())
-        _method = sys._getframe(1).f_code.co_name
-        _line = sys._getframe(1).f_lineno
+        try:
+            sys.stdout = sys.__stdout__
+            sys.stderr = sys.__stderr__
 
-        # Print the contextual information and the provided arguments
-        Console.textMuted(f"[Printout] File: {_file}, Line: {_line}, Method: {_method}")
-        print(*args[1:], end='\n')
-        Console.newLine()
+            caller_frame = sys._getframe(1)
+            _file = os.path.abspath(caller_frame.f_code.co_filename)
+            _line = caller_frame.f_lineno
 
-        # Restore the original stdout and stderr streams
-        sys.stdout = original_stdout
-        sys.stderr = original_stderr
+            dumper = Debug(f"{_file}:{_line}")
+            if self.__isTestCaseClass(args[0]):
+                dumper.dump(*args[1:])
+            else:
+                dumper.dump(*args)
+        finally:
+            sys.stdout = original_stdout
+            sys.stderr = original_stderr

{orionis-0.245.0.dist-info → orionis-0.247.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: orionis
-Version: 0.245.0
+Version: 0.247.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro
@@ -14,6 +14,9 @@ License-File: LICENCE
 Requires-Dist: apscheduler>=3.11.0
 Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: requests>=2.32.3
+Requires-Dist: rich>=13.9.4
+Requires-Dist: psutil>=7.0.0
+Requires-Dist: cryptography>=44.0.3
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier