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')