148 lines
4.7 KiB
Python
148 lines
4.7 KiB
Python
# 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.
|
|
|
|
from pathlib import Path
|
|
|
|
from twisted.web import http
|
|
|
|
from playwright.sync_api import Page, Route
|
|
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)
|
|
route.fulfill(
|
|
response=response,
|
|
status=201,
|
|
headers={"foo": "bar"},
|
|
content_type="text/plain",
|
|
body="Yo, page!",
|
|
)
|
|
|
|
page.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 test_should_fulfill_response_with_empty_body(page: Page, 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"}
|
|
)
|
|
|
|
page.route("**/*", handle)
|
|
response = page.goto(server.PREFIX + "/title.html")
|
|
assert response
|
|
assert response.status == 201
|
|
assert response.text() == ""
|
|
|
|
|
|
def test_should_override_with_defaults_when_intercepted_response_not_provided(
|
|
page: Page, 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)
|
|
|
|
page.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_should_fulfill_with_any_response(page: Page, 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")
|
|
page.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_should_support_fulfill_after_intercept(
|
|
page: Page, server: Server, assetdir: Path
|
|
) -> None:
|
|
def handle_route(route: Route) -> None:
|
|
response = page.request.fetch(route.request)
|
|
route.fulfill(response=response)
|
|
|
|
page.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 test_should_intercept_by_glob(page: Page, server: Server) -> None:
|
|
page.goto(server.EMPTY_PAGE)
|
|
page.route(
|
|
"http://localhos**?*oo",
|
|
lambda route: route.fulfill(body="intercepted", status=200),
|
|
)
|
|
|
|
result = page.evaluate(
|
|
"url => fetch(url).then(r => r.text())", server.PREFIX + "/?foo"
|
|
)
|
|
|
|
assert result == "intercepted"
|