def setUp(self):
super(TestICAClass, self).setUp()
self.client = InspectingClientAsync('',
0,
initial_inspection=False,
ioloop=self.io_loop)
self.client.set_state_callback(self._cb_state)
def setUp(self):
super(TestInspectingClientAsync, 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.client = InspectingClientAsync(self.host, self.port,
ioloop=self.io_loop)
self.io_loop.add_callback(self.client.connect)
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_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 setUp(self):
super(TestInspectingClientAsync, 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.client = InspectingClientAsync(self.host, self.port,
ioloop=self.io_loop)
self.io_loop.add_callback(self.client.connect)
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_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')
print("round-trip min/avg/max = {0}/{1}/{2} s".
format(min(self.durations),
sum(self.durations) / float(len(self.durations)),
max(self.durations)))
print("request had {0} informs with each {1} bytes additional pyload".
format(self.informs, self.size))
print("recieved {0} informs in total".format(self.recieved_informs))
def close(self):
self.running = False
if __name__ == "__main__":
args = parse_args()
print(args.host)
print(args.port)
print(args.request_count)
io_loop = tornado.ioloop.IOLoop.instance()
ic = InspectingClientAsync(args.host, args.port)
do_ping = DoPing(ic, args.host, args.request_count,
args.inform_count, args.size)
ic.set_ioloop(io_loop)
io_loop.add_callback(ic.connect)
io_loop.add_callback(do_ping.run)
try:
io_loop.start()
except KeyboardInterrupt:
do_ping.close()
ic.close()
do_ping.summary()
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 TestInspectingClientAsync(tornado.testing.AsyncTestCase):
def setUp(self):
super(TestInspectingClientAsync, 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.client = InspectingClientAsync(self.host, self.port,
ioloop=self.io_loop)
self.io_loop.add_callback(self.client.connect)
@tornado.testing.gen_test
def test_timeout_of_until_synced(self):
# Test for timing out
with self.assertRaises(tornado.gen.TimeoutError):
yield self.client.until_synced(timeout=0.00001)
# Test for NOT timing out
yield self.client.until_synced(timeout=0.5)
@tornado.testing.gen_test
def test_simple_request(self):
"""Perform a basic request."""
yield self.client.until_synced()
reply, informs = yield self.client.simple_request('help', 'watchdog')
self.assertIn('ok', str(reply))
self.assertEquals(len(informs), 1)
@tornado.testing.gen_test
def test_sensor(self):
"""Access the sensor with the Async client."""
yield self.client.until_synced()
sensor_name = 'an.int'
sensor = yield self.client.future_get_sensor(sensor_name)
self.assertEquals(sensor.name, sensor_name)
self.assertEquals(sensor.stype, 'integer')
# Unknown sensor requests return a None.
sensor_name = 'thing.unknown_sensor'
sensor = yield self.client.future_get_sensor(sensor_name)
self.assertIsNone(sensor)
@tornado.testing.gen_test
def test_request_access(self):
"""Test access to requests."""
yield self.client.until_synced()
request_name = 'watchdog'
self.assertIn(request_name, self.client.requests)
request = yield self.client.future_get_request(request_name)
self.assertEqual(request.name, request_name)
self.assertTrue(request.description,
'Expected an description: got nothing.')
# Unknown request return a None.
request_name = 'watchcat'
self.assertNotIn(request_name, self.client.requests)
request = yield self.client.future_get_request(request_name)
self.assertIsNone(request)
@tornado.testing.gen_test
def test_sensor_add_remove(self):
"""Test a sensor being added and then remove it."""
yield self.client.until_synced()
sensor = DeviceTestSensor(Sensor.INTEGER, "another.int",
"An Integer.",
"count", [-5, 5], timestamp=time.time(),
status=Sensor.NOMINAL, value=3)
# Check that the sensor does not exist currently
self.assertNotIn(sensor.name, self.client.sensors)
# Add a sensor.
self.server.add_sensor(sensor)
self.server.mass_inform(Message.inform('interface-changed'))
# Do a blocking request to ensure #interface-changed has been received
yield self.client.simple_request('watchdog')
yield self.client.until_synced()
self.assertIn('another.int', self.client.sensors)
# Remove a sensor.
self.server.remove_sensor(sensor)
self.server.mass_inform(Message.inform('interface-changed'))
# Do a blocking request to ensure #interface-changed has been received
yield self.client.simple_request('watchdog')
yield self.client.until_synced()
self.assertNotIn('another.int', self.client.sensors)
@tornado.testing.gen_test
def test_request_add_remove(self):
"""Test a request being added and then remove it."""
yield self.client.until_synced()
def request_sparkling_new(self, req, msg):
"""A new command."""
return Message.reply(msg.name, "ok", "bling1", "bling2")
# Check that the request did not exist before
self.assertNotIn('sparkling-new', self.client.requests)
# Add a request.
self.server.request_sparkling_new = request_sparkling_new
self.server._request_handlers['sparkling-new'] = request_sparkling_new
self.server.mass_inform(Message.inform('interface-changed'))
# Do a blocking request to ensure #interface-changed has been received
yield self.client.simple_request('watchdog')
yield self.client.until_synced()
self.assertIn('sparkling-new', self.client.requests)
req = yield self.client.future_get_request('sparkling-new')
self.assertEqual(req.name, 'sparkling-new')
# Remove a request.
self.server.request_sparkling_new = None
del(self.server._request_handlers['sparkling-new'])
self.server.mass_inform(Message.inform('interface-changed'))
# Do a blocking request to ensure #interface-changed has been received
self.client.simple_request('watchdog')
yield self.client.until_synced()
self.assertNotIn('sparkling_new', self.client.requests)
@tornado.testing.gen_test
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)
@tornado.testing.gen_test
def test_handle_sensor_value(self):
yield self.client.until_connected()
# Test that #sensor-value informs are handles like #sensor-inform informs if
# handle_sensor_value() is called.
sens = yield self.client.future_get_sensor('an.int')
test_val = 1911
# Check that the sensor doesn't start out with our test value
self.assertNotEqual(sens.read().value, test_val)
# Now set the value of the sensor on the server
server_sens = self.server.get_sensor('an.int')
server_sens.set_value(test_val)
# Do a request to ensure we are synced with the server
yield self.client.simple_request('watchdog')
# Test that the value has not yet been set on the client sensor (there are no
# strategies set)
self.assertNotEqual(sens.read().value, test_val)
# Now do a ?sensor-value request, and check that our object is NOT YET updated,
# since we have not called handle_sensor_value() yet
yield self.client.simple_request('sensor-value', 'an.int')
self.assertNotEqual(sens.read().value, test_val)
# Test call
self.client.handle_sensor_value()
# Now do a ?sensor-value request, and check that our object is updated
yield self.client.simple_request('sensor-value', 'an.int')
self.assertEqual(sens.read().value, test_val)
@tornado.testing.gen_test
def test_factories(self):
yield self.client.until_connected()
# Test that the correct factories are used to construct sensor and request
# objects, and that the factories are called with the correct parameters.
sf = self.client.sensor_factory = mock.Mock()
rf = self.client.request_factory = mock.Mock()
sen = yield self.client.future_get_sensor('an.int')
req = yield self.client.future_get_request('watchdog')
self.assertIs(sen, sf.return_value)
sf.assert_called_once_with(
units='count', sensor_type=0, params=[-5, 5],
description='An Integer.', name='an.int')
self.assertIs(req, rf.return_value)
rf.assert_called_once_with(
name='watchdog', description=mock.ANY, timeout_hint=None)
class TestInspectingClientAsync(tornado.testing.AsyncTestCase):
def setUp(self):
super(TestInspectingClientAsync, 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.client = InspectingClientAsync(self.host, self.port,
ioloop=self.io_loop)
self.io_loop.add_callback(self.client.connect)
@tornado.testing.gen_test
def test_simple_request(self):
"""Perform a basic request."""
yield self.client.until_synced()
reply, informs = yield self.client.simple_request('help', 'watchdog')
self.assertIn('ok', str(reply))
self.assertEquals(len(informs), 1)
@tornado.testing.gen_test
def test_sensor(self):
"""Access the sensor with the Async client."""
yield self.client.until_synced()
sensor_name = 'an.int'
sensor = yield self.client.future_get_sensor(sensor_name)
self.assertEquals(sensor.name, sensor_name)
self.assertEquals(sensor.stype, 'integer')
# Unknown sensor requests return a None.
sensor_name = 'thing.unknown_sensor'
sensor = yield self.client.future_get_sensor(sensor_name)
self.assertIsNone(sensor)
@tornado.testing.gen_test
def test_request_access(self):
"""Test access to requests."""
yield self.client.until_synced()
request_name = 'watchdog'
self.assertIn(request_name, self.client.requests)
request = yield self.client.future_get_request(request_name)
self.assertEqual(request.name, request_name)
self.assertTrue(request.description,
'Expected an description: got nothing.')
# Unknown request return a None.
request_name = 'watchcat'
self.assertNotIn(request_name, self.client.requests)
request = yield self.client.future_get_request(request_name)
self.assertIsNone(request)
@tornado.testing.gen_test
def test_sensor_add_remove(self):
"""Test a sensor being added and then remove it."""
yield self.client.until_synced()
sensor = DeviceTestSensor(Sensor.INTEGER, "another.int",
"An Integer.",
"count", [-5, 5], timestamp=time.time(),
status=Sensor.NOMINAL, value=3)
# Check that the sensor does not exist currently
self.assertNotIn(sensor.name, self.client.sensors)
# Add a sensor.
self.server.add_sensor(sensor)
self.server.mass_inform(Message.inform('interface-changed'))
# Do a blocking request to ensure #interface-changed has been received
yield self.client.simple_request('watchdog')
yield self.client.until_synced()
self.assertIn('another.int', self.client.sensors)
# Remove a sensor.
self.server.remove_sensor(sensor)
self.server.mass_inform(Message.inform('interface-changed'))
# Do a blocking request to ensure #interface-changed has been received
yield self.client.simple_request('watchdog')
yield self.client.until_synced()
self.assertNotIn('another.int', self.client.sensors)
@tornado.testing.gen_test
def test_request_add_remove(self):
"""Test a request being added and then remove it."""
yield self.client.until_synced()
def request_sparkling_new(self, req, msg):
"""A new command."""
return Message.reply(msg.name, "ok", "bling1", "bling2")
# Check that the request did not exist before
self.assertNotIn('sparkling-new', self.client.requests)
# Add a request.
self.server.request_sparkling_new = request_sparkling_new
self.server._request_handlers['sparkling-new'] = request_sparkling_new
self.server.mass_inform(Message.inform('interface-changed'))
# Do a blocking request to ensure #interface-changed has been received
yield self.client.simple_request('watchdog')
yield self.client.until_synced()
self.assertIn('sparkling-new', self.client.requests)
req = yield self.client.future_get_request('sparkling-new')
self.assertEqual(req.name, 'sparkling-new')
# Remove a request.
self.server.request_sparkling_new = None
del(self.server._request_handlers['sparkling-new'])
self.server.mass_inform(Message.inform('interface-changed'))
# Do a blocking request to ensure #interface-changed has been received
self.client.simple_request('watchdog')
yield self.client.until_synced()
self.assertNotIn('sparkling_new', self.client.requests)
@tornado.testing.gen_test
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)
@tornado.testing.gen_test
def test_handle_sensor_value(self):
yield self.client.until_connected()
# Test that #sensor-value informs are handles like #sensor-inform informs if
# handle_sensor_value() is called.
sens = yield self.client.future_get_sensor('an.int')
test_val = 1911
# Check that the sensor doesn't start out with our test value
self.assertNotEqual(sens.read().value, test_val)
# Now set the value of the sensor on the server
server_sens = self.server.get_sensor('an.int')
server_sens.set_value(test_val)
# Do a request to ensure we are synced with the server
yield self.client.simple_request('watchdog')
# Test that the value has not yet been set on the client sensor (there are no
# strategies set)
self.assertNotEqual(sens.read().value, test_val)
# Now do a ?sensor-value request, and check that our object is NOT YET updated,
# since we have not called handle_sensor_value() yet
yield self.client.simple_request('sensor-value', 'an.int')
self.assertNotEqual(sens.read().value, test_val)
# Test call
self.client.handle_sensor_value()
# Now do a ?sensor-value request, and check that our object is updated
yield self.client.simple_request('sensor-value', 'an.int')
self.assertEqual(sens.read().value, test_val)
@tornado.testing.gen_test
def test_factories(self):
yield self.client.until_connected()
# Test that the correct factories are used to construct sensor and request
# objects, and that the factories are called with the correct parameters.
sf = self.client.sensor_factory = mock.Mock()
rf = self.client.request_factory = mock.Mock()
sen = yield self.client.future_get_sensor('an.int')
req = yield self.client.future_get_request('watchdog')
self.assertIs(sen, sf.return_value)
sf.assert_called_once_with(
units=None, sensor_type=0, params=[-5, 5],
description='An Integer.', name='an.int')
self.assertIs(req, rf.return_value)
rf.assert_called_once_with('watchdog', mock.ANY)
min(self.durations),
sum(self.durations) / float(len(self.durations)),
max(self.durations)))
print("request had {0} informs with each {1} bytes additional pyload".
format(self.informs, self.size))
print("recieved {0} informs in total".format(self.recieved_informs))
def close(self):
self.running = False
if __name__ == "__main__":
args = parse_args()
print(args.host)
print(args.port)
print(args.request_count)
io_loop = tornado.ioloop.IOLoop.instance()
ic = InspectingClientAsync(args.host, args.port)
do_ping = DoPing(ic, args.host, args.request_count, args.inform_count,
args.size)
ic.set_ioloop(io_loop)
io_loop.add_callback(ic.connect)
io_loop.add_callback(do_ping.run)
try:
io_loop.start()
except KeyboardInterrupt:
do_ping.close()
ic.close()
do_ping.summary()
def setUp(self):
super(TestICAClass, self).setUp()
self.client = InspectingClientAsync('', 0, initial_inspection=False,
ioloop=self.io_loop)
self.client.set_state_callback(self._cb_state)
class TestICAClass(tornado.testing.AsyncTestCase):
def setUp(self):
super(TestICAClass, self).setUp()
self.client = InspectingClientAsync('', 0, initial_inspection=False,
ioloop=self.io_loop)
self.client.set_state_callback(self._cb_state)
def test_initial_state(self):
self.assertEqual(self.client.state,
inspecting_client.InspectingClientStateType(
connected=False, synced=False, model_changed=False, data_synced=False))
def _cb_state(self, state, model_changes):
"""A callback used in the test."""
self.stop((state, model_changes))
def test_util_method_difference_add(self):
"""Test the _difference utility method on add."""
name = None
original_keys = ['B', 'C']
updated_keys = ['B', 'C', 'D']
self.client._sensors_index = {}
for sen in original_keys:
data = {'description': "This is {0}.".format(sen)}
self.client._update_index(self.client._sensors_index, sen, data)
added, removed = self.client._difference(
original_keys, updated_keys, name, self.client._sensors_index)
self.assertIn('D', added)
self.assertIn('B', self.client.sensors)
self.assertIn('C', self.client.sensors)
def test_util_method_difference_rem(self):
"""Test the _difference utility method on remove."""
name = None
original_keys = ['A', 'B', 'C']
updated_keys = ['B', 'C']
self.client._sensors_index = {}
for sen in original_keys:
data = {'description': "This is {0}.".format(sen)}
self.client._update_index(self.client._sensors_index, sen, data)
added, removed = self.client._difference(
original_keys, updated_keys, name, self.client._sensors_index)
self.assertIn('A', removed)
self.assertNotIn('A', self.client.sensors)
self.assertIn('B', self.client.sensors)
self.assertIn('C', self.client.sensors)
def test_util_method_difference_rem_named(self):
"""Test the _difference utility method on remove with name set."""
name = 'A'
original_keys = ['B', 'C']
updated_keys = []
self.client._sensors_index = {}
for sen in original_keys:
data = {'description': "This is {0}.".format(sen)}
self.client._update_index(self.client._sensors_index, sen, data)
added, removed = self.client._difference(
original_keys, updated_keys, name, self.client._sensors_index)
self.assertNotIn('A', removed)
self.assertNotIn('A', self.client.sensors)
self.assertIn('B', self.client.sensors)
self.assertIn('C', self.client.sensors)
def test_util_method_difference_changed(self):
"""Test the _difference utility method on changed."""
name = None
original_keys = ['B']
updated_keys = ['B']
self.client._sensors_index = {}
for sen in original_keys:
data = {'description': "This is {0}.".format(sen), '_changed': True}
self.client._update_index(self.client._sensors_index, sen, data)
added, removed = self.client._difference(original_keys, updated_keys,
name, self.client._sensors_index)
self.assertIn('B', self.client.sensors)
def test_update_index(self):
"""Test the update_index method."""
index = self.client._sensors_index = {}
data = {'description': "This is {0}.".format('A')}
self.client._update_index(index, 'A', data)
data = {'description': "This is {0}.".format('B')}
self.client._update_index(index, 'B', data)
data = {'description': "This is {0}.".format('A')}
self.client._update_index(index, 'A', data)
data = {'description': "This is new {0}.".format('B')}
self.client._update_index(index, 'B', data)
self.assertIn('new', index['B'].get('description'))
self.assertFalse(index['A'].get('_changed', False))
self.assertTrue(index['B'].get('_changed'))
class TestICAClass(tornado.testing.AsyncTestCase):
def setUp(self):
super(TestICAClass, self).setUp()
self.client = InspectingClientAsync('', 0, initial_inspection=False,
ioloop=self.io_loop)
self.client.set_state_callback(self._cb_state)
def test_initial_state(self):
self.assertEqual(self.client.state,
inspecting_client.InspectingClientStateType(
connected=False, synced=False, model_changed=False, data_synced=False))
def _cb_state(self, state, model_changes):
"""A callback used in the test."""
self.stop((state, model_changes))
def test_util_method_difference_add(self):
"""Test the _difference utility method on add."""
name = None
original_keys = ['B', 'C']
updated_keys = ['B', 'C', 'D']
self.client._sensors_index = {}
for sen in original_keys:
data = {'description': "This is {0}.".format(sen)}
self.client._update_index(self.client._sensors_index, sen, data)
added, removed = self.client._difference(
original_keys, updated_keys, name, self.client._sensors_index)
self.assertIn('D', added)
self.assertIn('B', self.client.sensors)
self.assertIn('C', self.client.sensors)
def test_util_method_difference_rem(self):
"""Test the _difference utility method on remove."""
name = None
original_keys = ['A', 'B', 'C']
updated_keys = ['B', 'C']
self.client._sensors_index = {}
for sen in original_keys:
data = {'description': "This is {0}.".format(sen)}
self.client._update_index(self.client._sensors_index, sen, data)
added, removed = self.client._difference(
original_keys, updated_keys, name, self.client._sensors_index)
self.assertIn('A', removed)
self.assertNotIn('A', self.client.sensors)
self.assertIn('B', self.client.sensors)
self.assertIn('C', self.client.sensors)
def test_util_method_difference_rem_named(self):
"""Test the _difference utility method on remove with name set."""
name = 'A'
original_keys = ['B', 'C']
updated_keys = []
self.client._sensors_index = {}
for sen in original_keys:
data = {'description': "This is {0}.".format(sen)}
self.client._update_index(self.client._sensors_index, sen, data)
added, removed = self.client._difference(
original_keys, updated_keys, name, self.client._sensors_index)
self.assertNotIn('A', removed)
self.assertNotIn('A', self.client.sensors)
self.assertIn('B', self.client.sensors)
self.assertIn('C', self.client.sensors)
def test_util_method_difference_changed(self):
"""Test the _difference utility method on changed."""
name = None
original_keys = ['B']
updated_keys = ['B']
self.client._sensors_index = {}
for sen in original_keys:
data = {'description': "This is {0}.".format(sen), '_changed': True}
self.client._update_index(self.client._sensors_index, sen, data)
added, removed = self.client._difference(original_keys, updated_keys,
name, self.client._sensors_index)
self.assertIn('B', self.client.sensors)
def test_update_index(self):
"""Test the update_index method."""
index = self.client._sensors_index = {}
data = {'description': "This is {0}.".format('A')}
self.client._update_index(index, 'A', data)
data = {'description': "This is {0}.".format('B')}
self.client._update_index(index, 'B', data)
data = {'description': "This is {0}.".format('A')}
self.client._update_index(index, 'A', data)
data = {'description': "This is new {0}.".format('B')}
self.client._update_index(index, 'B', data)
self.assertIn('new', index['B'].get('description'))
self.assertFalse(index['A'].get('_changed', False))
self.assertTrue(index['B'].get('_changed'))
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)
