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 _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)
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 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,
{u'hello': u'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,
{u'hello': u'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)
