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"