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