def session_alt(event_loop):
session = ClientSession(
loop=event_loop,
default_headers=[(b"X-Default-One", b"AAA"),
(b"X-Default-Two", b"BBB")],
)
yield session
event_loop.run_until_complete(session.close())
def test_session_raises_for_redirect_without_location():
"""
If a server returns a redirect status without location response header,
the client raises an exception.
"""
with pytest.raises(MissingLocationForRedirect):
ClientSession.extract_redirect_location(Response(http.HTTPStatus.FOUND.value))
def test_check_permanent_redirects():
client = ClientSession()
client._permanent_redirects_urls._cache[b"/foo"] = URL(b"https://somewhere.org")
request = Request("GET", b"/foo", None)
assert request.url == URL(b"/foo")
client.check_permanent_redirects(request)
assert request.url == URL(b"https://somewhere.org")
def session(server_host, server_port, event_loop):
# It is important to pass the instance of ClientConnectionPools,
# to ensure that the connections are reused and closed
session = ClientSession(
loop=event_loop,
base_url=f"http://{server_host}:{server_port}",
pools=ClientConnectionPools(event_loop),
)
yield session
asyncio.run(session.close())
def test_update_request_for_redirect_raises_for_urn_redirects():
client = ClientSession()
with pytest.raises(UnsupportedRedirect) as redirect_exception:
client.update_request_for_redirect(
Request("GET", b"/foo", None),
Response(302, [
(b"Location", b"urn:uuid:6e8bc430-9c3a-11d9-9669-0800200c9a66")
]),
)
assert (redirect_exception.value.redirect_url ==
b"urn:uuid:6e8bc430-9c3a-11d9-9669-0800200c9a66")
async def test_client_session_validate_url_for_relative_urls_with_base_url():
async with ClientSession(base_url=b"https://foo.org") as client:
request = Request("GET", b"/home", None)
client._validate_request_url(request)
assert request.url == URL(b"https://foo.org/home")
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_maximum_number_of_redirects_detection(responses, maximum_redirects, pools_factory):
async with ClientSession(url=b'http://localhost:8080', pools=pools_factory(responses)) as client:
client.maximum_redirects = maximum_redirects
with pytest.raises(MaximumRedirectsExceededError):
await client.get(b'/')
async def test_multiple_middleware():
fake_pools = FakePools([Response(200, None, 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(
base_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!"
async def test_cookies_jar_single_cookie():
fake_pools = FakePools([
Response(200, [
(b"Set-Cookie", write_response_cookie(Cookie(b"X-Foo", b"Foo")))
]).with_content(TextContent("Hello, World!")),
Response(200, None, TextContent("Hello!")),
])
check_cookie = False
async def middleware_for_assertions(request, next_handler):
if check_cookie:
cookie = request.cookies.get("X-Foo")
assert (cookie is not None
), "X-Foo cookie must be configured for following requests"
return await next_handler(request)
async with ClientSession(
base_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)
async def test_circular_redirect_detection(responses, expected_error_message, pools_factory):
async with ClientSession(url=b'http://localhost:8080', pools=pools_factory(responses)) as client:
with pytest.raises(CircularRedirectError) as error:
await client.get(b'/')
assert str(error.value) == expected_error_message
async def test_non_url_redirect(responses, expected_status, expected_location, pools_factory):
async with ClientSession(url=b'http://localhost:8080', pools=pools_factory(responses)) as client:
response = await client.get(b'/')
assert response is not None
assert response.status == expected_status
location_header = response.headers.get_single(b'Location')
assert location_header.value == expected_location
async def test_connection_timeout():
fake_pools = FakePools([])
fake_pools.pool.sleep_for = 5 # wait for 5 seconds before returning a connection; to test timeout handling
async with ClientSession(base_url=b'http://localhost:8080',
pools=fake_pools,
connection_timeout=0.002 # 2ms - not realistic, but ok for this test
) as client:
with pytest.raises(ConnectionTimeout):
await client.get(b'/')
async def test_request_timeout():
fake_pools = FakePools([])
fake_pools.pool.connection.sleep_for = 5 # wait for 5 seconds before returning a response;
async with ClientSession(base_url=b'http://localhost:8080',
pools=fake_pools,
request_timeout=0.002 # 2ms - not realistic, but ok for this test
) as client:
with pytest.raises(RequestTimeout):
await client.get(b'/')
async def test_good_redirect(responses, expected_response_body, pools_factory):
async with ClientSession(url=b'http://localhost:8080', pools=pools_factory(responses)) as client:
response = await client.get(b'/')
assert response is not None
assert response.status == 200
content = await response.text()
assert content == expected_response_body
async def test_query_params_concatenation(request_url, params, expected_query):
fake_pools = FakePools([Response(200, None, TextContent('Hello, World!'))])
async def middleware_for_assertions(request, next_handler):
assert expected_query == request.url.query
return await next_handler(request)
async with ClientSession(base_url=b'http://localhost:8080',
pools=fake_pools,
middlewares=[middleware_for_assertions
]) as client:
await client.get(request_url, params=params)
async def test_not_follow_redirect(responses, expected_location, pools_factory):
async with ClientSession(url=b'http://localhost:8080',
pools=pools_factory(responses),
follow_redirects=False) as client:
response = await client.get(b'/')
assert response.status == 302
location = response.headers[b'location']
assert location
assert location[0].value == expected_location
async def test_not_follow_redirect(responses, expected_location, pools_factory):
async with ClientSession(
base_url=b"http://localhost:8080",
pools=pools_factory(responses),
follow_redirects=False,
) as client:
response = await client.get(b"/")
assert response.status == 302
location = response.headers[b"location"]
assert location
assert location[0] == expected_location
async def test_client_session_without_middlewares_and_cookiejar():
called = False
async def monkey_send_core(request):
nonlocal called
called = True
async with ClientSession(cookie_jar=False) as client:
assert client._handler is None
assert not client.middlewares
client._send_core = monkey_send_core # type: ignore
await client.send(Request("GET", b"https://somewhere.org", None))
assert called is True
async def test_request_headers():
fake_pools = FakePools([Response(200, [], TextContent('Hello, World!'))])
async def middleware_for_assertions(request, next_handler):
assert b'Hello' in request.headers
assert request.headers.get_single(b'Hello') == b'World'
return await next_handler(request)
async with ClientSession(base_url=b'http://localhost:8080',
pools=fake_pools,
middlewares=[middleware_for_assertions
]) as client:
await client.get(b'/', headers=[(b'Hello', b'World')])
await client.post(b'/', headers=[(b'Hello', b'World')])
await client.put(b'/', headers=[(b'Hello', b'World')])
await client.delete(b'/', headers=[(b'Hello', b'World')])
async def test_request_headers():
fake_pools = FakePools([Response(200, [], TextContent("Hello, World!"))])
async def middleware_for_assertions(request, next_handler):
assert b"Hello" in request.headers
assert request.headers.get_single(b"Hello") == b"World"
return await next_handler(request)
async with ClientSession(
base_url=b"http://localhost:8080",
pools=fake_pools,
middlewares=[middleware_for_assertions],
) as client:
await client.get(b"/", headers=[(b"Hello", b"World")])
await client.post(b"/", headers=[(b"Hello", b"World")])
await client.put(b"/", headers=[(b"Hello", b"World")])
await client.delete(b"/", headers=[(b"Hello", b"World")])
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_remove_cookie_with_max_age():
expire_cookie = Cookie("X-Foo", "Foo")
expire_cookie.max_age = 0
fake_pools = FakePools(
[
Response(
200,
[(b"Set-Cookie", write_response_cookie(Cookie("X-Foo", "Foo")))],
TextContent("Hello, World!"),
),
Response(200, None, TextContent("Hello!")),
Response(
200,
[(b"Set-Cookie", write_response_cookie(expire_cookie))],
TextContent("Hello, World!"),
),
Response(200, None, TextContent("Hello!")),
]
)
expect_cookie = False
async def middleware_for_assertions(request, next_handler):
cookie = request.cookies.get("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(
base_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_middlewares_can_be_applied_multiple_times_without_changing():
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) as client:
client.add_middlewares([middleware_one])
client.add_middlewares([middleware_two])
client.add_middlewares([middleware_three])
assert middleware_one in client._middlewares
assert middleware_two in client._middlewares
assert middleware_three in client._middlewares
client._build_middlewares_chain()
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!'
async def test_query_params(params, expected_query):
fake_pools = FakePools([Response(200, None, TextContent("Hello, World!"))])
async def middleware_for_assertions(request, next_handler):
assert expected_query == request.url.query
return await next_handler(request)
async with ClientSession(
base_url=b"http://localhost:8080",
pools=fake_pools,
middlewares=[middleware_for_assertions],
) as client:
await client.get(b"/", params=params)
await client.head(b"/", params=params)
await client.post(b"/", params=params)
await client.put(b"/", params=params)
await client.patch(b"/", params=params)
await client.delete(b"/", params=params)
await client.options(b"/", params=params)
await client.trace(b"/", params=params)
async def test_default_headers():
fake_pools = FakePools(
[Response(200, Headers(), TextContent('Hello, World!'))])
async def middleware_for_assertions(request, next_handler):
assert b'hello' in request.headers
assert request.headers.get_single(b'hello').value == b'World'
assert b'Foo' in request.headers
assert request.headers.get_single(b'Foo').value == b'Power'
return await next_handler(request)
async with ClientSession(url=b'http://localhost:8080',
pools=fake_pools,
middlewares=[middleware_for_assertions],
default_headers=[
Header(b'Hello', b'World'),
Header(b'Foo', b'Power')
]) as client:
await client.get(b'/')
async def test_single_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 with ClientSession(url=b'http://localhost:8080',
pools=fake_pools,
middlewares=[middleware_one]) as client:
response = await client.get(b'/')
assert steps == [1, 2]
assert response.status == 200
text = await response.text()
assert text == 'Hello, World!'
async def test_falsy_middleware():
fake_pools = FakePools([Response(200, None, 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 with ClientSession(
base_url=b"http://localhost:8080",
pools=fake_pools,
middlewares=[middleware_one, None, False], # type: ignore
) as client:
response = await client.get(b"/")
assert steps == [1, 2]
assert response.status == 200
text = await response.text()
assert text == "Hello, World!"
def session_alt(event_loop):
session = ClientSession(loop=event_loop,
default_headers=[(b'X-Default-One', b'AAA'),
(b'X-Default-Two', b'BBB')])
yield session
event_loop.run_until_complete(session.close())