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

eventsourcing/tests/__init__.py

@@ -0,0 +1,3 @@
+import warnings
+
+warnings.resetwarnings()  # VS Code unittest runner somehow adds warning filters :-/

eventsourcing/tests/application.py

@@ -5,38 +5,40 @@ import sys
 import traceback
 import warnings
 from concurrent.futures import ThreadPoolExecutor
-from datetime import datetime
 from decimal import Decimal
 from threading import Event, get_ident
 from time import sleep
 from timeit import timeit
-from typing import ClassVar, Dict, Type
+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
+from eventsourcing.domain import Aggregate, datetime_now_with_tzinfo
 from eventsourcing.persistence import (
     InfrastructureFactory,
+    InfrastructureFactoryError,
     IntegrityError,
-    Transcoder,
+    JSONTranscoder,
     Transcoding,
 )
 from eventsourcing.tests.domain import BankAccount, EmailAddress
-from eventsourcing.utils import get_topic
+from eventsourcing.utils import EnvType, get_topic
 
-TIMEIT_FACTOR = int(os.environ.get("TEST_TIMEIT_FACTOR", default=10))
+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]] = {}
+    started_ats: ClassVar[dict[type[TestCase], datetime]] = {}
+    counts: ClassVar[dict[type[TestCase], int]] = {}
     expected_factory_topic: str
 
-    def test_example_application(self):
+    def test_example_application(self) -> None:
         app = BankAccounts(env={"IS_SNAPSHOTTING_ENABLED": "y"})
-        max_notification_id = app.recorder.max_notification_id()
 
         self.assertEqual(get_topic(type(app.factory)), self.expected_factory_topic)
 
@@ -75,38 +77,38 @@ class ExampleApplicationTestCase(TestCase):
         )
 
         sleep(1)  # Added to make eventsourcing-axon tests work, perhaps not necessary.
-        section = app.notification_log[
-            f"{max_notification_id + 1},{max_notification_id + 10}"
-        ]
+        section = app.notification_log["1,10"]
         self.assertEqual(len(section.items), 4)
 
         # Take snapshot (specify version).
         app.take_snapshot(account_id, version=Aggregate.INITIAL_VERSION + 1)
 
+        assert app.snapshots is not None  # for mypy
         snapshots = list(app.snapshots.get(account_id))
         self.assertEqual(len(snapshots), 1)
         self.assertEqual(snapshots[0].originator_version, Aggregate.INITIAL_VERSION + 1)
 
-        from_snapshot = app.repository.get(
+        from_snapshot1: BankAccount = app.repository.get(
             account_id, version=Aggregate.INITIAL_VERSION + 2
         )
-        self.assertIsInstance(from_snapshot, BankAccount)
-        self.assertEqual(from_snapshot.version, Aggregate.INITIAL_VERSION + 2)
-        self.assertEqual(from_snapshot.balance, Decimal("35.00"))
+        self.assertIsInstance(from_snapshot1, BankAccount)
+        self.assertEqual(from_snapshot1.version, Aggregate.INITIAL_VERSION + 2)
+        self.assertEqual(from_snapshot1.balance, Decimal("35.00"))
 
         # Take snapshot (don't specify version).
         app.take_snapshot(account_id)
+        assert app.snapshots is not None  # for mypy
         snapshots = list(app.snapshots.get(account_id))
         self.assertEqual(len(snapshots), 2)
         self.assertEqual(snapshots[0].originator_version, Aggregate.INITIAL_VERSION + 1)
         self.assertEqual(snapshots[1].originator_version, Aggregate.INITIAL_VERSION + 3)
 
-        from_snapshot = app.repository.get(account_id)
-        self.assertIsInstance(from_snapshot, BankAccount)
-        self.assertEqual(from_snapshot.version, Aggregate.INITIAL_VERSION + 3)
-        self.assertEqual(from_snapshot.balance, Decimal("65.00"))
+        from_snapshot2: BankAccount = app.repository.get(account_id)
+        self.assertIsInstance(from_snapshot2, BankAccount)
+        self.assertEqual(from_snapshot2.version, Aggregate.INITIAL_VERSION + 3)
+        self.assertEqual(from_snapshot2.balance, Decimal("65.00"))
 
-    def test__put_performance(self):
+    def test__put_performance(self) -> None:
         app = BankAccounts()
 
         # Open an account.
@@ -116,7 +118,7 @@ class ExampleApplicationTestCase(TestCase):
         )
         account = app.get_account(account_id)
 
-        def put():
+        def put() -> None:
             # Credit the account.
             account.append_transaction(Decimal("10.00"))
             app.save(account)
@@ -128,14 +130,14 @@ class ExampleApplicationTestCase(TestCase):
         duration = timeit(put, number=self.timeit_number)
         self.print_time("store events", duration)
 
-    def test__get_performance_with_snapshotting_enabled(self):
+    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):
+    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):
+    def _test_get_performance(self, *, is_snapshotting_enabled: bool) -> None:
         app = BankAccounts(
             env={"IS_SNAPSHOTTING_ENABLED": "y" if is_snapshotting_enabled else "n"}
         )
@@ -146,7 +148,7 @@ class ExampleApplicationTestCase(TestCase):
             email_address="alice@example.com",
         )
 
-        def read():
+        def read() -> None:
             # Get the account.
             app.get_account(account_id)
 
@@ -161,10 +163,10 @@ class ExampleApplicationTestCase(TestCase):
             test_label = "get without snapshotting"
         self.print_time(test_label, duration)
 
-    def print_time(self, 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()
+            self.started_ats[cls] = datetime_now_with_tzinfo()
             print(f"{cls.__name__: <29} timeit number: {cls.timeit_number}")
             self.counts[cls] = 1
         else:
@@ -179,8 +181,8 @@ class ExampleApplicationTestCase(TestCase):
         )
 
         if self.counts[cls] == 3:
-            duration = datetime.now() - cls.started_ats[cls]
-            print(f"{cls.__name__: <29} timeit duration: {duration}")
+            cls_duration = datetime_now_with_tzinfo() - cls.started_ats[cls]
+            print(f"{cls.__name__: <29} timeit duration: {cls_duration}")
             sys.stdout.flush()
 
 
@@ -198,11 +200,11 @@ class EmailAddressAsStr(Transcoding):
 class BankAccounts(Application):
     is_snapshotting_enabled = True
 
-    def register_transcodings(self, transcoder: Transcoder) -> None:
+    def register_transcodings(self, transcoder: JSONTranscoder) -> None:
         super().register_transcodings(transcoder)
         transcoder.register(EmailAddressAsStr())
 
-    def open_account(self, full_name, email_address):
+    def open_account(self, full_name: str, email_address: str) -> UUID:
         account = BankAccount.open(
             full_name=full_name,
             email_address=email_address,
@@ -221,7 +223,7 @@ class BankAccounts(Application):
 
     def get_account(self, account_id: UUID) -> BankAccount:
         try:
-            aggregate = self.repository.get(account_id)
+            aggregate: BankAccount = self.repository.get(account_id)
         except AggregateNotFoundError:
             raise self.AccountNotFoundError(account_id) from None
         else:
@@ -233,7 +235,7 @@ class BankAccounts(Application):
 
 
 class ApplicationTestCase(TestCase):
-    def test_name(self):
+    def test_name(self) -> None:
         self.assertEqual(Application.name, "Application")
 
         class MyApplication1(Application):
@@ -246,7 +248,7 @@ class ApplicationTestCase(TestCase):
 
         self.assertEqual(MyApplication2.name, "MyBoundedContext")
 
-    def test_resolve_persistence_topics(self):
+    def test_resolve_persistence_topics(self) -> None:
         # None specified.
         app = Application()
         self.assertIsInstance(app.factory, InfrastructureFactory)
@@ -264,7 +266,7 @@ class ApplicationTestCase(TestCase):
         self.assertIsInstance(app.factory, InfrastructureFactory)
 
         # Check exceptions.
-        with self.assertRaises(AssertionError) as cm:
+        with self.assertRaises(InfrastructureFactoryError) as cm:
             Application(env={"PERSISTENCE_MODULE": "eventsourcing.application"})
         self.assertEqual(
             cm.exception.args[0],
@@ -272,17 +274,18 @@ class ApplicationTestCase(TestCase):
             "'eventsourcing.application', expected 1.",
         )
 
-        with self.assertRaises(AssertionError) as cm:
+        with self.assertRaises(InfrastructureFactoryError) as cm:
             Application(
                 env={"PERSISTENCE_MODULE": "eventsourcing.application:Application"}
             )
         self.assertEqual(
+            "Topic 'eventsourcing.application:Application' didn't "
+            "resolve to a persistence module or infrastructure factory class: "
+            "<class 'eventsourcing.application.Application'>",
             cm.exception.args[0],
-            "Not an infrastructure factory class or module: "
-            "eventsourcing.application:Application",
         )
 
-    def test_save_returns_recording_event(self):
+    def test_save_returns_recording_event(self) -> None:
         app = Application()
 
         recordings = app.save()
@@ -291,22 +294,22 @@ class ApplicationTestCase(TestCase):
         recordings = app.save(None)
         self.assertEqual(recordings, [])
 
-        max_id = app.recorder.max_notification_id()
-
         recordings = app.save(Aggregate())
         self.assertEqual(len(recordings), 1)
-        self.assertEqual(recordings[0].notification.id, 1 + max_id)
+        self.assertEqual(recordings[0].notification.id, 1)
 
         recordings = app.save(Aggregate())
         self.assertEqual(len(recordings), 1)
-        self.assertEqual(recordings[0].notification.id, 2 + max_id)
+        self.assertEqual(recordings[0].notification.id, 2)
 
         recordings = app.save(Aggregate(), Aggregate())
         self.assertEqual(len(recordings), 2)
-        self.assertEqual(recordings[0].notification.id, 3 + max_id)
-        self.assertEqual(recordings[1].notification.id, 4 + max_id)
+        self.assertEqual(recordings[0].notification.id, 3)
+        self.assertEqual(recordings[1].notification.id, 4)
 
-    def test_take_snapshot_raises_assertion_error_if_snapshotting_not_enabled(self):
+    def test_take_snapshot_raises_assertion_error_if_snapshotting_not_enabled(
+        self,
+    ) -> None:
         app = Application()
         with self.assertRaises(AssertionError) as cm:
             app.take_snapshot(uuid4())
@@ -319,12 +322,13 @@ class ApplicationTestCase(TestCase):
             "application class.",
         )
 
-    def test_application_with_cached_aggregates_and_fastforward(self):
+    def test_application_with_cached_aggregates_and_fastforward(self) -> None:
         app = Application(env={"AGGREGATE_CACHE_MAXSIZE": "10"})
 
         aggregate = Aggregate()
         app.save(aggregate)
         # Should not put the aggregate in the cache.
+        assert app.repository.cache is not None  # for mypy
         with self.assertRaises(KeyError):
             self.assertEqual(aggregate, app.repository.cache.get(aggregate.id))
 
@@ -344,111 +348,171 @@ class ApplicationTestCase(TestCase):
         app.repository.get(aggregate.id)
         self.assertEqual(aggregate, app.repository.cache.get(aggregate.id))
 
-    def test_application_fastforward_skipping_during_contention(self):
-        app = Application(
+    def test_check_aggregate_fastforwarding_nonblocking(self) -> None:
+        self._check_aggregate_fastforwarding_during_contention(
             env={
                 "AGGREGATE_CACHE_MAXSIZE": "10",
                 "AGGREGATE_CACHE_FASTFORWARD_SKIPPING": "y",
             }
         )
 
-        aggregate = Aggregate()
-        aggregate_id = aggregate.id
-        app.save(aggregate)
+    def test_check_aggregate_fastforwarding_blocking(self) -> None:
+        self._check_aggregate_fastforwarding_during_contention(
+            env={"AGGREGATE_CACHE_MAXSIZE": "10"}
+        )
+
+    def _check_aggregate_fastforwarding_during_contention(self, env: EnvType) -> None:
+        app = Application(env=env)
+
+        self.assertEqual(len(app.repository._fastforward_locks_inuse), 0)
+
+        # Create one aggregate.
+        original_aggregate = Aggregate()
+        app.save(original_aggregate)
+        obj_ids = set()
+
+        # Prime the cache.
+        app.repository.get(original_aggregate.id)
+
+        # Remember the aggregate ID.
+        aggregate_id = original_aggregate.id
 
         stopped = Event()
+        errors: list[BaseException] = []
+        successful_thread_ids = set()
 
-        # Trigger, save, get, check.
-        def trigger_save_get_check():
+        def trigger_save_get_check() -> None:
             while not stopped.is_set():
                 try:
-                    aggregate = app.repository.get(aggregate_id)
+                    # Get the aggregate.
+                    aggregate: Aggregate = app.repository.get(aggregate_id)
+                    original_version = aggregate.version
+
+                    # Try to record a new event.
                     aggregate.trigger_event(Aggregate.Event)
-                    saved_version = aggregate.version
+                    # Give other threads a chance.
                     try:
                         app.save(aggregate)
                     except IntegrityError:
+                        # Start again if we didn't record a new event.
+                        # print("Got integrity error")
+                        sleep(0.001)
                         continue
-                    cached_version = app.repository.get(aggregate_id).version
-                    if saved_version > cached_version:
-                        print(f"Skipped fast-forwarding at version {saved_version}")
-                        stopped.set()
-                    if aggregate.version % 1000 == 0:
-                        print("Version:", aggregate.version, get_ident())
-                    sleep(0.00)
-                except BaseException:
-                    print(traceback.format_exc())
-                    raise
 
-        executor = ThreadPoolExecutor(max_workers=100)
-        for _ in range(100):
-            executor.submit(trigger_save_get_check)
+                    # Get the aggregate from the cache.
+                    assert app.repository.cache is not None
+                    cached: Any = app.repository.cache.get(aggregate_id)
+                    obj_ids.add(id(cached))
 
-        if not stopped.wait(timeout=100):
-            stopped.set()
-            self.fail("Didn't skip fast forwarding before test timed out...")
-        executor.shutdown()
+                    if len(obj_ids) > 1:
+                        stopped.set()
+                        continue
 
-    def test_application_fastforward_blocking_during_contention(self):
-        app = Application(
-            env={
-                "AGGREGATE_CACHE_MAXSIZE": "10",
-            }
-        )
+                    # Fast-forward the cached aggregate.
+                    fastforwarded: Aggregate = app.repository.get(aggregate_id)
 
-        aggregate = Aggregate()
-        aggregate_id = aggregate.id
-        app.save(aggregate)
+                    # Check cached aggregate was fast-forwarded with recorded event.
+                    if fastforwarded.version < original_version:
+                        try:
+                            self.fail(
+                                f"Failed to fast-forward at version {original_version}"
+                            )
+                        except AssertionError as e:
+                            errors.append(e)
+                            stopped.set()
+                            continue
 
-        stopped = Event()
+                    # Monitor number of threads getting involved.
+                    thread_id = get_ident()
+                    successful_thread_ids.add(thread_id)
 
-        # Trigger, save, get, check.
-        def trigger_save_get_check():
-            while not stopped.is_set():
-                try:
-                    aggregate = app.repository.get(aggregate_id)
-                    aggregate.trigger_event(Aggregate.Event)
-                    saved_version = aggregate.version
-                    try:
-                        app.save(aggregate)
-                    except IntegrityError:
-                        continue
-                    cached_version = app.repository.get(aggregate_id).version
-                    if saved_version > cached_version:
-                        print(f"Skipped fast-forwarding at version {saved_version}")
+                    # print("Version:", aggregate.version, thread_id)
+
+                    # See if we have done enough.
+                    if len(successful_thread_ids) > 10 and aggregate.version >= 25:
                         stopped.set()
-                    if aggregate.version % 1000 == 0:
-                        print("Version:", aggregate.version, get_ident())
-                    sleep(0.00)
-                except BaseException:
+                        continue
+
+                    sleep(0.0001)
+                    # sleep(0.001)
+                except BaseException as e:
+                    errors.append(e)
+                    stopped.set()
                     print(traceback.format_exc())
                     raise
 
         executor = ThreadPoolExecutor(max_workers=100)
+        futures = []
         for _ in range(100):
-            executor.submit(trigger_save_get_check)
-
-        if not stopped.wait(timeout=3):
-            stopped.set()
-        else:
-            self.fail("Wrongly skipped fast forwarding")
+            f = executor.submit(trigger_save_get_check)
+            futures.append(f)
+
+        # Run for three seconds.
+        stopped.wait(timeout=10)
+        for f in futures:
+            f.result()
+        # print("Got all results, shutting down executor")
         executor.shutdown()
 
-    def test_application_with_cached_aggregates_not_fastforward(self):
+        try:
+            if errors:
+                raise errors[0]
+            if len(obj_ids) > 1:
+                self.fail(f"More than one instance used in the cache: {len(obj_ids)}")
+            if len(successful_thread_ids) < 3:
+                self.fail("Insufficient sharing across contentious threads")
+
+            final_aggregate: Aggregate = app.repository.get(aggregate_id)
+            # print("Final aggregate version:", final_aggregate.version)
+            if final_aggregate.version < 25:
+                self.fail(f"Insufficient version increment: {final_aggregate.version}")
+
+            self.assertEqual(len(app.repository._fastforward_locks_inuse), 0)
+
+        finally:
+            # print("Closing application")
+            app.close()
+
+    def test_application_with_cached_aggregates_not_fastforward(self) -> None:
         app = Application(
             env={
                 "AGGREGATE_CACHE_MAXSIZE": "10",
                 "AGGREGATE_CACHE_FASTFORWARD": "f",
             }
         )
-        aggregate = Aggregate()
-        app.save(aggregate)
-        # Should put the aggregate in the cache.
-        self.assertEqual(aggregate, app.repository.cache.get(aggregate.id))
-        app.repository.get(aggregate.id)
-        self.assertEqual(aggregate, app.repository.cache.get(aggregate.id))
+        aggregate1 = Aggregate()
+        app.save(aggregate1)
+        aggregate_id = aggregate1.id
 
-    def test_application_with_deepcopy_from_cache_arg(self):
+        # Should put the aggregate in the cache.
+        assert app.repository.cache is not None  # for mypy
+        self.assertEqual(aggregate1, app.repository.cache.get(aggregate_id))
+        app.repository.get(aggregate_id)
+        self.assertEqual(aggregate1, app.repository.cache.get(aggregate_id))
+
+        aggregate2 = Aggregate()
+        aggregate2._id = aggregate_id
+        aggregate2.trigger_event(Aggregate.Event)
+
+        # This will replace object in cache.
+        app.save(aggregate2)
+
+        self.assertEqual(aggregate2.version, aggregate1.version + 1)
+        aggregate3: Aggregate = app.repository.get(aggregate_id)
+        self.assertEqual(aggregate3.version, aggregate3.version)
+        self.assertEqual(id(aggregate3.version), id(aggregate3.version))
+
+        # This will mess things up because the cache has a stale aggregate.
+        aggregate3.trigger_event(Aggregate.Event)
+        app.events.put(aggregate3.collect_events())
+
+        # And so using the aggregate to record new events will cause an IntegrityError.
+        aggregate4: Aggregate = app.repository.get(aggregate_id)
+        aggregate4.trigger_event(Aggregate.Event)
+        with self.assertRaises(IntegrityError):
+            app.save(aggregate4)
+
+    def test_application_with_deepcopy_from_cache_arg(self) -> None:
         app = Application(
             env={
                 "AGGREGATE_CACHE_MAXSIZE": "10",
@@ -457,14 +521,15 @@ class ApplicationTestCase(TestCase):
         aggregate = Aggregate()
         app.save(aggregate)
         self.assertEqual(aggregate.version, 1)
-        aggregate = app.repository.get(aggregate.id)
-        aggregate.version = 101
+        reconstructed: Aggregate = app.repository.get(aggregate.id)
+        reconstructed.version = 101
+        assert app.repository.cache is not None  # for mypy
         self.assertEqual(app.repository.cache.get(aggregate.id).version, 1)
-        aggregate = app.repository.get(aggregate.id, deepcopy_from_cache=False)
-        aggregate.version = 101
+        cached: Aggregate = app.repository.get(aggregate.id, deepcopy_from_cache=False)
+        cached.version = 101
         self.assertEqual(app.repository.cache.get(aggregate.id).version, 101)
 
-    def test_application_with_deepcopy_from_cache_attribute(self):
+    def test_application_with_deepcopy_from_cache_attribute(self) -> None:
         app = Application(
             env={
                 "AGGREGATE_CACHE_MAXSIZE": "10",
@@ -473,15 +538,16 @@ class ApplicationTestCase(TestCase):
         aggregate = Aggregate()
         app.save(aggregate)
         self.assertEqual(aggregate.version, 1)
-        aggregate = app.repository.get(aggregate.id)
-        aggregate.version = 101
+        reconstructed: Aggregate = app.repository.get(aggregate.id)
+        reconstructed.version = 101
+        assert app.repository.cache is not None  # for mypy
         self.assertEqual(app.repository.cache.get(aggregate.id).version, 1)
         app.repository.deepcopy_from_cache = False
-        aggregate = app.repository.get(aggregate.id)
-        aggregate.version = 101
+        cached: Aggregate = app.repository.get(aggregate.id)
+        cached.version = 101
         self.assertEqual(app.repository.cache.get(aggregate.id).version, 101)
 
-    def test_application_log(self):
+    def test_application_log(self) -> None:
         # Check the old 'log' attribute presents the 'notification log' object.
         app = Application()
 
@@ -491,6 +557,6 @@ class ApplicationTestCase(TestCase):
 
         self.assertEqual(1, len(w))
         self.assertIs(w[-1].category, DeprecationWarning)
-        self.assertEqual(
-            "'log' is deprecated, use 'notifications' instead", w[-1].message.args[0]
+        self.assertIn(
+            "'log' is deprecated, use 'notifications' instead", str(w[-1].message)
         )