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