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

tests/foundation/config/queue/test_queue_database.py

@@ -0,0 +1,95 @@
+from orionis.luminate.foundation.config.queue.entities.database import Database
+from orionis.luminate.foundation.config.queue.enums.strategy import Strategy
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestDatabaseQueue(TestCase):
+
+    async def testDefaultInitialization(self):
+        """
+        Test that Database instance is initialized with correct default values.
+        Verifies that default table name, queue name, retry_after, and strategy are set properly.
+        """
+        db_queue = Database()
+        self.assertEqual(db_queue.table, "jobs")
+        self.assertEqual(db_queue.queue, "default")
+        self.assertEqual(db_queue.retry_after, 90)
+        self.assertEqual(db_queue.strategy, Strategy.FIFO.value)
+
+    async def testTableNameValidation(self):
+        """
+        Test validation for table name attribute.
+        Verifies that invalid table names raise OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Database(table="1jobs")  # Starts with number
+        with self.assertRaises(OrionisIntegrityException):
+            Database(table="Jobs")  # Uppercase letter
+        with self.assertRaises(OrionisIntegrityException):
+            Database(table="jobs-table")  # Invalid character
+        with self.assertRaises(OrionisIntegrityException):
+            Database(table=123)  # Non-string value
+
+    async def testQueueNameValidation(self):
+        """
+        Test validation for queue name attribute.
+        Verifies that non-ASCII queue names raise OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Database(queue="café")  # Non-ASCII character
+        with self.assertRaises(OrionisIntegrityException):
+            Database(queue=123)  # Non-string value
+
+    async def testRetryAfterValidation(self):
+        """
+        Test validation for retry_after attribute.
+        Verifies that non-positive integers raise OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Database(retry_after=0)
+        with self.assertRaises(OrionisIntegrityException):
+            Database(retry_after=-1)
+        with self.assertRaises(OrionisIntegrityException):
+            Database(retry_after="90")  # String instead of int
+
+    async def testStrategyValidation(self):
+        """
+        Test validation and normalization for strategy attribute.
+        Verifies both string and Strategy enum inputs are properly handled.
+        """
+        # Test string inputs (case-insensitive)
+        db1 = Database(strategy="fifo")
+        self.assertEqual(db1.strategy, Strategy.FIFO.value)
+        db2 = Database(strategy="LIFO")
+        self.assertEqual(db2.strategy, Strategy.LIFO.value)
+
+        # Test enum inputs
+        db3 = Database(strategy=Strategy.PRIORITY)
+        self.assertEqual(db3.strategy, Strategy.PRIORITY.value)
+
+        # Test invalid inputs
+        with self.assertRaises(OrionisIntegrityException):
+            Database(strategy="invalid_strategy")
+        with self.assertRaises(OrionisIntegrityException):
+            Database(strategy=123)
+
+    async def testToDictMethod(self):
+        """
+        Test the toDict method returns proper dictionary representation.
+        Verifies all fields are included with correct values.
+        """
+        db_queue = Database()
+        result = db_queue.toDict()
+        self.assertIsInstance(result, dict)
+        self.assertEqual(result["table"], "jobs")
+        self.assertEqual(result["queue"], "default")
+        self.assertEqual(result["retry_after"], 90)
+        self.assertEqual(result["strategy"], Strategy.FIFO.value)
+
+    async def testKwOnlyInitialization(self):
+        """
+        Test that Database requires keyword arguments for initialization.
+        Verifies the class enforces kw_only=True in its dataclass decorator.
+        """
+        with self.assertRaises(TypeError):
+            Database("jobs", "default", 90, Strategy.FIFO)

tests/foundation/config/root/test_root_paths.py

@@ -0,0 +1,134 @@
+from pathlib import Path
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.luminate.foundation.config.roots.paths import Paths
+from orionis.unittesting import TestCase
+
+class TestPaths(TestCase):
+    """
+    Test suite for the Paths dataclass which defines the project directory structure.
+    This test class verifies the integrity of path definitions, default values,
+    and the behavior of accessor methods.
+    """
+
+    def testDefaultPathsInstantiation(self):
+        """
+        Test that a Paths instance can be created with default values.
+        Verifies that all default paths are correctly initialized and
+        the instance is properly constructed.
+        """
+        paths = Paths()
+        self.assertIsInstance(paths, Paths)
+
+    def testRequiredPathsAreSet(self):
+        """
+        Test that all required paths have non-empty default values.
+        Checks that paths marked as required in metadata are properly
+        initialized with valid string values.
+        """
+        paths = Paths()
+        required_fields = [
+            'console_scheduler', 'console_commands', 'http_controllers',
+            'http_middleware', 'models', 'providers', 'exceptions',
+            'views', 'routes_web', 'config', 'migrations',
+            'storage_logs', 'storage_framework'
+        ]
+        for field in required_fields:
+            value = getattr(paths, field)
+            self.assertTrue(isinstance(value, str) and len(value) > 0)
+
+    def testOptionalPathsCanBeEmpty(self):
+        """
+        Test that optional paths can be empty strings.
+        Verifies that paths not marked as required can be empty strings
+        without raising exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Paths(
+                http_requests='',
+                events='',
+                listeners='',
+                notifications='',
+                jobs='',
+                policies='',
+                services='',
+                lang='',
+                assets='',
+                routes_api='',
+                routes_console='',
+                routes_channels='',
+                seeders='',
+                factories='',
+                storage_sessions='',
+                storage_cache='',
+                storage_views=''
+            )
+
+    def testPathValidationRejectsNonStringValues(self):
+        """
+        Test that non-string path values raise OrionisIntegrityException.
+        Verifies that the __post_init__ validation rejects non-string values
+        for all path fields.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Paths(console_scheduler=123)
+
+    def testPathValidationRejectsEmptyRequiredPaths(self):
+        """
+        Test that empty required paths raise OrionisIntegrityException.
+        Verifies that required paths cannot be empty strings.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Paths(console_scheduler='')
+
+    def testToDictReturnsCompleteDictionary(self):
+        """
+        Test that toDict() returns a complete dictionary of all paths.
+        Verifies that the returned dictionary contains all path fields
+        with their current values.
+        """
+        paths = Paths()
+        path_dict = paths.toDict()
+        self.assertIsInstance(path_dict, dict)
+        self.assertEqual(len(path_dict), len(paths.__dataclass_fields__))
+        for field in paths.__dataclass_fields__:
+            self.assertIn(field, path_dict)
+
+    def testPathAccessorMethodsReturnPathObjects(self):
+        """
+        Test that all path accessor methods return Path objects.
+        Verifies that each get* method returns a proper pathlib.Path instance.
+        """
+        paths = Paths()
+        self.assertIsInstance(paths.getConsoleScheduler(), Path)
+        self.assertIsInstance(paths.getHttpControllers(), Path)
+        self.assertIsInstance(paths.getModels(), Path)
+        self.assertIsInstance(paths.getViews(), Path)
+        self.assertIsInstance(paths.getRoutesWeb(), Path)
+        self.assertIsInstance(paths.getConfig(), Path)
+        self.assertIsInstance(paths.getMigrations(), Path)
+        self.assertIsInstance(paths.getStorageLogs(), Path)
+
+    def testFrozenDataclassBehavior(self):
+        """
+        Test that the dataclass is truly frozen (immutable).
+        Verifies that attempts to modify attributes after creation
+        raise exceptions.
+        """
+        paths = Paths()
+        with self.assertRaises(Exception):
+            paths.console_scheduler = 'new/path'  # type: ignore
+
+    def testPathMetadataIsAccessible(self):
+        """
+        Test that path metadata is properly defined and accessible.
+        Verifies that each path field has the expected metadata structure
+        with description, type, and required fields.
+        """
+        paths = Paths()
+        for field in paths.__dataclass_fields__.values():
+            metadata = field.metadata
+            self.assertIn('description', metadata)
+            self.assertIn('type', metadata)
+            self.assertIn('required', metadata)
+            self.assertIn(metadata['type'], ['file', 'directory'])
+            self.assertIsInstance(metadata['required'], bool)

tests/foundation/config/session/test_session.py

@@ -0,0 +1,138 @@
+from orionis.luminate.foundation.config.session.entities.session import Session
+from orionis.luminate.foundation.config.session.enums.same_site_policy import SameSitePolicy
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestSession(TestCase):
+
+    async def testDefaultInitialization(self):
+        """
+        Test that Session instance is initialized with correct default values.
+        Verifies default values for all attributes including secret_key generation.
+        """
+        session = Session()
+        self.assertIsInstance(session.secret_key, str)
+        self.assertEqual(session.session_cookie, "orionis_session")
+        self.assertEqual(session.max_age, 1800)
+        self.assertEqual(session.same_site, SameSitePolicy.LAX.value)
+        self.assertEqual(session.path, "/")
+        self.assertFalse(session.https_only)
+        self.assertIsNone(session.domain)
+
+    async def testSecretKeyValidation(self):
+        """
+        Test validation for secret_key attribute.
+        Verifies that invalid secret keys raise OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Session(secret_key="")  # Empty string
+        with self.assertRaises(OrionisIntegrityException):
+            Session(secret_key=123)  # Non-string value
+
+    async def testSessionCookieValidation(self):
+        """
+        Test validation for session_cookie attribute.
+        Verifies invalid cookie names raise OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Session(session_cookie="")  # Empty string
+        with self.assertRaises(OrionisIntegrityException):
+            Session(session_cookie="my session")  # Contains space
+        with self.assertRaises(OrionisIntegrityException):
+            Session(session_cookie="session;")  # Contains semicolon
+
+    async def testMaxAgeValidation(self):
+        """
+        Test validation for max_age attribute.
+        Verifies invalid max_age values raise OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Session(max_age="3600")  # String instead of int
+        with self.assertRaises(OrionisIntegrityException):
+            Session(max_age=-1)  # Negative value
+        # Test None is acceptable
+        session = Session(max_age=None)
+        self.assertIsNone(session.max_age)
+
+    async def testSameSiteValidation(self):
+        """
+        Test validation and normalization for same_site attribute.
+        Verifies both string and enum inputs are properly handled.
+        """
+        # Test string inputs (case-insensitive)
+        session1 = Session(same_site="strict")
+        self.assertEqual(session1.same_site, SameSitePolicy.STRICT.value)
+        session2 = Session(same_site="NONE")
+        self.assertEqual(session2.same_site, SameSitePolicy.NONE.value)
+
+        # Test enum inputs
+        session3 = Session(same_site=SameSitePolicy.LAX)
+        self.assertEqual(session3.same_site, SameSitePolicy.LAX.value)
+
+        # Test invalid inputs
+        with self.assertRaises(OrionisIntegrityException):
+            Session(same_site="invalid")
+        with self.assertRaises(OrionisIntegrityException):
+            Session(same_site=123)
+
+    async def testPathValidation(self):
+        """
+        Test validation for path attribute.
+        Verifies invalid paths raise OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Session(path="")  # Empty string
+        with self.assertRaises(OrionisIntegrityException):
+            Session(path="api")  # Doesn't start with /
+        with self.assertRaises(OrionisIntegrityException):
+            Session(path=123)  # Non-string value
+
+    async def testHttpsOnlyValidation(self):
+        """
+        Test validation for https_only attribute.
+        Verifies non-boolean values raise OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Session(https_only="true")  # String instead of bool
+        with self.assertRaises(OrionisIntegrityException):
+            Session(https_only=1)  # Integer instead of bool
+
+    async def testDomainValidation(self):
+        """
+        Test validation for domain attribute.
+        Verifies invalid domains raise OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Session(domain=".example.com")  # Starts with dot
+        with self.assertRaises(OrionisIntegrityException):
+            Session(domain="example.com.")  # Ends with dot
+        with self.assertRaises(OrionisIntegrityException):
+            Session(domain="example..com")  # Contains consecutive dots
+
+        # Test None is acceptable
+        session = Session(domain=None)
+        self.assertIsNone(session.domain)
+
+    async def testToDictMethod(self):
+        """
+        Test the toDict method returns proper dictionary representation.
+        Verifies all fields are included with correct values.
+        """
+        session = Session()
+        result = session.toDict()
+        self.assertIsInstance(result, dict)
+        self.assertIn("secret_key", result)
+        self.assertEqual(result["session_cookie"], "orionis_session")
+        self.assertEqual(result["max_age"], 1800)
+        self.assertEqual(result["same_site"], SameSitePolicy.LAX.value)
+        self.assertEqual(result["path"], "/")
+        self.assertFalse(result["https_only"])
+        self.assertIsNone(result["domain"])
+
+    async def testKwOnlyInitialization(self):
+        """
+        Test that Session requires keyword arguments for initialization.
+        Verifies the class enforces kw_only=True in its dataclass decorator.
+        """
+        with self.assertRaises(TypeError):
+            Session("key", "session")

tests/foundation/config/startup/test_config_startup.py

@@ -0,0 +1,134 @@
+from dataclasses import is_dataclass
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.luminate.foundation.config.startup import Configuration
+from orionis.unittesting import TestCase, UnittestMock
+
+class TestConfiguration(TestCase):
+    """
+    Test suite for the Configuration dataclass which encapsulates all major
+    configuration sections for the application.
+
+    This test class verifies the proper initialization, type validation,
+    and dictionary conversion of the Configuration class.
+    """
+
+    def testConfigurationIsDataclass(self):
+        """
+        Test that Configuration is properly defined as a dataclass.
+        Verifies that the @dataclass decorator was applied correctly.
+        """
+        self.assertTrue(is_dataclass(Configuration))
+
+    def testDefaultInitialization(self):
+        """
+        Test that Configuration can be initialized with default values.
+        Verifies that all default factories work correctly and the
+        instance is properly constructed.
+        """
+        config = Configuration()
+        self.assertIsInstance(config, Configuration)
+
+    def testAllSectionsHaveDefaultFactories(self):
+        """
+        Test that all configuration sections have default factories.
+        Verifies that each field in the Configuration class has a
+        default_factory specified.
+        """
+        config = Configuration()
+        for field in config.__dataclass_fields__.values():
+            self.assertTrue(hasattr(field, 'default_factory'),
+                            f"Field {field.name} is missing default_factory")
+
+    def testTypeValidationInPostInit(self):
+        """
+        Test that __post_init__ validates types correctly.
+        Verifies that the type checking for each configuration section
+        works as expected.
+        """
+        # Test with all correct types (should not raise)
+        try:
+            Configuration()
+        except OrionisIntegrityException:
+            self.fail("__post_init__ raised exception with valid types")
+
+        # Test each section with wrong type
+        sections = [
+            ('paths', UnittestMock()),
+            ('app', UnittestMock()),
+            ('auth', UnittestMock()),
+            ('cache', UnittestMock()),
+            ('cors', UnittestMock()),
+            ('database', UnittestMock()),
+            ('filesystems', UnittestMock()),
+            ('logging', UnittestMock()),
+            ('mail', UnittestMock()),
+            ('queue', UnittestMock()),
+            ('session', UnittestMock()),
+            ('testing', UnittestMock())
+        ]
+
+        for section_name, wrong_value in sections:
+            with self.subTest(section=section_name):
+                kwargs = {section_name: wrong_value}
+                with self.assertRaises(OrionisIntegrityException):
+                    Configuration(**kwargs)
+
+    def testToDictReturnsCompleteDictionary(self):
+        """
+        Test that toDict() returns a complete dictionary representation.
+        Verifies that the returned dictionary contains all configuration
+        sections with their current values.
+        """
+        config = Configuration()
+        config_dict = config.toDict()
+        self.assertIsInstance(config_dict, dict)
+        self.assertEqual(len(config_dict), len(config.__dataclass_fields__))
+        for field in config.__dataclass_fields__:
+            self.assertIn(field, config_dict)
+
+    def testToDictReturnsNestedStructures(self):
+        """
+        Test that toDict() properly converts nested dataclasses.
+        Verifies that the dictionary conversion works recursively for
+        all nested configuration sections.
+        """
+        config = Configuration()
+        config_dict = config.toDict()
+        self.assertIsInstance(config_dict['paths'], dict)
+        self.assertIsInstance(config_dict['app'], dict)
+        self.assertIsInstance(config_dict['database'], dict)
+
+    def testMetadataIsAccessible(self):
+        """
+        Test that field metadata is properly defined and accessible.
+        Verifies that each configuration section field has the expected
+        metadata structure with description.
+        """
+        config = Configuration()
+        for field in config.__dataclass_fields__.values():
+            metadata = field.metadata
+            self.assertIn('description', metadata)
+            self.assertIsInstance(metadata['description'], str)
+
+    def testConfigurationIsMutable(self):
+        """
+        Test that Configuration is mutable (not frozen).
+        Verifies that attributes can be modified after creation since
+        the dataclass isn't marked as frozen.
+        """
+        config = Configuration()
+        new_paths = config.paths.__class__()
+
+        try:
+            config.paths = new_paths
+        except Exception as e:
+            self.fail(f"Should be able to modify attributes, but got {type(e).__name__}")
+
+    def testConfigurationEquality(self):
+        """
+        Test that Configuration instances with same values are equal.
+        Verifies that dataclass equality comparison works as expected.
+        """
+        config1 = Configuration()
+        config2 = Configuration()
+        self.assertNotEqual(config1, config2)

tests/foundation/config/testing/test_testing.py

@@ -0,0 +1,167 @@
+from orionis.luminate.foundation.config.testing.entities.testing import Testing
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.luminate.test.enums.test_mode import ExecutionMode
+from orionis.unittesting import TestCase
+
+class TestTestingConfig(TestCase):
+
+    async def testDefaultValues(self):
+        """
+        Test the default values of the Testing configuration.
+        """
+        t = Testing()
+        self.assertEqual(t.verbosity, 2)
+        self.assertEqual(t.execution_mode, ExecutionMode.SEQUENTIAL.value)
+        self.assertTrue(isinstance(t.max_workers, int) and t.max_workers >= 1)
+        self.assertFalse(t.fail_fast)
+        self.assertTrue(t.print_result)
+        self.assertFalse(t.throw_exception)
+        self.assertEqual(t.base_path, "tests")
+        self.assertEqual(t.folder_path, "*")
+        self.assertEqual(t.pattern, "test_*.py")
+        self.assertIsNone(t.test_name_pattern)
+        self.assertEqual(t.tags, [])
+
+    async def testValidCustomValues(self):
+        """
+        Test custom valid values for all fields.
+        """
+        t = Testing(
+            verbosity=1,
+            execution_mode=ExecutionMode.PARALLEL,
+            max_workers=8,
+            fail_fast=True,
+            print_result=False,
+            throw_exception=True,
+            base_path="my_tests",
+            folder_path=["unit", "integration"],
+            pattern="*_spec.py",
+            test_name_pattern="test_login*",
+            tags=["fast", "critical"]
+        )
+        self.assertEqual(t.verbosity, 1)
+        self.assertEqual(t.execution_mode, ExecutionMode.PARALLEL.value)
+        self.assertEqual(t.max_workers, 8)
+        self.assertTrue(t.fail_fast)
+        self.assertFalse(t.print_result)
+        self.assertTrue(t.throw_exception)
+        self.assertEqual(t.base_path, "my_tests")
+        self.assertEqual(t.folder_path, ["unit", "integration"])
+        self.assertEqual(t.pattern, "*_spec.py")
+        self.assertEqual(t.test_name_pattern, "test_login*")
+        self.assertEqual(t.tags, ["fast", "critical"])
+
+    async def testFolderPathStringAndList(self):
+        """
+        Test folder_path accepts both string and list of strings.
+        """
+        t1 = Testing(folder_path="integration")
+        self.assertEqual(t1.folder_path, "integration")
+        t2 = Testing(folder_path=["integration", "unit"])
+        self.assertEqual(t2.folder_path, ["integration", "unit"])
+
+    async def testTagsNoneOrList(self):
+        """
+        Test tags accepts None or list of strings.
+        """
+        t1 = Testing(tags=None)
+        self.assertIsNone(t1.tags)
+        t2 = Testing(tags=["a", "b"])
+        self.assertEqual(t2.tags, ["a", "b"])
+
+    async def testInvalidVerbosity(self):
+        """
+        Test invalid verbosity values.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(verbosity=-1)
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(verbosity=3)
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(verbosity="high")
+
+    async def testInvalidExecutionMode(self):
+        """
+        Test execution_mode cannot be None.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(execution_mode=None)
+
+    async def testInvalidMaxWorkers(self):
+        """
+        Test invalid max_workers values.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(max_workers=0)
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(max_workers=-5)
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(max_workers="many")
+
+    async def testInvalidFailFast(self):
+        """
+        Test fail_fast must be boolean.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(fail_fast="yes")
+
+    async def testInvalidPrintResult(self):
+        """
+        Test print_result must be boolean.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(print_result=1)
+
+    async def testInvalidThrowException(self):
+        """
+        Test throw_exception must be boolean.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(throw_exception="no")
+
+    async def testInvalidBasePath(self):
+        """
+        Test base_path must be string.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(base_path=123)
+
+    async def testInvalidFolderPath(self):
+        """
+        Test folder_path must be string or list of strings.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(folder_path=123)
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(folder_path=[1, 2])
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(folder_path=["ok", 2])
+
+    async def testInvalidPattern(self):
+        """
+        Test pattern must be string.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(pattern=[])
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(pattern=123)
+
+    async def testInvalidTestNamePattern(self):
+        """
+        Test test_name_pattern must be string or None.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(test_name_pattern=[])
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(test_name_pattern=123)
+
+    async def testInvalidTags(self):
+        """
+        Test tags must be None or list of strings.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(tags="fast")
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(tags=[1, 2])
+        with self.assertRaises(OrionisIntegrityException):
+            Testing(tags=["ok", 2])

tests/patterns/singleton/test_singleton.py

@@ -1,5 +1,5 @@
-from orionis.luminate.patterns import Singleton
-from orionis.luminate.test import TestCase
+from orionis.luminate.patterns.singleton.meta_class import Singleton
+from orionis.luminate.test.cases.test_case import TestCase
 
 class TestsAsyncCoroutine(TestCase):