async def test_cookies_jar_single_cookie():
fake_pools = FakePools([
Response(
200,
Headers([
Header(b'Set-Cookie',
write_response_cookie(Cookie(b'X-Foo', b'Foo')))
]), TextContent('Hello, World!')),
Response(200, Headers(), TextContent('Hello!'))
])
check_cookie = False
async def middleware_for_assertions(request, next_handler):
if check_cookie:
cookie = request.cookies.get(b'X-Foo')
assert cookie is not None, 'X-Foo cookie must be configured for following requests'
return await next_handler(request)
async with ClientSession(url=b'https://bezkitu.org',
pools=fake_pools,
middlewares=[middleware_for_assertions
]) as client:
await client.get(
b'/'
) # the first request doesn't have any cookie because the response will set;
check_cookie = True
await client.get(b'/')
async def test_cookies_jar(first_request_url, second_request_url, set_cookies,
expected_cookies):
fake_pools = FakePools([
Response(200, Headers(set_cookies), TextContent('Hello, World!')),
Response(200, Headers(), TextContent('Hello!'))
])
check_cookie = False
async def middleware_for_assertions(request, next_handler):
if check_cookie:
if not expected_cookies:
assert not request.cookies
for expected_cookie in expected_cookies:
cookie = request.cookies.get(expected_cookie)
assert cookie is not None, f'{cookie.name.decode()} cookie must be configured for following requests'
return await next_handler(request)
async with ClientSession(
pools=fake_pools,
middlewares=[middleware_for_assertions],
) as client:
await client.get(first_request_url)
check_cookie = True
await client.get(second_request_url)
def test_http_header_collection_item_get_single_case_insensitive():
headers = Headers()
headers[b'example'] = b'Hello, World'
header = headers.get_single(b'Example')
assert header is not None
assert header.name == b'example'
assert header.value == b'Hello, World'
def test_http_header_collection_item_setter():
headers = Headers()
example = headers.get(b"example")
assert example == tuple()
headers[b"example"] = b"Hello, World"
example = headers.get(b"example")
assert example == (b"Hello, World", )
def test_iadd_http_header_collection_concatenation_with_collection_of_headers(
):
headers = Headers([(b"Hello", b"World"), (b"Svil", b"Power")])
headers += Headers([(b"foo", b"foo"), (b"ufo", b"ufo")])
for name in {b"foo", b"ufo"}:
example = headers[name]
assert len(example) == 1
header = example[0]
assert header == name
def test_http_header_collection_concatenation_with_other_collection():
headers = Headers([(b"Hello", b"World"), (b"Svil", b"Power")])
with_addition = headers + Headers([(b"Foo", b"foo"), (b"Ufo", b"ufo")])
for name in {b"foo", b"ufo"}:
assert headers[name] == tuple()
example = with_addition[name]
assert len(example) == 1
header = example[0]
assert header == name
def test_http_header_collection_item_setter():
headers = Headers()
example = headers.get(b'example')
assert example == []
headers[b'example'] = b'Hello, World'
example = headers.get(b'example')
assert len(example) == 1
header = example[0]
assert header.name == b'example'
assert header.value == b'Hello, World'
def test_http_header_collection_add_many_items():
headers = Headers()
values = {
b"A": b"B",
b"C": b"D",
b"E": b"F",
}
headers.add_many(values)
for key, value in values.items():
header = headers.get_single(key)
assert header is not None
assert header == value
async def test_multiple_middleware():
fake_pools = FakePools(
[Response(200, Headers(), TextContent('Hello, World!'))])
steps = []
async def middleware_one(request, next_handler):
steps.append(1)
response = await next_handler(request)
steps.append(2)
return response
async def middleware_two(request, next_handler):
steps.append(3)
response = await next_handler(request)
steps.append(4)
return response
async def middleware_three(request, next_handler):
steps.append(5)
response = await next_handler(request)
steps.append(6)
return response
async with ClientSession(
url=b'http://localhost:8080',
pools=fake_pools,
middlewares=[middleware_one, middleware_two,
middleware_three]) as client:
response = await client.get(b'/')
assert steps == [1, 3, 5, 6, 4, 2]
assert response.status == 200
text = await response.text()
assert text == 'Hello, World!'
def test_http_header_collection_instantiating_with_list_of_tuples(values):
headers = Headers(values)
for input_header in values:
header = headers[input_header[0]]
assert len(header) == 1
assert header[0] == input_header[1]
def test_http_header_collection_add_many_items():
headers = Headers()
values = {
b'A': b'B',
b'C': b'D',
b'E': b'F',
}
headers.add_many(values)
for key, value in values.items():
header = headers.get_single(key)
assert header is not None
assert header.name == key
assert header.value == value
def test_iadd_http_header_collection_concatenation_with_collection_of_headers(
):
headers = Headers([
Header(b'Hello', b'World'),
Header(b'Svil', b'Power'),
])
headers += Headers([Header(b'foo', b'foo'), Header(b'ufo', b'ufo')])
for name in {b'foo', b'ufo'}:
example = headers[name]
assert len(example) == 1
header = example[0]
assert header.name.lower() == name
assert header.value == name
def get_response_for_file(request, resource_path, cache_time):
# TODO: support for accept-range and bytes ranges
file_size = os.path.getsize(resource_path)
modified_time = os.path.getmtime(resource_path)
current_etag = str(modified_time).encode()
previous_etag = request.if_none_match
headers = [
Header(b'Last-Modified', unix_timestamp_to_datetime(modified_time)),
Header(b'ETag', current_etag)
]
if cache_time > 0:
headers.append(
Header(b'Cache-Control', b'max-age=' + str(cache_time).encode()))
if previous_etag and current_etag == previous_etag:
return Response(304, headers, None)
if request.method == b'HEAD':
headers.append(Header(b'Content-Type', get_mime_type(resource_path)))
headers.append(Header(b'Content-Length', str(file_size).encode()))
return Response(200, headers, None)
return Response(
200, Headers(headers),
Content(get_mime_type(resource_path),
get_file_data(resource_path, file_size)))
async def head(self,
url: URLType,
headers: Optional[List[Header]] = None,
params=None):
return await self.send(
Request(b'HEAD', self.get_url(url, params), Headers(headers),
None))
async def test_request_binder():
request = Request(b'GET', b'/', Headers(), None)
parameter = RequestBinder()
value = await parameter.get_value(request)
assert value is request
def on_headers_complete(self):
status = self.parser.get_status_code()
self.response = Response(
status,
Headers(self.headers),
None
)
self.response_ready.set()
async def test_can_read_json_data_even_without_content_type_header():
request = Request(b'POST', b'/', Headers(), None)
request.extend_body(b'{"hello":"world","foo":false}')
request.complete.set()
json = await request.json()
assert json == {"hello": "world", "foo": False}
async def test_from_query_raises_for_invalid_parameter(expected_type,
invalid_value: bytes):
request = Request(b'GET', b'/?foo=' + invalid_value, Headers(), None)
parameter = FromQuery(expected_type, 'foo', required=True)
with raises(BadRequest):
await parameter.get_value(request)
async def options(self,
url: URLType,
content: Content = None,
headers: Optional[List[Header]] = None,
params=None):
return await self.send(
Request(b'OPTIONS', self.get_url(url, params), Headers(headers),
content))
def test_http_header_collection_instantiating_with_dict_values(values):
headers = Headers(list(
Header(key, value) for key, value in values.items()))
for key, value in values.items():
header = headers[key]
assert len(header) == 1
assert header[0].name == key
assert header[0].value == value
def test_request_supports_dynamic_attributes():
request = Request(b'GET', b'/', Headers(), None)
foo = object()
assert hasattr(
request, 'foo'
) is False, 'This test makes sense if such attribute is not defined'
request.foo = foo
assert request.foo is foo
def test_http_header_collection_instantiating_with_list_of_headers(values):
headers = Headers(values)
for input_header in values:
header = headers[input_header.name]
assert len(header) == 1
assert header[0].name == input_header.name
assert header[0].value == input_header.value
assert header[0] is input_header
def test_http_header_collection_add_multiple_times_items():
headers = Headers()
values = [
Header(b'Cookie', b'Hello=World;'),
Header(b'Cookie', b'Foo=foo;'),
Header(b'Cookie', b'Ufo=ufo;'),
]
headers.add_many(values)
cookie_headers = headers[b'cookie']
assert cookie_headers
assert len(cookie_headers) == 3
assert any(x.value == b'Hello=World;' for x in cookie_headers)
assert any(x.value == b'Foo=foo;' for x in cookie_headers)
assert any(x.value == b'Ufo=ufo;' for x in cookie_headers)
def test_http_header_collection_add_multiple_times_items():
headers = Headers()
values = [
(b"Cookie", b"Hello=World;"),
(b"Cookie", b"Foo=foo;"),
(b"Cookie", b"Ufo=ufo;"),
]
headers.add_many(values)
cookie_headers = headers[b"cookie"]
assert cookie_headers
assert len(cookie_headers) == 3
assert any(x == b"Hello=World;" for x in cookie_headers)
assert any(x == b"Foo=foo;" for x in cookie_headers)
assert any(x == b"Ufo=ufo;" for x in cookie_headers)
def test_iadd_http_header_collection_concatenation_with_duplicate_():
headers = Headers([(b"Hello", b"World"), (b"Svil", b"Power")])
headers += (b"Svil", b"Kitty")
example = headers[b"Svil"]
assert len(example) == 2
assert any(x == b"Power" for x in example)
assert any(x == b"Kitty" for x in example)
async def test_from_route_raises_for_invalid_parameter(expected_type,
invalid_value):
request = Request(b'GET', b'/', Headers(), None)
request.route_values = {'name': invalid_value}
parameter = FromRoute(expected_type, 'name')
with raises(BadRequest):
await parameter.get_value(request)
async def frozen_file_getter(request):
previous_etag = request.if_none_match
if previous_etag and previous_etag == current_etag:
return Response(304, headers, None)
if request.method == b'HEAD':
return Response(200, head_headers, None)
return Response(200, Headers(headers), Content(mime, data))
async def test_remove_cookie_with_expiration():
expire_cookie = Cookie(b'X-Foo', b'Foo')
expire_cookie.expiration = datetime.utcnow() + timedelta(days=-2)
fake_pools = FakePools([
Response(
200,
Headers([
Header(b'Set-Cookie',
write_response_cookie(Cookie(b'X-Foo', b'Foo')))
]), TextContent('Hello, World!')),
Response(200, Headers(), TextContent('Hello!')),
Response(
200,
Headers(
[Header(b'Set-Cookie', write_response_cookie(expire_cookie))]),
TextContent('Hello, World!')),
Response(200, Headers(), TextContent('Hello!'))
])
expect_cookie = False
async def middleware_for_assertions(request, next_handler):
cookie = request.cookies.get(b'X-Foo')
if expect_cookie:
assert cookie is not None, 'X-Foo cookie must be configured'
else:
assert cookie is None
return await next_handler(request)
async with ClientSession(url=b'https://bezkitu.org',
pools=fake_pools,
middlewares=[middleware_for_assertions
]) as client:
await client.get(b'/') # <-- cookie set here
expect_cookie = True
await client.get(b'/') # <-- expect cookie in request
expect_cookie = True
await client.get(
b'/') # <-- expect cookie in request; it gets removed here
expect_cookie = False
await client.get(
b'/'
) # <-- expect missing cookie; was deleted by previous response
async def test_from_query_binding(expected_type, query_value, expected_value):
request = Request(b'GET', b'/?foo=' + query_value, Headers(), None)
parameter = FromQuery(expected_type, 'foo')
value = await parameter.get_value(request)
assert isinstance(value, expected_type)
assert value == expected_value
async def test_from_services():
request = Request(b'GET', b'/', Headers(), None)
service_instance = ExampleOne(1, 2)
request.services = {ExampleOne: service_instance}
parameter = FromServices(ExampleOne)
value = await parameter.get_value(request)
assert value is service_instance
