orionis 0.253.0__py3-none-any.whl → 0.265.0__py3-none-any.whl

orionis/luminate/test/output/{test_std_out.py → dumper.py}

@@ -1,11 +1,10 @@
 import os
 import sys
-from orionis.luminate.test.output.contracts.test_std_out import ITestStdOut
-from orionis.luminate.console.dumper.dump_die import Debug
+from orionis.luminate.test.output.contracts.dumper import ITestDumper
 
-class TestStdOut(ITestStdOut):
+class TestDumper(ITestDumper):
     """
-    TestStdOut provides utility methods for debugging and outputting information during test execution.
+    TestDumper 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.
@@ -49,6 +48,8 @@ class TestStdOut(ITestStdOut):
         original_stderr = sys.stderr
 
         try:
+            from orionis.luminate.console.dumper.dump_die import Debug
+
             sys.stdout = sys.__stdout__
             sys.stderr = sys.__stderr__
 
@@ -80,6 +81,8 @@ class TestStdOut(ITestStdOut):
         original_stderr = sys.stderr
 
         try:
+            from orionis.luminate.console.dumper.dump_die import Debug
+
             sys.stdout = sys.__stdout__
             sys.stderr = sys.__stderr__
 

orionis/luminate/test/suites/contracts/test_suite.py

@@ -0,0 +1,23 @@
+from abc import ABC, abstractmethod
+from orionis.luminate.foundation.config.testing.entities.testing import Testing as Configuration
+from orionis.luminate.test.suites.test_unit import UnitTest
+
+class ITestSuite(ABC):
+    """
+    Interface for configuring and running a UnitTest suite using a provided Configuration.
+    Methods:
+        run(config: Configuration = None) -> UnitTest
+    """
+
+    @abstractmethod
+    def run(self, config: Configuration = None) -> UnitTest:
+        """
+        Runs the test suite based on the provided configuration.
+        Args:
+            config (Configuration, optional): An optional Configuration object for the test suite.
+        Returns:
+            UnitTest: The result of the executed test suite.
+        Raises:
+            OrionisTestConfigException: If the config parameter is not an instance of Configuration.
+        """
+        pass

orionis/luminate/test/suites/test_suite.py

@@ -0,0 +1,101 @@
+import re
+from os import walk
+from orionis.luminate.foundation.config.testing.entities.testing import Testing as Configuration
+from orionis.luminate.test.suites.contracts.test_suite import ITestSuite
+from orionis.luminate.test.suites.test_unit import UnitTest
+from orionis.luminate.test.exceptions.test_config_exception import OrionisTestConfigException
+
+class TestSuite(ITestSuite):
+    """
+    TestSuite is a class responsible for managing and executing a suite of unit tests based on a configurable set of parameters.
+        config (Configuration, optional): An optional Configuration object that specifies parameters for the test suite execution. If not provided, a new Configuration instance is created.
+        _config (Configuration): The configuration object used to control test suite behavior, such as verbosity, execution mode, worker count, and test discovery patterns.
+    Methods:
+        __init__(config: Configuration = None):
+            Initializes the TestSuite with the provided configuration or a default one.
+        run() -> UnitTest:
+            Executes the test suite according to the configuration. Discovers test folders matching the specified pattern, adds discovered tests to the suite, and runs them.
+    """
+
+    def __init__(self, config:Configuration = None):
+        """
+        Initializes the object with the given configuration.
+
+        Args:
+            config (Configuration, optional): An optional Configuration object to initialize with. Defaults to None.
+
+        Attributes:
+            _config (Configuration): The configuration used by the object. If no configuration is provided, a new Configuration instance is created.
+        """
+        self._config = config or Configuration()
+
+    def run(self) -> UnitTest:
+        """
+        Runs the test suite based on the provided configuration.
+        This method initializes a UnitTest suite, configures it with parameters from the Configuration object,
+        discovers test folders matching the specified pattern, and adds the discovered tests to the suite.
+        Finally, it executes the test suite and returns the results.
+        Returns:
+            UnitTest: The result of the executed test suite.
+        Raises:
+            OrionisTestConfigException: If the provided configuration is not an instance of Configuration.
+        """
+
+        # Check if the config is provided
+        config = self._config
+
+        # Check if the config is an instance of Configuration
+        if not isinstance(config, Configuration):
+            raise OrionisTestConfigException("The config parameter must be an instance of the Configuration class.")
+
+        # Initialize the test suite
+        tests = UnitTest()
+
+        # 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
+        )
+
+        # 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):
+            matched_folders = []
+            for root, _, files in walk(custom_path):
+                for file in files:
+                    if re.fullmatch(pattern.replace('*', '.*').replace('?', '.'), file):
+                        relative_path = root.replace(base_path, '').replace('\\', '/').lstrip('/')
+                        if relative_path not in matched_folders:
+                            matched_folders.append(relative_path)
+            return matched_folders
+
+        # Discover folders
+        discovered_folders = []
+        if folder_path == '*':
+            discovered_folders.extend(list_matching_folders(base_path, pattern))
+        elif isinstance(folder_path, list):
+            for custom_path in folder_path:
+                discovered_folders.extend(list_matching_folders(f"{base_path}/{custom_path}", pattern))
+        else:
+            discovered_folders.extend(list_matching_folders(folder_path, pattern))
+
+        # Add discovered folders to the test suite
+        for folder in discovered_folders:
+            tests.discoverTestsInFolder(
+                folder_path=folder,
+                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
+        return tests.run()

orionis/luminate/test/{core → suites}/test_unit.py

@@ -14,11 +14,11 @@ from rich.panel import Panel
 from rich.syntax import Syntax
 from rich.table import Table
 from orionis.luminate.console.output.console import Console
-from orionis.luminate.test.core.contracts.test_unit import IUnitTest
+from orionis.luminate.test.suites.contracts.test_unit import IUnitTest
 from orionis.luminate.test.entities.test_result import TestResult
 from orionis.luminate.test.enums.test_mode import ExecutionMode
 from orionis.luminate.test.enums.test_status import TestStatus
-from orionis.luminate.test.exceptions.test_exception import OrionisTestFailureException
+from orionis.luminate.test.exceptions.test_failure_exception import OrionisTestFailureException
 
 class UnitTest(IUnitTest):
     """
@@ -40,7 +40,7 @@ class UnitTest(IUnitTest):
             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 (ExecutionMode): The mode of test execution (e.g., SEQUENTIAL or PARALLEL).
+            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.
@@ -55,7 +55,7 @@ class UnitTest(IUnitTest):
         self.start_time: float = 0.0
         self.print_result: bool = True
         self.verbosity: int = 2
-        self.execution_mode: ExecutionMode = ExecutionMode.SEQUENTIAL
+        self.execution_mode: str = ExecutionMode.SEQUENTIAL.value
         self.max_workers: int = 4
         self.fail_fast: bool = False
         self.rich_console = RichConsole()
@@ -67,7 +67,7 @@ class UnitTest(IUnitTest):
     def configure(
             self,
             verbosity: int = None,
-            execution_mode: ExecutionMode = None,
+            execution_mode: str | ExecutionMode = None,
             max_workers: int = None,
             fail_fast: bool = None,
             print_result: bool = None,
@@ -88,16 +88,24 @@ class UnitTest(IUnitTest):
         """
         if verbosity is not None:
             self.verbosity = verbosity
-        if execution_mode is not None:
+
+        if execution_mode is not None and isinstance(execution_mode, ExecutionMode):
+            self.execution_mode = execution_mode.value
+        else:
             self.execution_mode = execution_mode
+
         if max_workers is not None:
             self.max_workers = max_workers
+
         if fail_fast is not None:
             self.fail_fast = fail_fast
+
         if print_result is not None:
             self.print_result = print_result
+
         if throw_exception is not None:
             self.throw_exception = throw_exception
+
         return self
 
     def discoverTestsInFolder(
@@ -207,7 +215,7 @@ class UnitTest(IUnitTest):
         """
         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 else "Sequential"
+            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]",
@@ -255,7 +263,7 @@ class UnitTest(IUnitTest):
         error_buffer = io.StringIO()
 
         # Execute tests based on selected mode
-        if self.execution_mode == ExecutionMode.PARALLEL:
+        if self.execution_mode == ExecutionMode.PARALLEL.value:
             result = self._runTestsInParallel(output_buffer, error_buffer)
         else:
             result = self._runTestsSequentially(output_buffer, error_buffer)

orionis/unittesting.py

@@ -0,0 +1,43 @@
+from orionis.luminate.test.cases.test_case import TestCase
+from orionis.luminate.test.cases.test_sync import SyncTestCase
+from orionis.luminate.test.cases.test_async import AsyncTestCase
+
+from orionis.luminate.test.entities.test_result import TestResult
+
+from orionis.luminate.test.enums.test_mode import ExecutionMode
+from orionis.luminate.test.enums.test_status import TestStatus
+
+from orionis.luminate.test.exceptions.test_failure_exception import OrionisTestFailureException
+
+from orionis.luminate.test.suites.test_suite import Configuration, TestSuite
+from orionis.luminate.test.suites.test_unit import UnitTest
+
+from unittest import (
+    TestLoader as UnittestTestLoader,
+    TestSuite as UnittestTestSuite,
+    TestResult as UnittestTestResult,
+)
+from unittest.mock import (
+    Mock as UnittestMock,
+    MagicMock as UnittestMagicMock,
+    patch as unittest_mock_patch,
+)
+
+__all__ = [
+    "TestCase",
+    "SyncTestCase",
+    "AsyncTestCase",
+    "TestResult",
+    "ExecutionMode",
+    "TestStatus",
+    "OrionisTestFailureException",
+    "Configuration",
+    "TestSuite",
+    "UnitTest",
+    "UnittestTestLoader",
+    "UnittestTestSuite",
+    "UnittestTestResult",
+    "UnittestMock",
+    "UnittestMagicMock",
+    "unittest_mock_patch",
+]

{orionis-0.253.0.dist-info → orionis-0.265.0.dist-info}/METADATA

@@ -1,13 +1,27 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: orionis
-Version: 0.253.0
+Version: 0.265.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro
 Author-email: raulmauriciounate@gmail.com
-Classifier: Programming Language :: Python :: 3
+Keywords: orionis,framework,python,orionis-framework,django,flask,fastapi,starlettewerkzeuguvicorn
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Internet :: WWW/HTTP :: WSGI
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENCE
@@ -23,6 +37,8 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary