async def test_request_headers_should_get_the_same_headers_as_the_server_cors(
page: Page, server, is_webkit, is_win
):
await page.goto(server.PREFIX + "/empty.html")
server_request_headers_future: Future[Dict[str, str]] = asyncio.Future()
def handle_something(request):
normalized_headers = {
key.decode().lower(): value[0].decode()
for key, value in request.requestHeaders.getAllRawHeaders()
}
server_request_headers_future.set_result(normalized_headers)
request.setHeader("Access-Control-Allow-Origin", "*")
request.write(b"done")
request.finish()
server.set_route("/something", handle_something)
requestPromise = asyncio.create_task(page.wait_for_event("request"))
text = await page.evaluate(
"""async url => {
const data = await fetch(url);
return data.text();
}""",
server.CROSS_PROCESS_PREFIX + "/something",
)
request: Request = await requestPromise
assert text == "done"
server_headers = await server_request_headers_future
if is_webkit and is_win:
# Curl does not show accept-encoding and accept-language
server_headers.pop("accept-encoding")
server_headers.pop("accept-language")
assert request.headers == server_headers
async def test_should_override_request_url(page: Page, context: BrowserContext,
server: Server) -> None:
url = []
await context.route(
"**/global-var.html",
lambda route: (
url.append(route.request.url),
asyncio.create_task(route.continue_()),
),
)
await context.route(
"**/foo",
lambda route: asyncio.create_task(
route.fallback(url=server.PREFIX + "/global-var.html")),
)
[server_request, response, _] = await asyncio.gather(
server.wait_for_request("/global-var.html"),
page.wait_for_event("response"),
page.goto(server.PREFIX + "/foo"),
)
assert url == [server.PREFIX + "/global-var.html"]
assert response.url == server.PREFIX + "/foo"
assert await page.evaluate("() => window['globalVar']") == 123
assert server_request.uri == b"/global-var.html"
assert server_request.method == b"GET"
async def test_should_return_the_same_file_chooser_when_there_are_many_watchdogs_simultaneously(
page: Page, ):
await page.set_content("<input type=file>")
results = await asyncio.gather(
page.wait_for_event("filechooser"),
page.wait_for_event("filechooser"),
page.eval_on_selector("input", "input => input.click()"),
)
assert results[0] == results[1]
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.wait_for_event("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_accept_single_file(page: Page, server):
await page.set_content(
'<input type=file oninput="javascript:console.timeStamp()">')
file_chooser = (await asyncio.gather(
page.wait_for_event("filechooser"),
page.click("input"),
))[0]
assert file_chooser.page == page
assert file_chooser.element
await file_chooser.set_files(FILE_TO_UPLOAD)
assert await page.eval_on_selector("input",
"input => input.files.length") == 1
assert (await page.eval_on_selector(
"input", "input => input.files[0].name") == "file-to-upload.txt")
async def test_should_be_able_to_reset_selected_files_with_empty_file_list(
page: Page, server):
await page.set_content("<input type=file>")
page.once(
"filechooser",
lambda file_chooser: asyncio.create_task(
file_chooser.set_files(FILE_TO_UPLOAD)),
)
file_length_1 = (await asyncio.gather(
page.wait_for_event("filechooser"),
page.eval_on_selector(
"input",
"""async picker => {
picker.click();
await new Promise(x => picker.oninput = x);
return picker.files.length;
}""",
),
))[1]
assert file_length_1 == 1
page.once(
"filechooser",
lambda file_chooser: asyncio.create_task(file_chooser.set_files([])),
)
file_length_2 = (await asyncio.gather(
page.wait_for_event("filechooser"),
page.eval_on_selector(
"input",
"""async picker => {
picker.click()
await new Promise(x => picker.oninput = x)
return picker.files.length
}""",
),
))[1]
assert file_length_2 == 0
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_report_downloads_with_accept_downloads_false(
page: Page, server):
await page.set_content(
f'<a href="{server.PREFIX}/downloadWithFilename">download</a>')
download = (await asyncio.gather(page.wait_for_event("download"),
page.click("a")))[0]
assert download.url == f"{server.PREFIX}/downloadWithFilename"
assert download.suggested_filename == "file.txt"
error: Optional[Error] = None
try:
await download.path()
except Error as exc:
error = exc
assert "accept_downloads" in await download.failure()
assert error
assert "accept_downloads: True" in error.message
