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 )