def test_call_POST_on_weird_content_type(make_request):
req = make_request('POST',
'/',
headers=CIMultiDict({'CONTENT-TYPE':
'something/weird'}))
ret = yield from req.post()
assert CIMultiDict() == ret
def test_call_POST_on_weird_content_type(self):
req = self.make_request('POST',
'/',
headers=CIMultiDict(
{'CONTENT-TYPE': 'something/weird'}))
ret = self.loop.run_until_complete(req.post())
self.assertEqual(CIMultiDict(), ret)
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 prepare_request_params(self, service_desc, session, request_params):
headers = request_params.get('headers', CIMultiDict()).copy()
if not isinstance(headers, CIMultiDict):
headers = CIMultiDict(headers)
headers.update(self.default_headers)
headers.update(service_desc.get('headers', {}))
headers.update(request_params.get('headers', {}))
request_params['headers'] = headers
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 __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)
async def make_request(method, path, middlewares, cookies=None):
headers = CIMultiDict()
if cookies:
for key, value in cookies:
headers.add('Cookie', _cookie_value(key, value))
message = protocol.RawRequestMessage(method, path, protocol.HttpVersion11,
headers, True, False)
request = web.Request({}, message, EmptyStreamReader(), None, None, None)
if middlewares:
return await prepare_request(request, middlewares)
return request
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_merge_headers(create_session):
# Check incoming simple dict
session = create_session(headers={"h1": "header1", "h2": "header2"})
headers = session._prepare_headers({"h1": "h1"})
assert isinstance(headers, CIMultiDict)
assert headers == CIMultiDict([("h2", "header2"), ("h1", "h1")])
def test_ctor_content_type():
resp = Response(content_type='application/json')
assert 200 == resp.status
assert 'OK' == resp.reason
assert (CIMultiDict([('CONTENT-TYPE', 'application/json'),
('CONTENT-LENGTH', '0')]) == resp.headers)
def make_request(method,
path,
headers=CIMultiDict(),
version=HttpVersion11,
**kwargs):
message = RawRequestMessage(method, path, version, headers, False, False)
return request_from_message(message, **kwargs)
def test_keep_alive_http10_default():
message = RawRequestMessage('GET', '/', HttpVersion10, CIMultiDict(), True,
False)
req = request_from_message(message)
resp = StreamResponse()
yield from resp.prepare(req)
assert not resp.keep_alive
def test_init_headers_MultiDict(create_session):
session = create_session(
headers=MultiDict([("h1", "header1"), ("h2",
"header2"), ("h3", "header3")]))
assert (session._default_headers == CIMultiDict([("H1", "header1"),
("H2", "header2"),
("H3", "header3")]))
def make_request(self, method='GET', path='/', headers=CIMultiDict()):
self.app = mock.Mock()
message = RawRequestMessage(method, path, HttpVersion11, headers,
False, False)
req = Request(self.app, message, self.payload,
self.transport, self.reader, self.writer)
return req
def make_request(self,
method,
path,
headers=CIMultiDict(),
*,
version=HttpVersion(1, 1),
closing=False,
sslcontext=None,
secure_proxy_ssl_header=None):
if version < HttpVersion(1, 1):
closing = True
self.app = mock.Mock()
message = RawRequestMessage(method, path, version, headers, closing,
False)
self.payload = mock.Mock()
self.transport = mock.Mock()
def get_extra_info(key):
if key == 'sslcontext':
return sslcontext
else:
return None
self.transport.get_extra_info.side_effect = get_extra_info
self.writer = mock.Mock()
self.reader = mock.Mock()
req = Request(self.app,
message,
self.payload,
self.transport,
self.reader,
self.writer,
secure_proxy_ssl_header=secure_proxy_ssl_header)
return req
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 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_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 make_request(self,
method,
path,
headers=CIMultiDict(),
version=HttpVersion11):
message = RawRequestMessage(method, path, version, headers, False,
False)
return self.request_from_message(message)
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(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_keep_alive_http10_switched_on():
headers = CIMultiDict(Connection='keep-alive')
message = RawRequestMessage('GET', '/', HttpVersion10, headers,
[(b'Connection', b'keep-alive')], False, False)
req = request_from_message(message)
resp = StreamResponse()
yield from resp.prepare(req)
assert resp.keep_alive is True
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 test_keep_alive_http09():
headers = CIMultiDict(Connection='keep-alive')
message = RawRequestMessage('GET', '/', HttpVersion(0, 9), headers, False,
False)
req = request_from_message(message)
resp = StreamResponse()
yield from resp.prepare(req)
assert not 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 test_merge_headers_with_list_of_tuples_duplicated_names(create_session):
session = create_session(headers={"h1": "header1", "h2": "header2"})
headers = session._prepare_headers([("h1", "v1"), ("h1", "v2")])
assert isinstance(headers, CIMultiDict)
assert headers == CIMultiDict([("H2", "header2"), ("H1", "v1"),
("H1", "v2")])
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 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_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 prepare_request_params(self, service_desc, session, request_params):
headers = request_params.get('headers', CIMultiDict()).copy()
if not isinstance(headers, CIMultiDict):
headers = CIMultiDict(headers)
headers.update(self.default_headers)
headers.update(service_desc.get('headers', {}))
headers.update(request_params.get('headers', {}))
request_params['headers'] = headers
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()
class Response:
def __init__(self):
self.headers = CIMultiDict()
self._status_code = 200
self._cookies = http.cookies.SimpleCookie()
self._deleted_cookies = set()
def _copy_cookies(self):
for cookie in self._cookies.values():
value = cookie.output(header='')[1:]
self.headers.add('Set-Cookie', value)
@property
def cookies(self):
return self._cookies
def set_cookie(self, name, value, *, expires=None,
domain=None, max_age=None, path=None,
secure=None, httponly=None, version=None):
"""Set or update response cookie.
Sets new cookie or updates existent with new value.
Also updates only those params which are not None.
"""
if name in self._deleted_cookies:
self._deleted_cookies.remove(name)
self._cookies.pop(name, None)
self._cookies[name] = value
c = self._cookies[name]
if expires is not None:
c['expires'] = expires
if domain is not None:
c['domain'] = domain
if max_age is not None:
c['max-age'] = max_age
if path is not None:
c['path'] = path
if secure is not None:
c['secure'] = secure
if httponly is not None:
c['httponly'] = httponly
if version is not None:
c['version'] = version
def del_cookie(self, name, *, domain=None, path=None):
"""Delete cookie.
Creates new empty expired cookie.
"""
# TODO: do we need domain/path here?
self._cookies.pop(name, None)
self.set_cookie(name, '', max_age=0, domain=domain, path=path)
self._deleted_cookies.add(name)
@property
def status_code(self):
return self._status_code
@status_code.setter
def status_code(self, value):
assert isinstance(value, int), "Status code must be int"
self._status_code = value
def __init__(self):
self.headers = CIMultiDict()
self._status_code = 200
self._cookies = http.cookies.SimpleCookie()
self._deleted_cookies = set()
