async def test_should_give_access_to_the_intercepted_response(
page: Page, server: Server):
await page.goto(server.EMPTY_PAGE)
route_task = asyncio.Future()
await page.route("**/title.html",
lambda route: route_task.set_result(route))
eval_task = asyncio.create_task(
page.evaluate("url => fetch(url)", server.PREFIX + "/title.html"))
route = await route_task
response = await page.request.fetch(route.request)
assert response.status == 200
assert response.status_text == "OK"
assert response.ok is True
assert response.url.endswith("/title.html") is True
assert response.headers["content-type"] == "text/html; charset=utf-8"
assert list(
filter(
lambda header: header["name"].lower() == "content-type",
response.headers_array,
)) == [{
"name": "Content-Type",
"value": "text/html; charset=utf-8"
}]
await asyncio.gather(
route.fulfill(response=response),
eval_task,
)
async def test_should_amend_binary_post_data(page: Page,
context: BrowserContext,
server: Server):
await page.goto(server.EMPTY_PAGE)
post_data_buffer = []
await context.route(
"**/*",
lambda route: (
post_data_buffer.append(route.request.post_data),
asyncio.create_task(route.continue_()),
),
)
await context.route(
"**/*",
lambda route: asyncio.create_task(
route.fallback(post_data=b"\x00\x01\x02\x03\x04")),
)
[server_request, result] = await asyncio.gather(
server.wait_for_request("/sleep.zzz"),
page.evaluate(
"fetch('/sleep.zzz', { method: 'POST', body: 'birdy' })"),
)
# 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"
async def test_page_events_request_should_report_requests_and_responses_handled_by_service_worker(
page: Page, server):
await page.goto(server.PREFIX + "/serviceworkers/fetchdummy/sw.html")
await page.evaluate("() => window.activationPromise")
[request, sw_response
] = await asyncio.gather(page.waitForEvent("request"),
page.evaluate('() => fetchDummy("foo")'))
assert sw_response == "responseFromServiceWorker:foo"
assert request.url == server.PREFIX + "/serviceworkers/fetchdummy/foo"
response = await request.response()
assert response.url == server.PREFIX + "/serviceworkers/fetchdummy/foo"
assert await response.text() == "responseFromServiceWorker:foo"
async def test_should_delete_header_with_undefined_value(
page: Page, context: BrowserContext, server: Server) -> None:
await 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 = []
async def capture_and_continue(route: Route, request: Request):
intercepted_request.append(request)
await route.continue_()
await context.route("**/*", capture_and_continue)
async def delete_foo_header(route: Route, request: Request):
headers = await request.all_headers()
await route.fallback(headers={**headers, "foo": None})
await context.route(server.PREFIX + "/something", delete_foo_header)
[server_req, text] = await asyncio.gather(
server.wait_for_request("/something"),
page.evaluate(
"""
async url => {
const data = await fetch(url, {
headers: {
foo: 'a',
bar: 'b',
}
});
return data.text();
}
""",
server.PREFIX + "/something",
),
)
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"
async def test_console_should_work(page: Page, server):
messages: List[ConsoleMessage] = []
page.once("console", lambda m: messages.append(m))
await asyncio.gather(
page.evaluate('() => console.log("hello", 5, {foo: "bar"})'),
page.wait_for_event("console"),
)
assert len(messages) == 1
message = messages[0]
assert message.text == "hello 5 JSHandle@object"
assert str(message) == "hello 5 JSHandle@object"
assert message.type == "log"
assert await message.args[0].json_value() == "hello"
assert await message.args[1].json_value() == 5
assert await message.args[2].json_value() == {"foo": "bar"}
async def test_should_give_access_to_the_intercepted_response_body(
page: Page, server: Server):
await page.goto(server.EMPTY_PAGE)
route_task = asyncio.Future()
await page.route("**/simple.json",
lambda route: route_task.set_result(route))
eval_task = asyncio.create_task(
page.evaluate("url => fetch(url)", server.PREFIX + "/simple.json"))
route = await route_task
response = await page.request.fetch(route.request)
assert await response.text() == '{"foo": "bar"}\n'
await asyncio.gather(
route.fulfill(response=response),
eval_task,
)
async def test_should_amend_post_data(page: Page, server: Server) -> None:
await page.goto(server.EMPTY_PAGE)
post_data = []
await page.route(
"**/*",
lambda route: (
post_data.append(route.request.post_data),
asyncio.create_task(route.continue_()),
),
)
await page.route(
"**/*",
lambda route: asyncio.create_task(route.fallback(post_data="doggo")))
[server_request, _] = await asyncio.gather(
server.wait_for_request("/sleep.zzz"),
page.evaluate(
"() => fetch('/sleep.zzz', { method: 'POST', body: 'birdy' })"),
)
assert post_data == ["doggo"]
assert server_request.post_body == b"doggo"
async def test_should_amend_method(page: Page, server: Server) -> None:
await page.goto(server.EMPTY_PAGE)
method = []
await page.route(
"**/*",
lambda route: (
method.append(route.request.method),
asyncio.create_task(route.continue_()),
),
)
await page.route(
"**/*",
lambda route: asyncio.create_task(route.fallback(method="POST")))
[request, _] = await asyncio.gather(
server.wait_for_request("/sleep.zzz"),
page.evaluate("() => fetch('/sleep.zzz')"),
)
assert method == ["POST"]
assert request.method == b"POST"
