eventsourcing 9.3.4__py3-none-any.whl → 9.4.0__py3-none-any.whl

eventsourcing/tests/persistence.py

@@ -1,22 +1,23 @@
 from __future__ import annotations
 
-import os
 import traceback
 import zlib
 from abc import ABC, abstractmethod
 from concurrent.futures import ThreadPoolExecutor
-from datetime import datetime
+from pathlib import Path
 from tempfile import NamedTemporaryFile
 from threading import Event, Thread, get_ident
 from time import sleep
 from timeit import timeit
-from typing import Any, Dict, List
+from typing import TYPE_CHECKING, Any, Generic, cast
 from unittest import TestCase
 from uuid import UUID, uuid4
 
+from typing_extensions import TypeVar
+
 from eventsourcing.cipher import AESCipher
 from eventsourcing.compressor import ZlibCompressor
-from eventsourcing.domain import DomainEvent
+from eventsourcing.domain import DomainEvent, datetime_now_with_tzinfo
 from eventsourcing.persistence import (
     AggregateRecorder,
     ApplicationRecorder,
@@ -26,14 +27,23 @@ from eventsourcing.persistence import (
     IntegrityError,
     JSONTranscoder,
     Mapper,
+    Notification,
     ProcessRecorder,
     StoredEvent,
     Tracking,
+    TrackingRecorder,
+    Transcoder,
     Transcoding,
     UUIDAsHex,
+    WaitInterruptedError,
 )
 from eventsourcing.utils import Environment, get_topic
 
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from typing_extensions import Never
+
 
 class AggregateRecorderTestCase(TestCase, ABC):
     INITIAL_VERSION = 1
@@ -204,37 +214,32 @@ class AggregateRecorderTestCase(TestCase, ABC):
         )
 
 
-class ApplicationRecorderTestCase(TestCase, ABC):
+_TApplicationRecorder = TypeVar(
+    "_TApplicationRecorder", bound=ApplicationRecorder, default=ApplicationRecorder
+)
+
+
+class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder]):
     INITIAL_VERSION = 1
+    EXPECT_CONTIGUOUS_NOTIFICATION_IDS = True
 
     @abstractmethod
-    def create_recorder(self) -> ApplicationRecorder:
+    def create_recorder(self) -> _TApplicationRecorder:
         """"""
 
     def test_insert_select(self) -> None:
         # Construct the recorder.
         recorder = self.create_recorder()
 
-        max_notification_id = recorder.max_notification_id()
-
         # Check notifications methods work when there aren't any.
+        self.assertEqual(len(recorder.select_notifications(start=None, limit=3)), 0)
         self.assertEqual(
-            recorder.max_notification_id(),
-            max_notification_id,
-        )
-        self.assertEqual(
-            len(recorder.select_notifications(max_notification_id + 1, 3)),
-            0,
-        )
-        self.assertEqual(
-            len(
-                recorder.select_notifications(
-                    max_notification_id + 1, 3, topics=["topic1"]
-                )
-            ),
+            len(recorder.select_notifications(start=None, limit=3, topics=["topic1"])),
             0,
         )
 
+        self.assertIsNone(recorder.max_notification_id())
+
         # Write two stored events.
         originator_id1 = uuid4()
         originator_id2 = uuid4()
@@ -253,9 +258,7 @@ class ApplicationRecorderTestCase(TestCase, ABC):
         )
 
         notification_ids = recorder.insert_events([stored_event1, stored_event2])
-        self.assertEqual(
-            notification_ids, [max_notification_id + 1, max_notification_id + 2]
-        )
+        self.assertEqual(notification_ids, [1, 2])
 
         # Store a third event.
         stored_event3 = StoredEvent(
@@ -265,7 +268,7 @@ class ApplicationRecorderTestCase(TestCase, ABC):
             state=b"state3",
         )
         notification_ids = recorder.insert_events([stored_event3])
-        self.assertEqual(notification_ids, [max_notification_id + 3])
+        self.assertEqual(notification_ids, [3])
 
         stored_events1 = recorder.select_events(originator_id1)
         stored_events2 = recorder.select_events(originator_id2)
@@ -279,111 +282,158 @@ class ApplicationRecorderTestCase(TestCase, ABC):
             recorder.insert_events([stored_event3])
 
         sleep(1)  # Added to make eventsourcing-axon tests work, perhaps not necessary.
-        notifications = recorder.select_notifications(max_notification_id + 1, 3)
+        notifications = recorder.select_notifications(start=None, limit=10)
         self.assertEqual(len(notifications), 3)
-        self.assertEqual(notifications[0].id, max_notification_id + 1)
+        self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
         self.assertEqual(notifications[0].topic, "topic1")
         self.assertEqual(notifications[0].state, b"state1")
-        self.assertEqual(notifications[1].id, max_notification_id + 2)
+        self.assertEqual(notifications[1].id, 2)
         self.assertEqual(notifications[1].originator_id, originator_id1)
         self.assertEqual(notifications[1].topic, "topic2")
         self.assertEqual(notifications[1].state, b"state2")
-        self.assertEqual(notifications[2].id, max_notification_id + 3)
+        self.assertEqual(notifications[2].id, 3)
         self.assertEqual(notifications[2].originator_id, originator_id2)
         self.assertEqual(notifications[2].topic, "topic3")
         self.assertEqual(notifications[2].state, b"state3")
 
-        notifications = recorder.select_notifications(
-            max_notification_id + 1, 3, topics=["topic1", "topic2", "topic3"]
-        )
+        notifications = recorder.select_notifications(start=1, limit=10)
         self.assertEqual(len(notifications), 3)
-        self.assertEqual(notifications[0].id, max_notification_id + 1)
+        self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
         self.assertEqual(notifications[0].topic, "topic1")
         self.assertEqual(notifications[0].state, b"state1")
-        self.assertEqual(notifications[1].id, max_notification_id + 2)
+        self.assertEqual(notifications[1].id, 2)
         self.assertEqual(notifications[1].originator_id, originator_id1)
         self.assertEqual(notifications[1].topic, "topic2")
         self.assertEqual(notifications[1].state, b"state2")
-        self.assertEqual(notifications[2].id, max_notification_id + 3)
+        self.assertEqual(notifications[2].id, 3)
         self.assertEqual(notifications[2].originator_id, originator_id2)
         self.assertEqual(notifications[2].topic, "topic3")
         self.assertEqual(notifications[2].state, b"state3")
 
-        notifications = recorder.select_notifications(
-            max_notification_id + 1, 3, topics=["topic1"]
-        )
-        self.assertEqual(len(notifications), 1)
-        self.assertEqual(notifications[0].id, max_notification_id + 1)
+        notifications = recorder.select_notifications(start=None, stop=2, limit=10)
+        self.assertEqual(len(notifications), 2)
+        self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
         self.assertEqual(notifications[0].topic, "topic1")
         self.assertEqual(notifications[0].state, b"state1")
+        self.assertEqual(notifications[1].id, 2)
+        self.assertEqual(notifications[1].originator_id, originator_id1)
+        self.assertEqual(notifications[1].topic, "topic2")
+        self.assertEqual(notifications[1].state, b"state2")
 
         notifications = recorder.select_notifications(
-            max_notification_id + 1, 3, topics=["topic2"]
+            start=1, limit=10, inclusive_of_start=False
         )
-        self.assertEqual(len(notifications), 1)
-        self.assertEqual(notifications[0].id, max_notification_id + 2)
+        self.assertEqual(len(notifications), 2)
+        self.assertEqual(notifications[0].id, 2)
         self.assertEqual(notifications[0].originator_id, originator_id1)
         self.assertEqual(notifications[0].topic, "topic2")
         self.assertEqual(notifications[0].state, b"state2")
+        self.assertEqual(notifications[1].id, 3)
+        self.assertEqual(notifications[1].originator_id, originator_id2)
+        self.assertEqual(notifications[1].topic, "topic3")
+        self.assertEqual(notifications[1].state, b"state3")
 
         notifications = recorder.select_notifications(
-            max_notification_id + 1, 3, topics=["topic3"]
+            start=2, limit=10, inclusive_of_start=False
         )
         self.assertEqual(len(notifications), 1)
-        self.assertEqual(notifications[0].id, max_notification_id + 3)
+        self.assertEqual(notifications[0].id, 3)
         self.assertEqual(notifications[0].originator_id, originator_id2)
         self.assertEqual(notifications[0].topic, "topic3")
         self.assertEqual(notifications[0].state, b"state3")
 
         notifications = recorder.select_notifications(
-            max_notification_id + 1, 3, topics=["topic1", "topic3"]
+            start=None, limit=10, topics=["topic1", "topic2", "topic3"]
         )
+        self.assertEqual(len(notifications), 3)
+        self.assertEqual(notifications[0].id, 1)
+        self.assertEqual(notifications[0].originator_id, originator_id1)
+        self.assertEqual(notifications[0].topic, "topic1")
+        self.assertEqual(notifications[0].state, b"state1")
+        self.assertEqual(notifications[1].id, 2)
+        self.assertEqual(notifications[1].originator_id, originator_id1)
+        self.assertEqual(notifications[1].topic, "topic2")
+        self.assertEqual(notifications[1].state, b"state2")
+        self.assertEqual(notifications[2].id, 3)
+        self.assertEqual(notifications[2].originator_id, originator_id2)
+        self.assertEqual(notifications[2].topic, "topic3")
+        self.assertEqual(notifications[2].state, b"state3")
+
+        notifications = recorder.select_notifications(1, 10, topics=["topic1"])
+        self.assertEqual(len(notifications), 1)
+        self.assertEqual(notifications[0].id, 1)
+        self.assertEqual(notifications[0].originator_id, originator_id1)
+        self.assertEqual(notifications[0].topic, "topic1")
+        self.assertEqual(notifications[0].state, b"state1")
+
+        notifications = recorder.select_notifications(1, 3, topics=["topic2"])
+        self.assertEqual(len(notifications), 1)
+        self.assertEqual(notifications[0].id, 2)
+        self.assertEqual(notifications[0].originator_id, originator_id1)
+        self.assertEqual(notifications[0].topic, "topic2")
+        self.assertEqual(notifications[0].state, b"state2")
+
+        notifications = recorder.select_notifications(1, 3, topics=["topic3"])
+        self.assertEqual(len(notifications), 1)
+        self.assertEqual(notifications[0].id, 3)
+        self.assertEqual(notifications[0].originator_id, originator_id2)
+        self.assertEqual(notifications[0].topic, "topic3")
+        self.assertEqual(notifications[0].state, b"state3")
+
+        notifications = recorder.select_notifications(1, 3, topics=["topic1", "topic3"])
         self.assertEqual(len(notifications), 2)
-        self.assertEqual(notifications[0].id, max_notification_id + 1)
+        self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
         self.assertEqual(notifications[0].topic, "topic1")
         self.assertEqual(notifications[0].state, b"state1")
-        self.assertEqual(notifications[1].id, max_notification_id + 3)
+        self.assertEqual(notifications[1].id, 3)
         self.assertEqual(notifications[1].topic, "topic3")
         self.assertEqual(notifications[1].state, b"state3")
 
-        self.assertEqual(
-            recorder.max_notification_id(),
-            max_notification_id + 3,
-        )
+        self.assertEqual(recorder.max_notification_id(), 3)
 
-        notifications = recorder.select_notifications(max_notification_id + 1, 1)
+        # Check limit is working
+        notifications = recorder.select_notifications(None, 1)
         self.assertEqual(len(notifications), 1)
-        self.assertEqual(notifications[0].id, max_notification_id + 1)
+        self.assertEqual(notifications[0].id, 1)
 
-        notifications = recorder.select_notifications(max_notification_id + 2, 1)
+        notifications = recorder.select_notifications(2, 1)
         self.assertEqual(len(notifications), 1)
-        self.assertEqual(notifications[0].id, max_notification_id + 2)
+        self.assertEqual(notifications[0].id, 2)
 
-        notifications = recorder.select_notifications(max_notification_id + 2, 2)
+        notifications = recorder.select_notifications(1, 1, inclusive_of_start=False)
+        self.assertEqual(len(notifications), 1)
+        self.assertEqual(notifications[0].id, 2)
+
+        notifications = recorder.select_notifications(2, 2)
         self.assertEqual(len(notifications), 2)
-        self.assertEqual(notifications[0].id, max_notification_id + 2)
-        self.assertEqual(notifications[1].id, max_notification_id + 3)
+        self.assertEqual(notifications[0].id, 2)
+        self.assertEqual(notifications[1].id, 3)
 
-        notifications = recorder.select_notifications(max_notification_id + 3, 1)
+        notifications = recorder.select_notifications(3, 1)
         self.assertEqual(len(notifications), 1)
-        self.assertEqual(notifications[0].id, max_notification_id + 3)
+        self.assertEqual(notifications[0].id, 3)
 
-        notifications = recorder.select_notifications(
-            start=max_notification_id + 2, limit=10, stop=max_notification_id + 2
-        )
+        notifications = recorder.select_notifications(3, 1, inclusive_of_start=False)
+        self.assertEqual(len(notifications), 0)
+
+        notifications = recorder.select_notifications(start=2, limit=10, stop=2)
         self.assertEqual(len(notifications), 1)
-        self.assertEqual(notifications[0].id, max_notification_id + 2)
+        self.assertEqual(notifications[0].id, 2)
+
+        notifications = recorder.select_notifications(start=1, limit=10, stop=2)
+        self.assertEqual(len(notifications), 2, len(notifications))
+        self.assertEqual(notifications[0].id, 1)
+        self.assertEqual(notifications[1].id, 2)
 
         notifications = recorder.select_notifications(
-            start=max_notification_id + 1, limit=10, stop=max_notification_id + 2
+            start=1, limit=10, stop=2, inclusive_of_start=False
         )
-        self.assertEqual(len(notifications), 2, len(notifications))
-        self.assertEqual(notifications[0].id, max_notification_id + 1)
-        self.assertEqual(notifications[1].id, max_notification_id + 2)
+        self.assertEqual(len(notifications), 1, len(notifications))
+        self.assertEqual(notifications[0].id, 2)
 
     def test_concurrent_no_conflicts(self) -> None:
         print(self)
@@ -391,17 +441,17 @@ class ApplicationRecorderTestCase(TestCase, ABC):
         recorder = self.create_recorder()
 
         errors_happened = Event()
-        errors: List[Exception] = []
+        errors: list[Exception] = []
 
         counts = {}
-        threads: Dict[int, int] = {}
-        durations: Dict[int, float] = {}
+        threads: dict[int, int] = {}
+        durations: dict[int, float] = {}
 
         num_writers = 10
         num_writes_per_writer = 100
         num_events_per_write = 100
-        reader_sleep = 0.0
-        writer_sleep = 0.0
+        reader_sleep = 0.0001
+        writer_sleep = 0.0001
 
         def insert_events() -> None:
             thread_id = get_ident()
@@ -425,24 +475,23 @@ class ApplicationRecorderTestCase(TestCase, ABC):
                 )
                 for i in range(num_events_per_write)
             ]
-            started = datetime.now()
+            started = datetime_now_with_tzinfo()
             # print(f"Thread {thread_num} write beginning #{count + 1}")
             try:
                 recorder.insert_events(stored_events)
 
-            except Exception as e:  # pragma: nocover
+            except Exception as e:  # pragma: no cover
                 if errors:
                     return
-                ended = datetime.now()
+                ended = datetime_now_with_tzinfo()
                 duration = (ended - started).total_seconds()
                 print(f"Error after starting {duration}", e)
                 errors.append(e)
             else:
-                ended = datetime.now()
+                ended = datetime_now_with_tzinfo()
                 duration = (ended - started).total_seconds()
                 counts[thread_id] += 1
-                if duration > durations[thread_id]:
-                    durations[thread_id] = duration
+                durations[thread_id] = max(durations[thread_id], duration)
                 sleep(writer_sleep)
 
         stop_reading = Event()
@@ -451,7 +500,7 @@ class ApplicationRecorderTestCase(TestCase, ABC):
             while not stop_reading.is_set():
                 try:
                     recorder.select_notifications(0, 10)
-                except Exception as e:  # pragma: nocover
+                except Exception as e:  # pragma: no cover
                     errors.append(e)
                     return
                 # else:
@@ -466,22 +515,22 @@ class ApplicationRecorderTestCase(TestCase, ABC):
         with ThreadPoolExecutor(max_workers=num_writers) as executor:
             futures = []
             for _ in range(num_writes_per_writer):
-                if errors:  # pragma: nocover
+                if errors:  # pragma: no cover
                     break
                 future = executor.submit(insert_events)
                 futures.append(future)
             for future in futures:
-                if errors:  # pragma: nocover
+                if errors:  # pragma: no cover
                     break
                 try:
                     future.result()
-                except Exception as e:  # pragma: nocover
+                except Exception as e:  # pragma: no cover
                     errors.append(e)
                     break
 
         stop_reading.set()
 
-        if errors:  # pragma: nocover
+        if errors:  # pragma: no cover
             raise errors[0]
 
         for thread_id, thread_num in threads.items():
@@ -497,24 +546,12 @@ class ApplicationRecorderTestCase(TestCase, ABC):
 
         errors_happened = Event()
 
-        counts = {}
-        threads: Dict[int, int] = {}
-        durations: Dict[int, float] = {}
-
         # Match this to the batch page size in postgres insert for max throughput.
-        num_events = 500
-
-        started = datetime.now()
+        num_events_per_job = 500
+        num_jobs = 60
+        num_workers = 4
 
         def insert_events() -> None:
-            thread_id = get_ident()
-            if thread_id not in threads:
-                threads[thread_id] = len(threads)
-            if thread_id not in counts:
-                counts[thread_id] = 0
-            if thread_id not in durations:
-                durations[thread_id] = 0
-
             originator_id = uuid4()
             stored_events = [
                 StoredEvent(
@@ -523,42 +560,256 @@ class ApplicationRecorderTestCase(TestCase, ABC):
                     topic="topic",
                     state=b"state",
                 )
-                for i in range(num_events)
+                for i in range(num_events_per_job)
             ]
 
             try:
                 recorder.insert_events(stored_events)
 
-            except Exception:  # pragma: nocover
+            except Exception:  # pragma: no cover
                 errors_happened.set()
                 tb = traceback.format_exc()
                 print(tb)
-            finally:
-                ended = datetime.now()
-                duration = (ended - started).total_seconds()
-                counts[thread_id] += 1
-                durations[thread_id] = duration
 
-        num_jobs = 60
+        # Warm up.
+        with ThreadPoolExecutor(max_workers=num_workers) as executor:
+            futures = []
+            for _ in range(num_workers):
+                future = executor.submit(insert_events)
+                futures.append(future)
+            for future in futures:
+                future.result()
 
-        with ThreadPoolExecutor(max_workers=4) as executor:
+        # Run.
+        with ThreadPoolExecutor(max_workers=num_workers) as executor:
+            started = datetime_now_with_tzinfo()
             futures = []
             for _ in range(num_jobs):
                 future = executor.submit(insert_events)
-                # future.add_done_callback(self.close_db_connection)
                 futures.append(future)
             for future in futures:
                 future.result()
 
         self.assertFalse(errors_happened.is_set(), "There were errors (see above)")
-        ended = datetime.now()
-        rate = num_jobs * num_events / (ended - started).total_seconds()
+        ended = datetime_now_with_tzinfo()
+        rate = num_jobs * num_events_per_job / (ended - started).total_seconds()
         print(f"Rate: {rate:.0f} inserts per second")
 
+    def optional_test_insert_subscribe(self) -> None:
+
+        recorder = self.create_recorder()
+
+        # Get the max notification ID.
+        max_notification_id1 = recorder.max_notification_id()
+
+        # Write two stored events.
+        originator_id1 = uuid4()
+        originator_id2 = uuid4()
+
+        stored_event1 = StoredEvent(
+            originator_id=originator_id1,
+            originator_version=self.INITIAL_VERSION,
+            topic="topic1",
+            state=b"state1",
+        )
+        stored_event2 = StoredEvent(
+            originator_id=originator_id1,
+            originator_version=self.INITIAL_VERSION + 1,
+            topic="topic2",
+            state=b"state2",
+        )
+
+        notification_ids = recorder.insert_events([stored_event1, stored_event2])
+        if self.EXPECT_CONTIGUOUS_NOTIFICATION_IDS:
+            self.assertEqual(notification_ids, [1, 2])
+
+        # Get the max notification ID.
+        max_notification_id2 = recorder.max_notification_id()
+
+        # Start a subscription with default value for 'start'.
+        with recorder.subscribe() as subscription:
+
+            # Receive events from the subscription.
+            for _ in subscription:
+                break
+
+        # Start a subscription with None value for 'start'.
+        with recorder.subscribe(gt=None) as subscription:
+
+            # Receive events from the subscription.
+            for _ in subscription:
+                break
+
+        # Start a subscription with int value for 'start'.
+        with recorder.subscribe(gt=max_notification_id1) as subscription:
+
+            # Receive events from the subscription.
+            notifications: list[Notification] = []
+            for notification in subscription:
+                notifications.append(notification)
+                if len(notifications) == 2:
+                    break
+
+            # Check the events we received are the ones that were written.
+            self.assertEqual(
+                stored_event1.originator_id, notifications[0].originator_id
+            )
+            self.assertEqual(
+                stored_event1.originator_version, notifications[0].originator_version
+            )
+            self.assertEqual(
+                stored_event2.originator_id, notifications[1].originator_id
+            )
+            self.assertEqual(
+                stored_event2.originator_version, notifications[1].originator_version
+            )
+            if self.EXPECT_CONTIGUOUS_NOTIFICATION_IDS:
+                self.assertEqual(1, notifications[0].id)
+                self.assertEqual(2, notifications[1].id)
+
+            # Store a third event.
+            stored_event3 = StoredEvent(
+                originator_id=originator_id2,
+                originator_version=self.INITIAL_VERSION,
+                topic="topic3",
+                state=b"state3",
+            )
+            notification_ids = recorder.insert_events([stored_event3])
+            if self.EXPECT_CONTIGUOUS_NOTIFICATION_IDS:
+                self.assertEqual(notification_ids, [3])
+
+            # Receive events from the subscription.
+            for notification in subscription:
+                notifications.append(notification)
+                if len(notifications) == 3:
+                    break
+
+            # Check the events we received are the ones that were written.
+            self.assertEqual(
+                stored_event3.originator_id, notifications[2].originator_id
+            )
+            self.assertEqual(
+                stored_event3.originator_version, notifications[2].originator_version
+            )
+            if self.EXPECT_CONTIGUOUS_NOTIFICATION_IDS:
+                self.assertEqual(3, notifications[2].id)
+
+        # Start a subscription with int value for 'start'.
+        with recorder.subscribe(gt=max_notification_id2) as subscription:
+
+            # Receive events from the subscription.
+            notifications = []
+            for notification in subscription:
+                notifications.append(notification)
+                if len(notifications) == 1:
+                    break
+
+            # Check the events we received are the ones that were written.
+            self.assertEqual(
+                stored_event3.originator_id, notifications[0].originator_id
+            )
+
+        # Start a subscription, call stop() during iteration.
+        with recorder.subscribe(gt=None) as subscription:
+
+            # Receive events from the subscription.
+            for i, _ in enumerate(subscription):
+                subscription.stop()
+                # Shouldn't get here twice...
+                self.assertLess(i, 1, "Got here twice")
+
+        # Start a subscription, call stop() before iteration.
+        subscription = recorder.subscribe(gt=None)
+        with subscription:
+            subscription.stop()
+            # Receive events from the subscription.
+            for _ in subscription:
+                # Shouldn't get here...
+                self.fail("Got here")
+
+        # Start a subscription, call stop() before entering context manager.
+        subscription = recorder.subscribe(gt=None)
+        subscription.stop()
+        with subscription:
+            # Receive events from the subscription.
+            for _ in subscription:
+                # Shouldn't get here...
+                self.fail("Got here")
+
+        # Start a subscription with topics.
+        subscription = recorder.subscribe(gt=None, topics=["topic3"])
+        with subscription:
+            for notification in subscription:
+                self.assertEqual(notification.topic, "topic3")
+                if (
+                    notification.originator_id == stored_event3.originator_id
+                    and notification.originator_version
+                    == stored_event3.originator_version
+                ):
+                    break
+
     def close_db_connection(self, *args: Any) -> None:
         """"""
 
 
+class TrackingRecorderTestCase(TestCase, ABC):
+    @abstractmethod
+    def create_recorder(self) -> TrackingRecorder:
+        """"""
+
+    def test_insert_tracking(self) -> None:
+        tracking_recorder = self.create_recorder()
+
+        # Construct tracking objects.
+        tracking1 = Tracking(notification_id=21, application_name="upstream1")
+        tracking2 = Tracking(notification_id=22, application_name="upstream1")
+        tracking3 = Tracking(notification_id=21, application_name="upstream2")
+
+        # Insert tracking objects.
+        tracking_recorder.insert_tracking(tracking=tracking1)
+        tracking_recorder.insert_tracking(tracking=tracking2)
+        tracking_recorder.insert_tracking(tracking=tracking3)
+
+        # Fail to insert same tracking object twice.
+        with self.assertRaises(IntegrityError):
+            tracking_recorder.insert_tracking(tracking=tracking1)
+        with self.assertRaises(IntegrityError):
+            tracking_recorder.insert_tracking(tracking=tracking2)
+        with self.assertRaises(IntegrityError):
+            tracking_recorder.insert_tracking(tracking=tracking3)
+
+        # Get latest tracked position.
+        self.assertEqual(tracking_recorder.max_tracking_id("upstream1"), 22)
+        self.assertEqual(tracking_recorder.max_tracking_id("upstream2"), 21)
+        self.assertIsNone(tracking_recorder.max_tracking_id("upstream3"))
+
+        # Check if an event notification has been processed.
+        assert tracking_recorder.has_tracking_id("upstream1", 21)
+        assert tracking_recorder.has_tracking_id("upstream1", 22)
+        assert tracking_recorder.has_tracking_id("upstream2", 21)
+        assert not tracking_recorder.has_tracking_id("upstream2", 22)
+
+    def test_wait(self) -> None:
+        tracking_recorder = self.create_recorder()
+
+        tracking_recorder.wait("upstream1", None)
+
+        with self.assertRaises(TimeoutError):
+            tracking_recorder.wait("upstream1", 21, timeout=0.1)
+
+        tracking1 = Tracking(notification_id=21, application_name="upstream1")
+        tracking_recorder.insert_tracking(tracking=tracking1)
+        tracking_recorder.wait("upstream1", None)
+        tracking_recorder.wait("upstream1", 10)
+        tracking_recorder.wait("upstream1", 21)
+        with self.assertRaises(TimeoutError):
+            tracking_recorder.wait("upstream1", 22, timeout=0.1)
+        with self.assertRaises(WaitInterruptedError):
+            interrupt = Event()
+            interrupt.set()
+            tracking_recorder.wait("upstream1", 22, interrupt=interrupt)
+
+
 class ProcessRecorderTestCase(TestCase, ABC):
     @abstractmethod
     def create_recorder(self) -> ProcessRecorder:
@@ -569,10 +820,7 @@ class ProcessRecorderTestCase(TestCase, ABC):
         recorder = self.create_recorder()
 
         # Get current position.
-        self.assertEqual(
-            recorder.max_tracking_id("upstream_app"),
-            0,
-        )
+        self.assertIsNone(recorder.max_tracking_id("upstream_app"))
 
         # Write two stored events.
         originator_id1 = uuid4()
@@ -662,10 +910,11 @@ class ProcessRecorderTestCase(TestCase, ABC):
             2,
         )
 
-    def test_has_tracking_id(self):
+    def test_has_tracking_id(self) -> None:
         # Construct the recorder.
         recorder = self.create_recorder()
 
+        self.assertTrue(recorder.has_tracking_id("upstream_app", None))
         self.assertFalse(recorder.has_tracking_id("upstream_app", 1))
         self.assertFalse(recorder.has_tracking_id("upstream_app", 2))
         self.assertFalse(recorder.has_tracking_id("upstream_app", 3))
@@ -737,7 +986,7 @@ class ProcessRecorderTestCase(TestCase, ABC):
 class NonInterleavingNotificationIDsBaseCase(ABC, TestCase):
     insert_num = 1000
 
-    def test(self):
+    def test(self) -> None:
         recorder = self.create_recorder()
 
         max_notification_id = recorder.max_notification_id()
@@ -752,7 +1001,7 @@ class NonInterleavingNotificationIDsBaseCase(ABC, TestCase):
 
         errors = []
 
-        def insert_stack(stack):
+        def insert_stack(stack: list[StoredEvent]) -> None:
             try:
                 race_started.wait()
                 recorder.insert_events(stack)
@@ -775,7 +1024,9 @@ class NonInterleavingNotificationIDsBaseCase(ABC, TestCase):
 
         sleep(1)  # Added to make eventsourcing-axon tests work, perhaps not necessary.
         notifications = recorder.select_notifications(
-            start=max_notification_id + 1, limit=2 * self.insert_num
+            start=max_notification_id,
+            limit=2 * self.insert_num,
+            inclusive_of_start=False,
         )
         ids_for_sequence1 = [
             e.id for e in notifications if e.originator_id == originator1_id
@@ -796,7 +1047,7 @@ class NonInterleavingNotificationIDsBaseCase(ABC, TestCase):
         else:
             self.assertGreater(min_id_for_sequence2, max_id_for_sequence1)
 
-    def create_stack(self, originator_id):
+    def create_stack(self, originator_id: UUID) -> list[StoredEvent]:
         return [
             StoredEvent(
                 originator_id=originator_id,
@@ -812,37 +1063,52 @@ class NonInterleavingNotificationIDsBaseCase(ABC, TestCase):
         pass
 
 
-class InfrastructureFactoryTestCase(ABC, TestCase):
-    env: Environment | None = None
+_TInfrastrutureFactory = TypeVar(
+    "_TInfrastrutureFactory", bound=InfrastructureFactory[Any]
+)
+
+
+class InfrastructureFactoryTestCase(ABC, TestCase, Generic[_TInfrastrutureFactory]):
+    env: Environment
+
+    @abstractmethod
+    def expected_factory_class(self) -> type[_TInfrastrutureFactory]:
+        pass
+
+    @abstractmethod
+    def expected_aggregate_recorder_class(self) -> type[AggregateRecorder]:
+        pass
 
     @abstractmethod
-    def expected_factory_class(self):
+    def expected_application_recorder_class(self) -> type[ApplicationRecorder]:
         pass
 
     @abstractmethod
-    def expected_aggregate_recorder_class(self):
+    def expected_tracking_recorder_class(self) -> type[TrackingRecorder]:
         pass
 
     @abstractmethod
-    def expected_application_recorder_class(self):
+    def tracking_recorder_subclass(self) -> type[TrackingRecorder]:
         pass
 
     @abstractmethod
-    def expected_process_recorder_class(self):
+    def expected_process_recorder_class(self) -> type[ProcessRecorder]:
         pass
 
     def setUp(self) -> None:
-        self.factory = InfrastructureFactory.construct(self.env)
+        self.factory = cast(
+            "_TInfrastrutureFactory", InfrastructureFactory.construct(self.env)
+        )
         self.assertIsInstance(self.factory, self.expected_factory_class())
         self.transcoder = JSONTranscoder()
         self.transcoder.register(UUIDAsHex())
         self.transcoder.register(DecimalAsStr())
         self.transcoder.register(DatetimeAsISO())
 
-    def tearDown(self):
+    def tearDown(self) -> None:
         self.factory.close()
 
-    def test_createmapper(self):
+    def test_createmapper(self) -> None:
         # Want to construct:
         #  - application recorder
         #  - snapshot recorder
@@ -878,7 +1144,7 @@ class InfrastructureFactoryTestCase(ABC, TestCase):
         self.assertIsNone(mapper.cipher)
         self.assertIsNone(mapper.compressor)
 
-    def test_createmapper_with_compressor(self):
+    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)
@@ -893,7 +1159,7 @@ class InfrastructureFactoryTestCase(ABC, TestCase):
         self.assertEqual(mapper.compressor, zlib)
         self.assertIsNone(mapper.cipher)
 
-    def test_createmapper_with_cipher(self):
+    def test_createmapper_with_cipher(self) -> None:
         # Check cipher needs a key.
         self.env[self.factory.CIPHER_TOPIC] = get_topic(AESCipher)
 
@@ -914,7 +1180,7 @@ class InfrastructureFactoryTestCase(ABC, TestCase):
 
     def test_createmapper_with_cipher_and_compressor(
         self,
-    ):
+    ) -> None:
         # Create mapper with cipher and compressor.
         self.env[self.factory.COMPRESSOR_TOPIC] = get_topic(ZlibCompressor)
 
@@ -927,7 +1193,7 @@ class InfrastructureFactoryTestCase(ABC, TestCase):
         self.assertIsNotNone(mapper.cipher)
         self.assertIsNotNone(mapper.compressor)
 
-    def test_mapper_with_wrong_cipher_key(self):
+    def test_mapper_with_wrong_cipher_key(self) -> None:
         self.env.name = "App1"
         self.env[self.factory.CIPHER_TOPIC] = get_topic(AESCipher)
         cipher_key1 = AESCipher.create_key(16)
@@ -957,7 +1223,7 @@ class InfrastructureFactoryTestCase(ABC, TestCase):
         with self.assertRaises(ValueError):
             mapper2.to_domain_event(stored_event)
 
-    def test_create_aggregate_recorder(self):
+    def test_create_aggregate_recorder(self) -> None:
         recorder = self.factory.aggregate_recorder()
         self.assertEqual(type(recorder), self.expected_aggregate_recorder_class())
 
@@ -968,7 +1234,7 @@ class InfrastructureFactoryTestCase(ABC, TestCase):
         recorder = self.factory.aggregate_recorder()
         self.assertEqual(type(recorder), self.expected_aggregate_recorder_class())
 
-    def test_create_application_recorder(self):
+    def test_create_application_recorder(self) -> None:
         recorder = self.factory.application_recorder()
         self.assertEqual(type(recorder), self.expected_application_recorder_class())
         self.assertIsInstance(recorder, ApplicationRecorder)
@@ -978,7 +1244,27 @@ class InfrastructureFactoryTestCase(ABC, TestCase):
         recorder = self.factory.application_recorder()
         self.assertEqual(type(recorder), self.expected_application_recorder_class())
 
-    def test_create_process_recorder(self):
+    def test_create_tracking_recorder(self) -> None:
+        recorder = self.factory.tracking_recorder()
+        self.assertEqual(type(recorder), self.expected_tracking_recorder_class())
+        self.assertIsInstance(recorder, TrackingRecorder)
+
+        # Exercise code path where table is not created.
+        self.env["CREATE_TABLE"] = "f"
+        recorder = self.factory.tracking_recorder()
+        self.assertEqual(type(recorder), self.expected_tracking_recorder_class())
+
+        # Exercise code path where tracking recorder class is specified as arg.
+        subclass = self.tracking_recorder_subclass()
+        recorder = self.factory.tracking_recorder(subclass)
+        self.assertEqual(type(recorder), subclass)
+
+        # Exercise code path where tracking recorder class is specified as topic.
+        self.factory.env[self.factory.TRACKING_RECORDER_TOPIC] = get_topic(subclass)
+        recorder = self.factory.tracking_recorder()
+        self.assertEqual(type(recorder), subclass)
+
+    def test_create_process_recorder(self) -> None:
         recorder = self.factory.process_recorder()
         self.assertEqual(type(recorder), self.expected_process_recorder_class())
         self.assertIsInstance(recorder, ProcessRecorder)
@@ -989,23 +1275,26 @@ class InfrastructureFactoryTestCase(ABC, TestCase):
         self.assertEqual(type(recorder), self.expected_process_recorder_class())
 
 
-def tmpfile_uris():
+def tmpfile_uris() -> Iterator[str]:
     tmp_files = []
-    ram_disk_path = "/Volumes/RAM DISK/"
-    prefix = None
-    if os.path.exists(ram_disk_path):
-        prefix = ram_disk_path
+    ram_disk_path = Path("/Volumes/RAM DISK/")
+    prefix: str | None = None
+    if ram_disk_path.exists():
+        prefix = str(ram_disk_path)
     while True:
-        tmp_file = NamedTemporaryFile(prefix=prefix, suffix="_eventsourcing_test.db")
-        tmp_files.append(tmp_file)
-        yield "file:" + tmp_file.name
+        with NamedTemporaryFile(
+            prefix=prefix,
+            suffix="_eventsourcing_test.db",
+        ) as tmp_file:
+            tmp_files.append(tmp_file)
+            yield "file:" + tmp_file.name
 
 
 class CustomType1:
     def __init__(self, value: UUID):
         self.value = value
 
-    def __eq__(self, other: CustomType1):
+    def __eq__(self, other: object) -> bool:
         return type(self) is type(other) and self.__dict__ == other.__dict__
 
 
@@ -1013,39 +1302,48 @@ class CustomType2:
     def __init__(self, value: CustomType1):
         self.value = value
 
-    def __eq__(self, other: CustomType2):
+    def __eq__(self, other: object) -> bool:
         return type(self) is type(other) and self.__dict__ == other.__dict__
 
 
-class MyDict(dict):
-    def __repr__(self):
+_KT = TypeVar("_KT")
+_VT = TypeVar("_VT")
+
+
+class Mydict(dict[_KT, _VT]):
+    def __repr__(self) -> str:
         return f"{type(self).__name__}({super().__repr__()})"
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         return type(self) is type(other) and super().__eq__(other)
 
 
-class MyList(list):
-    def __repr__(self):
+_T = TypeVar("_T")
+
+
+class MyList(list[_T]):
+    def __repr__(self) -> str:
         return f"{type(self).__name__}({super().__repr__()})"
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         return type(self) is type(other) and super().__eq__(other)
 
 
 class MyStr(str):
-    def __repr__(self):
+    __slots__ = ()
+
+    def __repr__(self) -> str:
         return f"{type(self).__name__}({super().__repr__()})"
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         return type(self) is type(other) and super().__eq__(other)
 
 
 class MyInt(int):
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"{type(self).__name__}({super().__repr__()})"
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         return type(self) is type(other) and super().__eq__(other)
 
 
@@ -1081,10 +1379,10 @@ class TranscoderTestCase(TestCase):
     def setUp(self) -> None:
         self.transcoder = self.construct_transcoder()
 
-    def construct_transcoder(self):
+    def construct_transcoder(self) -> Transcoder:
         raise NotImplementedError
 
-    def test_str(self):
+    def test_str(self) -> None:
         obj = "a"
         data = self.transcoder.encode(obj)
         self.assertEqual(data, b'"a"')
@@ -1116,48 +1414,48 @@ class TranscoderTestCase(TestCase):
             obj, self.transcoder.decode(legacy_encoding_with_ensure_ascii_true)
         )
 
-    def test_dict(self):
+    def test_dict(self) -> None:
         # Empty dict.
-        obj = {}
-        data = self.transcoder.encode(obj)
+        obj1: dict[Never, Never] = {}
+        data = self.transcoder.encode(obj1)
         self.assertEqual(data, b"{}")
-        self.assertEqual(obj, self.transcoder.decode(data))
+        self.assertEqual(obj1, self.transcoder.decode(data))
 
-        # Dict with single key.
-        obj = {"a": 1}
-        data = self.transcoder.encode(obj)
+        # dict with single key.
+        obj2 = {"a": 1}
+        data = self.transcoder.encode(obj2)
         self.assertEqual(data, b'{"a":1}')
-        self.assertEqual(obj, self.transcoder.decode(data))
+        self.assertEqual(obj2, self.transcoder.decode(data))
 
-        # Dict with many keys.
-        obj = {"a": 1, "b": 2}
-        data = self.transcoder.encode(obj)
+        # dict with many keys.
+        obj3 = {"a": 1, "b": 2}
+        data = self.transcoder.encode(obj3)
         self.assertEqual(data, b'{"a":1,"b":2}')
-        self.assertEqual(obj, self.transcoder.decode(data))
+        self.assertEqual(obj3, self.transcoder.decode(data))
 
         # Empty dict in dict.
-        obj = {"a": {}}
-        data = self.transcoder.encode(obj)
+        obj4: dict[str, dict[Never, Never]] = {"a": {}}
+        data = self.transcoder.encode(obj4)
         self.assertEqual(data, b'{"a":{}}')
-        self.assertEqual(obj, self.transcoder.decode(data))
+        self.assertEqual(obj4, self.transcoder.decode(data))
 
         # Empty dicts in dict.
-        obj = {"a": {}, "b": {}}
-        data = self.transcoder.encode(obj)
+        obj5: dict[str, dict[Never, Never]] = {"a": {}, "b": {}}
+        data = self.transcoder.encode(obj5)
         self.assertEqual(data, b'{"a":{},"b":{}}')
-        self.assertEqual(obj, self.transcoder.decode(data))
+        self.assertEqual(obj5, self.transcoder.decode(data))
 
         # Empty dict in dict in dict.
-        obj = {"a": {"b": {}}}
-        data = self.transcoder.encode(obj)
+        obj6: dict[str, dict[str, dict[Never, Never]]] = {"a": {"b": {}}}
+        data = self.transcoder.encode(obj6)
         self.assertEqual(data, b'{"a":{"b":{}}}')
-        self.assertEqual(obj, self.transcoder.decode(data))
+        self.assertEqual(obj6, self.transcoder.decode(data))
 
         # Int in dict in dict in dict.
-        obj = {"a": {"b": {"c": 1}}}
-        data = self.transcoder.encode(obj)
+        obj7 = {"a": {"b": {"c": 1}}}
+        data = self.transcoder.encode(obj7)
         self.assertEqual(data, b'{"a":{"b":{"c":1}}}')
-        self.assertEqual(obj, self.transcoder.decode(data))
+        self.assertEqual(obj7, self.transcoder.decode(data))
 
         # TODO: Int keys?
         # obj = {1: "a"}
@@ -1165,115 +1463,115 @@ class TranscoderTestCase(TestCase):
         # self.assertEqual(data, b'{1:{"a"}')
         # self.assertEqual(obj, self.transcoder.decode(data))
 
-    def test_dict_with_len_2_and__data_(self):
+    def test_dict_with_len_2_and__data_(self) -> None:
         obj = {"_data_": 1, "something_else": 2}
         data = self.transcoder.encode(obj)
         self.assertEqual(obj, self.transcoder.decode(data))
 
-    def test_dict_with_len_2_and__type_(self):
+    def test_dict_with_len_2_and__type_(self) -> None:
         obj = {"_type_": 1, "something_else": 2}
         data = self.transcoder.encode(obj)
         self.assertEqual(obj, self.transcoder.decode(data))
 
-    def test_dict_subclass(self):
-        my_dict = MyDict({"a": 1})
+    def test_dict_subclass(self) -> None:
+        my_dict = Mydict({"a": 1})
         data = self.transcoder.encode(my_dict)
         self.assertEqual(b'{"_type_":"mydict","_data_":{"a":1}}', data)
         copy = self.transcoder.decode(data)
         self.assertEqual(my_dict, copy)
 
-    def test_list_subclass(self):
+    def test_list_subclass(self) -> None:
         my_list = MyList((("a", 1),))
         data = self.transcoder.encode(my_list)
         copy = self.transcoder.decode(data)
         self.assertEqual(my_list, copy)
 
-    def test_str_subclass(self):
+    def test_str_subclass(self) -> None:
         my_str = MyStr("a")
         data = self.transcoder.encode(my_str)
         copy = self.transcoder.decode(data)
         self.assertEqual(my_str, copy)
 
-    def test_int_subclass(self):
+    def test_int_subclass(self) -> None:
         my_int = MyInt(3)
         data = self.transcoder.encode(my_int)
         copy = self.transcoder.decode(data)
         self.assertEqual(my_int, copy)
 
-    def test_tuple(self):
+    def test_tuple(self) -> None:
         # Empty tuple.
-        obj = ()
-        data = self.transcoder.encode(obj)
+        obj1 = ()
+        data = self.transcoder.encode(obj1)
         self.assertEqual(data, b'{"_type_":"tuple_as_list","_data_":[]}')
-        self.assertEqual(obj, self.transcoder.decode(data))
+        self.assertEqual(obj1, self.transcoder.decode(data))
 
         # Empty tuple in a tuple.
-        obj = ((),)
-        data = self.transcoder.encode(obj)
-        self.assertEqual(obj, self.transcoder.decode(data))
+        obj2 = ((),)
+        data = self.transcoder.encode(obj2)
+        self.assertEqual(obj2, self.transcoder.decode(data))
 
         # Int in tuple in a tuple.
-        obj = ((1, 2),)
-        data = self.transcoder.encode(obj)
-        self.assertEqual(obj, self.transcoder.decode(data))
+        obj3 = ((1, 2),)
+        data = self.transcoder.encode(obj3)
+        self.assertEqual(obj3, self.transcoder.decode(data))
 
         # Str in tuple in a tuple.
-        obj = (("a", "b"),)
-        data = self.transcoder.encode(obj)
-        self.assertEqual(obj, self.transcoder.decode(data))
+        obj4 = (("a", "b"),)
+        data = self.transcoder.encode(obj4)
+        self.assertEqual(obj4, self.transcoder.decode(data))
 
         # Int and str in tuple in a tuple.
-        obj = ((1, "a"),)
-        data = self.transcoder.encode(obj)
-        self.assertEqual(obj, self.transcoder.decode(data))
+        obj5 = ((1, "a"),)
+        data = self.transcoder.encode(obj5)
+        self.assertEqual(obj5, self.transcoder.decode(data))
 
-    def test_list(self):
+    def test_list(self) -> None:
         # Empty list.
-        obj = []
-        data = self.transcoder.encode(obj)
-        self.assertEqual(obj, self.transcoder.decode(data))
+        obj1: list[Never] = []
+        data = self.transcoder.encode(obj1)
+        self.assertEqual(obj1, self.transcoder.decode(data))
 
         # Empty list in a list.
-        obj = [[]]
-        data = self.transcoder.encode(obj)
-        self.assertEqual(obj, self.transcoder.decode(data))
+        obj2: list[list[Never]] = [[]]
+        data = self.transcoder.encode(obj2)
+        self.assertEqual(obj2, self.transcoder.decode(data))
 
         # Int in list in a list.
-        obj = [[1, 2]]
-        data = self.transcoder.encode(obj)
-        self.assertEqual(obj, self.transcoder.decode(data))
+        obj3 = [[1, 2]]
+        data = self.transcoder.encode(obj3)
+        self.assertEqual(obj3, self.transcoder.decode(data))
 
         # Str in list in a list.
-        obj = [["a", "b"]]
-        data = self.transcoder.encode(obj)
-        self.assertEqual(obj, self.transcoder.decode(data))
+        obj4 = [["a", "b"]]
+        data = self.transcoder.encode(obj4)
+        self.assertEqual(obj4, self.transcoder.decode(data))
 
         # Int and str in list in a list.
-        obj = [[1, "a"]]
-        data = self.transcoder.encode(obj)
-        self.assertEqual(obj, self.transcoder.decode(data))
+        obj5 = [[1, "a"]]
+        data = self.transcoder.encode(obj5)
+        self.assertEqual(obj5, self.transcoder.decode(data))
 
-    def test_mixed(self):
-        obj = [(1, "a"), {"b": 2}]
-        data = self.transcoder.encode(obj)
-        self.assertEqual(obj, self.transcoder.decode(data))
+    def test_mixed(self) -> None:
+        obj1 = [(1, "a"), {"b": 2}]
+        data = self.transcoder.encode(obj1)
+        self.assertEqual(obj1, self.transcoder.decode(data))
 
-        obj = ([1, "a"], {"b": 2})
-        data = self.transcoder.encode(obj)
-        self.assertEqual(obj, self.transcoder.decode(data))
+        obj2 = ([1, "a"], {"b": 2})
+        data = self.transcoder.encode(obj2)
+        self.assertEqual(obj2, self.transcoder.decode(data))
 
-        obj = {"a": (1, 2), "b": [3, 4]}
-        data = self.transcoder.encode(obj)
-        self.assertEqual(obj, self.transcoder.decode(data))
+        obj3 = {"a": (1, 2), "b": [3, 4]}
+        data = self.transcoder.encode(obj3)
+        self.assertEqual(obj3, self.transcoder.decode(data))
 
-    def test_custom_type_in_dict(self):
+    def test_custom_type_in_dict(self) -> None:
         # Int in dict in dict in dict.
         obj = {"a": CustomType2(CustomType1(UUID("b2723fe2c01a40d2875ea3aac6a09ff5")))}
         data = self.transcoder.encode(obj)
         decoded_obj = self.transcoder.decode(data)
         self.assertEqual(obj, decoded_obj)
 
-    def test_nested_custom_type(self):
+    def test_nested_custom_type(self) -> None:
         obj = CustomType2(CustomType1(UUID("b2723fe2c01a40d2875ea3aac6a09ff5")))
         data = self.transcoder.encode(obj)
         expect = (
@@ -1289,7 +1587,7 @@ class TranscoderTestCase(TestCase):
         self.assertIsInstance(copy.value.value, UUID)
         self.assertEqual(copy.value.value, obj.value.value)
 
-    def test_custom_type_error(self):
+    def test_custom_type_error(self) -> None:
         # Expect a TypeError when encoding because transcoding not registered.
         with self.assertRaises(TypeError) as cm:
             self.transcoder.encode(MyClass())