eventsourcing 9.4.3__py3-none-any.whl → 9.4.5__py3-none-any.whl

eventsourcing/tests/application.py

@@ -1,20 +1,17 @@
 from __future__ import annotations
 
-import os
-import sys
 import traceback
 import warnings
 from concurrent.futures import ThreadPoolExecutor
 from decimal import Decimal
 from threading import Event, get_ident
 from time import sleep
-from timeit import timeit
 from typing import TYPE_CHECKING, Any, ClassVar
 from unittest import TestCase
 from uuid import UUID, uuid4
 
 from eventsourcing.application import AggregateNotFoundError, Application
-from eventsourcing.domain import Aggregate, datetime_now_with_tzinfo
+from eventsourcing.domain import Aggregate
 from eventsourcing.persistence import (
     InfrastructureFactory,
     InfrastructureFactoryError,
@@ -28,11 +25,8 @@ from eventsourcing.utils import EnvType, get_topic
 if TYPE_CHECKING:
     from datetime import datetime
 
-TIMEIT_FACTOR = int(os.environ.get("TEST_TIMEIT_FACTOR", default="10"))
-
 
 class ExampleApplicationTestCase(TestCase):
-    timeit_number: ClassVar[int] = TIMEIT_FACTOR
     started_ats: ClassVar[dict[type[TestCase], datetime]] = {}
     counts: ClassVar[dict[type[TestCase], int]] = {}
     expected_factory_topic: str
@@ -76,7 +70,7 @@ class ExampleApplicationTestCase(TestCase):
             Decimal("65.00"),
         )
 
-        sleep(1)  # Added to make eventsourcing-axon tests work, perhaps not necessary.
+        # sleep(1)  # Added to make eventsourcing-axon tests work.
         section = app.notification_log["1,10"]
         self.assertEqual(len(section.items), 4)
 
@@ -108,83 +102,6 @@ class ExampleApplicationTestCase(TestCase):
         self.assertEqual(from_snapshot2.version, Aggregate.INITIAL_VERSION + 3)
         self.assertEqual(from_snapshot2.balance, Decimal("65.00"))
 
-    def test__put_performance(self) -> None:
-        app = BankAccounts()
-
-        # Open an account.
-        account_id = app.open_account(
-            full_name="Alice",
-            email_address="alice@example.com",
-        )
-        account = app.get_account(account_id)
-
-        def put() -> None:
-            # Credit the account.
-            account.append_transaction(Decimal("10.00"))
-            app.save(account)
-
-        # Warm up.
-        number = 10
-        timeit(put, number=number)
-
-        duration = timeit(put, number=self.timeit_number)
-        self.print_time("store events", duration)
-
-    def test__get_performance_with_snapshotting_enabled(self) -> None:
-        print()
-        self._test_get_performance(is_snapshotting_enabled=True)
-
-    def test__get_performance_without_snapshotting_enabled(self) -> None:
-        self._test_get_performance(is_snapshotting_enabled=False)
-
-    def _test_get_performance(self, *, is_snapshotting_enabled: bool) -> None:
-        app = BankAccounts(
-            env={"IS_SNAPSHOTTING_ENABLED": "y" if is_snapshotting_enabled else "n"}
-        )
-
-        # Open an account.
-        account_id = app.open_account(
-            full_name="Alice",
-            email_address="alice@example.com",
-        )
-
-        def read() -> None:
-            # Get the account.
-            app.get_account(account_id)
-
-        # Warm up.
-        timeit(read, number=10)
-
-        duration = timeit(read, number=self.timeit_number)
-
-        if is_snapshotting_enabled:
-            test_label = "get with snapshotting"
-        else:
-            test_label = "get without snapshotting"
-        self.print_time(test_label, duration)
-
-    def print_time(self, test_label: str, duration: float) -> None:
-        cls = type(self)
-        if cls not in self.started_ats:
-            self.started_ats[cls] = datetime_now_with_tzinfo()
-            print(f"{cls.__name__: <29} timeit number: {cls.timeit_number}")
-            self.counts[cls] = 1
-        else:
-            self.counts[cls] += 1
-
-        rate = f"{self.timeit_number / duration:.0f} events/s"
-        print(
-            f"{cls.__name__: <29}",
-            f"{test_label: <21}",
-            f"{rate: >15}",
-            f"  {1000 * duration / self.timeit_number:.3f} ms/event",
-        )
-
-        if self.counts[cls] == 3:
-            cls_duration = datetime_now_with_tzinfo() - cls.started_ats[cls]
-            print(f"{cls.__name__: <29} timeit duration: {cls_duration}")
-            sys.stdout.flush()
-
 
 class EmailAddressAsStr(Transcoding):
     type = EmailAddress
@@ -197,7 +114,7 @@ class EmailAddressAsStr(Transcoding):
         return EmailAddress(data)
 
 
-class BankAccounts(Application):
+class BankAccounts(Application[UUID]):
     is_snapshotting_enabled = True
 
     def register_transcodings(self, transcoder: JSONTranscoder) -> None:
@@ -238,19 +155,19 @@ class ApplicationTestCase(TestCase):
     def test_name(self) -> None:
         self.assertEqual(Application.name, "Application")
 
-        class MyApplication1(Application):
+        class MyApplication1(Application[UUID]):
             pass
 
         self.assertEqual(MyApplication1.name, "MyApplication1")
 
-        class MyApplication2(Application):
+        class MyApplication2(Application[UUID]):
             name = "MyBoundedContext"
 
         self.assertEqual(MyApplication2.name, "MyBoundedContext")
 
     def test_resolve_persistence_topics(self) -> None:
         # None specified.
-        app = Application()
+        app = Application[UUID]()
         self.assertIsInstance(app.factory, InfrastructureFactory)
 
         # Legacy 'INFRASTRUCTURE_FACTORY'.
@@ -286,7 +203,7 @@ class ApplicationTestCase(TestCase):
         )
 
     def test_save_returns_recording_event(self) -> None:
-        app = Application()
+        app = Application[UUID]()
 
         recordings = app.save()
         self.assertEqual(recordings, [])
@@ -310,7 +227,7 @@ class ApplicationTestCase(TestCase):
     def test_take_snapshot_raises_assertion_error_if_snapshotting_not_enabled(
         self,
     ) -> None:
-        app = Application()
+        app = Application[UUID]()
         with self.assertRaises(AssertionError) as cm:
             app.take_snapshot(uuid4())
         self.assertEqual(
@@ -323,7 +240,7 @@ class ApplicationTestCase(TestCase):
         )
 
     def test_application_with_cached_aggregates_and_fastforward(self) -> None:
-        app = Application(env={"AGGREGATE_CACHE_MAXSIZE": "10"})
+        app = Application[UUID](env={"AGGREGATE_CACHE_MAXSIZE": "10"})
 
         aggregate = Aggregate()
         app.save(aggregate)
@@ -362,7 +279,7 @@ class ApplicationTestCase(TestCase):
         )
 
     def _check_aggregate_fastforwarding_during_contention(self, env: EnvType) -> None:
-        app = Application(env=env)
+        app = Application[UUID](env=env)
 
         self.assertEqual(len(app.repository._fastforward_locks_inuse), 0)
 
@@ -474,7 +391,7 @@ class ApplicationTestCase(TestCase):
             app.close()
 
     def test_application_with_cached_aggregates_not_fastforward(self) -> None:
-        app = Application(
+        app = Application[UUID](
             env={
                 "AGGREGATE_CACHE_MAXSIZE": "10",
                 "AGGREGATE_CACHE_FASTFORWARD": "f",
@@ -513,7 +430,7 @@ class ApplicationTestCase(TestCase):
             app.save(aggregate4)
 
     def test_application_with_deepcopy_from_cache_arg(self) -> None:
-        app = Application(
+        app = Application[UUID](
             env={
                 "AGGREGATE_CACHE_MAXSIZE": "10",
             }
@@ -530,7 +447,7 @@ class ApplicationTestCase(TestCase):
         self.assertEqual(app.repository.cache.get(aggregate.id).version, 101)
 
     def test_application_with_deepcopy_from_cache_attribute(self) -> None:
-        app = Application(
+        app = Application[UUID](
             env={
                 "AGGREGATE_CACHE_MAXSIZE": "10",
             }
@@ -549,7 +466,7 @@ class ApplicationTestCase(TestCase):
 
     def test_application_log(self) -> None:
         # Check the old 'log' attribute presents the 'notification log' object.
-        app = Application()
+        app = Application[UUID]()
 
         # Verify deprecation warning.
         with warnings.catch_warnings(record=True) as w:

eventsourcing/tests/persistence.py

@@ -40,7 +40,7 @@ from eventsourcing.persistence import (
 from eventsourcing.utils import Environment, get_topic
 
 if TYPE_CHECKING:
-    from collections.abc import Iterator
+    from collections.abc import Iterator, Sequence
 
     from typing_extensions import Never
 
@@ -79,6 +79,7 @@ class AggregateRecorderTestCase(TestCase, ABC):
 
         # Select stored events, expect list of one.
         stored_events = recorder.select_events(originator_id1)
+        stored_events = convert_stored_event_originator_ids(stored_events)
         self.assertEqual(len(stored_events), 1)
         self.assertEqual(stored_events[0].originator_id, originator_id1)
         self.assertEqual(stored_events[0].originator_version, self.INITIAL_VERSION)
@@ -105,6 +106,7 @@ class AggregateRecorderTestCase(TestCase, ABC):
 
         # Check still only have one record.
         stored_events = recorder.select_events(originator_id1)
+        stored_events = convert_stored_event_originator_ids(stored_events)
         self.assertEqual(len(stored_events), 1)
         self.assertEqual(stored_events[0].originator_id, stored_event1.originator_id)
         self.assertEqual(
@@ -124,6 +126,7 @@ class AggregateRecorderTestCase(TestCase, ABC):
 
         # Check we got what was written.
         stored_events = recorder.select_events(originator_id1)
+        stored_events = convert_stored_event_originator_ids(stored_events)
         self.assertEqual(len(stored_events), 3)
         self.assertEqual(stored_events[0].originator_id, originator_id1)
         self.assertEqual(stored_events[0].originator_version, self.INITIAL_VERSION)
@@ -140,6 +143,7 @@ class AggregateRecorderTestCase(TestCase, ABC):
 
         # Check we can get the last one recorded (used to get last snapshot).
         stored_events = recorder.select_events(originator_id1, desc=True, limit=1)
+        stored_events = convert_stored_event_originator_ids(stored_events)
         self.assertEqual(len(stored_events), 1)
         self.assertEqual(
             stored_events[0],
@@ -150,6 +154,7 @@ class AggregateRecorderTestCase(TestCase, ABC):
         stored_events = recorder.select_events(
             originator_id1, lte=self.INITIAL_VERSION + 1, desc=True, limit=1
         )
+        stored_events = convert_stored_event_originator_ids(stored_events)
         self.assertEqual(len(stored_events), 1)
         self.assertEqual(
             stored_events[0],
@@ -157,12 +162,13 @@ class AggregateRecorderTestCase(TestCase, ABC):
         )
 
         # Check we can get events between versions (historical state with snapshot).
-        events = recorder.select_events(
+        stored_events = recorder.select_events(
             originator_id1, gt=self.INITIAL_VERSION, lte=self.INITIAL_VERSION + 1
         )
-        self.assertEqual(len(events), 1)
+        stored_events = convert_stored_event_originator_ids(stored_events)
+        self.assertEqual(len(stored_events), 1)
         self.assertEqual(
-            events[0],
+            stored_events[0],
             stored_event2,
         )
 
@@ -181,8 +187,10 @@ class AggregateRecorderTestCase(TestCase, ABC):
             state=b"state4",
         )
         recorder.insert_events([stored_event4])
+        stored_events = recorder.select_events(originator_id2)
+        stored_events = convert_stored_event_originator_ids(stored_events)
         self.assertEqual(
-            recorder.select_events(originator_id2),
+            stored_events,
             [stored_event4],
         )
 
@@ -219,6 +227,39 @@ _TApplicationRecorder = TypeVar(
 )
 
 
+def convert_notification_originator_ids(
+    notifications: Sequence[Notification],
+) -> Sequence[Notification]:
+    return [
+        Notification(
+            originator_id=convert_originator_id(n.originator_id),
+            originator_version=n.originator_version,
+            topic=n.topic,
+            state=n.state,
+            id=n.id,
+        )
+        for n in notifications
+    ]
+
+
+def convert_stored_event_originator_ids(
+    stored_events: Sequence[StoredEvent],
+) -> Sequence[StoredEvent]:
+    return [
+        StoredEvent(
+            originator_id=convert_originator_id(s.originator_id),
+            originator_version=s.originator_version,
+            topic=s.topic,
+            state=s.state,
+        )
+        for s in stored_events
+    ]
+
+
+def convert_originator_id(originator_id: UUID | str) -> UUID:
+    return originator_id if isinstance(originator_id, UUID) else UUID(originator_id)
+
+
 class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder]):
     INITIAL_VERSION = 1
     EXPECT_CONTIGUOUS_NOTIFICATION_IDS = True
@@ -281,8 +322,9 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         with self.assertRaises(IntegrityError):
             recorder.insert_events([stored_event3])
 
-        sleep(1)  # Added to make eventsourcing-axon tests work, perhaps not necessary.
+        # sleep(1)  # Added to make eventsourcing-axon tests work.
         notifications = recorder.select_notifications(start=None, limit=10)
+        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 3)
         self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
@@ -298,6 +340,7 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         self.assertEqual(notifications[2].state, b"state3")
 
         notifications = recorder.select_notifications(start=1, limit=10)
+        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 3)
         self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
@@ -313,6 +356,7 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         self.assertEqual(notifications[2].state, b"state3")
 
         notifications = recorder.select_notifications(start=None, stop=2, limit=10)
+        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 2)
         self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
@@ -326,6 +370,7 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         notifications = recorder.select_notifications(
             start=1, limit=10, inclusive_of_start=False
         )
+        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 2)
         self.assertEqual(notifications[0].id, 2)
         self.assertEqual(notifications[0].originator_id, originator_id1)
@@ -339,6 +384,7 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         notifications = recorder.select_notifications(
             start=2, limit=10, inclusive_of_start=False
         )
+        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1)
         self.assertEqual(notifications[0].id, 3)
         self.assertEqual(notifications[0].originator_id, originator_id2)
@@ -348,6 +394,7 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         notifications = recorder.select_notifications(
             start=None, limit=10, topics=["topic1", "topic2", "topic3"]
         )
+        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 3)
         self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
@@ -363,6 +410,7 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         self.assertEqual(notifications[2].state, b"state3")
 
         notifications = recorder.select_notifications(1, 10, topics=["topic1"])
+        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1)
         self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
@@ -370,6 +418,7 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         self.assertEqual(notifications[0].state, b"state1")
 
         notifications = recorder.select_notifications(1, 3, topics=["topic2"])
+        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1)
         self.assertEqual(notifications[0].id, 2)
         self.assertEqual(notifications[0].originator_id, originator_id1)
@@ -377,6 +426,7 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         self.assertEqual(notifications[0].state, b"state2")
 
         notifications = recorder.select_notifications(1, 3, topics=["topic3"])
+        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1)
         self.assertEqual(notifications[0].id, 3)
         self.assertEqual(notifications[0].originator_id, originator_id2)
@@ -384,6 +434,7 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         self.assertEqual(notifications[0].state, b"state3")
 
         notifications = recorder.select_notifications(1, 3, topics=["topic1", "topic3"])
+        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 2)
         self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
@@ -397,34 +448,42 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
 
         # Check limit is working
         notifications = recorder.select_notifications(None, 1)
+        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1)
         self.assertEqual(notifications[0].id, 1)
 
         notifications = recorder.select_notifications(2, 1)
+        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1)
         self.assertEqual(notifications[0].id, 2)
 
         notifications = recorder.select_notifications(1, 1, inclusive_of_start=False)
+        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1)
         self.assertEqual(notifications[0].id, 2)
 
         notifications = recorder.select_notifications(2, 2)
+        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 2)
         self.assertEqual(notifications[0].id, 2)
         self.assertEqual(notifications[1].id, 3)
 
         notifications = recorder.select_notifications(3, 1)
+        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1)
         self.assertEqual(notifications[0].id, 3)
 
         notifications = recorder.select_notifications(3, 1, inclusive_of_start=False)
+        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 0)
 
         notifications = recorder.select_notifications(start=2, limit=10, stop=2)
+        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1)
         self.assertEqual(notifications[0].id, 2)
 
         notifications = recorder.select_notifications(start=1, limit=10, stop=2)
+        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 2, len(notifications))
         self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[1].id, 2)
@@ -432,6 +491,7 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         notifications = recorder.select_notifications(
             start=1, limit=10, stop=2, inclusive_of_start=False
         )
+        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1, len(notifications))
         self.assertEqual(notifications[0].id, 2)
 
@@ -547,8 +607,8 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         errors_happened = Event()
 
         # Match this to the batch page size in postgres insert for max throughput.
-        num_events_per_job = 500
-        num_jobs = 60
+        num_events_per_job = 50
+        num_jobs = 10
         num_workers = 4
 
         def insert_events() -> None:
@@ -891,6 +951,13 @@ class ProcessRecorderTestCase(TestCase, ABC):
             tracking=tracking1,
         )
 
+        # Check get record conflict error if attempt to store same event again.
+        with self.assertRaises(IntegrityError):
+            recorder.insert_events(
+                stored_events=[stored_event2],
+                tracking=tracking2,
+            )
+
         # Get current position.
         self.assertEqual(
             recorder.max_tracking_id("upstream_app"),
@@ -1065,7 +1132,7 @@ class NonInterleavingNotificationIDsBaseCase(ABC, TestCase):
 
         errors = []
 
-        def insert_stack(stack: list[StoredEvent]) -> None:
+        def insert_stack(stack: Sequence[StoredEvent]) -> None:
             try:
                 race_started.wait()
                 recorder.insert_events(stack)
@@ -1086,12 +1153,13 @@ class NonInterleavingNotificationIDsBaseCase(ABC, TestCase):
         if errors:
             raise errors[0]
 
-        sleep(1)  # Added to make eventsourcing-axon tests work, perhaps not necessary.
+        # sleep(1)  # Added to make eventsourcing-axon tests work.
         notifications = recorder.select_notifications(
             start=max_notification_id,
             limit=2 * self.insert_num,
             inclusive_of_start=False,
         )
+        notifications = convert_notification_originator_ids(notifications)
         ids_for_sequence1 = [
             e.id for e in notifications if e.originator_id == originator1_id
         ]
@@ -1111,7 +1179,7 @@ class NonInterleavingNotificationIDsBaseCase(ABC, TestCase):
         else:
             self.assertGreater(min_id_for_sequence2, max_id_for_sequence1)
 
-    def create_stack(self, originator_id: UUID) -> list[StoredEvent]:
+    def create_stack(self, originator_id: UUID) -> Sequence[StoredEvent]:
         return [
             StoredEvent(
                 originator_id=originator_id,
@@ -1161,7 +1229,7 @@ class InfrastructureFactoryTestCase(ABC, TestCase, Generic[_TInfrastrutureFactor
 
     def setUp(self) -> None:
         self.factory = cast(
-            "_TInfrastrutureFactory", InfrastructureFactory.construct(self.env)
+            _TInfrastrutureFactory, InfrastructureFactory.construct(self.env)
         )
         self.assertIsInstance(self.factory, self.expected_factory_class())
         self.transcoder = JSONTranscoder()
@@ -1201,7 +1269,7 @@ class InfrastructureFactoryTestCase(ABC, TestCase, Generic[_TInfrastrutureFactor
 
         # Create mapper.
 
-        mapper = self.factory.mapper(
+        mapper: Mapper[UUID] = self.factory.mapper(
             transcoder=self.transcoder,
         )
         self.assertIsInstance(mapper, Mapper)
@@ -1211,7 +1279,7 @@ class InfrastructureFactoryTestCase(ABC, TestCase, Generic[_TInfrastrutureFactor
     def test_createmapper_with_compressor(self) -> None:
         # Create mapper with compressor class as topic.
         self.env[self.factory.COMPRESSOR_TOPIC] = get_topic(ZlibCompressor)
-        mapper = self.factory.mapper(transcoder=self.transcoder)
+        mapper: Mapper[UUID] = self.factory.mapper(transcoder=self.transcoder)
         self.assertIsInstance(mapper, Mapper)
         self.assertIsInstance(mapper.compressor, ZlibCompressor)
         self.assertIsNone(mapper.cipher)
@@ -1237,7 +1305,7 @@ class InfrastructureFactoryTestCase(ABC, TestCase, Generic[_TInfrastrutureFactor
         self.env[AESCipher.CIPHER_KEY] = cipher_key
 
         # Create mapper with cipher.
-        mapper = self.factory.mapper(transcoder=self.transcoder)
+        mapper: Mapper[UUID] = self.factory.mapper(transcoder=self.transcoder)
         self.assertIsInstance(mapper, Mapper)
         self.assertIsNotNone(mapper.cipher)
         self.assertIsNone(mapper.compressor)
@@ -1252,7 +1320,7 @@ class InfrastructureFactoryTestCase(ABC, TestCase, Generic[_TInfrastrutureFactor
         cipher_key = AESCipher.create_key(16)
         self.env[AESCipher.CIPHER_KEY] = cipher_key
 
-        mapper = self.factory.mapper(transcoder=self.transcoder)
+        mapper: Mapper[UUID] = self.factory.mapper(transcoder=self.transcoder)
         self.assertIsInstance(mapper, Mapper)
         self.assertIsNotNone(mapper.cipher)
         self.assertIsNotNone(mapper.compressor)
@@ -1265,7 +1333,7 @@ class InfrastructureFactoryTestCase(ABC, TestCase, Generic[_TInfrastrutureFactor
         self.env["APP1_" + AESCipher.CIPHER_KEY] = cipher_key1
         self.env["APP2_" + AESCipher.CIPHER_KEY] = cipher_key2
 
-        mapper1: Mapper = self.factory.mapper(
+        mapper1: Mapper[UUID] = self.factory.mapper(
             transcoder=self.transcoder,
         )
 
@@ -1279,7 +1347,7 @@ class InfrastructureFactoryTestCase(ABC, TestCase, Generic[_TInfrastrutureFactor
         self.assertEqual(domain_event.originator_id, copy.originator_id)
 
         self.env.name = "App2"
-        mapper2: Mapper = self.factory.mapper(
+        mapper2: Mapper[UUID] = self.factory.mapper(
             transcoder=self.transcoder,
         )
         # This should fail because the infrastructure factory

eventsourcing/tests/postgres_utils.py

@@ -1,3 +1,5 @@
+import os
+
 import psycopg
 from psycopg.sql import SQL, Identifier
 
@@ -42,10 +44,28 @@ def pg_close_all_connections(
     pg_conn_cursor.execute(close_all_connections)
 
 
-def drop_postgres_table(datastore: PostgresDatastore, table_name: str) -> None:
-    # print(f"Dropping table {datastore.schema}.{table_name}")
-    statement = SQL("DROP TABLE IF EXISTS {0}.{1}").format(
-        Identifier(datastore.schema), Identifier(table_name)
-    )
-    with datastore.transaction(commit=True) as curs:
-        curs.execute(statement, prepare=False)
+def drop_tables() -> None:
+
+    for schema in ["public", "myschema"]:
+        datastore = PostgresDatastore(
+            dbname=os.environ.get("POSTGRES_DBNAME", "eventsourcing"),
+            host=os.environ.get("POSTGRES_HOST", "127.0.0.1"),
+            port=os.environ.get("POSTGRES_PORT", "5432"),
+            user=os.environ.get("POSTGRES_USER", "eventsourcing"),
+            password=os.environ.get("POSTGRES_PASSWORD", "eventsourcing"),
+            schema=schema,
+        )
+        with datastore.transaction(commit=True) as curs:
+            select_table_names = SQL(
+                "SELECT table_name FROM information_schema.tables "
+                "WHERE table_schema = %s"
+            )
+            fetchall = curs.execute(select_table_names, (datastore.schema,)).fetchall()
+            for row in fetchall:
+                table_name = row["table_name"]
+                # print(f"Dropping table '{table_name}' in schema '{schema}'")
+                statement = SQL("DROP TABLE IF EXISTS {0}.{1}").format(
+                    Identifier(datastore.schema), Identifier(table_name)
+                )
+                curs.execute(statement, prepare=False)
+                # print(f"Dropped table '{table_name}' in schema '{schema}'")

eventsourcing/utils.py

@@ -35,7 +35,7 @@ def get_topic(obj: SupportsTopic, /) -> str:
     try:
         return _type_cache[obj]
     except KeyError:
-        topic = f"{obj.__module__}:{obj.__qualname__}"
+        topic = getattr(obj, "TOPIC", f"{obj.__module__}:{obj.__qualname__}")
         register_topic(topic, obj)
         _type_cache[obj] = topic
         return topic