def test_stored_cookie_max_age_precedence():
cookie = Cookie("X-Foo", "Foo")
cookie.max_age = 0
cookie.expires = datetime.utcnow() + timedelta(days=2)
stored_cookie = StoredCookie(cookie)
assert stored_cookie.is_expired()
def test_stored_cookie_max_age_precedence():
cookie = Cookie(b'X-Foo', b'Foo')
cookie.set_max_age(0)
cookie.expiration = datetime.utcnow() + timedelta(days=2)
stored_cookie = StoredCookie(cookie)
assert stored_cookie.is_expired()
def test_raise_for_value_exceeding_length():
with pytest.raises(CookieValueExceedsMaximumLength):
Cookie("crash", "A" * 4967)
with pytest.raises(CookieValueExceedsMaximumLength):
Cookie("crash", "A" * 5000)
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'/')
def test_cookiejar_ignores_cookie_domain_set_as_ipaddress():
jar = CookieJar()
assert (jar.get_domain(
URL(b"https://foo.org/hello-world"),
Cookie(b"foo", b"foo", domain=b"192.168.1.5"),
) == b"foo.org")
def test_stored_cookie_handles_max_age():
stored = StoredCookie(Cookie(
b"name",
b"value",
max_age=b"20",
))
assert stored.expiry_time is not None
def test_get_cookies_for_url_ignores_secure_cookies_for_http():
jar = CookieJar()
jar.add(URL(b"https://foo.org"), Cookie(b"hello", b"world", secure=True))
cookies = list(jar.get_cookies_for_url(URL(b"http://foo.org/hello-world")))
assert len(cookies) == 0
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"/")
def test_write_cookie(
name,
value,
expires,
domain,
path,
http_only,
secure,
max_age,
same_site,
expected_result,
):
cookie = Cookie(
name,
value,
expires,
domain,
path,
http_only,
secure,
max_age,
same_site,
)
value = scribe.write_response_cookie(cookie)
assert value == expected_result
def test_stored_cookie_handles_max_age_value_error():
stored = StoredCookie(Cookie(
b"name",
b"value",
max_age=b"xx",
))
assert stored.expiry_time is None
def test_write_cookie(
name,
value,
expires,
domain,
path,
http_only,
secure,
max_age,
same_site,
expected_result,
):
cookie = Cookie(
name,
value,
datetime_to_cookie_format(expires) if expires else None,
domain,
path,
http_only,
secure,
datetime_to_cookie_format(max_age) if max_age else None,
same_site,
)
value = scribe.write_response_cookie(cookie)
assert value == expected_result
def test_cookie_jar_does_not_override_http_only_cookie_with_non_http_only_cookie(
):
jar = CookieJar()
jar.add(
URL(b"https://foo.org"),
Cookie(
b"hello",
b"world",
expires=datetime_to_cookie_format(datetime.utcnow() +
timedelta(days=2)),
http_only=True,
),
)
jar.add(
URL(b"https://foo.org"),
Cookie(
b"hello",
b"world2",
expires=datetime_to_cookie_format(datetime.utcnow() +
timedelta(days=2)),
http_only=True,
),
)
cookie = jar.get(b"foo.org", b"/", b"hello")
assert cookie is not None
assert cookie.cookie.value == b"world2"
jar.add(
URL(b"https://foo.org"),
Cookie(
b"hello",
b"world modified",
expires=datetime_to_cookie_format(datetime.utcnow() +
timedelta(days=2)),
http_only=False,
),
)
cookie = jar.get(b"foo.org", b"/", b"hello")
assert cookie is not None
assert cookie.cookie.value == b"world2"
def test_get_cookies_for_url():
jar = CookieJar()
jar.add(URL(b"https://foo.org"), Cookie("hello", "world"))
cookies = list(jar.get_cookies_for_url(URL(b"https://foo.org/hello-world")))
assert len(cookies) == 1
assert cookies[0].name == "hello"
assert cookies[0].value == "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
def test_get_cookies_for_url():
jar = CookieJar()
jar.add(URL(b'https://foo.org'), Cookie(b'hello', b'world'))
cookies = list(jar.get_cookies_for_url(
URL(b'https://foo.org/hello-world')))
assert len(cookies) == 1
assert cookies[0].name == b'hello'
assert cookies[0].value == b'world'
def test_cookie_jar_check_cookies_removes_expired():
jar = CookieJar()
# simulate an expired cookie that gets removed
jar._domain_cookies
jar._host_only_cookies = {
b"foo.org": {
b"/": {
b"hello":
StoredCookie(
Cookie(b"hello",
b"world",
expires=b"Fri, 17 Aug 2018 20:55:04 GMT"))
}
}
}
list(
jar._get_cookies_checking_exp(
b"https", jar._host_only_cookies[b"foo.org"][b"/"]))
assert jar.get(b"foo.org", b"/", b"hello") is None
def test_cookie_jar_check_cookies_removes_expired():
jar = CookieJar()
# simulate an expired cookie that gets removed
jar._domain_cookies
jar._host_only_cookies = {
"foo.org": {
"/": {
"hello": StoredCookie(
Cookie(
"hello",
"world",
expires=datetime_from_cookie_format(
b"Fri, 17 Aug 2018 20:55:04 GMT"
),
)
)
}
}
}
list(jar._get_cookies_checking_exp("https", jar._host_only_cookies["foo.org"]["/"]))
assert jar.get("foo.org", "/", "hello") is None
@pytest.mark.asyncio
@pytest.mark.parametrize(
'response,cookies,expected_result',
[(Response(400, Headers([
Header(b'Server', b'BlackSheep'),
]), Content(b'text/plain',
b'Hello, World')), [], b'HTTP/1.1 400 Bad Request\r\n'
b'Server: BlackSheep\r\n'
b'Content-Type: text/plain\r\n'
b'Content-Length: 12\r\n\r\nHello, World'),
(Response(400, Headers([
Header(b'Server', b'BlackSheep'),
]), Content(b'text/plain', b'Hello, World')),
[Cookie(b'session', b'123')], b'HTTP/1.1 400 Bad Request\r\n'
b'Server: BlackSheep\r\n'
b'Content-Type: text/plain\r\n'
b'Content-Length: 12\r\n'
b'Set-Cookie: session=123\r\n\r\nHello, World'),
(Response(400, Headers([Header(b'Server', b'BlackSheep')]),
Content(b'text/plain', b'Hello, World')), [
Cookie(b'session', b'123'),
Cookie(b'aaa', b'bbb', domain=b'bezkitu.org')
], b'HTTP/1.1 400 Bad Request\r\n'
b'Server: BlackSheep\r\n'
b'Content-Type: text/plain\r\n'
b'Content-Length: 12\r\n'
b'Set-Cookie: session=123\r\n'
b'Set-Cookie: aaa=bbb; Domain=bezkitu.org\r\n\r\nHello, World')])
async def test_write_http_response(response, cookies, expected_result):
def test_cookiejar_invalid_domain(request_url, cookie_domain):
jar = CookieJar()
cookie = Cookie(b'Name', b'Value', domain=cookie_domain)
with pytest.raises(InvalidCookieDomain):
jar.add(request_url, cookie)
def test_cookiejar_get_domain(request_url, cookie_domain, expected_domain):
jar = CookieJar()
cookie = Cookie(b'Name', b'Value', domain=cookie_domain)
domain = jar.get_domain(request_url, cookie)
assert domain == expected_domain
@pytest.mark.parametrize(
'request_url,cookie_domain',
[[URL(b'https://bezkitu.org'), b'example.com'],
[URL(b'https://foo.bezkitu.org'), b'baz.foo.bezkitu.org'],
[URL(b'https://foo.bezkitu.org'), b'foo.org']])
def test_cookiejar_invalid_domain(request_url, cookie_domain):
jar = CookieJar()
cookie = Cookie(b'Name', b'Value', domain=cookie_domain)
with pytest.raises(InvalidCookieDomain):
jar.add(request_url, cookie)
@pytest.mark.parametrize(
'cookie,expected_value',
[[Cookie(b'name', b'value'), False],
[
Cookie(b'name',
b'value',
expires=datetime_to_cookie_format(datetime.utcnow() +
timedelta(days=-20))), True
]])
def test_stored_cookie_is_expired(cookie, expected_value):
stored = StoredCookie(cookie)
expired = stored.is_expired()
assert expected_value == expired
@pytest.mark.asyncio
async def test_cookies_jar_single_cookie():
fake_pools = FakePools([
[URL(b"https://foo.bezkitu.org"), b"baz.foo.bezkitu.org"],
[URL(b"https://foo.bezkitu.org"), b"foo.org"],
],
)
def test_cookiejar_invalid_domain(request_url, cookie_domain):
jar = CookieJar()
cookie = Cookie(b"Name", b"Value", domain=cookie_domain)
with pytest.raises(InvalidCookieDomain):
jar.add(request_url, cookie)
@pytest.mark.parametrize(
"cookie,expected_value",
[
[Cookie(b"name", b"value"), False],
[
Cookie(
b"name",
b"value",
expires=datetime_to_cookie_format(datetime.utcnow() +
timedelta(days=-20)),
),
True,
],
],
)
def test_stored_cookie_is_expired(cookie, expected_value):
stored = StoredCookie(cookie)
expired = stored.is_expired()
assert expected_value == expired
[
(
Response(400, [(b"Server", b"BlackSheep")]).with_content(
Content(b"text/plain", b"Hello, World")
),
[],
b"HTTP/1.1 400 Bad Request\r\n"
b"Server: BlackSheep\r\n"
b"content-type: text/plain\r\n"
b"content-length: 12\r\n\r\nHello, World",
),
(
Response(400, [(b"Server", b"BlackSheep")]).with_content(
Content(b"text/plain", b"Hello, World")
),
[Cookie("session", "123")],
b"HTTP/1.1 400 Bad Request\r\n"
b"Server: BlackSheep\r\n"
b"set-cookie: session=123\r\n"
b"content-type: text/plain\r\n"
b"content-length: 12\r\n\r\nHello, World",
),
(
Response(400, [(b"Server", b"BlackSheep")]).with_content(
Content(b"text/plain", b"Hello, World")
),
[Cookie("session", "123"), Cookie("aaa", "bbb", domain="bezkitu.org")],
b"HTTP/1.1 400 Bad Request\r\n"
b"Server: BlackSheep\r\n"
b"set-cookie: session=123\r\n"
b"set-cookie: aaa=bbb; Domain=bezkitu.org\r\n"
async def set_cookies(name: FromQuery(str), value: FromQuery(str)):
response = text('Setting cookie')
response.set_cookie(Cookie(name.encode(), value.encode()))
return response
@pytest.mark.parametrize('response,cookies,expected_result', [
(
Response(400, [
(b'Server', b'BlackSheep'),
]).with_content(Content(b'text/plain', b'Hello, World')),
[],
b'HTTP/1.1 400 Bad Request\r\n'
b'Server: BlackSheep\r\n'
b'content-type: text/plain\r\n'
b'content-length: 12\r\n\r\nHello, World'
),
(
Response(400, [
(b'Server', b'BlackSheep'),
]).with_content(Content(b'text/plain', b'Hello, World')),
[Cookie(b'session', b'123')],
b'HTTP/1.1 400 Bad Request\r\n'
b'Server: BlackSheep\r\n'
b'set-cookie: session=123\r\n'
b'content-type: text/plain\r\n'
b'content-length: 12\r\n\r\nHello, World'
),
(
Response(400, [
(b'Server', b'BlackSheep')
]).with_content(Content(b'text/plain', b'Hello, World')),
[Cookie(b'session', b'123'), Cookie(b'aaa', b'bbb', domain=b'bezkitu.org')],
b'HTTP/1.1 400 Bad Request\r\n'
b'Server: BlackSheep\r\n'
b'set-cookie: session=123\r\n'
b'set-cookie: aaa=bbb; Domain=bezkitu.org\r\n'
async def set_cookies(name: FromQuery[str], value: FromQuery[str]):
response = text("Setting cookie")
response.set_cookie(Cookie(name.value, value.value))
return response
[
(
Response(400, [(b"Server", b"BlackSheep")]).with_content(
Content(b"text/plain", b"Hello, World")
),
[],
b"HTTP/1.1 400 Bad Request\r\n"
b"Server: BlackSheep\r\n"
b"content-type: text/plain\r\n"
b"content-length: 12\r\n\r\nHello, World",
),
(
Response(400, [(b"Server", b"BlackSheep")]).with_content(
Content(b"text/plain", b"Hello, World")
),
[Cookie(b"session", b"123")],
b"HTTP/1.1 400 Bad Request\r\n"
b"Server: BlackSheep\r\n"
b"set-cookie: session=123\r\n"
b"content-type: text/plain\r\n"
b"content-length: 12\r\n\r\nHello, World",
),
(
Response(400, [(b"Server", b"BlackSheep")]).with_content(
Content(b"text/plain", b"Hello, World")
),
[Cookie(b"session", b"123"), Cookie(b"aaa", b"bbb", domain=b"bezkitu.org")],
b"HTTP/1.1 400 Bad Request\r\n"
b"Server: BlackSheep\r\n"
b"set-cookie: session=123\r\n"
b"set-cookie: aaa=bbb; Domain=bezkitu.org\r\n"
[URL(b"https://foo.bezkitu.org"), "baz.foo.bezkitu.org"],
[URL(b"https://foo.bezkitu.org"), "foo.org"],
],
)
def test_cookiejar_invalid_domain(request_url, cookie_domain):
jar = CookieJar()
cookie = Cookie("Name", "Value", domain=cookie_domain)
with pytest.raises(InvalidCookieDomain):
jar.add(request_url, cookie)
@pytest.mark.parametrize(
"cookie,expected_value",
[
[Cookie("name", "value"), False],
[
Cookie("name", "value", expires=datetime.utcnow() + timedelta(days=-20)),
True,
],
],
)
def test_stored_cookie_is_expired(cookie, expected_value):
stored = StoredCookie(cookie)
expired = stored.is_expired()
assert expected_value == expired
def test_stored_cookie_handles_max_age_value_error():
stored = StoredCookie(
Cookie(
