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

eventsourcing/examples/searchablecontent/test_recorder.py

@@ -54,16 +54,15 @@ class TestWithPostgres(SearchableContentRecorderTestCase):
         super().tearDown()
 
     def drop_tables(self) -> None:
-        db = PostgresDatastore(
+        with PostgresDatastore(
             os.environ["POSTGRES_DBNAME"],
             os.environ["POSTGRES_HOST"],
             os.environ["POSTGRES_PORT"],
             os.environ["POSTGRES_USER"],
             os.environ["POSTGRES_PASSWORD"],
-        )
-        drop_postgres_table(db, "public.searchablecontentapplication_events")
-        drop_postgres_table(db, "public.pages_projection_example")
-        db.close()
+        ) as datastore:
+            drop_postgres_table(datastore, "public.searchablecontentapplication_events")
+            drop_postgres_table(datastore, "public.pages_projection_example")
 
 
 del SearchableContentRecorderTestCase

eventsourcing/examples/searchabletimestamps/test_searchabletimestamps.py

@@ -76,16 +76,19 @@ class WithPostgreSQL(SearchableTimestampsTestCase):
         super().tearDown()
 
     def drop_tables(self) -> None:
-        db = PostgresDatastore(
+        with PostgresDatastore(
             os.environ["POSTGRES_DBNAME"],
             os.environ["POSTGRES_HOST"],
             os.environ["POSTGRES_PORT"],
             os.environ["POSTGRES_USER"],
             os.environ["POSTGRES_PASSWORD"],
-        )
-        drop_postgres_table(db, "public.searchabletimestampsapplication_events")
-        drop_postgres_table(db, "public.searchabletimestampsapplication_timestamps")
-        db.close()
+        ) as datastore:
+            drop_postgres_table(
+                datastore, "public.searchabletimestampsapplication_events"
+            )
+            drop_postgres_table(
+                datastore, "public.searchabletimestampsapplication_timestamps"
+            )
 
 
 del SearchableTimestampsTestCase

eventsourcing/postgres.py

@@ -2,13 +2,14 @@ from __future__ import annotations
 
 import logging
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, Any, Callable, Dict, Iterator, List, Sequence
+from typing import TYPE_CHECKING, Any, Callable, Iterator, List, Sequence
 
 import psycopg
 import psycopg.errors
 import psycopg_pool
 from psycopg import Connection, Cursor
 from psycopg.rows import DictRow, dict_row
+from typing_extensions import Self
 
 from eventsourcing.persistence import (
     AggregateRecorder,
@@ -62,11 +63,11 @@ class PostgresDatastore:
         user: str,
         password: str,
         *,
-        connect_timeout: int = 5,
+        connect_timeout: int = 30,
         idle_in_transaction_session_timeout: int = 0,
         pool_size: int = 2,
         max_overflow: int = 2,
-        pool_timeout: float = 5.0,
+        max_waiting: int = 0,
         conn_max_age: float = 60 * 60.0,
         pre_ping: bool = False,
         lock_timeout: int = 0,
@@ -79,7 +80,6 @@ class PostgresDatastore:
         self.pool_open_timeout = pool_open_timeout
 
         check = ConnectionPool.check_connection if pre_ping else None
-        kwargs: Dict[str, Any] = {"check": check}
         self.pool = ConnectionPool(
             get_password_func=get_password_func,
             connection_class=Connection[DictRow],
@@ -96,9 +96,9 @@ class PostgresDatastore:
             open=False,
             configure=self.after_connect,
             timeout=connect_timeout,
-            max_waiting=round(pool_timeout),
+            max_waiting=max_waiting,
             max_lifetime=conn_max_age,
-            **kwargs,  # use the 'check' argument when no longer supporting Python 3.7
+            check=check,
         )
         self.lock_timeout = lock_timeout
         self.schema = schema.strip()
@@ -156,6 +156,12 @@ class PostgresDatastore:
     def __del__(self) -> None:
         self.close()
 
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, *args: object, **kwargs: Any) -> None:
+        self.close()
+
 
 class PostgresAggregateRecorder(AggregateRecorder):
     def __init__(
@@ -558,10 +564,10 @@ class Factory(InfrastructureFactory):
     POSTGRES_CONNECT_TIMEOUT = "POSTGRES_CONNECT_TIMEOUT"
     POSTGRES_CONN_MAX_AGE = "POSTGRES_CONN_MAX_AGE"
     POSTGRES_PRE_PING = "POSTGRES_PRE_PING"
-    POSTGRES_POOL_TIMEOUT = "POSTGRES_POOL_TIMEOUT"
+    POSTGRES_MAX_WAITING = "POSTGRES_MAX_WAITING"
     POSTGRES_LOCK_TIMEOUT = "POSTGRES_LOCK_TIMEOUT"
     POSTGRES_POOL_SIZE = "POSTGRES_POOL_SIZE"
-    POSTGRES_POOL_MAX_OVERFLOW = "POSTGRES_POOL_MAX_OVERFLOW"
+    POSTGRES_MAX_OVERFLOW = "POSTGRES_MAX_OVERFLOW"
     POSTGRES_IDLE_IN_TRANSACTION_SESSION_TIMEOUT = (
         "POSTGRES_IDLE_IN_TRANSACTION_SESSION_TIMEOUT"
     )
@@ -618,7 +624,7 @@ class Factory(InfrastructureFactory):
             get_password_func = resolve_topic(get_password_topic)
             password = ""
 
-        connect_timeout = 5
+        connect_timeout = 30
         connect_timeout_str = self.env.get(self.POSTGRES_CONNECT_TIMEOUT)
         if connect_timeout_str:
             try:
@@ -664,30 +670,30 @@ class Factory(InfrastructureFactory):
                 raise OSError(msg) from None
 
         pool_max_overflow = 10
-        pool_max_overflow_str = self.env.get(self.POSTGRES_POOL_MAX_OVERFLOW)
+        pool_max_overflow_str = self.env.get(self.POSTGRES_MAX_OVERFLOW)
         if pool_max_overflow_str:
             try:
                 pool_max_overflow = int(pool_max_overflow_str)
             except ValueError:
                 msg = (
                     "Postgres environment value for key "
-                    f"'{self.POSTGRES_POOL_MAX_OVERFLOW}' is invalid. "
+                    f"'{self.POSTGRES_MAX_OVERFLOW}' is invalid. "
                     "If set, an integer or empty string is expected: "
                     f"'{pool_max_overflow_str}'"
                 )
                 raise OSError(msg) from None
 
-        pool_timeout = 30.0
-        pool_timeout_str = self.env.get(self.POSTGRES_POOL_TIMEOUT)
-        if pool_timeout_str:
+        max_waiting = 0
+        max_waiting_str = self.env.get(self.POSTGRES_MAX_WAITING)
+        if max_waiting_str:
             try:
-                pool_timeout = float(pool_timeout_str)
+                max_waiting = int(max_waiting_str)
             except ValueError:
                 msg = (
                     "Postgres environment value for key "
-                    f"'{self.POSTGRES_POOL_TIMEOUT}' is invalid. "
-                    "If set, a float or empty string is expected: "
-                    f"'{pool_timeout_str}'"
+                    f"'{self.POSTGRES_MAX_WAITING}' is invalid. "
+                    "If set, an integer or empty string is expected: "
+                    f"'{max_waiting_str}'"
                 )
                 raise OSError(msg) from None
 
@@ -733,13 +739,16 @@ class Factory(InfrastructureFactory):
             idle_in_transaction_session_timeout=idle_in_transaction_session_timeout,
             pool_size=pool_size,
             max_overflow=pool_max_overflow,
-            pool_timeout=pool_timeout,
+            max_waiting=max_waiting,
             conn_max_age=conn_max_age,
             pre_ping=pre_ping,
             lock_timeout=lock_timeout,
             schema=schema,
         )
 
+    def env_create_table(self) -> bool:
+        return strtobool(self.env.get(self.CREATE_TABLE) or "yes")
+
     def aggregate_recorder(self, purpose: str = "events") -> AggregateRecorder:
         prefix = self.env.name.lower() or "stored"
         events_table_name = prefix + "_" + purpose
@@ -783,9 +792,6 @@ class Factory(InfrastructureFactory):
             recorder.create_table()
         return recorder
 
-    def env_create_table(self) -> bool:
-        return strtobool(self.env.get(self.CREATE_TABLE) or "yes")
-
     def close(self) -> None:
         if hasattr(self, "datastore"):
             self.datastore.close()

eventsourcing/system.py

@@ -8,6 +8,7 @@ from queue import Full, Queue
 from threading import Event, Lock, RLock, Thread
 from types import FrameType, ModuleType
 from typing import (
+    Any,
     ClassVar,
     Dict,
     Iterable,
@@ -21,6 +22,8 @@ from typing import (
     cast,
 )
 
+from typing_extensions import Self
+
 from eventsourcing.application import (
     Application,
     NotificationLog,
@@ -525,6 +528,13 @@ class SingleThreadedRunner(Runner, RecordingEventReceiver):
         assert isinstance(app, cls)
         return app
 
+    def __enter__(self) -> Self:
+        self.start()
+        return self
+
+    def __exit__(self, *args: object, **kwargs: Any) -> None:
+        self.stop()
+
 
 class NewSingleThreadedRunner(Runner, RecordingEventReceiver):
     """

eventsourcing/tests/docs_tests/test_docs.py

@@ -20,32 +20,32 @@ class TestDocs(TestCase):
         super().setUp()
         self.uris = tmpfile_uris()
 
-        db = PostgresDatastore(
+        with PostgresDatastore(
             "eventsourcing",
             "127.0.0.1",
             "5432",
             "eventsourcing",
             "eventsourcing",
-        )
-        drop_postgres_table(db, "dogschool_events")
-        drop_postgres_table(db, "counters_events")
-        drop_postgres_table(db, "counters_tracking")
+        ) as datastore:
+            drop_postgres_table(datastore, "dogschool_events")
+            drop_postgres_table(datastore, "counters_events")
+            drop_postgres_table(datastore, "counters_tracking")
 
     def tearDown(self) -> None:
         self.clean_env()
 
     def clean_env(self):
         clear_topic_cache()
-        db = PostgresDatastore(
+        with PostgresDatastore(
             "eventsourcing",
             "127.0.0.1",
             "5432",
             "eventsourcing",
             "eventsourcing",
-        )
-        drop_postgres_table(db, "dogschool_events")
-        drop_postgres_table(db, "counters_events")
-        drop_postgres_table(db, "counters_tracking")
+        ) as datastore:
+            drop_postgres_table(datastore, "dogschool_events")
+            drop_postgres_table(datastore, "counters_events")
+            drop_postgres_table(datastore, "counters_tracking")
 
         keys = [
             "PERSISTENCE_MODULE",

eventsourcing/tests/domain_tests/test_aggregate.py

@@ -1,10 +1,12 @@
 import inspect
+import warnings
 from dataclasses import _DataclassParams, dataclass
 from datetime import datetime
 from decimal import Decimal
 from unittest.case import TestCase
 from uuid import NAMESPACE_URL, UUID, uuid4, uuid5
 
+from eventsourcing.application import AggregateNotFound, AggregateNotFoundError
 from eventsourcing.domain import (
     Aggregate,
     AggregateCreated,
@@ -730,6 +732,7 @@ class TestAggregateCreation(TestCase):
         order = Order("name")
         pending = order.collect_events()
         self.assertEqual(type(pending[0]).__name__, "Started")
+        self.assertTrue(isinstance(pending[0], Order.Created))
 
     def test_raises_when_given_created_event_name_conflicts_with_created_event_class(
         self,
@@ -1098,6 +1101,19 @@ class TestAggregateEventsAreSubclassed(TestCase):
             MySubclass.Ended.__qualname__,
         )
 
+        self.assertTrue(
+            MySubclass._created_event_class.__qualname__.endswith("MySubclass.Opened")
+        )
+
+        class MySubSubClass(MySubclass):
+            pass
+
+        self.assertTrue(
+            MySubSubClass._created_event_class.__qualname__.endswith(
+                "MySubSubClass.Opened"
+            )
+        )
+
 
 class TestBankAccount(TestCase):
     def test_subclass_bank_account(self):
@@ -1157,3 +1173,28 @@ class TestBankAccount(TestCase):
         # Collect pending events.
         pending = account.collect_events()
         self.assertEqual(len(pending), 7)
+
+
+class TestAggregateNotFound(TestCase):
+    def test(self):
+        # Verify deprecation warning.
+        with warnings.catch_warnings(record=True) as w:
+            AggregateNotFound()
+
+        self.assertEqual(len(w), 1)
+        self.assertIs(w[-1].category, DeprecationWarning)
+        self.assertEqual(
+            "AggregateNotFound is deprecated, use AggregateNotFoundError instead",
+            w[-1].message.args[0],
+        )
+
+        # Verify no deprecation warning.
+        with warnings.catch_warnings(record=True) as w:
+            AggregateNotFoundError()
+        self.assertEqual(len(w), 0)
+
+        # Check we didn't break any code.
+        try:
+            raise AggregateNotFoundError
+        except AggregateNotFound:
+            pass

eventsourcing/tests/persistence.py

@@ -839,6 +839,9 @@ class InfrastructureFactoryTestCase(ABC, TestCase):
         self.transcoder.register(DecimalAsStr())
         self.transcoder.register(DatetimeAsISO())
 
+    def tearDown(self):
+        self.factory.close()
+
     def test_createmapper(self):
         # Want to construct:
         #  - application recorder