def test_start(self, ResponseImpl):
req = self.make_request('GET', '/')
resp = StreamResponse()
msg = resp.start(req)
self.assertTrue(msg.send_headers.called)
self.assertIs(msg, resp.start(req))
def test_keep_alive_http09(self):
headers = CIMultiDict(Connection='keep-alive')
message = RawRequestMessage('GET', '/', HttpVersion(0, 9), headers,
False, False)
req = self.request_from_message(message)
resp = StreamResponse()
resp.start(req)
self.assertFalse(resp.keep_alive)
def test_keep_alive_http09(self):
headers = CIMultiDict(Connection='keep-alive')
message = RawRequestMessage('GET', '/', HttpVersion(0, 9), headers,
False, False)
req = self.request_from_message(message)
resp = StreamResponse()
resp.start(req)
self.assertFalse(resp.keep_alive)
def hello(request):
resp = StreamResponse()
name = request.match_info.get('name', 'Anonymous')
answer = ('Hello, ' + name).encode('utf8')
resp.content_length = len(answer)
resp.start(request)
resp.write(answer)
yield from resp.write_eof()
return resp
def hello(request):
resp = StreamResponse()
name = request.match_info.get('name', 'Anonymous')
answer = ('Hello, ' + name).encode('utf8')
resp.content_length = len(answer)
resp.start(request)
resp.write(answer)
yield from resp.write_eof()
return resp
def test_chunked_encoding_forbidden_for_http_10(self):
req = self.make_request('GET', '/', version=HttpVersion10)
resp = StreamResponse()
resp.enable_chunked_encoding()
with self.assertRaisesRegex(
RuntimeError,
"Using chunked encoding is forbidden for HTTP/1.0"):
resp.start(req)
def intro(request):
txt = textwrap.dedent("""\
Type {url}/hello/John {url}/simple or {url}/change_body
in browser url bar
""").format(url='127.0.0.1:8080')
binary = txt.encode('utf8')
resp = StreamResponse()
resp.content_length = len(binary)
resp.start(request)
resp.write(binary)
return resp
def intro(request):
txt = textwrap.dedent("""\
Type {url}/hello/John {url}/simple or {url}/change_body
in browser url bar
""").format(url='127.0.0.1:8080')
binary = txt.encode('utf8')
resp = StreamResponse()
resp.content_length = len(binary)
resp.start(request)
resp.write(binary)
return resp
def test_cannot_write_eof_twice(self):
resp = StreamResponse()
resp.start(self.make_request('GET', '/'))
resp.write(b'data')
self.writer.drain.return_value = ()
self.loop.run_until_complete(resp.write_eof())
self.assertTrue(self.writer.write.called)
self.writer.write.reset_mock()
self.loop.run_until_complete(resp.write_eof())
self.assertFalse(self.writer.write.called)
def test_cannot_write_after_eof(self):
resp = StreamResponse()
resp.start(self.make_request('GET', '/'))
resp.write(b'data')
self.writer.drain.return_value = ()
self.loop.run_until_complete(resp.write_eof())
self.writer.write.reset_mock()
with self.assertRaises(RuntimeError):
resp.write(b'next data')
self.assertFalse(self.writer.write.called)
def test_cannot_write_after_eof(self):
resp = StreamResponse()
resp.start(self.make_request('GET', '/'))
resp.write(b'data')
self.writer.drain.return_value = ()
self.loop.run_until_complete(resp.write_eof())
self.writer.write.reset_mock()
with self.assertRaises(RuntimeError):
resp.write(b'next data')
self.assertFalse(self.writer.write.called)
def test_cannot_write_eof_twice(self):
resp = StreamResponse()
resp.start(self.make_request('GET', '/'))
resp.write(b'data')
self.writer.drain.return_value = ()
self.loop.run_until_complete(resp.write_eof())
self.assertTrue(self.writer.write.called)
self.writer.write.reset_mock()
self.loop.run_until_complete(resp.write_eof())
self.assertFalse(self.writer.write.called)
def test_keep_alive_http10(self):
message = RawRequestMessage('GET', '/', HttpVersion10, CIMultiDict(),
True, False)
req = self.request_from_message(message)
resp = StreamResponse()
resp.start(req)
self.assertFalse(resp.keep_alive)
headers = CIMultiDict(Connection='keep-alive')
message = RawRequestMessage('GET', '/', HttpVersion10, headers,
False, False)
req = self.request_from_message(message)
resp = StreamResponse()
resp.start(req)
self.assertEqual(resp.keep_alive, True)
def test_keep_alive_http10(self):
message = RawRequestMessage('GET', '/', HttpVersion10, CIMultiDict(),
True, False)
req = self.request_from_message(message)
resp = StreamResponse()
resp.start(req)
self.assertFalse(resp.keep_alive)
headers = CIMultiDict(Connection='keep-alive')
message = RawRequestMessage('GET', '/', HttpVersion10, headers, False,
False)
req = self.request_from_message(message)
resp = StreamResponse()
resp.start(req)
self.assertEqual(resp.keep_alive, True)
def test_start(self, ResponseImpl):
req = self.make_request('GET', '/')
resp = StreamResponse()
self.assertIsNone(resp.keep_alive)
msg = resp.start(req)
self.assertTrue(msg.send_headers.called)
self.assertIs(msg, resp.start(req))
self.assertTrue(resp.keep_alive)
req2 = self.make_request('GET', '/')
with self.assertRaises(RuntimeError):
resp.start(req2)
def test_start(self, ResponseImpl):
req = self.make_request('GET', '/')
resp = StreamResponse()
self.assertIsNone(resp.keep_alive)
msg = resp.start(req)
self.assertTrue(msg.send_headers.called)
self.assertIs(msg, resp.start(req))
self.assertTrue(resp.keep_alive)
req2 = self.make_request('GET', '/')
with self.assertRaises(RuntimeError):
resp.start(req2)
def test_start_twice(self, ResponseImpl):
req = self.make_request("GET", "/")
resp = StreamResponse()
with self.assertWarns(DeprecationWarning):
impl1 = resp.start(req)
impl2 = resp.start(req)
self.assertIs(impl1, impl2)
def test_start_twice(self, ResponseImpl):
req = self.make_request('GET', '/')
resp = StreamResponse()
with self.assertWarns(DeprecationWarning):
impl1 = resp.start(req)
impl2 = resp.start(req)
self.assertIs(impl1, impl2)
def test_start_twice(warning):
req = make_request('GET', '/')
resp = StreamResponse()
with warning(DeprecationWarning):
impl1 = resp.start(req)
impl2 = resp.start(req)
assert impl1 is impl2
def test_start_twice(warning):
req = make_request('GET', '/')
resp = StreamResponse()
with warning(DeprecationWarning):
impl1 = resp.start(req)
impl2 = resp.start(req)
assert impl1 is impl2
def test_start_force_close(self):
req = self.make_request('GET', '/')
resp = StreamResponse()
resp.force_close()
self.assertFalse(resp.keep_alive)
msg = resp.start(req)
self.assertFalse(resp.keep_alive)
self.assertTrue(msg.closing)
def test_start_force_close(self):
req = self.make_request('GET', '/')
resp = StreamResponse()
resp.force_close()
self.assertFalse(resp.keep_alive)
msg = resp.start(req)
self.assertFalse(resp.keep_alive)
self.assertTrue(msg.closing)
def test_force_compression_no_accept_gzip(self, ResponseImpl):
req = self.make_request('GET', '/')
resp = StreamResponse()
resp.enable_compression(ContentCoding.gzip)
self.assertTrue(resp.compression)
msg = resp.start(req)
msg.add_compression_filter.assert_called_with('gzip')
self.assertEqual('gzip', resp.headers.get(hdrs.CONTENT_ENCODING))
def test_force_compression_false_backwards_compat(self, ResponseImpl):
req = self.make_request('GET', '/')
resp = StreamResponse()
self.assertFalse(resp.compression)
resp.enable_compression(force=False)
self.assertTrue(resp.compression)
msg = resp.start(req)
self.assertFalse(msg.add_compression_filter.called)
def test_chunked_encoding(self, ResponseImpl):
req = self.make_request('GET', '/')
resp = StreamResponse()
self.assertFalse(resp.chunked)
resp.enable_chunked_encoding()
self.assertTrue(resp.chunked)
msg = resp.start(req)
self.assertTrue(msg.chunked)
def test_force_compression_false_backwards_compat(self, ResponseImpl):
req = self.make_request('GET', '/')
resp = StreamResponse()
self.assertFalse(resp.compression)
resp.enable_compression(force=False)
self.assertTrue(resp.compression)
msg = resp.start(req)
self.assertFalse(msg.add_compression_filter.called)
def test_force_compression_no_accept_gzip(self, ResponseImpl):
req = self.make_request('GET', '/')
resp = StreamResponse()
resp.enable_compression(ContentCoding.gzip)
self.assertTrue(resp.compression)
msg = resp.start(req)
msg.add_compression_filter.assert_called_with('gzip')
self.assertEqual('gzip', resp.headers.get(hdrs.CONTENT_ENCODING))
def test_chunked_encoding(self, ResponseImpl):
req = self.make_request('GET', '/')
resp = StreamResponse()
self.assertFalse(resp.chunked)
resp.enable_chunked_encoding()
self.assertTrue(resp.chunked)
msg = resp.start(req)
self.assertTrue(msg.chunked)
def test_compression_no_accept(self, ResponseImpl):
req = self.make_request('GET', '/')
resp = StreamResponse()
self.assertFalse(resp.chunked)
self.assertFalse(resp.compression)
resp.enable_compression()
self.assertTrue(resp.compression)
msg = resp.start(req)
self.assertFalse(msg.add_compression_filter.called)
def test_compression_no_accept(self, ResponseImpl):
req = self.make_request('GET', '/')
resp = StreamResponse()
self.assertFalse(resp.chunked)
self.assertFalse(resp.compression)
resp.enable_compression()
self.assertTrue(resp.compression)
msg = resp.start(req)
self.assertFalse(msg.add_compression_filter.called)
def test_chunk_size(self, ResponseImpl):
req = self.make_request('GET', '/')
resp = StreamResponse()
self.assertFalse(resp.chunked)
resp.enable_chunked_encoding(chunk_size=8192)
self.assertTrue(resp.chunked)
msg = resp.start(req)
self.assertTrue(msg.chunked)
msg.add_chunking_filter.assert_called_with(8192)
self.assertIsNotNone(msg.filter)
def test_force_compression_deflate(self, ResponseImpl):
req = self.make_request(
'GET', '/',
headers=CIMultiDict({hdrs.ACCEPT_ENCODING: 'gzip, deflate'}))
resp = StreamResponse()
resp.enable_compression(ContentCoding.deflate)
self.assertTrue(resp.compression)
msg = resp.start(req)
msg.add_compression_filter.assert_called_with('deflate')
self.assertEqual('deflate', resp.headers.get(hdrs.CONTENT_ENCODING))
def test_force_compression_deflate(self, ResponseImpl):
req = self.make_request(
'GET', '/',
headers=CIMultiDict({hdrs.ACCEPT_ENCODING: 'gzip, deflate'}))
resp = StreamResponse()
resp.enable_compression(ContentCoding.deflate)
self.assertTrue(resp.compression)
msg = resp.start(req)
msg.add_compression_filter.assert_called_with('deflate')
self.assertEqual('deflate', resp.headers.get(hdrs.CONTENT_ENCODING))
def test_chunk_size(self, ResponseImpl):
req = self.make_request('GET', '/')
resp = StreamResponse()
self.assertFalse(resp.chunked)
resp.enable_chunked_encoding(chunk_size=8192)
self.assertTrue(resp.chunked)
msg = resp.start(req)
self.assertTrue(msg.chunked)
msg.add_chunking_filter.assert_called_with(8192)
self.assertIsNotNone(msg.filter)
def test_compression(self, ResponseImpl):
req = self.make_request(
'GET', '/',
headers=CIMultiDict({hdrs.ACCEPT_ENCODING: 'gzip, deflate'}))
resp = StreamResponse()
self.assertFalse(resp.chunked)
self.assertFalse(resp.compression)
resp.enable_compression()
self.assertTrue(resp.compression)
msg = resp.start(req)
self.assertTrue(msg.add_compression_filter.called)
self.assertIsNotNone(msg.filter)
def test_compression(self, ResponseImpl):
req = self.make_request(
'GET', '/',
headers=CIMultiDict({hdrs.ACCEPT_ENCODING: 'gzip, deflate'}))
resp = StreamResponse()
self.assertFalse(resp.chunked)
self.assertFalse(resp.compression)
resp.enable_compression()
self.assertTrue(resp.compression)
msg = resp.start(req)
self.assertTrue(msg.add_compression_filter.called)
self.assertIsNotNone(msg.filter)
def test_compression_default_coding(self, ResponseImpl):
req = self.make_request(
'GET', '/',
headers=CIMultiDict({hdrs.ACCEPT_ENCODING: 'gzip, deflate'}))
resp = StreamResponse()
self.assertFalse(resp.chunked)
self.assertFalse(resp.compression)
resp.enable_compression()
self.assertTrue(resp.compression)
msg = resp.start(req)
msg.add_compression_filter.assert_called_with('deflate')
self.assertEqual('deflate', resp.headers.get(hdrs.CONTENT_ENCODING))
self.assertIsNotNone(msg.filter)
def test_compression_default_coding(self, ResponseImpl):
req = self.make_request(
'GET', '/',
headers=CIMultiDict({hdrs.ACCEPT_ENCODING: 'gzip, deflate'}))
resp = StreamResponse()
self.assertFalse(resp.chunked)
self.assertFalse(resp.compression)
resp.enable_compression()
self.assertTrue(resp.compression)
msg = resp.start(req)
msg.add_compression_filter.assert_called_with('deflate')
self.assertEqual('deflate', resp.headers.get(hdrs.CONTENT_ENCODING))
self.assertIsNotNone(msg.filter)
def test_write_non_byteish(self):
resp = StreamResponse()
resp.start(self.make_request('GET', '/'))
with self.assertRaises(TypeError):
resp.write(123)
def test_started_when_started(self):
resp = StreamResponse()
resp.start(self.make_request('GET', '/'))
self.assertTrue(resp.started)
class WSGIResponse:
__slots__ = (
"_handler",
"_request",
"_response",
)
def __init__(self, handler, request):
self._handler = handler
self._request = request
# State.
self._response = None
def start_response(self, status, headers, exc_info=None):
if exc_info:
# Log the error.
self._request.app.logger.error("Unexpected error",
exc_info=exc_info)
# Attempt to modify the response.
try:
if self._response and self._response.started:
raise exc_info[1].with_traceback(exc_info[2])
self._response = None
finally:
exc_info = None
# Cannot start response twice.
assert not self._response, "Cannot call start_response() twice"
# Parse the status.
assert isinstance(status, str), "Response status should be str"
status_code, reason = status.split(None, 1)
status_code = int(status_code)
# Store the response.
self._response = StreamResponse(
status=status_code,
reason=reason,
)
# Store the headers.
for header_name, header_value in headers:
assert not is_hop_by_hop(
header_name), "Hop-by-hop headers are forbidden"
self._response.headers.add(header_name, header_value)
# Return the stream writer interface.
return self.write_threadsafe
def _write_head(self):
assert self._response, "Application did not call start_response()"
if not self._response.started:
self._response.start(self._request)
def write(self, data):
assert isinstance(
data, (bytes, bytearray, memoryview)), "Data should be bytes"
self._write_head()
self._response.write(data)
@asyncio.coroutine
def drain(self):
self._write_head()
yield from self._response.drain()
@asyncio.coroutine
def write_eof(self):
self._write_head()
yield from self._response.write_eof()
def write_threadsafe(self, data):
with self._handler._lock_for_write():
self.write(data)
def test___repr__(self):
req = self.make_request('GET', '/path/to')
resp = StreamResponse(reason=301)
resp.start(req)
self.assertEqual("<StreamResponse 301 GET /path/to >", repr(resp))
def test_write_returns_drain(self):
resp = StreamResponse()
resp.start(self.make_request('GET', '/'))
self.assertEqual((), resp.write(b'data'))
def test_write_returns_empty_tuple_on_empty_data(self):
resp = StreamResponse()
resp.start(self.make_request('GET', '/'))
self.assertEqual((), resp.write(b''))
def test_write_returns_drain(self):
resp = StreamResponse()
resp.start(self.make_request('GET', '/'))
self.assertEqual((), resp.write(b'data'))
def test_write_returns_empty_tuple_on_empty_data(self):
resp = StreamResponse()
resp.start(self.make_request('GET', '/'))
self.assertEqual((), resp.write(b''))
def test_write_non_byteish(self):
resp = StreamResponse()
resp.start(self.make_request('GET', '/'))
with self.assertRaises(AssertionError):
resp.write(123)
def test___repr__(self):
req = self.make_request('GET', '/path/to')
resp = StreamResponse(reason=301)
resp.start(req)
self.assertEqual("<StreamResponse 301 GET /path/to >", repr(resp))
def test_started_when_started(self):
resp = StreamResponse()
resp.start(self.make_request('GET', '/'))
self.assertTrue(resp.started)
