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

eventsourcing/tests/domain_tests/test_domainevent.py

@@ -1,80 +0,0 @@
-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

@@ -1,258 +0,0 @@
-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_tests/test_aes.py

@@ -1,93 +0,0 @@
-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)