def test_call_POST_on_weird_content_type(self):
req = self.make_request(
'POST', '/',
headers=MultiDict({'CONTENT-TYPE': 'something/weird'}))
ret = self.loop.run_until_complete(req.post())
self.assertEqual(MultiDict(), ret)
def __init__(self,
host,
message,
req_body,
*,
session_factory=None,
loop=None):
if loop is None:
loop = asyncio.get_event_loop()
res = urlsplit(message.path)
self._loop = loop
self.version = message.version
self.method = message.method.upper()
self.host = message.headers.get('HOST', host)
self.host_url = 'http://' + self.host
self.path_qs = message.path
self.path = res.path
self.path_url = self.host_url + self.path
self.url = self.host_url + self.path_qs
self.query_string = res.query
self.args = MultiDict(parse_qsl(res.query))
self.headers = message.headers
self.matchdict = {}
self._request_body = req_body
self._response = Response()
self._session_factory = session_factory
self._session_fut = None
self._json_body = None
self._cookies = None
self._on_response = []
def make_request(self, method='GET', path='/', headers=MultiDict()):
self.app = mock.Mock()
message = RawRequestMessage(method, path, HttpVersion11, headers,
False, False)
req = Request(self.app, message, self.payload, self.transport,
self.writer, 15)
return req
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, path, headers=MultiDict()):
self.app = mock.Mock()
message = RawRequestMessage(method, path, HttpVersion11, headers,
False, False)
self.payload = mock.Mock()
self.writer = mock.Mock()
req = Request(self.app, message, self.payload, self.writer)
return req
def test_request_cookie__set_item(self):
headers = MultiDict(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 = MultiDict(COOKIE='cookie1=value1; cookie2=value2')
req = self.make_request('GET', '/', headers=headers)
self.assertEqual(req.cookies, {
'cookie1': 'value1',
'cookie2': 'value2',
})
def go():
_, _, url = yield from self.create_server('POST', '/', handler)
resp = yield from request('POST',
url,
data=MultiDict([('a', 1), ('a', 2)]),
loop=self.loop)
self.assertEqual(200, resp.status)
txt = yield from resp.text()
self.assertEqual('OK', txt)
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 make_request(self, method, path):
self.app = mock.Mock()
message = RawRequestMessage(method, path, HttpVersion(1, 1),
MultiDict(), False, False)
self.payload = mock.Mock()
self.transport = mock.Mock()
self.writer = mock.Mock()
req = Request(self.app, message, self.payload,
self.transport, self.writer, 15)
return req
def check_wrapped_data(self, klass):
schema = Schema(schemas.index)
# Validate request should understand wrapped data
base = {'name': TEST_NAME}
wrapped = (klass(MultiDict(base))
if klass == MultiDictProxy else klass(base))
data = schema.validate_request(wrapped)
self.assertEqual(data, base)
self.assertIsInstance(data, klass)
# Make response should understand wrapped data
base = {'name': TEST_NAME, 'time': time.time()}
wrapped = (klass(MultiDict(base))
if klass == MultiDictProxy else klass(base))
data = schema.make_response(wrapped)
self.assertEqual(data, base)
self.assertIsInstance(data, klass)
def test_merge_headers_with_multi_dict(self):
session = ClientSession(headers={
"h1": "header1",
"h2": "header2"
},
loop=self.loop)
headers = session._prepare_headers(MultiDict([("h1", "h1")]))
self.assertIsInstance(headers, CIMultiDict)
self.assertEqual(headers, CIMultiDict([("h2", "header2"),
("h1", "h1")]))
session.close()
def cookies(self):
"""Return request cookies.
A read-only dictionary-like object.
"""
if self._cookies is None:
raw = self.headers.get('COOKIE', '')
parsed = http.cookies.SimpleCookie(raw)
self._cookies = MultiDict(
{key: val.value
for key, val in parsed.items()})
return self._cookies
def make_request(self, method, path, headers=MultiDict(), *,
version=HttpVersion(1, 1), closing=False,
keep_alive_timeout=15):
self.app = mock.Mock()
message = RawRequestMessage(method, path, version, headers, closing,
False)
self.payload = mock.Mock()
self.transport = mock.Mock()
self.writer = mock.Mock()
req = Request(self.app, message, self.payload,
self.transport, self.writer, keep_alive_timeout)
return req
def test_ctor(self):
req = self.make_request('GET', '/path/to?a=1&b=2')
self.assertIs(self.app, req.app)
self.assertEqual('GET', req.method)
self.assertEqual(HttpVersion(1, 1), req.version)
self.assertEqual(None, req.host)
self.assertEqual('/path/to?a=1&b=2', req.path_qs)
self.assertEqual('/path/to', req.path)
self.assertEqual('a=1&b=2', req.query_string)
self.assertEqual(MultiDict([('a', '1'), ('b', '2')]), req.GET)
self.assertIs(self.payload, req.payload)
self.assertTrue(req.keep_alive)
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, MultiDict(),
False, False)
payload = mock.Mock()
with self.assertRaises(RuntimeError):
self.loop.run_until_complete(h.handle_request(message, payload))
def test_HTTP_200_GET_MultiDict_PARAMS(self):
with test_utils.run_server(self.loop, router=Functional) as httpd:
r = self.loop.run_until_complete(
client.request('get',
httpd.url('method', 'get'),
params=MultiDict([('q', 'test1'),
('q', 'test2')]),
loop=self.loop))
content = self.loop.run_until_complete(r.content.read())
content = content.decode()
self.assertIn('"query": "q=test1&q=test2"', content)
self.assertEqual(r.status, 200)
r.close()
def make_request(self,
method,
path,
headers=MultiDict(),
*,
version=HttpVersion(1, 1),
closing=False):
self.app = mock.Mock()
message = RawRequestMessage(method, path, version, headers, closing,
False)
self.payload = mock.Mock()
self.writer = mock.Mock()
req = Request(self.app, message, self.payload, self.writer)
return req
def test_POST_MultiDict(self):
with test_utils.run_server(self.loop, router=Functional) as httpd:
url = httpd.url('method', 'post')
r = self.loop.run_until_complete(
client.request('post',
url,
data=MultiDict([('q', 'test1'),
('q', 'test2')]),
loop=self.loop))
self.assertEqual(r.status, 200)
content = self.loop.run_until_complete(r.json())
self.assertEqual({'q': ['test1', 'test2']}, content['form'])
self.assertEqual(r.status, 200)
r.close()
def test_multidict_headers(self):
with test_utils.run_server(self.loop, router=Functional) as httpd:
url = httpd.url('method', 'post')
data = b'sample data'
r = self.loop.run_until_complete(
client.request(
'post', url, data=data,
headers=MultiDict({'Content-Length': str(len(data))}),
loop=self.loop))
content = self.loop.run_until_complete(r.json())
r.close()
self.assertEqual(str(len(data)),
content['headers']['Content-Length'])
def test_POST_FILES_IO_WITH_PARAMS(self):
with test_utils.run_server(self.loop, router=Functional) as httpd:
url = httpd.url('method', 'post')
data = io.BytesIO(b'data')
r = self.loop.run_until_complete(
client.request('post',
url,
data=(('test', 'true'),
MultiDict([('q', 't1'),
('q', 't2')]), data),
loop=self.loop))
content = self.loop.run_until_complete(r.json())
self.assertEqual(4, len(content['multipart-data']))
self.assertEqual(
{
'content-type': 'text/plain',
'data': 'true',
'name': 'test'
}, content['multipart-data'][0])
self.assertEqual(
{
'content-type': 'application/octet-stream',
'data': 'data',
'filename': 'unknown',
'filename*': "utf-8''unknown",
'name': 'unknown'
}, content['multipart-data'][1])
self.assertEqual(
{
'content-type': 'text/plain',
'data': 't1',
'name': 'q'
}, content['multipart-data'][2])
self.assertEqual(
{
'content-type': 'text/plain',
'data': 't2',
'name': 'q'
}, content['multipart-data'][3])
self.assertEqual(r.status, 200)
r.close()
def test_ctor(make_request, warning):
req = make_request('GET', '/path/to?a=1&b=2')
assert 'GET' == req.method
assert HttpVersion(1, 1) == req.version
assert req.host is None
assert '/path/to?a=1&b=2' == req.path_qs
assert '/path/to' == req.path
assert 'a=1&b=2' == req.query_string
get = req.GET
assert MultiDict([('a', '1'), ('b', '2')]) == get
# second call should return the same object
assert get is req.GET
with warning(DeprecationWarning):
req.payload
assert req.keep_alive
def test_ctor(self):
req = self.make_request('GET', '/path/to?a=1&b=2')
self.assertIs(self.app, req.app)
self.assertEqual('GET', req.method)
self.assertEqual(HttpVersion(1, 1), req.version)
self.assertEqual(None, req.host)
self.assertEqual('/path/to?a=1&b=2', req.path_qs)
self.assertEqual('/path/to', req.path)
self.assertEqual('a=1&b=2', req.query_string)
get = req.GET
self.assertEqual(MultiDict([('a', '1'), ('b', '2')]), get)
# second call should return the same object
self.assertIs(get, req.GET)
self.assertIs(self.payload, req.payload)
self.assertIs(self.transport, req.transport)
self.assertTrue(req.keep_alive)
def handle_request(self, message, payload):
response = aiohttp.Response(
self.writer, 200, http_version=message.version)
get_params = MultiDict(parse_qsl(urlparse(message.path).query))
if message.method == 'POST':
post_params = yield from payload.read()
else:
post_params = None
content = "<h1>It Works!</h1>"
if get_params:
content += "<h2>Get params</h2><p>" + str(get_params) + "</p>"
if post_params:
content += "<h2>Post params</h2><p>" + str(post_params) + "</p>"
bcontent = content.encode('utf-8')
response.add_header('Content-Type', 'text/html; charset=UTF-8')
response.add_header('Content-Length', str(len(bcontent)))
response.send_headers()
response.write(bcontent)
yield from response.write_eof()
def test_calc_content_type_on_getting_charset(self):
req = self.make_request(
'Get', '/',
MultiDict([('CONTENT-TYPE', 'text/html; charset=UTF-8')]))
self.assertEqual('UTF-8', req.charset)
self.assertEqual('text/html', req.content_type)
def test_merge_headers_with_multi_dict(create_session):
session = create_session(headers={"h1": "header1", "h2": "header2"})
headers = session._prepare_headers(MultiDict([("h1", "h1")]))
assert isinstance(headers, CIMultiDict)
assert headers == CIMultiDict([("h2", "header2"), ("h1", "h1")])
def test_content_type_from_spec(self):
req = self.make_request(
'Get', '/',
MultiDict([('CONTENT-TYPE', 'application/json')]))
self.assertEqual('application/json', req.content_type)
def test_content_type_from_spec_with_charset(self):
req = self.make_request(
'Get', '/',
MultiDict([('CONTENT-TYPE', 'text/html; charset=UTF-8')]))
self.assertEqual('text/html', req.content_type)
self.assertEqual('UTF-8', req.charset)
def test_content_length(self):
req = self.make_request('Get', '/',
MultiDict([('CONTENT-LENGTH', '123')]))
self.assertEqual(123, req.content_length)
def make_dict(self, *args, **kwargs):
return MultiDict(*args, **kwargs)
