orionis 0.421.0__py3-none-any.whl → 0.423.0__py3-none-any.whl

orionis/services/environment/enums/{cast_type.py → value_type.py}

@@ -1,6 +1,6 @@
 from enum import Enum
 
-class EnvCastType(Enum):
+class EnvironmentValueType(Enum):
     """
     Enum representing supported environment variable cast types.
 
@@ -31,12 +31,13 @@ class EnvCastType(Enum):
         An enumeration member representing the desired cast type.
     """
 
-    PATH = 'path'   # Represents a file system path
-    STR = 'str'     # Represents a string type
-    INT = 'int'     # Represents an integer type
-    FLOAT = 'float' # Represents a floating-point type
-    BOOL = 'bool'   # Represents a boolean type
-    LIST = 'list'   # Represents a list type
-    DICT = 'dict'   # Represents a dictionary type
-    TUPLE = 'tuple' # Represents a tuple type
-    SET = 'set'     # Represents a set type
+    BASE64 = 'base64' # Represents a base64 encoded type
+    PATH = 'path'     # Represents a file system path
+    STR = 'str'       # Represents a string type
+    INT = 'int'       # Represents an integer type
+    FLOAT = 'float'   # Represents a floating-point type
+    BOOL = 'bool'     # Represents a boolean type
+    LIST = 'list'     # Represents a list type
+    DICT = 'dict'     # Represents a dictionary type
+    TUPLE = 'tuple'   # Represents a tuple type
+    SET = 'set'       # Represents a set type

orionis/services/environment/key/key_generator.py

@@ -1,5 +1,4 @@
 import os
-import base64
 
 class SecureKeyGenerator:
     """
@@ -14,24 +13,17 @@ class SecureKeyGenerator:
     @staticmethod
     def generate() -> str:
         """
-        Generates a secure random key and encodes it in base64 format.
+        Generates a cryptographically secure random key and encodes it in hexadecimal format.
 
-        This method creates a cryptographically secure random key of 32 bytes,
-        encodes it using base64 encoding, and returns the result as a string
-        prefixed with 'base64:'.
+        This method uses the operating system's cryptographic random number generator to
+        produce a 32-byte random value, which is then encoded as a hexadecimal string.
 
         Returns
         -------
         str
-            A string in the format 'base64:<key>', where <key> is a base64-encoded
-            representation of a securely generated 32-byte random key.
+            A 64-character hexadecimal string representing a 32-byte secure random key.
         """
 
-        # Generate 32 bytes of cryptographically secure random data
-        key = os.urandom(32)
-
-        # Encode the random bytes using base64 and decode to a UTF-8 string
-        encoded = base64.b64encode(key).decode('utf-8')
-
-        # Return the key in the required format
-        return f"base64:{encoded}"
+        # Generate 32 random bytes using a cryptographically secure RNG
+        # Encode the bytes as a hexadecimal string and return
+        return os.urandom(32).hex()

orionis/services/environment/validators/types.py

@@ -1,11 +1,11 @@
 import re
-from typing import Any, Union
-from orionis.services.environment.enums.cast_type import EnvCastType
+from typing import Union
+from orionis.services.environment.enums.value_type import EnvironmentValueType
 from orionis.services.environment.exceptions.value import OrionisEnvironmentValueError
 
 class __ValidateTypes:
 
-    def __call__(self, value: Union[str, int, float, bool, list, dict, tuple, set], type_hint: str | EnvCastType = None) -> str:
+    def __call__(self, value: Union[str, int, float, bool, list, dict, tuple, set], type_hint: str | EnvironmentValueType = None) -> str:
 
         # Ensure the value is a valid type.
         if not isinstance(value, (str, int, float, bool, list, dict, tuple, set)):
@@ -14,23 +14,23 @@ class __ValidateTypes:
             )
 
         # If a type hint is provided, ensure it is valid.
-        if type_hint and not isinstance(type_hint, (str, EnvCastType)):
+        if type_hint and not isinstance(type_hint, (str, EnvironmentValueType)):
             raise OrionisEnvironmentValueError(
-                f"Type hint must be a string or EnvCastType, got {type(type_hint).__name__}."
+                f"Type hint must be a string or EnvironmentValueType, got {type(type_hint).__name__}."
             )
 
-        # If type_hint is provided, convert it to a string if it's an EnvCastType.
+        # If type_hint is provided, convert it to a string if it's an EnvironmentValueType.
         if type_hint:
 
-            # If type_hint is a string, convert it to EnvCastType if valid.
+            # If type_hint is a string, convert it to EnvironmentValueType if valid.
             if isinstance(type_hint, str):
                 try:
-                    type_hint = EnvCastType[type_hint.upper()].value
+                    type_hint = EnvironmentValueType[type_hint.upper()].value
                 except KeyError:
                     raise OrionisEnvironmentValueError(
-                        f"Invalid type hint: {type_hint}. Allowed types are {[e.value for e in EnvCastType]}"
+                        f"Invalid type hint: {type_hint}. Allowed types are: {[e.value for e in EnvironmentValueType]}"
                     )
-            elif isinstance(type_hint, EnvCastType):
+            elif isinstance(type_hint, EnvironmentValueType):
                 type_hint = type_hint.value
 
         # If no type hint is provided, use the type of the value.

{orionis-0.421.0.dist-info → orionis-0.423.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orionis
-Version: 0.421.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.421.0.dist-info → orionis-0.423.0.dist-info}/RECORD

@@ -1,5 +1,3 @@
-environment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-environment/test_services_environment.py,sha256=6UH3g2Z2DQYtGnyySCRnT35VCENlL-PQWHIdH6zA9rw,3767
 orionis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/_console/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/_console/command_filter.py,sha256=bn0fcWfQg13DrQBaV4NopNxdP-6up0G54Qmhg7r_BKA,1211
@@ -187,7 +185,7 @@ orionis/foundation/providers/progress_bar_provider.py,sha256=WW3grNgH-yV2meSSTeO
 orionis/foundation/providers/testing_provider.py,sha256=iJSN2RIChbYIL-1ue6vmPmDMCSrvERDkti4Er9MPiLA,1102
 orionis/foundation/providers/workers_provider.py,sha256=kiQjQRyUEyiBX2zcbF_KmqRgvc7Bvxsvg5oMtIvYniM,1075
 orionis/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/metadata/framework.py,sha256=Z_k5Op43n9NO2-4Tg4QDG9HjX9NK-Yi1CzWhnvOpkPg,4960
+orionis/metadata/framework.py,sha256=4ObKf3_80JdUtm-5cIFr9tho1b7Xi1akA-66eblfV6g,4960
 orionis/metadata/package.py,sha256=tqLfBRo-w1j_GN4xvzUNFyweWYFS-qhSgAEc-AmCH1M,5452
 orionis/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/asynchrony/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -199,26 +197,24 @@ orionis/services/asynchrony/exceptions/exception.py,sha256=yAVsjZ2lLAoFgNIiMcOtC
 orionis/services/environment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/environment/env.py,sha256=vKx9zO2DpUK089fL17qxQ4X4tLYzN3exGAKg3d-rp3c,2272
 orionis/services/environment/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/services/environment/contracts/caster.py,sha256=f5OsgsUCu-cqjmfWF6fqyKmXocHZGIjZgXw7F7g05yw,1211
 orionis/services/environment/contracts/env.py,sha256=7lezGxABAG63pEEvzAmHXgr9izBI6TCp05Trx_SRvc4,2054
-orionis/services/environment/contracts/types.py,sha256=n0USxUblz0Ofbo1ef0hnGHGkuGjSiWk-SBWVPXv33mE,1994
 orionis/services/environment/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/services/environment/core/dot_env.py,sha256=Dgkmy0juaFKZPEkv7nN7VvdYryX8fDs0JgRGOIHj7PM,10090
+orionis/services/environment/core/dot_env.py,sha256=1371GV5mxkBH4iPFHccBz9V-6JoZZfy_hSukqJWQjdE,14278
 orionis/services/environment/dynamic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/services/environment/dynamic/types.py,sha256=nf7HJjm-1S-BH2YnuBQNNWvb3Aqu-QYPUTfJRgVYZ1Y,18336
+orionis/services/environment/dynamic/caster.py,sha256=8j1yVcOhdS3WTTgzc19CzmxZFWyY6vRVGT__76mU5JI,35040
 orionis/services/environment/enums/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/services/environment/enums/cast_type.py,sha256=hoZhljXHNn03VYbg6VTauGyppmcoRjaepylrOKSBvu8,1217
+orionis/services/environment/enums/value_type.py,sha256=C-JQGGz1GtdoggKG-rBykUm9lUTS2JmU232D8lWTB2Q,1302
 orionis/services/environment/exceptions/__init__.py,sha256=YwLc8GsB0swlwu9T9Qt2vevaCoq5V2vmPUSlEUAqg2Q,199
 orionis/services/environment/exceptions/exception.py,sha256=NnxWmgoSca7LXi7GLDa95HSBPKotFfy8u729d1OAmCc,479
 orionis/services/environment/exceptions/value.py,sha256=Pe1qNHRrM9T0AzESN284CzA3GQYxzokfXPMOVqOTlyQ,475
 orionis/services/environment/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/environment/helpers/functions.py,sha256=MtlDTA1W8KVJu0cohh4TsuPg8CPcnySf36cp9E9tpJI,595
 orionis/services/environment/key/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/services/environment/key/key_generator.py,sha256=BHvcFiPOmJHQotstMNkUdoEwb0mNxQk5iyvQU3JlJ94,1134
-orionis/services/environment/serializer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/services/environment/serializer/values.py,sha256=ERnQWgCAljhJ9pRSd-knnGD5i6ne5Ho-4bh93pgDtwY,364
+orionis/services/environment/key/key_generator.py,sha256=uFHOPH0YtYU_vEG7Oc3a51O15QxZl1USD_KlYcS9SsQ,912
 orionis/services/environment/validators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/environment/validators/key_name.py,sha256=heMQoMY4vF9sIYAlET7noTQz383daGPvJnJOb62nxFo,1577
-orionis/services/environment/validators/types.py,sha256=AQvIZzBWxZ6-iJhzRkroim5CKBvWq2lTttRyXzc-6GU,1922
+orionis/services/environment/validators/types.py,sha256=t3G-JlJz1jDcYKrS7iljBL2q3m-KpmcCFBGoQIhRtK0,2000
 orionis/services/introspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/introspection/reflection.py,sha256=_Wdy8Wtt3RKXAqg9o5rvYa_Hyu-Z4674LKnNVg7u7pU,11467
 orionis/services/introspection/abstract/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -357,7 +353,7 @@ orionis/test/validators/web_report.py,sha256=-h3Fe9jY93_kzUhd2NBIqEfCcBpu-8Ei9x3
 orionis/test/validators/workers.py,sha256=LGffDKtK6SKixFKzIYPQpI5aFeQPAGXpv_LUtmEu6g4,1102
 orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/view/render.py,sha256=3ICz68l-WF3BtnYqH5m-ktN9UD00MELMbmMnyJDV74A,4768
-orionis-0.421.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.423.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/test_container.py,sha256=asv8TkkupVoex6SWod74NBl4dSs7wb9mLmu_glNdNy8,14815
@@ -389,6 +385,8 @@ tests/container/validators/test_is_not_subclass.py,sha256=1OCPtCRuysm7OKL6XhuXJP
 tests/container/validators/test_is_subclass.py,sha256=0Uc8uIR69ZX7G5Nrex0LMQXrueTdncdDxfQoila3h3U,5834
 tests/container/validators/test_is_valid_alias.py,sha256=egVf6IfSXurIdu8hKo03rwsM1P-bxGOFd1_9JjDHJIk,5657
 tests/container/validators/test_lifetime.py,sha256=5PequjXAcIcp0Q4TIki7THSU31XftGpI0u1mVGqHmpU,4692
+tests/environment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/environment/test_services_environment.py,sha256=Xf61PQJHgZSmDuASwWZBuoVnB353cibClyo9_EC3X0k,9567
 tests/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/example/test_example.py,sha256=XJEcsro3vCO5m4zvMiWUGphvd0C7oIkBtUfQgTDsdUU,25568
 tests/foundation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -500,8 +498,8 @@ tests/testing/validators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 tests/testing/validators/test_testing_validators.py,sha256=QdcF0Vhnnl_kD-PzceHJbUYOqwPTB1Td7YaTv8LTr30,19612
 tests/testing/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/testing/view/test_render.py,sha256=-ghGG8rimyb2b2wtvMuSPPH7Zac5_NlVCiUcHRA5SNg,1172
-orionis-0.421.0.dist-info/METADATA,sha256=LuYV7Rv2dQBgwy1Ztkz-8mlxiodXlvEPpSJmEw8Gzx0,4772
-orionis-0.421.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-orionis-0.421.0.dist-info/top_level.txt,sha256=0G1WIo0HbkZ6hNbKp6cdXLoKj1SfULEORhCuPIV_Dqw,26
-orionis-0.421.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-orionis-0.421.0.dist-info/RECORD,,
+orionis-0.423.0.dist-info/METADATA,sha256=sCWDt2p6GoLQ8lvYWZvDwnfDE6ipPB1GC2Ae9L2t7wE,4772
+orionis-0.423.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orionis-0.423.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.423.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.423.0.dist-info/RECORD,,

{orionis-0.421.0.dist-info → orionis-0.423.0.dist-info}/top_level.txt

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

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=')

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")