def test_slots_dispatch(self):
class Target(object):
__slots__ = ("_slots_dispatch", )
class TargetEvents(event.Events):
_dispatch_target = Target
def event_one(self, x, y):
pass
def event_two(self, x):
pass
def event_three(self, x):
pass
t1 = Target()
m1 = Mock()
event.listen(t1, "event_one", m1)
t1.dispatch.event_one(2, 4)
eq_(m1.mock_calls, [call(2, 4)])
def test_serial_integer(self):
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'),
]:
m = MetaData()
t = Table('t', m, Column('c', type_, primary_key=True))
if version:
dialect = postgresql.dialect()
dialect._get_server_version_info = 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_partial_kw_accept_wrapped(self):
TargetOne = self._wrapped_fixture()
canary = Mock()
@event.listens_for(TargetOne, "event_five", named=True)
def handler1(z, y, **kw):
canary(z, y, kw)
TargetOne().dispatch.event_five(4, 5, 6, 7)
eq_(
canary.mock_calls,
[
call(
"adapted 6",
"adapted 5",
{
"q": "adapted 7",
"x": "adapted 4"
},
)
],
)
def test_no_slots_dispatch(self):
class Target(object):
__slots__ = ()
class TargetEvents(event.Events):
_dispatch_target = Target
def event_one(self, x, y):
pass
def event_two(self, x):
pass
def event_three(self, x):
pass
t1 = Target()
with testing.expect_raises_message(
TypeError,
r"target .*Target.* doesn't have __dict__, should it "
"be defining _slots_dispatch",
):
event.listen(t1, "event_one", Mock())
def mock_conn_scalar(self):
return lambda text: Mock(exec_driver_sql=Mock(return_value=Mock(
scalar=Mock(return_value=text))))
def connect():
while True:
yield Mock(
spec=["cursor", "commit", "rollback", "close"],
cursor=Mock(side_effect=cursor()),
)
def test_bind_base_class_concrete_sub_class(self):
base_class_bind = Mock()
session = self._fixture({self.classes.BaseClass: base_class_bind})
is_(session.get_bind(self.classes.ConcreteSubClass), base_class_bind)
def test_bind_mixin_class_simple_class(self):
base_class_bind = Mock()
session = self._fixture({self.classes.MixinOne: base_class_bind})
is_(session.get_bind(self.classes.ClassWMixin), base_class_bind)
def test_bind_base_table_base_class(self):
base_class_bind = Mock()
session = self._fixture({self.tables.base_table: base_class_bind})
is_(session.get_bind(self.classes.BaseClass), base_class_bind)
def mock_conn(res):
return Mock(execute=Mock(return_value=Mock(scalar=Mock(
return_value=res))))
def connect(*arg, **kw):
return Mock(cursor=Mock(side_effect=cursor))
def test_recycle_pool_no_race(self):
def slow_close():
slow_closing_connection._slow_close()
time.sleep(.5)
slow_closing_connection = Mock()
slow_closing_connection.connect.return_value.close = slow_close
class Error(Exception):
pass
dialect = Mock()
dialect.is_disconnect = lambda *arg, **kw: True
dialect.dbapi.Error = Error
pools = []
class TrackQueuePool(pool.QueuePool):
def __init__(self, *arg, **kw):
pools.append(self)
super(TrackQueuePool, self).__init__(*arg, **kw)
def creator():
return slow_closing_connection.connect()
p1 = TrackQueuePool(creator=creator, pool_size=20)
from sqlalchemy import create_engine
eng = create_engine(testing.db.url, pool=p1, _initialize=False)
eng.dialect = dialect
# 15 total connections
conns = [eng.connect() for i in range(15)]
# return 8 back to the pool
for conn in conns[3:10]:
conn.close()
def attempt(conn):
time.sleep(random.random())
try:
conn._handle_dbapi_exception(Error(), "statement", {}, Mock(),
Mock())
except tsa.exc.DBAPIError:
pass
# run an error + invalidate operation on the remaining 7 open
#connections
threads = []
for conn in conns:
t = threading.Thread(target=attempt, args=(conn, ))
t.start()
threads.append(t)
for t in threads:
t.join()
# return all 15 connections to the pool
for conn in conns:
conn.close()
# re-open 15 total connections
conns = [eng.connect() for i in range(15)]
# 15 connections have been fully closed due to invalidate
assert slow_closing_connection._slow_close.call_count == 15
# 15 initial connections + 15 reconnections
assert slow_closing_connection.connect.call_count == 30
assert len(pools) <= 2, len(pools)
def _test_validator_backrefs(self, include_backrefs, include_removes):
users, addresses = (self.tables.users, self.tables.addresses)
canary = Mock()
class User(fixtures.ComparableEntity):
if include_removes:
@validates('addresses',
include_removes=True,
include_backrefs=include_backrefs)
def validate_address(self, key, item, remove):
canary(key, item, remove)
return item
else:
@validates('addresses',
include_removes=False,
include_backrefs=include_backrefs)
def validate_address(self, key, item):
canary(key, item)
return item
class Address(fixtures.ComparableEntity):
if include_removes:
@validates('user',
include_backrefs=include_backrefs,
include_removes=True)
def validate_user(self, key, item, remove):
canary(key, item, remove)
return item
else:
@validates('user', include_backrefs=include_backrefs)
def validate_user(self, key, item):
canary(key, item)
return item
mapper(User,
users,
properties={'addresses': relationship(Address, backref="user")})
mapper(Address, addresses)
u1 = User()
u2 = User()
a1, a2 = Address(), Address()
# 3 append/set, two removes
u1.addresses.append(a1)
u1.addresses.append(a2)
a2.user = u2
del a1.user
u2.addresses.remove(a2)
# copy, so that generation of the
# comparisons don't get caught
calls = list(canary.mock_calls)
if include_backrefs:
if include_removes:
eq_(
calls,
[
# append #1
call('addresses', Address(), False),
# backref for append
call('user', User(addresses=[]), False),
# append #2
call('addresses', Address(user=None), False),
# backref for append
call('user', User(addresses=[]), False),
# assign a2.user = u2
call('user', User(addresses=[]), False),
# backref for u1.addresses.remove(a2)
call('addresses', Address(user=None), True),
# backref for u2.addresses.append(a2)
call('addresses', Address(user=None), False),
# del a1.user
call('user', User(addresses=[]), True),
# backref for u1.addresses.remove(a1)
call('addresses', Address(), True),
# u2.addresses.remove(a2)
call('addresses', Address(user=None), True),
# backref for a2.user = None
call('user', None, False)
])
else:
eq_(calls, [
call('addresses', Address()),
call('user', User(addresses=[])),
call('addresses', Address(user=None)),
call('user', User(addresses=[])),
call('user', User(addresses=[])),
call('addresses', Address(user=None)),
call('user', None)
])
else:
if include_removes:
eq_(calls, [
call('addresses', Address(), False),
call('addresses', Address(user=None), False),
call('user', User(addresses=[]), False),
call('user', User(addresses=[]), True),
call('addresses', Address(user=None), True)
])
else:
eq_(calls, [
call('addresses', Address()),
call('addresses', Address(user=None)),
call('user', User(addresses=[]))
])
def test_pyodbc_version_productversion(self):
dialect = pyodbc.MSDialect_pyodbc()
conn = Mock(scalar=Mock(return_value="11.0.9216.62"))
eq_(dialect._get_server_version_info(conn), (11, 0, 9216, 62))
def test_legacy_schema_flag(self, cfg, expected):
with testing.expect_deprecated("The legacy_schema_aliasing parameter"):
e = engine_from_config(
cfg, module=Mock(version="MS SQL Server 11.0.92"))
is_(e.dialect.legacy_schema_aliasing, expected)
def cursor():
return Mock()
def shutdown(value):
if value:
db.connect = Mock(side_effect=Exception("connect failed"))
else:
db.connect = Mock(side_effect=connect)
db.is_shutdown = value
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 _fixture(self, **kw):
dbapi = Mock()
return dbapi, pool.QueuePool(creator=lambda: dbapi.connect('foo.db'),
**kw)
def test_bind_base_table_concrete_sub_class(self):
base_class_bind = Mock()
session = self._fixture({self.tables.base_table: base_class_bind})
is_(session.get_bind(self.classes.ConcreteSubClass), testing.db)
def cursor():
while True:
yield Mock()
def test_bind_base_class_joined_sub_class(self):
base_class_bind = Mock()
session = self._fixture({self.classes.BaseClass: base_class_bind})
is_(session.get_bind(self.classes.JoinedSubClass), base_class_bind)
def connect():
while True:
yield Mock(cursor=Mock(side_effect=cursor()))
class Dialect(DefaultDialect):
initialize = Mock()
def _invalidate_event_fixture(self):
p = self._queuepool_fixture()
canary = Mock()
event.listen(p, 'invalidate', canary)
return p, canary
def close():
cursor.fetchall = cursor.fetchone = Mock(
side_effect=MockError("cursor closed"))
def connect():
while True:
yield Mock(
spec=['cursor', 'commit', 'rollback', 'close'],
cursor=Mock(side_effect=cursor()),
)
def __init__(self):
self.mock = Mock()
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
def commit():
if conn.explode == "commit":
raise MockDisconnect("Lost the DB connection on commit")
elif conn.explode == "commit_no_disconnect":
raise MockError("something broke on commit but we didn't lose the "
"connection")
else:
return
conn = Mock(
rollback=Mock(side_effect=rollback),
commit=Mock(side_effect=commit),
cursor=Mock(side_effect=cursor()),
)
return conn
