eventsourcing 9.2.22__py3-none-any.whl → 9.3.0a1__py3-none-any.whl

eventsourcing/tests/application_tests/test_cache.py

@@ -0,0 +1,134 @@
+from unittest import TestCase
+
+from eventsourcing.application import Cache, LRUCache
+
+
+class TestCache(TestCase):
+    def test_put_get(self):
+        cache = Cache()
+
+        with self.assertRaises(KeyError):
+            cache.get(1)
+
+        cache.put(1, 1)
+        self.assertEqual(cache.get(1), 1)
+
+        cache.put(2, 2)
+        self.assertEqual(1, cache.get(1))
+        self.assertEqual(2, cache.get(2))
+
+        cache.put(3, 3)
+        self.assertEqual(3, cache.get(3))
+        self.assertEqual(2, cache.get(2))
+        self.assertEqual(1, cache.get(1))
+
+        cache.put(1, 2)
+        self.assertEqual(2, cache.get(1))
+        cache.put(1, 3)
+        self.assertEqual(3, cache.get(1))
+
+        cache.get(1, evict=True)
+        with self.assertRaises(KeyError):
+            cache.get(1)
+
+        cache.put(1, None)
+        with self.assertRaises(KeyError):
+            cache.get(1)
+
+
+class TestLRUCache(TestCase):
+    def test_put_get(self):
+        cache = LRUCache(maxsize=2)
+
+        with self.assertRaises(KeyError):
+            cache.get(1)
+
+        evicted = cache.put(1, 1)
+        self.assertEqual(evicted, (None, None))
+        self.assertEqual(cache.get(1), 1)
+
+        evicted = cache.put(2, 2)
+        self.assertEqual(evicted, (None, None))
+        self.assertEqual(1, cache.get(1))
+        self.assertEqual(2, cache.get(2))
+
+        evicted = cache.put(3, 3)
+        self.assertEqual(evicted, (1, 1))
+
+        self.assertEqual(3, cache.get(3))
+        self.assertEqual(2, cache.get(2))
+
+        cache.put(1, 1)
+        self.assertEqual(1, cache.get(1))
+        cache.put(1, 2)
+        self.assertEqual(2, cache.get(1))
+        cache.put(1, 3)
+        self.assertEqual(3, cache.get(1))
+
+    def test_put_get_evict_recent(self):
+        cache = LRUCache(maxsize=3)
+
+        cache.put(1, 1)
+        self.assertEqual(1, cache.get(1))
+        self.assertEqual(1, cache.get(1))
+        self.assertEqual(1, cache.get(1, evict=True))
+
+        with self.assertRaises(KeyError):
+            self.assertEqual(1, cache.get(1))
+
+        cache.put(1, 1)
+        cache.put(2, 2)
+        cache.put(3, 3)
+        evicted = cache.put(4, 4)
+        self.assertEqual(evicted, (1, 1))
+
+        self.assertEqual(3, cache.get(3, evict=True))
+
+        evicted = cache.put(5, 5)
+        self.assertEqual(evicted, (None, None))
+
+        evicted = cache.put(6, 6)
+        self.assertEqual(evicted, (2, 2))
+
+        evicted = cache.put(7, 7)
+        self.assertEqual(evicted, (4, 4))
+
+    def test_put_get_evict_oldest(self):
+        cache = LRUCache(maxsize=3)
+
+        cache.put(1, 1)
+        cache.put(2, 2)
+        cache.put(3, 3)
+        self.assertEqual(1, cache.get(1, evict=True))
+
+        evicted = cache.put(4, 4)
+        self.assertEqual(evicted, (None, None))
+
+        evicted = cache.put(5, 5)
+        self.assertEqual(evicted, (2, 2))
+
+        evicted = cache.put(6, 6)
+        self.assertEqual(evicted, (3, 3))
+
+        evicted = cache.put(7, 7)
+        self.assertEqual(evicted, (4, 4))
+
+    def test_put_get_evict_newest(self):
+        cache = LRUCache(maxsize=3)
+
+        cache.put(1, 1)
+        cache.put(2, 2)
+        cache.put(3, 3)
+        self.assertEqual(3, cache.get(3, evict=True))
+
+        evicted = cache.put(4, 4)
+        self.assertEqual(evicted, (None, None))
+
+        evicted = cache.put(5, 5)
+        self.assertEqual(evicted, (1, 1))
+
+        evicted = cache.put(6, 6)
+        self.assertEqual(evicted, (2, 2))
+
+        evicted = cache.put(7, 7)
+        self.assertEqual(evicted, (4, 4))

eventsourcing/tests/application_tests/test_event_sourced_log.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from unittest import TestCase
+from uuid import NAMESPACE_URL, UUID, uuid4, uuid5
+
+from eventsourcing.application import Application, EventSourcedLog
+from eventsourcing.domain import Aggregate, DomainEvent
+from eventsourcing.persistence import (
+    DatetimeAsISO,
+    DecimalAsStr,
+    EventStore,
+    JSONTranscoder,
+    Mapper,
+    UUIDAsHex,
+)
+from eventsourcing.popo import POPOAggregateRecorder
+
+if TYPE_CHECKING:  # pragma: nocover
+    from eventsourcing.utils import EnvType
+
+
+class TestEventSourcedLog(TestCase):
+    def test_logging_aggregate_ids(self) -> None:
+        class LoggedID(DomainEvent):
+            aggregate_id: UUID
+
+        transcoder = JSONTranscoder()
+        transcoder.register(UUIDAsHex())
+        transcoder.register(DecimalAsStr())
+        transcoder.register(DatetimeAsISO())
+
+        event_recorder = POPOAggregateRecorder()
+        event_store = EventStore(
+            mapper=Mapper(transcoder=transcoder),
+            recorder=event_recorder,
+        )
+
+        log: EventSourcedLog[LoggedID] = EventSourcedLog(
+            events=event_store,
+            originator_id=uuid5(NAMESPACE_URL, "/aggregates"),
+            logged_cls=LoggedID,
+        )
+        id1 = uuid4()
+        id2 = uuid4()
+        id3 = uuid4()
+
+        self.assertEqual(log.get_first(), None)
+        self.assertEqual(log.get_last(), None)
+        logged = log.trigger_event(aggregate_id=id1)
+        event_store.put([logged])
+        first = log.get_first()
+        assert first
+        self.assertEqual(first.aggregate_id, id1)
+        last = log.get_last()
+        assert last
+        self.assertEqual(last.aggregate_id, id1)
+        logged = log.trigger_event(aggregate_id=id2)
+        event_store.put([logged])
+        last = log.get_last()
+        assert last
+        self.assertEqual(last.aggregate_id, id2)
+        logged = log.trigger_event(aggregate_id=id3, next_originator_version=3)
+        event_store.put([logged])
+        last = log.get_last()
+        assert last
+        self.assertEqual(last.aggregate_id, id3)
+        first = log.get_first()
+        assert first
+        self.assertEqual(first.aggregate_id, id1)
+
+        ids = [e.aggregate_id for e in log.get()]
+        self.assertEqual(ids, [id1, id2, id3])
+
+        ids = [e.aggregate_id for e in log.get(gt=1)]
+        self.assertEqual(ids, [id2, id3])
+
+        ids = [e.aggregate_id for e in log.get(lte=2)]
+        self.assertEqual(ids, [id1, id2])
+
+        ids = [e.aggregate_id for e in log.get(limit=1)]
+        self.assertEqual(ids, [id1])
+
+        ids = [e.aggregate_id for e in log.get(desc=True)]
+        self.assertEqual(ids, [id3, id2, id1])
+
+    def test_with_application(self) -> None:
+        class LoggedID(DomainEvent):
+            aggregate_id: UUID
+
+        class MyApplication(Application):
+            def __init__(self, env: EnvType | None = None) -> None:
+                super().__init__(env=env)
+                self.aggregate_log = EventSourcedLog(
+                    events=self.events,
+                    originator_id=uuid5(NAMESPACE_URL, "/aggregates"),
+                    logged_cls=LoggedID,
+                )
+
+            def create_aggregate(self) -> UUID:
+                aggregate = Aggregate()
+                logged_id = self.aggregate_log.trigger_event(aggregate_id=aggregate.id)
+                self.save(aggregate, logged_id)
+                return aggregate.id
+
+        app = MyApplication()
+
+        self.assertEqual(app.aggregate_log.get_last(), None)
+
+        aggregate1_id = app.create_aggregate()
+        last = app.aggregate_log.get_last()
+        assert last
+        self.assertEqual(last.aggregate_id, aggregate1_id)
+
+        aggregate2_id = app.create_aggregate()
+        last = app.aggregate_log.get_last()
+        assert last
+        self.assertEqual(last.aggregate_id, aggregate2_id)
+
+        aggregate_ids = [i.aggregate_id for i in app.aggregate_log.get()]
+        self.assertEqual(aggregate_ids, [aggregate1_id, aggregate2_id])
+
+    def test_subclasses(self) -> None:
+        transcoder = JSONTranscoder()
+        transcoder.register(UUIDAsHex())
+        transcoder.register(DecimalAsStr())
+        transcoder.register(DatetimeAsISO())
+
+        event_recorder = POPOAggregateRecorder()
+        event_store = EventStore(
+            mapper=Mapper(transcoder=transcoder),
+            recorder=event_recorder,
+        )
+
+        class TransactionLogEvent(DomainEvent):
+            pass
+
+        class AccountCredited(TransactionLogEvent):
+            pass
+
+        class AccountDebited(TransactionLogEvent):
+            pass
+
+        # Subclass EventSourcedLog.
+        class TransactionLog(EventSourcedLog[TransactionLogEvent]):
+            def account_credited(self) -> AccountCredited:
+                return self._trigger_event(logged_cls=AccountCredited)
+
+            def account_debited(self) -> AccountDebited:
+                return self._trigger_event(logged_cls=AccountDebited)
+
+        transaction_log = TransactionLog(
+            events=event_store,
+            originator_id=uuid5(NAMESPACE_URL, "/aggregates"),
+            logged_cls=TransactionLogEvent,
+        )
+
+        account_credited = transaction_log.account_credited()
+        self.assertIsInstance(account_credited, AccountCredited)
+
+        account_debited = transaction_log.account_debited()
+        self.assertIsInstance(account_debited, AccountDebited)

eventsourcing/tests/application_tests/test_notificationlog.py

@@ -0,0 +1,232 @@
+from unittest.case import TestCase
+from uuid import uuid4
+
+from eventsourcing.application import LocalNotificationLog
+from eventsourcing.persistence import StoredEvent
+from eventsourcing.sqlite import SQLiteApplicationRecorder, SQLiteDatastore
+
+
+class TestNotificationLog(TestCase):
+    def test_get_section(self):
+        recorder = SQLiteApplicationRecorder(SQLiteDatastore(":memory:"))
+        recorder.create_table()
+
+        # Construct notification log.
+        notification_log = LocalNotificationLog(recorder, section_size=5)
+
+        # Get the "current" section of log.
+        section = notification_log["1,10"]
+        self.assertEqual(len(section.items), 0)  # event notifications
+        self.assertEqual(section.id, None)
+        self.assertEqual(section.next_id, None)
+
+        # Write 5 events.
+        originator_id = uuid4()
+        for i in range(5):
+            stored_event = StoredEvent(
+                originator_id=originator_id,
+                originator_version=i,
+                topic="topic",
+                state=b"state",
+            )
+            recorder.insert_events([stored_event])
+
+        # Get the "head" section of log.
+        section = notification_log["1,10"]
+        self.assertEqual(len(section.items), 5)  # event notifications
+        self.assertEqual(section.items[0].id, 1)
+        self.assertEqual(section.items[1].id, 2)
+        self.assertEqual(section.items[2].id, 3)
+        self.assertEqual(section.items[3].id, 4)
+        self.assertEqual(section.items[4].id, 5)
+        self.assertEqual(section.id, "1,5")
+        self.assertEqual(section.next_id, "6,10")
+
+        # Get the "1,5" section of log.
+        section = notification_log["1,5"]
+        self.assertEqual(len(section.items), 5)  # event notifications
+        self.assertEqual(section.items[0].id, 1)
+        self.assertEqual(section.items[1].id, 2)
+        self.assertEqual(section.items[2].id, 3)
+        self.assertEqual(section.items[3].id, 4)
+        self.assertEqual(section.items[4].id, 5)
+        self.assertEqual(section.id, "1,5")
+        self.assertEqual(section.next_id, "6,10")
+
+        # Get the next section of log.
+        section = notification_log["6,10"]
+        self.assertEqual(len(section.items), 0)  # event notifications
+        self.assertEqual(section.id, None)
+        self.assertEqual(section.next_id, None)
+
+        # Write 4 events.
+        originator_id = uuid4()
+        for i in range(4):
+            stored_event = StoredEvent(
+                originator_id=originator_id,
+                originator_version=i,
+                topic="topic",
+                state=b"state",
+            )
+            recorder.insert_events([stored_event])
+
+        # Get the next section of log.
+        section = notification_log["6,10"]
+        self.assertEqual(len(section.items), 4)  # event notifications
+        self.assertEqual(section.items[0].id, 6)
+        self.assertEqual(section.items[1].id, 7)
+        self.assertEqual(section.items[2].id, 8)
+        self.assertEqual(section.items[3].id, 9)
+        self.assertEqual(section.id, "6,9")
+        self.assertEqual(section.next_id, None)
+
+        # Start at non-regular section start.
+        section = notification_log["3,7"]
+        self.assertEqual(len(section.items), 5)  # event notifications
+        self.assertEqual(section.items[0].id, 3)
+        self.assertEqual(section.items[1].id, 4)
+        self.assertEqual(section.items[2].id, 5)
+        self.assertEqual(section.items[3].id, 6)
+        self.assertEqual(section.items[4].id, 7)
+        self.assertEqual(section.id, "3,7")
+        self.assertEqual(section.next_id, "8,12")
+
+        # Notification log limits section size.
+        section = notification_log["3,10"]
+        self.assertEqual(len(section.items), 5)  # event notifications
+        self.assertEqual(section.items[0].id, 3)
+        self.assertEqual(section.items[1].id, 4)
+        self.assertEqual(section.items[2].id, 5)
+        self.assertEqual(section.items[3].id, 6)
+        self.assertEqual(section.items[4].id, 7)
+        self.assertEqual(section.id, "3,7")
+        self.assertEqual(section.next_id, "8,12")
+
+        # Reader limits section size.
+        section = notification_log["3,4"]
+        self.assertEqual(len(section.items), 2)  # event notifications
+        self.assertEqual(section.items[0].id, 3)
+        self.assertEqual(section.items[1].id, 4)
+        self.assertEqual(section.id, "3,4")
+        self.assertEqual(section.next_id, "5,6")
+
+        # Meaningless section ID.
+        section = notification_log["3,2"]
+        self.assertEqual(len(section.items), 0)  # event notifications
+        self.assertEqual(section.id, None)
+        self.assertEqual(section.next_id, None)
+
+        # # Numbers below 1.
+        # section = notification_log["-3,0"]
+        # self.assertEqual(
+        #     len(section.items), 4
+        # )  # event notifications
+        # self.assertEqual(section.items[0].id, 6)
+        # self.assertEqual(section.items[1].id, 7)
+        # self.assertEqual(section.items[2].id, 8)
+        # self.assertEqual(section.items[3].id, 9)
+        # self.assertEqual(section.section_id, "6,9")
+        # self.assertEqual(section.next_id, None)
+        #
+        # section = notification_log["-4,0"]
+        # self.assertEqual(
+        #     len(section.items), 5
+        # )  # event notifications
+        # self.assertEqual(section.items[0].id, 5)
+        # self.assertEqual(section.items[1].id, 6)
+        # self.assertEqual(section.items[2].id, 7)
+        # self.assertEqual(section.items[3].id, 8)
+        # self.assertEqual(section.items[4].id, 9)
+        # self.assertEqual(section.section_id, "5,9")
+        # self.assertEqual(section.next_id, "10,14")
+        #
+        # section = notification_log["-4,-1"]
+        # self.assertEqual(
+        #     len(section.items), 4
+        # )  # event notifications
+        # self.assertEqual(section.items[0].id, 5)
+        # self.assertEqual(section.items[1].id, 6)
+        # self.assertEqual(section.items[2].id, 7)
+        # self.assertEqual(section.items[3].id, 8)
+        # self.assertEqual(section.section_id, "5,8")
+        # self.assertEqual(section.next_id, "9,12")
+
+    def test_select(self):
+        recorder = SQLiteApplicationRecorder(SQLiteDatastore(":memory:"))
+        recorder.create_table()
+
+        # Construct notification log.
+        notification_log = LocalNotificationLog(recorder, section_size=10)
+
+        # Select start 1, limit 10
+        notifications = notification_log.select(1, 10)
+        self.assertEqual(len(notifications), 0)
+
+        # Write 5 events.
+        originator_id = uuid4()
+        for i in range(5):
+            stored_event = StoredEvent(
+                originator_id=originator_id,
+                originator_version=i,
+                topic="topic",
+                state=b"state",
+            )
+            recorder.insert_events([stored_event])
+
+        # Select start 1, limit 10
+        notifications = notification_log.select(1, 5)
+        self.assertEqual(len(notifications), 5)
+        self.assertEqual(notifications[0].id, 1)
+        self.assertEqual(notifications[1].id, 2)
+        self.assertEqual(notifications[2].id, 3)
+        self.assertEqual(notifications[3].id, 4)
+        self.assertEqual(notifications[4].id, 5)
+
+        # Select start 1, limit 10
+        notifications = notification_log.select(1, 5)
+        self.assertEqual(len(notifications), 5)
+        self.assertEqual(notifications[0].id, 1)
+        self.assertEqual(notifications[1].id, 2)
+        self.assertEqual(notifications[2].id, 3)
+        self.assertEqual(notifications[3].id, 4)
+        self.assertEqual(notifications[4].id, 5)
+
+        # Select start 6, limit 5
+        notifications = notification_log.select(6, 5)
+        self.assertEqual(len(notifications), 0)
+
+        # Write 4 events.
+        originator_id = uuid4()
+        for i in range(4):
+            stored_event = StoredEvent(
+                originator_id=originator_id,
+                originator_version=i,
+                topic="topic",
+                state=b"state",
+            )
+            recorder.insert_events([stored_event])
+
+        # Select start 6, limit 5
+        notifications = notification_log.select(6, 5)
+        self.assertEqual(len(notifications), 4)  # event notifications
+        self.assertEqual(notifications[0].id, 6)
+        self.assertEqual(notifications[1].id, 7)
+        self.assertEqual(notifications[2].id, 8)
+        self.assertEqual(notifications[3].id, 9)
+
+        # Select start 3, limit 5
+        notifications = notification_log.select(3, 5)
+        self.assertEqual(len(notifications), 5)  # event notifications
+        self.assertEqual(notifications[0].id, 3)
+        self.assertEqual(notifications[1].id, 4)
+        self.assertEqual(notifications[2].id, 5)
+        self.assertEqual(notifications[3].id, 6)
+        self.assertEqual(notifications[4].id, 7)
+
+        # Notification log limits limit.
+        # Select start 1, limit 20
+        with self.assertRaises(ValueError) as cm:
+            notification_log.select(1, 20)
+        self.assertEqual(
+            cm.exception.args[0], "Requested limit 20 greater than section size 10"
+        )

eventsourcing/tests/application_tests/test_notificationlogreader.py

@@ -0,0 +1,126 @@
+from itertools import chain
+from unittest.case import TestCase
+from uuid import uuid4
+
+from eventsourcing.application import LocalNotificationLog
+from eventsourcing.persistence import StoredEvent
+from eventsourcing.sqlite import SQLiteDatastore, SQLiteProcessRecorder
+from eventsourcing.system import NotificationLogReader
+
+
+class TestNotificationLogReader(TestCase):
+    def test_read(self):
+        recorder = SQLiteProcessRecorder(SQLiteDatastore(":memory:"))
+        recorder.create_table()
+
+        # Construct notification log.
+        notification_log = LocalNotificationLog(recorder, section_size=5)
+        reader = NotificationLogReader(notification_log, section_size=10)
+        notifications = list(reader.read(start=1))
+        self.assertEqual(len(notifications), 0)
+
+        # Write 5 events.
+        originator_id = uuid4()
+        for i in range(5):
+            stored_event = StoredEvent(
+                originator_id=originator_id,
+                originator_version=i,
+                topic="topic",
+                state=b"state",
+            )
+            recorder.insert_events(
+                [stored_event],
+            )
+
+        notifications = list(reader.read(start=1))
+        self.assertEqual(len(notifications), 5)
+
+        # Write 4 events.
+        originator_id = uuid4()
+        for i in range(4):
+            stored_event = StoredEvent(
+                originator_id=originator_id,
+                originator_version=i,
+                topic="topic",
+                state=b"state",
+            )
+            recorder.insert_events([stored_event])
+
+        notifications = list(reader.read(start=1))
+        self.assertEqual(len(notifications), 9)
+
+        notifications = list(reader.read(start=2))
+        self.assertEqual(len(notifications), 8)
+
+        notifications = list(reader.read(start=3))
+        self.assertEqual(len(notifications), 7)
+
+        notifications = list(reader.read(start=4))
+        self.assertEqual(len(notifications), 6)
+
+        notifications = list(reader.read(start=8))
+        self.assertEqual(len(notifications), 2)
+
+        notifications = list(reader.read(start=9))
+        self.assertEqual(len(notifications), 1)
+
+        notifications = list(reader.read(start=10))
+        self.assertEqual(len(notifications), 0)
+
+    def test_select(self):
+        recorder = SQLiteProcessRecorder(SQLiteDatastore(":memory:"))
+        recorder.create_table()
+
+        # Construct notification log.
+        notification_log = LocalNotificationLog(recorder, section_size=5)
+        reader = NotificationLogReader(notification_log, section_size=5)
+        notifications = list(chain(*reader.select(start=1)))
+        self.assertEqual(len(notifications), 0)
+
+        # Write 5 events.
+        originator_id = uuid4()
+        for i in range(5):
+            stored_event = StoredEvent(
+                originator_id=originator_id,
+                originator_version=i,
+                topic="topic",
+                state=b"state",
+            )
+            recorder.insert_events(
+                [stored_event],
+            )
+
+        notifications = list(chain(*reader.select(start=1)))
+        self.assertEqual(len(notifications), 5)
+
+        # Write 4 events.
+        originator_id = uuid4()
+        for i in range(4):
+            stored_event = StoredEvent(
+                originator_id=originator_id,
+                originator_version=i,
+                topic="topic",
+                state=b"state",
+            )
+            recorder.insert_events([stored_event])
+
+        notifications = list(chain(*reader.select(start=1)))
+        self.assertEqual(len(notifications), 9)
+
+        notifications = list(chain(*reader.select(start=2)))
+        self.assertEqual(len(notifications), 8)
+
+        notifications = list(chain(*reader.select(start=3)))
+        self.assertEqual(len(notifications), 7)
+
+        notifications = list(chain(*reader.select(start=4)))
+        self.assertEqual(len(notifications), 6)
+
+        notifications = list(chain(*reader.select(start=8)))
+        self.assertEqual(len(notifications), 2)
+
+        notifications = list(chain(*reader.select(start=9)))
+        self.assertEqual(len(notifications), 1)
+
+        notifications = list(chain(*reader.select(start=10)))
+        self.assertEqual(len(notifications), 0)