def test_run_application_sendfile(self):
mock_file = unittest.mock.Mock()
mock_app = unittest.mock.AsyncMock()
mock_app.return_value = wsgi.FileWrapper(mock_file)
session = wsgi.HttpSession(None, mock_app, {})
context = wsgi._ApplicationContext()
run_task = tasks.spawn(session._run_application(context, {}))
get_task = tasks.spawn(self.get_body_chunks(context))
kernels.run(timeout=0.01)
self.assertTrue(context._chunks.is_closed())
self.assertTrue(run_task.is_completed())
run_task.get_result_nonblocking()
self.assertTrue(get_task.is_completed())
self.assertEqual(get_task.get_result_nonblocking(), [])
self.assertIs(context.file, mock_file)
# `close` is not called because ownership is transferred to
# context.
mock_file.close.assert_not_called()
def do_test(s0, s1):
m0 = nng.Message(b'hello world')
t0 = tasks.spawn(s0.sendmsg(m0))
t1 = tasks.spawn(s1.recv())
kernels.run(timeout=1)
self.assertTrue(t0.is_completed())
self.assertTrue(t1.is_completed())
self.assertEqual(t1.get_result_nonblocking(), b'hello world')
# Ownership is transferred on success.
self.assertIsNone(m0._msg_p)
def do_test(s0, s1):
t0 = tasks.spawn(s0.send(b'hello world'))
t1 = tasks.spawn(s1.recv())
kernels.run(timeout=1)
self.assertTrue(t0.is_completed())
self.assertTrue(t1.is_completed())
self.assertEqual(t1.get_result_nonblocking(), b'hello world')
t2 = tasks.spawn(s1.send(b'spam egg'))
t3 = tasks.spawn(s0.recv())
kernels.run(timeout=1)
self.assertTrue(t2.is_completed())
self.assertTrue(t3.is_completed())
self.assertEqual(t3.get_result_nonblocking(), b'spam egg')
async def _handle_request(self, environ, keep_alive):
# Check if client disables Keep-Alive explicitly.
connection = environ.get('HTTP_CONNECTION')
if connection is not None:
keep_alive = 'keep-alive' in connection.lower()
# At the moment we do not check any expectations (except those
# already in _RequestQueue), and just return HTTP 100 here.
if environ.get('HTTP_EXPECT', '').lower() == '100-continue':
await self._put_short_response(
http.HTTPStatus.CONTINUE, keep_alive
)
if not keep_alive:
raise _SessionExit
return
context = _ApplicationContext()
async with tasks.joining(
tasks.spawn(self._send_response(context, environ, keep_alive)),
always_cancel=True,
log_error=False, # We handle and log error below.
) as send_task, tasks.joining(
tasks.spawn(self._run_application(context, environ)),
always_cancel=True,
log_error=False, # We handle and log error below.
) as run_task:
async for task in tasks.as_completed([send_task, run_task]):
try:
task.get_result_nonblocking()
except self._EXIT_EXC_TYPES:
raise
except Exception:
if self._response_queue.has_begun():
LOG.exception(
'task crash after response starts sending: %r',
task,
)
raise _SessionExit from None
LOG.warning(
'task crash before response starts sending: %r',
task,
exc_info=True,
)
await self._put_short_response(
http.HTTPStatus.INTERNAL_SERVER_ERROR, keep_alive
)
if not keep_alive:
raise _SessionExit from None
break
def test_timeout(self):
with clients.Client(Request, Response, WIRE_DATA) as client:
client.socket.send_timeout = 1 # Unit: milliseconds.
client.socket.dial('inproc://%s' % uuid.uuid4())
task = tasks.spawn(client.m.greet(name='world'))
kernels.run(timeout=0.01)
self.assertTrue(task.is_completed())
with self.assertRaises(clients.ServerTimeoutError):
task.get_result_nonblocking()
task = tasks.spawn(
client.m.greet.on_timeout_return(42)(name='world'))
kernels.run(timeout=0.01)
self.assertTrue(task.is_completed())
self.assertEqual(task.get_result_nonblocking(), 42)
def test_timeout_other(self):
t = tasks.spawn(timers.sleep(100))
timers.timeout_after(0, task=t)
kernels.run(timeout=1)
self.assertTrue(t.is_completed())
with self.assertRaises(timers.Timeout):
t.get_result_nonblocking()
def main(_):
logging.basicConfig(level=logging.INFO)
start = time.perf_counter()
task = tasks.spawn(to_be_cancelled)
kernels.run(cancel_task(task))
elapsed = time.perf_counter() - start
print('total elapsed time: %.3f seconds' % elapsed)
return 0
def main(_):
start = time.perf_counter()
ts = [tasks.spawn(compute(i + 1)) for i in range(10)]
total = kernels.run(accumulate(ts))
elapsed = time.perf_counter() - start
print('result: %d' % total)
print('total elapsed time: %.3f seconds' % elapsed)
return 0
def test_already_closed_output(self):
q1 = queues.Queue()
q_out = queues.Queue()
q_out.close()
multiplexer_task = tasks.spawn(more_queues.multiplex([q1], q_out))
kernels.run(timeout=0.01)
self.assertTrue(multiplexer_task.is_completed())
self.assertIsNone(multiplexer_task.get_result_nonblocking())
def test_body_chunks(self):
chunks = []
async def get_body_chunks():
while True:
chunk = await self.context.get_body_chunk()
if not chunk:
break
chunks.append(chunk)
async def put_body_chunks():
await self.context.put_body_chunk(b'a')
await self.context.put_body_chunk(b'')
await self.context.put_body_chunk(b'b')
await self.context.put_body_chunk(b'')
await self.context.put_body_chunk(b'c')
put_task = tasks.spawn(put_body_chunks())
with self.assertRaises(kernels.KernelTimeout):
kernels.run(timeout=0.01)
self.assertEqual(chunks, [])
self.assertFalse(put_task.is_completed())
get_task = tasks.spawn(get_body_chunks())
with self.assertRaises(kernels.KernelTimeout):
kernels.run(timeout=0.01)
self.assertEqual(chunks, [b'a', b'b', b'c'])
self.assertTrue(put_task.is_completed())
self.assertFalse(get_task.is_completed())
self.context.end_body_chunks()
kernels.run(timeout=0.01)
self.assertEqual(chunks, [b'a', b'b', b'c'])
self.assertTrue(put_task.is_completed())
self.assertTrue(get_task.is_completed())
put_task.get_result_nonblocking()
get_task.get_result_nonblocking()
with self.assertRaisesRegex(
AssertionError,
r'expect .*UNDECIDED.*, not .*SEND:',
):
self.context.sendfile('foo')
async def _try_cache(self, cache, key, revalidate, request, kwargs):
task = cache.get(key)
if task is None:
task = cache[key] = tasks.spawn(self(request, **kwargs))
result = 'miss'
elif revalidate:
task = cache[key] = tasks.spawn(self(request, **kwargs))
result = 'revalidate'
else:
result = 'hit'
LOG.debug(
'send: cache %s: key=%r, %r, kwargs=%r', \
result, key, request, kwargs,
)
# Here is a risk that, if all task waiting for this task get
# cancelled before this task completes, this task might not
# be joined, but this risk is probably too small.
return await task.get_result()
def test_pubsub(self):
with contextlib.ExitStack() as stack:
wiredata = jsons.JsonWireData()
p_queue = queues.Queue()
s1_queue = queues.Queue()
s2_queue = queues.Queue()
publisher = stack.enter_context(
publishers.Publisher(p_queue, wiredata))
subscriber1 = stack.enter_context(
subscribers.Subscriber(Message, s1_queue, wiredata))
subscriber2 = stack.enter_context(
subscribers.Subscriber(Message, s2_queue, wiredata))
publisher.socket.listen('inproc://test_pubsub')
subscriber1.socket.dial('inproc://test_pubsub')
subscriber2.socket.dial('inproc://test_pubsub')
p_task = tasks.spawn(publisher.serve())
s1_task = tasks.spawn(subscriber1.serve())
s2_task = tasks.spawn(subscriber2.serve())
with self.assertRaises(kernels.KernelTimeout):
# Unfortunately this test is a somehow timing sensitive.
# If we remove this kernels.run call, the subscribers
# might sometimes not receive all messages.
kernels.run(timeout=0.01)
expect = (Message(content='hello'), Message(content='world'))
for message in expect:
publisher.publish_nonblocking(message)
self.assertFalse(s1_queue)
self.assertFalse(s2_queue)
with self.assertRaises(kernels.KernelTimeout):
kernels.run(timeout=0.01)
self.assertEqual(len(s1_queue), 2)
self.assertEqual(len(s2_queue), 2)
for message in expect:
self.assertEqual(s1_queue.get_nonblocking(), message)
self.assertEqual(s2_queue.get_nonblocking(), message)
publisher.shutdown()
subscriber1.shutdown()
subscriber2.shutdown()
kernels.run(timeout=0.01)
self.assertIsNone(p_task.get_result_nonblocking())
self.assertIsNone(s1_task.get_result_nonblocking())
self.assertIsNone(s2_task.get_result_nonblocking())
def test_run_application_non_aiter(self):
mock_app = unittest.mock.AsyncMock()
mock_app.return_value = [b'x', b'', b'', b'', b'y']
session = wsgi.HttpSession(None, mock_app, {})
context = wsgi._ApplicationContext()
run_task = tasks.spawn(session._run_application(context, {}))
get_task = tasks.spawn(self.get_body_chunks(context))
kernels.run(timeout=0.01)
self.assertTrue(context._chunks.is_closed())
self.assertTrue(run_task.is_completed())
run_task.get_result_nonblocking()
self.assertTrue(get_task.is_completed())
self.assertEqual(get_task.get_result_nonblocking(), [b'x', b'y'])
def do_test(s0):
m0 = nng.Message(b'hello world')
t0 = tasks.spawn(s0.sendmsg(m0))
t0.cancel()
kernels.run(timeout=1)
self.assertTrue(t0.is_completed())
self.assertIsInstance(t0.get_exception_nonblocking(),
tasks.Cancelled)
# Ownership was not transferred.
self.assertIsNotNone(m0._msg_p)
def test_dialer_start(self):
with contextlib.ExitStack() as stack:
url = 'inproc://%s' % uuid.uuid4()
s1 = stack.enter_context(asyncs.Socket(nng.Protocols.REP0))
s1.listen(url)
s0 = stack.enter_context(asyncs.Socket(nng.Protocols.REQ0))
d = s0.dial(url, create_only=True)
d.start()
t0 = tasks.spawn(s0.send(b'hello world'))
t1 = tasks.spawn(s1.recv())
kernels.run(timeout=1)
self.assertTrue(t0.is_completed())
self.assertTrue(t1.is_completed())
self.assertEqual(t1.get_result_nonblocking(), b'hello world')
d = s0.dial('inproc://%s' % uuid.uuid4())
with self.assertRaises(nng.Errors.ESTATE):
d.start()
def test_closed_output(self):
q1 = queues.Queue()
q_out = queues.Queue()
multiplexer_task = tasks.spawn(more_queues.multiplex([q1], q_out))
with self.assertRaises(kernels.KernelTimeout):
kernels.run(timeout=0.01)
q1.put_nonblocking('x')
q_out.close()
kernels.run(timeout=0.01)
self.assertEqual(get_many(q1), ['x'])
self.assertEqual(get_many(q_out), [])
self.assertTrue(multiplexer_task.is_completed())
self.assertIsNone(multiplexer_task.get_result_nonblocking())
def do_test_headers_sent_blocking(self, make_coro):
def assert_begin_but_not_sent():
self.assertEqual(self.response_queue.has_begun(), True)
self.assertEqual(self.response_queue._has_begun, True)
self.assertEqual(self.response_queue._headers_sent.is_set(), False)
block_send = locks.Event()
async def mock_send(data):
del data # Unused.
await block_send.wait()
return 1
self.mock_sock.send.side_effect = mock_send
self.mock_sock.sendfile.side_effect = mock_send
begin_task = tasks.spawn(
self.response_queue.begin(http.HTTPStatus.OK, []))
with self.assertRaises(kernels.KernelTimeout):
kernels.run(timeout=0.01)
assert_begin_but_not_sent()
self.assertFalse(begin_task.is_completed())
send_task = tasks.spawn(make_coro())
with self.assertRaises(kernels.KernelTimeout):
kernels.run(timeout=0.01)
assert_begin_but_not_sent()
self.assertFalse(begin_task.is_completed())
self.assertFalse(send_task.is_completed())
block_send.set()
kernels.run(timeout=0.01)
self.assert_begin(True)
self.assertTrue(begin_task.is_completed())
self.assertTrue(send_task.is_completed())
begin_task.get_result_nonblocking()
send_task.get_result_nonblocking()
def test_run_application_aiter(self):
class MockBody:
def __init__(self):
self._iter = iter([b'x', b'', b'', b'', b'y'])
self.closed = False
def __aiter__(self):
return self
async def __anext__(self):
try:
return next(self._iter)
except StopIteration:
raise StopAsyncIteration from None
def close(self):
self.closed = True
mock_body = MockBody()
mock_app = unittest.mock.AsyncMock()
mock_app.side_effect = [mock_body]
session = wsgi.HttpSession(None, mock_app, {})
context = wsgi._ApplicationContext()
run_task = tasks.spawn(session._run_application(context, {}))
get_task = tasks.spawn(self.get_body_chunks(context))
kernels.run(timeout=0.01)
self.assertTrue(mock_body.closed)
self.assertTrue(context._chunks.is_closed())
self.assertTrue(run_task.is_completed())
run_task.get_result_nonblocking()
self.assertTrue(get_task.is_completed())
self.assertEqual(get_task.get_result_nonblocking(), [b'x', b'y'])
def main(
args: asyncs.LABELS.args,
stub: LABELS.stub.stub,
supervise_agents: g1.asyncs.agents.parts.LABELS.supervise_agents,
graceful_exit: g1.asyncs.agents.parts.LABELS.graceful_exit,
):
supervisor_task = tasks.spawn(supervise_agents)
request = clients.Request('GET', args.url)
response = kernels.run(stub.send(request, priority=0))
for link in response.html().xpath('//a'):
print(link.get('href'))
graceful_exit.set()
kernels.run(supervisor_task.get_result())
return 0
def do_test(client, server, server_serve):
url = 'inproc://%s' % uuid.uuid4()
server.socket.listen(url)
client.socket.dial(url)
server_task = tasks.spawn(server_serve)
client_task = tasks.spawn(client.m.greet(name='world'))
with self.assertRaises(kernels.KernelTimeout):
kernels.run(timeout=0.005)
self.assertTrue(client_task.is_completed())
self.assertEqual(client_task.get_result_nonblocking(),
'Hello, world')
self.assertFalse(server_task.is_completed())
server.socket.close()
kernels.run(timeout=1)
self.assertTrue(server_task.is_completed())
self.assertIsNone(server_task.get_result_nonblocking())
def test_linger_on(self):
quit_handler = locks.Event()
handler_completed = locks.Event()
async def handler(request, response):
del request
response.headers['Content-Type'] = 'text/plain'
await response.write(b'hello world')
response.close()
await quit_handler.wait()
handler_completed.set()
async def get_content(content_iterator):
content = []
async for data in content_iterator:
content.append(data)
if not content:
return None
else:
return b''.join(content)
app = wsgi_apps.Application(handler)
app_task = tasks.spawn(app(self.ENVIRON, self.start_response_mock))
with self.assertRaises(kernels.KernelTimeout):
kernels.run(timeout=0.01)
self.assertTrue(app_task.is_completed())
self.assertFalse(handler_completed.is_set())
self.start_response_mock.assert_called_once_with(
'200 OK',
[('Content-Type', 'text/plain')],
)
self.assertEqual(
kernels.run(
get_content(app_task.get_result_nonblocking()),
timeout=0.01,
),
b'hello world',
)
# Handler lingers on after application completes.
self.assertFalse(handler_completed.is_set())
quit_handler.set()
kernels.run(timeout=0.01)
self.assertTrue(handler_completed.is_set())
app.shutdown()
kernels.run(app.serve(), timeout=0.01)
def test_grace_period_exceeded(self):
self.graceful_exit.set()
sleep_task = self.agent_queue.spawn(timers.sleep(99))
self.assert_state(False, 1, True, [])
self.main_task = tasks.spawn(
agents.supervise_agents(self.agent_queue, self.graceful_exit, 0))
kernels.run(timeout=0.01)
self.assert_state(True, 0, True, [r'graceful exit: requested by user'])
with self.assertRaisesRegex(
agents.SupervisorError,
r'grace period exceeded',
):
self.main_task.get_result_nonblocking()
with self.assertRaises(tasks.Cancelled):
sleep_task.get_result_nonblocking()
self.assertFalse(tasks.get_all_tasks())
def test_invalid_response(self):
with clients.Client(Request, Response, WIRE_DATA) as client:
with nng.Socket(nng.Protocols.REP0) as socket:
url = 'inproc://%s' % uuid.uuid4()
socket.listen(url)
client.socket.dial(url)
task = tasks.spawn(client.m.greet(name='world'))
with self.assertRaises(kernels.KernelTimeout):
kernels.run(timeout=0)
socket.recv()
socket.send(b'{"result": {"greet": 42}, "error": null}')
kernels.run(timeout=1)
self.assertTrue(task.is_completed())
with self.assertRaisesRegex(AssertionError, r'expect.*str'):
task.get_result_nonblocking()
def test_multiplex(self):
q1 = queues.Queue()
q2 = queues.Queue()
q_out = queues.Queue()
multiplexer_task = tasks.spawn(more_queues.multiplex([q1, q2], q_out))
q1.put_nonblocking('x')
with self.assertRaises(kernels.KernelTimeout):
kernels.run(timeout=0.01)
self.assertEqual(get_many(q_out), ['x'])
q2.put_nonblocking('a')
q1.put_nonblocking('y')
q2.put_nonblocking('b')
with self.assertRaises(kernels.KernelTimeout):
kernels.run(timeout=0.01)
# Hmmm... The order of q_out items depends on the internal
# implementation of multiplex. I am not sure whether this is a
# good test case.
self.assertEqual(get_many(q_out), ['a', 'y', 'b'])
q2.put_nonblocking('c')
q2.put_nonblocking('d')
q2.put_nonblocking('e')
with self.assertRaises(kernels.KernelTimeout):
kernels.run(timeout=0.01)
self.assertEqual(get_many(q_out), ['c', 'd', 'e'])
q2.close()
q1.put_nonblocking('z')
with self.assertRaises(kernels.KernelTimeout):
kernels.run(timeout=0.01)
self.assertEqual(get_many(q_out), ['z'])
self.assertFalse(multiplexer_task.is_completed())
q1.put_nonblocking('w')
q1.close()
kernels.run(timeout=0.01)
self.assertEqual(get_many(q_out), ['w'])
self.assertTrue(q_out.is_closed())
self.assertTrue(multiplexer_task.is_completed())
self.assertIsNone(multiplexer_task.get_result_nonblocking())
def test_success(self):
with clients.Client(Request, Response, WIRE_DATA) as client:
with nng.Socket(nng.Protocols.REP0) as socket:
url = 'inproc://%s' % uuid.uuid4()
socket.listen(url)
client.socket.dial(url)
task = tasks.spawn(client.m.greet(name='world'))
with self.assertRaises(kernels.KernelTimeout):
kernels.run(timeout=0)
request = WIRE_DATA.to_upper(Request, socket.recv())
self.assertEqual(request.args, Request.m.greet(name='world'))
response = Response(result=Response.Result(
greet='hello world'))
socket.send(WIRE_DATA.to_lower(response))
kernels.run(timeout=1)
self.assertTrue(task.is_completed())
self.assertEqual(task.get_result_nonblocking(), 'hello world')
def test_cancel(self):
q1 = queues.Queue()
q2 = queues.Queue()
q_out = queues.Queue(1)
multiplexer_task = tasks.spawn(more_queues.multiplex([q1, q2], q_out))
q1.put_nonblocking('x')
q1.put_nonblocking('y')
q2.put_nonblocking('a')
q2.put_nonblocking('b')
with self.assertRaises(kernels.KernelTimeout):
kernels.run(timeout=0.01)
multiplexer_task.cancel()
kernels.run(timeout=0.01)
self.assertTrue(multiplexer_task.is_completed())
self.assertIsInstance(multiplexer_task.get_exception_nonblocking(),
tasks.Cancelled)
self.assertTrue(q_out.is_closed())
# No input item is lost.
self.assertEqual(get_many(q1), ['y'])
self.assertEqual(get_many(q2), ['a', 'b'])
self.assertEqual(get_many(q_out), ['x'])
def test_send_response_put_body_chunks(self):
def make_context(status, headers, *body_chunks):
context = wsgi._ApplicationContext()
context._status = status
context._headers = headers
context._chunks = queues.Queue() # Unset capacity for test.
for chunk in body_chunks:
context._chunks.put_nonblocking(chunk)
context.end_body_chunks()
return context
session = wsgi.HttpSession(self.mock_sock, None, {})
for (
context,
keep_alive,
expect_data_per_call,
expect_not_session_exit,
) in [
# header: none ; body: none ; omit_body: false
(
make_context(http.HTTPStatus.OK, []),
True,
[
b'HTTP/1.1 200 OK\r\n'
b'Connection: keep-alive\r\n'
b'Content-Length: 0\r\n'
b'\r\n',
],
True,
),
# header: custom ; body: one chunk ; omit_body: false
(
make_context(http.HTTPStatus.NOT_FOUND, [(b'x', b'y')],
b'foo bar'),
False,
[
b'HTTP/1.1 404 Not Found\r\n'
b'x: y\r\n'
b'Connection: close\r\n'
b'Content-Length: 7\r\n'
b'\r\n',
b'foo bar',
],
False,
),
# header: connection ; body: multiple chunks ; omit_body: false
(
make_context(
http.HTTPStatus.OK,
[(b'connection', b'KeeP-Alive')],
b'spam',
b' ',
b'egg',
),
False,
[
b'HTTP/1.1 200 OK\r\n'
b'connection: KeeP-Alive\r\n'
b'Content-Length: 8\r\n'
b'\r\n',
b'spam',
b' ',
b'egg',
],
True,
),
# header: connection, content-length ; body: multiple chunks
# omit_body: false
(
make_context(
http.HTTPStatus.OK,
[(b'Connection', b'close'), (b'cOnTeNt-LeNgTh', b'8')],
b'spam',
b' ',
b'egg',
),
True,
[
b'HTTP/1.1 200 OK\r\n'
b'Connection: close\r\n'
b'cOnTeNt-LeNgTh: 8\r\n'
b'\r\n',
b'spam',
b' ',
b'egg',
],
False,
),
# header: none ; body: multiple chunks
# omit_body: true
(
make_context(http.HTTPStatus.NOT_MODIFIED, [], b'x', b' ',
b'y'),
True,
[
b'HTTP/1.1 304 Not Modified\r\n'
b'Connection: keep-alive\r\n'
b'Content-Length: 3\r\n'
b'\r\n',
],
True,
),
# header: wrong content-length; body: multiple chunks
# omit_body: false
(
make_context(
http.HTTPStatus.OK,
[(b'content-length', b'8')],
b'a',
b' ',
b'b',
),
True,
[
b'HTTP/1.1 200 OK\r\n'
b'content-length: 8\r\n'
b'Connection: keep-alive\r\n'
b'\r\n',
b'a',
b' ',
b'b',
],
False,
),
]:
with self.subTest((
context,
keep_alive,
expect_data_per_call,
expect_not_session_exit,
)):
self.mock_sock.send.reset_mock()
send_task = tasks.spawn(
session._send_response(context, {}, keep_alive))
kernels.run(timeout=0.01)
self.assertTrue(send_task.is_completed())
if expect_not_session_exit:
send_task.get_result_nonblocking()
else:
with self.assertRaises(wsgi._SessionExit):
send_task.get_result_nonblocking()
self.assertTrue(context._is_committed)
self.assertFalse(session._response_queue._has_begun)
self.assertFalse(
session._response_queue._headers_sent.is_set())
self.assert_send(*expect_data_per_call)
self.mock_sock.sendfile.assert_not_called()
def test_send_response_sendfile(self, mock_os):
mock_file = unittest.mock.Mock()
mock_os.fstat.return_value.st_size = 99
self.mock_sock.sendfile.return_value = 99
def make_context(status, headers):
context = wsgi._ApplicationContext()
context._status = status
context._headers = headers
context.sendfile(mock_file)
context.end_body_chunks()
return context
session = wsgi.HttpSession(self.mock_sock, None, {})
for (
context,
expect_headers,
expect_not_session_exit,
) in [
# header: none
(
make_context(http.HTTPStatus.OK, []),
b'HTTP/1.1 200 OK\r\n'
b'Connection: keep-alive\r\n'
b'Content-Length: 99\r\n\r\n',
True,
),
# header: content-length
(
make_context(http.HTTPStatus.OK, [(b'cOnTeNt-LeNgTh', b'99')]),
b'HTTP/1.1 200 OK\r\n'
b'cOnTeNt-LeNgTh: 99\r\n'
b'Connection: keep-alive\r\n\r\n',
True,
),
# header: wrong content-length
(
make_context(http.HTTPStatus.OK, [(b'cOnTeNt-LeNgTh', b'10')]),
b'HTTP/1.1 200 OK\r\n'
b'cOnTeNt-LeNgTh: 10\r\n'
b'Connection: keep-alive\r\n\r\n',
False,
),
]:
with self.subTest((
context,
expect_headers,
expect_not_session_exit,
)):
self.mock_sock.reset_mock()
mock_file.reset_mock()
send_task = tasks.spawn(
session._send_response(context, {}, True))
kernels.run(timeout=0.01)
self.assertTrue(send_task.is_completed())
if expect_not_session_exit:
send_task.get_result_nonblocking()
else:
with self.assertRaises(wsgi._SessionExit):
send_task.get_result_nonblocking()
self.assertTrue(context._is_committed)
self.assertFalse(session._response_queue._has_begun)
self.assertFalse(
session._response_queue._headers_sent.is_set())
self.mock_sock.assert_has_calls([
unittest.mock.call.send(expect_headers),
unittest.mock.call.sendfile(mock_file),
])
mock_file.close.assert_called_once()
async def serve(self):
async for tagged_item in more_queues.select(
cluster_stub._queue for cluster_stub in self._cluster_stubs):
request, kwargs, future = tagged_item.item
future.set_result(
tasks.spawn(self._base_session.send(request, **kwargs)))
def test_state_transition(self):
def is_committed():
return (
self.response._precommit is None
and not self.response._body.is_closed()
)
def is_closed():
return self.response._body.is_closed()
self.assertTrue(self.response._send_mechanism_decided.is_set())
self.assertIsNone(self.response.file)
with self.assertRaisesRegex(
AssertionError,
r'expect .*UNDECIDED:.*, not .*SEND:',
):
self.response.sendfile('foo')
self.assertIsNone(self.response.file)
self.assertTrue(self.response.is_uncommitted())
self.assertFalse(is_committed())
self.assertFalse(is_closed())
self.start_response_mock.assert_not_called()
# Write to pre-commit buffer.
kernels.run(self.response.write(b'hello world'))
read_task = tasks.spawn(self.response.read)
with self.assertRaises(kernels.KernelTimeout):
kernels.run(timeout=0.01)
self.assertFalse(read_task.is_completed())
with self.assertRaisesRegex(AssertionError, r'expect false-value'):
self.response.err_after_commit(None)
self.response.commit()
self.assertFalse(self.response.is_uncommitted())
self.assertTrue(is_committed())
self.assertFalse(is_closed())
self.start_response_mock.assert_called_once_with('200 OK', [])
kernels.run(timeout=0.01)
self.assertTrue(read_task.is_completed())
self.assertEqual(
read_task.get_result_nonblocking(),
b'hello world',
)
# Repeated calls to commit has no effect.
self.start_response_mock.reset_mock()
self.response.commit()
self.start_response_mock.assert_not_called()
kernels.run(self.response.write(b'foo bar'))
self.assertEqual(
kernels.run(self.response.read, timeout=0.01),
b'foo bar',
)
self.response.close()
self.assertFalse(self.response.is_uncommitted())
self.assertFalse(is_committed())
self.assertTrue(is_closed())
with self.assertRaisesRegex(ValueError, r'response is closed'):
kernels.run(self.response.write(b'spam egg'))
