mirror of
https://github.com/pyscript/pyscript.git
synced 2025-12-19 18:27:29 -05:00
8c5475f78f
This PR adds support for optionally running pyodide in a web worker: - add a new option config.execution_thread, which can be `main` or `worker`. The default is `main` - improve the test machinery so that we run all tests twice, once for `main` and once for `worker` - add a new esbuild target which builds the code for the worker The support for workers is not complete and many features are still missing: there are 71 tests which are marked as `@skip_worker`, but we can fix them in subsequent PRs. The vast majority of tests fail because js.document is unavailable: for it to run transparently, we need the "auto-syncify" feature of synclink. Co-authored-by: Hood Chatham <roberthoodchatham@gmail.com> Co-authored-by: Madhur Tandon <20173739+madhur-tandon@users.noreply.github.com>
965 lines
32 KiB
Python
965 lines
32 KiB
Python
import dataclasses
|
|
import functools
|
|
import math
|
|
import os
|
|
import pdb
|
|
import re
|
|
import sys
|
|
import time
|
|
import traceback
|
|
import urllib
|
|
from dataclasses import dataclass
|
|
|
|
import py
|
|
import pytest
|
|
import toml
|
|
from playwright.sync_api import Error as PlaywrightError
|
|
|
|
ROOT = py.path.local(__file__).dirpath("..", "..", "..")
|
|
BUILD = ROOT.join("pyscriptjs", "build")
|
|
|
|
|
|
def params_with_marks(params):
|
|
"""
|
|
Small helper to automatically apply to each param a pytest.mark with the
|
|
same name of the param itself. E.g.:
|
|
|
|
params_with_marks(['aaa', 'bbb'])
|
|
|
|
is equivalent to:
|
|
|
|
[pytest.param('aaa', marks=pytest.mark.aaa),
|
|
pytest.param('bbb', marks=pytest.mark.bbb)]
|
|
|
|
This makes it possible to use 'pytest -m aaa' to run ONLY the tests which
|
|
uses the param 'aaa'.
|
|
"""
|
|
return [pytest.param(name, marks=getattr(pytest.mark, name)) for name in params]
|
|
|
|
|
|
def with_execution_thread(*values):
|
|
"""
|
|
Class decorator to override config.execution_thread.
|
|
|
|
By default, we run each test twice:
|
|
- execution_thread = 'main'
|
|
- execution_thread = 'worker'
|
|
|
|
If you want to execute certain tests with only one specific values of
|
|
execution_thread, you can use this class decorator. For example:
|
|
|
|
@with_execution_thread('main')
|
|
class TestOnlyMainThread:
|
|
...
|
|
|
|
@with_execution_thread('worker')
|
|
class TestOnlyWorker:
|
|
...
|
|
|
|
If you use @with_execution_thread(None), the logic to inject the
|
|
execution_thread config is disabled.
|
|
"""
|
|
|
|
if values == (None,):
|
|
|
|
@pytest.fixture
|
|
def execution_thread(self, request):
|
|
return None
|
|
|
|
else:
|
|
for value in values:
|
|
assert value in ("main", "worker")
|
|
|
|
@pytest.fixture(params=params_with_marks(values))
|
|
def execution_thread(self, request):
|
|
return request.param
|
|
|
|
def with_execution_thread_decorator(cls):
|
|
cls.execution_thread = execution_thread
|
|
return cls
|
|
|
|
return with_execution_thread_decorator
|
|
|
|
|
|
def skip_worker(reason):
|
|
"""
|
|
Decorator to skip a test if self.execution_thread == 'worker'
|
|
"""
|
|
if callable(reason):
|
|
# this happens if you use @skip_worker instead of @skip_worker("bla bla bla")
|
|
raise Exception(
|
|
"You need to specify a reason for skipping, "
|
|
"please use: @skip_worker('...')"
|
|
)
|
|
|
|
def decorator(fn):
|
|
@functools.wraps(fn)
|
|
def decorated(self, *args):
|
|
if self.execution_thread == "worker":
|
|
pytest.skip(reason)
|
|
return fn(self, *args)
|
|
|
|
return decorated
|
|
|
|
return decorator
|
|
|
|
|
|
@pytest.mark.usefixtures("init")
|
|
@with_execution_thread("main", "worker")
|
|
class PyScriptTest:
|
|
"""
|
|
Base class to write PyScript integration tests, based on playwright.
|
|
|
|
It provides a simple API to generate HTML files and load them in
|
|
playwright.
|
|
|
|
It also provides a Pythonic API on top of playwright for the most
|
|
common tasks; in particular:
|
|
|
|
- self.console collects all the JS console.* messages. Look at the doc
|
|
of ConsoleMessageCollection for more details.
|
|
|
|
- self.check_js_errors() checks that no JS errors have been thrown
|
|
|
|
- after each test, self.check_js_errors() is automatically run to ensure
|
|
that no JS error passes uncaught.
|
|
|
|
- self.wait_for_console waits until the specified message appears in the
|
|
console
|
|
|
|
- self.wait_for_pyscript waits until all the PyScript tags have been
|
|
evaluated
|
|
|
|
- self.pyscript_run is the main entry point for pyscript tests: it
|
|
creates an HTML page to run the specified snippet.
|
|
"""
|
|
|
|
@pytest.fixture()
|
|
def init(self, request, tmpdir, logger, page, execution_thread):
|
|
"""
|
|
Fixture to automatically initialize all the tests in this class and its
|
|
subclasses.
|
|
|
|
The magic is done by the decorator @pytest.mark.usefixtures("init"),
|
|
which tells pytest to automatically use this fixture for all the test
|
|
method of this class.
|
|
|
|
Using the standard pytest behavior, we can request more fixtures:
|
|
tmpdir, and page; 'page' is a fixture provided by pytest-playwright.
|
|
|
|
Then, we save these fixtures on the self and proceed with more
|
|
initialization. The end result is that the requested fixtures are
|
|
automatically made available as self.xxx in all methods.
|
|
"""
|
|
self.testname = request.function.__name__.replace("test_", "")
|
|
self.tmpdir = tmpdir
|
|
# create a symlink to BUILD inside tmpdir
|
|
tmpdir.join("build").mksymlinkto(BUILD)
|
|
self.tmpdir.chdir()
|
|
self.logger = logger
|
|
self.execution_thread = execution_thread
|
|
|
|
if request.config.option.no_fake_server:
|
|
# use a real HTTP server. Note that as soon as we request the
|
|
# fixture, the server automatically starts in its own thread.
|
|
self.http_server = request.getfixturevalue("http_server")
|
|
self.router = None
|
|
self.is_fake_server = False
|
|
else:
|
|
# use the internal playwright routing
|
|
self.http_server = "https://fake_server"
|
|
self.router = SmartRouter(
|
|
"fake_server",
|
|
cache=request.config.cache,
|
|
logger=logger,
|
|
usepdb=request.config.option.usepdb,
|
|
)
|
|
self.router.install(page)
|
|
self.is_fake_server = True
|
|
#
|
|
self.init_page(page)
|
|
#
|
|
# this extra print is useful when using pytest -s, else we start printing
|
|
# in the middle of the line
|
|
print()
|
|
#
|
|
# if you use pytest --headed you can see the browser page while
|
|
# playwright executes the tests, but the page is closed very quickly
|
|
# as soon as the test finishes. To avoid that, we automatically start
|
|
# a pdb so that we can wait as long as we want.
|
|
yield
|
|
if request.config.option.headed:
|
|
pdb.Pdb.intro = (
|
|
"\n"
|
|
"This (Pdb) was started automatically because you passed --headed:\n"
|
|
"the execution of the test pauses here to give you the time to inspect\n"
|
|
"the browser. When you are done, type one of the following commands:\n"
|
|
" (Pdb) continue\n"
|
|
" (Pdb) cont\n"
|
|
" (Pdb) c\n"
|
|
)
|
|
pdb.set_trace()
|
|
|
|
def init_page(self, page):
|
|
self.page = page
|
|
|
|
# set default timeout to 60000 millliseconds from 30000
|
|
page.set_default_timeout(60000)
|
|
|
|
self.console = ConsoleMessageCollection(self.logger)
|
|
self._js_errors = []
|
|
page.on("console", self._on_console)
|
|
page.on("pageerror", self._on_pageerror)
|
|
|
|
def run_js(self, code):
|
|
"""
|
|
allows top level await to be present in the `code` parameter
|
|
"""
|
|
self.page.evaluate(
|
|
"""(async () => {
|
|
try {%s}
|
|
catch(e) {
|
|
console.error(e);
|
|
}
|
|
})();"""
|
|
% code
|
|
)
|
|
|
|
def teardown_method(self):
|
|
# we call check_js_errors on teardown: this means that if there are still
|
|
# non-cleared errors, the test will fail. If you expect errors in your
|
|
# page and they should not cause the test to fail, you should call
|
|
# self.check_js_errors() in the test itself.
|
|
self.check_js_errors()
|
|
|
|
def _on_console(self, msg):
|
|
self.console.add_message(msg.type, msg.text)
|
|
|
|
def _on_pageerror(self, error):
|
|
self.console.add_message("js_error", error.stack)
|
|
self._js_errors.append(error)
|
|
|
|
def check_js_errors(self, *expected_messages):
|
|
"""
|
|
Check whether JS errors were reported.
|
|
|
|
expected_messages is a list of strings of errors that you expect they
|
|
were raised in the page. They are checked using a simple 'in' check,
|
|
equivalent to this:
|
|
if expected_message in actual_error_message:
|
|
...
|
|
|
|
If an error was expected but not found, it raises
|
|
DidNotRaiseJsError().
|
|
|
|
If there are MORE errors other than the expected ones, it raises JsErrors.
|
|
|
|
Upon return, all the errors are cleared, so a subsequent call to
|
|
check_js_errors will not raise, unless NEW JS errors have been reported
|
|
in the meantime.
|
|
"""
|
|
expected_messages = list(expected_messages)
|
|
js_errors = self._js_errors[:]
|
|
|
|
for i, msg in enumerate(expected_messages):
|
|
for j, error in enumerate(js_errors):
|
|
if msg is not None and error is not None and msg in error.message:
|
|
# we matched one expected message with an error, remove both
|
|
expected_messages[i] = None
|
|
js_errors[j] = None
|
|
|
|
# if everything is find, now expected_messages and js_errors contains
|
|
# only Nones. If they contain non-None elements, it means that we
|
|
# either have messages which are expected-but-not-found or errors
|
|
# which are found-but-not-expected.
|
|
expected_messages = [msg for msg in expected_messages if msg is not None]
|
|
js_errors = [err for err in js_errors if err is not None]
|
|
self.clear_js_errors()
|
|
|
|
if expected_messages:
|
|
# expected-but-not-found
|
|
raise JsErrorsDidNotRaise(expected_messages, js_errors)
|
|
|
|
if js_errors:
|
|
# found-but-not-expected
|
|
raise JsErrors(js_errors)
|
|
|
|
def clear_js_errors(self):
|
|
"""
|
|
Clear all JS errors.
|
|
"""
|
|
self._js_errors = []
|
|
|
|
def writefile(self, filename, content):
|
|
"""
|
|
Very thin helper to write a file in the tmpdir
|
|
"""
|
|
f = self.tmpdir.join(filename)
|
|
f.dirpath().ensure(dir=True)
|
|
f.write(content)
|
|
|
|
def goto(self, path):
|
|
self.logger.reset()
|
|
self.logger.log("page.goto", path, color="yellow")
|
|
url = f"{self.http_server}/{path}"
|
|
self.page.goto(url, timeout=0)
|
|
|
|
def wait_for_console(
|
|
self, text, *, match_substring=False, timeout=None, check_js_errors=True
|
|
):
|
|
"""
|
|
Wait until the given message appear in the console. If the message was
|
|
already printed in the console, return immediately.
|
|
|
|
By default "text" must be the *exact* string as printed by a single
|
|
call to e.g. console.log. If match_substring is True, it is enough
|
|
that the console contains the given text anywhere.
|
|
|
|
timeout is expressed in milliseconds. If it's None, it will use
|
|
the same default as playwright, which is 30 seconds.
|
|
|
|
If check_js_errors is True (the default), it also checks that no JS
|
|
errors were raised during the waiting.
|
|
|
|
Return the elapsed time in ms.
|
|
"""
|
|
if match_substring:
|
|
|
|
def find_text():
|
|
return text in self.console.all.text
|
|
|
|
else:
|
|
|
|
def find_text():
|
|
return text in self.console.all.lines
|
|
|
|
if timeout is None:
|
|
timeout = 30 * 1000
|
|
# NOTE: we cannot use playwright's own page.expect_console_message(),
|
|
# because if you call it AFTER the text has already been emitted, it
|
|
# waits forever. Instead, we have to use our own custom logic.
|
|
try:
|
|
t0 = time.time()
|
|
while True:
|
|
elapsed_ms = (time.time() - t0) * 1000
|
|
if elapsed_ms > timeout:
|
|
raise TimeoutError(f"{elapsed_ms:.2f} ms")
|
|
#
|
|
if find_text():
|
|
# found it!
|
|
return elapsed_ms
|
|
#
|
|
self.page.wait_for_timeout(50)
|
|
finally:
|
|
# raise JsError if there were any javascript exception. Note that
|
|
# this might happen also in case of a TimeoutError. In that case,
|
|
# the JsError will shadow the TimeoutError but this is correct,
|
|
# because it's very likely that the console message never appeared
|
|
# precisely because of the exception in JS.
|
|
if check_js_errors:
|
|
self.check_js_errors()
|
|
|
|
def wait_for_pyscript(self, *, timeout=None, check_js_errors=True):
|
|
"""
|
|
Wait until pyscript has been fully loaded.
|
|
|
|
Timeout is expressed in milliseconds. If it's None, it will use
|
|
playwright's own default value, which is 30 seconds).
|
|
|
|
If check_js_errors is True (the default), it also checks that no JS
|
|
errors were raised during the waiting.
|
|
"""
|
|
# this is printed by interpreter.ts:Interpreter.initialize
|
|
elapsed_ms = self.wait_for_console(
|
|
"[pyscript/main] PyScript page fully initialized",
|
|
timeout=timeout,
|
|
check_js_errors=check_js_errors,
|
|
)
|
|
self.logger.log(
|
|
"wait_for_pyscript", f"Waited for {elapsed_ms/1000:.2f} s", color="yellow"
|
|
)
|
|
# We still don't know why this wait is necessary, but without it
|
|
# events aren't being triggered in the tests.
|
|
self.page.wait_for_timeout(100)
|
|
|
|
def _parse_py_config(self, doc):
|
|
configs = re.findall("<py-config>(.*?)</py-config>", doc, flags=re.DOTALL)
|
|
configs = [cfg.strip() for cfg in configs]
|
|
if len(configs) == 0:
|
|
return None
|
|
elif len(configs) == 1:
|
|
return toml.loads(configs[0])
|
|
else:
|
|
raise AssertionError("Too many <py-config>")
|
|
|
|
def _inject_execution_thread_config(self, snippet, execution_thread):
|
|
"""
|
|
If snippet already contains a py-config, let's try to inject
|
|
execution_thread automatically. Note that this works only for plain
|
|
<py-config> with inline config: type="json" and src="..." are not
|
|
supported by this logic, which should remain simple.
|
|
"""
|
|
cfg = self._parse_py_config(snippet)
|
|
if cfg is None:
|
|
# we don't have any <py-config>, let's add one
|
|
py_config_maybe = f"""
|
|
<py-config>
|
|
execution_thread = "{execution_thread}"
|
|
</py-config>
|
|
"""
|
|
else:
|
|
cfg["execution_thread"] = execution_thread
|
|
dumped_cfg = toml.dumps(cfg)
|
|
new_py_config = f"""
|
|
<py-config>
|
|
{dumped_cfg}
|
|
</py-config>
|
|
"""
|
|
snippet = re.sub(
|
|
"<py-config>.*</py-config>", new_py_config, snippet, flags=re.DOTALL
|
|
)
|
|
# no need for extra config, it's already in the snippet
|
|
py_config_maybe = ""
|
|
#
|
|
return snippet, py_config_maybe
|
|
|
|
def _pyscript_format(self, snippet, *, execution_thread, extra_head=""):
|
|
if execution_thread is None:
|
|
py_config_maybe = ""
|
|
else:
|
|
snippet, py_config_maybe = self._inject_execution_thread_config(
|
|
snippet, execution_thread
|
|
)
|
|
doc = f"""
|
|
<html>
|
|
<head>
|
|
<link rel="stylesheet" href="{self.http_server}/build/pyscript.css" />
|
|
<script defer src="{self.http_server}/build/pyscript.js"></script>
|
|
{extra_head}
|
|
</head>
|
|
<body>
|
|
{py_config_maybe}
|
|
{snippet}
|
|
</body>
|
|
</html>
|
|
"""
|
|
return doc
|
|
|
|
def pyscript_run(
|
|
self, snippet, *, extra_head="", wait_for_pyscript=True, timeout=None
|
|
):
|
|
"""
|
|
Main entry point for pyscript tests.
|
|
|
|
snippet contains a fragment of HTML which will be put inside a full
|
|
HTML document. In particular, the <head> automatically contains the
|
|
correct <script> and <link> tags which are necessary to load pyscript
|
|
correctly.
|
|
|
|
This method does the following:
|
|
- write a full HTML file containing the snippet
|
|
- open a playwright page for it
|
|
- wait until pyscript has been fully loaded
|
|
"""
|
|
doc = self._pyscript_format(
|
|
snippet, execution_thread=self.execution_thread, extra_head=extra_head
|
|
)
|
|
if not wait_for_pyscript and timeout is not None:
|
|
raise ValueError("Cannot set a timeout if wait_for_pyscript=False")
|
|
filename = f"{self.testname}.html"
|
|
self.writefile(filename, doc)
|
|
self.goto(filename)
|
|
if wait_for_pyscript:
|
|
self.wait_for_pyscript(timeout=timeout)
|
|
|
|
def iter_locator(self, loc):
|
|
"""
|
|
Helper method to iterate over all the elements which are matched by a
|
|
locator, since playwright does not seem to support it natively.
|
|
"""
|
|
n = loc.count()
|
|
elems = [loc.nth(i) for i in range(n)]
|
|
return iter(elems)
|
|
|
|
def assert_no_banners(self):
|
|
"""
|
|
Ensure that there are no alert banners on the page, which are used for
|
|
errors and warnings. Raise AssertionError if any if found.
|
|
"""
|
|
loc = self.page.locator(".alert-banner")
|
|
n = loc.count()
|
|
if n > 0:
|
|
text = "\n".join(loc.all_inner_texts())
|
|
raise AssertionError(f"Found {n} alert banners:\n" + text)
|
|
|
|
def assert_banner_message(self, expected_message):
|
|
"""
|
|
Ensure that there is an alert banner on the page with the given message.
|
|
Currently it only handles a single.
|
|
"""
|
|
banner = self.page.wait_for_selector(".alert-banner")
|
|
banner_text = banner.inner_text()
|
|
|
|
if expected_message not in banner_text:
|
|
raise AssertionError(
|
|
f"Expected message '{expected_message}' does not "
|
|
f"match banner text '{banner_text}'"
|
|
)
|
|
return True
|
|
|
|
def check_tutor_generated_code(self, modules_to_check=None):
|
|
"""
|
|
Ensure that the source code viewer injected by the PyTutor plugin
|
|
is presend. Raise AssertionError if not found.
|
|
|
|
Args:
|
|
|
|
modules_to_check(str): iterable with names of the python modules
|
|
that have been included in the tutor config
|
|
and needs to be checked (if they are included
|
|
in the displayed source code)
|
|
|
|
Returns:
|
|
None
|
|
"""
|
|
# Given: a page that has a <py-tutor> tag
|
|
assert self.page.locator("py-tutor").count()
|
|
|
|
# EXPECT that"
|
|
#
|
|
# the page has the "view-code-button"
|
|
view_code_button = self.page.locator("#view-code-button")
|
|
vcb_count = view_code_button.count()
|
|
if vcb_count != 1:
|
|
raise AssertionError(
|
|
f"Found {vcb_count} code view button. Should have been 1!"
|
|
)
|
|
|
|
# the page has the code-section element
|
|
code_section = self.page.locator("#code-section")
|
|
code_section_count = code_section.count()
|
|
code_msg = (
|
|
f"One (and only one) code section should exist. Found: {code_section_count}"
|
|
)
|
|
assert code_section_count == 1, code_msg
|
|
|
|
pyconfig_tag = self.page.locator("py-config")
|
|
code_section_inner_html = code_section.inner_html()
|
|
|
|
# the code_section has the index.html section
|
|
assert "<p>index.html</p>" in code_section_inner_html
|
|
|
|
# the section has the tags highlighting the HTML code
|
|
assert (
|
|
'<pre class="prism-code language-html" tabindex="0">'
|
|
' <code class="language-html">' in code_section_inner_html
|
|
)
|
|
|
|
# if modules were included, these are also presented in the code section
|
|
if modules_to_check:
|
|
for module in modules_to_check:
|
|
assert f"{module}" in code_section_inner_html
|
|
|
|
# the section also includes the config
|
|
assert "<</span>py-config</span>" in code_section_inner_html
|
|
|
|
# the contents of the py-config tag are included in the code section
|
|
assert pyconfig_tag.inner_html() in code_section_inner_html
|
|
|
|
# the code section to be invisible by default (by having the hidden class)
|
|
assert "code-section-hidden" in code_section.get_attribute("class")
|
|
|
|
# once the view_code_button is pressed, the code section becomes visible
|
|
view_code_button.click()
|
|
assert "code-section-visible" in code_section.get_attribute("class")
|
|
|
|
|
|
# ============== Helpers and utility functions ==============
|
|
|
|
MAX_TEST_TIME = 30 # Number of seconds allowed for checking a testing condition
|
|
TEST_TIME_INCREMENT = 0.25 # 1/4 second, the length of each iteration
|
|
TEST_ITERATIONS = math.ceil(
|
|
MAX_TEST_TIME / TEST_TIME_INCREMENT
|
|
) # 120 iters of 1/4 second
|
|
|
|
|
|
def wait_for_render(page, selector, pattern):
|
|
"""
|
|
Assert that rendering inserts data into the page as expected: search the
|
|
DOM from within the timing loop for a string that is not present in the
|
|
initial markup but should appear by way of rendering
|
|
"""
|
|
re_sub_content = re.compile(pattern)
|
|
py_rendered = False # Flag to be set to True when condition met
|
|
|
|
for _ in range(TEST_ITERATIONS):
|
|
content = page.inner_html(selector)
|
|
if re_sub_content.search(content):
|
|
py_rendered = True
|
|
break
|
|
time.sleep(TEST_TIME_INCREMENT)
|
|
|
|
assert py_rendered # nosec
|
|
|
|
|
|
class JsErrors(Exception):
|
|
"""
|
|
Represent one or more exceptions which happened in JS.
|
|
|
|
It's a thin wrapper around playwright.sync_api.Error, with two important
|
|
differences:
|
|
|
|
1. it has a better name: if you see JsError in a traceback, it's
|
|
immediately obvious that it's a JS exception.
|
|
|
|
2. Show also the JS stacktrace by default, contrarily to
|
|
playwright.sync_api.Error
|
|
"""
|
|
|
|
def __init__(self, errors):
|
|
n = len(errors)
|
|
assert n != 0
|
|
lines = [f"JS errors found: {n}"]
|
|
for err in errors:
|
|
lines.append(self.format_playwright_error(err))
|
|
msg = "\n".join(lines)
|
|
super().__init__(msg)
|
|
self.errors = errors
|
|
|
|
@staticmethod
|
|
def format_playwright_error(error):
|
|
# apparently, playwright Error.stack contains all the info that we
|
|
# want: exception name, message and stacktrace. The docs say that
|
|
# error.stack is optional, so fallback to the standard repr if it's
|
|
# unavailable.
|
|
return error.stack or str(error)
|
|
|
|
|
|
class JsErrorsDidNotRaise(Exception):
|
|
"""
|
|
Exception raised by check_js_errors when the expected JS error messages
|
|
are not found.
|
|
"""
|
|
|
|
def __init__(self, expected_messages, errors):
|
|
lines = ["The following JS errors were expected but could not be found:"]
|
|
for msg in expected_messages:
|
|
lines.append(" - " + msg)
|
|
if errors:
|
|
lines.append("---")
|
|
lines.append("The following JS errors were raised but not expected:")
|
|
for err in errors:
|
|
lines.append(JsErrors.format_playwright_error(err))
|
|
msg = "\n".join(lines)
|
|
super().__init__(msg)
|
|
self.expected_messages = expected_messages
|
|
self.errors = errors
|
|
|
|
|
|
class ConsoleMessageCollection:
|
|
"""
|
|
Helper class to collect and expose ConsoleMessage in a Pythonic way.
|
|
|
|
Usage:
|
|
|
|
console.log.messages: list of ConsoleMessage with type=='log'
|
|
console.log.lines: list of strings
|
|
console.log.text: the whole text as single string
|
|
|
|
console.debug.* same as above, but with different types
|
|
console.info.*
|
|
console.error.*
|
|
console.warning.*
|
|
|
|
console.js_error.* this is a special category which does not exist in the
|
|
browser: it prints uncaught JS exceptions
|
|
|
|
console.all.* same as the individual categories but considering
|
|
all messages which were sent to the console
|
|
"""
|
|
|
|
@dataclass
|
|
class Message:
|
|
type: str # 'log', 'info', 'debug', etc.
|
|
text: str
|
|
|
|
class View:
|
|
"""
|
|
Filter console messages by the given msg_type
|
|
"""
|
|
|
|
def __init__(self, console, msg_type):
|
|
self.console = console
|
|
self.msg_type = msg_type
|
|
|
|
@property
|
|
def messages(self):
|
|
if self.msg_type is None:
|
|
return self.console._messages
|
|
else:
|
|
return [
|
|
msg for msg in self.console._messages if msg.type == self.msg_type
|
|
]
|
|
|
|
@property
|
|
def lines(self):
|
|
return [msg.text for msg in self.messages]
|
|
|
|
@property
|
|
def text(self):
|
|
return "\n".join(self.lines)
|
|
|
|
_COLORS = {
|
|
"warning": "brown",
|
|
"error": "darkred",
|
|
"js_error": "red",
|
|
}
|
|
|
|
def __init__(self, logger):
|
|
self.logger = logger
|
|
self._messages = []
|
|
self.all = self.View(self, None)
|
|
self.log = self.View(self, "log")
|
|
self.debug = self.View(self, "debug")
|
|
self.info = self.View(self, "info")
|
|
self.error = self.View(self, "error")
|
|
self.warning = self.View(self, "warning")
|
|
self.js_error = self.View(self, "js_error")
|
|
|
|
def add_message(self, type, text):
|
|
# log the message: pytest will capture the output and display the
|
|
# messages if the test fails.
|
|
msg = self.Message(type=type, text=text)
|
|
category = f"console.{msg.type}"
|
|
color = self._COLORS.get(msg.type)
|
|
self.logger.log(category, msg.text, color=color)
|
|
self._messages.append(msg)
|
|
|
|
|
|
class Logger:
|
|
"""
|
|
Helper class to log messages to stdout.
|
|
|
|
Features:
|
|
- nice formatted category
|
|
- keep track of time passed since the last reset
|
|
- support colors
|
|
|
|
NOTE: the (lowercase) logger fixture is defined in conftest.py
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.reset()
|
|
# capture things like [pyscript/main]
|
|
self.prefix_regexp = re.compile(r"(\[.+?\])")
|
|
|
|
def reset(self):
|
|
self.start_time = time.time()
|
|
|
|
def colorize_prefix(self, text, *, color):
|
|
# find the first occurrence of something like [pyscript/main] and
|
|
# colorize it
|
|
start, end = Color.escape_pair(color)
|
|
return self.prefix_regexp.sub(rf"{start}\1{end}", text, 1)
|
|
|
|
def log(self, category, text, *, color=None):
|
|
delta = time.time() - self.start_time
|
|
text = self.colorize_prefix(text, color="teal")
|
|
line = f"[{delta:6.2f} {category:17}] {text}"
|
|
if color:
|
|
line = Color.set(color, line)
|
|
print(line)
|
|
|
|
|
|
class Color:
|
|
"""
|
|
Helper method to print colored output using ANSI escape codes.
|
|
"""
|
|
|
|
black = "30"
|
|
darkred = "31"
|
|
darkgreen = "32"
|
|
brown = "33"
|
|
darkblue = "34"
|
|
purple = "35"
|
|
teal = "36"
|
|
lightgray = "37"
|
|
darkgray = "30;01"
|
|
red = "31;01"
|
|
green = "32;01"
|
|
yellow = "33;01"
|
|
blue = "34;01"
|
|
fuchsia = "35;01"
|
|
turquoise = "36;01"
|
|
white = "37;01"
|
|
|
|
@classmethod
|
|
def set(cls, color, string):
|
|
start, end = cls.escape_pair(color)
|
|
return f"{start}{string}{end}"
|
|
|
|
@classmethod
|
|
def escape_pair(cls, color):
|
|
try:
|
|
color = getattr(cls, color)
|
|
except AttributeError:
|
|
pass
|
|
start = f"\x1b[{color}m"
|
|
end = "\x1b[00m"
|
|
return start, end
|
|
|
|
|
|
class SmartRouter:
|
|
"""
|
|
A smart router to be used in conjunction with playwright.Page.route.
|
|
|
|
Main features:
|
|
|
|
- it intercepts the requests to a local "fake server" and serve them
|
|
statically from disk
|
|
|
|
- it intercepts the requests to the network and cache the results
|
|
locally
|
|
"""
|
|
|
|
@dataclass
|
|
class CachedResponse:
|
|
"""
|
|
We cannot put playwright's APIResponse instances inside _cache, because
|
|
they are valid only in the context of the same page. As a workaround,
|
|
we manually save status, headers and body of each cached response.
|
|
"""
|
|
|
|
status: int
|
|
headers: dict
|
|
body: str
|
|
|
|
def asdict(self):
|
|
return dataclasses.asdict(self)
|
|
|
|
@classmethod
|
|
def fromdict(cls, d):
|
|
return cls(**d)
|
|
|
|
def __init__(self, fake_server, *, cache, logger, usepdb=False):
|
|
"""
|
|
fake_server: the domain name of the fake server
|
|
"""
|
|
self.fake_server = fake_server
|
|
self.cache = cache # this is pytest-cache, it survives across sessions
|
|
self.logger = logger
|
|
self.usepdb = usepdb
|
|
self.page = None
|
|
self.requests = [] # (status, kind, url)
|
|
|
|
def install(self, page):
|
|
"""
|
|
Install the smart router on a page
|
|
"""
|
|
self.page = page
|
|
self.page.route("**", self.router)
|
|
|
|
def router(self, route):
|
|
"""
|
|
Intercept and fulfill playwright requests.
|
|
|
|
NOTE!
|
|
If we raise an exception inside router, playwright just hangs and the
|
|
exception seems not to be propagated outside. It's very likely a
|
|
playwright bug.
|
|
|
|
This means that for example pytest doesn't have any chance to
|
|
intercept the exception and fail in a meaningful way.
|
|
|
|
As a workaround, we try to intercept exceptions by ourselves, print
|
|
something reasonable on the console and abort the request (hoping that
|
|
the test will fail cleaninly, that's the best we can do). We also try
|
|
to respect pytest --pdb, for what it's possible.
|
|
"""
|
|
try:
|
|
return self._router(route)
|
|
except Exception:
|
|
print("***** Error inside Fake_Server.router *****")
|
|
info = sys.exc_info()
|
|
print(traceback.format_exc())
|
|
if self.usepdb:
|
|
pdb.post_mortem(info[2])
|
|
route.abort()
|
|
|
|
def log_request(self, status, kind, url):
|
|
self.requests.append((status, kind, url))
|
|
color = "blue" if status == 200 else "red"
|
|
self.logger.log("request", f"{status} - {kind} - {url}", color=color)
|
|
|
|
def _router(self, route):
|
|
full_url = route.request.url
|
|
url = urllib.parse.urlparse(full_url)
|
|
assert url.scheme in ("http", "https")
|
|
|
|
# requests to http://fake_server/ are served from the current dir and
|
|
# never cached
|
|
if url.netloc == self.fake_server:
|
|
self.log_request(200, "fake_server", full_url)
|
|
assert url.path[0] == "/"
|
|
relative_path = url.path[1:]
|
|
if os.path.exists(relative_path):
|
|
headers = {
|
|
"Cross-Origin-Embedder-Policy": "require-corp",
|
|
"Cross-Origin-Opener-Policy": "same-origin",
|
|
}
|
|
route.fulfill(status=200, headers=headers, path=relative_path)
|
|
else:
|
|
route.fulfill(status=404)
|
|
return
|
|
|
|
# network requests might be cached
|
|
resp = self.fetch_from_cache(full_url)
|
|
if resp is not None:
|
|
kind = "CACHED"
|
|
else:
|
|
kind = "NETWORK"
|
|
resp = self.fetch_from_network(route.request)
|
|
self.save_resp_to_cache(full_url, resp)
|
|
|
|
self.log_request(resp.status, kind, full_url)
|
|
route.fulfill(status=resp.status, headers=resp.headers, body=resp.body)
|
|
|
|
def clear_cache(self, url):
|
|
key = "pyscript/" + url
|
|
self.cache.set(key, None)
|
|
|
|
def save_resp_to_cache(self, url, resp):
|
|
key = "pyscript/" + url
|
|
data = resp.asdict()
|
|
# cache.set encodes it as JSON, and "bytes" are not supported: let's
|
|
# encode them as latin-1
|
|
data["body"] = data["body"].decode("latin-1")
|
|
self.cache.set(key, data)
|
|
|
|
def fetch_from_cache(self, url):
|
|
key = "pyscript/" + url
|
|
data = self.cache.get(key, None)
|
|
if data is None:
|
|
return None
|
|
# see the corresponding comment in save_resp_to_cache
|
|
data["body"] = data["body"].encode("latin-1")
|
|
return self.CachedResponse(**data)
|
|
|
|
def fetch_from_network(self, request):
|
|
# sometimes the network is flaky and if the first request doesn't
|
|
# work, a subsequent one works. Instead of giving up immediately,
|
|
# let's try twice
|
|
try:
|
|
api_response = self.page.request.fetch(request)
|
|
except PlaywrightError:
|
|
# sleep a bit and try again
|
|
time.sleep(0.5)
|
|
api_response = self.page.request.fetch(request)
|
|
|
|
cached_response = self.CachedResponse(
|
|
status=api_response.status,
|
|
headers=api_response.headers,
|
|
body=api_response.body(),
|
|
)
|
|
return cached_response
|