orionis 0.422.0__tar.gz → 0.423.0__tar.gz

{orionis-0.422.0/orionis.egg-info → orionis-0.423.0}/PKG-INFO

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

{orionis-0.422.0 → orionis-0.423.0}/orionis/metadata/framework.py

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

{orionis-0.422.0 → orionis-0.423.0/orionis.egg-info}/PKG-INFO

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

{orionis-0.422.0 → orionis-0.423.0}/orionis.egg-info/SOURCES.txt

@@ -2,8 +2,6 @@ LICENCE
 MANIFEST.in
 README.md
 setup.py
-environment/__init__.py
-environment/test_services_environment.py
 orionis/__init__.py
 orionis.egg-info/PKG-INFO
 orionis.egg-info/SOURCES.txt
@@ -396,6 +394,8 @@ tests/container/validators/test_is_not_subclass.py
 tests/container/validators/test_is_subclass.py
 tests/container/validators/test_is_valid_alias.py
 tests/container/validators/test_lifetime.py
+tests/environment/__init__.py
+tests/environment/test_services_environment.py
 tests/example/__init__.py
 tests/example/test_example.py
 tests/foundation/__init__.py

{orionis-0.422.0 → orionis-0.423.0}/orionis.egg-info/top_level.txt

@@ -1,3 +1,2 @@
-environment
 orionis
 tests

orionis-0.423.0/tests/environment/test_services_environment.py

@@ -0,0 +1,227 @@
+from pathlib import Path
+from orionis.services.environment.env import Env
+from orionis.test.cases.asynchronous import AsyncTestCase
+import os
+from orionis.services.environment.core.dot_env import DotEnv
+from orionis.services.environment.enums.value_type import EnvironmentValueType
+from orionis.services.environment.core.dot_env import DotEnv
+
+class TestServicesEnvironment(AsyncTestCase):
+
+    async def testSetAndGetConstants(self):
+        """
+        Stores and retrieves framework metadata constants using Env.set and Env.get.
+
+        This test 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.
+        It then retrieves each constant using `Env.get` and asserts that the retrieved value matches
+        the original constant.
+
+        Parameters
+        ----------
+        self : TestServicesEnvironment
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate behavior.
+
+        Notes
+        -----
+        - Ensures that `Env.set` returns True for each constant.
+        - Ensures that `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
+        )
+
+        # Prepare a dictionary of constant names and their values
+        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
+        }
+
+        # Set each constant in the environment and assert the operation succeeds
+        for key, value in constants.items():
+            result = Env.set(key, value)
+            self.assertTrue(result)
+
+        # Retrieve each constant and assert the value matches the original
+        for key, value in constants.items():
+            retrieved = Env.get(key)
+            self.assertEqual(retrieved, value)
+
+    async def testGetNonExistentKey(self):
+        """
+        Test the behavior of `Env.get` when retrieving a non-existent environment key.
+
+        This test verifies that attempting to retrieve a value for a key that has not been set
+        in the environment returns `None`. This ensures that the environment behaves as expected
+        when queried for missing keys.
+
+        Parameters
+        ----------
+        self : TestServicesEnvironment
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate that `Env.get`
+            returns `None` for a non-existent key.
+
+        Notes
+        -----
+        - Ensures that `Env.get` returns `None` when the specified key does not exist in the environment.
+        """
+
+        # Attempt to retrieve a value for a key that has not been set.
+        self.assertIsNone(Env.get("NON_EXISTENT_KEY"))
+
+    async def testDotEnvSetAndGetWithType(self):
+        """
+        Test DotEnv.set and DotEnv.get with explicit EnvironmentValueType for various data types.
+
+        This test verifies that the `DotEnv` class correctly stores and retrieves environment variables
+        when an explicit `EnvironmentValueType` is provided. For each supported data type, the test sets
+        a value using `DotEnv.set` with the corresponding `EnvironmentValueType`, then retrieves it using
+        `DotEnv.get` and asserts that the returned value is correctly prefixed or formatted according to
+        the specified type.
+
+        Parameters
+        ----------
+        self : TestServicesEnvironment
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate the correct behavior
+            of `DotEnv.set` and `DotEnv.get` with explicit type information.
+
+        Notes
+        -----
+        - Ensures that values are stored and retrieved with the correct type prefixes or formatting.
+        - Covers all supported types: PATH, STR, INT, FLOAT, BOOL, LIST, DICT, TUPLE, SET, BASE64.
+        """
+
+        env = DotEnv()
+
+        # Set and assert a PATH value with explicit type
+        env.set("CAST_EXAMPLE_PATH", '/tests', EnvironmentValueType.PATH)
+        self.assertEqual(env.get("CAST_EXAMPLE_PATH"), Path(Path.cwd(), 'tests'))
+
+        # Set and assert a string value with explicit type
+        env.set("CAST_EXAMPLE_STR", 'hello', EnvironmentValueType.STR)
+        self.assertEqual(env.get("CAST_EXAMPLE_STR"), "hello")
+
+        # Set and assert an integer value with explicit type
+        env.set("CAST_EXAMPLE_INT", 123, EnvironmentValueType.INT)
+        self.assertEqual(env.get("CAST_EXAMPLE_INT"), 123)
+
+        # Set and assert a float value with explicit type
+        env.set("CAST_EXAMPLE_FLOAT", 3.14, EnvironmentValueType.FLOAT)
+        self.assertEqual(env.get("CAST_EXAMPLE_FLOAT"), 3.14)
+
+        # Set and assert a boolean value with explicit type
+        env.set("CAST_EXAMPLE_BOOL", True, EnvironmentValueType.BOOL)
+        self.assertEqual(env.get("CAST_EXAMPLE_BOOL"), True)
+
+        # Set and assert a list value with explicit type
+        env.set("CAST_EXAMPLE_LIST", [1, 2, 3], EnvironmentValueType.LIST)
+        self.assertEqual(env.get("CAST_EXAMPLE_LIST"), [1, 2, 3])
+
+        # Set and assert a dictionary value with explicit type
+        env.set("CAST_EXAMPLE_DICT", {"a": 1, "b": 2}, EnvironmentValueType.DICT)
+        self.assertEqual(env.get("CAST_EXAMPLE_DICT"), {"a": 1, "b": 2})
+
+        # Set and assert a tuple value with explicit type
+        env.set("CAST_EXAMPLE_TUPLE", (1, 2), EnvironmentValueType.TUPLE)
+        self.assertEqual(env.get("CAST_EXAMPLE_TUPLE"), (1, 2))
+
+        # Set and assert a set value with explicit type
+        env.set("CAST_EXAMPLE_SET", {1, 2, 3}, EnvironmentValueType.SET)
+        self.assertEqual(env.get("CAST_EXAMPLE_SET"), {1, 2, 3})
+
+        # Set and assert a base64 value with explicit type
+        ramdon_text = os.urandom(32).hex()
+        env.set("CAST_EXAMPLE_BASE64", ramdon_text, EnvironmentValueType.BASE64)
+        self.assertEqual(env.get("CAST_EXAMPLE_BASE64"), ramdon_text)
+
+    async def testDotEnvSetAndGetWithoutType(self):
+        """
+        Test DotEnv.set and DotEnv.get without explicit EnvironmentValueType for various data types.
+
+        This test verifies that the `DotEnv` class can store and retrieve environment variables of different
+        Python data types without specifying an explicit `EnvironmentValueType`. It checks that the values
+        are stored and retrieved as their string representations, and asserts the correctness of the returned
+        values for each data type.
+
+        Parameters
+        ----------
+        self : TestServicesEnvironment
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate that the returned values
+            from `DotEnv.get` match the expected string representations for each data type.
+
+        Notes
+        -----
+        - Ensures that values are stored and retrieved as strings when no explicit type is provided.
+        - Covers various data types: path, str, int, float, bool, list, dict, tuple, set, and base64.
+        """
+
+        env = DotEnv()
+
+        # Set and get a path value without explicit type
+        env.set("EXAMPLE_PATH", '/tests')
+        self.assertEqual(env.get("EXAMPLE_PATH"), '/tests')
+
+        # Set and get a string value without explicit type
+        env.set("EXAMPLE_STR", 'hello')
+        self.assertEqual(env.get("EXAMPLE_STR"), 'hello')
+
+        # Set and get an integer value without explicit type
+        env.set("EXAMPLE_INT", 123)
+        self.assertEqual(env.get("EXAMPLE_INT"), 123)
+
+        # Set and get a float value without explicit type
+        env.set("EXAMPLE_FLOAT", 3.14)
+        self.assertEqual(env.get("EXAMPLE_FLOAT"), 3.14)
+
+        # Set and get a boolean value without explicit type
+        env.set("EXAMPLE_BOOL", True)
+        self.assertEqual(env.get("EXAMPLE_BOOL"), True)
+
+        # Set and get a list value without explicit type
+        env.set("EXAMPLE_LIST", [1, 2, 3])
+        self.assertEqual(env.get("EXAMPLE_LIST"), [1, 2, 3])
+
+        # Set and get a dictionary value without explicit type
+        env.set("EXAMPLE_DICT", {"a": 1, "b": 2})
+        self.assertEqual(env.get("EXAMPLE_DICT"), {"a": 1, "b": 2})
+
+        # Set and get a tuple value without explicit type
+        env.set("EXAMPLE_TUPLE", (1, 2))
+        self.assertEqual(env.get("EXAMPLE_TUPLE"), (1, 2))
+
+        # Set and get a set value without explicit type
+        env.set("EXAMPLE_SET", {1, 2, 3})
+        self.assertEqual(env.get("EXAMPLE_SET"), {1, 2, 3})
+
+        # Set and get a base64 value without explicit type
+        env.set("EXAMPLE_BASE64", "T3Jpb25pcyBGcmFtZXdvcms=")
+        self.assertEqual(env.get("EXAMPLE_BASE64"), 'T3Jpb25pcyBGcmFtZXdvcms=')

orionis-0.422.0/environment/test_services_environment.py

@@ -1,93 +0,0 @@
-from orionis.services.environment.env import Env
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestServicesEnvironment(AsyncTestCase):
-
-    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")