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

tests/foundation/config/logging/test_logging_stack.py

@@ -0,0 +1,124 @@
+from orionis.luminate.foundation.config.logging.entities.stack import Stack
+from orionis.luminate.foundation.config.logging.enums.levels import Level
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestConfigStack(TestCase):
+    """
+    Test cases for the Stack logging configuration class.
+    """
+
+    async def testDefaultValues(self):
+        """
+        Test that Stack instance is created with correct default values.
+        Verifies default path and level match expected values from class definition.
+        """
+        stack = Stack()
+        self.assertEqual(stack.path, "storage/log/application.log")
+        self.assertEqual(stack.level, Level.INFO.value)
+
+    async def testPathValidation(self):
+        """
+        Test path attribute validation.
+        Verifies that empty or non-string paths raise exceptions.
+        """
+        # Test empty path
+        with self.assertRaises(OrionisIntegrityException):
+            Stack(path="")
+        # Test non-string path
+        with self.assertRaises(OrionisIntegrityException):
+            Stack(path=123)
+        # Test valid path
+        try:
+            Stack(path="custom/log/path.log")
+        except OrionisIntegrityException:
+            self.fail("Valid path should not raise exception")
+
+    async def testLevelValidation(self):
+        """
+        Test level attribute validation with different input types.
+        Verifies string, int and enum level values are properly handled.
+        """
+        # Test string level
+        stack = Stack(level="debug")
+        self.assertEqual(stack.level, Level.DEBUG.value)
+
+        # Test int level
+        stack = Stack(level=Level.WARNING.value)
+        self.assertEqual(stack.level, Level.WARNING.value)
+
+        # Test enum level
+        stack = Stack(level=Level.ERROR)
+        self.assertEqual(stack.level, Level.ERROR.value)
+
+        # Test invalid string level
+        with self.assertRaises(OrionisIntegrityException):
+            Stack(level="invalid")
+
+        # Test invalid int level
+        with self.assertRaises(OrionisIntegrityException):
+            Stack(level=999)
+
+        # Test invalid type
+        with self.assertRaises(OrionisIntegrityException):
+            Stack(level=[])
+
+    async def testWhitespaceHandling(self):
+        """
+        Test whitespace handling in path and level attributes.
+        Verifies whitespace is preserved in 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)
+
+    async def testToDictMethod(self):
+        """
+        Test that toDict returns proper dictionary representation.
+        Verifies both path and level are correctly included in dictionary.
+        """
+        stack = Stack()
+        stack_dict = stack.toDict()
+
+        self.assertIsInstance(stack_dict, dict)
+        self.assertEqual(stack_dict['path'], "storage/log/application.log")
+        self.assertEqual(stack_dict['level'], Level.INFO.value)
+
+    async def testCustomValuesToDict(self):
+        """
+        Test that custom values are properly included in dictionary representation.
+        """
+        custom_stack = Stack(
+            path="custom/logs/app.log",
+            level="warning"
+        )
+        stack_dict = custom_stack.toDict()
+        self.assertEqual(stack_dict['path'], "custom/logs/app.log")
+        self.assertEqual(stack_dict['level'], Level.WARNING.value)
+
+    async def testHashability(self):
+        """
+        Test that Stack maintains hashability due to unsafe_hash=True.
+        Verifies Stack instances can be used in sets and as dictionary keys.
+        """
+        stack1 = Stack()
+        stack2 = Stack()
+        stack_set = {stack1, stack2}
+
+        self.assertEqual(len(stack_set), 1)
+
+        custom_stack = Stack(path="custom.log")
+        stack_set.add(custom_stack)
+        self.assertEqual(len(stack_set), 2)
+
+    async def testKwOnlyInitialization(self):
+        """
+        Test that Stack enforces keyword-only initialization.
+        """
+        with self.assertRaises(TypeError):
+            Stack("path.log", "info")

tests/foundation/config/logging/test_logging_weekly.py

@@ -0,0 +1,133 @@
+from orionis.luminate.foundation.config.logging.entities.weekly import Weekly
+from orionis.luminate.foundation.config.logging.enums.levels import Level
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestConfigWeekly(TestCase):
+    """
+    Test cases for the Weekly logging configuration class.
+    """
+
+    async def testDefaultValues(self):
+        """
+        Test that Weekly instance is created with correct default values.
+        Verifies default path, level and retention_weeks match expected values.
+        """
+        weekly = Weekly()
+        self.assertEqual(weekly.path, "storage/log/application.log")
+        self.assertEqual(weekly.level, Level.INFO.value)
+        self.assertEqual(weekly.retention_weeks, 4)
+
+    async def testPathValidation(self):
+        """
+        Test path attribute validation.
+        Verifies that empty or non-string paths raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Weekly(path="")
+        with self.assertRaises(OrionisIntegrityException):
+            Weekly(path=123)
+        try:
+            Weekly(path="custom/log/path.log")
+        except OrionisIntegrityException:
+            self.fail("Valid path should not raise exception")
+
+    async def testLevelValidation(self):
+        """
+        Test level attribute validation with different input types.
+        """
+        # Test string level
+        weekly = Weekly(level="debug")
+        self.assertEqual(weekly.level, Level.DEBUG.value)
+
+        # Test int level
+        weekly = Weekly(level=Level.WARNING.value)
+        self.assertEqual(weekly.level, Level.WARNING.value)
+
+        # Test enum level
+        weekly = Weekly(level=Level.ERROR)
+        self.assertEqual(weekly.level, Level.ERROR.value)
+
+        # Test invalid cases
+        with self.assertRaises(OrionisIntegrityException):
+            Weekly(level="invalid")
+        with self.assertRaises(OrionisIntegrityException):
+            Weekly(level=999)
+        with self.assertRaises(OrionisIntegrityException):
+            Weekly(level=[])
+
+    async def testRetentionWeeksValidation(self):
+        """
+        Test retention_weeks attribute validation.
+        """
+        # Test valid values
+        try:
+            Weekly(retention_weeks=1)
+            Weekly(retention_weeks=12)
+            Weekly(retention_weeks=6)
+        except OrionisIntegrityException:
+            self.fail("Valid retention_weeks should not raise exception")
+
+        # Test invalid values
+        with self.assertRaises(OrionisIntegrityException):
+            Weekly(retention_weeks=0)
+        with self.assertRaises(OrionisIntegrityException):
+            Weekly(retention_weeks=13)
+        with self.assertRaises(OrionisIntegrityException):
+            Weekly(retention_weeks=-1)
+        with self.assertRaises(OrionisIntegrityException):
+            Weekly(retention_weeks="4")
+
+    async def testWhitespaceHandling(self):
+        """
+        Test whitespace handling in path and level attributes.
+        """
+        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):
+        """
+        Test that toDict returns proper dictionary representation.
+        """
+        weekly = Weekly()
+        weekly_dict = weekly.toDict()
+        self.assertIsInstance(weekly_dict, dict)
+        self.assertEqual(weekly_dict['path'], "storage/log/application.log")
+        self.assertEqual(weekly_dict['level'], Level.INFO.value)
+        self.assertEqual(weekly_dict['retention_weeks'], 4)
+
+    async def testCustomValuesToDict(self):
+        """
+        Test that custom values are properly included in dictionary.
+        """
+        custom_weekly = Weekly(
+            path="custom/logs/app.log",
+            level="warning",
+            retention_weeks=8
+        )
+        weekly_dict = custom_weekly.toDict()
+        self.assertEqual(weekly_dict['path'], "custom/logs/app.log")
+        self.assertEqual(weekly_dict['level'], Level.WARNING.value)
+        self.assertEqual(weekly_dict['retention_weeks'], 8)
+
+    async def testHashability(self):
+        """
+        Test that Weekly maintains hashability due to unsafe_hash=True.
+        """
+        weekly1 = Weekly()
+        weekly2 = Weekly()
+        weekly_set = {weekly1, weekly2}
+
+        self.assertEqual(len(weekly_set), 1)
+
+        custom_weekly = Weekly(path="custom.log")
+        weekly_set.add(custom_weekly)
+        self.assertEqual(len(weekly_set), 2)
+
+    async def testKwOnlyInitialization(self):
+        """
+        Test that Weekly enforces keyword-only initialization.
+        """
+        with self.assertRaises(TypeError):
+            Weekly("path.log", "info", 4)

tests/foundation/config/mail/test_mail.py

@@ -0,0 +1,73 @@
+from orionis.luminate.foundation.config.mail.entities.mail import Mail
+from orionis.luminate.foundation.config.mail.entities.mailers import Mailers
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestMail(TestCase):
+
+    async def testDefaultInitialization(self):
+        """
+        Test that Mail instance is initialized with correct default values.
+        Verifies that default mailer is 'smtp' and mailers is an instance of Mailers.
+        """
+        mail = Mail()
+        self.assertEqual(mail.default, "smtp")
+        self.assertIsInstance(mail.mailers, Mailers)
+
+    async def testDefaultValidation(self):
+        """
+        Test validation of default mailer against available options.
+        Verifies that invalid default mailer raises OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Mail(default="invalid_mailer")
+        with self.assertRaises(OrionisIntegrityException):
+            Mail(default=123)
+
+    async def testMailersTypeValidation(self):
+        """
+        Test validation of mailers attribute type.
+        Verifies that non-Mailers objects raise OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Mail(mailers="invalid_mailers_object")
+
+    async def testToDictMethod(self):
+        """
+        Test the toDict method returns proper dictionary representation.
+        Verifies the method returns a dict containing all fields.
+        """
+        mail = Mail()
+        result = mail.toDict()
+        self.assertIsInstance(result, dict)
+        self.assertIn("default", result)
+        self.assertIn("mailers", result)
+        self.assertEqual(result["default"], "smtp")
+
+    async def testHashability(self):
+        """
+        Test that Mail instances are hashable due to unsafe_hash=True.
+        Verifies instances can be used in sets or as dictionary keys.
+        """
+        mail1 = Mail()
+        mail2 = Mail(default="smtp")
+        test_set = {mail1, mail2}
+        self.assertEqual(len(test_set), 1)
+
+    async def testKwOnlyInitialization(self):
+        """
+        Test that Mail requires keyword arguments for initialization.
+        Verifies the class enforces kw_only=True in its dataclass decorator.
+        """
+        with self.assertRaises(TypeError):
+            Mail("smtp", Mailers())
+
+    async def testValidCustomInitialization(self):
+        """
+        Test valid custom initialization with proper values.
+        Verifies instance can be created with valid non-default values.
+        """
+        # Assuming 'smtp' is a valid mailer option from Mailers
+        mail = Mail(default="smtp", mailers=Mailers())
+        self.assertEqual(mail.default, "smtp")
+        self.assertIsInstance(mail.mailers, Mailers)

tests/foundation/config/mail/test_mail_file.py

@@ -0,0 +1,61 @@
+from orionis.luminate.foundation.config.mail.entities.file import File
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestMailFile(TestCase):
+
+    async def testDefaultPathValue(self):
+        """
+        Test that the File instance is initialized with the correct default path.
+        Verifies that a new File object has 'storage/mail' as the default path.
+        """
+        file = File()
+        self.assertEqual(file.path, "storage/mail")
+
+    async def testPathValidation(self):
+        """
+        Test the path validation in __post_init__ method.
+        Verifies that non-string paths raise OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            File(path=123)
+        with self.assertRaises(OrionisIntegrityException):
+            File(path="")
+
+    async def testValidPathAssignment(self):
+        """
+        Test that valid path assignments work correctly.
+        Verifies that string paths are accepted and stored properly.
+        """
+        test_path = "custom/path/to/mail"
+        file = File(path=test_path)
+        self.assertEqual(file.path, test_path)
+
+    async def testToDictMethod(self):
+        """
+        Test the toDict method returns a proper dictionary representation.
+        Checks that the toDict method converts the File instance
+        into a dictionary with the expected path field.
+        """
+        file = File()
+        result = file.toDict()
+        self.assertIsInstance(result, dict)
+        self.assertEqual(result["path"], "storage/mail")
+
+    async def testHashability(self):
+        """
+        Test that File instances are hashable due to unsafe_hash=True.
+        Verifies that instances can be used in sets or as dictionary keys.
+        """
+        file1 = File()
+        file2 = File(path="other/path")
+        test_set = {file1, file2}
+        self.assertEqual(len(test_set), 2)
+
+    async def testKwOnlyInitialization(self):
+        """
+        Test that File requires keyword arguments for initialization.
+        Verifies that the class enforces kw_only=True in its dataclass decorator.
+        """
+        with self.assertRaises(TypeError):
+            File("storage/mail")

tests/foundation/config/mail/test_mail_mailers.py

@@ -0,0 +1,58 @@
+from orionis.luminate.foundation.config.mail.entities.mailers import Mailers
+from orionis.luminate.foundation.config.mail.entities.smtp import Smtp
+from orionis.luminate.foundation.config.mail.entities.file import File
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestMailers(TestCase):
+
+    async def testDefaultInitialization(self):
+        """
+        Test that Mailers instance is initialized with correct default factories.
+        Verifies that smtp and file attributes are properly initialized with their respective types.
+        """
+        mailers = Mailers()
+        self.assertIsInstance(mailers.smtp, Smtp)
+        self.assertIsInstance(mailers.file, File)
+
+    async def testTypeValidation(self):
+        """
+        Test type validation for smtp and file attributes.
+        Verifies that invalid types raise OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Mailers(smtp="invalid_smtp")
+        with self.assertRaises(OrionisIntegrityException):
+            Mailers(file="invalid_file")
+
+    async def testCustomInitialization(self):
+        """
+        Test custom initialization with valid parameters.
+        Verifies that valid Smtp and File instances are accepted.
+        """
+        custom_smtp = Smtp()
+        custom_file = File()
+        mailers = Mailers(smtp=custom_smtp, file=custom_file)
+        self.assertIs(mailers.smtp, custom_smtp)
+        self.assertIs(mailers.file, custom_file)
+
+    async def testToDictMethod(self):
+        """
+        Test the toDict method returns proper dictionary representation.
+        Verifies the method returns a dict containing all fields with correct values.
+        """
+        mailers = Mailers()
+        result = mailers.toDict()
+        self.assertIsInstance(result, dict)
+        self.assertIn("smtp", result)
+        self.assertIn("file", result)
+        self.assertIsInstance(result["smtp"], dict)
+        self.assertIsInstance(result["file"], dict)
+
+    async def testKwOnlyInitialization(self):
+        """
+        Test that Mailers requires keyword arguments for initialization.
+        Verifies the class enforces kw_only=True in its dataclass decorator.
+        """
+        with self.assertRaises(TypeError):
+            Mailers(Smtp(), File())

tests/foundation/config/mail/test_mail_smtp.py

@@ -0,0 +1,102 @@
+from orionis.luminate.foundation.config.mail.entities.smtp import Smtp
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestSmtp(TestCase):
+
+    async def testDefaultInitialization(self):
+        """
+        Test that Smtp instance is initialized with correct default values.
+        Verifies all default values match the expected configuration.
+        """
+        smtp = Smtp()
+        self.assertEqual(smtp.url, "smtp.mailtrap.io")
+        self.assertEqual(smtp.host, "smtp.mailtrap.io")
+        self.assertEqual(smtp.port, 587)
+        self.assertEqual(smtp.encryption, "TLS")
+        self.assertEqual(smtp.username, "")
+        self.assertEqual(smtp.password, "")
+        self.assertIsNone(smtp.timeout)
+
+    async def testTypeValidation(self):
+        """
+        Test type validation for all Smtp attributes.
+        Verifies that invalid types raise OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Smtp(url=123)
+        with self.assertRaises(OrionisIntegrityException):
+            Smtp(host=456)
+        with self.assertRaises(OrionisIntegrityException):
+            Smtp(port="invalid")
+        with self.assertRaises(OrionisIntegrityException):
+            Smtp(encryption=123)
+        with self.assertRaises(OrionisIntegrityException):
+            Smtp(username=123)
+        with self.assertRaises(OrionisIntegrityException):
+            Smtp(password=123)
+        with self.assertRaises(OrionisIntegrityException):
+            Smtp(timeout="invalid")
+
+    async def testPortValidation(self):
+        """
+        Test specific validation for port attribute.
+        Verifies that negative port numbers raise OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Smtp(port=-1)
+
+    async def testTimeoutValidation(self):
+        """
+        Test specific validation for timeout attribute.
+        Verifies that negative timeout values raise OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Smtp(timeout=-1)
+
+    async def testValidCustomInitialization(self):
+        """
+        Test custom initialization with valid parameters.
+        Verifies that valid custom values are accepted and stored correctly.
+        """
+        custom_config = Smtp(
+            url="smtp.example.com",
+            host="mail.example.com",
+            port=465,
+            encryption="SSL",
+            username="user",
+            password="pass",
+            timeout=30
+        )
+        self.assertEqual(custom_config.url, "smtp.example.com")
+        self.assertEqual(custom_config.host, "mail.example.com")
+        self.assertEqual(custom_config.port, 465)
+        self.assertEqual(custom_config.encryption, "SSL")
+        self.assertEqual(custom_config.username, "user")
+        self.assertEqual(custom_config.password, "pass")
+        self.assertEqual(custom_config.timeout, 30)
+
+    async def testToDictMethod(self):
+        """
+        Test the toDict method returns proper dictionary representation.
+        Verifies the method returns a dict containing all fields with correct values.
+        """
+        smtp = Smtp()
+        result = smtp.toDict()
+        self.assertIsInstance(result, dict)
+        self.assertEqual(result["url"], "smtp.mailtrap.io")
+        self.assertEqual(result["host"], "smtp.mailtrap.io")
+        self.assertEqual(result["port"], 587)
+        self.assertEqual(result["encryption"], "TLS")
+        self.assertEqual(result["username"], "")
+        self.assertEqual(result["password"], "")
+        self.assertIsNone(result["timeout"])
+
+
+    async def testKwOnlyInitialization(self):
+        """
+        Test that Smtp requires keyword arguments for initialization.
+        Verifies the class enforces kw_only=True in its dataclass decorator.
+        """
+        with self.assertRaises(TypeError):
+            Smtp("smtp.mailtrap.io", "smtp.mailtrap.io", 587, "TLS", "", "", None)

tests/foundation/config/queue/test_queue.py

@@ -0,0 +1,58 @@
+from orionis.luminate.foundation.config.queue.entities.queue import Queue
+from orionis.luminate.foundation.config.queue.entities.brokers import Brokers
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestQueue(TestCase):
+
+    async def testDefaultInitialization(self):
+        """
+        Test that Queue instance is initialized with correct default values.
+        Verifies that default connection is 'sync' and brokers is a Brokers instance.
+        """
+        queue = Queue()
+        self.assertEqual(queue.default, "sync")
+        self.assertIsInstance(queue.brokers, Brokers)
+
+    async def testDefaultValidation(self):
+        """
+        Test validation for default attribute.
+        Verifies that invalid default values raise OrionisIntegrityException.
+        """
+        invalid_options = ["invalid", "", 123, None]
+        for option in invalid_options:
+            with self.assertRaises(OrionisIntegrityException):
+                Queue(default=option)
+
+    async def testBrokersValidation(self):
+        """
+        Test validation for brokers attribute.
+        Verifies that non-Brokers values raise OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Queue(brokers="invalid_brokers")
+        with self.assertRaises(OrionisIntegrityException):
+            Queue(brokers={})
+
+    async def testValidCustomInitialization(self):
+        """
+        Test custom initialization with valid parameters.
+        Verifies that valid default and Brokers instances are accepted.
+        """
+        custom_brokers = Brokers(sync=False)
+        queue = Queue(default="sync", brokers=custom_brokers)
+        self.assertEqual(queue.default, "sync")
+        self.assertIs(queue.brokers, custom_brokers)
+        self.assertFalse(queue.brokers.sync)
+
+    async def testToDictMethod(self):
+        """
+        Test the toDict method returns proper dictionary representation.
+        Verifies all fields are included with correct values.
+        """
+        queue = Queue()
+        result = queue.toDict()
+        self.assertIsInstance(result, dict)
+        self.assertEqual(result["default"], "sync")
+        self.assertIsInstance(result["brokers"], dict)
+        self.assertTrue(result["brokers"]["sync"])

tests/foundation/config/queue/test_queue_brokers.py

@@ -0,0 +1,67 @@
+from orionis.luminate.foundation.config.queue.entities.brokers import Brokers
+from orionis.luminate.foundation.config.queue.entities.database import Database
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestBrokers(TestCase):
+
+    async def testDefaultInitialization(self):
+        """
+        Test that Brokers instance is initialized with correct default values.
+        Verifies that sync is True by default and database is a Database instance.
+        """
+        brokers = Brokers()
+        self.assertTrue(brokers.sync)
+        self.assertIsInstance(brokers.database, Database)
+
+    async def testSyncValidation(self):
+        """
+        Test validation for sync attribute.
+        Verifies that non-boolean values raise OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Brokers(sync="true")
+        with self.assertRaises(OrionisIntegrityException):
+            Brokers(sync=1)
+
+    async def testDatabaseValidation(self):
+        """
+        Test validation for database attribute.
+        Verifies that non-Database values raise OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Brokers(database="invalid_database")
+        with self.assertRaises(OrionisIntegrityException):
+            Brokers(database={})
+
+    async def testCustomInitialization(self):
+        """
+        Test custom initialization with valid parameters.
+        Verifies that valid boolean and Database instances are accepted.
+        """
+        custom_db = Database(table="custom_queue")
+        brokers = Brokers(sync=False, database=custom_db)
+        self.assertFalse(brokers.sync)
+        self.assertIs(brokers.database, custom_db)
+        self.assertEqual(brokers.database.table, "custom_queue")
+
+    async def testToDictMethod(self):
+        """
+        Test the toDict method returns proper dictionary representation.
+        Verifies all fields are included with correct values.
+        """
+        brokers = Brokers()
+        result = brokers.toDict()
+        self.assertIsInstance(result, dict)
+        self.assertIn("sync", result)
+        self.assertIn("database", result)
+        self.assertTrue(result["sync"])
+        self.assertIsInstance(result["database"], dict)
+
+    async def testKwOnlyInitialization(self):
+        """
+        Test that Brokers requires keyword arguments for initialization.
+        Verifies the class enforces kw_only=True in its dataclass decorator.
+        """
+        with self.assertRaises(TypeError):
+            Brokers(True, Database())