def test_requests(self): DUT, DUT_manager = fake_clients.fake_KATCP_client_resource_container_factory( resource_client.KATCPClientResourceContainer, {}, copy.deepcopy(self.resources_spec)) DUT.start() yield DUT.until_any_child_in_state('syncing') yield DUT.until_synced() # Check the standard requests as implemented by # fake_clients.FakeInspectingClientManager. Expect this test to break if # FakeInspectingClientManager implements more requests. standard_requests = ('help', 'sensor_list') controlled_clients = [ escape_name(c_name) for c_name, c in self.resources_spec['clients'].items() if c.get('controlled')] desired_requests = sorted( escape_name(c)+'_'+r for c in controlled_clients for r in standard_requests) self.assertEqual(sorted(DUT.req.keys()), desired_requests) # Now add some requests DUT_manager.add_request_handlers_object('client1', FakeHandlers()) yield DUT.until_any_child_in_state('syncing') yield DUT.until_synced() desired_requests += ['client1_add_test', 'client1_async_divide'] desired_requests.sort() self.assertEqual(sorted(DUT.req.keys()), desired_requests) reply, informs = yield DUT.req.client1_add_test(1, 5, mid='1233') self.assertEqual(len(informs), 1) self.assertEqual(str(informs[0]), '#add-test[1233] 2 15') self.assertEqual(str(reply), '!add-test[1233] ok 6')
def test_requests(self): DUT, DUT_manager = fake_clients.fake_KATCP_client_resource_container_factory( resource_client.KATCPClientResourceContainer, {}, copy.deepcopy(self.resources_spec)) DUT.start() yield DUT.until_any_child_in_state('syncing') yield DUT.until_synced() # Check the standard requests as implemented by # fake_clients.FakeInspectingClientManager. Expect this test to break if # FakeInspectingClientManager implements more requests. standard_requests = ('help', 'sensor_list') controlled_clients = [ escape_name(c_name) for c_name, c in self.resources_spec['clients'].items() if c.get('controlled') ] desired_requests = sorted( escape_name(c) + '_' + r for c in controlled_clients for r in standard_requests) self.assertEqual(sorted(DUT.req.keys()), desired_requests) # Now add some requests DUT_manager.add_request_handlers_object('client1', FakeHandlers()) yield DUT.until_any_child_in_state('syncing') yield DUT.until_synced() desired_requests += ['client1_add_test', 'client1_async_divide'] desired_requests.sort() self.assertEqual(sorted(DUT.req.keys()), desired_requests) reply, informs = yield DUT.req.client1_add_test(1, 5, mid='1233') self.assertEqual(len(informs), 1) self.assertEqual(str(informs[0]), '#add-test[1233] 2 15') self.assertEqual(str(reply), '!add-test[1233] ok 6')
def test_disconnect(self): # Test that a device disconnect / reconnect is correctly handled DUT = yield self._get_DUT_and_sync(self.default_resource_spec) initial_reqs = set(DUT.req) initial_sensors = set(DUT.sensor) self.server.stop() self.server.join(timeout=1) yield DUT.until_state('disconnected') # Test that requests fail rep = yield DUT.req.watchdog() self.assertFalse(rep.succeeded) # Restart device so that we can reconnect self.server.start() # timewarp beyond reconect delay self.set_ioloop_time(self.ioloop_time + 1) yield DUT.until_state('syncing') yield DUT.until_state('synced') # check that sensors / requests are unchanged self.assertEqual(set(DUT.req), initial_reqs) self.assertEqual(set(DUT.sensor), initial_sensors) # Now disconnect and change the device, to check that it is properly resynced. self.server.stop() self.server.join(timeout=1) yield DUT.until_state('disconnected') # Add a new request to the server def request_sparkling_new(self, req, msg): """A new command.""" return Message.reply(msg.name, "ok", "bling1", "bling2") self.server._request_handlers['sparkling-new'] = request_sparkling_new # Check that the request does not exist currently self.assertNotIn('sparkling_new', initial_reqs) # Add a new sensor to the server sensor = DeviceTestSensor(DeviceTestSensor.INTEGER, "another.int", "An Integer.", "count", [-5, 5], timestamp=self.io_loop.time(), status=DeviceTestSensor.NOMINAL, value=3) self.server.add_sensor(sensor) # Check that the sensor does not exist currently escaped_new_sensor = resource.escape_name(sensor.name) self.assertNotIn(resource.escape_name(sensor.name), initial_sensors) # Restart device so that we can reconnect self.server.start() # timewarp beyond reconect delay self.set_ioloop_time(self.ioloop_time + 1) yield DUT.until_state('syncing') yield DUT.until_state('synced') # check that sensors / requests are correctly updated self.assertEqual(set(DUT.req), initial_reqs | set(['sparkling_new'])) self.assertEqual(set(DUT.sensor), initial_sensors | set([escaped_new_sensor]))
def test_init(self): m_logger = mock.Mock() DUT = resource_client.KATCPClientResourceContainer( self.default_spec, logger=m_logger) self.assertEqual(DUT.name, 'test-container') self.assertEqual(DUT.description, 'container for testing') child_specs = self.default_spec_orig['clients'] self.assertEqual(sorted(DUT.children), sorted(resource.escape_name(n) for n in child_specs)) for child_name, child_spec in child_specs.items(): child = DUT.children[resource.escape_name(child_name)] self.assertEqual(child.name, child_name) self.assertEqual(child.parent, DUT) self.assertEqual(child.address, child_spec['address']) self.assertIs(child._logger, m_logger)
def test_escape_name(self): desired_mappings = { 'blah-bal' : 'blah_bal', 'bief_bof.ba32f-blief' : 'bief_bof_ba32f_blief', 'already_escape_name' : 'already_escape_name'} for input, expected_output in desired_mappings.items(): self.assertEqual(resource.escape_name(input), expected_output)
def test_escape_name(self): desired_mappings = { 'blah-bal': 'blah_bal', 'bief_bof.ba32f-blief': 'bief_bof_ba32f_blief', 'already_escape_name': 'already_escape_name' } for input, expected_output in desired_mappings.items(): self.assertEqual(resource.escape_name(input), expected_output)
def client_resource_factory(self, res_spec, parent, logger): real_instance = super(FakeKATCPClientResourceContainer, self).client_resource_factory( res_spec, parent, logger ) fkcr, fkcr_manager = fake_KATCP_client_resource_factory( real_instance.__class__, fake_options, res_spec, parent=self, logger=logger ) self.fake_client_resource_managers[resource.escape_name(fkcr.name)] = fkcr_manager return fkcr
def client_resource_factory(self, res_spec, parent, logger): real_instance = (super(FakeKATCPClientResourceContainer, self).client_resource_factory( res_spec, parent, logger)) fkcr, fkcr_manager = fake_KATCP_client_resource_factory( real_instance.__class__, fake_options, res_spec, parent=self, logger=logger) self.fake_client_resource_managers[resource.escape_name( fkcr.name)] = fkcr_manager return fkcr
def test_set_ioloop(self): # Make two tornado IOLoop instances, one that is installed as the current thread # IOLoop, and one that we will explicity pass to set_ioloop. If set_ioloop is not # doing it's job, the children would automatically use thread_ioloop instance. thread_ioloop = tornado.ioloop.IOLoop() self.addCleanup(thread_ioloop.close, all_fds=True) thread_ioloop.make_current() our_ioloop = tornado.ioloop.IOLoop() self.addCleanup(our_ioloop.close, all_fds=True) DUT = resource_client.KATCPClientResourceContainer(self.default_spec) DUT.set_ioloop(our_ioloop) DUT.start() for child_name in self.default_spec_orig['clients']: self.assertIs(DUT.children[resource.escape_name(child_name)].ioloop, our_ioloop)
def test_interface_change(self): DUT = yield self._get_DUT_and_sync(self.default_resource_spec) sensors_before = set(DUT.sensor) reqs_before = set(DUT.req) # Add a new sensor to the server sensor = DeviceTestSensor(DeviceTestSensor.INTEGER, "another.int", "An Integer.", "count", [-5, 5], timestamp=self.io_loop.time(), status=DeviceTestSensor.NOMINAL, value=3) self.server.add_sensor(sensor) # Check that the sensor does not exist currently self.assertNotIn(resource.escape_name(sensor.name), sensors_before) # Add a new request to the server def request_sparkling_new(self, req, msg): """A new command.""" return Message.reply(msg.name, "ok", "bling1", "bling2") self.server._request_handlers['sparkling-new'] = request_sparkling_new # Check that the request did not exist before self.assertNotIn('sparkling-new', reqs_before) # Issue #interface-changed self.server.mass_inform(Message.inform('interface-changed')) yield DUT.until_state('syncing') yield DUT.until_state('synced') # Check if sensor/request was added self.assertEqual(set(DUT.sensor) - sensors_before, set(['another_int'])) self.assertEqual(set(DUT.req) - reqs_before, set(['sparkling_new'])) # And now remove them again self.server._request_handlers.pop('sparkling-new') self.server.remove_sensor('another.int') # Issue #interface-changed self.server.mass_inform(Message.inform('interface-changed')) yield DUT.until_state('syncing') yield DUT.until_state('synced') # Check if sensor/request was removed self.assertEqual(set(DUT.sensor), sensors_before) self.assertEqual(set(DUT.req), reqs_before)
def test_list_sensors(self): resource_spec = dict( name='testdev', address=('testhost', 12345)) DUT = resource_client.KATCPClientResource(resource_spec) sens_manager = mock.create_autospec( resource_client.KATCPClientResourceSensorsManager(mock.Mock(), "test")) test_sensors_info = AttrDict( sens_one=AttrDict(name='sens-one', description='sensor one', value=1), sens_two=AttrDict(name='sens.two', description='sensor one', value=2), sens_three=AttrDict(name='sens_three', description='sensor three', value=3)) sensor_strategies = dict(sens_one='event', sens_three='period 10') def make_test_sensors(sensors_info): test_sensors = AttrDict() for sens_pyname, info in sensors_info.items(): info = dict(info) info['sensor_type'] = Sensor.INTEGER val = info.pop('value') timestamp = val*10 received_timestamp = timestamp + 1 sens = test_sensors[sens_pyname] = resource.KATCPSensor( info, sens_manager) sens._reading = resource.KATCPSensorReading( received_timestamp, timestamp, Sensor.NOMINAL, val) test_sensors[sens_pyname] = sens return test_sensors test_sensors = make_test_sensors(test_sensors_info) sens_manager.get_sampling_strategy.side_effect = ( lambda sens_name: resource.normalize_strategy_parameters( sensor_strategies.get( resource.escape_name(sens_name), 'none')) ) DUT.sensor.update(test_sensors) # Simple search based on python identifier result = yield DUT.list_sensors('sens_one') self.assertEqual(len(result), 1) self.assertEqual(result[0], resource.SensorResultTuple( test_sensors.sens_one, test_sensors_info.sens_one.name, 'sens_one', test_sensors_info.sens_one.description, 'integer', '', test_sensors.sens_one.reading)) # Now get all the sensors result = yield DUT.list_sensors('') expected_result = sorted(resource.SensorResultTuple( test_sensors[s_id], test_sensors_info[s_id].name, s_id, test_sensors_info[s_id].description, 'integer', '', test_sensors[s_id].reading) for s_id in test_sensors_info) self.assertEqual(sorted(result), expected_result) # Test that all sensors are found using their Python identifiers result = yield DUT.list_sensors('sens_two') self.assertEqual(len(result), 1) self.assertEqual(result[0].object, test_sensors.sens_two) result = yield DUT.list_sensors('sens_three') self.assertEqual(len(result), 1) self.assertEqual(result[0].object, test_sensors.sens_three) # Test using actual sensor name result = yield DUT.list_sensors('sens_one', use_python_identifiers=False) self.assertEqual(len(result), 0) result = yield DUT.list_sensors('sens-one', use_python_identifiers=False) self.assertEqual(len(result), 1) self.assertEqual(result[0].name, 'sens-one') # Now test with strategy filter result = yield DUT.list_sensors('', strategy=True) self.assertEqual(len(result), len(sensor_strategies))