def test_hash_insert(self):
expected = LogVerbosity(verbosity=0)
expected2 = LogVerbosity(verbosity=1)
# insert proto
self._hash_dict['key1'] = expected
version = self._hash_dict.get_version("key1")
actual = self._hash_dict['key1']
self.assertEqual(1, version)
self.assertEqual(expected, actual)
# update proto
self._hash_dict['key1'] = expected2
version2 = self._hash_dict.get_version("key1")
actual2 = self._hash_dict['key1']
self.assertEqual(2, version2)
self.assertEqual(expected2, actual2)
def test_hash_delete(self):
expected = LogVerbosity(verbosity=2)
self._hash_dict['key3'] = expected
actual = self._hash_dict['key3']
self.assertEqual(expected, actual)
self._hash_dict.pop('key3')
self.assertRaises(KeyError, self._hash_dict.__getitem__, 'key3')
def test_flat_clear(self):
expected = LogVerbosity(verbosity=2)
self._flat_dict['key3'] = expected
actual = self._flat_dict['key3']
self.assertEqual(expected, actual)
self._flat_dict.clear()
self.assertEqual(0, len(self._flat_dict.keys()))
def test_flat_delete(self):
expected = LogVerbosity(verbosity=2)
self._flat_dict['key3'] = expected
actual = self._flat_dict['key3']
self.assertEqual(expected, actual)
del self._flat_dict['key3']
self.assertRaises(KeyError, self._flat_dict.__getitem__, 'key3')
self.assertEqual(None, self._flat_dict.get('key3'))
async def test():
get_grpc_mock.return_value = self.channel
self.mock_client.clear()
# Set state that will trigger the RpcError
log_key = 'id1:' + LOG_TYPE
self.mock_client[log_key] = LogVerbosity(verbosity=5)
try:
await self.state_replicator._resync()
except grpc.RpcError:
pass
self.assertEqual(False,
self.state_replicator._has_resync_completed)
self.assertEqual(0, len(self.state_replicator._state_versions))
def test_flat_bad_key(self):
expected = LogVerbosity(verbosity=2)
self.assertRaises(
ValueError,
self._flat_dict.__setitem__,
'bad:key',
expected,
)
self.assertRaises(
ValueError,
self._flat_dict.__getitem__,
'bad:key',
)
self.assertRaises(
ValueError,
self._flat_dict.__delitem__,
'bad:key',
)
async def test():
get_grpc_mock.return_value = self.channel
# Add initial state to be replicated
self.nid_client.clear()
self.idlist_client.clear()
self.log_client.clear()
self.foo_client.clear()
key = 'id1'
key2 = 'id2'
self.nid_client[key] = NetworkID(id='foo')
self.idlist_client[key] = IDList(ids=['bar', 'blah'])
# Increment version
self.idlist_client[key] = IDList(ids=['bar', 'blah'])
# Set state that will be 'unreplicated'
self.log_client[key2] = LogVerbosity(verbosity=5)
req = await self.state_replicator._collect_states_to_replicate()
self.assertEqual(3, len(req.states))
# Ensure in-memory map updates properly for successful replications
await self.state_replicator._send_to_state_service(req)
self.assertEqual(2, len(self.state_replicator._state_versions))
mem_key1 = make_mem_key('id1', NID_TYPE)
mem_key2 = make_mem_key(
'aaa-bbb:id1',
IDList_TYPE,
)
self.assertEqual(
1,
self.state_replicator._state_versions[mem_key1],
)
self.assertEqual(
2,
self.state_replicator._state_versions[mem_key2],
)
# Now run again, ensuring only the state the wasn't replicated
# will be sent again
req = await self.state_replicator._collect_states_to_replicate()
self.assertEqual(1, len(req.states))
self.assertEqual('aaa-bbb:id2', req.states[0].deviceID)
self.assertEqual(LOG_TYPE, req.states[0].type)
def test_flat_invalid_key(self):
expected = LogVerbosity(verbosity=5)
self.assertRaises(ValueError, self._flat_dict.__setitem__, 'key3',
expected)