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)])