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