def test_should_propagate_extra_http_headers_with_redirects(
playwright: Playwright, server: Server) -> None:
server.set_redirect("/a/redirect1", "/b/c/redirect2")
server.set_redirect("/b/c/redirect2", "/simple.json")
request = playwright.request.new_context(
extra_http_headers={"My-Secret": "Value"})
with server.expect_request("/a/redirect1") as server_req1:
with server.expect_request("/b/c/redirect2") as server_req2:
with server.expect_request("/simple.json") as server_req3:
request.get(f"{server.PREFIX}/a/redirect1"),
assert server_req1.value.getHeader("my-secret") == "Value"
assert server_req2.value.getHeader("my-secret") == "Value"
assert server_req3.value.getHeader("my-secret") == "Value"
def test_should_support_multipart_form_data(context: BrowserContext,
server: Server) -> None:
file: FilePayload = {
"name": "f.js",
"mimeType": "text/javascript",
"buffer": b"var x = 10;\r\n;console.log(x);",
}
with server.expect_request("/empty.html") as server_req:
context.request.post(
server.PREFIX + "/empty.html",
multipart={
"firstName": "John",
"lastName": "Doe",
"file": file,
},
)
assert server_req.value.method == b"POST"
content_type = server_req.value.getHeader("Content-Type")
assert content_type
assert content_type.startswith("multipart/form-data; ")
assert server_req.value.getHeader("Content-Length") == str(
len(server_req.value.post_body) # type: ignore
)
assert server_req.value.args[b"firstName"] == [b"John"]
assert server_req.value.args[b"lastName"] == [b"Doe"]
assert server_req.value.args[b"file"][0] == file["buffer"]
def test_should_add_default_headers(context: BrowserContext, page: Page,
server: Server) -> None:
with server.expect_request("/empty.html") as server_req:
context.request.get(server.EMPTY_PAGE)
assert server_req.value.getHeader("Accept") == "*/*"
assert server_req.value.getHeader("Accept-Encoding") == "gzip,deflate,br"
assert server_req.value.getHeader("User-Agent") == page.evaluate(
"() => navigator.userAgent")
def test_should_use_playwright_as_a_user_agent(playwright: Playwright,
server: Server) -> None:
request = playwright.request.new_context()
with server.expect_request("/empty.html") as server_req:
request.get(server.EMPTY_PAGE),
assert str(
server_req.value.getHeader("User-Agent")).startswith("Playwright/")
request.dispose()
def test_should_support_query_params(context: BrowserContext, server: Server,
method: str) -> None:
expected_params = {"p1": "v1", "парам2": "знач2"}
with server.expect_request("/empty.html") as server_req:
getattr(context.request, method)(server.EMPTY_PAGE + "?p1=foo",
params=expected_params)
assert server_req.value.args["p1".encode()][0].decode() == "v1"
assert len(server_req.value.args["p1".encode()]) == 1
assert server_req.value.args["парам2".encode()][0].decode() == "знач2"
def test_should_support_global_user_agent_option(playwright: Playwright,
server: Server) -> None:
request = playwright.request.new_context(user_agent="My Agent")
response = request.get(server.PREFIX + "/empty.html")
with server.expect_request("/empty.html") as server_req:
request.get(server.EMPTY_PAGE)
assert response.ok is True
assert response.url == server.EMPTY_PAGE
assert server_req.value.getHeader("user-agent") == "My Agent"
def test_should_add_session_cookies_to_request(context: BrowserContext,
server: Server) -> None:
context.add_cookies([{
"name": "username",
"value": "John Doe",
"url": server.EMPTY_PAGE,
"expires": -1,
"httpOnly": False,
"secure": False,
"sameSite": "Lax",
}])
with server.expect_request("/empty.html") as server_req:
context.request.get(server.EMPTY_PAGE)
assert server_req.value.getHeader("Cookie") == "username=John Doe"
def test_should_not_add_context_cookie_if_cookie_header_passed_as_parameter(
context: BrowserContext, server: Server) -> None:
context.add_cookies([{
"name": "username",
"value": "John Doe",
"url": server.EMPTY_PAGE,
"expires": -1,
"httpOnly": False,
"secure": False,
"sameSite": "Lax",
}])
with server.expect_request("/empty.html") as server_req:
context.request.get(server.EMPTY_PAGE, headers={"Cookie": "foo=bar"})
assert server_req.value.getHeader("Cookie") == "foo=bar"
def test_should_support_fulfill_after_intercept(page: Page, server: Server,
assetdir: Path) -> None:
def handle_route(route: Route) -> None:
response = page.request.fetch(route.request)
route.fulfill(response=response)
page.route("**", handle_route)
with server.expect_request("/title.html") as request_info:
response = page.goto(server.PREFIX + "/title.html")
assert response
request = request_info.value
assert request.uri.decode() == "/title.html"
original = (assetdir / "title.html").read_text()
assert response.text() == original
def test_should_amend_post_data(page: Page, server: Server) -> None:
page.goto(server.EMPTY_PAGE)
post_data = []
page.route(
"**/*",
lambda route: (
post_data.append(route.request.post_data),
route.continue_(),
),
)
page.route("**/*", lambda route: route.fallback(post_data="doggo"))
with server.expect_request("/sleep.zzz") as server_request_info:
page.evaluate("() => fetch('/sleep.zzz', { method: 'POST', body: 'birdy' })"),
server_request = server_request_info.value
assert post_data == ["doggo"]
assert server_request.post_body == b"doggo"
def test_should_amend_method(page: Page, server: Server) -> None:
page.goto(server.EMPTY_PAGE)
method = []
page.route(
"**/*",
lambda route: (
method.append(route.request.method),
route.continue_(),
),
)
page.route("**/*", lambda route: route.fallback(method="POST"))
with server.expect_request("/sleep.zzz") as request_info:
page.evaluate("() => fetch('/sleep.zzz')")
request = request_info.value
assert method == ["POST"]
assert request.method == b"POST"
def test_should_delete_header_with_undefined_value(page: Page, server: Server) -> None:
page.goto(server.EMPTY_PAGE)
server.set_route(
"/something",
lambda r: (
r.setHeader("Acces-Control-Allow-Origin", "*"),
r.write(b"done"),
r.finish(),
),
)
intercepted_request = []
def capture_and_continue(route: Route, request: Request):
intercepted_request.append(request)
route.continue_()
page.route("**/*", capture_and_continue)
def delete_foo_header(route: Route, request: Request):
headers = request.all_headers()
route.fallback(headers={**headers, "foo": None})
page.route(server.PREFIX + "/something", delete_foo_header)
with server.expect_request("/something") as server_req_info:
text = page.evaluate(
"""
async url => {
const data = await fetch(url, {
headers: {
foo: 'a',
bar: 'b',
}
});
return data.text();
}
""",
server.PREFIX + "/something",
)
server_req = server_req_info.value
assert text == "done"
assert not intercepted_request[0].headers.get("foo")
assert intercepted_request[0].headers.get("bar") == "b"
assert not server_req.getHeader("foo")
assert server_req.getHeader("bar") == "b"
def test_should_amend_binary_post_data(page: Page, server: Server) -> None:
page.goto(server.EMPTY_PAGE)
post_data_buffer = []
page.route(
"**/*",
lambda route: (
post_data_buffer.append(route.request.post_data),
route.continue_(),
),
)
page.route("**/*", lambda route: route.fallback(post_data=b"\x00\x01\x02\x03\x04"))
with server.expect_request("/sleep.zzz") as server_request_info:
page.evaluate("() => fetch('/sleep.zzz', { method: 'POST', body: 'birdy' })")
server_request = server_request_info.value
# FIXME: should this be bytes?
assert post_data_buffer == ["\x00\x01\x02\x03\x04"]
assert server_request.method == b"POST"
assert server_request.post_body == b"\x00\x01\x02\x03\x04"
def test_should_support_application_x_www_form_urlencoded(
context: BrowserContext, server: Server) -> None:
with server.expect_request("/empty.html") as server_req:
context.request.post(
server.PREFIX + "/empty.html",
form={
"firstName": "John",
"lastName": "Doe",
"file": "f.js",
},
)
assert server_req.value.method == b"POST"
assert (server_req.value.getHeader("Content-Type") ==
"application/x-www-form-urlencoded")
body = server_req.value.post_body.decode() # type: ignore
assert server_req.value.getHeader("Content-Length") == str(len(body))
params: Dict[bytes, List[bytes]] = parse_qs(
server_req.value.post_body) # type: ignore
assert params[b"firstName"] == [b"John"]
assert params[b"lastName"] == [b"Doe"]
assert params[b"file"] == [b"f.js"]
def test_should_override_request_url(page: Page, server: Server) -> None:
url = []
page.route(
"**/global-var.html",
lambda route: (
url.append(route.request.url),
route.continue_(),
),
)
page.route(
"**/foo",
lambda route: route.fallback(url=server.PREFIX + "/global-var.html"),
)
with server.expect_request("/global-var.html") as server_request_info:
with page.expect_event("response") as response_info:
page.goto(server.PREFIX + "/foo")
server_request = server_request_info.value
response = response_info.value
assert url == [server.PREFIX + "/global-var.html"]
assert response.url == server.PREFIX + "/foo"
assert page.evaluate("() => window['globalVar']") == 123
assert server_request.uri == b"/global-var.html"
assert server_request.method == b"GET"
