def test_request_aware_read_current(foo): # noqa
request1 = make_mocked_request('POST', '/')
foo._p_jar.transaction_manager.begin(request1)
request2 = make_mocked_request('POST', '/')
foo._p_jar.transaction_manager.begin(request2)
for i in range(0, 5):
SetItemView(foo, request1)(str(i), OOBTree.OOBTree())
assert '_txn_readCurrent' in request1.__dict__
assert len(request1._txn_readCurrent) > 0
CommitView(foo, request1)()
assert len(request1._txn_readCurrent) == 0
for i in range(5, 10):
SetItemView(foo, request2)(str(i), OOBTree.OOBTree())
assert '_txn_readCurrent' in request2.__dict__
assert len(request2._txn_readCurrent) > 0
CommitView(foo, request2)()
assert len(request2._txn_readCurrent) == 0
def test_multiple_connections(conn1, conn2): # noqa
root1 = conn1.root()
root2 = conn2.root()
request = make_mocked_request('POST', '/')
txn = root1._p_jar.transaction_manager.begin(request)
SetItemView(root1, request)('foo', OOBTree.OOBTree())
txn.commit()
assert 'foo' in root1
assert 'foo' not in root2
conn2.newTransaction(None)
assert 'foo' in root2
request1 = make_mocked_request('POST', '/')
txn1 = root1._p_jar.transaction_manager.begin(request1)
SetItemView(root1['foo'], request1)('bar', True)
request2 = make_mocked_request('POST', '/')
txn2 = root2._p_jar.transaction_manager.begin(request2)
SetItemView(root2['foo'], request2)('bar', False)
txn1.commit()
assert root1['foo']['bar']
assert not root2['foo']['bar']
with pytest.raises(ConflictError):
txn2.commit()
assert root2['foo']['bar']
def test_ctor():
req = make_mocked_request('GET', '/path/to?a=1&b=2')
assert 'GET' == req.method
assert HttpVersion(1, 1) == req.version
assert req.host == socket.getfqdn()
assert '/path/to?a=1&b=2' == req.path_qs
assert '/path/to' == req.path
assert 'a=1&b=2' == req.query_string
assert CIMultiDict() == req.headers
assert () == req.raw_headers
assert req.message == req._message
get = req.query
assert MultiDict([('a', '1'), ('b', '2')]) == get
# second call should return the same object
assert get is req.query
assert req.keep_alive
# just make sure that all lines of make_mocked_request covered
headers = CIMultiDict(FOO='bar')
payload = mock.Mock()
protocol = mock.Mock()
app = mock.Mock()
req = make_mocked_request('GET', '/path/to?a=1&b=2', headers=headers,
protocol=protocol, payload=payload, app=app)
assert req.app is app
assert req.content is payload
assert req.protocol is protocol
assert req.transport is protocol.transport
assert req.headers == headers
assert req.raw_headers == ((b'FOO', b'bar'),)
assert req.task is req._task
async def test_middleware_with_default_transport(tracer, fake_transport):
app = web.Application()
az.setup(app, tracer)
async def handler(request):
return web.Response(body=b'data')
req = make_mocked_request('GET', '/aa', headers={'token': 'x'}, app=app)
req.match_info.route.resource.canonical = '/{pid}'
middleware = middleware_maker()
await middleware(req, handler)
span = az.request_span(req)
assert span
assert len(fake_transport.records) == 1
rec = fake_transport.records[0]
assert rec.asdict()['tags'][az.HTTP_ROUTE] == '/{pid}'
# noop span does not produce records
headers = {'X-B3-Sampled': '0'}
req_noop = make_mocked_request('GET', '/', headers=headers, app=app)
await middleware(req_noop, handler)
span = az.request_span(req_noop)
assert span
assert len(fake_transport.records) == 1
def test_concurrent_transaction_abort_has_no_side_effects(root, foo, bar): # noqa
tm = root._p_jar.transaction_manager
# Create /foo/a
request1 = make_mocked_request('POST', '/foo')
t1 = tm.begin(request1)
SetItemView(foo, request1)('a', OOBTree.OOBTree())
# Test that object is registered
assert foo in request1._txn_dm._registered_objects
# Create /bar/b
request2 = make_mocked_request('POST', '/bar')
t2 = tm.begin(request2)
SetItemView(bar, request2)('b', OOBTree.OOBTree())
# Test that object is registered
assert bar in request2._txn_dm._registered_objects
# Test that two transactions are indepedent
assert bar not in request1._txn_dm._registered_objects
assert foo not in request2._txn_dm._registered_objects
# Abort the first transaction
t1.abort()
# Commit the second transaction
t2.commit()
# Test that /foo/a has not been created by t1
assert 'a' not in foo
# Test that /bar/b has been created by t2
assert 'b' in bar
async def test_add_domain(app, loop):
subapp1 = web.Application()
h1 = make_handler()
subapp1.router.add_get('/', h1)
app.add_domain('example.com', subapp1)
subapp2 = web.Application()
h2 = make_handler()
subapp2.router.add_get('/', h2)
app.add_domain('*.example.com', subapp2)
subapp3 = web.Application()
h3 = make_handler()
subapp3.router.add_get('/', h3)
app.add_domain('*', subapp3)
request = make_mocked_request('GET', '/', {'host': 'example.com'})
match_info = await app.router.resolve(request)
assert match_info.route.handler is h1
request = make_mocked_request('GET', '/', {'host': 'a.example.com'})
match_info = await app.router.resolve(request)
assert match_info.route.handler is h2
request = make_mocked_request('GET', '/', {'host': 'example2.com'})
match_info = await app.router.resolve(request)
assert match_info.route.handler is h3
request = make_mocked_request('POST', '/', {'host': 'example.com'})
match_info = await app.router.resolve(request)
assert isinstance(match_info.http_exception, HTTPMethodNotAllowed)
def test_is_xhr_request(self):
non_xhr_request = make_mocked_request('GET', '/')
self.assertFalse(is_xhr_request(non_xhr_request))
xhr_request = make_mocked_request('GET', '/api/', headers=CIMultiDict({
'X-Requested-With': 'XMLHttpRequest',
}))
self.assertTrue(is_xhr_request(xhr_request))
async def test_add_route_with_re(router) -> None:
handler = make_handler()
router.add_route('GET', r'/handler/{to:\d+}', handler)
req = make_mocked_request('GET', '/handler/1234')
info = await router.resolve(req)
assert info is not None
assert {'to': '1234'} == info
router.add_route('GET', r'/handler/{name}.html', handler)
req = make_mocked_request('GET', '/handler/test.html')
info = await router.resolve(req)
assert {'name': 'test'} == info
async def test_add_route_with_re_and_slashes(router) -> None:
handler = make_handler()
router.add_route('GET', r'/handler/{to:[^/]+/?}', handler)
req = make_mocked_request('GET', '/handler/1234/')
info = await router.resolve(req)
assert info is not None
assert {'to': '1234/'} == info
router.add_route('GET', r'/handler/{to:.+}', handler)
req = make_mocked_request('GET', '/handler/1234/5/6/7')
info = await router.resolve(req)
assert info is not None
assert {'to': '1234/5/6/7'} == info
async def test_any_method(router) -> None:
handler = make_handler()
route = router.add_route(hdrs.METH_ANY, '/', handler)
req = make_mocked_request('GET', '/')
info1 = await router.resolve(req)
assert info1 is not None
assert route is info1.route
req = make_mocked_request('POST', '/')
info2 = await router.resolve(req)
assert info2 is not None
assert info1.route is info2.route
def test_using_gzip_if_header_present_and_file_available(loop):
request = make_mocked_request(
'GET', URL('http://python.org/logo.png'), headers={
hdrs.ACCEPT_ENCODING: 'gzip'
}
)
gz_filepath = mock.Mock()
gz_filepath.open = mock.mock_open()
gz_filepath.is_file.return_value = True
gz_filepath.stat.return_value = mock.MagicMock()
gz_filepath.stat.st_size = 1024
filepath = mock.Mock()
filepath.name = 'logo.png'
filepath.open = mock.mock_open()
filepath.with_name.return_value = gz_filepath
file_sender = FileSender()
file_sender._sendfile = make_mocked_coro(None)
loop.run_until_complete(file_sender.send(request, filepath))
assert not filepath.open.called
assert gz_filepath.open.called
def test_remote_peername_forwarded():
transp = mock.Mock()
transp.get_extra_info.return_value = ('10.10.10.10', 1234)
req = make_mocked_request(
'GET', '/', transport=transp,
headers={'Forwarded': 'for=11.11.11.11, for=12.12.12.12'})
assert req.remote == '11.11.11.11'
def test_static_not_match(router):
router.add_static('/pre', os.path.dirname(aiohttp.__file__),
name='name')
resource = router['name']
ret = yield from resource.resolve(
make_mocked_request('GET', '/another/path'))
assert (None, set()) == ret
def test_gzip_if_header_present_and_file_not_available(loop) -> None:
request = make_mocked_request(
'GET', 'http://python.org/logo.png', headers={
hdrs.ACCEPT_ENCODING: 'gzip'
}
)
gz_filepath = mock.Mock()
gz_filepath.open = mock.mock_open()
gz_filepath.is_file.return_value = False
filepath = mock.Mock()
filepath.name = 'logo.png'
filepath.open = mock.mock_open()
filepath.with_name.return_value = gz_filepath
filepath.stat.return_value = mock.MagicMock()
filepath.stat.st_size = 1024
file_sender = FileResponse(filepath)
file_sender._sendfile = make_mocked_coro(None)
loop.run_until_complete(file_sender.prepare(request))
assert filepath.open.called
assert not gz_filepath.open.called
def test_get_stored_session():
req = make_mocked_request('GET', '/')
session = Session('identity', data=None, new=False)
req[SESSION_KEY] = session
ret = yield from get_session(req)
assert session is ret
async def test_middleware_with_valid_ip(tracer, version,
address_in, address_out):
if address_out is None:
address_out = address_in
app = web.Application()
az.setup(app, tracer)
# Fake transport
transp = Mock()
transp.get_extra_info.return_value = (address_in, '0')
async def handler(request):
return web.Response(body=b'data')
req = make_mocked_request('GET', '/',
headers={'token': 'x'},
transport=transp,
app=app)
middleware = middleware_maker()
with patch('aiozipkin.span.Span.remote_endpoint') as mocked_remote_ep:
await middleware(req, handler)
assert mocked_remote_ep.call_count == 1
args, kwargs = mocked_remote_ep.call_args
assert kwargs[version] == address_out
def test_no_request_cookies():
req = make_mocked_request('GET', '/')
assert req.cookies == {}
cookies = req.cookies
assert cookies is req.cookies
async def test_call_POST_on_weird_content_type():
req = make_mocked_request(
'POST', '/',
headers=CIMultiDict({'CONTENT-TYPE': 'something/weird'}))
ret = await req.post()
assert CIMultiDict() == ret
def test_single_forwarded_header_injection2():
header = 'very bad syntax, for=_real'
req = make_mocked_request('GET', '/',
headers=CIMultiDict({'Forwarded': header}))
assert len(req.forwarded) == 2
assert 'for' not in req.forwarded[0]
assert req.forwarded[1]['for'] == '_real'
def test_single_forwarded_header_empty_params():
# This is allowed by the grammar given in RFC 7239
header = ';For=identifier;;PROTO=https;;;'
req = make_mocked_request('GET', '/',
headers=CIMultiDict({'Forwarded': header}))
assert req.forwarded[0]['for'] == 'identifier'
assert req.forwarded[0]['proto'] == 'https'
def test_json():
def handler(request):
assert request.content_type == 'application/json'
assert 'jso' in request
return dict(request)
sd = {'parameters': parameters}
r = SwaggerValidationRoute(
'GET', handler=handler, resource=None,
swagger_data=sd)
r.build_swagger_data({})
request = make_mocked_request(
'POST', '/',
headers=multidict.CIMultiDict({
hdrs.CONTENT_TYPE: 'application/json'
}),
)
request.json = asyncio.coroutine(lambda: {'f': ''})
request._match_info = {}
resp = yield from r.handler(request)
assert isinstance(resp, dict), resp
assert 'road_id' in resp, resp
# not valid data
request.json = asyncio.coroutine(lambda: {'f': 1})
with pytest.raises(web.HTTPBadRequest):
yield from r.handler(request)
try:
yield from r.handler(request)
except web.HTTPBadRequest as e:
resp = e
assert resp.reason['jso.f'], resp.reason
def test_save_state_on_clone():
req = make_mocked_request('GET', '/')
req['key'] = 'val'
req2 = req.clone()
req2['key'] = 'val2'
assert req['key'] == 'val'
assert req2['key'] == 'val2'
def request(buf):
method = 'GET'
path = '/'
writer = mock.Mock()
writer.drain.return_value = ()
def append(data=b''):
buf.extend(data)
return helpers.noop()
async def write_headers(status_line, headers):
headers = status_line + '\r\n' + ''.join(
[k + ': ' + v + '\r\n' for k, v in headers.items()])
headers = headers.encode('utf-8') + b'\r\n'
buf.extend(headers)
writer.buffer_data.side_effect = append
writer.write.side_effect = append
writer.write_eof.side_effect = append
writer.write_headers.side_effect = write_headers
app = mock.Mock()
app._debug = False
app.on_response_prepare = signals.Signal(app)
app.on_response_prepare.freeze()
req = make_mocked_request(method, path, app=app, writer=writer)
return req
async def test_add_route_with_re_including_slashes(router) -> None:
handler = make_handler()
router.add_route('GET', r'/handler/{to:.+}/tail', handler)
req = make_mocked_request('GET', '/handler/re/with/slashes/tail')
info = await router.resolve(req)
assert info is not None
assert {'to': 're/with/slashes'} == info
async def test_match_info_with_plus(router) -> None:
handler = make_handler()
router.add_route('GET', '/get/{version}', handler)
req = make_mocked_request('GET', '/get/1.0+test')
match_info = await router.resolve(req)
assert {'version': '1.0+test'} == match_info
def maker(method, path, query_params={}, headers=None, match_info=None, loop=None):
path = URL(path)
if query_params:
path = path.with_query(query_params)
if headers is None:
headers = CIMultiDict(
{
"HOST": "server.example.com",
"UPGRADE": "websocket",
"CONNECTION": "Upgrade",
"SEC-WEBSOCKET-KEY": "dGhlIHNhbXBsZSBub25jZQ==",
"ORIGIN": "http://example.com",
"SEC-WEBSOCKET-PROTOCOL": "chat, superchat",
"SEC-WEBSOCKET-VERSION": "13",
}
)
writer = mock.Mock()
writer.write_headers = make_mocked_coro(None)
writer.write = make_mocked_coro(None)
writer.drain = make_mocked_coro(None)
transport = mock.Mock()
transport._drain_helper = make_mocked_coro()
ret = make_mocked_request(method, str(path), headers, writer=writer, loop=loop)
if match_info is None:
match_info = UrlMappingMatchInfo({}, mock.Mock())
match_info.add_app(app)
ret._match_info = match_info
return ret
def test_check_allowed_method_for_found_resource(router):
handler = make_handler()
resource = router.add_resource('/')
resource.add_route('GET', handler)
ret = yield from resource.resolve(make_mocked_request('GET', '/'))
assert ret[0] is not None
assert {'GET'} == ret[1]
async def test_match_info_get_info_dynamic(router) -> None:
handler = make_handler()
router.add_route('GET', '/{a}', handler)
req = make_mocked_request('GET', '/value')
info = await router.resolve(req)
assert info.get_info() == {
'pattern': re.compile(PATH_SEP+'(?P<a>[^{}/]+)'),
'formatter': '/{a}'}
async def test_dynamic_match_non_ascii(router) -> None:
handler = make_handler()
router.add_route('GET', '/{var}', handler)
req = make_mocked_request(
'GET',
'/%D1%80%D1%83%D1%81%20%D1%82%D0%B5%D0%BA%D1%81%D1%82')
match_info = await router.resolve(req)
assert {'var': 'рус текст'} == match_info
async def test_add_url_escaping(router) -> None:
handler = make_handler()
router.add_route('GET', '/+$', handler)
req = make_mocked_request('GET', '/+$')
info = await router.resolve(req)
assert info is not None
assert handler is info.handler
def test_single_forwarded_header_long_quoted_string():
header = 'for="' + '\\\\' * 5000 + '"'
req = make_mocked_request('GET',
'/',
headers=CIMultiDict({'Forwarded': header}))
assert req.forwarded[0]['for'] == '\\' * 5000
def test_remote_peername_unix():
transp = mock.Mock()
transp.get_extra_info.return_value = '/path/to/sock'
req = make_mocked_request('GET', '/', transport=transp)
assert req.remote == '/path/to/sock'
def test___repr___non_ascii_path():
req = make_mocked_request('GET', '/path/\U0001f415\U0001f308')
assert "<Request GET /path/\\U0001f415\\U0001f308 >" == repr(req)
def test_non_keepalive_on_http10():
req = make_mocked_request('GET', '/', version=HttpVersion(1, 0))
assert not req.keep_alive
def test_http_scheme():
req = make_mocked_request('GET', '/', headers={'Host': 'example.com'})
assert "http" == req.scheme
assert req.secure is False
def test_non_ascii_raw_path():
req = make_mocked_request('GET', '/путь')
assert '/путь' == req.raw_path
def test_request_iter():
req = make_mocked_request('GET', '/')
req['key'] = 'value'
req['key2'] = 'value2'
assert set(req) == {'key', 'key2'}
def test_request_delitem():
req = make_mocked_request('GET', '/')
req['key'] = 'value'
assert 'value' == req['key']
del req['key']
assert 'key' not in req
def test_clone_method():
req = make_mocked_request('GET', '/path')
req2 = req.clone(method='POST')
assert req2.method == 'POST'
assert req2.rel_url == URL('/path')
def test_clone_rel_url_str():
req = make_mocked_request('GET', '/path')
req2 = req.clone(rel_url='/path2')
assert req2.rel_url == URL('/path2')
def test_clone_scheme():
req = make_mocked_request('GET', '/')
req2 = req.clone(scheme='https')
assert req2.scheme == 'https'
def test_clone_headers_dict():
req = make_mocked_request('GET', '/path', headers={'A': 'B'})
req2 = req.clone(headers={'B': 'C'})
assert req2.headers == CIMultiDict({'B': 'C'})
assert req2.raw_headers == ((b'B', b'C'), )
def test_single_forwarded_header_bad_separator():
header = 'BY=identifier PROTO=https'
req = make_mocked_request('GET',
'/',
headers=CIMultiDict({'Forwarded': header}))
assert 'proto' not in req.forwarded[0]
def test_clone_client_max_size():
req = make_mocked_request('GET', '/path', client_max_size=1024)
req2 = req.clone()
assert req._client_max_size == req2._client_max_size
assert req2._client_max_size == 1024
def test_single_forwarded_header_single_param():
header = 'BY=identifier'
req = make_mocked_request('GET',
'/',
headers=CIMultiDict({'Forwarded': header}))
assert req.forwarded[0]['by'] == 'identifier'
def test_url_url():
req = make_mocked_request('GET', '/path', headers={'HOST': 'example.com'})
assert URL('http://example.com/path') == req.url
async def test_call_POST_on_GET_request():
req = make_mocked_request('GET', '/')
ret = await req.post()
assert CIMultiDict() == ret
def test_rel_url():
req = make_mocked_request('GET', '/path')
assert URL('/path') == req.rel_url
def test_non_keepalive_on_closing():
req = make_mocked_request('GET', '/', closing=True)
assert not req.keep_alive
def test_raw_headers():
req = make_mocked_request('GET',
'/',
headers=CIMultiDict({'X-HEADER': 'aaa'}))
assert req.raw_headers == ((b'X-HEADER', b'aaa'), )
def test_content_length():
req = make_mocked_request('Get', '/',
CIMultiDict([('CONTENT-LENGTH', '123')]))
assert 123 == req.content_length
async def test_call_POST_twice():
req = make_mocked_request('GET', '/')
ret1 = await req.post()
ret2 = await req.post()
assert ret1 is ret2
def test___repr__():
req = make_mocked_request('GET', '/path/to')
assert "<Request GET /path/to >" == repr(req)
def test_host_by_host_header():
req = make_mocked_request('GET',
'/',
headers=CIMultiDict({'Host': 'example.com'}))
assert req.host == 'example.com'
def test_request_is_mutable_mapping():
req = make_mocked_request('GET', '/')
assert isinstance(req, MutableMapping)
req['key'] = 'value'
assert 'value' == req['key']
def test_remote_peername_tcp():
transp = mock.Mock()
transp.get_extra_info.return_value = ('10.10.10.10', 1234)
req = make_mocked_request('GET', '/', transport=transp)
assert req.remote == '10.10.10.10'
def test_match_info():
req = make_mocked_request('GET', '/')
assert req._match_info is req.match_info
def test_request_cookie():
headers = CIMultiDict(COOKIE='cookie1=value1; cookie2=value2')
req = make_mocked_request('GET', '/', headers=headers)
assert req.cookies == {'cookie1': 'value1', 'cookie2': 'value2'}
def test_doubleslashes():
# NB: //foo/bar is an absolute URL with foo netloc and /bar path
req = make_mocked_request('GET', '/bar//foo/')
assert '/bar//foo/' == req.path
def test_request_len():
req = make_mocked_request('GET', '/')
assert len(req) == 0
req['key'] = 'value'
assert len(req) == 1
