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

eventsourcing/tests/persistence_tests/test_eventstore.py

@@ -0,0 +1,72 @@
+from decimal import Decimal
+from unittest.case import TestCase
+
+from eventsourcing.persistence import (
+    DatetimeAsISO,
+    DecimalAsStr,
+    EventStore,
+    JSONTranscoder,
+    Mapper,
+    UUIDAsHex,
+)
+from eventsourcing.sqlite import SQLiteAggregateRecorder, SQLiteDatastore
+from eventsourcing.tests.application import EmailAddressAsStr
+from eventsourcing.tests.domain import BankAccount
+
+
+class TestEventStore(TestCase):
+    def test(self):
+        # Open an account.
+        account = BankAccount.open(
+            full_name="Alice",
+            email_address="alice@example.com",
+        )
+
+        # Credit the account.
+        account.append_transaction(Decimal("10.00"))
+        account.append_transaction(Decimal("25.00"))
+        account.append_transaction(Decimal("30.00"))
+
+        # Collect pending events.
+        pending = account.collect_events()
+
+        # Construct event store.
+        transcoder = JSONTranscoder()
+        transcoder.register(UUIDAsHex())
+        transcoder.register(DecimalAsStr())
+        transcoder.register(DatetimeAsISO())
+        transcoder.register(EmailAddressAsStr())
+        recorder = SQLiteAggregateRecorder(SQLiteDatastore(":memory:"))
+        event_store = EventStore(
+            mapper=Mapper(transcoder),
+            recorder=recorder,
+        )
+        recorder.create_table()
+
+        # Get last event.
+        stored_events = event_store.get(account.id, desc=True, limit=1)
+        self.assertEqual(list(stored_events), [])
+
+        # Store pending events.
+        event_store.put(pending)
+
+        # Get domain events.
+        domain_events = event_store.get(account.id)
+
+        # Reconstruct the bank account.
+        copy = None
+        for domain_event in domain_events:
+            copy = domain_event.mutate(copy)
+
+        # Check copy has correct attribute values.
+        self.assertEqual(copy.id, account.id)
+        self.assertEqual(copy.balance, Decimal("65.00"))
+
+        # Get last event.
+        events = event_store.get(account.id, desc=True, limit=1)
+        events = list(events)
+        self.assertEqual(len(events), 1)
+        last_event = events[0]
+
+        self.assertEqual(last_event.originator_id, account.id)
+        assert type(last_event) is BankAccount.TransactionAppended

eventsourcing/tests/persistence_tests/test_infrastructure_factory.py

@@ -0,0 +1,21 @@
+from unittest.case import TestCase
+
+from eventsourcing.persistence import InfrastructureFactory
+from eventsourcing.utils import Environment, get_topic
+
+
+class TestInfrastructureFactoryErrors(TestCase):
+    def test_construct_raises_exception(self):
+        with self.assertRaises(EnvironmentError):
+            InfrastructureFactory.construct(
+                Environment(
+                    env={InfrastructureFactory.PERSISTENCE_MODULE: "invalid topic"}
+                )
+            )
+
+        with self.assertRaises(AssertionError):
+            InfrastructureFactory.construct(
+                Environment(
+                    env={InfrastructureFactory.PERSISTENCE_MODULE: get_topic(object)}
+                )
+            )

eventsourcing/tests/persistence_tests/test_mapper.py

@@ -0,0 +1,113 @@
+import warnings
+from decimal import Decimal
+from unittest.case import TestCase
+from uuid import uuid4
+
+from eventsourcing.cipher import AESCipher
+from eventsourcing.compressor import ZlibCompressor
+from eventsourcing.domain import AggregateEvent
+from eventsourcing.persistence import (
+    DatetimeAsISO,
+    DecimalAsStr,
+    JSONTranscoder,
+    Mapper,
+    UUIDAsHex,
+)
+from eventsourcing.tests.domain import BankAccount
+from eventsourcing.utils import Environment
+
+
+class TestMapper(TestCase):
+    def test(self):
+        # Construct transcoder.
+        transcoder = JSONTranscoder()
+        transcoder.register(UUIDAsHex())
+        transcoder.register(DecimalAsStr())
+        transcoder.register(DatetimeAsISO())
+
+        # Construct cipher.
+        environment = Environment()
+        environment[AESCipher.CIPHER_KEY] = AESCipher.create_key(16)
+        cipher = AESCipher(environment)
+
+        # Construct compressor.
+        compressor = ZlibCompressor()
+
+        # Construct mapper with cipher.
+        mapper = Mapper(transcoder=transcoder, cipher=cipher)
+
+        # Create a domain event.
+        domain_event = BankAccount.TransactionAppended(
+            originator_id=uuid4(),
+            originator_version=123456,
+            timestamp=BankAccount.TransactionAppended.create_timestamp(),
+            amount=Decimal("10.00"),
+        )
+
+        # Map to stored event.
+        stored_event = mapper.to_stored_event(domain_event)
+
+        # Map to domain event.
+        copy = mapper.to_domain_event(stored_event)
+
+        # Check values are not visible.
+        self.assertNotIn("Alice", str(stored_event.state))
+
+        # Check decrypted copy has correct values.
+        self.assertEqual(copy.originator_id, domain_event.originator_id)
+        self.assertEqual(copy.originator_version, domain_event.originator_version)
+        self.assertEqual(copy.timestamp, domain_event.timestamp)
+        self.assertEqual(copy.originator_version, domain_event.originator_version)
+
+        self.assertEqual(len(stored_event.state), 162)
+
+        # Construct mapper with cipher and compressor.
+        mapper = Mapper(
+            transcoder=transcoder,
+            cipher=cipher,
+            compressor=compressor,
+        )
+
+        # Map to stored event.
+        stored_event = mapper.to_stored_event(domain_event)
+
+        # Map to domain event.
+        copy = mapper.to_domain_event(stored_event)
+
+        # Check decompressed copy has correct values.
+        self.assertEqual(copy.originator_id, domain_event.originator_id)
+        self.assertEqual(copy.originator_version, domain_event.originator_version)
+
+        self.assertIn(len(stored_event.state), range(129, 143))
+
+    def test_from_domain_event_gives_deprecated_warning(self):
+        # Construct transcoder.
+        transcoder = JSONTranscoder()
+        transcoder.register(UUIDAsHex())
+        transcoder.register(DatetimeAsISO())
+
+        # Construct mapper with cipher.
+        mapper = Mapper(transcoder=transcoder)
+
+        # Create a domain event.
+        domain_event = AggregateEvent(
+            originator_id=uuid4(),
+            originator_version=123456,
+            timestamp=AggregateEvent.create_timestamp(),
+        )
+
+        # Verify deprecation warning.
+        with warnings.catch_warnings(record=True) as w:
+            stored_event = mapper.from_domain_event(domain_event)
+
+        self.assertEqual(len(w), 1)
+        self.assertIs(w[-1].category, DeprecationWarning)
+        self.assertEqual(
+            "'from_domain_event()' is deprecated, use 'to_stored_event()' instead",
+            w[-1].message.args[0],
+        )
+
+        self.assertEqual(stored_event.originator_id, domain_event.originator_id)
+        self.assertEqual(
+            stored_event.originator_version, domain_event.originator_version
+        )

eventsourcing/tests/persistence_tests/test_noninterleaving_notification_ids.py

@@ -0,0 +1,69 @@
+from eventsourcing.persistence import ApplicationRecorder
+from eventsourcing.popo import POPOApplicationRecorder
+from eventsourcing.postgres import PostgresApplicationRecorder, PostgresDatastore
+from eventsourcing.sqlite import SQLiteApplicationRecorder, SQLiteDatastore
+from eventsourcing.tests.persistence import (
+    NonInterleavingNotificationIDsBaseCase,
+    tmpfile_uris,
+)
+from eventsourcing.tests.postgres_utils import drop_postgres_table
+
+
+class TestNonInterleavingPOPO(NonInterleavingNotificationIDsBaseCase):
+    insert_num = 10000
+
+    def create_recorder(self) -> ApplicationRecorder:
+        return POPOApplicationRecorder()
+
+
+class TestNonInterleavingSQLiteInMemory(NonInterleavingNotificationIDsBaseCase):
+    insert_num = 10000
+
+    def create_recorder(self) -> ApplicationRecorder:
+        recorder = SQLiteApplicationRecorder(
+            SQLiteDatastore(db_name="file::memory:?cache=shared")
+        )
+        recorder.create_table()
+        return recorder
+
+
+class TestNonInterleavingSQLiteFileDB(NonInterleavingNotificationIDsBaseCase):
+    insert_num = 10000
+
+    def create_recorder(self) -> ApplicationRecorder:
+        self.uris = tmpfile_uris()
+        self.db_uri = next(self.uris)
+
+        recorder = SQLiteApplicationRecorder(SQLiteDatastore(db_name=self.db_uri))
+        recorder.create_table()
+        return recorder
+
+
+class TestNonInterleavingPostgres(NonInterleavingNotificationIDsBaseCase):
+    insert_num = 100
+
+    def setUp(self) -> None:
+        self.datastore = PostgresDatastore(
+            "eventsourcing",
+            "127.0.0.1",
+            "5432",
+            "eventsourcing",
+            "eventsourcing",
+        )
+        self.drop_table()
+
+    def tearDown(self) -> None:
+        self.drop_table()
+
+    def drop_table(self):
+        drop_postgres_table(self.datastore, "stored_events")
+
+    def create_recorder(self) -> ApplicationRecorder:
+        self.uris = tmpfile_uris()
+        self.db_uri = next(self.uris)
+        recorder = PostgresApplicationRecorder(self.datastore)
+        recorder.create_table()
+        return recorder
+
+
+del NonInterleavingNotificationIDsBaseCase

eventsourcing/tests/persistence_tests/test_popo.py

@@ -0,0 +1,124 @@
+from uuid import uuid4
+
+from eventsourcing.persistence import StoredEvent, Tracking
+from eventsourcing.popo import (
+    Factory,
+    POPOAggregateRecorder,
+    POPOApplicationRecorder,
+    POPOProcessRecorder,
+)
+from eventsourcing.tests.persistence import (
+    AggregateRecorderTestCase,
+    ApplicationRecorderTestCase,
+    InfrastructureFactoryTestCase,
+    ProcessRecorderTestCase,
+)
+from eventsourcing.utils import Environment
+
+
+class TestPOPOAggregateRecorder(AggregateRecorderTestCase):
+    def create_recorder(self):
+        return POPOAggregateRecorder()
+
+
+class TestPOPOApplicationRecorder(ApplicationRecorderTestCase):
+    def create_recorder(self):
+        return POPOApplicationRecorder()
+
+    def test_insert_select(self) -> None:
+        super().test_insert_select()
+
+        # Check select_notifications() does not use negative indexes.
+
+        # Construct the recorder.
+        recorder = self.create_recorder()
+
+        # Write two stored events.
+        stored_event1 = StoredEvent(
+            originator_id=uuid4(),
+            originator_version=self.INITIAL_VERSION,
+            topic="topic1",
+            state=b"state1",
+        )
+        stored_event2 = StoredEvent(
+            originator_id=uuid4(),
+            originator_version=self.INITIAL_VERSION,
+            topic="topic2",
+            state=b"state2",
+        )
+        recorder.insert_events([stored_event1, stored_event2])
+
+        # This was returning 3.
+        self.assertEqual(len(recorder.select_notifications(0, 10)), 2)
+
+        # This was returning 4.
+        self.assertEqual(len(recorder.select_notifications(-1, 10)), 2)
+
+
+class TestPOPOProcessRecorder(ProcessRecorderTestCase):
+    def create_recorder(self):
+        return POPOProcessRecorder()
+
+    def test_performance(self):
+        super().test_performance()
+
+    def test_max_doesnt_increase_when_lower_inserted_later(self) -> None:
+        # Construct the recorder.
+        recorder = self.create_recorder()
+
+        tracking1 = Tracking(
+            application_name="upstream_app",
+            notification_id=1,
+        )
+        tracking2 = Tracking(
+            application_name="upstream_app",
+            notification_id=2,
+        )
+
+        # Insert tracking info.
+        recorder.insert_events(
+            stored_events=[],
+            tracking=tracking2,
+        )
+
+        # Get current position.
+        self.assertEqual(
+            recorder.max_tracking_id("upstream_app"),
+            2,
+        )
+
+        # Insert tracking info.
+        recorder.insert_events(
+            stored_events=[],
+            tracking=tracking1,
+        )
+
+        # Get current position.
+        self.assertEqual(
+            recorder.max_tracking_id("upstream_app"),
+            2,
+        )
+
+
+class TestPOPOInfrastructureFactory(InfrastructureFactoryTestCase):
+    def setUp(self) -> None:
+        self.env = Environment("TestCase")
+        super().setUp()
+
+    def expected_factory_class(self):
+        return Factory
+
+    def expected_aggregate_recorder_class(self):
+        return POPOAggregateRecorder
+
+    def expected_application_recorder_class(self):
+        return POPOApplicationRecorder
+
+    def expected_process_recorder_class(self):
+        return POPOProcessRecorder
+
+
+del AggregateRecorderTestCase
+del ApplicationRecorderTestCase
+del ProcessRecorderTestCase
+del InfrastructureFactoryTestCase