def test_no_memory_leak_after_usage(self):
client = InspectingClientAsync(self.host, self.port, ioloop=self.io_loop)
wr = weakref.ref(client)
yield client.connect()
yield client.until_synced()
client.stop()
yield client.until_stopped()
client.join()
# clear strong reference and check if object can be garbage collected
client = None
gc.collect()
self.assertIsNone(wr())
class TestInspectingClientAsyncStateCallback(tornado.testing.AsyncTestCase):
longMessage = True
maxDiff = None
def setUp(self):
super(TestInspectingClientAsyncStateCallback, self).setUp()
self.server = DeviceTestServer('', 0)
start_thread_with_cleanup(self, self.server, start_timeout=1)
self.host, self.port = self.server.bind_address
self.state_cb_future = tornado.concurrent.Future()
self.client = InspectingClientAsync(self.host, self.port,
ioloop=self.io_loop)
# Set a short initial_resync timeout to make resync tests quick
self.client.initial_resync_timeout = 0.001
self.client.set_state_callback(self._test_state_cb)
self.done_state_cb_futures = []
self.cnt_state_cb_futures = collections.defaultdict(tornado.concurrent.Future)
def _test_state_cb(self, state, model_changes):
f = self.state_cb_future
self.state_cb_future = tornado.concurrent.Future()
self.done_state_cb_futures.append(f)
num_calls = len(self.done_state_cb_futures)
f.set_result((state, model_changes))
self.cnt_state_cb_futures[num_calls].set_result(None)
@tornado.gen.coroutine
def _check_cb_count(self, expected_count):
"""Let the ioloop run and assert that the callback has been called
the expected number of times"""
yield tornado.gen.moment
self.assertEqual(len(self.done_state_cb_futures), expected_count)
@tornado.testing.gen_test(timeout=1)
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_expected_model_changes(self, model_changes):
# Check that the model_changes reflect the sensors and requests of the
# test sever (self.server)
server_sensors = list(self.server._sensors.keys())
server_requests = list(self.server._request_handlers.keys())
self.assertEqual(model_changes, dict(
sensors=dict(added=set(server_sensors), removed=set()),
requests=dict(added=set(server_requests), removed=set())))
@tornado.testing.gen_test(timeout=1)
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)
@tornado.testing.gen_test(timeout=1)
def test_stop(self):
self.client.connect()
yield self.client.until_synced()
yield tornado.gen.moment # Make sure the ioloop is 'caught up'
# stop and check that the callback is called
num_calls_before = len(self.done_state_cb_futures)
next_state_cb_future = self.state_cb_future
self.client.stop()
yield self.client.until_stopped()
self.client.join()
state, model_changes = yield next_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)
@tornado.gen.coroutine
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)
@tornado.testing.gen_test(timeout=1)
def test_help_inspection_error(self):
yield self._test_inspection_error('break_help', 'Help is broken')
@tornado.testing.gen_test(timeout=1)
def test_sensor_list_inspection_error(self):
yield self._test_inspection_error(
'break_sensor_list', 'Sensor-list is broken')