def test_from_connect(self):
# Hold back #version-connect informs
num_calls_before = len(self.done_state_cb_futures)
logger.debug('before starting client, num_calls_before:{}'.format(
num_calls_before))
self.server.proceed_on_client_connect.clear()
self.client.connect()
state, model_changes = yield self.state_cb_future
self.assertEqual(
state,
inspecting_client.InspectingClientStateType(connected=False,
synced=False,
model_changed=False,
data_synced=False))
state, model_changes = yield self.state_cb_future
self.assertEqual(
state,
inspecting_client.InspectingClientStateType(connected=True,
synced=False,
model_changed=False,
data_synced=False))
self.assertIs(model_changes, None)
# Due to the structure of the state loop the initial state may be sent
# twice before we get here, and was the case for the initial
# implementation. Changes made on 2015-01-26 caused it to happen only
# once, hence + 1. If the implementation changes having + 2 would also
# be OK. As, indeed, changes made on 2016-11-03 caused again :)
yield self._check_cb_count(num_calls_before + 2)
# Now let the server send #version-connect informs
num_calls_before = len(self.done_state_cb_futures)
self.server.ioloop.add_callback(
self.server.proceed_on_client_connect.set)
# We're expecting two calls hard on each other's heels, so lets wait for them
yield self.cnt_state_cb_futures[num_calls_before + 2]
# We expected two status callbacks, and no more after
yield self._check_cb_count(num_calls_before + 2)
state, model_changes = yield self.done_state_cb_futures[-2]
state2, model_changes2 = yield self.done_state_cb_futures[-1]
self.assertEqual(
state,
inspecting_client.InspectingClientStateType(connected=True,
synced=False,
model_changed=True,
data_synced=True))
# Check that the expected model changes came from the callback
self._test_expected_model_changes(model_changes)
self.assertEqual(
state2,
inspecting_client.InspectingClientStateType(connected=True,
synced=True,
model_changed=False,
data_synced=True))
self.assertEqual(model_changes2, None)
def _test_inspection_error(self, break_var, break_message):
# Test that the client retries if there is an error in the inspection
# process
setattr(self.server, break_var, break_message)
self.client.connect()
# Wait for the client to be connected
yield self.client.until_connected()
# Wait for the state loop to send another update or 2
yield self.state_cb_future
state, _ = yield self.state_cb_future
# Check that data is still not synced
self.assertFalse(state.synced)
self.assertFalse(state.data_synced)
# Now fix the inspection request, client should sync up.
setattr(self.server, break_var, False)
# Check that the server's sensors and request are reflected in the model
# changes.
#
changes_state = inspecting_client.InspectingClientStateType(
connected=True, synced=False, model_changed=True, data_synced=True)
yield self.client.until_state(changes_state)
state, model_changes = self.done_state_cb_futures[-1].result()
assert state == changes_state
self._test_expected_model_changes(model_changes)
yield self.client.until_synced()
self.assertTrue(self.client.synced)
def test_initial_state(self):
self.assertEqual(
self.client.state,
inspecting_client.InspectingClientStateType(connected=False,
synced=False,
model_changed=False,
data_synced=False))
def test_reconnect(self):
self.client.connect()
yield self.client.until_synced()
yield tornado.gen.moment # Make sure the ioloop is 'caught up'
# cause a disconnection and check that the callback is called
num_calls_before = len(self.done_state_cb_futures)
self.server.stop()
self.server.join()
state, model_changes = yield self.state_cb_future
self.assertEqual(state, inspecting_client.InspectingClientStateType(
connected=False, synced=False, model_changed=False, data_synced=False))
self.assertIs(model_changes, None)
yield self._check_cb_count(num_calls_before + 1)