def wsgi_app(env, start):
start('200 OK', [('Content-Type', 'text/plain')])
f1 = tulip.Future(loop=self.loop)
f1.set_result(b'data')
fut = tulip.Future(loop=self.loop)
fut.set_result([f1])
return fut
def reset(ws):
global size, expected, connected, subscribed, sub_latch, run_latch, subscribers
size = int((yield from ws.recv()))
expected = size * size
connected = 0
subscribed = 0
sub_latch = tulip.Future()
run_latch = tulip.Future()
subscribers = [[set() for col in range(size)] for row in range(size)]
def test_ctor(self):
fut = tulip.Future(loop=self.loop)
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol, fut)
test_utils.run_briefly(self.loop)
self.assertIsNone(fut.result())
self.protocol.connection_made(tr)
self.proactor.recv.assert_called_with(self.sock, 4096)
def wait_for_blocker(blocker):
"""Run a recursive mainloop until blocker is triggered.
@param blocker: event to wait on
@type blocker: L{Blocker}
@since: 0.53"""
assert wait_for_blocker.x is None # Avoid recursion
loop = get_loop()
glib = loop.glib
if not blocker.happened:
def quitter():
yield blocker
if glib:
wait_for_blocker.x.quit()
else:
wait_for_blocker.x.set_result(None)
Task(quitter(), "quitter")
wait_for_blocker.x = glib.MainLoop() if glib else tulip.Future()
try:
logger.debug(_("Entering mainloop, waiting for %s"), blocker)
if glib:
wait_for_blocker.x.run()
else:
get_loop().run_until_complete(wait_for_blocker.x)
finally:
wait_for_blocker.x = None
assert blocker.happened, "Someone quit the main loop!"
check(blocker)
def run(loop, fut):
thread_loop = tulip.new_event_loop()
tulip.set_event_loop(thread_loop)
socks = thread_loop.run_until_complete(
thread_loop.start_serving(lambda: TestHttpServer(keep_alive=0.5),
host,
port,
ssl=sslcontext))
waiter = tulip.Future(loop=thread_loop)
loop.call_soon_threadsafe(
fut.set_result, (thread_loop, waiter, socks[0].getsockname()))
thread_loop.run_until_complete(waiter)
# close opened trnsports
for tr in transports:
tr.close()
run_briefly(thread_loop) # call close callbacks
for s in socks:
thread_loop.stop_serving(s)
thread_loop.stop()
thread_loop.close()
gc.collect()
def test_pause_resume(self):
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
futures = []
for msg in [b'data1', b'data2', b'data3', b'data4', b'']:
f = tulip.Future(loop=self.loop)
f.set_result(msg)
futures.append(f)
self.loop._proactor.recv.side_effect = futures
self.loop._run_once()
self.assertFalse(tr._paused)
self.loop._run_once()
self.protocol.data_received.assert_called_with(b'data1')
self.loop._run_once()
self.protocol.data_received.assert_called_with(b'data2')
tr.pause()
self.assertTrue(tr._paused)
for i in range(10):
self.loop._run_once()
self.protocol.data_received.assert_called_with(b'data2')
tr.resume()
self.assertFalse(tr._paused)
self.loop._run_once()
self.protocol.data_received.assert_called_with(b'data3')
self.loop._run_once()
self.protocol.data_received.assert_called_with(b'data4')
tr.close()
def test_loop_writing_stop(self):
fut = tulip.Future(loop=self.loop)
fut.set_result(b'data')
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._write_fut = fut
tr._loop_writing(fut)
self.assertIsNone(tr._write_fut)
def test_ctor(self):
fut = tulip.Future(loop=self.loop)
tr = _ProactorSocketTransport(
self.loop, self.sock, self.protocol, fut)
self.loop.call_soon.mock_calls[0].assert_called_with(tr._loop_reading)
self.loop.call_soon.mock_calls[1].assert_called_with(
self.protocol.connection_made, tr)
self.loop.call_soon.mock_calls[2].assert_called_with(
fut.set_result, None)
def run_server(cls, host, port):
handler = StaticFilesHandler(get_internal_wsgi_application())
# Save the event loop for the thread in a class variable
# so we can unblock it when the tests are finished.
cls.server_thread_loop = tulip.new_event_loop()
tulip.set_event_loop(cls.server_thread_loop)
cls.server_stop = tulip.Future()
run(host, port, handler, cls.server_thread_loop, cls.server_stop)
cls.server_thread_loop.close()
def test_loop_reading_data(self):
res = tulip.Future(loop=self.loop)
res.set_result(b'data')
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._read_fut = res
tr._loop_reading(res)
self.loop._proactor.recv.assert_called_with(self.sock, 4096)
self.protocol.data_received.assert_called_with(b'data')
def test_loop_writing_closing(self):
fut = tulip.Future(loop=self.loop)
fut.set_result(1)
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
self.loop.reset_mock()
tr._write_fut = fut
tr.close()
tr._loop_writing(fut)
self.assertIsNone(tr._write_fut)
self.loop.call_soon.assert_called_with(tr._call_connection_lost, None)
def test_loop_writing_closing(self):
fut = tulip.Future(loop=self.loop)
fut.set_result(1)
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
tr._write_fut = fut
tr.close()
tr._loop_writing(fut)
self.assertIsNone(tr._write_fut)
test_utils.run_briefly(self.loop)
self.protocol.connection_lost.assert_called_with(None)
def test_create_server_cancel(self):
pf = unittest.mock.Mock()
call_soon = self.loop.call_soon = unittest.mock.Mock()
self.loop._start_serving(pf, self.sock)
loop = call_soon.call_args[0][0]
# cancelled
fut = tulip.Future(loop=self.loop)
fut.cancel()
loop(fut)
self.assertTrue(self.sock.close.called)
def test_write_eof_buffer(self):
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
f = tulip.Future(loop=self.loop)
tr._loop._proactor.send.return_value = f
tr.write(b'data')
tr.write_eof()
self.assertTrue(tr._eof_written)
self.assertFalse(self.sock.shutdown.called)
tr._loop._proactor.send.assert_called_with(self.sock, b'data')
f.set_result(4)
self.loop._run_once()
self.sock.shutdown.assert_called_with(socket.SHUT_WR)
tr.close()
def test_loop_reading_no_data(self):
res = tulip.Future(loop=self.loop)
res.set_result(b'')
tr = _ProactorSocketTransport(self.loop, self.sock, self.protocol)
self.assertRaises(AssertionError, tr._loop_reading, res)
tr.close = unittest.mock.Mock()
tr._read_fut = res
tr._loop_reading(res)
self.assertFalse(self.loop._proactor.recv.called)
self.assertTrue(self.protocol.eof_received.called)
self.assertTrue(tr.close.called)
def run_test_server(loop,
*,
host='127.0.0.1',
port=0,
use_ssl=False,
router=None):
properties = {}
transports = []
class HttpServer:
def __init__(self, host, port):
self.host = host
self.port = port
self.address = (host, port)
self._url = '{}://{}:{}'.format('https' if use_ssl else 'http',
host, port)
def __getitem__(self, key):
return properties[key]
def __setitem__(self, key, value):
properties[key] = value
def url(self, *suffix):
return urllib.parse.urljoin(self._url,
'/'.join(str(s) for s in suffix))
class TestHttpServer(tulip.http.ServerHttpProtocol):
def connection_made(self, transport):
transports.append(transport)
super().connection_made(transport)
def handle_request(self, message, payload):
if properties.get('close', False):
return
if properties.get('noresponse', False):
yield from tulip.sleep(99999)
if router is not None:
body = bytearray()
chunk = yield from payload.read()
while chunk:
body.extend(chunk)
chunk = yield from payload.read()
rob = router(self, properties, self.transport, message,
bytes(body))
rob.dispatch()
else:
response = tulip.http.Response(self.transport, 200,
message.version)
text = b'Test message'
response.add_header('Content-type', 'text/plain')
response.add_header('Content-length', str(len(text)))
response.send_headers()
response.write(text)
response.write_eof()
if use_ssl:
here = os.path.join(os.path.dirname(__file__), '..', 'tests')
keyfile = os.path.join(here, 'sample.key')
certfile = os.path.join(here, 'sample.crt')
sslcontext = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
sslcontext.load_cert_chain(certfile, keyfile)
else:
sslcontext = None
def run(loop, fut):
thread_loop = tulip.new_event_loop()
tulip.set_event_loop(thread_loop)
socks = thread_loop.run_until_complete(
thread_loop.start_serving(lambda: TestHttpServer(keep_alive=0.5),
host,
port,
ssl=sslcontext))
waiter = tulip.Future(loop=thread_loop)
loop.call_soon_threadsafe(
fut.set_result, (thread_loop, waiter, socks[0].getsockname()))
thread_loop.run_until_complete(waiter)
# close opened trnsports
for tr in transports:
tr.close()
run_briefly(thread_loop) # call close callbacks
for s in socks:
thread_loop.stop_serving(s)
thread_loop.stop()
thread_loop.close()
gc.collect()
fut = tulip.Future(loop=loop)
server_thread = threading.Thread(target=run, args=(loop, fut))
server_thread.start()
thread_loop, waiter, addr = loop.run_until_complete(fut)
try:
yield HttpServer(*addr)
finally:
thread_loop.call_soon_threadsafe(waiter.set_result, None)
server_thread.join()
def __init__(self):
self.future = tulip.Future()
def async_func(value):
p = tulip.Future()
loop.call_later(0.01, p.set_result, value)
return p