def test_connect_failure_raises_interface_error(self):
datastore = PostgresDatastore(
dbname="eventsourcing",
host="127.0.0.1",
port="9876543210", # bad port
user="******",
password="******",
)
with self.assertRaises(InterfaceError):
datastore.transaction(commit=True)
def drop_postgres_table(datastore: PostgresDatastore, table_name):
statement = f"DROP TABLE {table_name};"
try:
with datastore.transaction(commit=True) as curs:
curs.execute(statement)
except PersistenceError:
pass
def test_connection_of_transaction_not_used_as_context_manager_also_goes_idle(
self):
datastore = PostgresDatastore(
dbname="eventsourcing",
host="127.0.0.1",
port="5432",
user="******",
password="******",
)
# Get a transaction.
transaction = datastore.transaction(commit=False)
# Check connection is not idle.
conn = transaction.c
self.assertFalse(conn.is_idle.is_set())
# Delete the transaction context manager before entering.
print(
"Testing transaction not used as context manager, expecting exception..."
)
del transaction
# Check connection is idle after garbage collection.
self.assertTrue(conn.is_idle.wait(timeout=0.1))
def test_timer_closes_connection(self):
datastore = PostgresDatastore(
dbname="eventsourcing",
host="127.0.0.1",
port="5432",
user="******",
password="******",
conn_max_age=0,
)
# Check connection is closed after using transaction.
transaction = datastore.transaction(commit=False)
with transaction as conn:
with conn.cursor() as c:
c.execute("SELECT 1")
self.assertEqual(c.fetchall(), [[1]])
self.assertTrue(transaction.c.is_closing.wait(timeout=0.5))
for _ in range(1000):
if transaction.c.is_closed:
break
else:
sleep(0.0001)
else:
self.fail("Connection is not closed")
with self.assertRaises(psycopg2.InterfaceError) as cm:
transaction.c.cursor()
self.assertEqual(cm.exception.args[0], "connection already closed")
# Check closed connection can be recreated and also closed.
transaction = datastore.transaction(commit=False)
with transaction as conn:
with conn.cursor() as c:
c.execute("SELECT 1")
self.assertEqual(c.fetchall(), [[1]])
self.assertTrue(transaction.c.is_closing.wait(timeout=0.5))
for _ in range(1000):
if transaction.c.is_closed:
break
else:
sleep(0.0001)
else:
self.fail("Connection is not closed")
def drop_postgres_table(datastore: PostgresDatastore, table_name):
try:
with datastore.transaction() as c:
statement = f"DROP TABLE {table_name};"
print("Executing statement:", statement)
c.execute(statement)
print("Executed statement:", statement)
except psycopg2.errors.lookup(UNDEFINED_TABLE):
print("Failed to execute statement:", statement)
pass # print(f"Table does not exist: {table_name}")
except Exception:
print("Strange error:", statement)
def test_close_connection(self):
datastore = PostgresDatastore(
dbname="eventsourcing",
host="127.0.0.1",
port="5432",
user="******",
password="******",
)
# Try closing without first creating connection.
datastore.close_connection()
# Create a connection.
with datastore.transaction(commit=False) as conn:
with conn.cursor() as c:
c.execute("SELECT 1")
self.assertEqual(c.fetchall(), [[1]])
# Try closing after creating connection.
datastore.close_connection()
def test_transaction(self):
datastore = PostgresDatastore(
dbname="eventsourcing",
host="127.0.0.1",
port="5432",
user="******",
password="******",
)
# Get a transaction.
transaction = datastore.transaction(commit=False)
# Check connection is not idle.
self.assertFalse(transaction.c.is_idle.is_set())
# Check transaction gives database cursor when used as context manager.
with transaction as conn:
with conn.cursor() as c:
c.execute("SELECT 1")
self.assertEqual(c.fetchall(), [[1]])
# Check connection is idle after context manager has exited.
self.assertTrue(transaction.c.is_idle.wait(timeout=0.1))
def drop_postgres_table(datastore: PostgresDatastore, table_name):
try:
with datastore.transaction() as c:
c.execute(f"DROP TABLE {table_name};")
except psycopg2.errors.lookup(UNDEFINED_TABLE):
pass # print(f"Table does not exist: {table_name}")
def test_pre_ping(self):
datastore = PostgresDatastore(
dbname="eventsourcing",
host="127.0.0.1",
port="5432",
user="******",
password="******",
pre_ping=True,
)
# Create a connection.
transaction = datastore.transaction(commit=False)
pg_conn = transaction.c.c
self.assertEqual(pg_conn, transaction.c.c)
# Check the connection works.
with transaction as conn:
with conn.cursor() as c:
c.execute("SELECT 1")
self.assertEqual(c.fetchall(), [[1]])
# Close all connections via separate connection.
pg_close_all_connections()
# Check the connection doesn't think it's closed.
self.assertFalse(transaction.c.is_closed)
# Check we can get a new connection that works.
transaction = datastore.transaction(commit=False)
with transaction as conn:
with conn.cursor() as c:
c.execute("SELECT 1")
self.assertEqual(c.fetchall(), [[1]])
# Check it's actually a different connection.
self.assertNotEqual(pg_conn, transaction.c.c)
# Check this doesn't work if we don't use pre_ping.
datastore = PostgresDatastore(
dbname="eventsourcing",
host="127.0.0.1",
port="5432",
user="******",
password="******",
pre_ping=False,
)
# Create a connection.
transaction = datastore.transaction(commit=False)
pg_conn = transaction.c.c
self.assertEqual(pg_conn, transaction.c.c)
# Check the connection works.
with transaction as conn:
with conn.cursor() as c:
c.execute("SELECT 1")
self.assertEqual(c.fetchall(), [[1]])
# Close all connections via separate connection.
pg_close_all_connections()
# Check the connection doesn't think it's closed.
self.assertFalse(transaction.c.is_closed)
# Get a stale connection and check it doesn't work.
transaction = datastore.transaction(commit=False)
# Check it's the same connection.
self.assertEqual(pg_conn, transaction.c.c)
with self.assertRaises(InterfaceError):
with transaction as conn:
with conn.cursor() as c:
c.execute("SELECT 1")