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

eventsourcing/tests/domain_tests/test_domainevent.py

@@ -0,0 +1,80 @@
+from dataclasses import _DataclassParams
+from datetime import datetime, timezone
+from time import sleep
+from unittest.case import TestCase
+from uuid import UUID, uuid4
+
+from eventsourcing.domain import DomainEvent, MetaDomainEvent
+
+
+class TestMetaDomainEvent(TestCase):
+    def test_class_instance_defined_as_frozen_dataclass(self):
+        class A(metaclass=MetaDomainEvent):
+            pass
+
+        self.assertIsInstance(A, type)
+        self.assertTrue("__dataclass_params__" in A.__dict__)
+        self.assertIsInstance(A.__dataclass_params__, _DataclassParams)
+        self.assertTrue(A.__dataclass_params__.frozen)
+
+
+class TestDomainEvent(TestCase):
+    def test_domain_event_class_is_a_meta_domain_event(self):
+        self.assertIsInstance(DomainEvent, MetaDomainEvent)
+
+    def test_create_timestamp(self):
+        before = datetime.now(tz=timezone.utc)
+        sleep(1e-5)
+        timestamp = DomainEvent.create_timestamp()
+        sleep(1e-5)
+        after = datetime.now(tz=timezone.utc)
+        self.assertGreater(timestamp, before)
+        self.assertGreater(after, timestamp)
+
+    def test_domain_event_instance(self):
+        originator_id = uuid4()
+        originator_version = 101
+        timestamp = DomainEvent.create_timestamp()
+        a = DomainEvent(
+            originator_id=originator_id,
+            originator_version=originator_version,
+            timestamp=timestamp,
+        )
+        self.assertEqual(a.originator_id, originator_id)
+        self.assertEqual(a.originator_version, originator_version)
+        self.assertEqual(a.timestamp, timestamp)
+
+    def test_examples(self):
+        # Define an 'account opened' domain event.
+        class AccountOpened(DomainEvent):
+            full_name: str
+
+        # Create an 'account opened' event.
+        event3 = AccountOpened(
+            originator_id=uuid4(),
+            originator_version=0,
+            timestamp=AccountOpened.create_timestamp(),
+            full_name="Alice",
+        )
+
+        self.assertEqual(event3.full_name, "Alice")
+        assert isinstance(event3.originator_id, UUID)
+        self.assertEqual(event3.originator_version, 0)
+
+        # Define a 'full name updated' domain event.
+        class FullNameUpdated(DomainEvent):
+            full_name: str
+            timestamp: datetime
+
+        # Create a 'full name updated' domain event.
+        event4 = FullNameUpdated(
+            originator_id=event3.originator_id,
+            originator_version=1,
+            timestamp=FullNameUpdated.create_timestamp(),
+            full_name="Bob",
+        )
+
+        # Check the attribute values of the domain event.
+        self.assertEqual(event4.full_name, "Bob")
+        assert isinstance(event4.originator_id, UUID)
+        self.assertEqual(event4.originator_version, 1)

eventsourcing/tests/interface_tests/test_remotenotificationlog.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+
+import json
+import threading
+from abc import abstractmethod
+from http.client import HTTPConnection
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from threading import Event, Thread
+from typing import Callable, ClassVar, List, Sequence
+from unittest.case import TestCase
+from uuid import UUID
+
+from eventsourcing.interface import (
+    NotificationLogInterface,
+    NotificationLogJSONClient,
+    NotificationLogJSONService,
+)
+from eventsourcing.tests.application import BankAccounts
+
+
+class TestRemoteNotificationLog(TestCase):
+    def test_directly(self):
+        client = BankAccountsJSONClient(BankAccountsJSONService(BankAccounts()))
+        account_id1 = client.open_account("Alice", "alice@example.com")
+        account_id2 = client.open_account("Bob", "bob@example.com")
+
+        # Get the "first" section of log.
+        section = client.log["1,10"]
+        self.assertEqual(len(section.items), 2)
+        self.assertEqual(section.items[0].originator_id, account_id1)
+        self.assertEqual(section.items[1].originator_id, account_id2)
+
+        # Get notifications start 1, limit 10.
+        notifications = client.log.select(start=1, limit=10)
+        self.assertEqual(len(notifications), 2)
+        self.assertEqual(notifications[0].originator_id, account_id1)
+        self.assertEqual(notifications[1].originator_id, account_id2)
+
+    def test_with_http(self):
+        server_address = ("127.0.0.1", 8080)
+
+        server = HTTPApplicationServer(
+            address=server_address,
+            handler=BankAccountsHTTPHandler,
+        )
+        server.start()
+        if not server.is_running.wait(timeout=5):
+            server.stop()
+            self.fail("Unable to start HTTPApplicationServer")
+
+        try:
+            client = BankAccountsJSONClient(
+                BankAccountsHTTPClient(server_address=server_address)
+            )
+
+            account_id1 = client.open_account("Alice", "alice@example.com")
+            account_id2 = client.open_account("Bob", "bob@example.com")
+
+            # Get the "first" section of log.
+            section = client.log["1,10"]
+            self.assertEqual(len(section.items), 2)
+            self.assertEqual(section.items[0].originator_id, account_id1)
+            self.assertEqual(section.items[1].originator_id, account_id2)
+
+            # Get notifications start 1, limit 10.
+            notifications = client.log.select(1, 10)
+            self.assertEqual(len(notifications), 2)
+            self.assertEqual(notifications[0].originator_id, account_id1)
+            self.assertEqual(notifications[1].originator_id, account_id2)
+        finally:
+            server.stop()
+
+    def test_with_http_and_threads(self):
+        server_address = ("127.0.0.1", 8081)
+
+        server = HTTPApplicationServer(
+            address=server_address,
+            handler=BankAccountsHTTPHandler,
+        )
+        server.start()
+        if not server.is_running.wait(timeout=5):
+            server.stop()
+            self.fail("Unable to start HTTPApplicationServer")
+
+        try:
+            self.has_errors = False
+
+            def open_account():
+                client = BankAccountsJSONClient(
+                    BankAccountsHTTPClient(server_address=server_address)
+                )
+                try:
+                    for _ in range(30):
+                        client.open_account("Alice", "alice@example.com")
+                    # print(threading.get_ident(), account_id1)
+                except Exception as e:
+                    print(threading.get_ident(), "error:", e)
+                    self.has_errors = True
+                    raise
+
+            thread1 = Thread(target=open_account)
+            thread1.start()
+            thread2 = Thread(target=open_account)
+            thread2.start()
+
+            thread1.join()
+            thread2.join()
+
+            self.assertFalse(self.has_errors)
+
+            # Check the notification log.
+            client = BankAccountsJSONClient(
+                BankAccountsHTTPClient(server_address=server_address)
+            )
+            self.assertEqual(len(client.log["1,10"].items), 10)
+            self.assertEqual(len(client.log["11,20"].items), 10)
+            self.assertEqual(len(client.log["21,30"].items), 10)
+            self.assertEqual(len(client.log["31,40"].items), 10)
+            self.assertEqual(len(client.log["41,50"].items), 10)
+            self.assertEqual(len(client.log["51,60"].items), 10)
+            self.assertEqual(len(client.log["61,70"].items), 0)
+
+            self.assertEqual(len(client.log.select(start=1, limit=10)), 10)
+            self.assertEqual(len(client.log.select(start=11, limit=10)), 10)
+            self.assertEqual(len(client.log.select(start=21, limit=10)), 10)
+            self.assertEqual(len(client.log.select(start=31, limit=10)), 10)
+            self.assertEqual(len(client.log.select(start=41, limit=10)), 10)
+            self.assertEqual(len(client.log.select(start=51, limit=10)), 10)
+            self.assertEqual(len(client.log.select(start=61, limit=10)), 0)
+
+        finally:
+            server.stop()
+
+
+class BankAccountsInterface(NotificationLogInterface):
+    @abstractmethod
+    def open_account(self, body: str) -> str:
+        pass
+
+
+class BankAccountsJSONService(
+    BankAccountsInterface,
+    NotificationLogJSONService[BankAccounts],
+):
+    def open_account(self, request: str) -> str:
+        kwargs = json.loads(request)
+        account_id = self.app.open_account(**kwargs)
+        return json.dumps({"account_id": account_id.hex})
+
+
+class BankAccountsJSONClient:
+    def __init__(self, interface: BankAccountsInterface):
+        self.interface = interface
+        self.log = NotificationLogJSONClient(interface)
+
+    def open_account(self, full_name, email_address) -> UUID:
+        body = json.dumps(
+            {
+                "full_name": full_name,
+                "email_address": email_address,
+            }
+        )
+        body = self.interface.open_account(body)
+        return UUID(json.loads(body)["account_id"])
+
+
+class HTTPApplicationServer(Thread):
+    prepare: ClassVar[List[Callable]] = []
+
+    def __init__(self, address, handler):
+        super().__init__(daemon=True)
+        self.server = HTTPServer(
+            server_address=address,
+            RequestHandlerClass=handler,
+        )
+        self.is_running = Event()
+
+    def run(self):
+        [f() for f in self.prepare]
+        self.is_running.set()
+        self.server.serve_forever()
+
+    def stop(self):
+        self.server.shutdown()
+        self.join()
+
+    @classmethod
+    def before_first_request(cls, f):
+        HTTPApplicationServer.prepare.append(f)
+        return f
+
+
+class BankAccountsHTTPHandler(BaseHTTPRequestHandler):
+    def do_PUT(self):  # noqa: N802
+        if self.path.startswith("/accounts/"):
+            length = int(self.headers["Content-Length"])
+            request_msg = self.rfile.read(length).decode("utf8")
+            body = bank_accounts_service.open_account(request_msg)
+            status = 201
+        else:
+            body = "Not found: " + self.path
+            status = 404
+        self.send(body, status)
+
+    def do_GET(self):  # noqa: N802
+        if self.path.startswith("/notifications/"):
+            section_id = self.path.split("/")[-1]
+            body = bank_accounts_service.get_log_section(section_id)
+            status = 200
+        elif self.path.startswith("/notifications"):
+            args = self.path.split("?")[-1].split("&")
+            args = [p.split("=") for p in args]
+            args = {p[0]: p[1] for p in args}
+            start = int(args["start"])
+            limit = int(args["limit"])
+
+            body = bank_accounts_service.get_notifications(start=start, limit=limit)
+            status = 200
+        else:
+            body = "Not found: " + self.path
+            status = 404
+        self.send(body, status)
+
+    def send(self, body: str, status: int):
+        self.send_response(status)
+        self.send_header("Content-type", "text/html")
+        self.end_headers()
+        self.wfile.write(body.encode("utf8"))
+
+
+class BankAccountsHTTPClient(BankAccountsInterface):
+    def __init__(self, server_address):
+        self.connection = HTTPConnection(*server_address)
+
+    def get_log_section(self, section_id: str) -> str:
+        return self._request("GET", f"/notifications/{section_id}")
+
+    def get_notifications(
+        self, start: int, limit: int, topics: Sequence[str] = ()
+    ) -> str:
+        return self._request("GET", f"/notifications?start={start}&limit={limit}")
+
+    def open_account(self, body: str) -> str:
+        return self._request("PUT", "/accounts/", body.encode("utf8"))
+
+    def _request(self, method, url, body=None):
+        self.connection.request(method, url, body)
+        response = self.connection.getresponse()
+        return response.read().decode()
+
+
+bank_accounts_service: BankAccountsInterface
+
+
+@HTTPApplicationServer.before_first_request
+def init_bank_accounts() -> None:
+    global bank_accounts_service  # noqa: PLW0603
+    bank_accounts_service = BankAccountsJSONService(BankAccounts())

eventsourcing/tests/persistence.py

@@ -10,7 +10,7 @@ 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, Optional
+from typing import Any, Dict, List
 from unittest import TestCase
 from uuid import UUID, uuid4
 
@@ -70,12 +70,13 @@ class AggregateRecorderTestCase(TestCase, ABC):
         # Select stored events, expect list of one.
         stored_events = recorder.select_events(originator_id1)
         self.assertEqual(len(stored_events), 1)
-        assert stored_events[0].originator_id == originator_id1
-        assert stored_events[0].originator_version == self.INITIAL_VERSION
-        assert stored_events[0].topic == "topic1"
+        self.assertEqual(stored_events[0].originator_id, originator_id1)
+        self.assertEqual(stored_events[0].originator_version, self.INITIAL_VERSION)
+        self.assertEqual(stored_events[0].topic, "topic1")
+        self.assertEqual(stored_events[0].state, b"state1")
+        self.assertIsInstance(stored_events[0].state, bytes)
 
         # Check get record conflict error if attempt to store it again.
-        stored_events = recorder.select_events(originator_id1)
         with self.assertRaises(IntegrityError):
             recorder.insert_events([stored_event1])
 
@@ -95,9 +96,11 @@ class AggregateRecorderTestCase(TestCase, ABC):
         # Check still only have one record.
         stored_events = recorder.select_events(originator_id1)
         self.assertEqual(len(stored_events), 1)
-        assert stored_events[0].originator_id == stored_event1.originator_id
-        assert stored_events[0].originator_version == stored_event1.originator_version
-        assert stored_events[0].topic == stored_event1.topic
+        self.assertEqual(stored_events[0].originator_id, stored_event1.originator_id)
+        self.assertEqual(
+            stored_events[0].originator_version, stored_event1.originator_version
+        )
+        self.assertEqual(stored_events[0].topic, stored_event1.topic)
 
         # Check can write two events together.
         stored_event3 = StoredEvent(
@@ -112,18 +115,18 @@ class AggregateRecorderTestCase(TestCase, ABC):
         # Check we got what was written.
         stored_events = recorder.select_events(originator_id1)
         self.assertEqual(len(stored_events), 3)
-        assert stored_events[0].originator_id == originator_id1
-        assert stored_events[0].originator_version == self.INITIAL_VERSION
-        assert stored_events[0].topic == "topic1"
+        self.assertEqual(stored_events[0].originator_id, originator_id1)
+        self.assertEqual(stored_events[0].originator_version, self.INITIAL_VERSION)
+        self.assertEqual(stored_events[0].topic, "topic1")
         self.assertEqual(stored_events[0].state, b"state1")
-        assert stored_events[1].originator_id == originator_id1
-        assert stored_events[1].originator_version == self.INITIAL_VERSION + 1
-        assert stored_events[1].topic == "topic2"
-        assert stored_events[1].state == b"state2"
-        assert stored_events[2].originator_id == originator_id1
-        assert stored_events[2].originator_version == self.INITIAL_VERSION + 2
-        assert stored_events[2].topic == "topic3"
-        assert stored_events[2].state == b"state3"
+        self.assertEqual(stored_events[1].originator_id, originator_id1)
+        self.assertEqual(stored_events[1].originator_version, self.INITIAL_VERSION + 1)
+        self.assertEqual(stored_events[1].topic, "topic2")
+        self.assertEqual(stored_events[1].state, b"state2")
+        self.assertEqual(stored_events[2].originator_id, originator_id1)
+        self.assertEqual(stored_events[2].originator_version, self.INITIAL_VERSION + 2)
+        self.assertEqual(stored_events[2].topic, "topic3")
+        self.assertEqual(stored_events[2].state, b"state3")
 
         # Check we can get the last one recorded (used to get last snapshot).
         stored_events = recorder.select_events(originator_id1, desc=True, limit=1)
@@ -248,21 +251,19 @@ class ApplicationRecorderTestCase(TestCase, ABC):
             topic="topic2",
             state=b"state2",
         )
-        stored_event3 = StoredEvent(
-            originator_id=originator_id2,
-            originator_version=self.INITIAL_VERSION,
-            topic="topic3",
-            state=b"state3",
-        )
-
-        notification_ids = recorder.insert_events([])
-        self.assertEqual(notification_ids, [])
 
         notification_ids = recorder.insert_events([stored_event1, stored_event2])
         self.assertEqual(
             notification_ids, [max_notification_id + 1, max_notification_id + 2]
         )
 
+        # 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])
         self.assertEqual(notification_ids, [max_notification_id + 3])
 
@@ -273,6 +274,10 @@ class ApplicationRecorderTestCase(TestCase, ABC):
         self.assertEqual(len(stored_events1), 2)
         self.assertEqual(len(stored_events2), 1)
 
+        # Check get record conflict error if attempt to store it again.
+        with self.assertRaises(IntegrityError):
+            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)
         self.assertEqual(len(notifications), 3)
@@ -497,7 +502,7 @@ class ApplicationRecorderTestCase(TestCase, ABC):
         durations: Dict[int, float] = {}
 
         # Match this to the batch page size in postgres insert for max throughput.
-        NUM_EVENTS = 500
+        num_events = 500
 
         started = datetime.now()
 
@@ -518,7 +523,7 @@ class ApplicationRecorderTestCase(TestCase, ABC):
                     topic="topic",
                     state=b"state",
                 )
-                for i in range(NUM_EVENTS)
+                for i in range(num_events)
             ]
 
             try:
@@ -534,11 +539,11 @@ class ApplicationRecorderTestCase(TestCase, ABC):
                 counts[thread_id] += 1
                 durations[thread_id] = duration
 
-        NUM_JOBS = 60
+        num_jobs = 60
 
         with ThreadPoolExecutor(max_workers=4) as executor:
             futures = []
-            for _ in range(NUM_JOBS):
+            for _ in range(num_jobs):
                 future = executor.submit(insert_events)
                 # future.add_done_callback(self.close_db_connection)
                 futures.append(future)
@@ -547,7 +552,7 @@ class ApplicationRecorderTestCase(TestCase, ABC):
 
         self.assertFalse(errors_happened.is_set(), "There were errors (see above)")
         ended = datetime.now()
-        rate = NUM_JOBS * NUM_EVENTS / (ended - started).total_seconds()
+        rate = num_jobs * num_events / (ended - started).total_seconds()
         print(f"Rate: {rate:.0f} inserts per second")
 
     def close_db_connection(self, *args: Any) -> None:
@@ -808,7 +813,7 @@ class NonInterleavingNotificationIDsBaseCase(ABC, TestCase):
 
 
 class InfrastructureFactoryTestCase(ABC, TestCase):
-    env: Optional[Environment] = None
+    env: Environment | None = None
 
     @abstractmethod
     def expected_factory_class(self):
@@ -1074,7 +1079,7 @@ class TranscoderTestCase(TestCase):
         self.transcoder = self.construct_transcoder()
 
     def construct_transcoder(self):
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def test_str(self):
         obj = "a"
@@ -1151,7 +1156,7 @@ class TranscoderTestCase(TestCase):
         self.assertEqual(data, b'{"a":{"b":{"c":1}}}')
         self.assertEqual(obj, self.transcoder.decode(data))
 
-        # Todo: Int keys?
+        # TODO: Int keys?
         # obj = {1: "a"}
         # data = self.transcoder.encode(obj)
         # self.assertEqual(data, b'{1:{"a"}')
@@ -1288,11 +1293,9 @@ class TranscoderTestCase(TestCase):
 
         self.assertEqual(
             cm.exception.args[0],
-            (
-                "Object of type <class 'eventsourcing.tests.persistence."
-                "MyClass'> is not serializable. Please define "
-                "and register a custom transcoding for this type."
-            ),
+            "Object of type <class 'eventsourcing.tests.persistence."
+            "MyClass'> is not serializable. Please define "
+            "and register a custom transcoding for this type.",
         )
 
         # Expect a TypeError when encoding because transcoding not registered (nested).
@@ -1301,11 +1304,9 @@ class TranscoderTestCase(TestCase):
 
         self.assertEqual(
             cm.exception.args[0],
-            (
-                "Object of type <class 'eventsourcing.tests.persistence."
-                "MyClass'> is not serializable. Please define "
-                "and register a custom transcoding for this type."
-            ),
+            "Object of type <class 'eventsourcing.tests.persistence."
+            "MyClass'> is not serializable. Please define "
+            "and register a custom transcoding for this type.",
         )
 
         # Check we get a TypeError when decoding because transcodings aren't registered.
@@ -1316,8 +1317,6 @@ class TranscoderTestCase(TestCase):
 
         self.assertEqual(
             cm.exception.args[0],
-            (
-                "Data serialized with name 'custom_type3_as_dict' is not "
-                "deserializable. Please register a custom transcoding for this type."
-            ),
+            "Data serialized with name 'custom_type3_as_dict' is not "
+            "deserializable. Please register a custom transcoding for this type.",
         )

eventsourcing/tests/persistence_tests/test_aes.py

@@ -0,0 +1,93 @@
+from base64 import b64encode
+from unittest.case import TestCase
+
+from eventsourcing.cipher import AESCipher
+from eventsourcing.utils import Environment
+
+
+class TestAESCipher(TestCase):
+    def test_createkey(self):
+        environment = Environment()
+
+        # Valid key lengths.
+        key = AESCipher.create_key(16)
+        environment["CIPHER_KEY"] = key
+        AESCipher(environment)
+
+        key = AESCipher.create_key(24)
+        environment["CIPHER_KEY"] = key
+        AESCipher(environment)
+
+        key = AESCipher.create_key(32)
+        environment["CIPHER_KEY"] = key
+        AESCipher(environment)
+
+        # Non-valid key lengths (on generate key).
+        with self.assertRaises(ValueError):
+            AESCipher.create_key(12)
+
+        with self.assertRaises(ValueError):
+            AESCipher.create_key(20)
+
+        with self.assertRaises(ValueError):
+            AESCipher.create_key(28)
+
+        with self.assertRaises(ValueError):
+            AESCipher.create_key(36)
+
+        # Non-valid key lengths (on construction).
+        def create_key(num_bytes):
+            return b64encode(AESCipher.random_bytes(num_bytes)).decode("utf8")
+
+        key = create_key(12)
+        environment["CIPHER_KEY"] = key
+        with self.assertRaises(ValueError):
+            AESCipher(environment)
+
+        key = create_key(20)
+        environment["CIPHER_KEY"] = key
+        with self.assertRaises(ValueError):
+            AESCipher(environment)
+
+        key = create_key(28)
+        environment["CIPHER_KEY"] = key
+        with self.assertRaises(ValueError):
+            AESCipher(environment)
+
+        key = create_key(36)
+        environment["CIPHER_KEY"] = key
+        with self.assertRaises(ValueError):
+            AESCipher(environment)
+
+    def test_encrypt_and_decrypt(self):
+        environment = Environment()
+
+        key = AESCipher.create_key(16)
+        environment["CIPHER_KEY"] = key
+
+        # Check plain text can be encrypted and recovered.
+        plain_text = b"some text"
+        cipher = AESCipher(environment)
+        cipher_text = cipher.encrypt(plain_text)
+        cipher = AESCipher(environment)
+        recovered_text = cipher.decrypt(cipher_text)
+        self.assertEqual(recovered_text, plain_text)
+
+        # Check raises on invalid nonce.
+        with self.assertRaises(ValueError):
+            cipher.decrypt(cipher_text[:10])
+
+        # Check raises on invalid tag.
+        with self.assertRaises(ValueError):
+            cipher.decrypt(cipher_text[:20])
+
+        # Check raises on invalid data.
+        with self.assertRaises(ValueError):
+            cipher.decrypt(cipher_text[:30])
+
+        # Check raises on invalid key.
+        key = AESCipher.create_key(16)
+        environment["CIPHER_KEY"] = key
+        cipher = AESCipher(environment)
+        with self.assertRaises(ValueError):
+            cipher.decrypt(cipher_text)