def test_request_cookie__set_item(self):
headers = CIMultiDict(COOKIE='name=value')
req = self.make_request('GET', '/', headers=headers)
self.assertEqual(req.cookies, {'name': 'value'})
with self.assertRaises(TypeError):
req.cookies['my'] = 'value'
def test_request_cookie__set_item(make_request):
headers = CIMultiDict(COOKIE='name=value')
req = make_request('GET', '/', headers=headers)
assert req.cookies == {'name': 'value'}
with pytest.raises(TypeError):
req.cookies['my'] = 'value'
def test_request_cookie(self):
headers = CIMultiDict(COOKIE='cookie1=value1; cookie2=value2')
req = self.make_request('GET', '/', headers=headers)
self.assertEqual(req.cookies, {
'cookie1': 'value1',
'cookie2': 'value2',
})
def test_ctor_with_headers_and_status():
resp = Response(body=b'body', status=201, headers={'Age': '12'})
assert 201 == resp.status
assert b'body' == resp.body
assert 4 == resp.content_length
assert (CIMultiDict([('AGE', '12'),
('CONTENT-LENGTH', '4')]) == resp.headers)
def start(self, connection, read_until_eof=False):
nonlocal conn
conn = connection
self.status = 123
self.reason = 'Test OK'
self.headers = CIMultiDictProxy(CIMultiDict())
self.cookies = SimpleCookie()
return
def test_keep_alive_http09():
headers = CIMultiDict(Connection='keep-alive')
message = RawRequestMessage('GET', '/', HttpVersion(0, 9), headers,
[(b'Connection', b'keep-alive')], False, False)
req = request_from_message(message)
resp = StreamResponse()
yield from resp.prepare(req)
assert not resp.keep_alive
def test_response_ctor():
resp = Response()
assert 200 == resp.status
assert 'OK' == resp.reason
assert resp.body is None
assert 0 == resp.content_length
assert CIMultiDict([('CONTENT-LENGTH', '0')]) == resp.headers
def test_ctor_with_headers_and_status(self):
resp = Response(body=b'body', status=201, headers={'Age': '12'})
self.assertEqual(201, resp.status)
self.assertEqual(b'body', resp.body)
self.assertEqual(4, resp.content_length)
self.assertEqual(CIMultiDict([('AGE', '12'), ('CONTENT-LENGTH', '4')]),
resp.headers)
def test_ctor_content_type(self):
resp = Response(content_type='application/json')
self.assertEqual(200, resp.status)
self.assertEqual('OK', resp.reason)
self.assertEqual(
CIMultiDict([('CONTENT-TYPE', 'application/json'),
('CONTENT-LENGTH', '0')]), resp.headers)
def test_ctor(self):
resp = Response()
self.assertEqual(200, resp.status)
self.assertEqual('OK', resp.reason)
self.assertIsNone(resp.body)
self.assertEqual(0, resp.content_length)
self.assertEqual(CIMultiDict([('CONTENT-LENGTH', '0')]), resp.headers)
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_init_headers_list_of_tuples(self):
session = ClientSession(headers=[("h1", "header1"), ("h2", "header2"),
("h3", "header3")],
loop=self.loop)
self.assertEqual(
session._default_headers,
CIMultiDict([("h1", "header1"), ("h2", "header2"),
("h3", "header3")]))
session.close()
def make_request(method,
path,
headers=CIMultiDict(),
version=HttpVersion11,
**kwargs):
message = RawRequestMessage(method, path, version, headers,
[(k.encode('utf-8'), v.encode('utf-8'))
for k, v in headers.items()], False, False)
return request_from_message(message, **kwargs)
def test_init_headers_MultiDict(self):
session = ClientSession(headers=MultiDict([("h1", "header1"),
("h2", "header2"),
("h3", "header3")]),
loop=self.loop)
self.assertEqual(
session._default_headers,
CIMultiDict([("H1", "header1"), ("H2", "header2"),
("H3", "header3")]))
session.close()
def test_ctor_text():
resp = Response(text='test text')
assert 200 == resp.status
assert 'OK' == resp.reason
assert (CIMultiDict([('CONTENT-TYPE', 'text/plain; charset=utf-8'),
('CONTENT-LENGTH', '9')]) == resp.headers)
assert resp.body == b'test text'
assert resp.text == 'test text'
def make_request(self, method, path):
self.app = mock.Mock()
message = RawRequestMessage(method, path, HttpVersion(1, 1),
CIMultiDict(), False, False)
self.payload = mock.Mock()
self.transport = mock.Mock()
self.reader = mock.Mock()
self.writer = mock.Mock()
req = Request(self.app, message, self.payload, self.transport,
self.reader, self.writer)
return req
def make_request(self, app, method, path):
headers = CIMultiDict()
message = aiohttp.RawRequestMessage(method, path,
aiohttp.HttpVersion(1, 1), headers,
False, False)
self.payload = mock.Mock()
self.transport = mock.Mock()
self.writer = mock.Mock()
req = web.Request(app, message, self.payload, self.transport,
self.writer, 15)
return req
def test_ctor_text(self):
resp = Response(text='test text')
self.assertEqual(200, resp.status)
self.assertEqual('OK', resp.reason)
self.assertEqual(
CIMultiDict([('CONTENT-TYPE', 'text/plain; charset=utf-8'),
('CONTENT-LENGTH', '9')]), resp.headers)
self.assertEqual(resp.body, b'test text')
self.assertEqual(resp.text, 'test text')
def test_merge_headers_with_list_of_tuples(self):
session = ClientSession(headers={
"h1": "header1",
"h2": "header2"
},
loop=self.loop)
headers = session._prepare_headers([("h1", "h1")])
self.assertIsInstance(headers, CIMultiDict)
self.assertEqual(headers, CIMultiDict([("h2", "header2"),
("h1", "h1")]))
session.close()
def test_merge_headers(self):
# Check incoming simple dict
session = ClientSession(headers={
"h1": "header1",
"h2": "header2"
},
loop=self.loop)
headers = session._prepare_headers({"h1": "h1"})
self.assertIsInstance(headers, CIMultiDict)
self.assertEqual(headers, CIMultiDict([("h2", "header2"),
("h1", "h1")]))
session.close()
def _init_meta(self, request):
transport = self.__request.transport
remote_addr, remote_port = transport.get_extra_info("peername")
meta = CIMultiDict({
k.replace('-', '_'): v
for k, v in request.headers.items()})
peer_info = {
'REMOTE_ADDR': remote_addr,
"REMOTE_PORT": remote_port
}
meta.update(peer_info)
self.META = CIMultiDictProxy(meta)
def test_force_compression_gzip(self, ResponseImpl):
req = self.make_request(
'GET', '/',
headers=CIMultiDict({hdrs.ACCEPT_ENCODING: 'gzip, deflate'}))
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_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 = self.loop.run_until_complete(resp.prepare(req))
msg.add_compression_filter.assert_called_with('deflate')
self.assertEqual('deflate', resp.headers.get(hdrs.CONTENT_ENCODING))
def __init__(self,
request,
template_name,
context,
headers=None,
**kwargs):
if not headers:
headers = {}
headers = CIMultiDict(headers)
if 'Content-type' not in headers:
headers.update({'Content-type': 'text/html; charset=utf-8'})
body = render(request.app['loader'], template_name, context)
super().__init__(body=body.encode(), headers=headers, **kwargs)
def test_force_compression_gzip():
req = make_request('GET',
'/',
headers=CIMultiDict(
{hdrs.ACCEPT_ENCODING: 'gzip, deflate'}))
resp = StreamResponse()
resp.enable_compression(ContentCoding.gzip)
assert resp.compression
with mock.patch('aiohttp.web_reqrep.ResponseImpl'):
msg = yield from resp.prepare(req)
msg.add_compression_filter.assert_called_with('gzip')
assert 'gzip' == resp.headers.get(hdrs.CONTENT_ENCODING)
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_handler_returns_not_response(self):
app = web.Application(loop=self.loop)
def handler(request):
return 'abc'
app.router.add_route('GET', '/', handler)
h = app.make_handler()()
message = RawRequestMessage('GET', '/', HttpVersion11, CIMultiDict(),
False, False)
payload = mock.Mock()
with self.assertRaises(AssertionError):
self.loop.run_until_complete(h.handle_request(message, payload))
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 make_request(self,
method,
path,
headers=CIMultiDict(),
*,
version=HttpVersion(1, 1),
closing=False):
self.app = mock.Mock()
message = RawRequestMessage(method, path, version, headers, closing,
False)
self.payload = mock.Mock()
self.transport = mock.Mock()
self.writer = mock.Mock()
self.reader = mock.Mock()
req = Request(self.app, message, self.payload, self.transport,
self.reader, self.writer)
return req
def test_compression_default_coding():
req = make_request('GET',
'/',
headers=CIMultiDict(
{hdrs.ACCEPT_ENCODING: 'gzip, deflate'}))
resp = StreamResponse()
assert not resp.chunked
assert not resp.compression
resp.enable_compression()
assert resp.compression
with mock.patch('aiohttp.web_reqrep.ResponseImpl'):
msg = yield from resp.prepare(req)
msg.add_compression_filter.assert_called_with('deflate')
assert 'deflate' == resp.headers.get(hdrs.CONTENT_ENCODING)
assert msg.filter is not None
