orionis 0.253.0__py3-none-any.whl → 0.266.0__py3-none-any.whl

tests/services/standard/test_std.py

@@ -0,0 +1,127 @@
+
+from orionis.luminate.services.standard.std import StdClass
+from orionis.unittesting import TestCase
+
+class TestStdClass(TestCase):
+
+    async def testInitializationAndAccess(self):
+        """
+        Test the initialization of StdClass and access to its attributes.
+
+        This test verifies that an instance of StdClass can be created with the given
+        first name, last name, and age, and that these attributes can be accessed
+        correctly after initialization.
+        """
+        obj = StdClass(
+            first_name='Raul',
+            last_name='Uñate',
+            age=31
+        )
+        self.assertEqual(obj.first_name, 'Raul')
+        self.assertEqual(obj.age, 31)
+
+    async def testToDictReturnsCorrectData(self):
+        """
+        Test that the toDict method of StdClass returns a dictionary with the correct data.
+
+        This test creates an instance of StdClass with specific attributes and verifies
+        that calling toDict() returns a dictionary containing those attributes and their values.
+        """
+        obj = StdClass(a=1, b=2)
+        expected = {'a': 1, 'b': 2}
+        self.assertEqual(obj.toDict(), expected)
+
+    async def testUpdateAttributes(self):
+        """
+        Test that the `update` method of `StdClass` correctly sets multiple attributes.
+
+        This test creates an instance of `StdClass`, updates its attributes using the `update` method,
+        and asserts that the attributes `foo` and `number` are set to the expected values.
+        """
+        obj = StdClass()
+        obj.update(foo='bar', number=42)
+        self.assertEqual(obj.foo, 'bar')
+        self.assertEqual(obj.number, 42)
+
+    async def testUpdateReservedAttributeRaisesError(self):
+        """
+        Test that updating a reserved attribute (such as '__init__') on a StdClass instance
+        raises a ValueError exception.
+        """
+        obj = StdClass()
+        with self.assertRaises(ValueError):
+            obj.update(__init__='bad')
+
+    async def testUpdateConflictingAttributeRaisesError(self):
+        """
+        Test that updating an object with a conflicting attribute name ('toDict') raises a ValueError.
+
+        This test ensures that attempting to update the StdClass instance with a keyword argument
+        that conflicts with an existing method or reserved attribute ('toDict') correctly triggers
+        a ValueError, enforcing attribute safety.
+        """
+        obj = StdClass()
+        with self.assertRaises(ValueError):
+            obj.update(toDict='oops')
+
+    async def testRemoveExistingAttributes(self):
+        """
+        Tests that the `remove` method of `StdClass` successfully removes an existing attribute ('x') from the object,
+        while leaving other attributes ('y') intact.
+        """
+        obj = StdClass(x=1, y=2)
+        obj.remove('x')
+        self.assertFalse(hasattr(obj, 'x'))
+        self.assertTrue(hasattr(obj, 'y'))
+
+    async def testRemoveNonExistingAttributeRaisesError(self):
+        """
+        Test that attempting to remove a non-existing attribute from a StdClass instance raises an AttributeError.
+
+        This test verifies that the `remove` method of `StdClass` correctly raises an AttributeError
+        when called with the name of an attribute that does not exist on the object.
+        """
+        obj = StdClass()
+        with self.assertRaises(AttributeError):
+            obj.remove('not_there')
+
+    async def testFromDictCreatesEquivalentInstance(self):
+        """
+        Test that StdClass.from_dict creates an instance equivalent to the original data.
+
+        This test verifies that when a dictionary is passed to StdClass.from_dict,
+        the resulting object's toDict() method returns a dictionary equal to the original input.
+        """
+        data = {'a': 10, 'b': 20}
+        obj = StdClass.from_dict(data)
+        self.assertEqual(obj.toDict(), data)
+
+    async def testReprAndStr(self):
+        """
+        Test that the __repr__ and __str__ methods of StdClass include the class name and the value of 'x' respectively.
+
+        This test verifies:
+        - The string representation produced by repr(obj) contains the class name 'StdClass'.
+        - The string representation produced by str(obj) contains the key-value pair "'x': 5".
+        """
+        obj = StdClass(x=5)
+        self.assertIn("StdClass", repr(obj))
+        self.assertIn("'x': 5", str(obj))
+
+    async def testEquality(self):
+        """
+        Tests the equality and inequality operations for StdClass instances.
+
+        This test creates three instances of StdClass:
+        - 'a' and 'b' with identical attributes (x=1, y=2), which should be considered equal.
+        - 'c' with a different attribute (x=3), which should not be equal to 'a'.
+
+        Assertions:
+        - Verifies that 'a' and 'b' are equal.
+        - Verifies that 'a' and 'c' are not equal.
+        """
+        a = StdClass(x=1, y=2)
+        b = StdClass(x=1, y=2)
+        c = StdClass(x=3)
+        self.assertEqual(a, b)
+        self.assertNotEqual(a, c)

tests/services/wrapper/test_wrapper_doc_dict.py

@@ -0,0 +1,129 @@
+from orionis.luminate.services.wrapper.dicts.dot_dict import DotDict
+from orionis.unittesting import TestCase
+
+class TestDotDict(TestCase):
+    """
+    Test cases for the DotDict class which provides dictionary with dot notation access.
+    """
+
+    async def testDotNotationAccess(self):
+        """
+        Test that dictionary values can be accessed using dot notation.
+        Verifies that both existing and non-existing keys can be accessed via dot notation,
+        with None returned for missing keys.
+        """
+        dd = DotDict({'key1': 'value1', 'nested': {'inner': 42}})
+        self.assertEqual(dd.key1, 'value1')
+        self.assertEqual(dd.nested.inner, 42)
+        self.assertIsNone(dd.non_existent)
+
+    async def testDotNotationAssignment(self):
+        """
+        Test that dictionary values can be set using dot notation.
+        Verifies that new keys can be added and existing keys can be updated using dot notation,
+        with automatic conversion of nested dictionaries to DotDict.
+        """
+        dd = DotDict()
+        dd.key1 = 'value1'
+        dd.nested = {'inner': 42}
+
+        self.assertEqual(dd['key1'], 'value1')
+        self.assertIsInstance(dd.nested, DotDict)
+        self.assertEqual(dd.nested.inner, 42)
+
+    async def testDotNotationDeletion(self):
+        """
+        Test that dictionary keys can be deleted using dot notation.
+        Verifies that existing keys can be deleted and appropriate AttributeError is raised
+        when trying to delete non-existent keys.
+        """
+        dd = DotDict({'key1': 'value1', 'key2': 'value2'})
+        del dd.key1
+        self.assertNotIn('key1', dd)
+
+        with self.assertRaises(AttributeError):
+            del dd.non_existent
+
+    async def testGetMethod(self):
+        """
+        Test that the get method works with automatic DotDict conversion.
+        Verifies that the get method returns the correct value or default,
+        and converts nested dictionaries to DotDict instances.
+        """
+        dd = DotDict({'key1': 'value1', 'nested': {'inner': 42}})
+
+        self.assertEqual(dd.get('key1'), 'value1')
+        self.assertEqual(dd.get('non_existent', 'default'), 'default')
+        self.assertIsInstance(dd.get('nested'), DotDict)
+        self.assertEqual(dd.get('nested').inner, 42)
+
+    async def testExportMethod(self):
+        """
+        Test that the export method converts to regular dictionary recursively.
+        Verifies that all nested DotDict instances are converted back to regular dicts.
+        """
+        dd = DotDict({
+            'key1': 'value1',
+            'nested': DotDict({
+                'inner': 42,
+                'deep': DotDict({'a': 1})
+            })
+        })
+
+        exported = dd.export()
+        self.assertIsInstance(exported, dict)
+        self.assertIsInstance(exported['nested'], dict)
+        self.assertIsInstance(exported['nested']['deep'], dict)
+        self.assertEqual(exported['nested']['inner'], 42)
+
+    async def testCopyMethod(self):
+        """
+        Test that the copy method creates a deep copy with DotDict conversion.
+        Verifies that the copy is independent of the original and maintains DotDict structure.
+        """
+        original = DotDict({
+            'key1': 'value1',
+            'nested': {'inner': 42}
+        })
+
+        copied = original.copy()
+        copied.key1 = 'modified'
+        copied.nested.inner = 100
+
+        self.assertEqual(original.key1, 'value1')
+        self.assertEqual(original.nested.inner, 42)
+        self.assertEqual(copied.key1, 'modified')
+        self.assertEqual(copied.nested.inner, 100)
+        self.assertIsInstance(copied.nested, DotDict)
+
+    async def testNestedDictConversion(self):
+        """
+        Test that nested dictionaries are automatically converted to DotDict.
+        Verifies that nested dicts are converted both during initialization and assignment.
+        """
+        dd = DotDict({
+            'level1': {
+                'level2': {
+                    'value': 42
+                }
+            }
+        })
+
+        self.assertIsInstance(dd.level1, DotDict)
+        self.assertIsInstance(dd.level1.level2, DotDict)
+        self.assertEqual(dd.level1.level2.value, 42)
+
+        # Test dynamic assignment
+        dd.new_nested = {'a': {'b': 1}}
+        self.assertIsInstance(dd.new_nested, DotDict)
+        self.assertIsInstance(dd.new_nested.a, DotDict)
+
+    async def testReprMethod(self):
+        """
+        Test that the string representation correctly identifies as DotDict.
+        Verifies that the __repr__ method includes the DotDict prefix.
+        """
+        dd = DotDict({'key': 'value'})
+        self.assertTrue(repr(dd).startswith('DotDict({'))
+        self.assertTrue(repr(dd).endswith('})'))
+        self.assertIn("'key': 'value'", repr(dd))

tests/testing/test_testing_result.py

@@ -0,0 +1,92 @@
+
+from orionis.unittesting import TestCase, TestResult, TestStatus
+
+class TestTestResult(TestCase):
+    """
+    Test cases for the TestResult dataclass.
+    """
+
+    async def testDefaultValues(self):
+        """
+        Test that TestResult initializes with correct default values for optional fields.
+
+        Verifies that optional fields are None when not provided during initialization.
+        """
+        result = TestResult(
+            id=1,
+            name="Sample Test",
+            status=TestStatus.PASSED,
+            execution_time=0.5
+        )
+        self.assertIsNone(result.error_message)
+        self.assertIsNone(result.traceback)
+        self.assertIsNone(result.class_name)
+        self.assertIsNone(result.method)
+        self.assertIsNone(result.module)
+        self.assertIsNone(result.file_path)
+
+    async def testRequiredFields(self):
+        """
+        Test that TestResult requires all non-optional fields during initialization.
+
+        Ensures that missing any required field raises a TypeError.
+        """
+        with self.assertRaises(TypeError):
+            TestResult()  # Missing all required fields
+
+        with self.assertRaises(TypeError):
+            # Missing id
+            TestResult(
+                name="Sample Test",
+                status=TestStatus.PASSED,
+                execution_time=0.5
+            )
+
+    async def testImmutable(self):
+        """
+        Test that TestResult instances are immutable (frozen dataclass).
+
+        Verifies that attribute modification after creation raises a FrozenInstanceError.
+        """
+        result = TestResult(
+            id=1,
+            name="Sample Test",
+            status=TestStatus.PASSED,
+            execution_time=0.5
+        )
+        with self.assertRaises(Exception):
+            result.name = "Modified Name"
+
+    async def testStatusValues(self):
+        """
+        Test that TestResult correctly handles all possible TestStatus values.
+
+        Verifies that all enum values can be assigned to the status field.
+        """
+        for status in TestStatus:
+            result = TestResult(
+                id=1,
+                name="Status Test",
+                status=status,
+                execution_time=0.1
+            )
+            self.assertEqual(result.status, status)
+
+    async def testErrorFields(self):
+        """
+        Test that error-related fields are properly stored when provided.
+
+        Verifies that error_message and traceback are stored correctly when provided.
+        """
+        error_msg = "Test failed"
+        traceback = "Traceback info"
+        result = TestResult(
+            id=1,
+            name="Failing Test",
+            status=TestStatus.FAILED,
+            execution_time=0.2,
+            error_message=error_msg,
+            traceback=traceback
+        )
+        self.assertEqual(result.error_message, error_msg)
+        self.assertEqual(result.traceback, traceback)

tests/testing/test_testing_unit.py

@@ -0,0 +1,138 @@
+from orionis.luminate.test.cases.test_case import TestCase
+from orionis.unittesting import UnitTest, ExecutionMode, UnittestTestLoader, UnittestTestSuite, unittest_mock_patch, UnittestMagicMock, UnittestTestResult
+
+class TestUnitTest(TestCase):
+    """
+    Test cases for the UnitTest class which handles test discovery and execution.
+    """
+
+    async def testDefaultConfiguration(self):
+        """
+        Test that UnitTest initializes with correct default configuration values.
+        Verifies that all default attributes are set as expected upon initialization.
+        """
+        unit_test = UnitTest()
+        self.assertEqual(unit_test.verbosity, 2)
+        self.assertEqual(unit_test.execution_mode, ExecutionMode.SEQUENTIAL.value)
+        self.assertEqual(unit_test.max_workers, 4)
+        self.assertFalse(unit_test.fail_fast)
+        self.assertTrue(unit_test.print_result)
+        self.assertIsInstance(unit_test.loader, UnittestTestLoader)
+        self.assertIsInstance(unit_test.suite, UnittestTestSuite)
+
+    async def testConfigureMethod(self):
+        """
+        Test that configure method properly updates configuration values.
+        Verifies that all configuration parameters can be updated through the configure method.
+        """
+        unit_test = UnitTest()
+        configured = unit_test.configure(
+            verbosity=1,
+            execution_mode=ExecutionMode.PARALLEL,
+            max_workers=8,
+            fail_fast=True,
+            print_result=False,
+            throw_exception=True
+        )
+
+        self.assertEqual(unit_test.verbosity, 1)
+        self.assertEqual(unit_test.execution_mode, ExecutionMode.PARALLEL.value)
+        self.assertEqual(unit_test.max_workers, 8)
+        self.assertTrue(unit_test.fail_fast)
+        self.assertFalse(unit_test.print_result)
+        self.assertTrue(unit_test.throw_exception)
+        self.assertEqual(configured, unit_test)
+
+    async def testDiscoverTestsInModule(self):
+        """
+        Test that discoverTestsInModule correctly loads tests from a module.
+        Verifies that tests can be discovered from a module and added to the test suite.
+        """
+        unit_test = UnitTest()
+        with unittest_mock_patch.object(unit_test.loader, 'loadTestsFromName') as mock_load:
+            mock_load.return_value = UnittestTestSuite()
+            result = unit_test.discoverTestsInModule('test_module')
+
+            mock_load.assert_called_once_with('test_module')
+            self.assertEqual(result, unit_test)
+            self.assertEqual(len(unit_test.suite._tests), 0)
+
+    async def testFlattenTestSuite(self):
+        """
+        Test that _flattenTestSuite correctly flattens nested test suites.
+
+        Verifies that both simple and nested test suites are properly flattened.
+        """
+        unit_test = UnitTest()
+        test_case1 = UnittestMagicMock()
+        test_case2 = UnittestMagicMock()
+
+        nested_suite = UnittestTestSuite()
+        nested_suite.addTest(test_case1)
+        nested_suite.addTest(test_case2)
+
+        main_suite = UnittestTestSuite()
+        main_suite.addTest(nested_suite)
+
+        flattened = unit_test._flattenTestSuite(main_suite)
+        self.assertEqual(len(flattened), 2)
+        self.assertIn(test_case1, flattened)
+        self.assertIn(test_case2, flattened)
+
+    async def testMergeTestResults(self):
+        """
+        Test that _mergeTestResults correctly combines test results.
+
+        Verifies that test counts, failures, and errors are properly merged.
+        """
+        unit_test = UnitTest()
+        combined = UnittestTestResult()
+        individual = UnittestTestResult()
+
+        individual.testsRun = 2
+        individual.failures = [('test1', 'failure')]
+        individual.errors = [('test2', 'error')]
+
+        unit_test._mergeTestResults(combined, individual)
+        self.assertEqual(combined.testsRun, 2)
+        self.assertEqual(len(combined.failures), 1)
+        self.assertEqual(len(combined.errors), 1)
+
+    async def testClearTests(self):
+        """
+        Test that clearTests method resets the test suite.
+        Verifies that the test suite is emptied when clearTests is called.
+        """
+        unit_test = UnitTest()
+        mock_test = UnittestMagicMock()
+        unit_test.suite.addTest(mock_test)
+
+        unit_test.clearTests()
+        self.assertEqual(len(unit_test.suite._tests), 0)
+
+    async def testGetTestNames(self):
+        """
+        Test that getTestNames returns correct test identifiers.
+        Verifies that test names are properly extracted from the test suite.
+        """
+        unit_test = UnitTest()
+        mock_test = UnittestMagicMock()
+        mock_test.id.return_value = 'test_id'
+        unit_test.suite.addTest(mock_test)
+
+        names = unit_test.getTestNames()
+        self.assertEqual(names, ['test_id'])
+
+    async def testGetTestCount(self):
+        """
+        Test that getTestCount returns the correct number of tests.
+        Verifies that the count matches the number of tests in the suite.
+        """
+        unit_test = UnitTest()
+        mock_test1 = UnittestMagicMock()
+        mock_test2 = UnittestMagicMock()
+        unit_test.suite.addTest(mock_test1)
+        unit_test.suite.addTest(mock_test2)
+
+        count = unit_test.getTestCount()
+        self.assertEqual(count, 2)

orionis/luminate/config/app/__init__.py

@@ -1,10 +0,0 @@
-from orionis.luminate.config.app.entities.app import App
-
-__all__ = [
-    "app"
-]
-__author__ = "Raúl Mauricio Uñate Castro"
-__description__ = (
-    "This dataclass defines the main configuration of the Orionis Framework application. "
-    "Its design aims to provide a flexible and adaptable structure for Python projects."
-)

orionis/luminate/config/auth/__init__.py

@@ -1,7 +0,0 @@
-from orionis.luminate.config.auth.entities.auth import Auth
-
-__all__ = [
-    "Auth",
-]
-__author__ = "Raul Mauricio Uñate Castro"
-__description__ = "This module exports a dataclass that contains the required properties to configure an Orionis application"

orionis/luminate/config/cache/__init__.py

@@ -1,9 +0,0 @@
-from orionis.luminate.config.cache.entities.cache import Cache
-
-__all__ = [
-    "Cache",
-]
-__author__ = "Raúl Mauricio Uñate Castro"
-__description__ = (
-    "This dataclass defines the structure of the cache configuration. "
-)

orionis/luminate/config/cache/entities/cache.py

@@ -1,58 +0,0 @@
-from dataclasses import dataclass, field
-from orionis.luminate.config.cache.entities.file import File
-from orionis.luminate.config.cache.entities.stores import Stores
-from orionis.luminate.config.cache.enums.drivers import Drivers
-from orionis.luminate.config.exceptions.integrity_exception import OrionisIntegrityException
-from orionis.luminate.services.environment import Env
-
-@dataclass
-class Cache:
-    """
-    Represents the cache configuration for the application.
-    Attributes:
-        default (Drivers | str): The default cache storage type. Can be a member of the Drivers enum or a string
-            (e.g., 'memory', 'file'). Defaults to the value of the 'CACHE_STORE' environment variable or Drivers.MEMORY.
-        stores (Stores): The configuration for available cache stores. Defaults to a Stores instance with a file store
-            at the path specified by the 'CACHE_PATH' environment variable or "storage/framework/cache/data".
-    Methods:
-        __post_init__():
-            - Validates that 'default' is either a Drivers enum member or a string.
-            - Converts 'default' from string to Drivers enum if necessary.
-            - Validates that 'stores' is an instance of Stores.
-    """
-
-    default: Drivers | str = field(
-        default=Env.get("CACHE_STORE", Drivers.MEMORY),
-        metadata={
-            "description": "The default cache storage type (e.g., 'memory' or 'file').",
-            "type": Drivers,
-        },
-    )
-
-    stores: Stores = field(
-        default_factory=lambda: Stores(
-            file=File(
-                path=Env.get("CACHE_PATH", "storage/framework/cache/data")
-            )
-        )
-    )
-
-    def __post_init__(self):
-        """
-        Post-initialization processing to ensure the cache configuration is set correctly.
-        """
-        # Ensure the default cache store is valid
-        if not isinstance(self.default, (Drivers, str)):
-            raise OrionisIntegrityException("The default cache store must be an instance of Drivers or a string.")
-
-        # Convert string to Drivers enum if applicable
-        if isinstance(self.default, str):
-            value = self.default.upper().strip()
-            if value not in Drivers._member_names_:
-                raise OrionisIntegrityException(f"Invalid cache driver: {self.default}. Must be one of {Drivers._member_names_}.")
-            else:
-                self.default = getattr(Drivers, value)
-
-        # Ensure the stores attribute is an instance of Stores
-        if not isinstance(self.stores, Stores):
-            raise OrionisIntegrityException("The stores must be an instance of Stores.")

orionis/luminate/config/cache/entities/file.py

@@ -1,29 +0,0 @@
-from dataclasses import dataclass, field
-from orionis.luminate.services.paths import Resolver
-
-@dataclass
-class File:
-    """
-    Represents a file storage path.
-
-    Attributes
-    ----------
-    path : str
-        The file path used for caching.
-    """
-    path: str = field(
-        default_factory=lambda:Resolver().relativePath('storage/framework/cache/data').toString(),
-        metadata={
-            "description": "The file path used for caching.",
-            "type": str,
-        },
-    )
-
-    def __post_init__(self):
-        """
-        Post-initialization processing to ensure the path is set correctly.
-        """
-        if not self.path:
-            raise ValueError("The file path cannot be empty.")
-        if not isinstance(self.path, str):
-            raise TypeError("The file path must be a string.")

orionis/luminate/config/cache/entities/stores.py

@@ -1,35 +0,0 @@
-from dataclasses import dataclass, field
-from typing import Any
-from orionis.luminate.config.cache.entities.file import File
-from orionis.luminate.services.paths.resolver import Resolver
-
-@dataclass
-class Stores:
-    """
-    Represents a collection of cache storage backends for the application.
-    Attributes:
-        file (File): An instance of `File` representing file-based cache storage.
-            The default path is set to 'storage/framework/cache/data', resolved
-            relative to the application's root directory.
-    Methods:
-        __post_init__():
-            Ensures that the 'file' attribute is properly initialized as an instance of `File`.
-            Raises a TypeError if the type check fails.
-    """
-
-    file: File = field(
-        default_factory=lambda: File(
-            path=Resolver().relativePath('storage/framework/cache/data').toString()
-        ),
-        metadata={
-            "description": "An instance of `File` representing file-based cache storage.",
-            "type": File,
-        },
-    )
-
-    def __post_init__(self):
-        """
-        Post-initialization processing to ensure the stores are set correctly.
-        """
-        if not isinstance(self.file, File):
-            raise TypeError("The file store must be an instance of File.")