async def test_request_headers_should_get_the_same_headers_as_the_server(
page: Page, server):
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.waitForEvent("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
assert request.headers == server_headers
async def test_should_work_when_file_input_is_attached_to_DOM(
page: Page, server):
await page.setContent("<input type=file>")
file_chooser = asyncio.create_task(page.waitForEvent("filechooser"))
await asyncio.sleep(0) # execute scheduled tasks, but don't await them
await page.click("input")
assert await file_chooser
async def test_should_return_the_same_file_chooser_when_there_are_many_watchdogs_simultaneously(
page: Page, server):
await page.setContent("<input type=file>")
results = await asyncio.gather(
page.waitForEvent("filechooser"),
page.waitForEvent("filechooser"),
page.evalOnSelector("input", "input => input.click()"),
)
assert results[0] == results[1]
async def test_should_be_able_to_reset_selected_files_with_empty_file_list(
page: Page, server
):
await page.setContent("<input type=file>")
page.once(
"filechooser",
lambda file_chooser: asyncio.create_task(file_chooser.setFiles(FILE_TO_UPLOAD)),
)
file_length_1 = (
await asyncio.gather(
page.waitForEvent("filechooser"),
page.evalOnSelector(
"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.setFiles([])),
)
file_length_2 = (
await asyncio.gather(
page.waitForEvent("filechooser"),
page.evalOnSelector(
"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_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_accept_single_file(page: Page, server):
await page.setContent('<input type=file oninput="javascript:console.timeStamp()">')
file_chooser = (
await asyncio.gather(page.waitForEvent("filechooser"), page.click("input"),)
)[0]
assert file_chooser.page == page
assert file_chooser.element
await file_chooser.setFiles(FILE_TO_UPLOAD)
assert await page.evalOnSelector("input", "input => input.files.length") == 1
assert (
await page.evalOnSelector("input", "input => input.files[0].name")
== "file-to-upload.txt"
)
async def test_should_report_downloads_with_acceptDownloads_false(page: Page, server):
await page.setContent(
f'<a href="{server.PREFIX}/downloadWithFilename">download</a>'
)
download = (await asyncio.gather(page.waitForEvent("download"), page.click("a")))[0]
assert download.url == f"{server.PREFIX}/downloadWithFilename"
assert download.suggestedFilename == "file.txt"
error: Optional[Error] = None
try:
await download.path()
except Error as exc:
error = exc
assert "acceptDownloads" in await download.failure()
assert error
assert "acceptDownloads: true" in error.message
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.waitForEvent("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].jsonValue() == "hello"
assert await message.args[1].jsonValue() == 5
assert await message.args[2].jsonValue() == {"foo": "bar"}
async def test_workers_should_emit_created_and_destroyed_events(page: Page):
worker_createdpromise = asyncio.create_task(page.waitForEvent("worker"))
await asyncio.sleep(0) # execute scheduled tasks, but don't await them
worker_obj = await page.evaluateHandle(
"() => new Worker(URL.createObjectURL(new Blob(['1'], {type: 'application/javascript'})))"
)
worker = await worker_createdpromise
worker_this_obj = await worker.evaluateHandle("() => this")
worker_destroyed_promise: Future[Worker] = asyncio.Future()
worker.once("close", lambda w: worker_destroyed_promise.set_result(w))
await page.evaluate("workerObj => workerObj.terminate()", worker_obj)
assert await worker_destroyed_promise == worker
with pytest.raises(Error) as exc:
await worker_this_obj.getProperty("self")
assert "Most likely the worker has been closed." in exc.value.message
