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

eventsourcing/tests/docs_tests/test_docs.py

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

eventsourcing/tests/domain_tests/test_aggregate.py

@@ -5,7 +5,6 @@ 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,
@@ -1172,9 +1171,3 @@ class TestBankAccount(TestCase):
         # Collect pending events.
         pending = account.collect_events()
         self.assertEqual(len(pending), 7)
-
-
-class TestAggregateNotFound(TestCase):
-    def test(self):
-        e = AggregateNotFound()
-        self.assertIsInstance(e, AggregateNotFoundError)

eventsourcing/tests/persistence.py

@@ -839,9 +839,6 @@ 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

eventsourcing/tests/persistence_tests/test_postgres.py

@@ -53,26 +53,26 @@ class TestPostgresDatastore(TestCase):
         self.assertTrue(psycopg.Pipeline.is_supported())
 
     def test_has_connection_pool(self):
-        with PostgresDatastore(
+        datastore = PostgresDatastore(
             dbname="eventsourcing",
             host="127.0.0.1",
             port="5432",
             user="eventsourcing",
             password="eventsourcing",  # noqa: S106
-        ) as datastore:
-            self.assertIsInstance(datastore.pool, ConnectionPool)
+        )
+        self.assertIsInstance(datastore.pool, ConnectionPool)
 
     def test_get_connection(self):
-        with PostgresDatastore(
+        datastore = PostgresDatastore(
             dbname="eventsourcing",
             host="127.0.0.1",
             port="5432",
             user="eventsourcing",
             password="eventsourcing",  # noqa: S106
-        ) as datastore:
-            conn: Connection
-            with datastore.get_connection() as conn:
-                self.assertIsInstance(conn, Connection)
+        )
+        conn: Connection
+        with datastore.get_connection() as conn:
+            self.assertIsInstance(conn, Connection)
 
     def test_context_manager_converts_exceptions_and_conditionally_calls_close(self):
         cases = [
@@ -88,30 +88,31 @@ class TestPostgresDatastore(TestCase):
             (TypeError, TypeError(), True),
             (TypeError, TypeError, True),
         ]
-        with PostgresDatastore(
+        datastore = PostgresDatastore(
             dbname="eventsourcing",
             host="127.0.0.1",
             port="5432",
             user="eventsourcing",
             password="eventsourcing",  # noqa: S106
-        ) as datastore:
-            for expected_exc_type, raised_exc, expect_conn_closed in cases:
-                with self.assertRaises(expected_exc_type):
-                    conn: Connection
-                    with datastore.get_connection() as conn:
-                        self.assertFalse(conn.closed)
-                        raise raised_exc
-                    self.assertTrue(conn.closed is expect_conn_closed, raised_exc)
+        )
+        for expected_exc_type, raised_exc, expect_conn_closed in cases:
+            with self.assertRaises(expected_exc_type):
+                conn: Connection
+                with datastore.get_connection() as conn:
+                    self.assertFalse(conn.closed)
+                    raise raised_exc
+                self.assertTrue(conn.closed is expect_conn_closed, raised_exc)
 
     def test_transaction_from_datastore(self):
-        with PostgresDatastore(
+        datastore = PostgresDatastore(
             dbname="eventsourcing",
             host="127.0.0.1",
             port="5432",
             user="eventsourcing",
             password="eventsourcing",  # noqa: S106
-        ) as datastore, datastore.transaction(commit=False) as curs:
-            # As a convenience, we can use the transaction() method.
+        )
+        # As a convenience, we can use the transaction() method.
+        with datastore.transaction(commit=False) as curs:
             curs.execute("SELECT 1")
             self.assertEqual(curs.fetchall(), [{"?column?": 1}])
 
@@ -127,14 +128,15 @@ class TestPostgresDatastore(TestCase):
         with self.assertRaises(OperationalError), datastore.get_connection():
             pass
 
-        with PostgresDatastore(
+        datastore = PostgresDatastore(
             dbname="eventsourcing",
             host="127.0.0.1",
             port="987654321",  # bad value
             user="eventsourcing",
             password="eventsourcing",  # noqa: S106
             pool_open_timeout=2,
-        ) as datastore, self.assertRaises(OperationalError), datastore.get_connection():
+        )
+        with self.assertRaises(OperationalError), datastore.get_connection():
             pass
 
     @skipIf(
@@ -144,7 +146,7 @@ class TestPostgresDatastore(TestCase):
     def test_pre_ping(self):
         # Define method to open and close a connection, and then execute a statement.
         def open_close_execute(*, pre_ping: bool):
-            with PostgresDatastore(
+            datastore = PostgresDatastore(
                 dbname="eventsourcing",
                 host="127.0.0.1",
                 port="5432",
@@ -152,28 +154,28 @@ class TestPostgresDatastore(TestCase):
                 password="eventsourcing",  # noqa: S106
                 pool_size=1,
                 pre_ping=pre_ping,
-            ) as datastore:
+            )
 
-                # Create a connection.
-                conn: Connection
-                with datastore.get_connection() as conn, conn.cursor() as curs:
-                    curs.execute("SELECT 1")
-                    self.assertEqual(curs.fetchall(), [{"?column?": 1}])
+            # Create a connection.
+            conn: Connection
+            with datastore.get_connection() as conn, conn.cursor() as curs:
+                curs.execute("SELECT 1")
+                self.assertEqual(curs.fetchall(), [{"?column?": 1}])
 
-                # Close all connections via separate connection.
-                pg_close_all_connections()
+            # Close all connections via separate connection.
+            pg_close_all_connections()
 
-                # Check the connection doesn't think it's closed.
-                self.assertTrue(datastore.pool._pool)
-                self.assertFalse(datastore.pool._pool[0].closed)
+            # Check the connection doesn't think it's closed.
+            self.assertTrue(datastore.pool._pool)
+            self.assertFalse(datastore.pool._pool[0].closed)
 
-                # Get a closed connection.
-                conn: Connection
-                with datastore.get_connection() as conn:
-                    self.assertFalse(conn.closed)
+            # Get a closed connection.
+            conn: Connection
+            with datastore.get_connection() as conn:
+                self.assertFalse(conn.closed)
 
-                    with conn.cursor() as curs:
-                        curs.execute("SELECT 1")
+                with conn.cursor() as curs:
+                    curs.execute("SELECT 1")
 
         # Check using the closed connection gives an error.
         with self.assertRaises(OperationalError):
@@ -183,62 +185,60 @@ class TestPostgresDatastore(TestCase):
         open_close_execute(pre_ping=True)
 
     def test_idle_in_transaction_session_timeout(self):
-        with PostgresDatastore(
+        datastore = PostgresDatastore(
             dbname="eventsourcing",
             host="127.0.0.1",
             port="5432",
             user="eventsourcing",
             password="eventsourcing",  # noqa: S106
             idle_in_transaction_session_timeout=1,
-        ) as datastore:
+        )
 
-            # Error on commit is raised.
-            with self.assertRaises(
-                OperationalError
-            ), datastore.get_connection() as curs:
-                curs.execute("BEGIN")
-                curs.execute("SELECT 1")
-                self.assertFalse(curs.closed)
-                sleep(2)
-
-            # Error on commit is raised.
-            with self.assertRaises(OperationalError), datastore.transaction(
-                commit=True
-            ) as curs:
-                # curs.execute("BEGIN")
-                curs.execute("SELECT 1")
-                self.assertFalse(curs.closed)
-                sleep(2)
+        # Error on commit is raised.
+        with self.assertRaises(OperationalError), datastore.get_connection() as curs:
+            curs.execute("BEGIN")
+            curs.execute("SELECT 1")
+            self.assertFalse(curs.closed)
+            sleep(2)
+
+        # Error on commit is raised.
+        with self.assertRaises(OperationalError), datastore.transaction(
+            commit=True
+        ) as curs:
+            # curs.execute("BEGIN")
+            curs.execute("SELECT 1")
+            self.assertFalse(curs.closed)
+            sleep(2)
 
-            # Force rollback. Error is ignored.
-            with datastore.transaction(commit=False) as curs:
-                # curs.execute("BEGIN")
-                curs.execute("SELECT 1")
-                self.assertFalse(curs.closed)
-                sleep(2)
+        # Force rollback. Error is ignored.
+        with datastore.transaction(commit=False) as curs:
+            # curs.execute("BEGIN")
+            curs.execute("SELECT 1")
+            self.assertFalse(curs.closed)
+            sleep(2)
 
-            # Autocommit mode - transaction is commited in time.
-            with datastore.get_connection() as curs:
-                curs.execute("SELECT 1")
-                self.assertFalse(curs.closed)
-                sleep(2)
+        # Autocommit mode - transaction is commited in time.
+        with datastore.get_connection() as curs:
+            curs.execute("SELECT 1")
+            self.assertFalse(curs.closed)
+            sleep(2)
 
     def test_get_password_func(self):
         # Check correct password is required, wrong password causes operational error.
-        with PostgresDatastore(
+        datastore = PostgresDatastore(
             dbname="eventsourcing",
             host="127.0.0.1",
             port="5432",
             user="eventsourcing",
             password="wrong",  # noqa: S106
             pool_size=1,
-        ) as datastore:
+        )
 
-            conn: Connection
-            with self.assertRaises(
-                OperationalError
-            ), datastore.get_connection() as conn, conn.cursor() as curs:
-                curs.execute("SELECT 1")
+        conn: Connection
+        with self.assertRaises(
+            OperationalError
+        ), datastore.get_connection() as conn, conn.cursor() as curs:
+            curs.execute("SELECT 1")
 
         # Define a "get password" function, with a generator that returns
         # wrong password a few times first.
@@ -253,7 +253,7 @@ class TestPostgresDatastore(TestCase):
             return next(password_generator)
 
         # Construct datastore with "get password" function.
-        with PostgresDatastore(
+        datastore = PostgresDatastore(
             dbname="eventsourcing",
             host="127.0.0.1",
             port="5432",
@@ -262,9 +262,11 @@ class TestPostgresDatastore(TestCase):
             pool_size=1,
             get_password_func=get_password_func,
             connect_timeout=10,
-        ) as datastore, datastore.get_connection() as conn, conn.cursor() as curs:
-            # Create a connection, and check it works (this test depends on psycopg
-            # retrying attempt to connect, should call "get password" twice).
+        )
+
+        # Create a connection, and check it works (this test depends on psycopg
+        # retrying attempt to connect, should call "get password" twice).
+        with datastore.get_connection() as conn, conn.cursor() as curs:
             curs.execute("SELECT 1")
             self.assertEqual(curs.fetchall(), [{"?column?": 1}])
 
@@ -779,15 +781,15 @@ class TestPostgresInfrastructureFactory(InfrastructureFactoryTestCase):
         super().tearDown()
 
     def drop_tables(self):
-        with PostgresDatastore(
+        datastore = PostgresDatastore(
             "eventsourcing",
             "127.0.0.1",
             "5432",
             "eventsourcing",
             "eventsourcing",
-        ) as datastore:
-            drop_postgres_table(datastore, "testcase_events")
-            drop_postgres_table(datastore, "testcase_tracking")
+        )
+        drop_postgres_table(datastore, "testcase_events")
+        drop_postgres_table(datastore, "testcase_tracking")
 
     def test_close(self):
         factory = Factory(self.env)
@@ -818,16 +820,16 @@ class TestPostgresInfrastructureFactory(InfrastructureFactoryTestCase):
         self.assertEqual(self.factory.datastore.pool.min_size, 5)
 
     def test_max_overflow_is_ten_by_default(self):
-        self.assertTrue(Factory.POSTGRES_MAX_OVERFLOW not in self.env)
+        self.assertTrue(Factory.POSTGRES_POOL_MAX_OVERFLOW not in self.env)
         self.factory = Factory(self.env)
         self.assertEqual(self.factory.datastore.pool.max_size, 15)
 
-        self.env[Factory.POSTGRES_MAX_OVERFLOW] = ""
+        self.env[Factory.POSTGRES_POOL_MAX_OVERFLOW] = ""
         self.factory = Factory(self.env)
         self.assertEqual(self.factory.datastore.pool.max_size, 15)
 
     def test_max_overflow_is_set(self):
-        self.env[Factory.POSTGRES_MAX_OVERFLOW] = "7"
+        self.env[Factory.POSTGRES_POOL_MAX_OVERFLOW] = "7"
         self.factory = Factory(self.env)
         self.assertEqual(self.factory.datastore.pool.max_size, 12)
 
@@ -836,31 +838,31 @@ class TestPostgresInfrastructureFactory(InfrastructureFactoryTestCase):
         self.factory = Factory(self.env)
         self.assertEqual(self.factory.datastore.pool.min_size, 6)
 
-    def test_connect_timeout_is_thirty_by_default(self):
+    def test_connect_timeout_is_five_by_default(self):
         self.assertTrue(Factory.POSTGRES_CONNECT_TIMEOUT not in self.env)
         self.factory = Factory(self.env)
-        self.assertEqual(self.factory.datastore.pool.timeout, 30)
+        self.assertEqual(self.factory.datastore.pool.timeout, 5)
 
         self.env[Factory.POSTGRES_CONNECT_TIMEOUT] = ""
         self.factory = Factory(self.env)
-        self.assertEqual(self.factory.datastore.pool.timeout, 30)
+        self.assertEqual(self.factory.datastore.pool.timeout, 5)
 
     def test_connect_timeout_is_set(self):
         self.env[Factory.POSTGRES_CONNECT_TIMEOUT] = "8"
         self.factory = Factory(self.env)
         self.assertEqual(self.factory.datastore.pool.timeout, 8)
 
-    def test_max_waiting_is_0_by_default(self):
-        self.assertTrue(Factory.POSTGRES_MAX_WAITING not in self.env)
+    def test_pool_timeout_is_30_by_default(self):
+        self.assertTrue(Factory.POSTGRES_POOL_TIMEOUT not in self.env)
         self.factory = Factory(self.env)
-        self.assertEqual(self.factory.datastore.pool.max_waiting, 0)
+        self.assertEqual(self.factory.datastore.pool.max_waiting, 30)
 
-        self.env[Factory.POSTGRES_MAX_WAITING] = ""
+        self.env[Factory.POSTGRES_POOL_TIMEOUT] = ""
         self.factory = Factory(self.env)
-        self.assertEqual(self.factory.datastore.pool.max_waiting, 0)
+        self.assertEqual(self.factory.datastore.pool.max_waiting, 30)
 
-    def test_max_waiting_is_set(self):
-        self.env[Factory.POSTGRES_MAX_WAITING] = "8"
+    def test_pool_timeout_is_set(self):
+        self.env[Factory.POSTGRES_POOL_TIMEOUT] = "8"
         self.factory = Factory(self.env)
         self.assertEqual(self.factory.datastore.pool.max_waiting, 8)
 
@@ -943,14 +945,14 @@ class TestPostgresInfrastructureFactory(InfrastructureFactoryTestCase):
             "is invalid. If set, an integer or empty string is expected: 'abc'",
         )
 
-    def test_environment_error_raised_when_max_waiting_not_an_integer(self):
-        self.env[Factory.POSTGRES_MAX_WAITING] = "abc"
+    def test_environment_error_raised_when_pool_timeout_not_an_integer(self):
+        self.env[Factory.POSTGRES_POOL_TIMEOUT] = "abc"
         with self.assertRaises(EnvironmentError) as cm:
             Factory(self.env)
         self.assertEqual(
             cm.exception.args[0],
-            "Postgres environment value for key 'POSTGRES_MAX_WAITING' "
-            "is invalid. If set, an integer or empty string is expected: 'abc'",
+            "Postgres environment value for key 'POSTGRES_POOL_TIMEOUT' "
+            "is invalid. If set, a float or empty string is expected: 'abc'",
         )
 
     def test_environment_error_raised_when_lock_timeout_not_an_integer(self):
@@ -974,12 +976,12 @@ class TestPostgresInfrastructureFactory(InfrastructureFactoryTestCase):
         )
 
     def test_environment_error_raised_when_max_conn_not_an_integer(self):
-        self.env[Factory.POSTGRES_MAX_OVERFLOW] = "abc"
+        self.env[Factory.POSTGRES_POOL_MAX_OVERFLOW] = "abc"
         with self.assertRaises(EnvironmentError) as cm:
             Factory(self.env)
         self.assertEqual(
             cm.exception.args[0],
-            "Postgres environment value for key 'POSTGRES_MAX_OVERFLOW' "
+            "Postgres environment value for key 'POSTGRES_POOL_MAX_OVERFLOW' "
             "is invalid. If set, an integer or empty string is expected: 'abc'",
         )
 

eventsourcing/tests/system_tests/test_runner.py

@@ -738,28 +738,28 @@ class TestMultiThreadedRunnerWithPostgres(TestMultiThreadedRunner):
         os.environ["POSTGRES_USER"] = "eventsourcing"
         os.environ["POSTGRES_PASSWORD"] = "eventsourcing"  # noqa: S105
 
-        with PostgresDatastore(
+        db = PostgresDatastore(
             os.getenv("POSTGRES_DBNAME"),
             os.getenv("POSTGRES_HOST"),
             os.getenv("POSTGRES_PORT"),
             os.getenv("POSTGRES_USER"),
             os.getenv("POSTGRES_PASSWORD"),
-        ) as datastore:
-            drop_postgres_table(datastore, f"{BankAccounts.name.lower()}_events")
-            drop_postgres_table(datastore, f"{EmailProcess.name.lower()}_events")
-            drop_postgres_table(datastore, f"{EmailProcess.name.lower()}_tracking")
-            drop_postgres_table(datastore, f"{EmailProcess.name.lower()}2_events")
-            drop_postgres_table(datastore, f"{EmailProcess.name.lower()}2_tracking")
-            drop_postgres_table(datastore, "brokenprocessing_events")
-            drop_postgres_table(datastore, "brokenprocessing_tracking")
-            drop_postgres_table(datastore, "brokenconverting_events")
-            drop_postgres_table(datastore, "brokenconverting_tracking")
-            drop_postgres_table(datastore, "brokenpulling_events")
-            drop_postgres_table(datastore, "brokenpulling_tracking")
-            drop_postgres_table(datastore, "commands_events")
-            drop_postgres_table(datastore, "commands_tracking")
-            drop_postgres_table(datastore, "results_events")
-            drop_postgres_table(datastore, "results_tracking")
+        )
+        drop_postgres_table(db, f"{BankAccounts.name.lower()}_events")
+        drop_postgres_table(db, f"{EmailProcess.name.lower()}_events")
+        drop_postgres_table(db, f"{EmailProcess.name.lower()}_tracking")
+        drop_postgres_table(db, f"{EmailProcess.name.lower()}2_events")
+        drop_postgres_table(db, f"{EmailProcess.name.lower()}2_tracking")
+        drop_postgres_table(db, "brokenprocessing_events")
+        drop_postgres_table(db, "brokenprocessing_tracking")
+        drop_postgres_table(db, "brokenconverting_events")
+        drop_postgres_table(db, "brokenconverting_tracking")
+        drop_postgres_table(db, "brokenpulling_events")
+        drop_postgres_table(db, "brokenpulling_tracking")
+        drop_postgres_table(db, "commands_events")
+        drop_postgres_table(db, "commands_tracking")
+        drop_postgres_table(db, "results_events")
+        drop_postgres_table(db, "results_tracking")
 
         os.environ["PERSISTENCE_MODULE"] = "eventsourcing.postgres"
 

eventsourcing/tests/system_tests/test_system.py

@@ -155,7 +155,10 @@ class TestSystem(TestCase):
 
     def test_system_has_topic_if_defined_as_module_attribute(self):
         system_topic = system_defined_as_global.topic
-        self.assertTrue(system_topic.endswith("test_system:system_defined_as_global"))
+        self.assertEqual(
+            system_topic,
+            "eventsourcing.tests.system_tests.test_system:system_defined_as_global",
+        )
         self.assertEqual(resolve_topic(system_topic), system_defined_as_global)
 
     def test_system_topic_is_none_if_defined_in_function_body(self):

{eventsourcing-9.3.0.dist-info → eventsourcing-9.3.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eventsourcing
-Version: 9.3.0
+Version: 9.3.0b1
 Summary: Event sourcing in Python
 Home-page: https://github.com/pyeventsourcing/eventsourcing
 License: BSD 3-Clause
@@ -8,7 +8,7 @@ Keywords: event sourcing,event store,domain driven design,domain-driven design,d
 Author: John Bywater
 Author-email: john.bywater@appropriatesoftware.net
 Requires-Python: >=3.8,<4.0
-Classifier: Development Status :: 5 - Production/Stable
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
 Classifier: Intended Audience :: Science/Research
@@ -29,13 +29,11 @@ Provides-Extra: postgres
 Requires-Dist: Sphinx ; extra == "docs"
 Requires-Dist: backports.zoneinfo ; python_version < "3.9"
 Requires-Dist: orjson ; extra == "docs"
-Requires-Dist: psycopg (<=3.2.1) ; (python_full_version <= "3.12.999999") and (extra == "postgres")
-Requires-Dist: psycopg-c (<=3.2.1) ; (python_full_version <= "3.12.999999") and (extra == "postgres")
-Requires-Dist: psycopg-pool (<=3.2.2) ; (python_full_version <= "3.12.999999") and (extra == "postgres")
+Requires-Dist: psycopg[c,pool] (<=3.9.99999) ; extra == "postgres"
 Requires-Dist: pycryptodome (<=3.20.99999) ; extra == "crypto"
 Requires-Dist: pydantic ; extra == "docs"
 Requires-Dist: sphinx_rtd_theme ; extra == "docs"
-Requires-Dist: typing_extensions
+Requires-Dist: typing_extensions ; python_version < "3.8"
 Project-URL: Repository, https://github.com/pyeventsourcing/eventsourcing
 Description-Content-Type: text/markdown