orionis 0.431.0__py3-none-any.whl → 0.434.0__py3-none-any.whl

tests/metadata/test_metadata_package.py

@@ -1,19 +1,19 @@
 from orionis.test.cases.asynchronous import AsyncTestCase
 from unittest.mock import patch
 
-class TestPypiPackageApi(AsyncTestCase):
+class TestPypiOrionisPackage(AsyncTestCase):
 
-    @patch("orionis.metadata.package.PypiPackageApi")
-    async def testGetName(self, MockPypiPackageApi):
+    @patch("orionis.metadata.package.PypiOrionisPackage")
+    async def testGetName(self, MockPypiOrionisPackage):
         """
-        Tests the `getName` method of the `PypiPackageApi` class.
+        Tests the `getName` method of the `PypiOrionisPackage` class.
 
         This test verifies that the mocked `getName` method returns the expected package name.
 
         Parameters
         ----------
-        MockPypiPackageApi : MagicMock
-            Mocked `PypiPackageApi` class.
+        MockPypiOrionisPackage : MagicMock
+            Mocked `PypiOrionisPackage` class.
 
         Returns
         -------
@@ -22,7 +22,7 @@ class TestPypiPackageApi(AsyncTestCase):
         """
 
         # Get the mocked API instance
-        api = MockPypiPackageApi.return_value
+        api = MockPypiOrionisPackage.return_value
 
         # Set the return value for getName
         api.getName.return_value = "orionis"
@@ -30,17 +30,17 @@ class TestPypiPackageApi(AsyncTestCase):
         # Assert that getName returns the expected value
         self.assertEqual(api.getName(), "orionis")
 
-    @patch("orionis.metadata.package.PypiPackageApi")
-    async def testGetAuthor(self, MockPypiPackageApi):
+    @patch("orionis.metadata.package.PypiOrionisPackage")
+    async def testGetAuthor(self, MockPypiOrionisPackage):
         """
-        Tests the `getAuthor` method of the `PypiPackageApi` class.
+        Tests the `getAuthor` method of the `PypiOrionisPackage` class.
 
         This test checks that the mocked `getAuthor` method returns the correct author name.
 
         Parameters
         ----------
-        MockPypiPackageApi : MagicMock
-            Mocked `PypiPackageApi` class.
+        MockPypiOrionisPackage : MagicMock
+            Mocked `PypiOrionisPackage` class.
 
         Returns
         -------
@@ -49,7 +49,7 @@ class TestPypiPackageApi(AsyncTestCase):
         """
 
         # Get the mocked API instance
-        api = MockPypiPackageApi.return_value
+        api = MockPypiOrionisPackage.return_value
 
         # Set the return value for getAuthor
         api.getAuthor.return_value = "Raul Mauricio Uñate Castro"
@@ -57,17 +57,17 @@ class TestPypiPackageApi(AsyncTestCase):
         # Assert that getAuthor returns the expected value
         self.assertEqual(api.getAuthor(), "Raul Mauricio Uñate Castro")
 
-    @patch("orionis.metadata.package.PypiPackageApi")
-    async def testGetAuthorEmail(self, MockPypiPackageApi):
+    @patch("orionis.metadata.package.PypiOrionisPackage")
+    async def testGetAuthorEmail(self, MockPypiOrionisPackage):
         """
-        Tests the `getAuthorEmail` method of the `PypiPackageApi` class.
+        Tests the `getAuthorEmail` method of the `PypiOrionisPackage` class.
 
         This test ensures that the mocked `getAuthorEmail` method returns the correct author email address.
 
         Parameters
         ----------
-        MockPypiPackageApi : MagicMock
-            Mocked `PypiPackageApi` class.
+        MockPypiOrionisPackage : MagicMock
+            Mocked `PypiOrionisPackage` class.
 
         Returns
         -------
@@ -76,7 +76,7 @@ class TestPypiPackageApi(AsyncTestCase):
         """
 
         # Get the mocked API instance
-        api = MockPypiPackageApi.return_value
+        api = MockPypiOrionisPackage.return_value
 
         # Set the return value for getAuthorEmail
         api.getAuthorEmail.return_value = "raulmauriciounate@gmail.com"
@@ -84,17 +84,17 @@ class TestPypiPackageApi(AsyncTestCase):
         # Assert that getAuthorEmail returns the expected value
         self.assertEqual(api.getAuthorEmail(), "raulmauriciounate@gmail.com")
 
-    @patch("orionis.metadata.package.PypiPackageApi")
-    async def testGetDescription(self, MockPypiPackageApi):
+    @patch("orionis.metadata.package.PypiOrionisPackage")
+    async def testGetDescription(self, MockPypiOrionisPackage):
         """
-        Tests the `getDescription` method of the `PypiPackageApi` class.
+        Tests the `getDescription` method of the `PypiOrionisPackage` class.
 
         This test verifies that the mocked `getDescription` method returns the expected package description.
 
         Parameters
         ----------
-        MockPypiPackageApi : MagicMock
-            Mocked `PypiPackageApi` class.
+        MockPypiOrionisPackage : MagicMock
+            Mocked `PypiOrionisPackage` class.
 
         Returns
         -------
@@ -103,7 +103,7 @@ class TestPypiPackageApi(AsyncTestCase):
         """
 
         # Get the mocked API instance
-        api = MockPypiPackageApi.return_value
+        api = MockPypiOrionisPackage.return_value
 
         # Set the return value for getDescription
         api.getDescription.return_value = "Orionis Framework – Elegant, Fast, and Powerful."
@@ -111,17 +111,17 @@ class TestPypiPackageApi(AsyncTestCase):
         # Assert that getDescription returns the expected value
         self.assertEqual(api.getDescription(), "Orionis Framework – Elegant, Fast, and Powerful.")
 
-    @patch("orionis.metadata.package.PypiPackageApi")
-    async def testGetPythonVersion(self, MockPypiPackageApi):
+    @patch("orionis.metadata.package.PypiOrionisPackage")
+    async def testGetPythonVersion(self, MockPypiOrionisPackage):
         """
-        Tests the `getPythonVersion` method of the `PypiPackageApi` class.
+        Tests the `getPythonVersion` method of the `PypiOrionisPackage` class.
 
         This test checks that the mocked `getPythonVersion` method returns the correct Python version requirement.
 
         Parameters
         ----------
-        MockPypiPackageApi : MagicMock
-            Mocked `PypiPackageApi` class.
+        MockPypiOrionisPackage : MagicMock
+            Mocked `PypiOrionisPackage` class.
 
         Returns
         -------
@@ -130,7 +130,7 @@ class TestPypiPackageApi(AsyncTestCase):
         """
 
         # Get the mocked API instance
-        api = MockPypiPackageApi.return_value
+        api = MockPypiOrionisPackage.return_value
 
         # Set the return value for getPythonVersion
         api.getPythonVersion.return_value = ">=3.12"

tests/support/entities/mock_dataclass.py

@@ -10,7 +10,18 @@ class Color(Enum):
 @dataclass
 class ExampleEntity(BaseEntity):
     """
-    Example entity representing a data structure with id, name, color, and tags.
+    Data structure representing an example entity with an identifier, name, color, and tags.
+
+    Parameters
+    ----------
+    id : int, optional
+        Unique identifier for the entity. Default is 0.
+    name : str, optional
+        Name of the entity. Default is 'default'.
+    color : Color, optional
+        Color associated with the entity. Default is Color.RED.
+    tags : list, optional
+        List of tags associated with the entity. Default is an empty list.
 
     Attributes
     ----------
@@ -22,13 +33,8 @@ class ExampleEntity(BaseEntity):
         Color associated with the entity.
     tags : list
         List of tags associated with the entity.
-
-    Returns
-    -------
-    ExampleEntity
-        An instance of ExampleEntity with specified attributes.
     """
-    id: int = 0  # Default id is 0
-    name: str = "default"  # Default name is 'default'
-    color: Color = Color.RED  # Default color is RED
-    tags: list = field(default_factory=list, metadata={"default": ["tag1", "tag2"]})  # Default tags list
+    id: int = 0                                                                         # Default id is 0
+    name: str = "default"                                                               # Default name is 'default'
+    color: Color = Color.RED                                                            # Default color is RED
+    tags: list = field(default_factory=list, metadata={"default": ["tag1", "tag2"]})    # Default tags list

tests/support/entities/test_base.py

@@ -5,32 +5,27 @@ class TestBaseEntity(AsyncTestCase):
 
     async def asyncSetUp(self):
         """
-        Set up the test case asynchronously by initializing an ExampleEntity instance.
+        Asynchronously initializes the test environment before each test.
 
-        This method is called before each test coroutine to prepare the test environment.
-        It creates an ExampleEntity with predefined attributes.
+        Initializes an ExampleEntity instance with predefined attributes and assigns it to self.entity.
 
         Returns
         -------
         None
-            This method does not return any value.
         """
         # Create an ExampleEntity instance for use in tests
         self.entity = ExampleEntity(id=42, name="test", color=Color.GREEN, tags=["a", "b"])
 
     async def testToDict(self):
         """
-        Test the toDict method of ExampleEntity.
+        Tests the toDict method of ExampleEntity.
 
-        Verifies that the toDict method returns a dictionary representation of the entity
-        with correct field values.
+        Verifies that toDict returns a dictionary with correct field values for the entity.
 
         Returns
         -------
         None
-            This method does not return any value.
         """
-
         # Convert entity to dictionary
         result = self.entity.toDict()
         self.assertIsInstance(result, dict)
@@ -43,17 +38,14 @@ class TestBaseEntity(AsyncTestCase):
 
     async def testGetFields(self):
         """
-        Test the getFields method of ExampleEntity.
+        Tests the getFields method of ExampleEntity.
 
-        Ensures that getFields returns a list of field information dictionaries,
-        each containing field name, types, default value, and metadata.
+        Ensures getFields returns a list of dictionaries, each containing field name, types, default value, and metadata.
 
         Returns
         -------
         None
-            This method does not return any value.
         """
-
         # Retrieve field information from entity
         fields_info = self.entity.getFields()
         self.assertIsInstance(fields_info, list)

tests/support/patterns/singleton/test_patterns_singleton.py

@@ -5,22 +5,21 @@ class TestPatternsSingleton(AsyncTestCase):
 
     async def testSingleton(self):
         """
-        Tests the behavior of the Singleton metaclass.
+        Test the Singleton metaclass to ensure only one instance is created.
 
-        Validates that a class using the Singleton metaclass only ever creates a single instance,
-        regardless of how many times it is instantiated. Also checks that the initial state of the
-        singleton instance remains unchanged after subsequent instantiations.
+        This test verifies that a class using the Singleton metaclass will always return
+        the same instance, regardless of how many times it is instantiated. It also checks
+        that the initial state of the singleton instance does not change after subsequent
+        instantiations with different arguments.
 
         Parameters
         ----------
         self : TestPatternsSingleton
-            The test case instance.
+            Instance of the test case.
 
         Returns
         -------
         None
-            This method does not return any value. Assertions are used to verify singleton behavior.
-
         """
         # Define a class using the Singleton metaclass
         class SingletonClass(metaclass=Singleton):
@@ -37,4 +36,4 @@ class TestPatternsSingleton(AsyncTestCase):
         self.assertIs(instance1, instance2)
 
         # Assert that the value remains as set by the first instantiation
-        self.assertEqual(instance1.value, 1)
+        self.assertEqual(instance1.value, 1)

tests/support/standard/test_services_std.py

@@ -6,13 +6,21 @@ class TestSupportStd(AsyncTestCase):
 
     async def testInitializationAndAccess(self):
         """
-        Test the initialization of StdClass and access to its attributes.
+        Test initialization and attribute access of StdClass.
+
+        Parameters
+        ----------
+        self : TestSupportStd
+            The test case instance.
+
+        Returns
+        -------
+        None
 
         Notes
         -----
-        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.
+        Verifies that StdClass can be instantiated with specific attributes and
+        that those attributes are accessible after initialization.
         """
         obj = StdClass(
             first_name='Raul',
@@ -24,12 +32,20 @@ class TestSupportStd(AsyncTestCase):
 
     async def testToDictReturnsCorrectData(self):
         """
-        Test that the toDict method of StdClass returns a dictionary with the correct data.
+        Test that StdClass.toDict returns a dictionary with correct attribute data.
+
+        Parameters
+        ----------
+        self : TestSupportStd
+            The test case instance.
+
+        Returns
+        -------
+        None
 
         Notes
         -----
-        Creates an instance of StdClass with specific attributes and verifies
-        that calling toDict() returns a dictionary containing those attributes and their values.
+        Ensures that toDict() returns a dictionary containing all attributes and their values.
         """
         obj = StdClass(a=1, b=2)
         expected = {'a': 1, 'b': 2}
@@ -37,12 +53,20 @@ class TestSupportStd(AsyncTestCase):
 
     async def testUpdateAttributes(self):
         """
-        Test that the `update` method of `StdClass` correctly sets multiple attributes.
+        Test updating multiple attributes using StdClass.update.
+
+        Parameters
+        ----------
+        self : TestSupportStd
+            The test case instance.
+
+        Returns
+        -------
+        None
 
         Notes
         -----
-        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.
+        Verifies that update() sets multiple attributes as expected.
         """
         obj = StdClass()
         obj.update(foo='bar', number=42)
@@ -51,12 +75,21 @@ class TestSupportStd(AsyncTestCase):
 
     async def testUpdateReservedAttributeRaisesError(self):
         """
-        Test that updating a reserved attribute (such as '__init__') on a StdClass instance
-        raises a ValueError exception.
+        Test that updating a reserved attribute raises OrionisStdValueException.
+
+        Parameters
+        ----------
+        self : TestSupportStd
+            The test case instance.
+
+        Returns
+        -------
+        None
 
         Notes
         -----
-        Ensures that updating a reserved attribute raises an OrionisStdValueException.
+        Ensures that attempting to update a reserved attribute (e.g., '__init__')
+        raises the appropriate exception.
         """
         obj = StdClass()
         with self.assertRaises(OrionisStdValueException):
@@ -64,13 +97,21 @@ class TestSupportStd(AsyncTestCase):
 
     async def testUpdateConflictingAttributeRaisesError(self):
         """
-        Test that updating an object with a conflicting attribute name ('toDict') raises a ValueError.
+        Test that updating with a conflicting attribute name raises OrionisStdValueException.
+
+        Parameters
+        ----------
+        self : TestSupportStd
+            The test case instance.
+
+        Returns
+        -------
+        None
 
         Notes
         -----
-        Ensures that attempting to update the StdClass instance with a keyword argument
-        that conflicts with an existing method or reserved attribute ('toDict') correctly triggers
-        an OrionisStdValueException, enforcing attribute safety.
+        Ensures that updating with a name that conflicts with an existing method
+        or reserved attribute (e.g., 'toDict') raises an exception.
         """
         obj = StdClass()
         with self.assertRaises(OrionisStdValueException):
@@ -78,11 +119,20 @@ class TestSupportStd(AsyncTestCase):
 
     async def testRemoveExistingAttributes(self):
         """
-        Test that the `remove` method of `StdClass` successfully removes an existing attribute.
+        Test removal of an existing attribute using StdClass.remove.
+
+        Parameters
+        ----------
+        self : TestSupportStd
+            The test case instance.
+
+        Returns
+        -------
+        None
 
         Notes
         -----
-        Removes attribute 'x' from the object and checks that 'y' remains.
+        Removes an attribute and checks that it no longer exists, while others remain.
         """
         obj = StdClass(x=1, y=2)
         obj.remove('x')
@@ -91,12 +141,20 @@ class TestSupportStd(AsyncTestCase):
 
     async def testRemoveNonExistingAttributeRaisesError(self):
         """
-        Test that attempting to remove a non-existing attribute from a StdClass instance raises an AttributeError.
+        Test that removing a non-existing attribute raises AttributeError.
+
+        Parameters
+        ----------
+        self : TestSupportStd
+            The test case instance.
+
+        Returns
+        -------
+        None
 
         Notes
         -----
-        Verifies that the `remove` method of `StdClass` raises an AttributeError
-        when called with the name of an attribute that does not exist on the object.
+        Ensures that attempting to remove an attribute that does not exist raises an error.
         """
         obj = StdClass()
         with self.assertRaises(AttributeError):
@@ -104,12 +162,20 @@ class TestSupportStd(AsyncTestCase):
 
     async def testFromDictCreatesEquivalentInstance(self):
         """
-        Test that StdClass.from_dict creates an instance equivalent to the original data.
+        Test creation of StdClass instance from a dictionary using fromDict.
+
+        Parameters
+        ----------
+        self : TestSupportStd
+            The test case instance.
+
+        Returns
+        -------
+        None
 
         Notes
         -----
-        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.
+        Verifies that fromDict creates an instance whose attributes match the input dictionary.
         """
         data = {'a': 10, 'b': 20}
         obj = StdClass.fromDict(data)
@@ -117,12 +183,20 @@ class TestSupportStd(AsyncTestCase):
 
     async def testReprAndStr(self):
         """
-        Test that the __repr__ and __str__ methods of StdClass include the class name and the value of 'x' respectively.
+        Test __repr__ and __str__ methods of StdClass for expected output.
+
+        Parameters
+        ----------
+        self : TestSupportStd
+            The test case instance.
+
+        Returns
+        -------
+        None
 
         Notes
         -----
-        - Checks that repr(obj) contains the class name 'StdClass'.
-        - Checks that str(obj) contains the key-value pair "'x': 5".
+        Checks that __repr__ includes the class name and __str__ includes attribute key-value pairs.
         """
         obj = StdClass(x=5)
         self.assertIn("StdClass", repr(obj))
@@ -130,18 +204,20 @@ class TestSupportStd(AsyncTestCase):
 
     async def testEquality(self):
         """
-        Test the equality and inequality operations for StdClass instances.
+        Test equality and inequality operations for StdClass instances.
 
-        Notes
-        -----
-        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'.
+        Parameters
+        ----------
+        self : TestSupportStd
+            The test case instance.
 
-        Asserts
+        Returns
         -------
-        - 'a' and 'b' are equal.
-        - 'a' and 'c' are not equal.
+        None
+
+        Notes
+        -----
+        Verifies that instances with identical attributes are equal and those with different attributes are not.
         """
         a = StdClass(x=1, y=2)
         b = StdClass(x=1, y=2)