def test_owner_database_pairs(self, identifier, expected_schema, expected_owner, use_stmt): dialect = mssql.dialect() schema, owner = base._owner_plus_db(dialect, identifier) eq_(owner, expected_owner) eq_(schema, expected_schema) mock_connection = mock.Mock( dialect=dialect, scalar=mock.Mock(return_value="Some Database"), ) mock_lambda = mock.Mock() base._switch_db(schema, mock_connection, mock_lambda, "x", y="bar") if schema is None: eq_(mock_connection.mock_calls, []) else: eq_( mock_connection.mock_calls, [ mock.call.scalar("select db_name()"), mock.call.execute(use_stmt), mock.call.execute("use [Some Database]"), ], ) eq_(mock_lambda.mock_calls, [mock.call("x", y="bar")])
def _join_fixture_inh_selfref_w_entity(self, **kw): fake_logger = mock.Mock(info=lambda *arg, **kw: None) prop = mock.Mock(parent=mock.Mock(), mapper=mock.Mock(), logger=fake_logger) local_selectable = self.base.join(self.sub) remote_selectable = self.base.join(self.sub_w_sub_rel) # note this test requires that "parentmapper" annotation is # present in the columns ahead of time sub_w_sub_rel__sub_id = self.sub_w_sub_rel.c.sub_id._annotate( {"parentmapper": prop.mapper}) sub__id = self.sub.c.id._annotate({"parentmapper": prop.parent}) sub_w_sub_rel__flag = self.base.c.flag._annotate( {"parentmapper": prop.mapper}) return relationships.JoinCondition( local_selectable, remote_selectable, local_selectable, remote_selectable, primaryjoin=and_( sub_w_sub_rel__sub_id == sub__id, sub_w_sub_rel__flag == True, # noqa ), prop=prop, )
def fake_isolation_level(connection): connection = mock.Mock( cursor=mock.Mock( return_value=mock.Mock( fetchone=mock.Mock(return_value=None) ) ) ) return real_isolation_level(connection)
def test_max_ident_122_11compat(self): dialect = self._dialect((12, 2, 0)) conn = mock.Mock(execute=mock.Mock(return_value=mock.Mock( scalar=lambda: "11.0.0"))) dialect.initialize(conn) eq_(dialect.server_version_info, (12, 2, 0)) eq_(dialect._get_effective_compat_server_version_info(conn), (11, 0, 0)) eq_(dialect.max_identifier_length, 30)
def cx_Oracle(self): return mock.Mock( NUMBER=self.cx_Oracle_NUMBER, STRING=self.cx_Oracle_STRING, FIXED_CHAR=self.cx_Oracle_FIXED_CHAR, CLOB=self.cx_Oracle_CLOB, NCLOB=self.cx_Oracle_NCLOB, version="7.0.1", __future__=mock.Mock(), )
def test_bulk_save_mappings_preserve_order(self): (User, ) = self.classes("User") s = Session() # commit some object into db user1 = User(name="i1") user2 = User(name="i2") s.add(user1) s.add(user2) s.commit() # make some changes user1.name = "u1" user3 = User(name="i3") s.add(user3) user2.name = "u2" objects = [user1, user3, user2] from sqlalchemy_1_3 import inspect def _bulk_save_mappings( mapper, mappings, isupdate, isstates, return_defaults, update_changed_only, render_nulls, ): mock_method(list(mappings), isupdate) mock_method = mock.Mock() with mock.patch.object(s, "_bulk_save_mappings", _bulk_save_mappings): s.bulk_save_objects(objects) eq_( mock_method.mock_calls, [ mock.call([inspect(user1)], True), mock.call([inspect(user3)], False), mock.call([inspect(user2)], True), ], ) mock_method = mock.Mock() with mock.patch.object(s, "_bulk_save_mappings", _bulk_save_mappings): s.bulk_save_objects(objects, preserve_order=False) eq_( mock_method.mock_calls, [ mock.call([inspect(user3)], False), mock.call([inspect(user1), inspect(user2)], True), ], )
def test_owner_database_pairs_dont_use_for_same_db(self): dialect = mssql.dialect() identifier = "my_db.some_schema" schema, owner = base._owner_plus_db(dialect, identifier) mock_connection = mock.Mock(dialect=dialect, scalar=mock.Mock(return_value="my_db")) mock_lambda = mock.Mock() base._switch_db(schema, mock_connection, mock_lambda, "x", y="bar") eq_(mock_connection.mock_calls, [mock.call.scalar("select db_name()")]) eq_(mock_lambda.mock_calls, [mock.call("x", y="bar")])
def test_max_ident_122(self): dialect = self._dialect((12, 2, 0)) conn = mock.Mock(execute=mock.Mock(return_value=mock.Mock( scalar=lambda: "12.2.0"))) with self._expect_max_ident_warning(): dialect.initialize(conn) eq_(dialect.server_version_info, (12, 2, 0)) eq_(dialect._get_effective_compat_server_version_info(conn), (12, 2, 0)) eq_( dialect.max_identifier_length, oracle.OracleDialect.max_identifier_length, )
def test_encoding_errors_cx_oracle_py3k( self, cx_Oracle, cx_oracle_type, ): ignore_dialect = cx_oracle.dialect(dbapi=cx_Oracle, encoding_errors="ignore") ignore_outputhandler = ( ignore_dialect._generate_connection_outputtype_handler()) cursor = mock.Mock() ignore_outputhandler(cursor, "foo", cx_oracle_type, None, None, None) eq_( cursor.mock_calls, [ mock.call.var( mock.ANY, None, cursor.arraysize, encodingErrors="ignore", ) ], )
def test_invalidate_dont_call_finalizer(self): conn = self.db.connect() finalizer = mock.Mock() conn.connection._connection_record.finalize_callback.append(finalizer) conn.invalidate() assert conn.invalidated eq_(finalizer.call_count, 0)
def test_correct_for_mysql_bugs_88718_96365(self): dialect = mysql.dialect() for casing, (fkeys, ischema) in [ (0, self._bug_88718_96365_casing_0()), (1, self._bug_88718_96365_casing_1()), (2, self._bug_88718_96365_casing_2()), ]: dialect._casing = casing dialect.default_schema_name = "Test" connection = mock.Mock(dialect=dialect, execute=lambda stmt, **params: ischema) dialect._correct_for_mysql_bugs_88718_96365(fkeys, connection) eq_( fkeys, [ { "name": "FK_PlaylistTTrackId", "constrained_columns": ["TTrackID"], "referred_schema": "Test_Schema", "referred_table": "Track", "referred_columns": ["TrackID"], "options": {}, }, { "name": "FK_PlaylistTrackId", "constrained_columns": ["TrackID"], "referred_schema": None, "referred_table": "Track", "referred_columns": ["TrackID"], "options": {}, }, ], )
def test_metadata_drop_both(self): metadata, bind = self.metadata, self.bind canary = mock.Mock() event.listen(metadata, "before_drop", canary.before_drop) event.listen(metadata, "after_drop", canary.after_drop) metadata.create_all(bind) metadata.drop_all(bind) eq_( canary.mock_calls, [ mock.call.before_drop( metadata, self.bind, checkfirst=False, tables=list(metadata.tables.values()), _ddl_runner=mock.ANY, ), mock.call.after_drop( metadata, self.bind, checkfirst=False, tables=list(metadata.tables.values()), _ddl_runner=mock.ANY, ), ], )
def test_table_create_both(self): table, bind = self.table, self.bind canary = mock.Mock() event.listen(table, "before_create", canary.before_create) event.listen(table, "after_create", canary.after_create) table.create(bind) table.drop(bind) eq_( canary.mock_calls, [ mock.call.before_create( table, self.bind, checkfirst=False, _ddl_runner=mock.ANY, _is_metadata_operation=mock.ANY, ), mock.call.after_create( table, self.bind, checkfirst=False, _ddl_runner=mock.ANY, _is_metadata_operation=mock.ANY, ), ], )
def _test_baked_lazy_loading_relationship_flag(self, flag): User, Address = self._o2m_fixture(bake_queries=flag) sess = Session() u1 = sess.query(User).first() from sqlalchemy_1_3.orm import Query canary = mock.Mock() # I would think Mock can do this but apparently # it cannot (wrap / autospec don't work together) real_compile_context = Query._compile_context def _my_compile_context(*arg, **kw): if arg[0].column_descriptions[0]["entity"] is Address: canary() return real_compile_context(*arg, **kw) with mock.patch.object(Query, "_compile_context", _my_compile_context): u1.addresses sess.expire(u1) u1.addresses if flag: eq_(canary.call_count, 1) else: eq_(canary.call_count, 2)
def test_parameters(self, exec_type, usemethod, connection): collect = mock.Mock() @self._fixture def fn(context): collect(context.get_current_parameters()) table = self.tables.some_table if exec_type in ("multivalues", "executemany"): parameters = [{"y": "h1"}, {"y": "h2"}] else: parameters = [{"y": "hello"}] if exec_type == "multivalues": stmt, params = table.insert().values(parameters), {} else: stmt, params = table.insert(), parameters connection.execute(stmt, params) eq_( collect.mock_calls, [mock.call({ "y": param["y"], "x": None }) for param in parameters], )
def test_max_ident_122_11compat_vparam_cant_parse(self): dialect = self._dialect((12, 2, 0)) def c122(): return "12.thisiscrap.0" conn = mock.Mock(execute=mock.Mock(return_value=mock.Mock( scalar=c122))) with self._expect_max_ident_warning(): dialect.initialize(conn) eq_(dialect.server_version_info, (12, 2, 0)) eq_(dialect._get_effective_compat_server_version_info(conn), (12, 2, 0)) eq_( dialect.max_identifier_length, oracle.OracleDialect.max_identifier_length, )
def test_custom_bind(self): Address, addresses, users, User = ( self.classes.Address, self.tables.addresses, self.tables.users, self.classes.User, ) mapper( User, users, properties=dict(addresses=relationship( mapper(Address, addresses), lazy="select", primaryjoin=and_( users.c.id == addresses.c.user_id, users.c.name == bindparam("name"), ), )), ) canary = mock.Mock() class MyOption(MapperOption): propagate_to_loaders = True def __init__(self, crit): self.crit = crit def process_query_conditionally(self, query): """process query during a lazyload""" canary() query._params = query._params.union(dict(name=self.crit)) s = Session() ed = s.query(User).options(MyOption("ed")).filter_by(name="ed").one() eq_( ed.addresses, [ Address(id=2, user_id=8), Address(id=3, user_id=8), Address(id=4, user_id=8), ], ) eq_(canary.mock_calls, [mock.call()]) fred = (s.query(User).options( MyOption("ed")).filter_by(name="fred").one()) eq_(fred.addresses, []) # fred is missing eq_(canary.mock_calls, [mock.call(), mock.call()]) # the lazy query was not cached; the option is re-applied to the # Fred object due to populate_existing() fred = (s.query(User).populate_existing().options( MyOption("fred")).filter_by(name="fred").one()) eq_(fred.addresses, [Address(id=5, user_id=9)]) # fred is there eq_(canary.mock_calls, [mock.call(), mock.call(), mock.call()])
def test_max_ident_122_11compat_vparam_raises(self): dialect = self._dialect((12, 2, 0)) def c122(): raise exc.DBAPIError("statement", None, "no such table", None, None) conn = mock.Mock(execute=mock.Mock(return_value=mock.Mock( scalar=c122))) with self._expect_max_ident_warning(): dialect.initialize(conn) eq_(dialect.server_version_info, (12, 2, 0)) eq_(dialect._get_effective_compat_server_version_info(conn), (12, 2, 0)) eq_( dialect.max_identifier_length, oracle.OracleDialect.max_identifier_length, )
def test_default_schema_name_not_interpreted_as_tokenized(self): dialect = mssql.dialect() dialect.server_version_info = base.MS_2014_VERSION mock_connection = mock.Mock(scalar=lambda sql: "Jonah.The.Whale") schema_name = dialect._get_default_schema_name(mock_connection) eq_(schema_name, "Jonah.The.Whale") eq_( base._owner_plus_db(dialect, schema_name), (None, "Jonah.The.Whale"), )
def test_ident_length_in_13_is_30(self): from sqlalchemy_1_3 import __version__ m = re.match(r"(\d+)\.(\d+)(?:\.(\d+))?", __version__) version = tuple(int(x) for x in m.group(1, 2, 3) if x is not None) if version >= (1, 4): length = 128 else: length = 30 eq_(oracle.OracleDialect.max_identifier_length, length) dialect = self._dialect((12, 2, 0)) conn = mock.Mock(execute=mock.Mock(return_value=mock.Mock( scalar=lambda: "12.2.0"))) with self._expect_max_ident_warning(): dialect.initialize(conn) eq_(dialect.server_version_info, (12, 2, 0)) eq_(dialect._get_effective_compat_server_version_info(conn), (12, 2, 0)) eq_(dialect.max_identifier_length, length)
def test_serial_integer(self): class BITD(TypeDecorator): impl = Integer def load_dialect_impl(self, dialect): if dialect.name == "postgresql": return BigInteger() else: return Integer() for version, type_, expected in [ (None, Integer, "SERIAL"), (None, BigInteger, "BIGSERIAL"), ((9, 1), SmallInteger, "SMALLINT"), ((9, 2), SmallInteger, "SMALLSERIAL"), (None, postgresql.INTEGER, "SERIAL"), (None, postgresql.BIGINT, "BIGSERIAL"), ( None, Integer().with_variant(BigInteger(), "postgresql"), "BIGSERIAL", ), ( None, Integer().with_variant(postgresql.BIGINT, "postgresql"), "BIGSERIAL", ), ( (9, 2), Integer().with_variant(SmallInteger, "postgresql"), "SMALLSERIAL", ), (None, BITD(), "BIGSERIAL"), ]: m = MetaData() t = Table("t", m, Column("c", type_, primary_key=True)) if version: dialect = postgresql.dialect() dialect._get_server_version_info = mock.Mock( return_value=version ) dialect.initialize(testing.db.connect()) else: dialect = testing.db.dialect ddl_compiler = dialect.ddl_compiler(dialect, schema.CreateTable(t)) eq_( ddl_compiler.get_column_specification(t.c.c), "c %s NOT NULL" % expected, )
def test_metadata_table_isolation(self): metadata, table = self.metadata, self.table table_canary = mock.Mock() metadata_canary = mock.Mock() event.listen(table, "before_create", table_canary.before_create) event.listen(metadata, "before_create", metadata_canary.before_create) self.table.create(self.bind) eq_( table_canary.mock_calls, [ mock.call.before_create( table, self.bind, checkfirst=False, _ddl_runner=mock.ANY, _is_metadata_operation=mock.ANY, ) ], ) eq_(metadata_canary.mock_calls, [])
def test_older_cx_oracle_warning(self, cx_Oracle, cx_oracle_type): cx_Oracle.version = "6.3" ignore_dialect = cx_oracle.dialect(dbapi=cx_Oracle, encoding_errors="ignore") ignore_outputhandler = ( ignore_dialect._generate_connection_outputtype_handler()) cursor = mock.Mock() with testing.expect_warnings( r"cx_oracle version \(6, 3\) does not support encodingErrors"): ignore_outputhandler(cursor, "foo", cx_oracle_type, None, None, None)
def test_no_encoding_errors_sqla_py2k( self, cx_Oracle, cx_oracle_type, ): plain_dialect = cx_oracle.dialect(dbapi=cx_Oracle) plain_outputhandler = ( plain_dialect._generate_connection_outputtype_handler()) cursor = mock.Mock() plain_outputhandler(cursor, "foo", cx_oracle_type, None, None, None) outconverter = cursor.mock_calls[0][2]["outconverter"] self._assert_errorhandler(outconverter, False)
def test_modified_event(self): canary = mock.Mock() event.listen(Foo.data, "modified", canary) f1 = Foo(data={"a": "b"}) f1.data["a"] = "c" eq_( canary.mock_calls, [ mock.call( f1, attributes.Event(Foo.data.impl, attributes.OP_MODIFIED)) ], )
def test_is_disconnect( self, arg0, message, exc_cls_name, dialect_name, is_disconnect ): class Error(Exception): pass dbapi = mock.Mock() dbapi.Error = Error dbapi.ProgrammingError = type("ProgrammingError", (Error,), {}) dbapi.OperationalError = type("OperationalError", (Error,), {}) dbapi.InterfaceError = type("InterfaceError", (Error,), {}) dbapi.InternalError = type("InternalError", (Error,), {}) dialect = getattr(mysql, dialect_name).dialect(dbapi=dbapi) error = getattr(dbapi, exc_cls_name)(arg0, message) eq_(dialect.is_disconnect(error, None, None), is_disconnect)
def test_spoiled_half_w_params(self): User = self.classes.User canary = mock.Mock() def fn1(s): canary.fn1() return s.query(User.id, User.name).order_by(User.id) def fn2(q): canary.fn2() return q.filter(User.id == bindparam("id")) def fn3(q): canary.fn3() return q bq = self.bakery(fn1) bq += fn2 for x in range(3): bq = self.bakery(fn1) bq += fn2 sess = Session(autocommit=True) eq_( bq.spoil().add_criteria(fn3)(sess).params(id=7).all(), [(7, "jack")], ) eq_( canary.mock_calls, [ mock.call.fn1(), mock.call.fn2(), mock.call.fn3(), mock.call.fn3(), mock.call.fn3(), ], )
def test_table_drop_after(self): table, bind = self.table, self.bind canary = mock.Mock() event.listen(table, "after_drop", canary.after_drop) table.create(bind) canary.state = "skipped" table.drop(bind) eq_( canary.mock_calls, [ mock.call.after_drop( table, self.bind, checkfirst=False, _ddl_runner=mock.ANY, _is_metadata_operation=mock.ANY, ) ], )
def test_metadata_create_before(self): metadata, bind = self.metadata, self.bind canary = mock.Mock() event.listen(metadata, "before_create", canary.before_create) metadata.create_all(bind) metadata.drop_all(bind) eq_( canary.mock_calls, [ mock.call.before_create( # checkfirst is False because of the MockConnection # used in the current testing strategy. metadata, self.bind, checkfirst=False, tables=list(metadata.tables.values()), _ddl_runner=mock.ANY, ) ], )
def modify_query_fixture(self): def set_event(bake_ok): event.listen( Query, "before_compile", _modify_query, retval=True, bake_ok=bake_ok, ) return m1 m1 = mock.Mock() def _modify_query(query): m1(query.column_descriptions[0]["entity"]) query = query.enable_assertions(False).filter( literal_column("1") == 1) return query yield set_event event.remove(Query, "before_compile", _modify_query)