orionis 0.454.0__tar.gz → 0.456.0__tar.gz

{orionis-0.454.0/orionis.egg-info → orionis-0.456.0}/PKG-INFO

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

orionis-0.456.0/orionis/console/commands/help.py

@@ -0,0 +1,36 @@
+from orionis.console.base.command import BaseCommand
+from orionis.console.exceptions import CLIOrionisRuntimeError
+from rich.console import Console
+from rich.panel import Panel
+
+class HelpCommand(BaseCommand):
+    """
+    Command class to display usage information for the Orionis CLI.
+    """
+
+    timestamps: bool = False
+    signature: str = "help"
+    description: str = "Prints help information for the Orionis CLI commands."
+
+    def handle(self) -> None:
+        """
+        Executes the command to display usage information for the Orionis CLI.
+        """
+        try:
+            console = Console()
+            usage = (
+                "[bold cyan]Usage:[/]\n"
+                "  orionis <command> [options]\n\n"
+                "[bold cyan]Available Commands:[/]\n"
+                "  help        Show this help message\n"
+                "  run         Run the application\n"
+                "  make        Generate code scaffolding\n"
+                "  migrate     Run database migrations\n"
+                "  ...         Other available commands\n\n"
+                "[bold cyan]Options:[/]\n"
+                "  -h, --help  Show this help message and exit\n"
+            )
+            panel = Panel(usage, title="[bold green]Orionis CLI Help[/]", expand=False, border_style="bright_blue")
+            console.print(panel)
+        except Exception as e:
+            raise CLIOrionisRuntimeError(f"An unexpected error occurred: {e}") from e

orionis-0.456.0/orionis/console/contracts/reactor.py

@@ -0,0 +1,39 @@
+from abc import ABC, abstractmethod
+from typing import List, Optional
+
+class IReactor(ABC):
+
+    @abstractmethod
+    def call(
+        self,
+        signature: str,
+        args: Optional[List[str]] = None
+    ):
+        """
+        Executes a command by its signature with optional command-line arguments.
+
+        This method retrieves a registered command by its signature, validates any provided
+        arguments against the command's argument parser, and executes the command's handle
+        method with the parsed arguments and application context.
+
+        Parameters
+        ----------
+        signature : str
+            The unique signature identifier of the command to execute.
+        args : Optional[List[str]], default None
+            Command-line arguments to pass to the command. If None, no arguments are provided.
+
+        Returns
+        -------
+        None
+            This method does not return any value. The command's handle method is called
+            directly for execution.
+
+        Raises
+        ------
+        ValueError
+            If the command with the specified signature is not found in the registry.
+        SystemExit
+            If argument parsing fails due to invalid arguments provided.
+        """
+        pass

{orionis-0.454.0 → orionis-0.456.0}/orionis/console/core/reactor.py

@@ -8,13 +8,14 @@ from orionis.app import Orionis
 from orionis.console.args.argument import CLIArgument
 from orionis.console.base.command import BaseCommand
 from orionis.console.base.contracts.command import IBaseCommand
+from orionis.console.contracts.reactor import IReactor
 from orionis.console.output.contracts.console import IConsole
 from orionis.console.output.contracts.executor import IExecutor
 from orionis.foundation.contracts.application import IApplication
 from orionis.services.introspection.modules.reflection import ReflectionModule
 from orionis.services.log.contracts.log_service import ILogger
 
-class Reactor:
+class Reactor(IReactor):
 
     def __init__(
         self,
@@ -100,9 +101,13 @@ class Reactor:
 
         # Import the core command class for version
         from orionis.console.commands.version import VersionCommand
+        from orionis.console.commands.help import HelpCommand
 
         # List of core command classes to load (extend this list as more core commands are added)
-        core_commands = [VersionCommand]
+        core_commands = [
+            VersionCommand,
+            HelpCommand
+        ]
 
         # Iterate through the core command classes and register them
         for obj in core_commands:

orionis-0.456.0/orionis/console/kernel.py

@@ -0,0 +1,99 @@
+from orionis.console.contracts.kernel import IKernelCLI
+from orionis.console.contracts.reactor import IReactor
+from orionis.console.output.contracts.console import IConsole
+from orionis.foundation.contracts.application import IApplication
+from orionis.console.exceptions import CLIOrionisValueError
+
+class KernelCLI(IKernelCLI):
+
+    def __init__(
+        self,
+        app: IApplication
+    ) -> None:
+        """
+        Initializes the KernelCLI instance with the provided application container.
+
+        Parameters
+        ----------
+        app : IApplication
+            The application container instance that provides access to services and dependencies.
+
+        Returns
+        -------
+        None
+            This constructor does not return a value. It initializes internal dependencies required for CLI operations.
+
+        Raises
+        ------
+        CLIOrionisValueError
+            If the provided `app` argument is not an instance of `IApplication`.
+        """
+
+        # Validate that the app is an instance of IApplication
+        if not isinstance(app, IApplication):
+            raise CLIOrionisValueError(
+                f"Failed to initialize TestKernel: expected IApplication, got {type(app).__module__}.{type(app).__name__}."
+            )
+
+        # Retrieve and initialize the reactor instance from the application container.
+        # The reactor is responsible for dispatching CLI commands.
+        self.__reactor: IReactor = app.make('x-orionis.console.core.reactor', app)
+
+        # Retrieve and initialize the console instance for command output and error handling.
+        self.__console: IConsole = app.make('x-orionis.console.output.console')
+
+    def handle(self, args: list) -> None:
+        """
+        Processes and dispatches command line arguments to the appropriate command handler.
+
+        Parameters
+        ----------
+        args : list
+            The list of command line arguments, typically `sys.argv`.
+
+        Returns
+        -------
+        None
+            This method does not return a value. It may terminate the process or delegate execution to command handlers.
+
+        Raises
+        ------
+        SystemExit
+            If invalid arguments are provided or no command is specified, this method may terminate the process with an error message.
+        """
+
+        try:
+
+            # Ensure the arguments are provided as a list
+            if not isinstance(args, list):
+                raise CLIOrionisValueError(
+                    f"Failed to handle command line arguments: expected list, got {type(args).__module__}.{type(args).__name__}."
+                )
+
+            # If no arguments or only the script name is provided, show the default help command
+            if not args or len(args) <= 1:
+                return self.__reactor.call('help')
+
+            # Remove the first argument (script name) to process only the command and its parameters
+            args = args[1:]
+
+            # If no command is provided after removing the script name, exit with an error
+            if len(args) == 0:
+                raise CLIOrionisValueError("No command provided to execute.")
+
+            # If only the command is provided, call it without additional arguments
+            if len(args) == 1:
+                return self.__reactor.call(args[0])
+
+            # If command and arguments are provided, call the command with its arguments
+            return self.__reactor.call(args[0], args[1:])
+
+        except SystemExit as e:
+
+            # Handle SystemExit exceptions gracefully, allowing for clean exits with error messages
+            self.__console.exitError(str(e))
+
+        except Exception as e:
+
+            # Handle any other exceptions that may occur during command processing
+            self.__console.exitError(f"An unexpected error occurred: {str(e)}")

{orionis-0.454.0 → orionis-0.456.0}/orionis/foundation/application.py

@@ -179,6 +179,7 @@ class Application(Container, IApplication):
         from orionis.foundation.providers.testing_provider import TestingProvider
         from orionis.foundation.providers.inspirational_provider import InspirationalProvider
         from orionis.foundation.providers.executor_provider import ConsoleExecuteProvider
+        from orionis.foundation.providers.reactor_provider import ReactorProvider
 
         # Core framework providers
         core_providers = [
@@ -189,7 +190,8 @@ class Application(Container, IApplication):
             LoggerProvider,
             TestingProvider,
             InspirationalProvider,
-            ConsoleExecuteProvider
+            ConsoleExecuteProvider,
+            ReactorProvider
         ]
 
         # Register each core provider

orionis-0.456.0/orionis/foundation/providers/reactor_provider.py

@@ -0,0 +1,93 @@
+from orionis.console.contracts.reactor import IReactor
+from orionis.console.core.reactor import Reactor
+from orionis.container.providers.service_provider import ServiceProvider
+
+class ReactorProvider(ServiceProvider):
+    """
+    Service provider for worker management functionality within the Orionis framework.
+
+    This provider is responsible for registering and configuring the worker management
+    service implementation in the application's dependency injection container. It
+    establishes the binding between the IReactor interface contract and its concrete
+    Reactor implementation, enabling consistent reactor operations throughout the
+    application lifecycle.
+
+    The provider follows the standard service provider pattern, offering both
+    registration and boot phases for complete service lifecycle management.
+
+    Attributes
+    ----------
+    app : Application
+        The main application container instance used for service registration
+        and dependency injection management.
+
+    Notes
+    -----
+    This provider registers the reactor service with a transient lifetime, ensuring
+    that each request for reactor functionality receives a fresh instance. This
+    approach is optimal for operations that may maintain temporary state or require
+    isolation between different execution contexts.
+    """
+
+    def register(self) -> None:
+        """
+        Register the reactor management service in the application container.
+
+        This method binds the IReactor interface to a new instance of the Reactor
+        implementation within the application's dependency injection container. The
+        service is registered with a transient lifetime, ensuring that each resolution
+        yields a new Reactor instance. An alias is provided for convenient retrieval.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method does not return any value. It performs registration
+            as a side effect on the application container.
+
+        Notes
+        -----
+        - Each call to resolve IReactor will produce a new Reactor instance.
+        - No singleton or caching behavior is applied.
+        - The alias "x-orionis.console.core.reactor" can be used for explicit lookups.
+        """
+
+        # Register the Reactor service with the application container
+        # as a singleton, allowing it to be resolved throughout the application lifecycle
+        self.app.singleton(
+            IReactor,
+            Reactor,
+            alias="x-orionis.console.core.reactor"
+        )
+
+    def boot(self) -> None:
+        """
+        Perform post-registration initialization for the reactor management service.
+
+        This method is invoked after all services have been registered in the container.
+        It provides an opportunity for additional setup, configuration, or initialization
+        logic that may depend on other services being available. Currently, this method
+        does not perform any actions but serves as a placeholder for future enhancements.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method does not return any value. It only performs initialization
+            side effects if required.
+
+        Notes
+        -----
+        - Called automatically during the application boot sequence.
+        - Intended for cross-service configuration or runtime setup.
+        - No initialization is currently required for the reactor service.
+        """
+
+        # No additional initialization required at this time
+        pass

orionis-0.456.0/orionis/foundation/providers/testing_provider.py

@@ -0,0 +1,77 @@
+from orionis.container.providers.service_provider import ServiceProvider
+from orionis.test.contracts.unit_test import IUnitTest
+from orionis.test.core.unit_test import UnitTest
+
+class TestingProvider(ServiceProvider):
+    """
+    Provides comprehensive unit testing environment services for the Orionis framework.
+
+    This service provider integrates a native unit testing framework into the Orionis
+    application ecosystem, enabling advanced testing capabilities with configurable
+    execution modes, parallel processing, and persistent result storage. The provider
+    registers the testing service as a singleton within the application's dependency
+    injection container, making it available throughout the application lifecycle.
+
+    The TestingProvider handles the complete lifecycle of testing services, from
+    initial configuration and test discovery to storage preparation and service
+    registration. It supports various testing patterns, execution strategies, and
+    reporting mechanisms to accommodate different testing scenarios and requirements.
+
+    Attributes
+    ----------
+    app : Application
+        The Orionis application container instance that manages service registration,
+        configuration access, and dependency injection throughout the framework.
+
+    Notes
+    -----
+    This provider follows the Orionis service provider pattern, implementing both
+    register() and boot() methods to ensure proper service initialization and
+    post-registration setup. The testing service is registered with the interface
+    binding IUnitTest and can be resolved using the alias "x-orionis.test.core.unit_test".
+
+    The provider requires a valid testing configuration section in the application
+    configuration, which should include settings for verbosity, execution mode,
+    worker configuration, and storage paths.
+    """
+
+    def register(self) -> None:
+        """
+        Register and configure the unit testing service in the application container.
+
+        This method loads the testing configuration from the application, instantiates
+        and configures a UnitTest service, and registers it as a singleton in the
+        dependency injection container. The service is bound to the IUnitTest interface
+        and is accessible via the alias "x-orionis.test.core.unit_test".
+
+        The registration process includes:
+            - Retrieving testing configuration from the application settings.
+            - Instantiating the UnitTest service with the appropriate configuration.
+            - Registering the UnitTest service as a singleton in the container.
+            - Binding the service to the IUnitTest interface and alias.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It performs side effects by
+            registering and binding the testing service in the application container.
+        """
+
+        # Register the UnitTest service as a singleton in the application container.
+        # The service is bound to the IUnitTest interface and can be resolved using the alias.
+        self.app.singleton(IUnitTest, UnitTest, alias="x-orionis.test.core.unit_test")
+
+    def boot(self) -> None:
+        """
+        Finalize initialization for the testing provider after service registration.
+
+        This method is called after the registration phase to allow for any additional
+        setup required for the testing environment. In this implementation, no further
+        actions are performed during the boot phase.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+        """
+        pass

{orionis-0.454.0 → orionis-0.456.0}/orionis/metadata/framework.py

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

{orionis-0.454.0 → orionis-0.456.0}/orionis/test/contracts/unit_test.py

@@ -52,6 +52,60 @@ class IUnitTest(ABC):
         """
         pass
 
+    @abstractmethod
+    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
+    ) -> 'IUnitTest':
+        """
+        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
+        """
+        pass
+
     @abstractmethod
     def discoverTestsInFolder(
         self,

{orionis-0.454.0 → orionis-0.456.0}/orionis/test/kernel.py

@@ -2,6 +2,7 @@ from orionis.console.output.contracts.console import IConsole
 from orionis.foundation.contracts.application import IApplication
 from orionis.test.contracts.kernel import ITestKernel
 from orionis.test.contracts.unit_test import IUnitTest
+from orionis.foundation.config.testing.entities.testing import Testing
 from orionis.test.exceptions import OrionisTestConfigException, OrionisTestFailureException
 
 class TestKernel(ITestKernel):
@@ -38,8 +39,33 @@ class TestKernel(ITestKernel):
                 f"Failed to initialize TestKernel: expected IApplication, got {type(app).__module__}.{type(app).__name__}."
             )
 
+        # Load testing configuration from application config and create Testing instance
+        config = Testing(**app.config('testing'))
+
         # Resolve the unit test service from the application container
-        self.__unit_test: IUnitTest = app.make('x-orionis.test.core.unit_test')
+        self.__unit_test: IUnitTest = app.make('x-orionis.test.core.unit_test', app)
+
+        # Apply configuration settings to the UnitTest instance
+        self.__unit_test.configure(
+            verbosity=config.verbosity,                 # Set output verbosity level
+            execution_mode=config.execution_mode,       # Configure test execution mode
+            max_workers=config.max_workers,             # Set maximum worker threads for parallel execution
+            fail_fast=config.fail_fast,                 # Enable/disable fail-fast behavior
+            print_result=config.print_result,           # Control result output printing
+            throw_exception=config.throw_exception,     # Configure exception throwing behavior
+            persistent=config.persistent,               # Enable/disable persistent test results
+            persistent_driver=config.persistent_driver, # Set persistent storage driver
+            web_report=config.web_report                # Enable/disable web-based reporting
+        )
+
+        # Discover and load test files based on configuration criteria
+        self.__unit_test.discoverTests(
+            base_path=config.base_path,                 # Root directory for test discovery
+            folder_path=config.folder_path,             # Specific folder path within base_path
+            pattern=config.pattern,                     # File name pattern for test files
+            test_name_pattern=config.test_name_pattern, # Pattern for test method names
+            tags=config.tags                            # Tags to filter tests during discovery
+        )
 
         # Resolve the console service from the application container
         self.__console: IConsole = app.make('x-orionis.console.output.console')

{orionis-0.454.0 → orionis-0.456.0/orionis.egg-info}/PKG-INFO

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

{orionis-0.454.0 → orionis-0.456.0}/orionis.egg-info/SOURCES.txt

@@ -21,9 +21,11 @@ orionis/console/base/command.py
 orionis/console/base/contracts/__init__.py
 orionis/console/base/contracts/command.py
 orionis/console/commands/__init__.py
+orionis/console/commands/help.py
 orionis/console/commands/version.py
 orionis/console/contracts/__init__.py
 orionis/console/contracts/kernel.py
+orionis/console/contracts/reactor.py
 orionis/console/core/__init__.py
 orionis/console/core/reactor.py
 orionis/console/dumper/__init__.py
@@ -187,6 +189,7 @@ orionis/foundation/providers/executor_provider.py
 orionis/foundation/providers/inspirational_provider.py
 orionis/foundation/providers/logger_provider.py
 orionis/foundation/providers/progress_bar_provider.py
+orionis/foundation/providers/reactor_provider.py
 orionis/foundation/providers/testing_provider.py
 orionis/foundation/providers/workers_provider.py
 orionis/metadata/__init__.py

{orionis-0.454.0 → orionis-0.456.0}/tests/services/introspection/dependencies/test_reflect_dependencies.py

@@ -170,7 +170,7 @@ class TestReflectDependencies(AsyncTestCase):
         self.assertEqual(dep_user_permissions.type, FakeUserWithPermissions)
 
         # Extract and validate the 'permissions' dependency (built-in generic type)
-        dep_permissions: Argument = method_dependencies.resolved.get('permissions')
+        dep_permissions: Argument = method_dependencies.unresolved.get('permissions')
 
         # Ensure the built-in type dependency is properly resolved as an Argument instance
         self.assertIsInstance(dep_permissions, Argument)
@@ -248,10 +248,14 @@ class TestReflectDependencies(AsyncTestCase):
         dep_x: Argument = callable_dependencies.resolved.get('x')
 
         # Verify that the 'x' parameter resolves to its default value of 3
-        self.assertEqual(dep_x, 3)
+        self.assertIsInstance(dep_x, Argument)
+        self.assertTrue(dep_x.resolved)
+        self.assertEqual(dep_x.default, 3)
 
         # Extract and validate the 'y' parameter dependency from resolved dependencies
         dep_y: Argument = callable_dependencies.resolved.get('y')
 
         # Verify that the 'y' parameter resolves to its default value of 4
-        self.assertEqual(dep_y, 4)
+        self.assertIsInstance(dep_y, Argument)
+        self.assertTrue(dep_y.resolved)
+        self.assertEqual(dep_y.default, 4)

{orionis-0.454.0 → orionis-0.456.0}/tests/services/introspection/reflection/test_reflection_abstract.py

@@ -1007,14 +1007,5 @@ class TestServiceReflectionAbstract(AsyncTestCase):
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         method_deps: ResolveArguments = reflect.getMethodDependencies('instanceSyncMethod')
-        self.assertIn('x', method_deps.resolved)
-        self.assertIn('y', method_deps.resolved)
-        self.assertEqual(method_deps.resolved['x'].class_name, 'int')
-        self.assertEqual(method_deps.resolved['y'].class_name, 'int')
-        self.assertEqual(method_deps.resolved['x'].module_name, 'builtins')
-        self.assertEqual(method_deps.resolved['y'].module_name, 'builtins')
-        self.assertEqual(method_deps.resolved['x'].type, int)
-        self.assertEqual(method_deps.resolved['y'].type, int)
-        self.assertEqual(method_deps.resolved['x'].full_class_path, 'builtins.int')
-        self.assertEqual(method_deps.resolved['y'].full_class_path, 'builtins.int')
-        self.assertEqual(method_deps.unresolved, [])
+        self.assertIn('x', method_deps.unresolved)
+        self.assertIn('y', method_deps.unresolved)

{orionis-0.454.0 → orionis-0.456.0}/tests/services/introspection/reflection/test_reflection_concrete.py

@@ -948,14 +948,5 @@ class TestServiceReflectionConcrete(AsyncTestCase):
         """
         reflect = ReflectionConcrete(FakeClass)
         method_deps: ResolveArguments = reflect.getMethodDependencies('instanceSyncMethod')
-        self.assertIn('x', method_deps.resolved)
-        self.assertIn('y', method_deps.resolved)
-        self.assertEqual(method_deps.resolved['x'].class_name, 'int')
-        self.assertEqual(method_deps.resolved['y'].class_name, 'int')
-        self.assertEqual(method_deps.resolved['x'].module_name, 'builtins')
-        self.assertEqual(method_deps.resolved['y'].module_name, 'builtins')
-        self.assertEqual(method_deps.resolved['x'].type, int)
-        self.assertEqual(method_deps.resolved['y'].type, int)
-        self.assertEqual(method_deps.resolved['x'].full_class_path, 'builtins.int')
-        self.assertEqual(method_deps.resolved['y'].full_class_path, 'builtins.int')
-        self.assertEqual(method_deps.unresolved, [])
+        self.assertIn('x', method_deps.unresolved)
+        self.assertIn('y', method_deps.unresolved)

{orionis-0.454.0 → orionis-0.456.0}/tests/services/introspection/reflection/test_reflection_instance.py

@@ -1229,14 +1229,5 @@ class TestServiceReflectionInstance(AsyncTestCase):
         """
         reflect = ReflectionInstance(FakeClass())
         method_deps: ResolveArguments = reflect.getMethodDependencies('instanceSyncMethod')
-        self.assertIn('x', method_deps.resolved)
-        self.assertIn('y', method_deps.resolved)
-        self.assertEqual(method_deps.resolved['x'].class_name, 'int')
-        self.assertEqual(method_deps.resolved['y'].class_name, 'int')
-        self.assertEqual(method_deps.resolved['x'].module_name, 'builtins')
-        self.assertEqual(method_deps.resolved['y'].module_name, 'builtins')
-        self.assertEqual(method_deps.resolved['x'].type, int)
-        self.assertEqual(method_deps.resolved['y'].type, int)
-        self.assertEqual(method_deps.resolved['x'].full_class_path, 'builtins.int')
-        self.assertEqual(method_deps.resolved['y'].full_class_path, 'builtins.int')
-        self.assertEqual(method_deps.unresolved, [])
+        self.assertIn('x', method_deps.unresolved)
+        self.assertIn('y', method_deps.unresolved)

orionis-0.454.0/orionis/console/kernel.py

@@ -1,25 +0,0 @@
-from orionis.console.contracts.kernel import IKernelCLI
-from orionis.foundation.contracts.application import IApplication
-from orionis.console.exceptions import CLIOrionisValueError
-
-class KernelCLI(IKernelCLI):
-
-    def __init__(
-        self,
-        app: IApplication
-    ) -> None:
-
-        # Validate that the app is an instance of IApplication
-        if not isinstance(app, IApplication):
-            raise CLIOrionisValueError(
-                f"Failed to initialize TestKernel: expected IApplication, got {type(app).__module__}.{type(app).__name__}."
-            )
-
-    def handle(self, args: list) -> None:
-        """
-        Handle the command line arguments.
-
-        :param args: List of command line arguments (e.g., sys.argv).
-        """
-        # This method should be implemented in subclasses
-        print(args)