')
loaded.append(True)
content_promise = asyncio.create_task(load())
diff --git a/tests/async/test_page_network_response.py b/tests/async/test_page_network_response.py
new file mode 100644
index 000000000..52dd6e64a
--- /dev/null
+++ b/tests/async/test_page_network_response.py
@@ -0,0 +1,72 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+
+import pytest
+
+from playwright.async_api import Page
+from tests.server import HttpRequestWithPostBody, Server
+
+
+async def test_should_reject_response_finished_if_page_closes(
+ page: Page, server: Server
+) -> None:
+ await page.goto(server.EMPTY_PAGE)
+
+ def handle_get(request: HttpRequestWithPostBody):
+ # In Firefox, |fetch| will be hanging until it receives |Content-Type| header
+ # from server.
+ request.setHeader("Content-Type", "text/plain; charset=utf-8")
+ request.write(b"hello ")
+
+ server.set_route("/get", handle_get)
+ # send request and wait for server response
+ [page_response, _] = await asyncio.gather(
+ page.wait_for_event("response"),
+ page.evaluate("() => fetch('./get', { method: 'GET' })"),
+ )
+
+ finish_coroutine = page_response.finished()
+ await page.close()
+ with pytest.raises(Exception) as exc_info:
+ await finish_coroutine
+ error = exc_info.value
+ assert "closed" in error.message
+
+
+async def test_should_reject_response_finished_if_context_closes(
+ page: Page, server: Server
+) -> None:
+ await page.goto(server.EMPTY_PAGE)
+
+ def handle_get(request: HttpRequestWithPostBody):
+ # In Firefox, |fetch| will be hanging until it receives |Content-Type| header
+ # from server.
+ request.setHeader("Content-Type", "text/plain; charset=utf-8")
+ request.write(b"hello ")
+
+ server.set_route("/get", handle_get)
+ # send request and wait for server response
+ [page_response, _] = await asyncio.gather(
+ page.wait_for_event("response"),
+ page.evaluate("() => fetch('./get', { method: 'GET' })"),
+ )
+
+ finish_coroutine = page_response.finished()
+ await page.context.close()
+ with pytest.raises(Exception) as exc_info:
+ await finish_coroutine
+ error = exc_info.value
+ assert "closed" in error.message
diff --git a/tests/async/test_page_request_intercept.py b/tests/async/test_page_request_intercept.py
index 9b41d9630..bda57cf44 100644
--- a/tests/async/test_page_request_intercept.py
+++ b/tests/async/test_page_request_intercept.py
@@ -18,6 +18,22 @@
from tests.server import Server
+async def test_should_not_follow_redirects_when_max_redirects_is_set_to_0_in_route_fetch(
+ server: Server, page: Page
+):
+ server.set_redirect("/foo", "/empty.html")
+
+ async def handle(route: Route):
+ response = await route.fetch(max_redirects=0)
+ assert response.headers["location"] == "/empty.html"
+ assert response.status == 302
+ await route.fulfill(body="hello")
+
+ await page.route("**/*", lambda route: handle(route))
+ await page.goto(server.PREFIX + "/foo")
+ assert "hello" in await page.content()
+
+
async def test_should_intercept_with_url_override(server: Server, page: Page):
async def handle(route: Route):
response = await route.fetch(url=server.PREFIX + "/one-style.html")
diff --git a/tests/async/test_resource_timing.py b/tests/async/test_resource_timing.py
index a948b9f6c..17ea0e10b 100644
--- a/tests/async/test_resource_timing.py
+++ b/tests/async/test_resource_timing.py
@@ -32,7 +32,7 @@ async def test_should_work(page, server):
@flaky
async def test_should_work_for_subresource(page, server, is_win, is_mac, is_webkit):
- if is_webkit and is_win:
+ if is_webkit and (is_mac or is_win):
pytest.skip()
requests = []
page.on("requestfinished", lambda request: requests.append(request))
diff --git a/tests/async/test_selectors_get_by.py b/tests/async/test_selectors_get_by.py
index 46a3ef1bc..88cb50947 100644
--- a/tests/async/test_selectors_get_by.py
+++ b/tests/async/test_selectors_get_by.py
@@ -12,7 +12,80 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-from playwright.async_api import Page
+from playwright.async_api import Page, expect
+
+
+async def test_get_by_escaping(page: Page) -> None:
+ await page.set_content(
+ """
+ """
+ )
+ await page.eval_on_selector(
+ "input",
+ """input => {
+ input.setAttribute('placeholder', 'hello my\\nwo"rld');
+ input.setAttribute('title', 'hello my\\nwo"rld');
+ input.setAttribute('alt', 'hello my\\nwo"rld');
+ }""",
+ )
+ await expect(page.get_by_text('hello my\nwo"rld')).to_have_attribute("id", "label")
+ await expect(page.get_by_text('hello my wo"rld')).to_have_attribute(
+ "id", "label"
+ )
+ await expect(page.get_by_label('hello my\nwo"rld')).to_have_attribute(
+ "id", "control"
+ )
+ await expect(page.get_by_placeholder('hello my\nwo"rld')).to_have_attribute(
+ "id", "control"
+ )
+ await expect(page.get_by_alt_text('hello my\nwo"rld')).to_have_attribute(
+ "id", "control"
+ )
+ await expect(page.get_by_title('hello my\nwo"rld')).to_have_attribute(
+ "id", "control"
+ )
+
+ await page.set_content(
+ """
+ """
+ )
+ await page.eval_on_selector(
+ "input",
+ """input => {
+ input.setAttribute('placeholder', 'hello my\\nworld');
+ input.setAttribute('title', 'hello my\\nworld');
+ input.setAttribute('alt', 'hello my\\nworld');
+ }""",
+ )
+ await expect(page.get_by_text("hello my\nworld")).to_have_attribute("id", "label")
+ await expect(page.get_by_text("hello my world")).to_have_attribute(
+ "id", "label"
+ )
+ await expect(page.get_by_label("hello my\nworld")).to_have_attribute(
+ "id", "control"
+ )
+ await expect(page.get_by_placeholder("hello my\nworld")).to_have_attribute(
+ "id", "control"
+ )
+ await expect(page.get_by_alt_text("hello my\nworld")).to_have_attribute(
+ "id", "control"
+ )
+ await expect(page.get_by_title("hello my\nworld")).to_have_attribute(
+ "id", "control"
+ )
+
+ await page.set_content("""Text here
""")
+ await expect(page.get_by_title("my title", exact=True)).to_have_count(
+ 1, timeout=500
+ )
+ await expect(page.get_by_title("my t\\itle", exact=True)).to_have_count(
+ 0, timeout=500
+ )
+ await expect(page.get_by_title("my t\\\\itle", exact=True)).to_have_count(
+ 0, timeout=500
+ )
async def test_get_by_role_escaping(
@@ -70,3 +143,21 @@ async def test_get_by_role_escaping(
).evaluate_all("els => els.map(e => e.outerHTML)") == [
"""he llo 56""",
]
+
+ assert await page.get_by_role("button", name="Click me", exact=True).evaluate_all(
+ "els => els.map(e => e.outerHTML)"
+ ) == [
+ "",
+ ]
+ assert (
+ await page.get_by_role("button", name="Click \\me", exact=True).evaluate_all(
+ "els => els.map(e => e.outerHTML)"
+ )
+ == []
+ )
+ assert (
+ await page.get_by_role("button", name="Click \\\\me", exact=True).evaluate_all(
+ "els => els.map(e => e.outerHTML)"
+ )
+ == []
+ )
diff --git a/tests/server.py b/tests/server.py
index fd3f6e36f..9b486af3c 100644
--- a/tests/server.py
+++ b/tests/server.py
@@ -42,7 +42,7 @@ def find_free_port() -> int:
return s.getsockname()[1]
-class HttpRequestWitPostBody(http.Request):
+class HttpRequestWithPostBody(http.Request):
post_body = None
@@ -162,20 +162,20 @@ class MyHttpFactory(http.HTTPFactory):
self.listen(MyHttpFactory())
- async def wait_for_request(self, path: str) -> HttpRequestWitPostBody:
+ async def wait_for_request(self, path: str) -> HttpRequestWithPostBody:
if path in self.request_subscribers:
return await self.request_subscribers[path]
- future: asyncio.Future["HttpRequestWitPostBody"] = asyncio.Future()
+ future: asyncio.Future["HttpRequestWithPostBody"] = asyncio.Future()
self.request_subscribers[path] = future
return await future
@contextlib.contextmanager
def expect_request(
self, path: str
- ) -> Generator[ExpectResponse[HttpRequestWitPostBody], None, None]:
+ ) -> Generator[ExpectResponse[HttpRequestWithPostBody], None, None]:
future = asyncio.create_task(self.wait_for_request(path))
- cb_wrapper: ExpectResponse[HttpRequestWitPostBody] = ExpectResponse()
+ cb_wrapper: ExpectResponse[HttpRequestWithPostBody] = ExpectResponse()
def done_cb(task: asyncio.Task) -> None:
cb_wrapper._value = future.result()
diff --git a/tests/sync/test_expect_misc.py b/tests/sync/test_expect_misc.py
new file mode 100644
index 000000000..042929fde
--- /dev/null
+++ b/tests/sync/test_expect_misc.py
@@ -0,0 +1,72 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+
+from playwright.sync_api import Page, expect
+from tests.server import Server
+
+
+def test_to_be_in_viewport_should_work(page: Page) -> None:
+ page.set_content(
+ """
+
+ foo
+ """
+ )
+ expect(page.locator("#big")).to_be_in_viewport()
+ expect(page.locator("#small")).not_to_be_in_viewport()
+ page.locator("#small").scroll_into_view_if_needed()
+ expect(page.locator("#small")).to_be_in_viewport()
+ expect(page.locator("#small")).to_be_in_viewport(ratio=1)
+
+
+def test_to_be_in_viewport_should_respect_ratio_option(
+ page: Page, server: Server
+) -> None:
+ page.set_content(
+ """
+
+
+ """
+ )
+ expect(page.locator("div")).to_be_in_viewport()
+ expect(page.locator("div")).to_be_in_viewport(ratio=0.1)
+ expect(page.locator("div")).to_be_in_viewport(ratio=0.2)
+
+ expect(page.locator("div")).to_be_in_viewport(ratio=0.25)
+ # In this test, element's ratio is 0.25.
+ expect(page.locator("div")).not_to_be_in_viewport(ratio=0.26)
+
+ expect(page.locator("div")).not_to_be_in_viewport(ratio=0.3)
+ expect(page.locator("div")).not_to_be_in_viewport(ratio=0.7)
+ expect(page.locator("div")).not_to_be_in_viewport(ratio=0.8)
+
+
+def test_to_be_in_viewport_should_have_good_stack(page: Page, server: Server) -> None:
+ with pytest.raises(AssertionError) as exc_info:
+ expect(page.locator("body")).not_to_be_in_viewport(timeout=100)
+ assert 'unexpected value "viewport ratio' in str(exc_info.value)
+
+
+def test_to_be_in_viewport_should_report_intersection_even_if_fully_covered_by_other_element(
+ page: Page, server: Server
+) -> None:
+ page.set_content(
+ """
+ hello
+ None:
+ page.goto(server.EMPTY_PAGE)
+
+ def handle_get(request: http.Request) -> None:
+ # In Firefox, |fetch| will be hanging until it receives |Content-Type| header
+ # from server.
+ request.setHeader("Content-Type", "text/plain; charset=utf-8")
+ request.write(b"hello ")
+
+ server.set_route("/get", handle_get)
+ # send request and wait for server response
+ with page.expect_response("**/*") as response_info:
+ page.evaluate("() => fetch('./get', { method: 'GET' })")
+ page_response = response_info.value
+ page.close()
+ with pytest.raises(Error) as exc_info:
+ page_response.finished()
+ error = exc_info.value
+ assert "closed" in error.message
+
+
+def test_should_reject_response_finished_if_context_closes(
+ page: Page, server: Server
+) -> None:
+ page.goto(server.EMPTY_PAGE)
+
+ def handle_get(request: http.Request) -> None:
+ # In Firefox, |fetch| will be hanging until it receives |Content-Type| header
+ # from server.
+ request.setHeader("Content-Type", "text/plain; charset=utf-8")
+ request.write(b"hello ")
+
+ server.set_route("/get", handle_get)
+ # send request and wait for server response
+ with page.expect_response("**/*") as response_info:
+ page.evaluate("() => fetch('./get', { method: 'GET' })")
+ page_response = response_info.value
+
+ page.context.close()
+ with pytest.raises(Error) as exc_info:
+ page_response.finished()
+ error = exc_info.value
+ assert "closed" in error.message
diff --git a/tests/sync/test_page_request_fallback.py b/tests/sync/test_page_request_fallback.py
index b77ffb234..09a3c9845 100644
--- a/tests/sync/test_page_request_fallback.py
+++ b/tests/sync/test_page_request_fallback.py
@@ -345,6 +345,6 @@ def handler(route: Route) -> None:
)
with server.expect_request("/sleep.zzz") as server_request:
- page.evaluate("() => fetch('/sleep.zzz', { method: 'POST', body: 'birdy' })"),
+ page.evaluate("() => fetch('/sleep.zzz', { method: 'POST', body: 'birdy' })")
assert post_data == ['{"foo": "bar"}']
assert server_request.value.post_body == b'{"foo": "bar"}'
diff --git a/tests/sync/test_request_intercept.py b/tests/sync/test_request_intercept.py
index dc714e832..8df41c0c2 100644
--- a/tests/sync/test_request_intercept.py
+++ b/tests/sync/test_request_intercept.py
@@ -20,6 +20,22 @@
from tests.server import Server
+def test_should_not_follow_redirects_when_max_redirects_is_set_to_0_in_route_fetch(
+ server: Server, page: Page
+) -> None:
+ server.set_redirect("/foo", "/empty.html")
+
+ def handle(route: Route) -> None:
+ response = route.fetch(max_redirects=0)
+ assert response.headers["location"] == "/empty.html"
+ assert response.status == 302
+ route.fulfill(body="hello")
+
+ page.route("**/*", lambda route: handle(route))
+ page.goto(server.PREFIX + "/foo")
+ assert "hello" in page.content()
+
+
def test_should_fulfill_intercepted_response(page: Page, server: Server) -> None:
def handle(route: Route) -> None:
response = page.request.fetch(route.request)
diff --git a/tests/sync/test_resource_timing.py b/tests/sync/test_resource_timing.py
index 447ab97a2..dcfcc48df 100644
--- a/tests/sync/test_resource_timing.py
+++ b/tests/sync/test_resource_timing.py
@@ -37,7 +37,7 @@ def test_should_work(page: Page, server: Server) -> None:
def test_should_work_for_subresource(
page: Page, server: Server, is_win: bool, is_mac: bool, is_webkit: bool
) -> None:
- if is_webkit and is_mac:
+ if is_webkit and (is_mac or is_win):
pytest.skip()
requests = []
page.on("requestfinished", lambda request: requests.append(request))