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

tests/support/wrapper/test_services_wrapper_docdict.py

@@ -5,18 +5,16 @@ class TestSupportWrapperDocDict(AsyncTestCase):
 
     async def testDotNotationAccess(self):
         """
-        Tests dot notation access for dictionary values.
+        Test dot notation access for dictionary values.
 
-        This method verifies that values in a DotDict instance can be accessed using dot notation.
-        It checks that existing keys return their corresponding values, nested dictionaries are
-        accessible via chained dot notation, and accessing a non-existent key returns None.
+        Checks that values in a DotDict instance can be accessed using dot notation,
+        including nested dictionaries via chained dot notation. Also verifies that
+        accessing a non-existent key returns None.
 
         Returns
         -------
         None
-            This is a test method and does not return a value.
         """
-
         # Create a DotDict instance with initial values
         dd = DotDict({'key1': 'value1', 'nested': {'inner': 42}})
 
@@ -31,18 +29,16 @@ class TestSupportWrapperDocDict(AsyncTestCase):
 
     async def testDotNotationAssignment(self):
         """
-        Tests assignment of dictionary values using dot notation.
+        Test assignment of dictionary values using dot notation.
 
-        This method verifies that new keys can be added and existing keys can be updated
-        using dot notation. It also checks that nested dictionaries assigned via dot notation
-        are automatically converted to DotDict instances.
+        Verifies that new keys can be added and existing keys updated using dot notation.
+        Also checks that nested dictionaries assigned via dot notation are automatically
+        converted to DotDict instances.
 
         Returns
         -------
         None
-            This is a test method and does not return a value.
         """
-
         # Create a DotDict instance and assign values using dot notation
         dd = DotDict()
 
@@ -59,17 +55,15 @@ class TestSupportWrapperDocDict(AsyncTestCase):
 
     async def testDotNotationDeletion(self):
         """
-        Tests deletion of dictionary keys using dot notation.
+        Test deletion of dictionary keys using dot notation.
 
-        This method verifies that existing keys can be deleted using dot notation.
-        It also checks that attempting to delete a non-existent key raises an AttributeError.
+        Ensures that existing keys can be deleted using dot notation and that attempting
+        to delete a non-existent key raises an AttributeError.
 
         Returns
         -------
         None
-            This is a test method and does not return a value.
         """
-
         # Create a DotDict instance and delete an existing key
         dd = DotDict({'key1': 'value1', 'key2': 'value2'})
 
@@ -83,18 +77,16 @@ class TestSupportWrapperDocDict(AsyncTestCase):
 
     async def testGetMethod(self):
         """
-        Tests the `get` method with automatic DotDict conversion.
+        Test the `get` method with automatic DotDict conversion.
 
-        This method verifies that the `get` method returns the correct value for a given key,
-        returns the provided default for missing keys, and converts nested dictionaries to
-        DotDict instances when accessed.
+        Verifies that the `get` method returns the correct value for a given key,
+        returns the provided default for missing keys, and converts nested dictionaries
+        to DotDict instances when accessed.
 
         Returns
         -------
         None
-            This is a test method and does not return a value.
         """
-
         # Create a DotDict instance and test the `get` method
         dd = DotDict({'key1': 'value1', 'nested': {'inner': 42}})
 
@@ -107,17 +99,15 @@ class TestSupportWrapperDocDict(AsyncTestCase):
 
     async def testExportMethod(self):
         """
-        Tests the `export` method for recursive conversion to regular dict.
+        Test the `export` method for recursive conversion to regular dict.
 
-        This method verifies that calling `export` on a DotDict instance recursively converts
+        Ensures that calling `export` on a DotDict instance recursively converts
         all nested DotDict objects back to regular Python dictionaries.
 
         Returns
         -------
         None
-            This is a test method and does not return a value.
         """
-
         # Create a DotDict instance and export it
         dd = DotDict({
             'key1': 'value1',
@@ -137,18 +127,16 @@ class TestSupportWrapperDocDict(AsyncTestCase):
 
     async def testCopyMethod(self):
         """
-        Tests the `copy` method for deep copy with DotDict conversion.
+        Test the `copy` method for deep copy with DotDict conversion.
 
-        This method verifies that copying a DotDict instance produces an independent copy,
-        with all nested dictionaries converted to DotDict instances. It checks that changes
-        to the copy do not affect the original.
+        Verifies that copying a DotDict instance produces an independent copy,
+        with all nested dictionaries converted to DotDict instances. Checks that
+        changes to the copy do not affect the original.
 
         Returns
         -------
         None
-            This is a test method and does not return a value.
         """
-
         # Create a DotDict instance and copy it
         original = DotDict({
             'key1': 'value1',
@@ -171,15 +159,14 @@ class TestSupportWrapperDocDict(AsyncTestCase):
 
     async def testNestedDictConversion(self):
         """
-        Tests automatic conversion of nested dictionaries to DotDict.
+        Test automatic conversion of nested dictionaries to DotDict.
 
-        This method verifies that nested dictionaries are converted to DotDict instances
+        Verifies that nested dictionaries are converted to DotDict instances
         both during initialization and dynamic assignment.
 
         Returns
         -------
         None
-            This is a test method and does not return a value.
         """
         dd = DotDict({
             'level1': {
@@ -201,17 +188,15 @@ class TestSupportWrapperDocDict(AsyncTestCase):
 
     async def testReprMethod(self):
         """
-        Tests the string representation of DotDict.
+        Test the string representation of DotDict.
 
-        This method verifies that the `__repr__` method of DotDict returns a string
+        Verifies that the `__repr__` method of DotDict returns a string
         representation that includes the DotDict prefix.
 
         Returns
         -------
         None
-            This is a test method and does not return a value.
         """
-
         # Create a DotDict instance and test its string representation
         dd = DotDict({'key': 'value'})
         self.assertEqual(repr(dd), "{'key': 'value'}")

tests/testing/cases/test_testing_asynchronous.py

@@ -5,22 +5,22 @@ class TestAsyncTestCase(AsyncTestCase):
 
     async def testMethodsExist(self):
         """
-        Checks if the AsyncTestCase class defines the required asynchronous lifecycle methods.
+        Verify that AsyncTestCase defines the required asynchronous lifecycle methods.
 
         Parameters
         ----------
         self : TestAsyncTestCase
-            The test case instance.
+            Instance of the test case.
 
         Returns
         -------
         None
-            This method does not return anything. It asserts the existence of required methods.
+            This method does not return a value.
 
-        Notes
-        -----
-        This test ensures that the AsyncTestCase class contains all necessary asynchronous lifecycle methods
-        for proper setup and teardown in asynchronous test scenarios.
+        Raises
+        ------
+        AssertionError
+            If any of the required methods do not exist in AsyncTestCase.
         """
         required_methods = [
             "asyncSetUp",
@@ -34,22 +34,22 @@ class TestAsyncTestCase(AsyncTestCase):
 
     async def testMethodsAreCoroutines(self):
         """
-        Checks that all required asynchronous lifecycle methods in AsyncTestCase are coroutine functions.
+        Check that all required asynchronous lifecycle methods in AsyncTestCase are coroutine functions.
 
         Parameters
         ----------
         self : TestAsyncTestCase
-            The test case instance.
+            Instance of the test case.
 
         Returns
         -------
         None
-            This method does not return anything. It asserts that required methods are coroutine functions.
+            This method does not return a value.
 
-        Notes
-        -----
-        This test verifies that the lifecycle methods are implemented as coroutine functions,
-        which is necessary for asynchronous execution in test cases.
+        Raises
+        ------
+        AssertionError
+            If any of the required methods are not coroutine functions.
         """
         required_methods = [
             "asyncSetUp",

tests/testing/cases/test_testing_synchronous.py

@@ -6,18 +6,17 @@ class TestSyncTestCase(AsyncTestCase):
 
     async def testHasMethods(self):
         """
-        Checks whether the SyncTestCase class defines the required synchronous lifecycle methods.
+        Verify that SyncTestCase defines the required synchronous lifecycle methods.
 
-        This test verifies the existence of the following methods in SyncTestCase:
-            - setUp: Prepares the test environment before each test.
-            - tearDown: Cleans up the test environment after each test.
-            - onSetup: Additional setup logic for tests.
-            - onTeardown: Additional teardown logic for tests.
+        This method asserts the presence of the following methods in SyncTestCase:
+        - setUp
+        - tearDown
+        - onSetup
+        - onTeardown
 
         Returns
         -------
         None
-            This method does not return any value. It performs assertions to validate the presence of required methods.
         """
         # Assert that SyncTestCase has a setUp method
         self.assertTrue(hasattr(SyncTestCase, "setUp"))
@@ -33,18 +32,17 @@ class TestSyncTestCase(AsyncTestCase):
 
     async def testMethodsAreNotCoroutines(self):
         """
-        Checks that the lifecycle methods of SyncTestCase are regular functions and not coroutine functions.
+        Ensure that the lifecycle methods of SyncTestCase are synchronous functions.
 
-        This test ensures that the following methods are synchronous:
-            - setUp
-            - tearDown
-            - onSetup
-            - onTeardown
+        This method checks that the following methods are not coroutine functions:
+        - setUp
+        - tearDown
+        - onSetup
+        - onTeardown
 
         Returns
         -------
         None
-            This method does not return any value. It performs assertions to confirm that the methods are not coroutine functions.
         """
         # Assert that setUp is not a coroutine function
         self.assertFalse(inspect.iscoroutinefunction(SyncTestCase.setUp))

tests/testing/entities/test_testing_result.py

@@ -6,17 +6,10 @@ class TestTestingResult(AsyncTestCase):
 
     async def testDefaultValues(self) -> None:
         """
-        Ensures that optional fields in a TestResult instance are set to None when not provided during initialization.
+        Test that optional fields in TestResult are set to None by default.
 
-        This test checks the default behavior for the following optional fields:
-            - error_message
-            - traceback
-            - class_name
-            - method
-            - module
-            - file_path
-
-        The method asserts that each of these fields is None after instantiating TestResult with only required arguments.
+        Checks that the fields `error_message`, `traceback`, `class_name`, `method`, `module`, and `file_path`
+        are None when not provided during initialization.
 
         Parameters
         ----------
@@ -26,11 +19,6 @@ class TestTestingResult(AsyncTestCase):
         Returns
         -------
         None
-            This method does not return any value. It performs assertions to validate default field values.
-
-        Notes
-        -----
-        This test verifies that the TestResult dataclass correctly initializes optional fields to None when they are omitted.
         """
         # Create a TestResult instance with only required fields
         result = TestResult(
@@ -49,9 +37,9 @@ class TestTestingResult(AsyncTestCase):
 
     async def testRequiredFields(self) -> None:
         """
-        Validates that TestResult enforces the presence of all required fields during initialization.
+        Test that TestResult enforces required fields during initialization.
 
-        This test attempts to instantiate TestResult without required fields and expects a TypeError to be raised.
+        Verifies that omitting required fields raises a TypeError.
 
         Parameters
         ----------
@@ -61,13 +49,6 @@ class TestTestingResult(AsyncTestCase):
         Returns
         -------
         None
-            This method does not return any value. It performs assertions to validate required field enforcement.
-
-        Notes
-        -----
-        - Attempts to instantiate TestResult with no arguments.
-        - Attempts to instantiate TestResult missing the 'id' field.
-        - Expects a TypeError to be raised in both cases.
         """
         # Attempt to create TestResult with no arguments; should raise TypeError
         with self.assertRaises(TypeError):
@@ -83,9 +64,9 @@ class TestTestingResult(AsyncTestCase):
 
     async def testImmutable(self) -> None:
         """
-        Tests the immutability of TestResult instances.
+        Test that TestResult instances are immutable.
 
-        Ensures that TestResult, implemented as a frozen dataclass, does not allow modification of its attributes after instantiation.
+        Ensures that modifying an attribute of a TestResult instance raises an exception.
 
         Parameters
         ----------
@@ -95,16 +76,6 @@ class TestTestingResult(AsyncTestCase):
         Returns
         -------
         None
-            This method does not return any value. It performs assertions to validate immutability.
-
-        Raises
-        ------
-        Exception
-            If an attempt is made to modify an attribute of a frozen TestResult instance.
-
-        Notes
-        -----
-        Attempts to modify the 'name' attribute of a TestResult instance and expects an exception to be raised.
         """
         # Create a TestResult instance
         result = TestResult(
@@ -119,9 +90,9 @@ class TestTestingResult(AsyncTestCase):
 
     async def testStatusValues(self) -> None:
         """
-        Verifies that all possible values of the TestStatus enum can be assigned to the status field of a TestResult instance.
+        Test that all TestStatus enum values can be assigned to TestResult.
 
-        Iterates over each TestStatus value, assigns it to a TestResult, and asserts that the status is set correctly.
+        Iterates through each TestStatus value and checks assignment to the status field.
 
         Parameters
         ----------
@@ -131,11 +102,6 @@ class TestTestingResult(AsyncTestCase):
         Returns
         -------
         None
-            This method does not return any value. It performs assertions to validate status assignment.
-
-        Notes
-        -----
-        This test ensures that the status field in TestResult supports all enum values defined in TestStatus.
         """
         # Iterate through all possible TestStatus values
         for status in TestStatus:
@@ -151,9 +117,9 @@ class TestTestingResult(AsyncTestCase):
 
     async def testErrorFields(self) -> None:
         """
-        Verifies that the error_message and traceback fields are correctly stored in the TestResult object when provided.
+        Test that error_message and traceback fields are stored correctly in TestResult.
 
-        This test initializes a TestResult with error_message and traceback values and asserts that they are set as expected.
+        Verifies that providing values for error_message and traceback sets them as expected.
 
         Parameters
         ----------
@@ -163,11 +129,6 @@ class TestTestingResult(AsyncTestCase):
         Returns
         -------
         None
-            This method does not return any value. It performs assertions to validate error field assignment.
-
-        Notes
-        -----
-        This test ensures that error-related fields are properly assigned and retrievable from the TestResult instance.
         """
         error_msg = "Test failed"
         traceback = "Traceback info"
@@ -182,4 +143,4 @@ class TestTestingResult(AsyncTestCase):
         )
         # Assert that error_message and traceback fields are set correctly
         self.assertEqual(result.error_message, error_msg)
-        self.assertEqual(result.traceback, traceback)
+        self.assertEqual(result.traceback, traceback)

tests/testing/enums/test_testing_status.py

@@ -6,15 +6,13 @@ class TestTestStatus(AsyncTestCase):
 
     async def testHasEnumMembers(self):
         """
-        Checks that the TestStatus enum contains the expected members.
+        Test that the TestStatus enum contains the expected members.
 
-        This test verifies the presence of the following enum members:
-        'PASSED', 'FAILED', 'ERRORED', and 'SKIPPED'.
+        Checks for the presence of the 'PASSED', 'FAILED', 'ERRORED', and 'SKIPPED' members in the TestStatus enum.
 
         Returns
         -------
         None
-            This method does not return a value. It asserts the existence of enum members.
         """
         # Assert that each expected member exists in TestStatus
         self.assertTrue(hasattr(TestStatus, "PASSED"))
@@ -24,14 +22,13 @@ class TestTestStatus(AsyncTestCase):
 
     async def testEnumValuesAreUnique(self):
         """
-        Ensures that all TestStatus enum member values are unique.
+        Test that all TestStatus enum member values are unique.
 
-        This test collects all values from the TestStatus enum and checks for uniqueness.
+        Collects all values from the TestStatus enum and asserts that there are no duplicate values.
 
         Returns
         -------
         None
-            This method does not return a value. It asserts the uniqueness of enum values.
         """
         # Gather all enum values
         values = [status.value for status in TestStatus]
@@ -40,28 +37,26 @@ class TestTestStatus(AsyncTestCase):
 
     async def testEnumIsInstanceOfEnum(self):
         """
-        Validates that TestStatus is a subclass of Enum.
+        Test that TestStatus is a subclass of Enum.
 
-        This test checks the inheritance of TestStatus from the Enum base class.
+        Asserts that TestStatus inherits from the Enum base class.
 
         Returns
         -------
         None
-            This method does not return a value. It asserts the subclass relationship.
         """
         # Assert that TestStatus inherits from Enum
         self.assertTrue(issubclass(TestStatus, Enum))
 
     async def testEnumMembersType(self):
         """
-        Confirms that each member of TestStatus is an instance of TestStatus.
+        Test that each member of TestStatus is an instance of TestStatus.
 
-        This test iterates through all members of TestStatus and checks their type.
+        Iterates through all members of TestStatus and asserts their type.
 
         Returns
         -------
         None
-            This method does not return a value. It asserts the type of each enum member.
         """
         # Assert that each enum member is an instance of TestStatus
         for status in TestStatus:

tests/testing/output/test_testing_dumper.py

@@ -5,18 +5,15 @@ class TestTestingDumper(AsyncTestCase):
 
     async def testMethodsExist(self):
         """
-        Checks if the required methods are present in the TestDumper class.
+        Verify the presence of required methods in the TestDumper class.
 
-        This test verifies that the `TestDumper` class contains all methods
-        specified in the `required_methods` list. It asserts the existence of
-        each method using `hasattr`.
+        This asynchronous test checks whether the TestDumper class implements all methods listed in `required_methods`. 
+        An assertion error is raised if any required method is missing.
 
         Returns
         -------
         None
-            This method does not return any value. It raises an assertion error if any required method is missing.
         """
-
         required_methods = [
             "dd",
             "dump"

tests/testing/output/test_testing_printer.py

@@ -5,20 +5,20 @@ class TestTestingPrinter(AsyncTestCase):
 
     async def testMethodsExist(self):
         """
-        Checks for the existence of required methods in the TestPrinter class.
+        Verify that all required methods are present in the TestPrinter class.
 
-        This test ensures that all methods listed in `required_methods` are present
-        in the `TestPrinter` class by asserting their existence using `hasattr`.
+        This asynchronous test checks whether each method listed in `required_methods`
+        exists as an attribute of the TestPrinter class. An assertion error is raised
+        if any required method is missing.
 
         Parameters
         ----------
         self : TestTestingPrinter
-            The test case instance.
+            Instance of the test case.
 
         Returns
         -------
         None
-            Raises an AssertionError if any required method is missing.
         """
         # List of method names that must exist in TestPrinter
         required_methods = [

tests/testing/records/test_testing_records.py

@@ -8,17 +8,15 @@ class TestTestingRecords(AsyncTestCase):
 
     async def testCreateAndGetReport(self):
         """
-        Tests the creation of a test report and retrieval of the most recent report.
+        Test the creation and retrieval of a test report.
 
-        This method creates a test report with all required fields, stores it using
-        the `TestLogs` class, and then retrieves the most recent report to verify
-        its contents.
+        Creates a test report with all required fields, stores it using the
+        TestLogs class, and retrieves the most recent report to verify its
+        contents.
 
         Returns
         -------
         None
-            This is a test method and does not return any value. Assertions are used
-            to validate expected behavior.
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             logs = TestLogs(tmpdir)
@@ -51,16 +49,14 @@ class TestTestingRecords(AsyncTestCase):
 
     async def testCreateMissingFields(self):
         """
-        Tests error handling when creating a report with missing required fields.
+        Test error handling for missing required fields in report creation.
 
-        This method attempts to create a report without the required 'timestamp'
-        field and expects an `OrionisTestValueError` to be raised.
+        Attempts to create a report without the required 'timestamp' field and
+        expects an OrionisTestValueError to be raised.
 
         Returns
         -------
         None
-            This is a test method and does not return any value. Assertions are used
-            to validate expected behavior.
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             logs = TestLogs(tmpdir)
@@ -83,16 +79,14 @@ class TestTestingRecords(AsyncTestCase):
 
     async def testResetDatabase(self):
         """
-        Tests the reset functionality of the test logs database.
+        Test the reset functionality of the test logs database.
 
-        This method creates a report, stores it, and then resets the logs database.
-        It verifies that the reset operation returns True.
+        Creates a report, stores it, and then resets the logs database.
+        Verifies that the reset operation returns True.
 
         Returns
         -------
         None
-            This is a test method and does not return any value. Assertions are used
-            to validate expected behavior.
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             logs = TestLogs(tmpdir)
@@ -116,16 +110,14 @@ class TestTestingRecords(AsyncTestCase):
 
     async def testGetReportsInvalidParams(self):
         """
-        Tests error handling for invalid parameters passed to `TestLogs.get()`.
+        Test error handling for invalid parameters in TestLogs.get().
 
-        This method checks that passing mutually exclusive or invalid values to
-        `get()` raises an `OrionisTestValueError`.
+        Checks that passing mutually exclusive or invalid values to get()
+        raises an OrionisTestValueError.
 
         Returns
         -------
         None
-            This is a test method and does not return any value. Assertions are used
-            to validate expected behavior.
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             logs = TestLogs(tmpdir)
@@ -144,16 +136,14 @@ class TestTestingRecords(AsyncTestCase):
 
     async def testGetLastReports(self):
         """
-        Tests retrieval of the last N reports and verifies their order.
+        Test retrieval of the last N reports and their order.
 
-        This method creates multiple reports, retrieves the last two, and checks
-        that the reports are returned in descending order by their identifier.
+        Creates multiple reports, retrieves the last two, and checks that the
+        reports are returned in descending order by their identifier.
 
         Returns
         -------
         None
-            This is a test method and does not return any value. Assertions are used
-            to validate expected behavior.
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             logs = TestLogs(tmpdir)