class test_AsyncClientIntegratedBase(TimewarpAsyncTestCase):
def setUp(self):
super(test_AsyncClientIntegratedBase, self).setUp()
self.server = DeviceTestServer('localhost', 0)
self.server.set_ioloop(self.io_loop)
self.server.set_concurrency_options(thread_safe=False, handler_thread=False)
self.server.start()
host, port = self.server.bind_address
logger.info('host, port: {}:{}'.format(host, port))
self.client = katcp.CallbackClient(host, port)
self.client.set_ioloop(self.io_loop)
class test_AsyncClientIntegrated(tornado.testing.AsyncTestCase, TestUtilMixin):
def setUp(self):
super(test_AsyncClientIntegrated, self).setUp()
self.server = DeviceTestServer('', 0)
self.server.set_ioloop(self.io_loop)
self.server.set_concurrency_options(thread_safe=False, handler_thread=False)
self.server.start()
host, port = self.server.bind_address
self.client = katcp.CallbackClient(host, port)
self.client.set_ioloop(self.io_loop)
self.client.start()
@tornado.testing.gen_test
def test_future_request_simple(self):
yield self.client.until_connected()
reply, informs = yield self.client.future_request(Message.request('watchdog'))
self.assertEqual(len(informs), 0)
self.assertEqual(reply.name, "watchdog")
self.assertEqual(reply.arguments, ["ok"])
@tornado.testing.gen_test
def test_future_request_with_informs(self):
yield self.client.until_connected()
reply, informs = yield self.client.future_request(Message.request('help'))
self.assertEqual(reply.name, "help")
self.assertEqual(reply.arguments, ["ok", "%d" % NO_HELP_MESSAGES])
self.assertEqual(len(informs), NO_HELP_MESSAGES)
@tornado.testing.gen_test
def test_disconnect_cleanup(self):
yield self.client.until_protocol()
mid = 55
future_reply = self.client.future_request(Message.request(
'slow-command', 1, mid=mid))
# Force a disconnect
self.client._disconnect()
reply, informs = yield future_reply
self.assertEqual(reply, Message.reply(
'slow-command', 'fail', 'Connection closed before reply was received',
mid=mid))
@tornado.testing.gen_test
def test_stop_cleanup(self):
yield self.client.until_protocol()
mid = 564
future_reply = self.client.future_request(Message.request(
'slow-command', 1, mid=mid))
# Stop client
self.client.stop()
reply, informs = yield future_reply
self.assertEqual(reply, Message.reply(
'slow-command', 'fail', 'Client stopped before reply was received', mid=mid))
class test_AsyncClientIntegratedBase(TimewarpAsyncTestCase):
def setUp(self):
super(test_AsyncClientIntegratedBase, self).setUp()
self.server = DeviceTestServer('localhost', 0)
self.server.set_ioloop(self.io_loop)
self.server.set_concurrency_options(thread_safe=False,
handler_thread=False)
self.server.start()
host, port = self.server.bind_address
logger.info('host, port: {}:{}'.format(host, port))
self.client = katcp.CallbackClient(host, port)
self.client.set_ioloop(self.io_loop)
class test_AsyncClientTimeoutsIntegrated(TimewarpAsyncTestCase):
def setUp(self):
super(test_AsyncClientTimeoutsIntegrated, self).setUp()
self.server = DeviceTestServer('', 0)
self.server.set_ioloop(self.io_loop)
self.server.set_concurrency_options(thread_safe=False, handler_thread=False)
self.server.start()
host, port = self.server.bind_address
self.client = katcp.CallbackClient(host, port)
self.client.set_ioloop(self.io_loop)
self.client.start()
@tornado.testing.gen_test(timeout=10)
# We are using time-warping, so the timeout should be longer than the fake-duration
def test_future_request_default_timeout(self):
# Test the default timeout of 5s
yield self._test_timeout(5)
@tornado.testing.gen_test()
def test_future_request_change_default_timeout(self):
self.client._request_timeout = 3
yield self._test_timeout(3)
@tornado.testing.gen_test()
def test_future_request_request_timeout(self):
yield self._test_timeout(1, set_request_timeout=True)
@gen.coroutine
def _test_timeout(self, timeout, set_request_timeout=False):
request_timeout = timeout if set_request_timeout else None
yield self.client.until_connected()
t0 = self.io_loop.time()
reply_future = self.client.future_request(Message.request('slow-command', timeout + 1),
timeout=request_timeout)
# Warp to just before the timeout expires and check that the future is not yet
# resolved
self.set_ioloop_time(t0 + timeout*0.9999)
yield self.wake_ioloop()
self.assertFalse(reply_future.done())
# Warp to just after the timeout expires, and check that it gives us a timeout
# error reply
self.set_ioloop_time(t0 + timeout*1.0001)
yield self.wake_ioloop()
self.assertTrue(reply_future.done())
reply, informs = reply_future.result()
self.assertFalse(reply.reply_ok())
self.assertRegexpMatches(
reply.arguments[1],
r"Request slow-command timed out after .* seconds.")
class test_AsyncClientIntegrated(tornado.testing.AsyncTestCase, TestUtilMixin):
def setUp(self):
super(test_AsyncClientIntegrated, self).setUp()
self.server = DeviceTestServer('', 0)
self.server.set_ioloop(self.io_loop)
self.server.set_concurrency_options(thread_safe=False,
handler_thread=False)
self.server.start()
host, port = self.server.bind_address
self.client = katcp.CallbackClient(host, port)
self.client.set_ioloop(self.io_loop)
self.client.start()
@tornado.testing.gen_test
def test_timeout_of_until_connected(self):
# Test for timing out
with self.assertRaises(tornado.gen.TimeoutError):
yield self.client.until_connected(timeout=0.0001)
# Test for NOT timing out
host, port = self.server.bind_address
client2 = katcp.CallbackClient(host, port)
client2.set_ioloop(self.io_loop)
client2.start()
yield client2.until_connected(timeout=0.5)
self.assertTrue(client2.is_connected)
@tornado.testing.gen_test
def test_timeout_of_until_protocol(self):
# Test for timing out
with self.assertRaises(tornado.gen.TimeoutError):
yield self.client.until_protocol(timeout=0.0001)
# Test for NOT timing out
host, port = self.server.bind_address
client2 = katcp.CallbackClient(host, port)
client2.set_ioloop(self.io_loop)
client2.start()
yield client2.until_protocol(timeout=0.5)
@tornado.testing.gen_test
def test_future_request_simple(self):
yield self.client.until_connected()
reply, informs = yield self.client.future_request(
Message.request('watchdog'))
self.assertEqual(len(informs), 0)
self.assertEqual(reply.name, "watchdog")
self.assertEqual(reply.arguments, ["ok"])
@tornado.testing.gen_test
def test_future_request_with_informs(self):
yield self.client.until_connected()
reply, informs = yield self.client.future_request(
Message.request('help'))
self.assertEqual(reply.name, "help")
self.assertEqual(reply.arguments, ["ok", "%d" % NO_HELP_MESSAGES])
self.assertEqual(len(informs), NO_HELP_MESSAGES)
@tornado.testing.gen_test
def test_disconnect_cleanup(self):
yield self.client.until_protocol()
mid = 55
future_reply = self.client.future_request(
Message.request('slow-command', 1, mid=mid))
# Force a disconnect
self.client._disconnect()
reply, informs = yield future_reply
self.assertEqual(
reply,
Message.reply('slow-command',
'fail',
'Connection closed before reply was received',
mid=mid))
@tornado.testing.gen_test
def test_stop_cleanup(self):
yield self.client.until_protocol()
mid = 564
future_reply = self.client.future_request(
Message.request('slow-command', 1, mid=mid))
# Stop client
self.client.stop()
reply, informs = yield future_reply
self.assertEqual(
reply,
Message.reply('slow-command',
'fail',
'Client stopped before reply was received',
mid=mid))
import tornado
import IPython
from katcp.testutils import DeviceTestServer
from katcp import resource_client, inspecting_client
log = logging.getLogger(__name__)
ioloop = tornado.ioloop.IOLoop.current()
d = DeviceTestServer("", 0)
d.set_concurrency_options(False, False)
d.set_ioloop(ioloop)
ioloop.add_callback(d.start)
def setup_resource_client():
global rc
print d.bind_address
rc = resource_client.KATCPClientResource(dict(name="thething", address=d.bind_address, controlled=True))
rc.start()
def printy(*args):
print args
@tornado.gen.coroutine
import tornado
import IPython
from katcp.testutils import DeviceTestServer
from katcp import resource_client, inspecting_client
log = logging.getLogger(__name__)
ioloop = tornado.ioloop.IOLoop.current()
d = DeviceTestServer('', 0)
d.set_concurrency_options(False, False)
d.set_ioloop(ioloop)
ioloop.add_callback(d.start)
def setup_resource_client():
global rc
print d.bind_address
rc = resource_client.KATCPClientResource(dict(
name='thething',
address=d.bind_address,
controlled=True
))
rc.start()
def printy(*args):
print args
