orionis 0.703.0__tar.gz → 0.705.0__tar.gz

{orionis-0.703.0/orionis.egg-info → orionis-0.705.0}/PKG-INFO

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

{orionis-0.703.0 → orionis-0.705.0}/orionis/console/commands/test.py

@@ -1,3 +1,5 @@
+from typing import List
+from orionis.console.args.argument import CLIArgument
 from orionis.console.base.command import BaseCommand
 from orionis.console.exceptions import CLIOrionisRuntimeError
 from orionis.foundation.contracts.application import IApplication
@@ -26,6 +28,32 @@ class TestCommand(BaseCommand):
     # Command description
     description: str = "Executes all automated tests using the configured test kernel for the Orionis application."
 
+    def options(self) -> List[CLIArgument]:
+        """
+        Returns the list of command-line options available for the test command.
+
+        This method defines the supported CLI arguments for the test command,
+        allowing users to specify additional options such as the modules to test.
+
+        Returns
+        -------
+        List[CLIArgument]
+            A list containing CLIArgument instances that describe the available
+            command-line options for the test command.
+        """
+
+        # Define the available command-line options for the test command
+        return [
+            CLIArgument(
+                flags=["--module", "-m"],
+                type=str,
+                default=[],
+                help="Specify one or more test modules to execute (can be used multiple times).",
+                action="append",
+                dest="modules"
+            )
+        ]
+
     def handle(self, app: IApplication) -> dict:
         """
         Executes all automated tests using the configured test kernel.
@@ -59,7 +87,9 @@ class TestCommand(BaseCommand):
             kernel: ITestKernel = app.make(ITestKernel)
 
             # Run the test suite using the kernel's handle method
-            return kernel.handle()
+            return kernel.handle(
+                modules=self.argument("modules")
+            )
 
         except Exception as e:
 

{orionis-0.703.0 → orionis-0.705.0}/orionis/metadata/framework.py

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

orionis-0.705.0/orionis/test/cases/asynchronous.py

@@ -0,0 +1,8 @@
+import unittest
+from orionis.test.output.dumper import TestDumper
+
+class AsyncTestCase(unittest.IsolatedAsyncioTestCase, TestDumper):
+    """
+    Base class for asynchronous unit tests in the Orionis framework.
+    """
+    pass

orionis-0.705.0/orionis/test/cases/synchronous.py

@@ -0,0 +1,8 @@
+import unittest
+from orionis.test.output.dumper import TestDumper
+
+class SyncTestCase(unittest.TestCase, TestDumper):
+    """
+    Base class for synchronous unit tests in the Orionis framework.
+    """
+    pass

orionis-0.705.0/orionis/test/contracts/kernel.py

@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod
+from orionis.test.contracts.unit_test import IUnitTest
+
+class ITestKernel(ABC):
+    """
+    Interface for test kernel implementations in the Orionis testing framework.
+
+    The test kernel manages the application context, validates and handles test configuration,
+    orchestrates test discovery and execution, and provides a unified interface for test operations.
+    """
+
+    @abstractmethod
+    def handle(
+        self,
+        modules: list = []
+    ) -> IUnitTest:
+        """
+        Configures and executes unit tests based on the current test kernel configuration.
+
+        This method sets up the test environment, loads the specified modules, and orchestrates
+        the execution of unit tests. It returns an instance of `IUnitTest` representing the
+        results and state of the executed tests.
+
+        Parameters
+        ----------
+        modules : list, optional
+            A list of modules to be included in the test execution. Defaults to an empty list.
+
+        Returns
+        -------
+        IUnitTest
+            An instance representing the configured and executed unit test.
+        """
+        pass

{orionis-0.703.0 → orionis-0.705.0}/orionis/test/contracts/unit_test.py

@@ -4,6 +4,34 @@ from typing import Any, Dict, List
 
 class IUnitTest(ABC):
 
+    @abstractmethod
+    def setModule(
+        self,
+        module: str
+    ) -> None:
+        """
+        Add a specific module name to the list of modules for test discovery.
+
+        This method appends the provided module name to the internal list of specific modules
+        (`__specific_modules`). These modules will be considered during test discovery and loading.
+
+        Parameters
+        ----------
+        module : str
+            The name of the module to add for test discovery.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It updates the internal module list.
+
+        Notes
+        -----
+        - The module name should be a string representing the fully qualified module path.
+        - This method is useful for targeting specific modules for test execution.
+        """
+        pass
+
     @abstractmethod
     def run(self) -> Dict[str, Any]:
         """

{orionis-0.703.0 → orionis-0.705.0}/orionis/test/core/unit_test.py

@@ -1,3 +1,4 @@
+import asyncio
 import io
 import json
 import logging
@@ -19,6 +20,7 @@ from orionis.foundation.contracts.application import IApplication
 from orionis.services.introspection.concretes.reflection import ReflectionConcrete
 from orionis.services.introspection.instances.reflection import ReflectionInstance
 from orionis.support.performance.contracts.counter import IPerformanceCounter
+from orionis.test.cases.asynchronous import AsyncTestCase
 from orionis.test.contracts.test_result import IOrionisTestResult
 from orionis.test.contracts.unit_test import IUnitTest
 from orionis.test.entities.result import TestResult
@@ -32,7 +34,6 @@ from orionis.test.validators import (
     ValidPersistent, ValidThrowException, ValidVerbosity, ValidWebReport, ValidWorkers,
 )
 from orionis.test.view.render import TestingResultRender
-import asyncio
 
 class UnitTest(IUnitTest):
     """
@@ -91,10 +92,10 @@ class UnitTest(IUnitTest):
         logging.getLogger("asyncio").setLevel(logging.ERROR)
 
         # List of common setup/teardown methods to inspect for debug calls
-        self.__commonMethods = [
-            'setUp', 'tearDown', 'onSetup', 'onTeardown',
-            'asyncSetUp', 'asyncTearDown', 'onAsyncSetup', 'onAsyncTeardown'
-        ]
+        self.__commonMethods = {
+            'sync': ['setUp', 'tearDown'],
+            'async': ['asyncSetUp', 'asyncTearDown']
+        }
 
         # Store the application instance for dependency injection and configuration access
         self.__app: IApplication = app
@@ -107,6 +108,7 @@ class UnitTest(IUnitTest):
         self.__flatten_test_suite: Optional[List[unittest.TestCase]] = None
 
         # List to store imported test modules
+        self.__specific_modules: List[str] = []
         self.__imported_modules: List = []
 
         # Sets to track discovered test cases, modules, and IDs
@@ -278,7 +280,8 @@ class UnitTest(IUnitTest):
             )
 
     def __loadModules(
-        self
+        self,
+        modules: List[str] = None
     ) -> None:
         """
         Loads and validates Python modules for test discovery based on the configured folder paths and file patterns.
@@ -311,14 +314,23 @@ class UnitTest(IUnitTest):
         """
 
         # Use a set to avoid duplicate module imports
-        modules = set()
+        discover_modules = set()
+
+        # If specific modules are provided, validate and import them directly
+        if modules:
+            for module in modules:
+                if not isinstance(module, str) or not module.strip():
+                    raise OrionisTestValueError(
+                        f"Invalid module name: expected a non-empty string, got {repr(module)}."
+                    )
+                discover_modules.add(import_module(ValidModuleName(module.strip())))
 
         # If folder_path is '*', discover all modules matching the pattern in the test directory
-        if self.__folder_path == '*':
+        elif self.__folder_path == '*':
             list_modules = self.__listMatchingModules(
                 self.__root_path, self.__test_path, '', self.__pattern
             )
-            modules.update(list_modules)
+            discover_modules.update(list_modules)
 
         # If folder_path is a list, discover modules in each specified subdirectory
         elif isinstance(self.__folder_path, list):
@@ -326,10 +338,10 @@ class UnitTest(IUnitTest):
                 list_modules = self.__listMatchingModules(
                     self.__root_path, self.__test_path, custom_path, self.__pattern
                 )
-                modules.update(list_modules)
+                discover_modules.update(list_modules)
 
         # Extend the internal module list with the sorted discovered modules
-        self.__imported_modules.extend(modules)
+        self.__imported_modules.extend(discover_modules)
 
     def __listMatchingModules(
         self,
@@ -656,7 +668,7 @@ class UnitTest(IUnitTest):
             rf_instance = ReflectionInstance(test_case)
             method_name = rf_instance.getAttribute("_testMethodName")
             method_names_to_check = [method_name] if method_name else []
-            method_names_to_check += [m for m in self.__commonMethods if rf_instance.hasMethod(m)]
+            method_names_to_check += [m for m in self.__commonMethods['sync'] + self.__commonMethods['async'] if rf_instance.hasMethod(m)]
 
             # Inspect each method's source code for debug keywords
             for mname in method_names_to_check:
@@ -701,6 +713,35 @@ class UnitTest(IUnitTest):
         # No debug keywords found in any inspected method
         return False
 
+    def setModule(
+        self,
+        module: str
+    ) -> None:
+        """
+        Add a specific module name to the list of modules for test discovery.
+
+        This method appends the provided module name to the internal list of specific modules
+        (`__specific_modules`). These modules will be considered during test discovery and loading.
+
+        Parameters
+        ----------
+        module : str
+            The name of the module to add for test discovery.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It updates the internal module list.
+
+        Notes
+        -----
+        - The module name should be a string representing the fully qualified module path.
+        - This method is useful for targeting specific modules for test execution.
+        """
+
+        # Append the provided module name to the list of specific modules for discovery
+        self.__specific_modules.append(module)
+
     def run(
         self,
         performance_counter: IPerformanceCounter
@@ -729,7 +770,7 @@ class UnitTest(IUnitTest):
         self.__loadConfig()
 
         # Discover and import test modules based on the configuration
-        self.__loadModules()
+        self.__loadModules(self.__specific_modules)
 
         # Discover and load all test cases from the imported modules into the suite
         self.__loadTests()
@@ -923,10 +964,17 @@ class UnitTest(IUnitTest):
             if not rf_instance.hasAttribute("_testMethodName"):
                 return test_case
 
+            # Determine if the test case uses async or sync common methods
+            common_methods = []
+            if AsyncTestCase in rf_instance.getBaseClasses():
+                common_methods = self.__commonMethods['async']
+            else:
+                common_methods = self.__commonMethods['sync']
+
             # Iterate over the main test method and common setup/teardown methods
             for method_name in [
                 rf_instance.getAttribute("_testMethodName"),
-                *self.__commonMethods
+                *common_methods
             ]:
 
                 # Skip if the method does not exist on the class
@@ -958,26 +1006,15 @@ class UnitTest(IUnitTest):
                         dependencies
                     )
 
-                    # If the test method is asynchronous, wrap it to run in an event loop
+                    # If the test method is asynchronous, wrap it to preserve async nature
                     if asyncio.iscoroutinefunction(original_method):
 
-                        # Define an async wrapper to inject dependencies
+                        # Define an async wrapper to inject dependencies and preserve async nature
                         async def async_wrapper(self_instance):
-                            return await original_method(self_instance, **resolved_args)
-
-                        # Wrap with a sync function for unittest compatibility
-                        def sync_wrapper(self_instance):
-                            try:
-                                loop = asyncio.get_running_loop()
-                            except RuntimeError:
-                                loop = None
-                            if loop and loop.is_running():
-                                return loop.create_task(async_wrapper(self_instance)) # NOSONAR
-                            else:
-                                return asyncio.run(async_wrapper(self_instance))
+                            return await original_method(self_instance, **resolved_args) # NOSONAR
 
-                        # Bind the wrapped method to the test case instance
-                        bound_method = sync_wrapper.__get__(test_case, test_cls)
+                        # Bind the async wrapped method to the test case instance
+                        bound_method = async_wrapper.__get__(test_case, test_cls)
 
                     else:
 
@@ -1045,7 +1082,7 @@ class UnitTest(IUnitTest):
             )
 
             # Run the current test case and obtain the result
-            single_result: IOrionisTestResult = runner.run(unittest.TestSuite([case]))
+            single_result: unittest.TestResult = runner.run(unittest.TestSuite([case]))
 
             # Print the result of the current test case using the printer
             self.__printer.unittestResult(single_result.test_results[0])

{orionis-0.703.0 → orionis-0.705.0}/orionis/test/kernel.py

@@ -47,7 +47,10 @@ class TestKernel(ITestKernel):
         # Retrieve the unit test service from the application container
         self.__unit_test: IUnitTest = app.make(IUnitTest)
 
-    def handle(self) -> dict:
+    def handle(
+        self,
+        modules: list = []
+    ) -> dict:
         """
         Executes the unit test suite and logs a summary of the results.
 
@@ -68,6 +71,11 @@ class TestKernel(ITestKernel):
             'success_rate', and 'timestamp'. If no tests are run, returns None.
         """
 
+        # If specific modules are provided, set them in the unit test service
+        if modules and isinstance(modules, list) and len(modules) > 0:
+            for module in modules:
+                self.__unit_test.setModule(module)
+
         # Run the unit test suite and collect the output summary
         output = self.__app.call(self.__unit_test, 'run')
 

{orionis-0.703.0 → orionis-0.705.0/orionis.egg-info}/PKG-INFO

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

orionis-0.703.0/orionis/test/cases/asynchronous.py

@@ -1,70 +0,0 @@
-import unittest
-from orionis.test.output.dumper import TestDumper
-
-class AsyncTestCase(unittest.IsolatedAsyncioTestCase, TestDumper):
-    """
-    Base class for asynchronous unit tests in the Orionis framework.
-
-    Inherits from `unittest.IsolatedAsyncioTestCase` and `TestDumper`, providing
-    a structure for writing asynchronous tests with isolated event loops and
-    enhanced output capabilities. Subclasses can override `onAsyncSetup` and
-    `onAsyncTeardown` for custom asynchronous setup and teardown logic.
-
-    Attributes
-    ----------
-    None
-    """
-
-    async def asyncSetUp(self):
-        """
-        Asynchronous setup executed before each test method.
-
-        Calls the parent class's asyncSetUp and then invokes the
-        `onAsyncSetup` hook for additional subclass-specific setup.
-
-        Returns
-        -------
-        None
-        """
-        await super().asyncSetUp()
-        await self.onAsyncSetup()
-
-    async def asyncTearDown(self):
-        """
-        Asynchronous teardown executed after each test method.
-
-        Invokes the `onAsyncTeardown` hook for subclass-specific cleanup,
-        then calls the parent class's asyncTearDown.
-
-        Returns
-        -------
-        None
-        """
-        await self.onAsyncTeardown()
-        await super().asyncTearDown()
-
-    async def onAsyncSetup(self):
-        """
-        Hook for subclass-specific asynchronous setup logic.
-
-        Intended to be overridden by subclasses to perform custom
-        asynchronous initialization before each test.
-
-        Returns
-        -------
-        None
-        """
-        pass
-
-    async def onAsyncTeardown(self):
-        """
-        Hook for subclass-specific asynchronous teardown logic.
-
-        Intended to be overridden by subclasses to perform custom
-        asynchronous cleanup after each test.
-
-        Returns
-        -------
-        None
-        """
-        pass

orionis-0.703.0/orionis/test/cases/synchronous.py

@@ -1,70 +0,0 @@
-import unittest
-from orionis.test.output.dumper import TestDumper
-
-class SyncTestCase(unittest.TestCase, TestDumper):
-    """
-    Base class for synchronous unit tests in the Orionis framework.
-
-    Inherits from `unittest.TestCase` and `TestDumper`, providing
-    hooks for custom setup and teardown logic via `onSetup()` and
-    `onTeardown()` methods. Subclasses should override these hooks
-    to implement test-specific initialization and cleanup.
-
-    Attributes
-    ----------
-    None
-    """
-
-    def setUp(self):
-        """
-        Set up the test environment before each test method.
-
-        Calls the superclass `setUp()` and then invokes the
-        `onSetup()` hook for additional initialization.
-
-        Returns
-        -------
-        None
-        """
-        super().setUp()
-        self.onSetup()
-
-    def tearDown(self):
-        """
-        Clean up the test environment after each test method.
-
-        Invokes the `onTeardown()` hook for custom cleanup and
-        then calls the superclass `tearDown()`.
-
-        Returns
-        -------
-        None
-        """
-        self.onTeardown()
-        super().tearDown()
-
-    def onSetup(self):
-        """
-        Hook for subclass-specific setup logic.
-
-        Intended to be overridden by subclasses to perform
-        custom initialization before each test.
-
-        Returns
-        -------
-        None
-        """
-        pass
-
-    def onTeardown(self):
-        """
-        Hook for subclass-specific teardown logic.
-
-        Intended to be overridden by subclasses to perform
-        custom cleanup after each test.
-
-        Returns
-        -------
-        None
-        """
-        pass

orionis-0.703.0/orionis/test/contracts/kernel.py

@@ -1,22 +0,0 @@
-from abc import ABC, abstractmethod
-from orionis.test.contracts.unit_test import IUnitTest
-
-class ITestKernel(ABC):
-    """
-    Interface for test kernel implementations in the Orionis testing framework.
-
-    The test kernel manages the application context, validates and handles test configuration,
-    orchestrates test discovery and execution, and provides a unified interface for test operations.
-    """
-
-    @abstractmethod
-    def handle(self) -> IUnitTest:
-        """
-        Configure and execute unit tests according to the current configuration.
-
-        Returns
-        -------
-        IUnitTest
-            An instance representing the configured and executed unit test.
-        """
-        pass