def test_add_init_script_work_with_browser_context_scripts_for_already_created_pages(
page: Page, context: BrowserContext) -> None:
context.add_init_script("window.temp = 123")
page.add_init_script("window.injected = window.temp")
page.goto(
"data:text/html,<script>window.result = window.injected</script>")
assert page.evaluate("window.result") == 123
def test_should_round_trip_through_the_file(browser: Browser,
context: BrowserContext,
tmpdir: Path) -> None:
page1 = context.new_page()
page1.route(
"**/*",
lambda route: route.fulfill(body="<html></html>"),
)
page1.goto("https://www.example.com")
page1.evaluate("""() => {
localStorage["name1"] = "value1"
document.cookie = "username=John Doe"
return document.cookie
}""")
path = tmpdir / "storage-state.json"
state = context.storage_state(path=path)
with open(path, "r") as f:
written = json.load(f)
assert state == written
context2 = browser.new_context(storage_state=path)
page2 = context2.new_page()
page2.route(
"**/*",
lambda route: route.fulfill(body="<html></html>"),
)
page2.goto("https://www.example.com")
local_storage = page2.evaluate("window.localStorage")
assert local_storage == {"name1": "value1"}
cookie = page2.evaluate("document.cookie")
assert cookie == "username=John Doe"
context2.close()
def test_add_init_script_work_with_browser_context_scripts_with_a_path(
page: Page, context: BrowserContext, assetdir: Path) -> None:
context.add_init_script(path=assetdir / "injectedfile.js")
page = context.new_page()
page.goto(
"data:text/html,<script>window.result = window.injected</script>")
assert page.evaluate("window.result") == 123
def test_should_capture_local_storage(context: BrowserContext) -> None:
page1 = context.new_page()
page1.route("**/*", lambda route: route.fulfill(body="<html></html>"))
page1.goto("https://www.example.com")
page1.evaluate("localStorage['name1'] = 'value1'")
page1.goto("https://www.domain.com")
page1.evaluate("localStorage['name2'] = 'value2'")
state = context.storage_state()
origins = state["origins"]
assert origins
assert len(origins) == 2
assert origins[0] == {
"origin": "https://www.example.com",
"localStorage": [{
"name": "name1",
"value": "value1"
}],
}
assert origins[1] == {
"origin": "https://www.domain.com",
"localStorage": [{
"name": "name2",
"value": "value2"
}],
}
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_fulfill_response_with_empty_body(page: Page,
context: BrowserContext,
server: Server) -> None:
def handle(route: Route) -> None:
response = page.request.fetch(route.request)
route.fulfill(response=response,
status=201,
body="",
headers={"content-length": "0"})
context.route("**/*", handle)
response = page.goto(server.PREFIX + "/title.html")
assert response
assert response.status == 201
assert response.text() == ""
def test_should_support_fulfill_after_intercept(page: Page,
context: BrowserContext,
server: Server,
assetdir: Path) -> None:
def handle_route(route: Route) -> None:
response = page.request.fetch(route.request)
route.fulfill(response=response)
context.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 page(context: BrowserContext,
base_url: str) -> Generator[Page, None, None]:
page = context.new_page()
page._goto = page.goto # type: ignore
page.goto = lambda *args, **kwargs: _handle_page_goto( # type: ignore
page, list(args), kwargs, base_url)
yield page
page.close()
def test_close_should_reject_all_promises(context: BrowserContext) -> None:
new_page = context.new_page()
with pytest.raises(Error) as exc_info:
new_page._gather(
lambda: new_page.evaluate("() => new Promise(r => {})"),
lambda: new_page.close(),
)
assert "Target closed" in exc_info.value.message
def test_should_fulfill_with_any_response(page: Page, context: BrowserContext,
server: Server) -> None:
def server_handler(request: http.Request) -> None:
request.setHeader("foo", "bar")
request.write("Woo-hoo".encode())
request.finish()
server.set_route("/sample", server_handler)
sample_response = page.request.get(server.PREFIX + "/sample")
context.route(
"**/*",
lambda route: route.fulfill(
response=sample_response, status=201, content_type="text/plain"),
)
response = page.goto(server.EMPTY_PAGE)
assert response
assert response.status == 201
assert response.text() == "Woo-hoo"
assert response.headers["foo"] == "bar"
def test_bing_is_working(context: BrowserContext):
page = context.newPage()
page.setContent('<a href="https://bing.com" target="_blank">link</a>')
with page.expect_popup() as popup_event:
page.click('text=link')
popup = popup_event.value
assert 'bing.com' in popup.url
popup.bringToFront()
def test_should_fulfill_intercepted_response(page: Page,
context: BrowserContext,
server: Server) -> None:
def handle(route: Route) -> None:
response = page.request.fetch(route.request)
route.fulfill(
response=response,
status=201,
headers={"foo": "bar"},
content_type="text/plain",
body="Yo, page!",
)
context.route("**/*", handle)
response = page.goto(server.PREFIX + "/empty.html")
assert response
assert response.status == 201
assert response.headers["foo"] == "bar"
assert response.headers["content-type"] == "text/plain"
assert page.evaluate("() => document.body.textContent") == "Yo, page!"
def page(context: BrowserContext,
base_url: str) -> Generator[Page, None, None]:
page = context.new_page()
page._goto = page.goto # type: ignore
page.goto = lambda *args, **kwargs: _handle_page_goto( # type: ignore
page, list(args), kwargs, base_url)
yield page
# save off the test unique id
current_path_name = context.pages[0].video.path()
BrowserContext.current_video_name = current_path_name
page.close()
def test_should_override_with_defaults_when_intercepted_response_not_provided(
page: Page, context: BrowserContext, server: Server,
browser_name: str) -> None:
def server_handler(request: http.Request) -> None:
request.setHeader("foo", "bar")
request.write("my content".encode())
request.finish()
server.set_route("/empty.html", server_handler)
def handle(route: Route) -> None:
page.request.fetch(route.request)
route.fulfill(status=201)
context.route("**/*", handle)
response = page.goto(server.EMPTY_PAGE)
assert response
assert response.status == 201
assert response.text() == ""
if browser_name == "webkit":
assert response.headers == {"content-type": "text/plain"}
else:
assert response.headers == {}
def test_sync_handle_multiple_pages(context: BrowserContext) -> None:
page1 = context.new_page()
page2 = context.new_page()
assert len(context.pages) == 2
page1.set_content("one")
page2.set_content("two")
assert "one" in page1.content()
assert "two" in page2.content()
page1.close()
assert len(context.pages) == 1
page2.close()
assert len(context.pages) == 0
for page in [page1, page2]:
with pytest.raises(Error):
page.content()
def _page(context: BrowserContext) -> t.Generator[Page, None, None]:
page = context.new_page()
yield page
def page(context: BrowserContext) -> Generator[Page, None, None]:
page = context.new_page()
yield page
page.close()
