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

eventsourcing/examples/contentmanagementsystem/postgres.py

@@ -1,17 +0,0 @@
-from eventsourcing.examples.searchablecontent.postgres import (
-    PostgresSearchableContentRecorder,
-)
-from eventsourcing.postgres import Factory, PostgresProcessRecorder
-
-
-class SearchableContentProcessRecorder(
-    PostgresSearchableContentRecorder, PostgresProcessRecorder
-):
-    pass
-
-
-class SearchableContentInfrastructureFactory(Factory):
-    process_recorder_class = SearchableContentProcessRecorder
-
-
-del Factory

eventsourcing/examples/contentmanagementsystem/sqlite.py

@@ -1,17 +0,0 @@
-from eventsourcing.examples.searchablecontent.sqlite import (
-    SQLiteSearchableContentRecorder,
-)
-from eventsourcing.sqlite import Factory, SQLiteProcessRecorder
-
-
-class SearchableContentProcessRecorder(
-    SQLiteSearchableContentRecorder, SQLiteProcessRecorder
-):
-    pass
-
-
-class SearchableContentInfrastructureFactory(Factory):
-    process_recorder_class = SearchableContentProcessRecorder
-
-
-del Factory

eventsourcing/examples/contentmanagementsystem/system.py

@@ -1,14 +0,0 @@
-from __future__ import annotations
-
-from eventsourcing.examples.contentmanagement.application import (
-    ContentManagementApplication,
-)
-from eventsourcing.examples.contentmanagementsystem.application import (
-    SearchIndexApplication,
-)
-from eventsourcing.system import System
-
-
-class ContentManagementSystem(System):
-    def __init__(self) -> None:
-        super().__init__(pipes=[[ContentManagementApplication, SearchIndexApplication]])

eventsourcing/examples/contentmanagementsystem/test_system.py

@@ -1,180 +0,0 @@
-from __future__ import annotations
-
-from typing import ClassVar, Dict
-from unittest import TestCase
-from uuid import uuid4
-
-from eventsourcing.examples.contentmanagement.application import (
-    ContentManagementApplication,
-)
-from eventsourcing.examples.contentmanagement.domainmodel import user_id_cvar
-from eventsourcing.examples.contentmanagementsystem.application import (
-    SearchIndexApplication,
-)
-from eventsourcing.examples.contentmanagementsystem.system import (
-    ContentManagementSystem,
-)
-from eventsourcing.postgres import PostgresDatastore
-from eventsourcing.system import SingleThreadedRunner
-from eventsourcing.tests.postgres_utils import drop_postgres_table
-
-
-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))
-
-
-class TestWithSQLite(ContentManagementSystemTestCase):
-    env: ClassVar[Dict[str, str]] = {
-        "PERSISTENCE_MODULE": "eventsourcing.examples.contentmanagementsystem.sqlite",
-        "SQLITE_DBNAME": ":memory:",
-    }
-
-
-class TestWithPostgres(ContentManagementSystemTestCase):
-    env: ClassVar[Dict[str, str]] = {
-        "PERSISTENCE_MODULE": "eventsourcing.examples.contentmanagementsystem.postgres",
-        "POSTGRES_DBNAME": "eventsourcing",
-        "POSTGRES_HOST": "127.0.0.1",
-        "POSTGRES_PORT": "5432",
-        "POSTGRES_USER": "eventsourcing",
-        "POSTGRES_PASSWORD": "eventsourcing",
-    }
-
-    def setUp(self) -> None:
-        super().setUp()
-        self.drop_tables()
-
-    def tearDown(self) -> None:
-        self.drop_tables()
-        super().tearDown()
-
-    def drop_tables(self) -> None:
-        with 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")
-
-
-del ContentManagementSystemTestCase

eventsourcing/examples/searchablecontent/application.py

@@ -1,45 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, List, Tuple, cast
-
-from eventsourcing.examples.contentmanagement.application import (
-    ContentManagementApplication,
-    PageDetailsType,
-)
-from eventsourcing.examples.contentmanagement.domainmodel import Page
-from eventsourcing.examples.searchablecontent.persistence import (
-    SearchableContentRecorder,
-)
-
-if TYPE_CHECKING:  # pragma: nocover
-    from uuid import UUID
-
-    from eventsourcing.domain import DomainEventProtocol, MutableOrImmutableAggregate
-    from eventsourcing.persistence import Recording
-
-
-class SearchableContentApplication(ContentManagementApplication):
-    def save(
-        self,
-        *objs: MutableOrImmutableAggregate | DomainEventProtocol | None,
-        **kwargs: Any,
-    ) -> List[Recording]:
-        insert_pages: List[Tuple[UUID, str, str, str]] = []
-        update_pages: List[Tuple[UUID, str, str, str]] = []
-        for obj in objs:
-            if isinstance(obj, Page):
-                if obj.version == len(obj.pending_events):
-                    insert_pages.append((obj.id, obj.slug, obj.title, obj.body))
-                else:
-                    update_pages.append((obj.id, obj.slug, obj.title, obj.body))
-        kwargs["insert_pages"] = insert_pages
-        kwargs["update_pages"] = update_pages
-        return super().save(*objs, **kwargs)
-
-    def search(self, query: str) -> List[PageDetailsType]:
-        pages = []
-        recorder = cast(SearchableContentRecorder, self.recorder)
-        for page_id in recorder.search_pages(query):
-            page = self.get_page_by_id(page_id)
-            pages.append(page)
-        return pages

eventsourcing/examples/searchablecontent/persistence.py

@@ -1,23 +0,0 @@
-from __future__ import annotations
-
-from abc import abstractmethod
-from typing import TYPE_CHECKING, List, Tuple
-
-from eventsourcing.persistence import AggregateRecorder
-
-if TYPE_CHECKING:  # pragma: nocover
-    from uuid import UUID
-
-
-class SearchableContentRecorder(AggregateRecorder):
-    @abstractmethod
-    def search_pages(self, query: str) -> List[UUID]:
-        """
-        Returns IDs for pages that match query.
-        """
-
-    @abstractmethod
-    def select_page(self, page_id: UUID) -> Tuple[str, str, str]:
-        """
-        Returns slug, title and body for given ID.
-        """

eventsourcing/examples/searchablecontent/postgres.py

@@ -1,118 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, List, Sequence, Tuple
-
-from eventsourcing.examples.contentmanagement.application import PageNotFoundError
-from eventsourcing.examples.searchablecontent.persistence import (
-    SearchableContentRecorder,
-)
-from eventsourcing.postgres import (
-    Factory,
-    PostgresAggregateRecorder,
-    PostgresApplicationRecorder,
-)
-
-if TYPE_CHECKING:  # pragma: nocover
-    from uuid import UUID
-
-    from psycopg import Cursor
-    from psycopg.rows import DictRow
-
-    from eventsourcing.persistence import StoredEvent
-
-
-class PostgresSearchableContentRecorder(
-    SearchableContentRecorder,
-    PostgresAggregateRecorder,
-):
-    pages_table_name = "pages_projection_example"
-    select_page_statement = (
-        f"SELECT page_slug, page_title, page_body FROM {pages_table_name}"
-        " WHERE page_id = %s"
-    )
-
-    insert_page_statement = f"INSERT INTO {pages_table_name} VALUES (%s, %s, %s, %s)"
-
-    update_page_statement = (
-        f"UPDATE {pages_table_name}"
-        " SET page_slug = %s, page_title = %s, page_body = %s WHERE page_id = %s"
-    )
-
-    search_pages_statement = (
-        f"SELECT page_id FROM {pages_table_name} WHERE"
-        " to_tsvector('english', page_body) @@ websearch_to_tsquery('english', %s)"
-    )
-
-    def construct_create_table_statements(self) -> List[str]:
-        statements = super().construct_create_table_statements()
-        statements.append(
-            "CREATE TABLE IF NOT EXISTS "
-            f"{self.pages_table_name} ("
-            "page_id uuid, "
-            "page_slug text, "
-            "page_title text, "
-            "page_body text, "
-            "PRIMARY KEY "
-            "(page_id))"
-        )
-        statements.append(
-            f"CREATE INDEX IF NOT EXISTS {self.pages_table_name}_idx "
-            f"ON {self.pages_table_name} "
-            "USING GIN (to_tsvector('english', page_body))"
-        )
-        return statements
-
-    def _insert_events(
-        self,
-        c: Cursor[DictRow],
-        stored_events: List[StoredEvent],
-        **kwargs: Any,
-    ) -> None:
-        self._insert_pages(c, **kwargs)
-        self._update_pages(c, **kwargs)
-        super()._insert_events(c, stored_events, **kwargs)
-
-    def _insert_pages(
-        self,
-        c: Cursor[DictRow],
-        insert_pages: Sequence[Tuple[UUID, str, str, str]] = (),
-        **_: Any,
-    ) -> None:
-        for params in insert_pages:
-            c.execute(self.insert_page_statement, params, prepare=True)
-
-    def _update_pages(
-        self,
-        c: Cursor[DictRow],
-        update_pages: Sequence[Tuple[UUID, str, str, str]] = (),
-        **_: Any,
-    ) -> None:
-        for page_id, page_slug, page_title, page_body in update_pages:
-            params = (page_slug, page_title, page_body, page_id)
-            c.execute(self.update_page_statement, params, prepare=True)
-
-    def search_pages(self, query: str) -> List[UUID]:
-        with self.datastore.transaction(commit=False) as curs:
-            curs.execute(self.search_pages_statement, [query], prepare=True)
-            return [row["page_id"] for row in curs.fetchall()]
-
-    def select_page(self, page_id: UUID) -> Tuple[str, str, str]:
-        with self.datastore.transaction(commit=False) as curs:
-            curs.execute(self.select_page_statement, [str(page_id)], prepare=True)
-            for row in curs.fetchall():
-                return row["page_slug"], row["page_title"], row["page_body"]
-        msg = f"Page ID {page_id} not found"
-        raise PageNotFoundError(msg)
-
-
-class SearchableContentApplicationRecorder(
-    PostgresSearchableContentRecorder, PostgresApplicationRecorder
-):
-    pass
-
-
-class SearchableContentInfrastructureFactory(Factory):
-    application_recorder_class = SearchableContentApplicationRecorder
-
-
-del Factory

eventsourcing/examples/searchablecontent/sqlite.py

@@ -1,136 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, List, Sequence, Tuple
-from uuid import UUID
-
-from eventsourcing.examples.contentmanagement.application import PageNotFoundError
-from eventsourcing.examples.searchablecontent.persistence import (
-    SearchableContentRecorder,
-)
-from eventsourcing.sqlite import (
-    Factory,
-    SQLiteAggregateRecorder,
-    SQLiteApplicationRecorder,
-    SQLiteCursor,
-)
-
-if TYPE_CHECKING:  # pragma: nocover
-    from eventsourcing.persistence import StoredEvent
-
-
-class SQLiteSearchableContentRecorder(
-    SearchableContentRecorder, SQLiteAggregateRecorder
-):
-    pages_table_name = "pages_projection_example"
-    pages_virtual_table_name = pages_table_name + "_fts"
-    select_page_statement = (
-        "SELECT page_slug, page_title, page_body FROM "
-        f"{pages_table_name} WHERE page_id = ?"
-    )
-    insert_page_statement = f"INSERT INTO {pages_table_name} VALUES (?, ?, ?, ?)"
-    update_page_statement = (
-        f"UPDATE {pages_table_name} "
-        "SET page_slug = ?, page_title = ?, page_body = ? WHERE page_id = ?"
-    )
-    search_pages_statement = (
-        f"SELECT page_id FROM {pages_virtual_table_name} WHERE page_body MATCH ?"
-    )
-
-    def construct_create_table_statements(self) -> List[str]:
-        statements = super().construct_create_table_statements()
-        statements.append(
-            "CREATE TABLE IF NOT EXISTS "
-            f"{self.pages_table_name} ("
-            "page_id TEXT, "
-            "page_slug TEXT, "
-            "page_title TEXT, "
-            "page_body TEXT, "
-            "PRIMARY KEY "
-            "(page_id)) "
-        )
-        statements.append(
-            f"CREATE VIRTUAL TABLE {self.pages_virtual_table_name} USING fts5("
-            f"page_id, page_body, content='{self.pages_table_name}')"
-        )
-        statements.append(
-            "CREATE TRIGGER projection_ai AFTER INSERT ON "
-            f"{self.pages_table_name} BEGIN "
-            f"INSERT INTO {self.pages_virtual_table_name} "
-            "(rowid, page_id, page_body) "
-            "VALUES (new.rowid, new.page_id, new.page_body); "
-            "END"
-        )
-        statements.append(
-            "CREATE TRIGGER projection_au AFTER UPDATE ON "
-            f"{self.pages_table_name} "
-            "BEGIN "
-            f"INSERT INTO {self.pages_virtual_table_name} "
-            f"({self.pages_virtual_table_name}, rowid, page_id, page_body) "
-            "VALUES ('delete', old.rowid, old.page_id, old.page_body);"
-            f"INSERT INTO {self.pages_virtual_table_name} "
-            "(rowid, page_id, page_body) "
-            "VALUES (new.rowid, new.page_id, new.page_body); "
-            "END"
-        )
-        return statements
-
-    def _insert_events(
-        self,
-        c: SQLiteCursor,
-        stored_events: List[StoredEvent],
-        **kwargs: Any,
-    ) -> Sequence[int] | None:
-        notification_ids = super()._insert_events(c, stored_events, **kwargs)
-        self._insert_pages(c, **kwargs)
-        self._update_pages(c, **kwargs)
-        return notification_ids
-
-    def _insert_pages(
-        self,
-        c: SQLiteCursor,
-        insert_pages: Sequence[Tuple[UUID, str, str, str]] = (),
-        **_: Any,
-    ) -> None:
-        for page_id, page_slug, page_title, page_body in insert_pages:
-            c.execute(
-                self.insert_page_statement,
-                (str(page_id), page_slug, page_title, page_body),
-            )
-
-    def _update_pages(
-        self,
-        c: SQLiteCursor,
-        update_pages: Sequence[Tuple[UUID, str, str, str]] = (),
-        **_: Any,
-    ) -> None:
-        for page_id, page_slug, page_title, page_body in update_pages:
-            c.execute(
-                self.update_page_statement,
-                (page_slug, page_title, page_body, str(page_id)),
-            )
-
-    def search_pages(self, query: str) -> List[UUID]:
-        with self.datastore.transaction(commit=False) as c:
-            c.execute(self.search_pages_statement, [query])
-            return [UUID(row["page_id"]) for row in c.fetchall()]
-
-    def select_page(self, page_id: UUID) -> Tuple[str, str, str]:
-        with self.datastore.transaction(commit=False) as c:
-            c.execute(self.select_page_statement, [str(page_id)])
-            for row in c.fetchall():
-                return row["page_slug"], row["page_title"], row["page_body"]
-        msg = f"Page ID {page_id} not found"
-        raise PageNotFoundError(msg)
-
-
-class SearchableContentApplicationRecorder(
-    SQLiteSearchableContentRecorder, SQLiteApplicationRecorder
-):
-    pass
-
-
-class SearchableContentInfrastructureFactory(Factory):
-    application_recorder_class = SearchableContentApplicationRecorder
-
-
-del Factory

eventsourcing/examples/searchablecontent/test_application.py

@@ -1,110 +0,0 @@
-from __future__ import annotations
-
-import os
-from typing import ClassVar, Dict
-from unittest import TestCase
-from uuid import uuid4
-
-from eventsourcing.examples.contentmanagement.domainmodel import user_id_cvar
-from eventsourcing.examples.searchablecontent.application import (
-    SearchableContentApplication,
-)
-from eventsourcing.postgres import PostgresDatastore
-from eventsourcing.tests.postgres_utils import drop_postgres_table
-
-
-class SearchableContentApplicationTestCase(TestCase):
-    env: ClassVar[Dict[str, str]] = {}
-
-    def test_app(self) -> None:
-        app = SearchableContentApplication(env=self.env)
-
-        # Set user_id context variable.
-        user_id = uuid4()
-        user_id_cvar.set(user_id)
-
-        # Create empty pages.
-        app.create_page(title="Animals", slug="animals")
-        app.create_page(title="Plants", slug="plants")
-        app.create_page(title="Minerals", slug="minerals")
-
-        # Search, expect no results.
-        self.assertEqual(0, len(app.search("dog")))
-        self.assertEqual(0, len(app.search("rose")))
-        self.assertEqual(0, len(app.search("zinc")))
-
-        # Update the pages.
-        app.update_body(slug="animals", body="cat dog zebra")
-        app.update_body(slug="plants", body="bluebell rose jasmine")
-        app.update_body(slug="minerals", body="iron zinc calcium")
-
-        # Search for single words, expect results.
-        pages = app.search("dog")
-        self.assertEqual(1, len(pages))
-        self.assertEqual(pages[0]["slug"], "animals")
-        self.assertEqual(pages[0]["body"], "cat dog zebra")
-
-        pages = app.search("rose")
-        self.assertEqual(1, len(pages))
-        self.assertEqual(pages[0]["slug"], "plants")
-        self.assertEqual(pages[0]["body"], "bluebell rose jasmine")
-
-        pages = app.search("zinc")
-        self.assertEqual(1, len(pages))
-        self.assertEqual(pages[0]["slug"], "minerals")
-        self.assertEqual(pages[0]["body"], "iron zinc calcium")
-
-        # Search for multiple words in same page.
-        pages = app.search("dog cat")
-        self.assertEqual(1, len(pages))
-        self.assertEqual(pages[0]["slug"], "animals")
-        self.assertEqual(pages[0]["body"], "cat dog zebra")
-
-        # Search for multiple words in same page, expect no results.
-        pages = app.search("rose zebra")
-        self.assertEqual(0, len(pages))
-
-        # Search for alternative words, expect two results.
-        pages = app.search("rose OR zebra")
-        self.assertEqual(2, len(pages))
-        self.assertEqual(["animals", "plants"], sorted(p["slug"] for p in pages))
-
-
-class TestWithSQLite(SearchableContentApplicationTestCase):
-    env: ClassVar[Dict[str, str]] = {
-        "PERSISTENCE_MODULE": "eventsourcing.examples.searchablecontent.sqlite",
-        "SQLITE_DBNAME": ":memory:",
-    }
-
-
-class TestWithPostgres(SearchableContentApplicationTestCase):
-    env: ClassVar[Dict[str, str]] = {
-        "PERSISTENCE_MODULE": "eventsourcing.examples.searchablecontent.postgres"
-    }
-
-    def setUp(self) -> None:
-        super().setUp()
-        os.environ["POSTGRES_DBNAME"] = "eventsourcing"
-        os.environ["POSTGRES_HOST"] = "127.0.0.1"
-        os.environ["POSTGRES_PORT"] = "5432"
-        os.environ["POSTGRES_USER"] = "eventsourcing"
-        os.environ["POSTGRES_PASSWORD"] = "eventsourcing"  # noqa: S105
-        self.drop_tables()
-
-    def tearDown(self) -> None:
-        self.drop_tables()
-        super().tearDown()
-
-    def drop_tables(self) -> None:
-        with 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")
-
-
-del SearchableContentApplicationTestCase