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

eventsourcing/examples/aggregate8/test_compression_and_encryption.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from unittest import TestCase
+
+from eventsourcing.cipher import AESCipher
+from eventsourcing.examples.aggregate8.application import DogSchool
+
+
+class TestDogSchool(TestCase):
+    def test_dog_school(self) -> None:
+        # Construct application object.
+        school = DogSchool(
+            env={
+                "COMPRESSOR_TOPIC": "eventsourcing.compressor:ZlibCompressor",
+                "CIPHER_TOPIC": "eventsourcing.cipher:AESCipher",
+                "CIPHER_KEY": AESCipher.create_key(num_bytes=32),
+            }
+        )
+
+        # Evolve application state.
+        dog_id = school.register_dog("Fido")
+        school.add_trick(dog_id, "roll over")
+        school.add_trick(dog_id, "play dead")
+
+        # Query application state.
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        assert dog["tricks"] == ("roll over", "play dead")
+
+        # Select notifications.
+        notifications = school.notification_log.select(start=1, limit=10)
+        assert len(notifications) == 3
+
+        # Take snapshot.
+        school.take_snapshot(dog_id, version=3)
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        assert dog["tricks"] == ("roll over", "play dead")
+
+        # Continue with snapshotted aggregate.
+        school.add_trick(dog_id, "fetch ball")
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        assert dog["tricks"] == ("roll over", "play dead", "fetch ball")

eventsourcing/examples/aggregate8/test_snapshotting_intervals.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar, Dict, Type
+from unittest import TestCase
+
+from eventsourcing.examples.aggregate8.application import DogSchool
+from eventsourcing.examples.aggregate8.domainmodel import Dog
+
+if TYPE_CHECKING:  # pragma: nocover
+    from eventsourcing.domain import MutableOrImmutableAggregate
+
+
+class SubDogSchool(DogSchool):
+    snapshotting_intervals: ClassVar[
+        Dict[Type[MutableOrImmutableAggregate], int] | None
+    ] = {Dog: 1}
+
+
+class TestDogSchool(TestCase):
+    def test_dog_school(self) -> None:
+        # Construct application object.
+        school = SubDogSchool()
+
+        # Evolve application state.
+        dog_id = school.register_dog("Fido")
+        assert school.snapshots is not None
+        self.assertEqual(1, len(list(school.snapshots.get(dog_id))))
+
+        school.add_trick(dog_id, "roll over")
+        self.assertEqual(2, len(list(school.snapshots.get(dog_id))))
+
+        school.add_trick(dog_id, "play dead")
+        self.assertEqual(3, len(list(school.snapshots.get(dog_id))))
+
+        # Query application state.
+        dog = school.get_dog(dog_id)
+        self.assertEqual(dog["name"], "Fido")
+        self.assertEqual(dog["tricks"], ("roll over", "play dead"))

eventsourcing/examples/bankaccounts/application.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from eventsourcing.application import AggregateNotFoundError, Application
+from eventsourcing.examples.bankaccounts.domainmodel import BankAccount
+
+if TYPE_CHECKING:  # pragma: nocover
+    from decimal import Decimal
+    from uuid import UUID
+
+
+class BankAccounts(Application):
+    def open_account(self, full_name: str, email_address: str) -> UUID:
+        account = BankAccount(
+            full_name=full_name,
+            email_address=email_address,
+        )
+        self.save(account)
+        return account.id
+
+    def get_account(self, account_id: UUID) -> BankAccount:
+        try:
+            return self.repository.get(account_id)
+        except AggregateNotFoundError:
+            raise AccountNotFoundError(account_id) from None
+
+    def get_balance(self, account_id: UUID) -> Decimal:
+        account = self.get_account(account_id)
+        return account.balance
+
+    def deposit_funds(self, credit_account_id: UUID, amount: Decimal) -> None:
+        account = self.get_account(credit_account_id)
+        account.credit(amount)
+        self.save(account)
+
+    def withdraw_funds(self, debit_account_id: UUID, amount: Decimal) -> None:
+        account = self.get_account(debit_account_id)
+        account.debit(amount)
+        self.save(account)
+
+    def transfer_funds(
+        self,
+        debit_account_id: UUID,
+        credit_account_id: UUID,
+        amount: Decimal,
+    ) -> None:
+        debit_account = self.get_account(debit_account_id)
+        credit_account = self.get_account(credit_account_id)
+        debit_account.debit(amount)
+        credit_account.credit(amount)
+        self.save(debit_account, credit_account)
+
+    def set_overdraft_limit(self, account_id: UUID, overdraft_limit: Decimal) -> None:
+        account = self.get_account(account_id)
+        account.set_overdraft_limit(overdraft_limit)
+        self.save(account)
+
+    def get_overdraft_limit(self, account_id: UUID) -> Decimal:
+        account = self.get_account(account_id)
+        return account.overdraft_limit
+
+    def close_account(self, account_id: UUID) -> None:
+        account = self.get_account(account_id)
+        account.close()
+        self.save(account)
+
+
+class AccountNotFoundError(Exception):
+    pass

eventsourcing/examples/bankaccounts/domainmodel.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from decimal import Decimal
+
+from eventsourcing.domain import Aggregate, event
+
+
+class BankAccount(Aggregate):
+    @event("Opened")
+    def __init__(self, full_name: str, email_address: str):
+        self.full_name = full_name
+        self.email_address = email_address
+        self.balance = Decimal("0.00")
+        self.overdraft_limit = Decimal("0.00")
+        self.is_closed = False
+
+    @event("Credited")
+    def credit(self, amount: Decimal) -> None:
+        self.check_account_is_not_closed()
+        self.balance += amount
+
+    @event("Debited")
+    def debit(self, amount: Decimal) -> None:
+        self.check_account_is_not_closed()
+        self.check_has_sufficient_funds(amount)
+        self.balance -= amount
+
+    @event("OverdraftLimitSet")
+    def set_overdraft_limit(self, overdraft_limit: Decimal) -> None:
+        assert overdraft_limit > Decimal("0.00")
+        self.check_account_is_not_closed()
+        self.overdraft_limit = overdraft_limit
+
+    @event("Closed")
+    def close(self) -> None:
+        self.is_closed = True
+
+    def check_account_is_not_closed(self) -> None:
+        if self.is_closed:
+            raise AccountClosedError({"account_id": self.id})
+
+    def check_has_sufficient_funds(self, amount: Decimal) -> None:
+        if self.balance - amount < -self.overdraft_limit:
+            raise InsufficientFundsError({"account_id": self.id})
+
+
+class TransactionError(Exception):
+    pass
+
+
+class AccountClosedError(TransactionError):
+    pass
+
+
+class InsufficientFundsError(TransactionError):
+    pass

eventsourcing/examples/bankaccounts/test.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+import unittest
+from decimal import Decimal
+from uuid import uuid4
+
+from eventsourcing.examples.bankaccounts.application import (
+    AccountNotFoundError,
+    BankAccounts,
+)
+from eventsourcing.examples.bankaccounts.domainmodel import (
+    AccountClosedError,
+    InsufficientFundsError,
+)
+
+
+class TestBankAccounts(unittest.TestCase):
+    def test(self) -> None:
+        app = BankAccounts()
+
+        # Check account not found error.
+        with self.assertRaises(AccountNotFoundError):
+            app.get_balance(uuid4())
+
+        # Create account #1.
+        account_id1 = app.open_account(
+            full_name="Alice",
+            email_address="alice@example.com",
+        )
+
+        # Check balance of account #1.
+        self.assertEqual(app.get_balance(account_id1), Decimal("0.00"))
+
+        # Deposit funds in account #1.
+        app.deposit_funds(
+            credit_account_id=account_id1,
+            amount=Decimal("200.00"),
+        )
+
+        # Check balance of account #1.
+        self.assertEqual(app.get_balance(account_id1), Decimal("200.00"))
+
+        # Withdraw funds from account #1.
+        app.withdraw_funds(
+            debit_account_id=account_id1,
+            amount=Decimal("50.00"),
+        )
+
+        # Check balance of account #1.
+        self.assertEqual(app.get_balance(account_id1), Decimal("150.00"))
+
+        # Fail to withdraw funds from account #1- insufficient funds.
+        with self.assertRaises(InsufficientFundsError):
+            app.withdraw_funds(
+                debit_account_id=account_id1,
+                amount=Decimal("151.00"),
+            )
+
+        # Check balance of account #1 - should be unchanged.
+        self.assertEqual(app.get_balance(account_id1), Decimal("150.00"))
+
+        # Create account #2.
+        account_id2 = app.open_account(
+            full_name="Bob",
+            email_address="bob@example.com",
+        )
+
+        # Transfer funds from account #1 to account #2.
+        app.transfer_funds(
+            debit_account_id=account_id1,
+            credit_account_id=account_id2,
+            amount=Decimal("100.00"),
+        )
+
+        # Check balances.
+        self.assertEqual(app.get_balance(account_id1), Decimal("50.00"))
+        self.assertEqual(app.get_balance(account_id2), Decimal("100.00"))
+
+        # Fail to transfer funds - insufficient funds.
+        with self.assertRaises(InsufficientFundsError):
+            app.transfer_funds(
+                debit_account_id=account_id1,
+                credit_account_id=account_id2,
+                amount=Decimal("1000.00"),
+            )
+
+        # Check balances - should be unchanged.
+        self.assertEqual(app.get_balance(account_id1), Decimal("50.00"))
+        self.assertEqual(app.get_balance(account_id2), Decimal("100.00"))
+
+        # Close account #1.
+        app.close_account(account_id1)
+
+        # Fail to transfer funds - account #1 is closed.
+        with self.assertRaises(AccountClosedError):
+            app.transfer_funds(
+                debit_account_id=account_id1,
+                credit_account_id=account_id2,
+                amount=Decimal("50.00"),
+            )
+
+        # Fail to withdraw funds - account #1 is closed.
+        with self.assertRaises(AccountClosedError):
+            app.withdraw_funds(
+                debit_account_id=account_id1,
+                amount=Decimal("1.00"),
+            )
+
+        # Fail to deposit funds - account #1 is closed.
+        with self.assertRaises(AccountClosedError):
+            app.deposit_funds(
+                credit_account_id=account_id1,
+                amount=Decimal("1000.00"),
+            )
+
+        # Fail to set overdraft limit on account #1 - account is closed.
+        with self.assertRaises(AccountClosedError):
+            app.set_overdraft_limit(
+                account_id=account_id1,
+                overdraft_limit=Decimal("500.00"),
+            )
+
+        # Check balances - should be unchanged.
+        self.assertEqual(app.get_balance(account_id1), Decimal("50.00"))
+        self.assertEqual(app.get_balance(account_id2), Decimal("100.00"))
+
+        # Check overdraft limits - should be unchanged.
+        self.assertEqual(
+            app.get_overdraft_limit(account_id1),
+            Decimal("0.00"),
+        )
+        self.assertEqual(
+            app.get_overdraft_limit(account_id2),
+            Decimal("0.00"),
+        )
+
+        # Set overdraft limit on account #2.
+        app.set_overdraft_limit(
+            account_id=account_id2,
+            overdraft_limit=Decimal("500.00"),
+        )
+
+        # Can't set negative overdraft limit.
+        with self.assertRaises(AssertionError):
+            app.set_overdraft_limit(
+                account_id=account_id2,
+                overdraft_limit=Decimal("-500.00"),
+            )
+
+        # Check overdraft limit of account #2.
+        self.assertEqual(
+            app.get_overdraft_limit(account_id2),
+            Decimal("500.00"),
+        )
+
+        # Withdraw funds from account #2.
+        app.withdraw_funds(
+            debit_account_id=account_id2,
+            amount=Decimal("500.00"),
+        )
+
+        # Check balance of account #2 - should be overdrawn.
+        self.assertEqual(
+            app.get_balance(account_id2),
+            Decimal("-400.00"),
+        )
+
+        # Fail to withdraw funds from account #2 - insufficient funds.
+        with self.assertRaises(InsufficientFundsError):
+            app.withdraw_funds(
+                debit_account_id=account_id2,
+                amount=Decimal("101.00"),
+            )

eventsourcing/examples/cargoshipping/application.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, List, cast
+
+from eventsourcing.application import Application
+from eventsourcing.examples.cargoshipping.domainmodel import (
+    REGISTERED_ROUTES,
+    Cargo,
+    HandlingActivity,
+    Itinerary,
+    Leg,
+    Location,
+)
+from eventsourcing.persistence import Transcoder, Transcoding
+
+if TYPE_CHECKING:  # pragma: nocover
+    from datetime import datetime
+    from uuid import UUID
+
+
+class LocationAsName(Transcoding):
+    type = Location
+    name = "location"
+
+    def encode(self, obj: Location) -> str:
+        return obj.name
+
+    def decode(self, data: str) -> Location:
+        assert isinstance(data, str)
+        return Location[data]
+
+
+class HandlingActivityAsName(Transcoding):
+    type = HandlingActivity
+    name = "handling_activity"
+
+    def encode(self, obj: HandlingActivity) -> str:
+        return obj.name
+
+    def decode(self, data: str) -> HandlingActivity:
+        assert isinstance(data, str)
+        return HandlingActivity[data]
+
+
+class ItineraryAsDict(Transcoding):
+    type = Itinerary
+    name = "itinerary"
+
+    def encode(self, obj: Itinerary) -> Dict[str, Any]:
+        return obj.__dict__
+
+    def decode(self, data: Dict[str, Any]) -> Itinerary:
+        assert isinstance(data, dict)
+        return Itinerary(**data)
+
+
+class LegAsDict(Transcoding):
+    type = Leg
+    name = "leg"
+
+    def encode(self, obj: Leg) -> Dict[str, Any]:
+        return obj.__dict__
+
+    def decode(self, data: Dict[str, Any]) -> Leg:
+        assert isinstance(data, dict)
+        return Leg(**data)
+
+
+class BookingApplication(Application):
+    def register_transcodings(self, transcoder: Transcoder) -> None:
+        super().register_transcodings(transcoder)
+        transcoder.register(LocationAsName())
+        transcoder.register(HandlingActivityAsName())
+        transcoder.register(ItineraryAsDict())
+        transcoder.register(LegAsDict())
+
+    def book_new_cargo(
+        self,
+        origin: Location,
+        destination: Location,
+        arrival_deadline: datetime,
+    ) -> UUID:
+        cargo = Cargo.new_booking(origin, destination, arrival_deadline)
+        self.save(cargo)
+        return cargo.id
+
+    def change_destination(self, tracking_id: UUID, destination: Location) -> None:
+        cargo = self.get_cargo(tracking_id)
+        cargo.change_destination(destination)
+        self.save(cargo)
+
+    def request_possible_routes_for_cargo(self, tracking_id: UUID) -> List[Itinerary]:
+        cargo = self.get_cargo(tracking_id)
+        from_location = (cargo.last_known_location or cargo.origin).value
+        to_location = cargo.destination.value
+        try:
+            possible_routes = REGISTERED_ROUTES[(from_location, to_location)]
+        except KeyError:
+            msg = f"Can't find routes from {from_location} to {to_location}"
+            raise ValueError(msg) from None
+
+        return possible_routes
+
+    def assign_route(self, tracking_id: UUID, itinerary: Itinerary) -> None:
+        cargo = self.get_cargo(tracking_id)
+        cargo.assign_route(itinerary)
+        self.save(cargo)
+
+    def register_handling_event(
+        self,
+        tracking_id: UUID,
+        voyage_number: str | None,
+        location: Location,
+        handing_activity: HandlingActivity,
+    ) -> None:
+        cargo = self.get_cargo(tracking_id)
+        cargo.register_handling_event(
+            tracking_id,
+            voyage_number,
+            location,
+            handing_activity,
+        )
+        self.save(cargo)
+
+    def get_cargo(self, tracking_id: UUID) -> Cargo:
+        return cast(Cargo, self.repository.get(tracking_id))