orionis 0.436.0__py3-none-any.whl → 0.438.0__py3-none-any.whl

tests/container/mocks/mock_simple_classes.py

@@ -2,31 +2,97 @@ from abc import ABC, abstractmethod
 
 class ICar(ABC):
     """
-    ICar is an interface that defines the structure for car objects.
-    It includes methods for starting and stopping the car.
+    Interface for car objects.
+
+    Defines the required methods for car objects, including starting and stopping the car.
+
+    Methods
+    -------
+    start() -> str
+        Start the car and return a message indicating the car has started.
+    stop() -> str
+        Stop the car and return a message indicating the car has stopped.
     """
 
     @abstractmethod
     def start(self) -> str:
         """
-        Starts the car and returns a message indicating the car has started.
+        Start the car.
+
+        Returns
+        -------
+        str
+            Message indicating the car has started.
         """
         pass
 
     @abstractmethod
     def stop(self) -> str:
         """
-        Stops the car and returns a message indicating the car has stopped.
+        Stop the car.
+
+        Returns
+        -------
+        str
+            Message indicating the car has stopped.
         """
         pass
 
 class Car(ICar):
+    """
+    Concrete implementation of the ICar interface.
+
+    Parameters
+    ----------
+    brand : str, optional
+        The brand of the car (default is 'a').
+    model : str, optional
+        The model of the car (default is 'b').
+
+    Attributes
+    ----------
+    brand : str
+        The brand of the car.
+    model : str
+        The model of the car.
+    """
+
     def __init__(self, brand: str = 'a', model: str = 'b'):
-        self.brand = brand
-        self.model = model
+        """
+        Initialize a new Car instance with the specified brand and model.
+
+        Parameters
+        ----------
+        brand : str, optional
+            The brand of the car. Default is 'a'.
+        model : str, optional
+            The model of the car. Default is 'b'.
+
+        Notes
+        -----
+        This constructor sets the brand and model attributes for the Car object.
+        """
+        self.brand = brand  # Set the brand of the car
+        self.model = model  # Set the model of the car
 
     def start(self):
+        """
+        Start the car.
+
+        Returns
+        -------
+        str
+            Message indicating the car is starting.
+        """
         return f"{self.brand} {self.model} is starting."
 
     def stop(self):
+        """
+        Stop the car.
+
+        Returns
+        -------
+        str
+            Message indicating the car is stopping.
+        """
         return f"{self.brand} {self.model} is stopping."

tests/container/validators/test_is_valid_alias.py

@@ -80,7 +80,7 @@ class TestIsValidAlias(AsyncTestCase):
             This method does not return any value. It passes if the expected exception and message are raised.
         """
         invalid_aliases = [
-            "invalid alias",  # space
+            "invalid alias",   # space
             "invalid\talias",  # tab
             "invalid\nalias",  # newline
             "invalid@alias",   # special character

tests/foundation/config/database/test_foundation_config_database.py

@@ -5,23 +5,24 @@ from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestFoundationConfigDatabase(AsyncTestCase):
     """
-    Test cases for the Database configuration class.
+    Unit tests for the Database configuration class.
 
-    This class contains unit tests for the `Database` configuration class,
-    ensuring correct default values, validation, dictionary representation,
-    custom values, hashability, and keyword-only initialization.
-
-    Attributes
-    ----------
-    None
+    This class provides asynchronous test cases to verify the behavior,
+    validation, and integrity of the `Database` configuration class,
+    including default values, attribute validation, dictionary conversion,
+    custom values, hashability, and keyword-only initialization enforcement.
     """
 
     async def testDefaultValues(self):
         """
-        Test creation of Database instance with default values.
+        Test that a Database instance initializes with correct default values.
+
+        Ensures that the `default` attribute is set to 'sqlite' and the
+        `connections` attribute is an instance of Connections.
 
-        Ensures that the default connection is set to 'sqlite' and the
-        connections attribute is properly initialized as a Connections instance.
+        Returns
+        -------
+        None
         """
         db = Database()
         self.assertEqual(db.default, 'sqlite')
@@ -29,11 +30,15 @@ class TestFoundationConfigDatabase(AsyncTestCase):
 
     async def testDefaultConnectionValidation(self):
         """
-        Validate the default connection attribute.
+        Validate the `default` connection attribute for allowed values.
 
-        Checks that only valid connection types are accepted as default.
-        Also verifies that invalid, empty, or non-string defaults raise
+        Checks that only valid connection types are accepted for the `default`
+        attribute. Verifies that invalid, empty, or non-string values raise
         OrionisIntegrityException.
+
+        Returns
+        -------
+        None
         """
         # Test valid connection types
         valid_connections = ['sqlite', 'mysql', 'pgsql', 'oracle']
@@ -57,11 +62,15 @@ class TestFoundationConfigDatabase(AsyncTestCase):
 
     async def testConnectionsValidation(self):
         """
-        Validate the connections attribute.
+        Validate the `connections` attribute for correct type.
 
         Ensures that only instances of Connections are accepted for the
-        connections attribute. Invalid types or None should raise
+        `connections` attribute. Invalid types or None should raise
         OrionisIntegrityException.
+
+        Returns
+        -------
+        None
         """
         # Test invalid connections type
         with self.assertRaises(OrionisIntegrityException):
@@ -79,10 +88,15 @@ class TestFoundationConfigDatabase(AsyncTestCase):
 
     async def testToDictMethod(self):
         """
-        Test the toDict method of Database.
+        Test the `toDict` method for dictionary representation.
 
-        Ensures that the toDict method returns a dictionary representation
-        of the Database instance, including all attributes.
+        Ensures that the `toDict` method returns a dictionary containing
+        all attributes of the Database instance, including `default` and
+        `connections`.
+
+        Returns
+        -------
+        None
         """
         db = Database()
         db_dict = db.toDict()
@@ -92,10 +106,14 @@ class TestFoundationConfigDatabase(AsyncTestCase):
 
     async def testCustomValues(self):
         """
-        Test storage and validation of custom values.
+        Test handling and validation of custom attribute values.
+
+        Ensures that custom values for `default` and `connections` are
+        correctly stored and validated in the Database instance.
 
-        Ensures that custom configurations for default and connections
-        are correctly handled and validated.
+        Returns
+        -------
+        None
         """
         custom_connections = Connections()
         custom_db = Database(
@@ -107,10 +125,14 @@ class TestFoundationConfigDatabase(AsyncTestCase):
 
     async def testHashability(self):
         """
-        Test hashability of Database instances.
+        Test that Database instances are hashable.
 
-        Ensures that Database instances are hashable (due to unsafe_hash=True)
-        and can be used in sets and as dictionary keys.
+        Verifies that Database instances can be used in sets and as dictionary
+        keys, and that identical instances are considered equal.
+
+        Returns
+        -------
+        None
         """
         db1 = Database()
         db2 = Database()
@@ -123,10 +145,14 @@ class TestFoundationConfigDatabase(AsyncTestCase):
 
     async def testKwOnlyInitialization(self):
         """
-        Test keyword-only initialization enforcement.
+        Test enforcement of keyword-only initialization.
+
+        Ensures that Database raises TypeError when positional arguments are
+        used instead of keyword arguments during initialization.
 
-        Ensures that Database enforces keyword-only initialization and
-        raises TypeError when positional arguments are used.
+        Returns
+        -------
+        None
         """
         with self.assertRaises(TypeError):
             Database('sqlite', Connections())

tests/foundation/config/filesystems/test_foundation_config_filesystems_aws.py

@@ -4,18 +4,23 @@ from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestFoundationConfigFilesystemsAws(AsyncTestCase):
     """
-    Test cases for the S3 storage configuration class.
+    Unit tests for the S3 storage configuration entity.
 
-    This class contains unit tests for the S3 configuration entity, ensuring
-    correct default values, field validation, custom value handling, dictionary
-    conversion, hashability, and keyword-only initialization.
+    This test class validates the behavior of the S3 configuration entity, including
+    default value assignment, field validation, custom value handling, dictionary
+    conversion, hashability, and enforcement of keyword-only initialization.
     """
 
     async def testDefaultValues(self):
         """
-        Test that S3 instance is created with correct default values.
+        Validate default values of S3 configuration fields.
 
-        Verifies all default values match expected defaults from class definition.
+        Ensures that a newly created S3 instance has the expected default values
+        for all attributes as defined in the class.
+
+        Returns
+        -------
+        None
         """
         s3 = S3()
         self.assertEqual(s3.key, "")
@@ -29,9 +34,10 @@ class TestFoundationConfigFilesystemsAws(AsyncTestCase):
 
     async def testRequiredFieldValidation(self):
         """
-        Test validation of required fields.
+        Validate required field constraints for S3 configuration.
 
-        Ensures that the 'region' field must be a non-empty string.
+        Checks that the 'region' field must be a non-empty string and raises
+        OrionisIntegrityException if the constraint is violated.
 
         Raises
         ------
@@ -48,9 +54,10 @@ class TestFoundationConfigFilesystemsAws(AsyncTestCase):
 
     async def testOptionalFieldValidation(self):
         """
-        Test validation of optional fields.
+        Validate optional field types for S3 configuration.
 
-        Ensures that optional fields accept None or proper types.
+        Ensures that optional fields accept None or valid types, and raises
+        OrionisIntegrityException for invalid types.
 
         Raises
         ------
@@ -72,9 +79,10 @@ class TestFoundationConfigFilesystemsAws(AsyncTestCase):
 
     async def testBooleanFieldValidation(self):
         """
-        Test validation of boolean fields.
+        Validate boolean field types for S3 configuration.
 
-        Ensures that boolean fields only accept boolean values.
+        Ensures that boolean fields accept only boolean values and raises
+        OrionisIntegrityException for invalid types.
 
         Raises
         ------
@@ -91,10 +99,14 @@ class TestFoundationConfigFilesystemsAws(AsyncTestCase):
 
     async def testCustomValues(self):
         """
-        Test that custom values are properly stored and validated.
+        Validate assignment and storage of custom values in S3 configuration.
 
-        Ensures custom configuration values are correctly handled.
+        Ensures that custom values provided during initialization are correctly
+        stored and validated in the S3 instance.
 
+        Returns
+        -------
+        None
         """
         custom_s3 = S3(
             key="AKIAEXAMPLE",
@@ -118,14 +130,14 @@ class TestFoundationConfigFilesystemsAws(AsyncTestCase):
 
     async def testToDictMethod(self):
         """
-        Test that toDict returns proper dictionary representation.
+        Validate dictionary conversion of S3 configuration.
 
-        Ensures all attributes are correctly included in the dictionary.
+        Ensures that the toDict method returns a dictionary containing all
+        attributes of the S3 instance with correct values.
 
         Returns
         -------
-        dict
-            Dictionary representation of the S3 instance.
+        None
         """
         s3 = S3()
         s3_dict = s3.toDict()
@@ -142,9 +154,14 @@ class TestFoundationConfigFilesystemsAws(AsyncTestCase):
 
     async def testHashability(self):
         """
-        Test that S3 maintains hashability due to unsafe_hash=True.
+        Validate hashability of S3 configuration instances.
+
+        Ensures that S3 instances are hashable and can be used in sets and as
+        dictionary keys due to unsafe_hash=True.
 
-        Ensures that S3 instances can be used in sets and as dictionary keys.
+        Returns
+        -------
+        None
         """
         s3_1 = S3()
         s3_2 = S3()
@@ -158,9 +175,10 @@ class TestFoundationConfigFilesystemsAws(AsyncTestCase):
 
     async def testKwOnlyInitialization(self):
         """
-        Test that S3 enforces keyword-only initialization.
+        Validate enforcement of keyword-only initialization for S3.
 
-        Ensures that positional arguments are not allowed for initialization.
+        Ensures that S3 cannot be initialized with positional arguments and
+        raises TypeError if attempted.
 
         Raises
         ------

tests/foundation/config/filesystems/test_foundation_config_filesystems_public.py

@@ -4,41 +4,23 @@ from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestFoundationConfigFilesystemsPublic(AsyncTestCase):
     """
-    Test cases for the Public storage configuration class.
-
-    This class contains asynchronous unit tests for the `Public` storage configuration,
-    validating default values, custom values, input validation, dictionary conversion,
-    whitespace handling, hashability, and keyword-only initialization.
-
-    Methods
-    -------
-    testDefaultValues()
-        Test that Public instance is created with correct default values.
-    testCustomValues()
-        Test that custom path and url can be set during initialization.
-    testEmptyPathValidation()
-        Test that empty paths are rejected.
-    testEmptyUrlValidation()
-        Test that empty URLs are rejected.
-    testTypeValidation()
-        Test that non-string values are rejected for both attributes.
-    testToDictMethod()
-        Test that toDict returns proper dictionary representation.
-    testCustomValuesToDict()
-        Test that custom values are properly included in dictionary representation.
-    testWhitespaceHandling()
-        Test that values with whitespace are accepted but not automatically trimmed.
-    testHashability()
-        Test that Public maintains hashability due to unsafe_hash=True.
-    testKwOnlyInitialization()
-        Test that Public enforces keyword-only initialization.
+    Asynchronous unit tests for the `Public` storage configuration class.
+
+    This class validates the behavior of the `Public` storage configuration, including
+    default and custom value assignment, input validation, dictionary conversion,
+    whitespace handling, hashability, and enforcement of keyword-only initialization.
     """
 
     async def testDefaultValues(self):
         """
-        Test that Public instance is created with correct default values.
+        Test creation of a Public instance with default values.
+
+        Ensures that the default `path` and `url` attributes are set as defined
+        in the class.
 
-        Verifies both default path and url match expected values from class definition.
+        Returns
+        -------
+        None
         """
         public = Public()
         self.assertEqual(public.path, "storage/app/public")
@@ -46,9 +28,14 @@ class TestFoundationConfigFilesystemsPublic(AsyncTestCase):
 
     async def testCustomValues(self):
         """
-        Test that custom path and url can be set during initialization.
+        Test assignment of custom values to path and url.
+
+        Checks that custom `path` and `url` values are accepted and stored
+        correctly during initialization.
 
-        Verifies both attributes accept and store valid custom values.
+        Returns
+        -------
+        None
         """
         custom_path = "custom/public/path"
         custom_url = "assets"
@@ -58,27 +45,42 @@ class TestFoundationConfigFilesystemsPublic(AsyncTestCase):
 
     async def testEmptyPathValidation(self):
         """
-        Test that empty paths are rejected.
+        Test validation for empty path values.
 
-        Verifies that an empty path raises OrionisIntegrityException.
+        Verifies that providing an empty string for `path` raises
+        OrionisIntegrityException.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             Public(path="")
 
     async def testEmptyUrlValidation(self):
         """
-        Test that empty URLs are rejected.
+        Test validation for empty url values.
+
+        Verifies that providing an empty string for `url` raises
+        OrionisIntegrityException.
 
-        Verifies that an empty url raises OrionisIntegrityException.
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             Public(url="")
 
     async def testTypeValidation(self):
         """
-        Test that non-string values are rejected for both attributes.
+        Test type validation for path and url attributes.
+
+        Ensures that non-string values for `path` and `url` raise
+        OrionisIntegrityException.
 
-        Verifies that non-string values raise OrionisIntegrityException.
+        Returns
+        -------
+        None
         """
         # Test path validation
         with self.assertRaises(OrionisIntegrityException):
@@ -94,9 +96,14 @@ class TestFoundationConfigFilesystemsPublic(AsyncTestCase):
 
     async def testToDictMethod(self):
         """
-        Test that toDict returns proper dictionary representation.
+        Test the toDict method for correct dictionary output.
 
-        Verifies the returned dictionary contains both default values.
+        Ensures that the dictionary representation contains the correct
+        default values for `path` and `url`.
+
+        Returns
+        -------
+        None
         """
         public = Public()
         config_dict = public.toDict()
@@ -107,9 +114,14 @@ class TestFoundationConfigFilesystemsPublic(AsyncTestCase):
 
     async def testCustomValuesToDict(self):
         """
-        Test that custom values are properly included in dictionary representation.
+        Test dictionary output with custom values.
+
+        Ensures that the dictionary representation includes custom
+        `path` and `url` values when specified.
 
-        Verifies toDict() includes custom values when specified.
+        Returns
+        -------
+        None
         """
         custom_path = "public/assets"
         custom_url = "cdn"
@@ -121,9 +133,14 @@ class TestFoundationConfigFilesystemsPublic(AsyncTestCase):
 
     async def testWhitespaceHandling(self):
         """
-        Test that values with whitespace are accepted but not automatically trimmed.
+        Test handling of whitespace in attribute values.
+
+        Verifies that values containing whitespace are accepted and
+        not automatically trimmed.
 
-        Verifies the validation allows values containing whitespace characters.
+        Returns
+        -------
+        None
         """
         spaced_path = "  public/storage  "
         spaced_url = "  static/files  "
@@ -133,9 +150,14 @@ class TestFoundationConfigFilesystemsPublic(AsyncTestCase):
 
     async def testHashability(self):
         """
-        Test that Public maintains hashability due to unsafe_hash=True.
+        Test hashability of Public instances.
 
-        Verifies that Public instances can be used in sets and as dictionary keys.
+        Ensures that Public instances are hashable and can be used in sets
+        and as dictionary keys due to `unsafe_hash=True`.
+
+        Returns
+        -------
+        None
         """
         public1 = Public()
         public2 = Public()
@@ -149,9 +171,14 @@ class TestFoundationConfigFilesystemsPublic(AsyncTestCase):
 
     async def testKwOnlyInitialization(self):
         """
-        Test that Public enforces keyword-only initialization.
+        Test enforcement of keyword-only initialization.
+
+        Verifies that positional arguments are not allowed when initializing
+        a Public instance.
 
-        Verifies that positional arguments are not allowed for initialization.
+        Returns
+        -------
+        None
         """
         with self.assertRaises(TypeError):
             Public("storage/path", "static")