orionis 0.404.0__py3-none-any.whl → 0.406.0__py3-none-any.whl

tests/container/validators/test_is_subclass.py

@@ -0,0 +1,115 @@
+from abc import ABC
+from orionis.container.validators.is_subclass import IsSubclass
+from orionis.container.exceptions.exception import OrionisContainerException
+from orionis.test.cases.asynchronous import AsyncTestCase
+
+class TestIsSubclass(AsyncTestCase):
+    """
+    Test cases for the IsSubclass validator in orionis.container.validators.is_subclass.
+
+    Notes
+    -----
+    This test suite validates the functionality of the IsSubclass validator
+    which ensures that a concrete class is a subclass of an abstract class.
+    """
+
+    async def testValidSubclass(self) -> None:
+        """
+        Test that validation passes when concrete class is a valid subclass.
+        """
+        # Define test classes
+        class AbstractClass(ABC):
+            pass
+
+        class ConcreteClass(AbstractClass):
+            pass
+
+        class SubConcreteClass(ConcreteClass):
+            pass
+
+        # These should not raise exceptions
+        IsSubclass(AbstractClass, ConcreteClass)
+        IsSubclass(AbstractClass, SubConcreteClass)
+        IsSubclass(ConcreteClass, SubConcreteClass)
+
+    async def testInvalidSubclass(self) -> None:
+        """
+        Test that validation fails when concrete class is not a subclass.
+        """
+        # Define test classes
+        class AbstractClass1(ABC):
+            pass
+
+        class AbstractClass2(ABC):
+            pass
+
+        class ConcreteClass1(AbstractClass1):
+            pass
+
+        class ConcreteClass2(AbstractClass2):
+            pass
+
+        # These should raise exceptions
+        with self.assertRaises(OrionisContainerException) as context:
+            IsSubclass(AbstractClass1, AbstractClass2)
+        self.assertIn("concrete class must inherit", str(context.exception))
+
+        with self.assertRaises(OrionisContainerException) as context:
+            IsSubclass(AbstractClass1, ConcreteClass2)
+        self.assertIn("concrete class must inherit", str(context.exception))
+
+        with self.assertRaises(OrionisContainerException) as context:
+            IsSubclass(ConcreteClass1, AbstractClass1)
+        self.assertIn("concrete class must inherit", str(context.exception))
+
+    async def testSameClass(self) -> None:
+        """
+        Test validation when abstract and concrete are the same class.
+        """
+        class TestClass:
+            pass
+
+        # A class is considered a subclass of itself
+        IsSubclass(TestClass, TestClass)
+
+    async def testBuiltinTypes(self) -> None:
+        """
+        Test validation with built-in types.
+        """
+        # Valid subclass relationships
+        IsSubclass(Exception, ValueError)
+        IsSubclass(BaseException, Exception)
+
+        # Invalid subclass relationships
+        with self.assertRaises(OrionisContainerException):
+            IsSubclass(ValueError, Exception)
+
+        with self.assertRaises(OrionisContainerException):
+            IsSubclass(int, str)
+
+        with self.assertRaises(OrionisContainerException):
+            IsSubclass(list, dict)
+
+    async def testNonClassArguments(self) -> None:
+        """
+        Test validation with non-class arguments which should raise TypeError.
+        """
+        class TestClass:
+            pass
+
+        # These should raise TypeError when passed to issubclass()
+        non_class_args = [
+            None,
+            123,
+            "string",
+            [],
+            {},
+            lambda x: x
+        ]
+
+        for arg in non_class_args:
+            with self.assertRaises(TypeError):
+                IsSubclass(TestClass, arg)
+
+            with self.assertRaises(TypeError):
+                IsSubclass(arg, TestClass)

tests/container/validators/test_is_valid_alias.py

@@ -0,0 +1,113 @@
+from orionis.container.validators.is_valid_alias import IsValidAlias
+from orionis.container.exceptions.type import OrionisContainerTypeError
+from orionis.test.cases.asynchronous import AsyncTestCase
+
+class TestIsValidAlias(AsyncTestCase):
+    """
+    Test cases for the IsValidAlias validator in orionis.container.validators.is_valid_alias.
+
+    Notes
+    -----
+    This test suite validates the functionality of the IsValidAlias validator
+    which ensures that alias values are valid strings without invalid characters.
+    """
+
+    async def testValidAliases(self) -> None:
+        """
+        Test that validation passes when valid aliases are provided.
+        """
+        valid_aliases = [
+            "valid",
+            "valid_alias",
+            "validAlias",
+            "valid123",
+            "valid_123",
+            "v",
+            "1",
+            "_",
+            "valid_alias_with_underscores",
+            "ValidAliasWithMixedCase",
+            "VALID_UPPERCASE_ALIAS"
+        ]
+
+        for alias in valid_aliases:
+            IsValidAlias(alias)
+
+    async def testInvalidAliasTypes(self) -> None:
+        """
+        Test that validation fails when non-string types are provided.
+        """
+        invalid_types = [
+            123,
+            3.14,
+            None,
+            True,
+            False,
+            [],
+            {},
+            (),
+            set()
+        ]
+
+        for value in invalid_types:
+            with self.assertRaises(OrionisContainerTypeError) as context:
+                IsValidAlias(value)
+
+    async def testAliasWithInvalidCharacters(self) -> None:
+        """
+        Test that validation fails when aliases contain invalid characters.
+        """
+        invalid_aliases = [
+            "invalid alias",  # space
+            "invalid\talias",  # tab
+            "invalid\nalias",  # newline
+            "invalid@alias",   # special character
+            "invalid#alias",   # special character
+            "invalid$alias",   # special character
+            "invalid%alias",   # special character
+            "invalid&alias",   # special character
+            "invalid*alias",   # special character
+            "invalid(alias)",  # parentheses
+            "invalid[alias]",  # brackets
+            "invalid{alias}",  # braces
+            "invalid;alias",   # semicolon
+            "invalid:alias",   # colon
+            "invalid,alias",   # comma
+            "invalid/alias",   # slash
+            "invalid\\alias",  # backslash
+            "invalid<alias>",  # angle brackets
+            "invalid|alias",   # pipe
+            "invalid`alias",   # backtick
+            'invalid"alias',   # double quote
+            "invalid'alias"    # single quote
+        ]
+
+        for alias in invalid_aliases:
+            with self.assertRaises(OrionisContainerTypeError) as context:
+                IsValidAlias(alias)
+
+            expected_msg_start = f"Alias '{alias}' contains invalid characters."
+            self.assertTrue(str(context.exception).startswith(expected_msg_start))
+            self.assertIn("Aliases must not contain whitespace or special symbols", str(context.exception))
+
+    async def testEmptyAlias(self) -> None:
+        """
+        Test that validation fails with an empty string.
+        """
+        # Empty string should be rejected
+        with self.assertRaises(OrionisContainerTypeError) as context:
+            IsValidAlias("")
+
+        self.assertEqual(
+            str(context.exception),
+            "Alias cannot be None, empty, or whitespace only."
+        )
+
+        # Whitespace-only string should also be rejected
+        with self.assertRaises(OrionisContainerTypeError) as context:
+            IsValidAlias("   ")
+
+        self.assertEqual(
+            str(context.exception),
+            "Alias cannot be None, empty, or whitespace only."
+        )

tests/container/validators/test_lifetime.py

@@ -0,0 +1,75 @@
+from orionis.container.validators.lifetime import LifetimeValidator
+from orionis.container.enums.lifetimes import Lifetime
+from orionis.container.exceptions.type import OrionisContainerTypeError
+from orionis.test.cases.asynchronous import AsyncTestCase
+
+class TestLifetimeValidator(AsyncTestCase):
+    """
+    Test cases for the LifetimeValidator in orionis.container.validators.lifetime.
+
+    Notes
+    -----
+    This test suite validates the functionality of the LifetimeValidator
+    which ensures that lifetime values are correctly validated and converted.
+    """
+
+    async def testValidLifetimeEnumValues(self) -> None:
+        """
+        Test that validation passes when Lifetime enum values are provided.
+        """
+        self.assertEqual(LifetimeValidator(Lifetime.TRANSIENT), Lifetime.TRANSIENT)
+        self.assertEqual(LifetimeValidator(Lifetime.SINGLETON), Lifetime.SINGLETON)
+        self.assertEqual(LifetimeValidator(Lifetime.SCOPED), Lifetime.SCOPED)
+
+    async def testValidLifetimeStringValues(self) -> None:
+        """
+        Test that validation passes when valid string representations are provided.
+        """
+        self.assertEqual(LifetimeValidator("TRANSIENT"), Lifetime.TRANSIENT)
+        self.assertEqual(LifetimeValidator("SINGLETON"), Lifetime.SINGLETON)
+        self.assertEqual(LifetimeValidator("SCOPED"), Lifetime.SCOPED)
+
+        # Test with lowercase and mixed case
+        self.assertEqual(LifetimeValidator("transient"), Lifetime.TRANSIENT)
+        self.assertEqual(LifetimeValidator("Singleton"), Lifetime.SINGLETON)
+        self.assertEqual(LifetimeValidator("scoped"), Lifetime.SCOPED)
+
+        # Test with extra whitespace
+        self.assertEqual(LifetimeValidator(" TRANSIENT "), Lifetime.TRANSIENT)
+        self.assertEqual(LifetimeValidator("  singleton  "), Lifetime.SINGLETON)
+
+    async def testInvalidLifetimeStringValue(self) -> None:
+        """
+        Test that validation fails when invalid string representations are provided.
+        """
+        with self.assertRaises(OrionisContainerTypeError) as context:
+            LifetimeValidator("INVALID_LIFETIME")
+
+        self.assertIn("Invalid lifetime 'INVALID_LIFETIME'", str(context.exception))
+        self.assertIn("Valid options are:", str(context.exception))
+        self.assertIn("TRANSIENT", str(context.exception))
+        self.assertIn("SINGLETON", str(context.exception))
+        self.assertIn("SCOPED", str(context.exception))
+
+    async def testInvalidLifetimeType(self) -> None:
+        """
+        Test that validation fails when invalid types are provided.
+        """
+        invalid_values = [
+            123,
+            3.14,
+            None,
+            True,
+            False,
+            [],
+            {},
+            (),
+            set()
+        ]
+
+        for value in invalid_values:
+            with self.assertRaises(OrionisContainerTypeError) as context:
+                LifetimeValidator(value)
+
+            expected_msg = f"Lifetime must be of type str or Lifetime enum, got {type(value).__name__}."
+            self.assertEqual(str(context.exception), expected_msg)

tests/foundation/config/logging/test_foundation_config_logging_chunked.py

@@ -25,7 +25,7 @@ class TestFoundationConfigLoggingChunked(AsyncTestCase):
         None
         """
         chunked = Chunked()
-        self.assertEqual(chunked.path, "storage/log/application.log")
+        self.assertEqual(chunked.path, "storage/log/chunked.log")
         self.assertEqual(chunked.level, Level.INFO.value)
         self.assertEqual(chunked.mb_size, 10)
         self.assertEqual(chunked.files, 5)
@@ -85,39 +85,19 @@ class TestFoundationConfigLoggingChunked(AsyncTestCase):
         """
         Test validation of the `mb_size` attribute.
 
-        Ensures that valid integer and string formats are accepted, and invalid
-        values raise `OrionisIntegrityException`.
-
         Returns
         -------
         None
         """
-        # Test valid integer values
-        try:
-            Chunked(mb_size=1)
-            Chunked(mb_size=100)
-        except OrionisIntegrityException:
-            self.fail("Valid mb_size should not raise exception")
-
-        # Test string formats
-        chunked = Chunked(mb_size="10MB")
+        chunked = Chunked(mb_size=10)
         self.assertEqual(chunked.mb_size, 10)
 
-        chunked = Chunked(mb_size="10240KB")
-        self.assertEqual(chunked.mb_size, 10)
-
-        chunked = Chunked(mb_size="10485760B")
-        self.assertEqual(chunked.mb_size, 10)
+        chunked = Chunked(mb_size=1000)
+        self.assertEqual(chunked.mb_size, 1000)
 
-        # Test invalid cases
-        with self.assertRaises(OrionisIntegrityException):
-            Chunked(mb_size=0)
-        with self.assertRaises(OrionisIntegrityException):
-            Chunked(mb_size=-1)
-        with self.assertRaises(OrionisIntegrityException):
-            Chunked(mb_size="invalid")
         with self.assertRaises(OrionisIntegrityException):
-            Chunked(mb_size="10GB")
+            chunked = Chunked(mb_size=2048)
+            self.assertEqual(chunked.mb_size, 2048)
 
     async def testFilesValidation(self):
         """
@@ -149,16 +129,14 @@ class TestFoundationConfigLoggingChunked(AsyncTestCase):
         """
         Test handling of whitespace in `path` and `level` attributes.
 
-        Ensures that leading and trailing whitespace in `path` and `level` are
-        handled as expected.
-
         Returns
         -------
         None
         """
-        chunked = Chunked(path="  logs/app.log  ", level="  debug  ")
-        self.assertEqual(chunked.path, "  logs/app.log  ")
-        self.assertEqual(chunked.level, Level.DEBUG.value)
+        with self.assertRaises(OrionisIntegrityException):
+            chunked = Chunked(path="  logs/app.log  ", level="  debug  ")
+            self.assertEqual(chunked.path, "  logs/app.log  ")
+            self.assertEqual(chunked.level, Level.DEBUG.value)
 
     async def testToDictMethod(self):
         """
@@ -175,7 +153,7 @@ class TestFoundationConfigLoggingChunked(AsyncTestCase):
         chunked_dict = chunked.toDict()
 
         self.assertIsInstance(chunked_dict, dict)
-        self.assertEqual(chunked_dict['path'], "storage/log/application.log")
+        self.assertEqual(chunked_dict['path'], "storage/log/chunked.log")
         self.assertEqual(chunked_dict['level'], Level.INFO.value)
         self.assertEqual(chunked_dict['mb_size'], 10)
         self.assertEqual(chunked_dict['files'], 5)
@@ -199,7 +177,7 @@ class TestFoundationConfigLoggingChunked(AsyncTestCase):
         )
         chunked_dict = custom_chunked.toDict()
         self.assertEqual(chunked_dict['path'], "custom/logs/app.log")
-        self.assertEqual(chunked_dict['level'], Level.WARNING.value)
+        self.assertEqual(chunked_dict['level'], 30)
         self.assertEqual(chunked_dict['mb_size'], 20)
         self.assertEqual(chunked_dict['files'], 10)
 

tests/foundation/config/logging/test_foundation_config_logging_daily.py

@@ -25,10 +25,10 @@ class TestFoundationConfigLoggingDaily(AsyncTestCase):
         None
         """
         daily = Daily()
-        self.assertEqual(daily.path, "storage/log/application.log")
+        self.assertEqual(daily.path, "storage/log/daily.log")
         self.assertEqual(daily.level, Level.INFO.value)
         self.assertEqual(daily.retention_days, 7)
-        self.assertEqual(daily.at, "00:00:00")
+        self.assertEqual(daily.at, "00:00")
 
     async def testPathValidation(self):
         """
@@ -122,7 +122,7 @@ class TestFoundationConfigLoggingDaily(AsyncTestCase):
         """
         # Test time object
         daily = Daily(at=time(12, 30))
-        self.assertEqual(daily.at, "12:30:00")
+        self.assertEqual(daily.at, "12:30")
 
         # Test invalid type
         with self.assertRaises(OrionisIntegrityException):
@@ -134,15 +134,15 @@ class TestFoundationConfigLoggingDaily(AsyncTestCase):
         """
         Test handling of whitespace in path and level attributes.
 
-        Ensures that whitespace in path and level is preserved or handled as expected.
-
         Returns
         -------
         None
         """
-        daily = Daily(path="  logs/app.log  ", level="  debug  ")
-        self.assertEqual(daily.path, "  logs/app.log  ")
-        self.assertEqual(daily.level, Level.DEBUG.value)
+
+        with self.assertRaises(OrionisIntegrityException):
+            daily = Daily(path="  logs/app.log  ", level="  debug  ")
+            self.assertEqual(daily.path, "  logs/app.log  ")
+            self.assertEqual(daily.level, Level.DEBUG.value)
 
     async def testToDictMethod(self):
         """
@@ -159,10 +159,10 @@ class TestFoundationConfigLoggingDaily(AsyncTestCase):
         daily_dict = daily.toDict()
 
         self.assertIsInstance(daily_dict, dict)
-        self.assertEqual(daily_dict['path'], "storage/log/application.log")
+        self.assertEqual(daily_dict['path'], "storage/log/daily.log")
         self.assertEqual(daily_dict['level'], Level.INFO.value)
         self.assertEqual(daily_dict['retention_days'], 7)
-        self.assertEqual(daily_dict['at'], "00:00:00")
+        self.assertEqual(daily_dict['at'], "00:00")
 
     async def testCustomValuesToDict(self):
         """
@@ -184,7 +184,7 @@ class TestFoundationConfigLoggingDaily(AsyncTestCase):
         self.assertEqual(daily_dict['path'], "custom/logs/app.log")
         self.assertEqual(daily_dict['level'], Level.WARNING.value)
         self.assertEqual(daily_dict['retention_days'], 14)
-        self.assertEqual(daily_dict['at'], "23:59:00")
+        self.assertEqual(daily_dict['at'], "23:59")
 
     async def testHashability(self):
         """

tests/foundation/config/logging/test_foundation_config_logging_hourly.py

@@ -24,7 +24,7 @@ class TestFoundationConfigLoggingHourly(AsyncTestCase):
         None
         """
         hourly = Hourly()
-        self.assertEqual(hourly.path, "storage/log/application.log")
+        self.assertEqual(hourly.path, "storage/log/hourly.log")
         self.assertEqual(hourly.level, Level.INFO.value)
         self.assertEqual(hourly.retention_hours, 24)
 
@@ -113,16 +113,15 @@ class TestFoundationConfigLoggingHourly(AsyncTestCase):
         """
         Test whitespace handling in path and level attributes.
 
-        Verifies that leading and trailing whitespace in the `path` and `level`
-        attributes are handled as expected.
-
         Returns
         -------
         None
         """
-        hourly = Hourly(path="  logs/app.log  ", level="  debug  ")
-        self.assertEqual(hourly.path, "  logs/app.log  ")
-        self.assertEqual(hourly.level, Level.DEBUG.value)
+
+        with self.assertRaises(OrionisIntegrityException):
+            hourly = Hourly(path="  logs/app.log  ", level="  debug  ")
+            self.assertEqual(hourly.path, "  logs/app.log  ")
+            self.assertEqual(hourly.level, Level.DEBUG.value)
 
     async def testToDictMethod(self):
         """
@@ -138,7 +137,7 @@ class TestFoundationConfigLoggingHourly(AsyncTestCase):
         hourly = Hourly()
         hourly_dict = hourly.toDict()
         self.assertIsInstance(hourly_dict, dict)
-        self.assertEqual(hourly_dict['path'], "storage/log/application.log")
+        self.assertEqual(hourly_dict['path'], "storage/log/hourly.log")
         self.assertEqual(hourly_dict['level'], Level.INFO.value)
         self.assertEqual(hourly_dict['retention_hours'], 24)
 

tests/foundation/config/logging/test_foundation_config_logging_monthly.py

@@ -25,7 +25,7 @@ class TestFoundationConfigLoggingMonthly(AsyncTestCase):
         - Default retention_months is 4.
         """
         monthly = Monthly()
-        self.assertEqual(monthly.path, "storage/log/application.log")
+        self.assertEqual(monthly.path, "storage/log/monthly.log")
         self.assertEqual(monthly.level, Level.INFO.value)
         self.assertEqual(monthly.retention_months, 4)
 
@@ -106,15 +106,12 @@ class TestFoundationConfigLoggingMonthly(AsyncTestCase):
     async def testWhitespaceHandling(self):
         """
         Test whitespace handling in path and level attributes.
-
-        Verifies
-        --------
-        - Whitespace in path is preserved.
-        - Whitespace in level is handled correctly.
         """
-        monthly = Monthly(path="  logs/app.log  ", level="  debug  ")
-        self.assertEqual(monthly.path, "  logs/app.log  ")
-        self.assertEqual(monthly.level, Level.DEBUG.value)
+
+        with self.assertRaises(OrionisIntegrityException):
+            monthly = Monthly(path="  logs/app.log  ", level="  debug  ")
+            self.assertEqual(monthly.path, "  logs/app.log  ")
+            self.assertEqual(monthly.level, Level.DEBUG.value)
 
     async def testToDictMethod(self):
         """
@@ -127,7 +124,7 @@ class TestFoundationConfigLoggingMonthly(AsyncTestCase):
         monthly = Monthly()
         monthly_dict = monthly.toDict()
         self.assertIsInstance(monthly_dict, dict)
-        self.assertEqual(monthly_dict['path'], "storage/log/application.log")
+        self.assertEqual(monthly_dict['path'], "storage/log/monthly.log")
         self.assertEqual(monthly_dict['level'], Level.INFO.value)
         self.assertEqual(monthly_dict['retention_months'], 4)
 

tests/foundation/config/logging/test_foundation_config_logging_stack.py

@@ -20,7 +20,7 @@ class TestFoundationConfigLoggingStack(AsyncTestCase):
         Verifies that the default path and level match the expected values from the class definition.
         """
         stack = Stack()
-        self.assertEqual(stack.path, "storage/log/application.log")
+        self.assertEqual(stack.path, "storage/log/stack.log")
         self.assertEqual(stack.level, Level.INFO.value)
 
     async def testPathValidation(self):
@@ -84,17 +84,12 @@ class TestFoundationConfigLoggingStack(AsyncTestCase):
     async def testWhitespaceHandling(self):
         """
         Test handling of whitespace in path and level attributes.
-
-        Ensures that whitespace is preserved in the path and trimmed in level strings.
         """
-        # Test path with whitespace
-        spaced_path = "  logs/app.log  "
-        stack = Stack(path=spaced_path)
-        self.assertEqual(stack.path, spaced_path)
 
-        # Test level with whitespace
-        stack = Stack(level="  debug  ")
-        self.assertEqual(stack.level, Level.DEBUG.value)
+        with self.assertRaises(OrionisIntegrityException):
+            spaced_path = "  logs/app.log  "
+            stack = Stack(path=spaced_path)
+            self.assertEqual(stack.path, spaced_path)
 
     async def testToDictMethod(self):
         """
@@ -111,7 +106,7 @@ class TestFoundationConfigLoggingStack(AsyncTestCase):
         stack_dict = stack.toDict()
 
         self.assertIsInstance(stack_dict, dict)
-        self.assertEqual(stack_dict['path'], "storage/log/application.log")
+        self.assertEqual(stack_dict['path'], "storage/log/stack.log")
         self.assertEqual(stack_dict['level'], Level.INFO.value)
 
     async def testCustomValuesToDict(self):

tests/foundation/config/logging/test_foundation_config_logging_weekly.py

@@ -49,7 +49,7 @@ class TestFoundationConfigLoggingWeekly(AsyncTestCase):
         None
         """
         weekly = Weekly()
-        self.assertEqual(weekly.path, "storage/log/application.log")
+        self.assertEqual(weekly.path, "storage/log/weekly.log")
         self.assertEqual(weekly.level, Level.INFO.value)
         self.assertEqual(weekly.retention_weeks, 4)
 
@@ -144,9 +144,10 @@ class TestFoundationConfigLoggingWeekly(AsyncTestCase):
         -------
         None
         """
-        weekly = Weekly(path="  logs/app.log  ", level="  debug  ")
-        self.assertEqual(weekly.path, "  logs/app.log  ")
-        self.assertEqual(weekly.level, Level.DEBUG.value)
+        with self.assertRaises(OrionisIntegrityException):
+            weekly = Weekly(path="  logs/app.log  ", level="  debug  ")
+            self.assertEqual(weekly.path, "  logs/app.log  ")
+            self.assertEqual(weekly.level, Level.DEBUG.value)
 
     async def testToDictMethod(self):
         """
@@ -162,7 +163,7 @@ class TestFoundationConfigLoggingWeekly(AsyncTestCase):
         weekly = Weekly()
         weekly_dict = weekly.toDict()
         self.assertIsInstance(weekly_dict, dict)
-        self.assertEqual(weekly_dict['path'], "storage/log/application.log")
+        self.assertEqual(weekly_dict['path'], "storage/log/weekly.log")
         self.assertEqual(weekly_dict['level'], Level.INFO.value)
         self.assertEqual(weekly_dict['retention_weeks'], 4)
 

tests/foundation/config/testing/test_foundation_config_testing.py

@@ -1,6 +1,6 @@
 from orionis.foundation.config.testing.entities.testing import Testing
+from orionis.foundation.config.testing.enums.mode import ExecutionMode
 from orionis.foundation.exceptions import OrionisIntegrityException
-from orionis.test.enums.execution_mode import ExecutionMode
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestFoundationConfigTesting(AsyncTestCase):