orionis 0.286.0__py3-none-any.whl → 0.288.0__py3-none-any.whl

tests/foundation/config/session/{test_session.py → test_foundation_config_session.py}

@@ -3,11 +3,13 @@ from orionis.foundation.config.session.enums.same_site_policy import SameSitePol
 from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.unittesting import TestCase
 
-class TestSession(TestCase):
-
+class TestFoundationConfigSession(TestCase):
     async def testDefaultInitialization(self):
         """
         Test that Session instance is initialized with correct default values.
+
+        Notes
+        -----
         Verifies default values for all attributes including secret_key generation.
         """
         session = Session()
@@ -22,6 +24,9 @@ class TestSession(TestCase):
     async def testSecretKeyValidation(self):
         """
         Test validation for secret_key attribute.
+
+        Notes
+        -----
         Verifies that invalid secret keys raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
@@ -32,6 +37,9 @@ class TestSession(TestCase):
     async def testSessionCookieValidation(self):
         """
         Test validation for session_cookie attribute.
+
+        Notes
+        -----
         Verifies invalid cookie names raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
@@ -44,6 +52,9 @@ class TestSession(TestCase):
     async def testMaxAgeValidation(self):
         """
         Test validation for max_age attribute.
+
+        Notes
+        -----
         Verifies invalid max_age values raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
@@ -57,6 +68,9 @@ class TestSession(TestCase):
     async def testSameSiteValidation(self):
         """
         Test validation and normalization for same_site attribute.
+
+        Notes
+        -----
         Verifies both string and enum inputs are properly handled.
         """
         # Test string inputs (case-insensitive)
@@ -78,6 +92,9 @@ class TestSession(TestCase):
     async def testPathValidation(self):
         """
         Test validation for path attribute.
+
+        Notes
+        -----
         Verifies invalid paths raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
@@ -90,6 +107,9 @@ class TestSession(TestCase):
     async def testHttpsOnlyValidation(self):
         """
         Test validation for https_only attribute.
+
+        Notes
+        -----
         Verifies non-boolean values raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
@@ -100,6 +120,9 @@ class TestSession(TestCase):
     async def testDomainValidation(self):
         """
         Test validation for domain attribute.
+
+        Notes
+        -----
         Verifies invalid domains raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
@@ -116,6 +139,9 @@ class TestSession(TestCase):
     async def testToDictMethod(self):
         """
         Test the toDict method returns proper dictionary representation.
+
+        Notes
+        -----
         Verifies all fields are included with correct values.
         """
         session = Session()
@@ -132,6 +158,9 @@ class TestSession(TestCase):
     async def testKwOnlyInitialization(self):
         """
         Test that Session requires keyword arguments for initialization.
+
+        Notes
+        -----
         Verifies the class enforces kw_only=True in its dataclass decorator.
         """
         with self.assertRaises(TypeError):

tests/foundation/config/startup/{test_config_startup.py → test_foundation_config_startup.py}

@@ -1,29 +1,64 @@
 from dataclasses import is_dataclass
 from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.foundation.config.startup import Configuration
-from orionis.unittesting import TestCase, UnittestMock
+from orionis.unittesting import TestCase, Mock
 
-class TestConfiguration(TestCase):
+class TestFoundationConfigStartup(TestCase):
     """
-    Test suite for the Configuration dataclass which encapsulates all major
-    configuration sections for the application.
+    Test suite for the Configuration dataclass.
 
-    This test class verifies the proper initialization, type validation,
-    and dictionary conversion of the Configuration class.
+    This class contains unit tests to verify the correct behavior of the
+    Configuration dataclass, including initialization, type validation,
+    dictionary conversion, metadata accessibility, mutability, and equality.
+
+    Attributes
+    ----------
+    None
+
+    Methods
+    -------
+    testConfigurationIsDataclass()
+        Test that Configuration is properly defined as a dataclass.
+    testDefaultInitialization()
+        Test that Configuration can be initialized with default values.
+    testAllSectionsHaveDefaultFactories()
+        Test that all configuration sections have default factories.
+    testTypeValidationInPostInit()
+        Test that __post_init__ validates types correctly.
+    testToDictReturnsCompleteDictionary()
+        Test that toDict() returns a complete dictionary representation.
+    testToDictReturnsNestedStructures()
+        Test that toDict() properly converts nested dataclasses.
+    testMetadataIsAccessible()
+        Test that field metadata is properly defined and accessible.
+    testConfigurationIsMutable()
+        Test that Configuration is mutable (not frozen).
+    testConfigurationEquality()
+        Test that Configuration instances with same values are equal.
     """
 
     def testConfigurationIsDataclass(self):
         """
         Test that Configuration is properly defined as a dataclass.
-        Verifies that the @dataclass decorator was applied correctly.
+
+        Ensures that the @dataclass decorator was applied correctly.
+
+        Returns
+        -------
+        None
         """
         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.
+
+        Verifies that all default factories work correctly and the instance
+        is properly constructed.
+
+        Returns
+        -------
+        None
         """
         config = Configuration()
         self.assertIsInstance(config, Configuration)
@@ -31,8 +66,13 @@ class TestConfiguration(TestCase):
     def testAllSectionsHaveDefaultFactories(self):
         """
         Test that all configuration sections have default factories.
+
         Verifies that each field in the Configuration class has a
         default_factory specified.
+
+        Returns
+        -------
+        None
         """
         config = Configuration()
         for field in config.__dataclass_fields__.values():
@@ -42,8 +82,13 @@ class TestConfiguration(TestCase):
     def testTypeValidationInPostInit(self):
         """
         Test that __post_init__ validates types correctly.
+
         Verifies that the type checking for each configuration section
         works as expected.
+
+        Returns
+        -------
+        None
         """
         # Test with all correct types (should not raise)
         try:
@@ -53,18 +98,18 @@ class TestConfiguration(TestCase):
 
         # 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())
+            ('paths', Mock()),
+            ('app', Mock()),
+            ('auth', Mock()),
+            ('cache', Mock()),
+            ('cors', Mock()),
+            ('database', Mock()),
+            ('filesystems', Mock()),
+            ('logging', Mock()),
+            ('mail', Mock()),
+            ('queue', Mock()),
+            ('session', Mock()),
+            ('testing', Mock())
         ]
 
         for section_name, wrong_value in sections:
@@ -76,8 +121,13 @@ class TestConfiguration(TestCase):
     def testToDictReturnsCompleteDictionary(self):
         """
         Test that toDict() returns a complete dictionary representation.
+
         Verifies that the returned dictionary contains all configuration
         sections with their current values.
+
+        Returns
+        -------
+        None
         """
         config = Configuration()
         config_dict = config.toDict()
@@ -89,8 +139,13 @@ class TestConfiguration(TestCase):
     def testToDictReturnsNestedStructures(self):
         """
         Test that toDict() properly converts nested dataclasses.
+
         Verifies that the dictionary conversion works recursively for
         all nested configuration sections.
+
+        Returns
+        -------
+        None
         """
         config = Configuration()
         config_dict = config.toDict()
@@ -101,8 +156,13 @@ class TestConfiguration(TestCase):
     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.
+
+        Returns
+        -------
+        None
         """
         config = Configuration()
         for field in config.__dataclass_fields__.values():
@@ -113,8 +173,13 @@ class TestConfiguration(TestCase):
     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.
+
+        Returns
+        -------
+        None
         """
         config = Configuration()
         new_paths = config.paths.__class__()
@@ -127,7 +192,12 @@ class TestConfiguration(TestCase):
     def testConfigurationEquality(self):
         """
         Test that Configuration instances with same values are equal.
+
         Verifies that dataclass equality comparison works as expected.
+
+        Returns
+        -------
+        None
         """
         config1 = Configuration()
         config2 = Configuration()

tests/foundation/config/testing/{test_testing.py → test_foundation_config_testing.py}

@@ -3,11 +3,22 @@ from orionis.foundation.config.exceptions.integrity import OrionisIntegrityExcep
 from orionis.test.enums.test_mode import ExecutionMode
 from orionis.unittesting import TestCase
 
-class TestTestingConfig(TestCase):
+class TestFoundationConfigTesting(TestCase):
+    """
+    Test suite for the Testing configuration entity.
+
+    This class contains asynchronous test cases to validate the default values,
+    custom values, and integrity constraints of the Testing configuration.
+    """
 
     async def testDefaultValues(self):
         """
         Test the default values of the Testing configuration.
+
+        Notes
+        -----
+        Ensures that all default attributes of the Testing configuration are set
+        as expected.
         """
         t = Testing()
         self.assertEqual(t.verbosity, 2)
@@ -25,6 +36,11 @@ class TestTestingConfig(TestCase):
     async def testValidCustomValues(self):
         """
         Test custom valid values for all fields.
+
+        Notes
+        -----
+        Verifies that the Testing configuration accepts and correctly sets
+        custom valid values for all its fields.
         """
         t = Testing(
             verbosity=1,
@@ -54,6 +70,10 @@ class TestTestingConfig(TestCase):
     async def testFolderPathStringAndList(self):
         """
         Test folder_path accepts both string and list of strings.
+
+        Notes
+        -----
+        Checks that the folder_path attribute can be set as a string or a list of strings.
         """
         t1 = Testing(folder_path="integration")
         self.assertEqual(t1.folder_path, "integration")
@@ -63,6 +83,10 @@ class TestTestingConfig(TestCase):
     async def testTagsNoneOrList(self):
         """
         Test tags accepts None or list of strings.
+
+        Notes
+        -----
+        Ensures that the tags attribute can be set to None or a list of strings.
         """
         t1 = Testing(tags=None)
         self.assertIsNone(t1.tags)
@@ -72,6 +96,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidVerbosity(self):
         """
         Test invalid verbosity values.
+
+        Notes
+        -----
+        Verifies that invalid verbosity values raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(verbosity=-1)
@@ -83,6 +111,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidExecutionMode(self):
         """
         Test execution_mode cannot be None.
+
+        Notes
+        -----
+        Ensures that setting execution_mode to None raises OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(execution_mode=None)
@@ -90,6 +122,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidMaxWorkers(self):
         """
         Test invalid max_workers values.
+
+        Notes
+        -----
+        Checks that invalid values for max_workers raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(max_workers=0)
@@ -101,6 +137,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidFailFast(self):
         """
         Test fail_fast must be boolean.
+
+        Notes
+        -----
+        Ensures that non-boolean values for fail_fast raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(fail_fast="yes")
@@ -108,6 +148,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidPrintResult(self):
         """
         Test print_result must be boolean.
+
+        Notes
+        -----
+        Ensures that non-boolean values for print_result raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(print_result=1)
@@ -115,6 +159,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidThrowException(self):
         """
         Test throw_exception must be boolean.
+
+        Notes
+        -----
+        Ensures that non-boolean values for throw_exception raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(throw_exception="no")
@@ -122,6 +170,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidBasePath(self):
         """
         Test base_path must be string.
+
+        Notes
+        -----
+        Ensures that non-string values for base_path raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(base_path=123)
@@ -129,6 +181,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidFolderPath(self):
         """
         Test folder_path must be string or list of strings.
+
+        Notes
+        -----
+        Ensures that invalid types for folder_path raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(folder_path=123)
@@ -140,6 +196,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidPattern(self):
         """
         Test pattern must be string.
+
+        Notes
+        -----
+        Ensures that non-string values for pattern raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(pattern=[])
@@ -149,6 +209,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidTestNamePattern(self):
         """
         Test test_name_pattern must be string or None.
+
+        Notes
+        -----
+        Ensures that invalid types for test_name_pattern raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(test_name_pattern=[])
@@ -158,6 +222,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidTags(self):
         """
         Test tags must be None or list of strings.
+
+        Notes
+        -----
+        Ensures that invalid types for tags raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(tags="fast")

tests/patterns/singleton/test_patterns_singleton.py

@@ -0,0 +1,27 @@
+from orionis.patterns.singleton.meta_class import Singleton
+from orionis.test.cases.test_case import TestCase
+
+class TestPatternsSingleton(TestCase):
+    """
+    Test cases for the Singleton metaclass.
+
+    This class contains asynchronous test methods to verify the correct behavior
+    of the Singleton metaclass, ensuring that only one instance of a class is created.
+    """
+
+    async def testSingleton(self):
+        """
+        Test the Singleton metaclass.
+
+        Ensures that only one instance of a class using the Singleton metaclass is created,
+        regardless of how many times the class is instantiated.
+        """
+        class SingletonClass(metaclass=Singleton):
+            def __init__(self, value):
+                self.value = value
+
+        instance1 = SingletonClass(1)
+        instance2 = SingletonClass(2)
+
+        self.assertIs(instance1, instance2)
+        self.assertEqual(instance1.value, 1)

tests/services/asynchrony/{test_async_io.py → test_services_asynchrony_coroutine.py}

@@ -3,7 +3,7 @@ from orionis.services.asynchrony.coroutines import Coroutine
 from orionis.services.asynchrony.exceptions.coroutine_exception import OrionisCoroutineException
 from orionis.unittesting import TestCase
 
-class TestsAsyncIO(TestCase):
+class TestServicesAsynchronyCoroutine(TestCase):
 
     async def testExecuteWithActiveEventLoop(self):
         """

tests/services/environment/test_services_environment.py

@@ -0,0 +1,93 @@
+from orionis.services.environment.env import Env
+from orionis.unittesting import TestCase
+
+class TestServicesEnvironment(TestCase):
+
+    async def testSetAndGetConstants(self):
+        """
+        Test storing and retrieving framework metadata constants using Env.set and Env.get.
+
+        Imports several metadata constants from the `orionis.metadata.framework` module, sets each constant
+        in the Env storage using `Env.set`, and verifies that the operation succeeds. Then retrieves each
+        constant using `Env.get` and asserts that the retrieved value matches the original constant.
+
+        Ensures
+        -------
+        - `Env.set` returns True for each constant.
+        - `Env.get` returns the correct value for each constant.
+        """
+        from orionis.metadata.framework import (
+            NAME, VERSION, AUTHOR, AUTHOR_EMAIL, DESCRIPTION,
+            SKELETON, FRAMEWORK, DOCS, API, PYTHON_REQUIRES
+        )
+        constants = {
+            "NAME": NAME,
+            "VERSION": VERSION,
+            "AUTHOR": AUTHOR,
+            "AUTHOR_EMAIL": AUTHOR_EMAIL,
+            "DESCRIPTION": DESCRIPTION,
+            "SKELETON": SKELETON,
+            "FRAMEWORK": FRAMEWORK,
+            "DOCS": DOCS,
+            "API": API,
+            "PYTHON_REQUIRES": PYTHON_REQUIRES
+        }
+        for key, value in constants.items():
+            result = Env.set(key, value)
+            self.assertTrue(result)
+        for key, value in constants.items():
+            retrieved = Env.get(key)
+            self.assertEqual(retrieved, value)
+
+    async def testGetNonExistentKey(self):
+        """
+        Test that Env.get returns None for a non-existent environment key.
+
+        Ensures
+        -------
+        - `Env.get` returns None when the key does not exist.
+        """
+        self.assertIsNone(Env.get("NON_EXISTENT_KEY"))
+
+    async def testTypeHints(self):
+        """
+        Test that Env.set and Env.get correctly handle and preserve Python type hints.
+
+        Sets environment variables with various data types (int, float, bool, str, list, dict, tuple, set)
+        using the `Env.set` method, specifying the type as a string. Then retrieves each variable using
+        `Env.get` and asserts that the returned value is of the expected Python type.
+
+        Ensures
+        -------
+        - The returned value from `Env.get` matches the expected Python type for each variable.
+        """
+
+        # Set environment variables with type hints
+        Env.set("TEST_INT", 42, 'int')
+        Env.set("TEST_FLOAT", 3.14, 'float')
+        Env.set("TEST_BOOL", True, 'bool')
+        Env.set("TEST_STR", "Hello, World!", 'str')
+        Env.set("TEST_LIST", [1, 2, 3], 'list')
+        Env.set("TEST_DICT", {"key": "value"}, 'dict')
+        Env.set("TEST_TUPLE", (1,2,3), 'tuple')
+        Env.set("TEST_SET", {1, 2, 3}, 'set')
+
+        # Retrieve and check types
+        self.assertIsInstance(Env.get("TEST_INT"), int)
+        self.assertIsInstance(Env.get("TEST_FLOAT"), float)
+        self.assertIsInstance(Env.get("TEST_BOOL"), bool)
+        self.assertIsInstance(Env.get("TEST_STR"), str)
+        self.assertIsInstance(Env.get("TEST_LIST"), list)
+        self.assertIsInstance(Env.get("TEST_DICT"), dict)
+        self.assertIsInstance(Env.get("TEST_TUPLE"), tuple)
+        self.assertIsInstance(Env.get("TEST_SET"), set)
+
+        # Clean up environment variables after test
+        Env.unset("TEST_INT")
+        Env.unset("TEST_FLOAT")
+        Env.unset("TEST_BOOL")
+        Env.unset("TEST_STR")
+        Env.unset("TEST_LIST")
+        Env.unset("TEST_DICT")
+        Env.unset("TEST_TUPLE")
+        Env.unset("TEST_SET")