def test_mget_from_cache(mocker):
mocker.patch.object(CacheMixin, "_db_session", DBSession)
t1 = Team(id=0, team_name="hello")
t2 = Team(id=1, team_name="world")
with mocker.patch.object(_RedisWrapper, "mget",
return_value=[t1.__rawdata__, t2.__rawdata__]):
m = Team.mget([0, 1])
assert all([t._cached for t in m])
def test_mget_from_db(mocker):
t1 = Team(id=0, team_name="hello")
t2 = Team(id=1, team_name="world")
mocker.patch.object(_RedisWrapper, "mget", mocker.Mock(return_value=None))
mocker.patch.object(Team, "_db_session", MockSession([t1, t2]))
r = Team.mget([0, 1, 2])
assert len(r) == 2
assert r[0] is t1 and r[1] is t2
def test_new_cache_mget(mocker):
t1 = Team(id=0, team_name="hello")
t2 = Team(id=1, team_name="world")
mocker.patch.object(_RedisWrapper, "mget", mocker.Mock(return_value=None))
mocker.patch.object(Team, "_db_session", MockSession([t1, t2]))
mset_raw = mocker.MagicMock()
mocker.patch.object(Team, "_mset_raw", mset_raw)
Team.mget([0, 1])
mset_raw.assert_called_with([t1, t2], nx=True)
def test_mset(mocker):
t1 = Team(id=0, team_name="hello")
t2 = Team(id=1, team_name="world")
mset = mocker.MagicMock()
mocker.patch.object(_RedisWrapper, "mset", mset)
Team.mset([t1, t2])
expected = mocker.call(
{"team|0": t1.__rawdata__, "team|1": t2.__rawdata__},
expiration_time=Team.TABLE_CACHE_EXPIRATION_TIME)
mset.assert_has_calls([expected])
def test_mget_cache_hit(mocker):
mocker.patch.object(CacheMixin, "_db_session", DBSession)
t1 = Team(id=0, team_name="hello")
t2 = Team(id=1, team_name="world")
raw = [t.__rawdata__ for t in (t1, t2)]
mocker.patch.object(_RedisWrapper, "mget", mocker.Mock(return_value=raw))
# get
incr = mocker.MagicMock()
mocker.patch.object(Team, "_statsd_incr", incr)
Team.mget([0, 1])
incr.assert_called_with("hit", 2)
def test_mget_from_session(mocker):
session = DBSession
mocker.patch.object(CacheMixin, "_db_session", DBSession)
t1 = Team(id=0, team_name="hello")
t2 = Team(id=1, team_name="world")
for t in (t1, t2):
session.add(t)
session.commit()
r = Team.mget([0, 1])
assert r[0] is t1 and r[1] is t2
session.close()
def test_get_from_cache(mocker):
mocker.patch.object(CacheMixin, "_db_session", DBSession)
t = Team(id=0, team_name="test_get_from_cache")
with mocker.patch.object(_RedisWrapper, "get", return_value=t.__rawdata__):
m = Team.get(0)
assert m._cached
def test_mixin_set(mocker):
t = Team(id=0, team_name="hello")
set_raw_mock = mocker.MagicMock()
mocker.patch.object(Team, "set_raw", set_raw_mock)
Team.set(t, expiration_time=900)
assert set_raw_mock.called
def test_get_from_db(mocker):
t = Team(id=0, team_name="hello")
mocker.patch.object(_RedisWrapper, "get", mocker.Mock(return_value=None))
mocker.patch.object(CacheMixin, "_db_session", MockSession(t))
r = Team.get(0)
assert r is t
def test_from_cache(mocker):
t = Team(id=0, team_name='test')
_key = 0
with mocker.patch.object(_RedisWrapper, "mget",
return_value=t.__rawdata__):
m = Team._from_cache([_key])
assert _key in m
def test_rawdata_sub(hook, mocker):
m = Team(id=0, team_name="hello")
set_raw = mocker.MagicMock()
mocker.patch.object(CacheMixinBase, "set_raw", set_raw)
hook._rawdata_sub(m.__rawdata__, Team)
set_raw.assert_called_with(
{'id': 0, 'status': None, 'team_desc': None, "team_name": "hello"})
def test_rollback():
session = Team._db_session
try:
session.add(Team(id=0, team_name="hello"))
session.flush()
raise TypeError()
except:
session.rollback()
assert not getattr(session, "pending_write", None)
def test_get_cache_miss(mocker):
t = Team(id=0, team_name="hello")
mocker.patch.object(_RedisWrapper, "get", mocker.Mock(return_value=None))
mocker.patch.object(Team, "_db_session", MockSession(t))
incr = mocker.MagicMock()
mocker.patch.object(Team, "_statsd_incr", incr)
Team.get(0)
incr.assert_called_with("miss")
def test_mget_get_primary_key(mocker):
t = Team(id=0, team_name="hello")
mocker.patch.object(_RedisWrapper, "mget", mocker.Mock(return_value=None))
mocker.patch.object(Team, "_db_session", MockSession([t]))
pk = mocker.MagicMock()
mocker.patch.object(Team, "pk", pk)
a = Team.mget([0], as_dict=True)
assert a == {pk: t}
def test_new_cache_get(mocker):
t = Team(id=0, team_name="hello")
mocker.patch.object(_RedisWrapper, "get", mocker.Mock(return_value=None))
mocker.patch.object(CacheMixin, "_db_session", MockSession(t))
mock_set_raw = mocker.MagicMock()
mocker.patch.object(Team, "set_raw", mock_set_raw)
v = Team.get(0)
mock_set_raw.assert_called_with(v.__rawdata__, nx=True)
assert v is t
def test_get_from_session(mocker):
session = DBSession
mocker.patch.object(CacheMixin, "_db_session", DBSession)
team = Team(id=0, team_name="test_get_from_session")
session.add(team)
session.commit()
t = Team.get(0)
assert t is team
session.close()
def test_set_raw(mocker):
t = Team(id=0, team_name="hello")
mock_set = mocker.MagicMock()
mocker.patch.object(_RedisWrapper, "set", mock_set)
Team.set_raw(t.__rawdata__, expiration_time=900)
mock_set.assert_called_with(
"team|0", {'id': 0, 'status': None,
'team_desc': None, 'team_name': 'hello'},
expiration_time=900)
def test_cache_mixin(mocker):
assert 'team|0' in repr(Team(id=0, team_name="hello"))
assert Team(id=0, team_name='hello').pk_name() == 'id'
assert Team(id=0, team_name='hello').pk_attribute().key == 'id'
t = Team(team_name='test_cache_mixin')
DBSession.add(t)
DBSession.commit()
assert len(Team.mget([t.id], force=True)) == 1
with pytest.raises(NotImplementedError):
CacheMixinBase._cache_client.error
with pytest.raises(NotImplementedError):
CacheMixinBase._db_session.error
with mocker.patch.object(CacheMixinBase, 'RAWDATA_VERSION',
mocker.MagicMock(__str__=lambda x: '233')):
assert Team.gen_raw_key(1) == 'team|1|233'
with mocker.patch.object(Team.__mapper__, 'primary_key',
mocker.MagicMock(return_value=[],
__nonzero__=mocker.MagicMock(
return_value=False))):
assert Team(id=2, team_name='hello').pk_name() is None
assert Team(id=3, team_name='hello').pk_attribute() is None
def test_get_cache_hit(mocker):
mocker.patch.object(CacheMixin, "_db_session", DBSession)
t = Team(id=0, team_name="hello")
raw = t.__rawdata__
mocker.patch.object(_RedisWrapper, "get", mocker.Mock(return_value=raw))
# get
incr = mocker.MagicMock()
mocker.patch.object(Team, "_statsd_incr", incr)
Team.get(0)
incr.assert_called_with("hit")
def test_update_cache_fail_hook(hook, mocker):
callback_confirm = []
def callback(data_obj, model, pk, val):
callback_confirm.append((data_obj, model, pk, val))
# register callback
Team.register_set_fail_callback(callback)
m = Team(id=0, team_name="OK")
mocker.patch.object(CacheMixinBase, '_cache_client', mocker.MagicMock())
# perform an exception
mocker.patch.object(CacheMixinBase, 'set_raw',
mocker.MagicMock(side_effect=Exception))
with pytest.raises(Exception):
hook._rawdata_sub(m.__rawdata__, Team)
assert callback_confirm == [
({'id': 0, 'status': None, 'team_desc': None, 'team_name': 'OK'},
Team, 'id', 0)]
def test_team(db):
team = Team(team_name='Foo', team_desc='foo-bar')
db.add(team)
db.commit()
return team
def test_make_transient_to_detached_error():
t = Team(id=0, team_name='233')
with pytest.raises(sa_exc.InvalidRequestError):
DBSession.add(t)
make_transient_to_detached(t)
