def test_send_request(self): """Very high level test. Calling methods to insure they do not raise exception. """ client = InspectingClientAsync(self.host, self.port, ioloop=self.io_loop, initial_inspection=False) yield client.connect() yield client.until_connected() yield client.until_synced() self.assertEquals(len(client.sensors), 0) self.assertEquals(len(client.requests), 0) self.assertTrue(client.synced) self.assertTrue(client.is_connected()) self.assertTrue(client.connected) yield client.simple_request('sensor-sampling', 'an.int', 'event') # Wait for sync and check if the sensor was automaticaly added. # Get the sensor object and see if it has data. sensor = yield client.future_get_sensor('an.int') self.assertEquals(len(client.sensors), 1) self.assertTrue(sensor.read()) self.assertEquals(len(client.requests), 0)
def test_send_request(self): """Very high level test. Calling methods to insure they do not raise exception. """ client = InspectingClientAsync(self.host, self.port, ioloop=self.io_loop, initial_inspection=False) yield client.connect() yield client.until_connected() yield client.until_synced() self.assertEquals(len(client.sensors), 0) self.assertEquals(len(client.requests), 0) self.assertTrue(client.synced) self.assertTrue(client.is_connected()) self.assertTrue(client.connected) yield client.simple_request('sensor-sampling', 'an.int', 'event') # Wait for sync and check if the sensor was automaticaly added. # Get the sensor object and see if it has data. sensor = yield client.future_get_sensor('an.int') self.assertEquals(len(client.sensors), 1) self.assertTrue(sensor.read()) self.assertEquals(len(client.requests), 0)
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())
def _test_inspect_requests(self, timeout_hints): """Test index creation Parameters ---------- timeout_hints : bool Whether or not the server being tested against should privide request timeout hints Disables :meth:`InspectingClient.inspect_requests` so that inspecting does not happen until the test triggers is. Then checks that :attr:`InspectingClient._requests_index` is correctly generated """ host, port, server = self._get_server(hints=timeout_hints) DUT = InspectingClientAsync(host, port, ioloop=self.io_loop) # mock out the state loop so that syncing does not happen automatically DUT._state_loop = mock.Mock() # Connect to test server yield DUT.connect(timeout=1) # Now run the method under test yield DUT.inspect_requests() expected_request_index = self._get_expected_request_index(server) self.assertEqual(DUT._requests_index, expected_request_index)
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 = self.server._sensors.keys() server_requests = 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.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')
class TestInspectingClientAsyncStateCallback(tornado.testing.AsyncTestCase): 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) 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_no_cb(self, no_expected): """Let the ioloop run and assert that the callback was not called""" yield tornado.gen.moment self.assertEqual(len(self.done_state_cb_futures), no_expected) @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=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 her, and was the case for the initial implementation. Changes made # on 2015-01-26 caused it to happy only once, hence + 1. If the implementation # changes having + 2 would also be OK. yield self._check_no_cb(num_calls_before + 1) # 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_no_cb(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)) server_sensors = self.server._sensors.keys() server_requests = 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()))) self.assertEqual(state2, inspecting_client.InspectingClientStateType( connected=True, synced=True, model_changed=False, data_synced=True)) self.assertEqual(model_changes2, None) @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_no_cb(num_calls_before + 1)
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 = self.server._sensors.keys() server_requests = 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.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')