def test_parent_instance_child_class_apply_after(self): l1 = Mock() l2 = Mock() event.listen(self.TargetElement, "event_one", l2) factory = self.TargetFactory() element = factory.create() element.run_event(1) event.listen(factory, "event_one", l1) element.run_event(2) element.run_event(3) # if _JoinedListener fixes .listeners # at construction time, then we don't get # the new listeners. # eq_(l1.mock_calls, []) # alternatively, if _JoinedListener shares the list # using a @property, then we get them, at the arguable # expense of the extra method call to access the .listeners # collection eq_(l1.mock_calls, [call(element, 2), call(element, 3)]) eq_( l2.mock_calls, [call(element, 1), call(element, 2), call(element, 3)], )
def MockDBAPI(): def cursor(): while True: if explode_on_exec: yield Mock( description=[], close=Mock(side_effect=DBAPIError("explode")), execute=Mock(side_effect=DBAPIError("explode")), ) else: yield Mock( description=[], close=Mock(side_effect=Exception("explode")), ) def connect(): while True: yield Mock( spec=["cursor", "commit", "rollback", "close"], cursor=Mock(side_effect=cursor()), ) return Mock( Error=DBAPIError, paramstyle="qmark", connect=Mock(side_effect=connect()), )
def test_parent_instance_child_class_apply_before(self): l1 = Mock() l2 = Mock() event.listen(self.TargetElement, "event_one", l2) factory = self.TargetFactory() event.listen(factory, "event_one", l1) element = factory.create() element.run_event(1) element.run_event(2) element.run_event(3) eq_( l1.mock_calls, [call(element, 1), call(element, 2), call(element, 3)], ) eq_( l2.mock_calls, [call(element, 1), call(element, 2), call(element, 3)], )
def test_exec_once_unless_exception(self): m1 = Mock() m1.side_effect = ValueError event.listen(self.Target, "event_one", m1) t1 = self.Target() assert_raises( ValueError, t1.dispatch.event_one.for_modify( t1.dispatch).exec_once_unless_exception, 5, 6, ) assert_raises( ValueError, t1.dispatch.event_one.for_modify( t1.dispatch).exec_once_unless_exception, 7, 8, ) m1.side_effect = None t1.dispatch.event_one.for_modify( t1.dispatch).exec_once_unless_exception(9, 10) t1.dispatch.event_one.for_modify( t1.dispatch).exec_once_unless_exception(11, 12) eq_(m1.mock_calls, [call(5, 6), call(7, 8), call(9, 10)])
def _dbapi(self): return Mock( paramstyle="qmark", connect=Mock(return_value=Mock( server_version="UI-V6.3.2.18118 Firebird 2.1", cursor=Mock(return_value=Mock()), )), )
def mock_dbapi(): return Mock( paramstyle="qmark", connect=Mock( return_value=Mock( cursor=Mock(return_value=Mock(description=None, rowcount=None)) ) ), )
def mock_connection(): def mock_cursor(): def execute(*args, **kwargs): if conn.explode == "execute": raise MockDisconnect("Lost the DB connection on execute") elif conn.explode == "interrupt": conn.explode = "explode_no_disconnect" raise MockExitIsh("Keyboard / greenlet / etc interruption") elif conn.explode == "interrupt_dont_break": conn.explode = None raise MockExitIsh("Keyboard / greenlet / etc interruption") elif conn.explode in ( "execute_no_disconnect", "explode_no_disconnect", ): raise MockError( "something broke on execute but we didn't lose the " "connection") elif conn.explode in ( "rollback", "rollback_no_disconnect", "explode_no_disconnect", ): raise MockError( "something broke on execute but we didn't lose the " "connection") elif args and "SELECT" in args[0]: cursor.description = [("foo", None, None, None, None, None)] else: return def close(): cursor.fetchall = cursor.fetchone = Mock( side_effect=MockError("cursor closed")) cursor = Mock(execute=Mock(side_effect=execute), close=Mock(side_effect=close)) return cursor def cursor(): while True: yield mock_cursor() def rollback(): if conn.explode == "rollback": raise MockDisconnect("Lost the DB connection on rollback") if conn.explode == "rollback_no_disconnect": raise MockError( "something broke on rollback but we didn't lose the " "connection") else: return conn = Mock(rollback=Mock(side_effect=rollback), cursor=Mock(side_effect=cursor())) return conn
def test_bind_joined_sub_class_joined_sub_class(self): base_class_bind = Mock(name="base") joined_class_bind = Mock(name="joined") session = self._fixture({ self.classes.BaseClass: base_class_bind, self.classes.JoinedSubClass: joined_class_bind, }) is_(session.get_bind(self.classes.BaseClass), base_class_bind) is_(session.get_bind(self.classes.JoinedSubClass), joined_class_bind)
def _mock_connection(self, item_exists): def has_item(connection, name, schema): return item_exists(name) return Mock(dialect=Mock( supports_sequences=True, has_table=Mock(side_effect=has_item), has_sequence=Mock(side_effect=has_item), supports_comments=True, inline_comments=False, ))
def test_plugin_multiple_url_registration(self): from sqlalchemy_1_3.dialects import sqlite global MyEnginePlugin1 global MyEnginePlugin2 def side_effect_1(url, kw): eq_(kw, {"logging_name": "foob"}) kw["logging_name"] = "bar" url.query.pop("myplugin1_arg", None) return MyEnginePlugin1 def side_effect_2(url, kw): url.query.pop("myplugin2_arg", None) return MyEnginePlugin2 MyEnginePlugin1 = Mock(side_effect=side_effect_1) MyEnginePlugin2 = Mock(side_effect=side_effect_2) plugins.register("engineplugin1", __name__, "MyEnginePlugin1") plugins.register("engineplugin2", __name__, "MyEnginePlugin2") e = create_engine( "sqlite:///?plugin=engineplugin1&foo=bar&myplugin1_arg=bat" "&plugin=engineplugin2&myplugin2_arg=hoho", logging_name="foob", ) eq_(e.dialect.name, "sqlite") eq_(e.logging_name, "bar") # plugin args are removed from URL. eq_(e.url.query, {"foo": "bar"}) assert isinstance(e.dialect, sqlite.dialect) eq_( MyEnginePlugin1.mock_calls, [ call(url.make_url("sqlite:///?foo=bar"), {}), call.handle_dialect_kwargs(sqlite.dialect, mock.ANY), call.handle_pool_kwargs(mock.ANY, {"dialect": e.dialect}), call.engine_created(e), ], ) eq_( MyEnginePlugin2.mock_calls, [ call(url.make_url("sqlite:///?foo=bar"), {}), call.handle_dialect_kwargs(sqlite.dialect, mock.ANY), call.handle_pool_kwargs(mock.ANY, {"dialect": e.dialect}), call.engine_created(e), ], )
def test_bind_sub_class_concrete_sub_class(self): base_class_bind = Mock(name="base") concrete_sub_bind = Mock(name="concrete") session = self._fixture({ self.classes.BaseClass: base_class_bind, self.classes.ConcreteSubClass: concrete_sub_bind, }) is_(session.get_bind(self.classes.BaseClass), base_class_bind) is_(session.get_bind(self.classes.ConcreteSubClass), concrete_sub_bind)
def cursor(): while True: if explode_on_exec: yield Mock( description=[], close=Mock(side_effect=DBAPIError("explode")), execute=Mock(side_effect=DBAPIError("explode")), ) else: yield Mock( description=[], close=Mock(side_effect=Exception("explode")), )
def test_listen_override(self): listen_one = Mock() listen_two = Mock() event.listen(self.Target, "event_one", listen_one, add=True) event.listen(self.Target, "event_one", listen_two) t1 = self.Target() t1.dispatch.event_one(5, 7) t1.dispatch.event_one(10, 5) eq_(listen_one.mock_calls, [call(12), call(15)]) eq_(listen_two.mock_calls, [call(5, 7), call(10, 5)])
def test_bind_joined_sub_table_joined_sub_class(self): base_class_bind = Mock(name="base") joined_class_bind = Mock(name="joined") session = self._fixture({ self.tables.base_table: base_class_bind, self.tables.joined_sub_table: joined_class_bind, }) is_(session.get_bind(self.classes.BaseClass), base_class_bind) # joined table inheritance has to query based on the base # table, so this is what we expect is_(session.get_bind(self.classes.JoinedSubClass), base_class_bind)
def _fixture(self, explode_on_exec, initialize): class DBAPIError(Exception): pass def MockDBAPI(): def cursor(): while True: if explode_on_exec: yield Mock( description=[], close=Mock(side_effect=DBAPIError("explode")), execute=Mock(side_effect=DBAPIError("explode")), ) else: yield Mock( description=[], close=Mock(side_effect=Exception("explode")), ) def connect(): while True: yield Mock( spec=["cursor", "commit", "rollback", "close"], cursor=Mock(side_effect=cursor()), ) return Mock( Error=DBAPIError, paramstyle="qmark", connect=Mock(side_effect=connect()), ) dbapi = MockDBAPI() from sqlalchemy_1_3.engine import default url = Mock( get_dialect=lambda: default.DefaultDialect, _get_entrypoint=lambda: default.DefaultDialect, _instantiate_plugins=lambda kwargs: (), translate_connect_args=lambda: {}, query={}, ) eng = testing_engine(url, options=dict(module=dbapi, _initialize=initialize)) eng.pool.logger = Mock() return eng
def test_listener_collection_removed_cleanup(self): from sqlalchemy_1_3.event import registry Target = self._fixture() m1 = Mock() t1 = Target() event.listen(t1, "event_one", m1) key = (id(t1), "event_one", id(m1)) assert key in registry._key_to_collection collection_ref = list(registry._key_to_collection[key])[0] assert collection_ref in registry._collection_to_key t1.dispatch.event_one("t1") del t1 gc_collect() assert key not in registry._key_to_collection assert collection_ref not in registry._collection_to_key
def test_once_doesnt_dereference_listener(self): # test for [ticket:4794] Target = self._fixture() canary = Mock() def go(target, given_id): def anonymous(run_id): canary(run_id, given_id) event.listen(target, "event_one", anonymous, once=True) t1 = Target() assert_calls = [] given_ids = [] for given_id in range(100): given_ids.append(given_id) go(t1, given_id) if given_id % 10 == 0: t1.dispatch.event_one(given_id) assert_calls.extend(call(given_id, i) for i in given_ids) given_ids[:] = [] eq_(canary.mock_calls, assert_calls)
def test_collection(self): users, addresses, Address = ( self.tables.users, self.tables.addresses, self.classes.Address, ) canary = Mock() class User(fixtures.ComparableEntity): @validates("addresses") def validate_address(self, key, ad): canary(key, ad) assert "@" in ad.email_address return ad mapper(User, users, properties={"addresses": relationship(Address)}) mapper(Address, addresses) sess = Session() u1 = User(name="edward") a0 = Address(email_address="noemail") assert_raises(AssertionError, u1.addresses.append, a0) a1 = Address(id=15, email_address="*****@*****.**") u1.addresses.append(a1) eq_(canary.mock_calls, [call("addresses", a0), call("addresses", a1)]) sess.add(u1) sess.commit() eq_( sess.query(User).filter_by(name="edward").one(), User( name="edward", addresses=[Address(email_address="*****@*****.**")] ), )
def test_scalar(self): users = self.tables.users canary = Mock() class User(fixtures.ComparableEntity): @validates("name") def validate_name(self, key, name): canary(key, name) ne_(name, "fred") return name + " modified" mapper(User, users) sess = Session() u1 = User(name="ed") eq_(u1.name, "ed modified") assert_raises(AssertionError, setattr, u1, "name", "fred") eq_(u1.name, "ed modified") eq_(canary.mock_calls, [call("name", "ed"), call("name", "fred")]) sess.add(u1) sess.commit() eq_( sess.query(User).filter_by(name="ed modified").one(), User(name="ed"), )
def MockDBAPI(**assert_kwargs): connection = Mock(get_server_version_info=Mock(return_value="5.0")) def connect(*args, **kwargs): for k in assert_kwargs: assert k in kwargs, "key %s not present in dictionary" % k eq_(kwargs[k], assert_kwargs[k]) return connection return MagicMock( sqlite_version_info=(99, 9, 9), version_info=(99, 9, 9), sqlite_version="99.9.9", paramstyle="named", connect=Mock(side_effect=connect), )
def test_propagate(self): Target = self._fixture() m1 = Mock() t1 = Target() t2 = Target() event.listen(t1, "event_one", m1, propagate=True) event.listen(t1, "event_two", m1, propagate=False) t2.dispatch._update(t1.dispatch) t1.dispatch.event_one("t1e1x") t1.dispatch.event_two("t1e2x") t2.dispatch.event_one("t2e1x") t2.dispatch.event_two("t2e2x") event.remove(t1, "event_one", m1) event.remove(t1, "event_two", m1) t1.dispatch.event_one("t1e1y") t1.dispatch.event_two("t1e2y") t2.dispatch.event_one("t2e1y") t2.dispatch.event_two("t2e2y") eq_(m1.mock_calls, [call("t1e1x"), call("t1e2x"), call("t2e1x")])
def test_wrapper_hooks(self): def get_dialect_cls(url): url.drivername = "sqlite" return url.get_dialect() global WrapperFactory WrapperFactory = Mock() WrapperFactory.get_dialect_cls.side_effect = get_dialect_cls registry.register("wrapperdialect", __name__, "WrapperFactory") from sqlalchemy_1_3.dialects import sqlite e = create_engine("wrapperdialect://") eq_(e.dialect.name, "sqlite") assert isinstance(e.dialect, sqlite.dialect) eq_( WrapperFactory.mock_calls, [ call.get_dialect_cls(url.make_url("sqlite://")), call.engine_created(e), ], )
def test_legacy_accept_kw_cls(self): canary = Mock() @event.listens_for(self.TargetOne, "event_four") def handler1(x, y, **kw): canary(x, y, kw) self._test_legacy_accept_kw(self.TargetOne(), canary)
def test_standard_accept_has_legacies(self): canary = Mock() event.listen(self.TargetOne, "event_three", canary) self.TargetOne().dispatch.event_three(4, 5) eq_(canary.mock_calls, [call(4, 5)])
def test_use_nchar(self): dialect = self._dialect((10, 2, 5), use_nchar_for_unicode=True) dialect.initialize(Mock()) assert dialect._use_nchar_for_unicode self.assert_compile(String(50), "VARCHAR2(50 CHAR)", dialect=dialect) self.assert_compile(Unicode(50), "NVARCHAR2(50)", dialect=dialect) self.assert_compile(UnicodeText(), "NCLOB", dialect=dialect)
def test_insert_invoke_clslevel(self): canary = Mock() event.listen(self.BaseTarget, "event_one", canary, insert=True) s1 = self.SubTarget(self.BaseTarget()) s1.dispatch.event_one() eq_(canary.mock_calls, [call.event_one()])
def test_exec_once_exception(self): m1 = Mock() m1.side_effect = ValueError event.listen(self.Target, "event_one", m1) t1 = self.Target() assert_raises( ValueError, t1.dispatch.event_one.for_modify(t1.dispatch).exec_once, 5, 6, ) t1.dispatch.event_one.for_modify(t1.dispatch).exec_once(7, 8) eq_(m1.mock_calls, [call(5, 6)])
def test_propagate(self): listen_one = Mock() listen_two = Mock() t1 = self.Target() event.listen(t1, "event_one", listen_one, propagate=True) event.listen(t1, "event_two", listen_two) t2 = self.Target() t2.dispatch._update(t1.dispatch) t2.dispatch.event_one(t2, 1) t2.dispatch.event_two(t2, 2) eq_(listen_one.mock_calls, [call(t2, 1)]) eq_(listen_two.mock_calls, [])
def test_remove_instancelevel(self): listen_one = Mock() t1 = self.Target() event.listen(t1, "event_one", listen_one, add=True) t1.dispatch.event_one(5, 7) eq_(listen_one.mock_calls, [call(12)]) event.remove(t1, "event_one", listen_one) t1.dispatch.event_one(10, 5) eq_(listen_one.mock_calls, [call(12)])
def test_complex_legacy_accept(self): canary = Mock() @event.listens_for(self.TargetOne, "event_six") def handler1(x, y, z, q): canary(x, y, z, q) self.TargetOne().dispatch.event_six(4, 5) eq_(canary.mock_calls, [call(4, 5, 9, 20)])