def test_engine_connect(self, testing_engine):
e1 = testing_engine(config.db_url)
canary = Mock()
def thing(conn, branch):
canary(conn, branch)
event.listen(e1, "engine_connect", thing)
msg = (
r"The argument signature for the "
r'"ConnectionEvents.engine_connect" event listener has changed as '
r"of version 2.0, and conversion for the old argument signature "
r"will be removed in a future release. The new signature is "
r'"def engine_connect\(conn\)')
with expect_deprecated(msg):
c1 = e1.connect()
c1.close()
with expect_deprecated(msg):
c2 = e1.connect()
c2.close()
eq_(canary.mock_calls, [mock.call(c1, False), mock.call(c2, False)])
def test_implicit_returning_engine_parameter(self, implicit_returning):
if implicit_returning is None:
engines.testing_engine()
else:
with assertions.expect_deprecated(ce_implicit_returning):
engines.testing_engine(
options={"implicit_returning": implicit_returning})
def test_standalone_via_exec_removed(self, connection):
t = self.tables.default_test
with expect_deprecated(
r"Using the .execute\(\) method to invoke a "
r"DefaultGenerator object is deprecated; please use "
r"the .scalar\(\) method."):
connection.execute(t.c.col1.default)
with expect_deprecated(
r"Using the .execute\(\) method to invoke a "
r"DefaultGenerator object is deprecated; please use "
r"the .scalar\(\) method."):
connection.execute(t.c.col2.default)
with expect_deprecated(
r"Using the .execute\(\) method to invoke a "
r"DefaultGenerator object is deprecated; please use "
r"the .scalar\(\) method."):
connection.execute(t.c.col3.default)
def test_execute_deprecated(self, connection):
s = Sequence("my_sequence", optional=True)
with expect_deprecated(
r"Using the .execute\(\) method to invoke a "
r"DefaultGenerator object is deprecated; please use "
r"the .scalar\(\) method."):
self._assert_seq_result(connection.execute(s))
def test_connection_fairy_connection(self):
dbapi = MockDBAPI()
p1 = pool.QueuePool(creator=lambda: dbapi.connect("foo.db"))
fairy = p1.connect()
with expect_deprecated(
"The _ConnectionFairy.connection attribute is deprecated; "
"please use 'driver_connection'"):
is_(fairy.connection, fairy.dbapi_connection)
def test_connection_rec_connection(self):
dbapi = MockDBAPI()
p1 = pool.Pool(creator=lambda: dbapi.connect("foo.db"))
rec = pool._ConnectionRecord(p1)
with expect_deprecated(
"The _ConnectionRecord.connection attribute is deprecated; "
"please use 'driver_connection'"):
is_(rec.connection, rec.dbapi_connection)
def test_implicit_returning_engine_parameter(self, implicit_returning):
if implicit_returning is None:
e = engines.testing_engine()
else:
with assertions.expect_deprecated(ce_implicit_returning):
e = engines.testing_engine(
options={"implicit_returning": implicit_returning})
if implicit_returning is None:
eq_(
e.dialect.implicit_returning,
testing.db.dialect.implicit_returning,
)
else:
eq_(e.dialect.implicit_returning, implicit_returning)
t = Table(
"t",
MetaData(),
Column("id", Integer, primary_key=True),
Column("data", String(50)),
)
t2 = Table(
"t",
MetaData(),
Column("id", Integer, primary_key=True),
Column("data", String(50)),
implicit_returning=False,
)
with e.connect() as conn:
stmt = insert(t).values(data="data")
if implicit_returning:
if not testing.requires.returning.enabled:
with expect_raises_message(exc.CompileError,
"RETURNING is not supported"):
stmt.compile(conn)
else:
eq_(stmt.compile(conn).implicit_returning, [t.c.id])
elif (implicit_returning is None
and testing.db.dialect.implicit_returning):
eq_(stmt.compile(conn).implicit_returning, [t.c.id])
else:
eq_(stmt.compile(conn).implicit_returning, [])
# table setting it to False disables it
stmt2 = insert(t2).values(data="data")
eq_(stmt2.compile(conn).implicit_returning, [])
def test_dbapi_clsmethod_renamed(self):
"""The dbapi() class method is renamed to import_dbapi(),
so that the .dbapi attribute can be exclusively an instance
attribute.
"""
from sqlalchemy.dialects.sqlite import pysqlite
from sqlalchemy.dialects import registry
canary = mock.Mock()
class MyDialect(pysqlite.SQLiteDialect_pysqlite):
@classmethod
def dbapi(cls):
canary()
return __import__("sqlite3")
tokens = __name__.split(".")
global dialect
dialect = MyDialect
registry.register("mockdialect1.sqlite", ".".join(tokens[0:-1]),
tokens[-1])
with expect_deprecated(
r"The dbapi\(\) classmethod on dialect classes has "
r"been renamed to import_dbapi\(\). Implement an "
r"import_dbapi\(\) classmethod directly on class "
r".*MyDialect.* to remove this warning; the old "
r".dbapi\(\) classmethod may be maintained for backwards "
r"compatibility."):
e = create_engine("mockdialect1+sqlite://")
eq_(canary.mock_calls, [mock.call()])
sqlite3 = __import__("sqlite3")
is_(e.dialect.dbapi, sqlite3)
async def test_sequence_execute(
self, async_session: AsyncSession, metadata, use_scalar
):
seq = Sequence("some_sequence", metadata=metadata)
sync_connection = (await async_session.connection()).sync_connection
await (await async_session.connection()).run_sync(metadata.create_all)
if use_scalar:
eq_(
await async_session.scalar(seq),
sync_connection.dialect.default_sequence_base,
)
else:
with expect_deprecated(
r"Using the .execute\(\) method to invoke a "
r"DefaultGenerator object is deprecated; please use "
r"the .scalar\(\) method."
):
eq_(
await async_session.execute(seq),
sync_connection.dialect.default_sequence_base,
)
def _legacy_schema_aliasing_warning():
return assertions.expect_deprecated("The legacy_schema_aliasing parameter")
def test_only_str_drivername_no_none_legacy(self, value):
with expect_deprecated(r"Calling URL\(\) directly"):
assert_raises_message(
TypeError, "drivername must be a string", url.URL, value
)
