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

eventsourcing/application.py

@@ -915,16 +915,6 @@ class AggregateNotFoundError(EventSourcingError):
     """
 
 
-class AggregateNotFound(AggregateNotFoundError):  # noqa: N818
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        warn(
-            "AggregateNotFound is deprecated, use AggregateNotFoundError instead",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        super().__init__(*args, **kwargs)
-
-
 class EventSourcedLog(Generic[TDomainEvent]):
     """
     Constructs a sequence of domain events, like an aggregate.

eventsourcing/domain.py

@@ -941,7 +941,6 @@ class MetaAggregate(type, Generic[TAggregate]):
             setattr(cls, base_event_name, base_event_cls)
 
         # Make sure all events defined on aggregate subclass the base event class.
-        created_event_classes: Dict[str, Type[CanInitAggregate]] = {}
         for name, value in tuple(cls.__dict__.items()):
             if name == base_event_name:
                 # Don't subclass the base event class again.
@@ -956,20 +955,31 @@ class MetaAggregate(type, Generic[TAggregate]):
             ):
                 sub_class = cls._define_event_class(name, (value, base_event_cls), None)
                 setattr(cls, name, sub_class)
-        for name, value in tuple(cls.__dict__.items()):
-            if isinstance(value, type) and issubclass(value, CanInitAggregate):
-                created_event_classes[name] = value
+
+        # Identify or define the aggregate's "created" event class.
+        created_event_class: Type[CanInitAggregate] | None = None
+
+        # Has the "created" event class been indicated with '_created_event_class'.
+        if "_created_event_class" in cls.__dict__:
+            created_event_class = cls.__dict__["_created_event_class"]
+            if isinstance(created_event_class, type) and issubclass(
+                created_event_class, CanInitAggregate
+            ):
+                # We just subclassed the event classes, so reassign this.
+                created_event_class = getattr(cls, created_event_class.__name__)
+                assert created_event_class
+                cls._created_event_class = created_event_class
+            else:
+                msg = (
+                    f"{created_event_class} not subclass of {CanInitAggregate.__name__}"
+                )
+                raise TypeError(msg)
 
         # Disallow using both '_created_event_class' and 'created_event_name'.
-        created_event_class: Type[CanInitAggregate] | None = cls.__dict__.get(
-            "_created_event_class"
-        )
         if created_event_class and created_event_name:
             msg = "Can't use both '_created_event_class' and 'created_event_name'"
             raise TypeError(msg)
 
-        # Identify or define the aggregate's "created" event class.
-
         # Is the init method decorated with a CommandMethodDecorator?
         if isinstance(cls.__dict__.get("__init__"), CommandMethodDecorator):
             init_decorator: CommandMethodDecorator = cls.__dict__["__init__"]
@@ -977,20 +987,31 @@ class MetaAggregate(type, Generic[TAggregate]):
             # Set the original method on the class (un-decorate __init__).
             cls.__init__ = init_decorator.decorated_method  # type: ignore
 
-            # Disallow using both 'created_event_name' and decorator on __init__.
+            # Disallow using both 'created_event_name' and '_created_event_class'.
             if created_event_name:
                 msg = "Can't use both 'created_event_name' and decorator on __init__"
                 raise TypeError(msg)
-            # Disallow using both '_created_event_class' and decorator on __init__.
             if created_event_class:
                 msg = "Can't use both '_created_event_class' and decorator on __init__"
                 raise TypeError(msg)
 
-            # Does the decorator specify a "created" event class?
+            # Does the decorator specify a "create" event class?
             if init_decorator.given_event_cls:
-                created_event_class = cast(
-                    Type[CanInitAggregate], init_decorator.given_event_cls
+                created_event_class = getattr(
+                    cls, init_decorator.given_event_cls.__name__
                 )
+                if isinstance(created_event_class, type) and issubclass(
+                    created_event_class, CanInitAggregate
+                ):
+                    assert created_event_class
+                    cls._created_event_class = created_event_class
+                else:
+                    msg = (
+                        f"{created_event_class} not subclass of "
+                        f"{CanInitAggregate.__name__}"
+                    )
+                    raise TypeError(msg)
+
             # Does the decorator specify a "created" event name?
             elif init_decorator.event_cls_name:
                 created_event_name = init_decorator.event_cls_name
@@ -1007,85 +1028,65 @@ class MetaAggregate(type, Generic[TAggregate]):
                 _init_mentions_id.add(cls)
                 break
 
-        if created_event_class:
-            # Check specified "created" event class can init aggregate.
-            if not issubclass(created_event_class, CanInitAggregate):
-                msg = (
-                    f"{created_event_class} not subclass of {CanInitAggregate.__name__}"
-                )
-                raise TypeError(msg)
-
-            for sub_class in created_event_classes.values():
-                if issubclass(sub_class, created_event_class):
-                    # We just subclassed the created event class, so reassign it.
-                    created_event_class = sub_class
-
-        # Is a "created" event class already defined that matches the name?
-        elif created_event_name and created_event_name in created_event_classes:
-            created_event_class = created_event_classes[created_event_name]
-
-        # If there is only one class defined, then use it.
-        elif len(created_event_classes) == 1 and not created_event_name:
-            created_event_class = next(iter(created_event_classes.values()))
-
-        # If there are no "created" event classes already defined, or a name is
-        # specified that hasn't matched, then define a "created" event class.
-        elif len(created_event_classes) == 0 or created_event_name:
-
-            # Decide the base classes for the new "created" event class.
-            if created_event_name and len(created_event_classes) == 1:
-                base_created_event_cls = next(iter(created_event_classes.values()))
-            else:
-                for base_cls in cls.__mro__:
-                    if base_cls is cls:
-                        continue
-                    base_created_event_cls = base_cls.__dict__.get(
-                        "_created_event_class",
-                        base_cls.__dict__.get("Created"),
-                    )
-                    if base_created_event_cls:
-                        break
-                else:  # pragma: no cover
-                    msg = "Can't decide base class for new 'created' event class"
-                    raise TypeError(msg)
-
-            if not created_event_name:
-                created_event_name = base_created_event_cls.__name__
-
-            # Disallow init method from having variable params if
-            # we are using it to define a "created" event class.
-            try:
-                init_method = cls.__dict__["__init__"]
-            except KeyError:
-                init_method = None
-            else:
+        # If no "created" event class has been specified, find or create one.
+        if created_event_class is None:
+            # Discover all the "created" event classes already defined.
+            created_event_classes: Dict[str, Type[AggregateCreated]] = {}
+            for name, value in tuple(cls.__dict__.items()):
+                if isinstance(value, type) and issubclass(value, AggregateCreated):
+                    created_event_classes[name] = value
+
+            # Is a "created" event class already defined that matches the name?
+            if created_event_name in created_event_classes:
+                cls._created_event_class = created_event_classes[created_event_name]
+
+            # If there is only one class defined, and we have no name, use it.
+            elif len(created_event_classes) == 1 and not created_event_name:
+                cls._created_event_class = next(iter(created_event_classes.values()))
+
+            # If there are no "created" event classes already defined, or a name is
+            # specified that hasn't matched, then define a "created" event class.
+            elif len(created_event_classes) == 0 or created_event_name:
+                # If no "created" event name has been specified, use default name.
+                if not created_event_name:
+                    # This is safe because len(created_event_classes) == 0.
+                    created_event_name = "Created"
+
+                # Disallow init method from having variable params if
+                # we are using it to define a "created" event class.
                 try:
-                    _check_no_variable_params(init_method)
-                except TypeError:
-                    raise
-
-            # Define a "created" event class for this aggregate.
-            if issubclass(base_created_event_cls, base_event_cls):
-                # Don't subclass from base event class twice.
-                bases: Tuple[Type[CanMutateAggregate], ...] = (base_created_event_cls,)
-            else:
-                bases = (base_created_event_cls, base_event_cls)
-            created_event_class = cast(
-                Type[CanInitAggregate],
-                cls._define_event_class(
+                    init_method = cls.__dict__["__init__"]
+                except KeyError:
+                    init_method = None
+                else:
+                    try:
+                        _check_no_variable_params(init_method)
+                    except TypeError:
+                        raise
+
+                # Define a "created" event class for this aggregate.
+                if issubclass(cls.Created, base_event_cls):
+                    # Don't subclass from base event class twice.
+                    bases: Tuple[Type[CanMutateAggregate], ...] = (cls.Created,)
+                else:
+                    bases = (cls.Created, base_event_cls)
+                event_cls = cls._define_event_class(
                     created_event_name,
                     bases,
                     init_method,
-                ),
-            )
-            # Set the event class as an attribute of the aggregate class.
-            setattr(cls, created_event_name, created_event_class)
+                )
+
+                # Set the event class as an attribute of the aggregate class.
+                setattr(cls, created_event_name, event_cls)
+
+                # Remember which is the "created" event class.
+                cls._created_event_class = cast(Type[AggregateCreated], event_cls)
 
-        if created_event_class:
-            cls._created_event_class = created_event_class
-        else:
             # Prepare to disallow ambiguity of choice between created event classes.
-            aggregate_has_many_created_event_classes[cls] = list(created_event_classes)
+            else:
+                aggregate_has_many_created_event_classes[cls] = list(
+                    created_event_classes
+                )
 
         # Prepare the subsequent event classes.
         for attr_name, attr_value in tuple(cls.__dict__.items()):

eventsourcing/examples/aggregate4/domainmodel.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
+import contextlib
+from collections import defaultdict
 from dataclasses import dataclass
 from datetime import datetime, timezone
-from typing import Any, Iterable, List, Type, TypeVar, cast
+from typing import Any, ClassVar, Dict, Iterable, List, Type, TypeVar, cast
 from uuid import UUID, uuid4
 
 from eventsourcing.dispatch import singledispatchmethod
@@ -27,7 +29,6 @@ class Aggregate:
     id: UUID
     version: int
     created_on: datetime
-    _pending_events: List[DomainEvent]
 
     def __init__(self, event: DomainEvent):
         self.id = event.originator_id
@@ -46,15 +47,15 @@ class Aggregate:
             timestamp=event_class.create_timestamp(),
         )
         new_event = event_class(**kwargs)
-        self._apply(new_event)
-        self._pending_events.append(new_event)
+        self.apply(new_event)
+        self.pending_events.append(new_event)
 
     @singledispatchmethod
-    def _apply(self, event: DomainEvent) -> None:
+    def apply(self, event: DomainEvent) -> None:
         """Applies event to aggregate."""
 
     def collect_events(self) -> List[DomainEvent]:
-        events, self._pending_events = self._pending_events, []
+        events, self.pending_events = self.pending_events, []
         return events
 
     @classmethod
@@ -63,12 +64,25 @@ class Aggregate:
         _: TAggregate | None,
         events: Iterable[DomainEvent],
     ) -> TAggregate | None:
-        aggregate: TAggregate = object.__new__(cls)
-        aggregate._pending_events = []
+        aggregate = object.__new__(cls)
         for event in events:
-            aggregate._apply(event)
+            aggregate.apply(event)
         return aggregate
 
+    @property
+    def pending_events(self) -> List[DomainEvent]:
+        return type(self).__pending_events[id(self)]
+
+    @pending_events.setter
+    def pending_events(self, pending_events: List[DomainEvent]) -> None:
+        type(self).__pending_events[id(self)] = pending_events
+
+    __pending_events: ClassVar[Dict[int, List[DomainEvent]]] = defaultdict(list)
+
+    def __del__(self) -> None:
+        with contextlib.suppress(KeyError):
+            type(self).__pending_events.pop(id(self))
+
 
 class Dog(Aggregate):
     @dataclass(frozen=True)
@@ -88,27 +102,27 @@ class Dog(Aggregate):
             name=name,
         )
         dog = cast(Dog, cls.projector(None, [event]))
-        dog._pending_events.append(event)
+        dog.pending_events.append(event)
         return dog
 
     def add_trick(self, trick: str) -> None:
         self.trigger_event(self.TrickAdded, trick=trick)
 
     @singledispatchmethod
-    def _apply(self, event: DomainEvent) -> None:
+    def apply(self, event: DomainEvent) -> None:
         """Applies event to aggregate."""
 
-    @_apply.register(Registered)
+    @apply.register(Registered)
     def _(self, event: Registered) -> None:
         super().__init__(event)
         self.name = event.name
         self.tricks: List[str] = []
 
-    @_apply.register(TrickAdded)
+    @apply.register(TrickAdded)
     def _(self, event: TrickAdded) -> None:
         self.tricks.append(event.trick)
         self.version = event.originator_version
 
-    @_apply.register(Snapshot)
+    @apply.register(Snapshot)
     def _(self, event: Snapshot) -> None:
         self.__dict__.update(event.state)

eventsourcing/examples/contentmanagementsystem/test_system.py

@@ -23,119 +23,112 @@ class ContentManagementSystemTestCase(TestCase):
     env: ClassVar[Dict[str, str]] = {}
 
     def test_system(self) -> None:
-        with SingleThreadedRunner(
-            system=ContentManagementSystem(), env=self.env
-        ) as runner:
-
-            content_management_app = runner.get(ContentManagementApplication)
-            search_index_app = runner.get(SearchIndexApplication)
-
-            # Set user_id context variable.
-            user_id = uuid4()
-            user_id_cvar.set(user_id)
-
-            # Create empty pages.
-            content_management_app.create_page(title="Animals", slug="animals")
-            content_management_app.create_page(title="Plants", slug="plants")
-            content_management_app.create_page(title="Minerals", slug="minerals")
-
-            # Search, expect no results.
-            self.assertEqual(0, len(search_index_app.search("cat")))
-            self.assertEqual(0, len(search_index_app.search("rose")))
-            self.assertEqual(0, len(search_index_app.search("calcium")))
-
-            # Update the pages.
-            content_management_app.update_body(slug="animals", body="cat")
-            content_management_app.update_body(slug="plants", body="rose")
-            content_management_app.update_body(slug="minerals", body="calcium")
-
-            # Search for single words.
-            page_ids = search_index_app.search("cat")
-            self.assertEqual(1, len(page_ids))
-            page = content_management_app.get_page_by_id(page_ids[0])
-            self.assertEqual(page["slug"], "animals")
-            self.assertEqual(page["body"], "cat")
-
-            page_ids = search_index_app.search("rose")
-            self.assertEqual(1, len(page_ids))
-            page = content_management_app.get_page_by_id(page_ids[0])
-            self.assertEqual(page["slug"], "plants")
-            self.assertEqual(page["body"], "rose")
-
-            page_ids = search_index_app.search("calcium")
-            self.assertEqual(1, len(page_ids))
-            page = content_management_app.get_page_by_id(page_ids[0])
-            self.assertEqual(page["slug"], "minerals")
-            self.assertEqual(page["body"], "calcium")
-
-            self.assertEqual(len(search_index_app.search("dog")), 0)
-            self.assertEqual(len(search_index_app.search("bluebell")), 0)
-            self.assertEqual(len(search_index_app.search("zinc")), 0)
-
-            # Update the pages again.
-            content_management_app.update_body(slug="animals", body="cat dog zebra")
-            content_management_app.update_body(
-                slug="plants", body="bluebell rose jasmine"
-            )
-            content_management_app.update_body(
-                slug="minerals", body="iron zinc calcium"
-            )
-
-            # Search for single words.
-            page_ids = search_index_app.search("cat")
-            self.assertEqual(1, len(page_ids))
-            page = content_management_app.get_page_by_id(page_ids[0])
-            self.assertEqual(page["slug"], "animals")
-            self.assertEqual(page["body"], "cat dog zebra")
-
-            page_ids = search_index_app.search("rose")
-            self.assertEqual(1, len(page_ids))
-            page = content_management_app.get_page_by_id(page_ids[0])
-            self.assertEqual(page["slug"], "plants")
-            self.assertEqual(page["body"], "bluebell rose jasmine")
-
-            page_ids = search_index_app.search("calcium")
-            self.assertEqual(1, len(page_ids))
-            page = content_management_app.get_page_by_id(page_ids[0])
-            self.assertEqual(page["slug"], "minerals")
-            self.assertEqual(page["body"], "iron zinc calcium")
-
-            page_ids = search_index_app.search("dog")
-            self.assertEqual(1, len(page_ids))
-            page = content_management_app.get_page_by_id(page_ids[0])
-            self.assertEqual(page["slug"], "animals")
-            self.assertEqual(page["body"], "cat dog zebra")
-
-            page_ids = search_index_app.search("bluebell")
-            self.assertEqual(1, len(page_ids))
-            page = content_management_app.get_page_by_id(page_ids[0])
-            self.assertEqual(page["slug"], "plants")
-            self.assertEqual(page["body"], "bluebell rose jasmine")
-
-            page_ids = search_index_app.search("zinc")
-            self.assertEqual(1, len(page_ids))
-            page = content_management_app.get_page_by_id(page_ids[0])
-            self.assertEqual(page["slug"], "minerals")
-            self.assertEqual(page["body"], "iron zinc calcium")
-
-            # Search for multiple words in same page.
-            page_ids = search_index_app.search("dog cat")
-            self.assertEqual(1, len(page_ids))
-            page = content_management_app.get_page_by_id(page_ids[0])
-            self.assertEqual(page["slug"], "animals")
-            self.assertEqual(page["body"], "cat dog zebra")
-
-            # Search for multiple words in same page, expect no results.
-            page_ids = search_index_app.search("rose zebra")
-            self.assertEqual(0, len(page_ids))
-
-            # Search for alternative words, expect two results.
-            page_ids = search_index_app.search("rose OR zebra")
-            pages = [
-                content_management_app.get_page_by_id(page_id) for page_id in page_ids
-            ]
-            self.assertEqual(2, len(pages))
-            self.assertEqual(["animals", "plants"], sorted(p["slug"] for p in pages))
+        runner = SingleThreadedRunner(system=ContentManagementSystem(), env=self.env)
+        runner.start()
+
+        content_management_app = runner.get(ContentManagementApplication)
+        search_index_app = runner.get(SearchIndexApplication)
+
+        # Set user_id context variable.
+        user_id = uuid4()
+        user_id_cvar.set(user_id)
+
+        # Create empty pages.
+        content_management_app.create_page(title="Animals", slug="animals")
+        content_management_app.create_page(title="Plants", slug="plants")
+        content_management_app.create_page(title="Minerals", slug="minerals")
+
+        # Search, expect no results.
+        self.assertEqual(0, len(search_index_app.search("cat")))
+        self.assertEqual(0, len(search_index_app.search("rose")))
+        self.assertEqual(0, len(search_index_app.search("calcium")))
+
+        # Update the pages.
+        content_management_app.update_body(slug="animals", body="cat")
+        content_management_app.update_body(slug="plants", body="rose")
+        content_management_app.update_body(slug="minerals", body="calcium")
+
+        # Search for single words.
+        page_ids = search_index_app.search("cat")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "animals")
+        self.assertEqual(page["body"], "cat")
+
+        page_ids = search_index_app.search("rose")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "plants")
+        self.assertEqual(page["body"], "rose")
+
+        page_ids = search_index_app.search("calcium")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "minerals")
+        self.assertEqual(page["body"], "calcium")
+
+        self.assertEqual(len(search_index_app.search("dog")), 0)
+        self.assertEqual(len(search_index_app.search("bluebell")), 0)
+        self.assertEqual(len(search_index_app.search("zinc")), 0)
+
+        # Update the pages again.
+        content_management_app.update_body(slug="animals", body="cat dog zebra")
+        content_management_app.update_body(slug="plants", body="bluebell rose jasmine")
+        content_management_app.update_body(slug="minerals", body="iron zinc calcium")
+
+        # Search for single words.
+        page_ids = search_index_app.search("cat")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "animals")
+        self.assertEqual(page["body"], "cat dog zebra")
+
+        page_ids = search_index_app.search("rose")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "plants")
+        self.assertEqual(page["body"], "bluebell rose jasmine")
+
+        page_ids = search_index_app.search("calcium")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "minerals")
+        self.assertEqual(page["body"], "iron zinc calcium")
+
+        page_ids = search_index_app.search("dog")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "animals")
+        self.assertEqual(page["body"], "cat dog zebra")
+
+        page_ids = search_index_app.search("bluebell")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "plants")
+        self.assertEqual(page["body"], "bluebell rose jasmine")
+
+        page_ids = search_index_app.search("zinc")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "minerals")
+        self.assertEqual(page["body"], "iron zinc calcium")
+
+        # Search for multiple words in same page.
+        page_ids = search_index_app.search("dog cat")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "animals")
+        self.assertEqual(page["body"], "cat dog zebra")
+
+        # Search for multiple words in same page, expect no results.
+        page_ids = search_index_app.search("rose zebra")
+        self.assertEqual(0, len(page_ids))
+
+        # Search for alternative words, expect two results.
+        page_ids = search_index_app.search("rose OR zebra")
+        pages = [content_management_app.get_page_by_id(page_id) for page_id in page_ids]
+        self.assertEqual(2, len(pages))
+        self.assertEqual(["animals", "plants"], sorted(p["slug"] for p in pages))
 
 
 class TestWithSQLite(ContentManagementSystemTestCase):
@@ -164,17 +157,18 @@ class TestWithPostgres(ContentManagementSystemTestCase):
         super().tearDown()
 
     def drop_tables(self) -> None:
-        with PostgresDatastore(
+        db = PostgresDatastore(
             self.env["POSTGRES_DBNAME"],
             self.env["POSTGRES_HOST"],
             self.env["POSTGRES_PORT"],
             self.env["POSTGRES_USER"],
             self.env["POSTGRES_PASSWORD"],
-        ) as datastore:
-            drop_postgres_table(datastore, "public.contentmanagementapplication_events")
-            drop_postgres_table(datastore, "public.pages_projection_example")
-            drop_postgres_table(datastore, "public.searchindexapplication_events")
-            drop_postgres_table(datastore, "public.searchindexapplication_tracking")
+        )
+        drop_postgres_table(db, "public.contentmanagementapplication_events")
+        drop_postgres_table(db, "public.pages_projection_example")
+        drop_postgres_table(db, "public.searchindexapplication_events")
+        drop_postgres_table(db, "public.searchindexapplication_tracking")
+        db.close()
 
 
 del ContentManagementSystemTestCase

eventsourcing/examples/searchablecontent/test_application.py

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

eventsourcing/examples/searchablecontent/test_recorder.py

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