def test_save_behavior(self):
mydict = ModelDict(ModelDictModel, key='key', value='value', auto_create=True)
mydict['hello'] = 'foo'
for n in xrange(10):
mydict[str(n)] = 'foo'
self.assertEquals(len(mydict), 11)
self.assertEquals(ModelDictModel.objects.count(), 11)
mydict = ModelDict(ModelDictModel, key='key', value='value', auto_create=True)
m = ModelDictModel.objects.get(key='hello')
m.value = 'bar'
m.save()
self.assertEquals(ModelDictModel.objects.count(), 11)
self.assertEquals(len(mydict), 11)
self.assertEquals(mydict['hello'], 'bar')
mydict = ModelDict(ModelDictModel, key='key', value='value', auto_create=True)
m = ModelDictModel.objects.get(key='hello')
m.value = 'bar2'
m.save()
self.assertEquals(ModelDictModel.objects.count(), 11)
self.assertEquals(len(mydict), 11)
self.assertEquals(mydict['hello'], 'bar2')
def test_save_behavior(self):
mydict = ModelDict(ModelDictModel, key='key', value='value', auto_create=True)
mydict['hello'] = 'foo'
for n in range(10):
mydict[str(n)] = 'foo'
assert len(mydict) == 11
assert ModelDictModel.objects.count() == 11
mydict = ModelDict(ModelDictModel, key='key', value='value', auto_create=True)
m = ModelDictModel.objects.get(key='hello')
m.value = 'bar'
m.save()
assert ModelDictModel.objects.count() == 11
assert len(mydict) == 11
assert mydict['hello'] == 'bar'
mydict = ModelDict(ModelDictModel, key='key', value='value', auto_create=True)
m = ModelDictModel.objects.get(key='hello')
m.value = 'bar2'
m.save()
assert ModelDictModel.objects.count() == 11
assert len(mydict) == 11
assert mydict['hello'] == 'bar2'
def setUp(self):
self.cache = mock.Mock()
self.cache.get.return_value = {}
self.mydict = ModelDict(ModelDictModel,
key='key',
value='value',
auto_create=True,
cache=self.cache)
def test_api(self):
base_count = ModelDictModel.objects.count()
mydict = ModelDict(ModelDictModel, key='key', value='value')
mydict['foo'] = 'bar'
self.assertEquals(mydict['foo'], 'bar')
self.assertEquals(
ModelDictModel.objects.values_list('value',
flat=True).get(key='foo'),
'bar')
self.assertEquals(ModelDictModel.objects.count(), base_count + 1)
mydict['foo'] = 'bar2'
self.assertEquals(mydict['foo'], 'bar2')
self.assertEquals(
ModelDictModel.objects.values_list('value',
flat=True).get(key='foo'),
'bar2')
self.assertEquals(ModelDictModel.objects.count(), base_count + 1)
mydict['foo2'] = 'bar'
self.assertEquals(mydict['foo2'], 'bar')
self.assertEquals(
ModelDictModel.objects.values_list('value',
flat=True).get(key='foo2'),
'bar')
self.assertEquals(ModelDictModel.objects.count(), base_count + 2)
del mydict['foo2']
self.assertRaises(KeyError, mydict.__getitem__, 'foo2')
self.assertFalse(ModelDictModel.objects.filter(key='foo2').exists())
self.assertEquals(ModelDictModel.objects.count(), base_count + 1)
ModelDictModel.objects.create(key='foo3', value='hello')
self.assertEquals(mydict['foo3'], 'hello')
self.assertTrue(
ModelDictModel.objects.filter(key='foo3').exists(), True)
self.assertEquals(ModelDictModel.objects.count(), base_count + 2)
request_finished.send(sender=self)
self.assertEquals(mydict._last_checked_for_remote_changes, None)
# These should still error because even though the cache repopulates (local cache)
# the remote cache pool does not
# self.assertRaises(KeyError, mydict.__getitem__, 'foo3')
# self.assertTrue(ModelDictModel.objects.filter(key='foo3').exists())
# self.assertEquals(ModelDictModel.objects.count(), base_count + 2)
self.assertEquals(mydict['foo'], 'bar2')
self.assertEquals(
ModelDictModel.objects.values_list('value',
flat=True).get(key='foo'),
'bar2')
self.assertEquals(ModelDictModel.objects.count(), base_count + 2)
self.assertEquals(mydict.pop('foo'), 'bar2')
self.assertEquals(mydict.pop('foo', None), None)
self.assertFalse(ModelDictModel.objects.filter(key='foo').exists())
self.assertEquals(ModelDictModel.objects.count(), base_count + 1)
def test_modeldict_localcache_has_expired_true_with_no_jitter(
self, mock_time):
timeout = 30
mock_time.time.return_value = self.now + timeout + 1
mydict = ModelDict(ModelDictModel,
key='key',
value='value',
timeout=timeout)
mydict._last_checked_for_remote_changes = self.now
assert mydict.local_cache_has_expired() == True
def test_modeldict_localcache_has_expired_false_with_jitter(
self, mock_random, mock_time):
timeout = 30
max_local_timeout_jitter = 10
mock_time.time.return_value = self.now + timeout + max_local_timeout_jitter
mock_random.random.return_value = 1.0
mydict = ModelDict(ModelDictModel,
key='key',
value='value',
timeout=timeout,
max_local_timeout_jitter=max_local_timeout_jitter)
mydict._last_checked_for_remote_changes = self.now
assert mydict.local_cache_has_expired() == False
def test_setdefault(self):
mydict = ModelDict(ModelDictModel, key='key', value='value')
with pytest.raises(KeyError):
mydict['hello']
ret = mydict.setdefault('hello', 'world')
assert ret == 'world'
assert mydict['hello'] == 'world'
ret = mydict.setdefault('hello', 'world2')
assert ret == 'world'
assert mydict['hello'] == 'world'
def test_save_behavior(self):
mydict = ModelDict(ModelDictModel, key='key', value='value', auto_create=True)
mydict['hello'] = 'foo'
for n in xrange(10):
mydict[str(n)] = 'foo'
self.assertEquals(len(mydict), 11)
self.assertEquals(ModelDictModel.objects.count(), 11)
mydict = ModelDict(ModelDictModel, key='key', value='value', auto_create=True)
m = ModelDictModel.objects.get(key='hello')
m.value = 'bar'
m.save()
self.assertEquals(ModelDictModel.objects.count(), 11)
self.assertEquals(len(mydict), 11)
self.assertEquals(mydict['hello'], 'bar')
mydict = ModelDict(ModelDictModel, key='key', value='value', auto_create=True)
m = ModelDictModel.objects.get(key='hello')
m.value = 'bar2'
m.save()
self.assertEquals(ModelDictModel.objects.count(), 11)
self.assertEquals(len(mydict), 11)
self.assertEquals(mydict['hello'], 'bar2')
# def test_modeldict_counts(self):
# # TODO:
# mydict = ModelDict(ModelDictModel, key='key', value='value')
# mydict['test_1'] = 'foo'
# mydict['test_2'] = 'bar'
# del mydict
# request_finished.send(sender=self)
#
# mydict = ModelDict(ModelDictModel, key='key', value='value')
# # First and only cache.get() here.
# self.assertEqual(mydict['test_1'], 'foo')
# self.assertEqual(mydict['test_2'], 'bar')
# self.assertEqual(mydict['test_1'], 'foo')
#
# request_finished.send(sender=self)
# # Should not be another cache.get().
# self.assertEqual(mydict['test_1'], 'foo')
# self.assertEqual(mydict['test_2'], 'bar')
# self.assertEqual(mydict['test_1'], 'foo')
#
# self.assertEqual(cache._gets[c.get_key('ModelDict:ModelDictModel:key')], 1)
# self.assertEqual(cache._gets[c.get_key('ModelDict.last_updated:ModelDictModel:key')], 2)
def test_setdefault_instances(self):
mydict = ModelDict(ModelDictModel, key='key', value='value')
with pytest.raises(KeyError):
mydict['hello']
instance = ModelDictModel(key='hello', value='world')
ret = mydict.setdefault('hello', instance)
assert ret == 'world'
assert mydict['hello'] == 'world'
instance2 = ModelDictModel(key='hello', value='world2')
ret = mydict.setdefault('hello', instance2)
assert ret == 'world'
assert mydict['hello'] == 'world'
def test_modeldict_instances(self):
base_count = ModelDictModel.objects.count()
mydict = ModelDict(ModelDictModel,
key='key',
value='value',
instances=True)
mydict['foo'] = ModelDictModel(key='foo', value='bar')
assert isinstance(mydict['foo'], ModelDictModel)
assert mydict['foo'].pk
assert mydict['foo'].value == 'bar'
assert ModelDictModel.objects.values_list(
'value', flat=True).get(key='foo') == 'bar'
assert ModelDictModel.objects.count() == base_count + 1
old_pk = mydict['foo'].pk
mydict['foo'] = ModelDictModel(key='foo', value='bar2')
assert isinstance(mydict['foo'], ModelDictModel)
assert mydict['foo'].pk == old_pk
assert mydict['foo'].value == 'bar2'
assert ModelDictModel.objects.values_list(
'value', flat=True).get(key='foo') == 'bar2'
assert ModelDictModel.objects.count() == base_count + 1
# test deletion
mydict['foo'].delete()
assert 'foo' not in mydict
def test_modeldict_instances(self):
base_count = ModelDictModel.objects.count()
mydict = ModelDict(ModelDictModel,
key='key',
value='value',
instances=True)
mydict['foo'] = ModelDictModel(key='foo', value='bar')
self.assertTrue(isinstance(mydict['foo'], ModelDictModel))
self.assertTrue(mydict['foo'].pk)
self.assertEquals(mydict['foo'].value, 'bar')
self.assertEquals(
ModelDictModel.objects.values_list('value',
flat=True).get(key='foo'),
'bar')
self.assertEquals(ModelDictModel.objects.count(), base_count + 1)
old_pk = mydict['foo'].pk
mydict['foo'] = ModelDictModel(key='foo', value='bar2')
self.assertTrue(isinstance(mydict['foo'], ModelDictModel))
self.assertEquals(mydict['foo'].pk, old_pk)
self.assertEquals(mydict['foo'].value, 'bar2')
self.assertEquals(
ModelDictModel.objects.values_list('value',
flat=True).get(key='foo'),
'bar2')
self.assertEquals(ModelDictModel.objects.count(), base_count + 1)
# test deletion
mydict['foo'].delete()
self.assertTrue('foo' not in mydict)
def test_remote_cache_key_suffixed_by_py_version(self):
mydict = ModelDict(ModelDictModel,
key='key',
value='value',
instances=True)
expected_version_suffix = 'py%s' % sys.version_info[0]
assert mydict.remote_cache_key.endswith(expected_version_suffix)
def test_django_signals_are_connected(self):
from django.db.models.signals import post_save, post_delete
from django.core.signals import request_finished
mydict = ModelDict(ModelDictModel, key='key', value='value', auto_create=True)
self.assertHasReceiver(post_save, mydict._post_save)
self.assertHasReceiver(post_delete, mydict._post_delete)
self.assertHasReceiver(request_finished, mydict._cleanup)
def test_api(self):
base_count = ModelDictModel.objects.count()
mydict = ModelDict(ModelDictModel, key='key', value='value')
mydict['foo'] = 'bar'
assert mydict['foo'] == 'bar'
assert ModelDictModel.objects.values_list('value', flat=True).get(key='foo') == 'bar'
assert ModelDictModel.objects.count() == base_count + 1
mydict['foo'] = 'bar2'
assert mydict['foo'] == 'bar2'
assert ModelDictModel.objects.values_list('value', flat=True).get(key='foo') == 'bar2'
assert ModelDictModel.objects.count() == base_count + 1
mydict['foo2'] = 'bar'
assert mydict['foo2'] == 'bar'
assert ModelDictModel.objects.values_list('value', flat=True).get(key='foo2') == 'bar'
assert ModelDictModel.objects.count() == base_count + 2
del mydict['foo2']
with pytest.raises(KeyError):
mydict.__getitem__('foo2')
assert not ModelDictModel.objects.filter(key='foo2').exists()
assert ModelDictModel.objects.count() == base_count + 1
ModelDictModel.objects.create(key='foo3', value='hello')
assert mydict['foo3'] == 'hello'
assert ModelDictModel.objects.filter(key='foo3').exists(), True
assert ModelDictModel.objects.count() == base_count + 2
request_finished.send(sender=self)
assert mydict._last_checked_for_remote_changes == 0.0
# These should still error because even though the cache repopulates (local cache)
# the remote cache pool does not
# self.assertRaises(KeyError, mydict.__getitem__, 'foo3')
# self.assertTrue(ModelDictModel.objects.filter(key='foo3').exists())
# self.assertEquals(ModelDictModel.objects.count(), base_count + 2)
assert mydict['foo'] == 'bar2'
assert ModelDictModel.objects.values_list('value', flat=True).get(key='foo') == 'bar2'
assert ModelDictModel.objects.count() == base_count + 2
assert mydict.pop('foo') == 'bar2'
assert mydict.pop('foo', None) is None
assert not ModelDictModel.objects.filter(key='foo').exists()
assert ModelDictModel.objects.count() == base_count + 1
def test_celery_signals_are_connected(self):
from celery.signals import task_postrun
mydict = ModelDict(ModelDictModel,
key='key',
value='value',
auto_create=True)
self.assertHasReceiver(task_postrun, mydict._cleanup)
def test_api(self):
base_count = ModelDictModel.objects.count()
mydict = ModelDict(ModelDictModel, key='key', value='value')
mydict['foo'] = 'bar'
self.assertEquals(mydict['foo'], 'bar')
self.assertEquals(ModelDictModel.objects.values_list('value', flat=True).get(key='foo'), 'bar')
self.assertEquals(ModelDictModel.objects.count(), base_count + 1)
mydict['foo'] = 'bar2'
self.assertEquals(mydict['foo'], 'bar2')
self.assertEquals(ModelDictModel.objects.values_list('value', flat=True).get(key='foo'), 'bar2')
self.assertEquals(ModelDictModel.objects.count(), base_count + 1)
mydict['foo2'] = 'bar'
self.assertEquals(mydict['foo2'], 'bar')
self.assertEquals(ModelDictModel.objects.values_list('value', flat=True).get(key='foo2'), 'bar')
self.assertEquals(ModelDictModel.objects.count(), base_count + 2)
del mydict['foo2']
self.assertRaises(KeyError, mydict.__getitem__, 'foo2')
self.assertFalse(ModelDictModel.objects.filter(key='foo2').exists())
self.assertEquals(ModelDictModel.objects.count(), base_count + 1)
ModelDictModel.objects.create(key='foo3', value='hello')
self.assertEquals(mydict['foo3'], 'hello')
self.assertTrue(ModelDictModel.objects.filter(key='foo3').exists(), True)
self.assertEquals(ModelDictModel.objects.count(), base_count + 2)
request_finished.send(sender=self)
self.assertEquals(mydict._last_checked_for_remote_changes, None)
# These should still error because even though the cache repopulates (local cache)
# the remote cache pool does not
# self.assertRaises(KeyError, mydict.__getitem__, 'foo3')
# self.assertTrue(ModelDictModel.objects.filter(key='foo3').exists())
# self.assertEquals(ModelDictModel.objects.count(), base_count + 2)
self.assertEquals(mydict['foo'], 'bar2')
self.assertEquals(ModelDictModel.objects.values_list('value', flat=True).get(key='foo'), 'bar2')
self.assertEquals(ModelDictModel.objects.count(), base_count + 2)
self.assertEquals(mydict.pop('foo'), 'bar2')
self.assertEquals(mydict.pop('foo', None), None)
self.assertFalse(ModelDictModel.objects.filter(key='foo').exists())
self.assertEquals(ModelDictModel.objects.count(), base_count + 1)
def test_modeldict_auto_create_no_value(self):
# with auto_create and no value
mydict = ModelDict(ModelDictModel,
key='key',
value='value',
auto_create=True)
repr(mydict['hello'])
assert ModelDictModel.objects.count() == 1
assert ModelDictModel.objects.get(key='hello').value == ''
def test_modeldict_auto_create(self):
# with auto_create and value
mydict = ModelDict(ModelDictModel,
key='key',
value='value',
auto_create=True)
mydict['hello'] = 'foo'
assert ModelDictModel.objects.count() == 1
assert ModelDictModel.objects.get(key='hello').value == 'foo'
def test_modeldict_instances_auto_create(self):
mydict = ModelDict(ModelDictModel,
key='key',
value='value',
instances=True,
auto_create=True)
obj = mydict['foo']
assert isinstance(obj, ModelDictModel)
assert obj.value == ''
def test_api(self):
base_count = ModelDictModel.objects.count()
mydict = ModelDict(ModelDictModel, key='key', value='value')
mydict['foo'] = 'bar'
assert mydict['foo'] == 'bar'
assert ModelDictModel.objects.values_list(
'value', flat=True).get(key='foo') == 'bar'
assert ModelDictModel.objects.count() == base_count + 1
mydict['foo'] = 'bar2'
assert mydict['foo'] == 'bar2'
assert ModelDictModel.objects.values_list(
'value', flat=True).get(key='foo') == 'bar2'
assert ModelDictModel.objects.count() == base_count + 1
mydict['foo2'] = 'bar'
assert mydict['foo2'] == 'bar'
assert ModelDictModel.objects.values_list(
'value', flat=True).get(key='foo2') == 'bar'
assert ModelDictModel.objects.count() == base_count + 2
del mydict['foo2']
with pytest.raises(KeyError):
mydict.__getitem__('foo2')
assert not ModelDictModel.objects.filter(key='foo2').exists()
assert ModelDictModel.objects.count() == base_count + 1
ModelDictModel.objects.create(key='foo3', value='hello')
assert mydict['foo3'] == 'hello'
assert ModelDictModel.objects.filter(key='foo3').exists(), True
assert ModelDictModel.objects.count() == base_count + 2
request_finished.send(sender=self)
assert mydict._last_checked_for_remote_changes == 0.0
# These should still error because even though the cache repopulates (local cache)
# the remote cache pool does not
# self.assertRaises(KeyError, mydict.__getitem__, 'foo3')
# self.assertTrue(ModelDictModel.objects.filter(key='foo3').exists())
# self.assertEquals(ModelDictModel.objects.count(), base_count + 2)
assert mydict['foo'] == 'bar2'
assert ModelDictModel.objects.values_list(
'value', flat=True).get(key='foo') == 'bar2'
assert ModelDictModel.objects.count() == base_count + 2
assert mydict.pop('foo') == 'bar2'
assert mydict.pop('foo', None) is None
assert not ModelDictModel.objects.filter(key='foo').exists()
assert ModelDictModel.objects.count() == base_count + 1
def test_switch_creation_with_custom_remote_timeout(self):
cache = mock.Mock()
mydict = ModelDict(ModelDictModel,
key='key',
value='value',
auto_create=True,
cache=cache,
remote_timeout=None)
mydict['hello'] = 'foo'
assert cache.get.call_count == 0
assert cache.set_many.call_count == 1
cache.set_many.assert_any_call(
{
mydict.remote_cache_key: {
u'hello': u'foo'
},
mydict.remote_cache_last_updated_key:
mydict._last_checked_for_remote_changes,
},
timeout=None)
def test_modeldict_expirey(self):
base_count = ModelDictModel.objects.count()
mydict = ModelDict(ModelDictModel, key='key', value='value')
self.assertEquals(mydict._cache, None)
mydict['test_modeldict_expirey'] = 'hello'
self.assertEquals(len(mydict._cache), base_count + 1)
self.assertEquals(mydict['test_modeldict_expirey'], 'hello')
self.client.get('/')
self.assertEquals(mydict._cache, None)
self.assertEquals(mydict['test_modeldict_expirey'], 'hello')
self.assertEquals(len(mydict._cache), base_count + 1)
request_finished.send(sender=self)
self.assertEquals(mydict._cache, None)
self.assertEquals(mydict['test_modeldict_expirey'], 'hello')
self.assertEquals(len(mydict._cache), base_count + 1)
def test_modeldict_expirey(self):
base_count = ModelDictModel.objects.count()
mydict = ModelDict(ModelDictModel, key='key', value='value')
assert mydict._local_cache == {}
mydict['test_modeldict_expirey'] = 'hello'
assert len(mydict._local_cache) == base_count + 1
assert mydict['test_modeldict_expirey'] == 'hello'
self.client.get('/')
assert mydict._last_checked_for_remote_changes == 0.0
assert mydict['test_modeldict_expirey'] == 'hello'
assert len(mydict._local_cache) == base_count + 1
request_finished.send(sender=self)
assert mydict._last_checked_for_remote_changes == 0.0
assert mydict['test_modeldict_expirey'] == 'hello'
assert len(mydict._local_cache) == base_count + 1
def test_modeldict_items(self):
mydict = ModelDict(ModelDictModel, key='key', value='value')
mydict['hello'] = 'world'
assert list(mydict.items()) == [('hello', 'world')]
def setUp(self):
self.cache = mock.Mock()
self.cache.get.return_value = {}
self.mydict = ModelDict(ModelDictModel, key='key', value='value', auto_create=True, cache=self.cache)
class CacheIntegrationTest(TestCase):
def setUp(self):
self.cache = mock.Mock()
self.cache.get.return_value = {}
self.mydict = ModelDict(ModelDictModel, key='key', value='value', auto_create=True, cache=self.cache)
def test_switch_creation(self):
self.mydict['hello'] = 'foo'
self.assertEquals(self.cache.get.call_count, 0)
self.assertEquals(self.cache.set.call_count, 2)
self.cache.set.assert_any_call(self.mydict.remote_cache_key, {'hello': 'foo'})
self.cache.set.assert_any_call(self.mydict.remote_cache_last_updated_key, self.mydict._last_checked_for_remote_changes)
def test_switch_change(self):
self.mydict['hello'] = 'foo'
self.cache.reset_mock()
self.mydict['hello'] = 'bar'
self.assertEquals(self.cache.get.call_count, 0)
self.assertEquals(self.cache.set.call_count, 2)
self.cache.set.assert_any_call(self.mydict.remote_cache_key, {'hello': 'bar'})
self.cache.set.assert_any_call(self.mydict.remote_cache_last_updated_key, self.mydict._last_checked_for_remote_changes)
def test_switch_delete(self):
self.mydict['hello'] = 'foo'
self.cache.reset_mock()
del self.mydict['hello']
self.assertEquals(self.cache.get.call_count, 0)
self.assertEquals(self.cache.set.call_count, 2)
self.cache.set.assert_any_call(self.mydict.remote_cache_key, {})
self.cache.set.assert_any_call(self.mydict.remote_cache_last_updated_key, self.mydict._last_checked_for_remote_changes)
def test_switch_access(self):
self.mydict['hello'] = 'foo'
self.cache.reset_mock()
foo = self.mydict['hello']
foo = self.mydict['hello']
foo = self.mydict['hello']
foo = self.mydict['hello']
self.assertEquals(foo, 'foo')
self.assertEquals(self.cache.get.call_count, 0)
self.assertEquals(self.cache.set.call_count, 0)
def test_switch_access_without_local_cache(self):
self.mydict['hello'] = 'foo'
self.mydict._local_cache = None
self.mydict._last_checked_for_remote_changes = None
self.cache.reset_mock()
foo = self.mydict['hello']
self.assertEquals(foo, 'foo')
# "1" here signifies that we didn't ask the remote cache for its last
# updated value
self.assertEquals(self.cache.get.call_count, 1)
self.assertEquals(self.cache.set.call_count, 0)
self.cache.get.assert_any_call(self.mydict.remote_cache_key)
self.cache.reset_mock()
foo = self.mydict['hello']
foo = self.mydict['hello']
foo = self.mydict['hello']
self.assertEquals(self.cache.get.call_count, 0)
self.assertEquals(self.cache.set.call_count, 0)
def test_switch_access_with_expired_local_cache(self):
self.mydict['hello'] = 'foo'
self.mydict._last_checked_for_remote_changes = None
self.cache.reset_mock()
foo = self.mydict['hello']
self.assertEquals(foo, 'foo')
self.assertEquals(self.cache.get.call_count, 2)
self.assertEquals(self.cache.set.call_count, 0)
self.cache.get.assert_any_call(self.mydict.remote_cache_last_updated_key)
self.cache.reset_mock()
foo = self.mydict['hello']
foo = self.mydict['hello']
self.assertEquals(self.cache.get.call_count, 0)
self.assertEquals(self.cache.set.call_count, 0)
def test_does_not_pull_down_all_data(self):
self.mydict['hello'] = 'foo'
self.cache.get.return_value = self.mydict._local_last_updated - 100
self.cache.reset_mock()
self.mydict._cleanup()
self.assertEquals(self.mydict['hello'], 'foo')
self.cache.get.assert_called_once_with(
self.mydict.remote_cache_last_updated_key
)
class CacheIntegrationTest(TestCase):
def setUp(self):
self.cache = mock.Mock()
self.cache.get.return_value = {}
self.mydict = ModelDict(ModelDictModel, key='key', value='value', auto_create=True, cache=self.cache)
def test_switch_creation(self):
self.mydict['hello'] = 'foo'
assert self.cache.get.call_count == 0
assert self.cache.set_many.call_count == 1
self.cache.set_many.assert_any_call({
self.mydict.remote_cache_key: {u'hello': u'foo'},
self.mydict.remote_cache_last_updated_key: self.mydict._last_checked_for_remote_changes,
})
def test_switch_change(self):
self.mydict['hello'] = 'foo'
self.cache.reset_mock()
self.mydict['hello'] = 'bar'
assert self.cache.get.call_count == 0
assert self.cache.set_many.call_count == 1
self.cache.set_many.assert_any_call({
self.mydict.remote_cache_key: {u'hello': u'bar'},
self.mydict.remote_cache_last_updated_key: self.mydict._last_checked_for_remote_changes
})
def test_switch_delete(self):
self.mydict['hello'] = 'foo'
self.cache.reset_mock()
del self.mydict['hello']
assert self.cache.get.call_count == 0
assert self.cache.set_many.call_count == 1
self.cache.set_many.assert_any_call({
self.mydict.remote_cache_key: {},
self.mydict.remote_cache_last_updated_key: self.mydict._last_checked_for_remote_changes
})
def test_switch_access(self):
self.mydict['hello'] = 'foo'
self.cache.reset_mock()
foo = self.mydict['hello']
foo = self.mydict['hello']
foo = self.mydict['hello']
foo = self.mydict['hello']
assert foo == 'foo'
assert self.cache.get.call_count == 0
assert self.cache.set_many.call_count == 0
def test_switch_access_without_local_cache(self):
self.mydict['hello'] = 'foo'
self.mydict._local_cache = {}
self.mydict._local_last_updated = None
self.mydict._last_checked_for_remote_changes = 0.0
self.cache.reset_mock()
foo = self.mydict['hello']
assert foo == 'foo'
# "1" here signifies that we didn't ask the remote cache for its last
# updated value
assert self.cache.get.call_count == 1
assert self.cache.set_many.call_count == 0
self.cache.get.assert_any_call(self.mydict.remote_cache_key)
self.cache.reset_mock()
foo = self.mydict['hello']
foo = self.mydict['hello']
foo = self.mydict['hello']
assert self.cache.get.call_count == 0
assert self.cache.set_many.call_count == 0
def test_switch_access_with_expired_local_cache(self):
self.mydict['hello'] = 'foo'
self.mydict._last_checked_for_remote_changes = 0.0
self.cache.reset_mock()
foo = self.mydict['hello']
assert foo == 'foo'
assert self.cache.get.call_count == 2
assert self.cache.set_many.call_count == 0
self.cache.get.assert_any_call(self.mydict.remote_cache_last_updated_key)
self.cache.reset_mock()
foo = self.mydict['hello']
foo = self.mydict['hello']
assert self.cache.get.call_count == 0
assert self.cache.set_many.call_count == 0
def test_does_not_pull_down_all_data(self):
self.mydict['hello'] = 'foo'
self.cache.get.return_value = self.mydict._local_last_updated - 100
self.cache.reset_mock()
self.mydict._cleanup()
assert self.mydict['hello'] == 'foo'
self.cache.get.assert_called_once_with(
self.mydict.remote_cache_last_updated_key
)
class CacheIntegrationTest(TestCase):
def setUp(self):
self.cache = mock.Mock()
self.cache.get.return_value = {}
self.mydict = ModelDict(ModelDictModel,
key='key',
value='value',
auto_create=True,
cache=self.cache)
def _get_other_version_key(self, mydict=None):
if mydict is None:
mydict = self.mydict
expected_other_version_no = '2' if sys.version_info[0] == 3 else '3'
return mydict.remote_cache_key[:-1] + expected_other_version_no
def test_switch_creation(self):
self.mydict['hello'] = 'foo'
assert self.cache.get.call_count == 0
assert self.cache.set_many.call_count == 1
self.cache.set_many.assert_any_call({
self.mydict.remote_cache_key: {
u'hello': u'foo'
},
self.mydict.remote_cache_last_updated_key:
self.mydict._last_checked_for_remote_changes,
})
def test_other_version_cache_deleted_on_switch_creation(self):
expected_other_version_cache_key = self._get_other_version_key()
self.mydict['hello'] = 'foo'
self.cache.delete.assert_called_once_with(
expected_other_version_cache_key)
def test_other_version_cache_deleted_on_switch_change(self):
expected_other_version_cache_key = self._get_other_version_key()
self.mydict['hello'] = 'foo'
self.cache.reset_mock()
self.mydict['hello'] = 'bar'
self.cache.delete.assert_called_once_with(
expected_other_version_cache_key)
@mock.patch('modeldict.base.CachedDict.get_cache_data')
def test_cache_is_refreshed_if_key_is_missing(self, mock_get_cache_data):
self.mydict['hello'] = 'foo'
self.cache.reset_mock()
self.cache.get.return_value = None
self.mydict._last_checked_for_remote_changes = 0.0
self.mydict['hello']
self.cache.set.assert_called_once_with(
self.mydict.remote_cache_key, mock_get_cache_data.return_value)
def test_switch_creation_with_custom_remote_timeout(self):
cache = mock.Mock()
mydict = ModelDict(ModelDictModel,
key='key',
value='value',
auto_create=True,
cache=cache,
remote_timeout=None)
mydict['hello'] = 'foo'
assert cache.get.call_count == 0
assert cache.set_many.call_count == 1
cache.set_many.assert_any_call(
{
mydict.remote_cache_key: {
u'hello': u'foo'
},
mydict.remote_cache_last_updated_key:
mydict._last_checked_for_remote_changes,
},
timeout=None)
def test_switch_change(self):
self.mydict['hello'] = 'foo'
self.cache.reset_mock()
self.mydict['hello'] = 'bar'
assert self.cache.get.call_count == 0
assert self.cache.set_many.call_count == 1
self.cache.set_many.assert_any_call({
self.mydict.remote_cache_key: {
u'hello': u'bar'
},
self.mydict.remote_cache_last_updated_key:
self.mydict._last_checked_for_remote_changes
})
def test_switch_delete(self):
self.mydict['hello'] = 'foo'
self.cache.reset_mock()
del self.mydict['hello']
assert self.cache.get.call_count == 0
assert self.cache.set_many.call_count == 1
self.cache.set_many.assert_any_call({
self.mydict.remote_cache_key: {},
self.mydict.remote_cache_last_updated_key:
self.mydict._last_checked_for_remote_changes
})
def test_switch_access(self):
self.mydict['hello'] = 'foo'
self.cache.reset_mock()
foo = self.mydict['hello']
foo = self.mydict['hello']
foo = self.mydict['hello']
foo = self.mydict['hello']
assert foo == 'foo'
assert self.cache.get.call_count == 0
assert self.cache.set_many.call_count == 0
def test_switch_access_without_local_cache(self):
self.mydict['hello'] = 'foo'
self.mydict._local_cache = {}
self.mydict._local_last_updated = None
self.mydict._last_checked_for_remote_changes = 0.0
self.cache.reset_mock()
foo = self.mydict['hello']
assert foo == 'foo'
# "1" here signifies that we didn't ask the remote cache for its last
# updated value
assert self.cache.get.call_count == 1
assert self.cache.set_many.call_count == 0
self.cache.get.assert_any_call(self.mydict.remote_cache_key)
self.cache.reset_mock()
foo = self.mydict['hello']
foo = self.mydict['hello']
foo = self.mydict['hello']
assert self.cache.get.call_count == 0
assert self.cache.set_many.call_count == 0
def test_switch_access_with_expired_local_cache(self):
self.mydict['hello'] = 'foo'
self.mydict._last_checked_for_remote_changes = 0.0
self.cache.reset_mock()
foo = self.mydict['hello']
assert foo == 'foo'
assert self.cache.get.call_count == 2
assert self.cache.set_many.call_count == 0
self.cache.get.assert_any_call(
self.mydict.remote_cache_last_updated_key)
self.cache.reset_mock()
foo = self.mydict['hello']
foo = self.mydict['hello']
assert self.cache.get.call_count == 0
assert self.cache.set_many.call_count == 0
def test_does_not_pull_down_all_data(self):
self.mydict['hello'] = 'foo'
self.cache.get.return_value = self.mydict._local_last_updated - 100
self.cache.reset_mock()
self.mydict._cleanup()
assert self.mydict['hello'] == 'foo'
self.cache.get.assert_called_once_with(
self.mydict.remote_cache_last_updated_key)
def test_modeldict_no_auto_create(self):
# without auto_create
mydict = ModelDict(ModelDictModel, key='key', value='value')
self.assertRaises(KeyError, lambda x: x['hello'], mydict)
self.assertEquals(ModelDictModel.objects.count(), 0)
def test_modeldict_no_auto_create(self):
# without auto_create
mydict = ModelDict(ModelDictModel, key='key', value='value')
with pytest.raises(KeyError):
mydict['hello']
assert ModelDictModel.objects.count() == 0
def test_modeldict_values(self):
mydict = ModelDict(ModelDictModel, key='key', value='value')
mydict['hello'] = 'world'
assert list(mydict.values()) == ['world']
def test_modeldict_iter(self):
mydict = ModelDict(ModelDictModel, key='key', value='value')
mydict['hello'] = 'world'
assert next(iter(mydict)) == 'hello'
def test_modeldict_len_two(self):
mydict = ModelDict(ModelDictModel, key='key', value='value')
mydict['hello'] = 'world'
mydict['hi'] = 'world'
assert len(mydict) == 2
def test_modeldict_len_empty(self):
mydict = ModelDict(ModelDictModel, key='key', value='value')
assert len(mydict) == 0
