async def test():
get_rpc_mock.return_value = self.channel
# Ensure setup is initialized properly
self.nid_client.clear()
self.idlist_client.clear()
self.log_client.clear()
self.foo_client.clear()
key = 'id1'
foo = Foo("boo", 4)
self.nid_client[key] = NetworkID(id='foo')
self.idlist_client[key] = IDList(ids=['bar', 'blah'])
self.foo_client[key] = foo
# Increment version
self.idlist_client[key] = IDList(ids=['bar', 'blah'])
req = await self.state_replicator._collect_states_to_replicate()
self.assertEqual(3, len(req.states))
# Ensure in-memory map updates properly
await self.state_replicator._send_to_state_service(req)
self.assertEqual(3, len(self.state_replicator._state_versions))
mem_key1 = self.state_replicator.make_mem_key('id1', NID_TYPE)
mem_key2 = self.state_replicator.make_mem_key(
'aaa-bbb:id1', IDList_TYPE)
mem_key3 = self.state_replicator.make_mem_key('id1', FOO_TYPE)
self.assertEqual(1,
self.state_replicator._state_versions[mem_key1])
self.assertEqual(2,
self.state_replicator._state_versions[mem_key2])
self.assertEqual(1,
self.state_replicator._state_versions[mem_key3])
# Now add new state and update some existing state
key2 = 'id2'
self.nid_client[key2] = NetworkID(id='bar')
self.idlist_client[key] = IDList(ids=['bar', 'foo'])
req = await self.state_replicator._collect_states_to_replicate()
self.assertEqual(2, len(req.states))
# Ensure in-memory map updates properly
await self.state_replicator._send_to_state_service(req)
self.assertEqual(4, len(self.state_replicator._state_versions))
mem_key4 = self.state_replicator.make_mem_key('id2', NID_TYPE)
self.assertEqual(1,
self.state_replicator._state_versions[mem_key1])
self.assertEqual(3,
self.state_replicator._state_versions[mem_key2])
self.assertEqual(1,
self.state_replicator._state_versions[mem_key3])
self.assertEqual(1,
self.state_replicator._state_versions[mem_key4])
async def test():
# Ensure setup is initialized properly
self.nid_client.clear()
self.idlist_client.clear()
self.log_client.clear()
self.foo_client.clear()
key = 'id1'
self.nid_client[key] = NetworkID(id='foo')
self.idlist_client[key] = IDList(ids=['bar', 'blah'])
self.foo_client[key] = Foo("boo", 3)
exp1 = self.convert_msg_to_state(self.nid_client[key])
exp2 = self.convert_msg_to_state(self.idlist_client[key])
exp3 = self.convert_msg_to_state(self.foo_client[key], False)
req = await self.state_replicator._collect_states_to_replicate()
self.assertEqual(3, len(req.states))
for state in req.states:
if state.type == NID_TYPE:
self.assertEqual('id1', state.deviceID)
self.assertEqual(1, state.version)
self.assertEqual(exp1, state.value)
elif state.type == IDList_TYPE:
self.assertEqual('aaa-bbb:id1', state.deviceID)
self.assertEqual(1, state.version)
self.assertEqual(exp2, state.value)
elif state.type == FOO_TYPE:
self.assertEqual('id1', state.deviceID)
self.assertEqual(1, state.version)
self.assertEqual(exp3, state.value)
else:
self.fail("Unknown state type %s" % state.type)
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)
async def test():
get_grpc_mock.return_value = self.channel
self.nid_client.clear()
self.idlist_client.clear()
self.log_client.clear()
self.foo_client.clear()
key = 'id1'
# Set state that will be 'unsynced'
self.nid_client[key] = NetworkID(id='foo')
self.idlist_client[key] = IDList(ids=['bar', 'blah'])
# Increment state's version
self.idlist_client[key] = IDList(ids=['bar', 'blah'])
await self.state_replicator._resync()
self.assertEqual(True, self.state_replicator._has_resync_completed)
self.assertEqual(1, len(self.state_replicator._state_versions))
mem_key = make_mem_key('aaa-bbb:id1', IDList_TYPE)
self.assertEqual(2, self.state_replicator._state_versions[mem_key])