Draft/toga-web-testing

positron/src/positron/django_templates/manage.py.tmpl

@@ -1,5 +1,6 @@
 #!/usr/bin/env python
 """Django's command-line utility for administrative tasks."""
+
 import os
 import sys
 

travertino/pyproject.toml

@@ -41,6 +41,10 @@ classifiers = [
     "Topic :: Software Development :: User Interfaces",
 ]
 
+dependencies = [
+    "packaging",
+]
+
 [project.urls]
 Homepage = "https://beeware.org/travertino"
 Funding = "https://beeware.org/contributing/membership/"

web-testbed/README.md

@@ -0,0 +1,15 @@
+This repository is dedicated to development, testing, and proof-of-concept work related to issue [3545](https://github.com/beeware/toga/issues/3545), which focuses on implementing testing for the web platform.
+
+## How We Run this Test Suite
+1. Open this directory.
+2. Create a Python 3.12 virtual environment and install test requirements:
+   - `python3.12 -m venv venv`
+   - `source venv/bin/activate`
+   - `pip install -U pip`
+   - `pip install --group test`
+   - `playwright install chromium`
+3. Run your Toga app as a web app.
+   - `briefcase run web`
+4. In a separate terminal, run the test suite:
+   - `source venv/bin/activate`
+   - `pytest tests`

web-testbed/pyproject.toml

@@ -0,0 +1,49 @@
+[project]
+name = "testbed"
+version = "0.0.1"
+
+[dependency-groups]
+test = [
+    "briefcase",
+    "playwright == 1.51.0",
+    # "pytest==8.4.1",
+    "pytest==8.3.5",
+    # "pytest-asyncio==1.1.0",
+    "pytest-asyncio==0.26.0",
+    "pytest-playwright==0.7.0",
+]
+
+[tool.briefcase]
+project_name = "Toga Web Testbed"
+bundle = "org.beeware.toga"
+url = "https://beeware.org"
+license = "BSD-3-Clause"
+license-files = [
+    "LICENSE",
+]
+author = "Tiberius Yak"
+author_email = "[email protected]"
+
+[tool.briefcase.app.testbed]
+formal_name = "Toga Testbed"
+description = "A testbed for Toga visual tests"
+icon = "icons/testbed"
+sources = [
+    "src/testbed",
+]
+test_sources = [
+    "tests",
+]
+requires = [
+    "../travertino",
+    "../core",
+]
+
+[tool.briefcase.app.testbed.web]
+requires = [
+    "../web"
+]
+style_framework = "Shoelace v2.3"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

web-testbed/src/testbed/__main__.py

@@ -0,0 +1,4 @@
+from testbed.app import main
+
+if __name__ == "__main__":
+    main().main_loop()

web-testbed/src/testbed/app.py

@@ -0,0 +1,122 @@
+import os
+import types
+from unittest.mock import Mock
+
+import toga
+from toga.style import Pack
+from toga.style.pack import COLUMN
+
+try:
+    import js
+except ModuleNotFoundError:
+    js = None
+try:
+    from pyodide.ffi import create_proxy, to_js
+except ModuleNotFoundError:
+    pyodide = None
+
+
+def _truthy(v) -> bool:
+    return str(v).strip().lower() in {"1", "true", "yes", "on"}
+
+
+def _web_testing_enabled() -> bool:
+    if _truthy(os.getenv("TOGA_WEB_TESTING")):
+        return True
+
+    if js is not None:
+        try:
+            if _truthy(getattr(js.window, "TOGA_WEB_TESTING", "")):
+                return True
+            qs = str(getattr(js.window, "location", None).search or "")
+            # enable if ?toga_web_testing=1 in url
+            if "toga_web_testing" in qs.lower():
+                return True
+        except Exception:
+            pass
+
+    return False
+
+
+class HelloWorld(toga.App):
+    def startup(self):
+        main_box = toga.Box(style=Pack(direction=COLUMN))
+        self.label = toga.Label(id="myLabel", text="Test App - Toga Web Testing")
+
+        if _web_testing_enabled() and js is not None and create_proxy is not None:
+            self.my_objs = {}
+            js.window.test_cmd = create_proxy(self.cmd_test)
+
+        main_box.add(self.label)
+        self.main_window = toga.MainWindow(title=self.formal_name)
+        self.main_window.content = main_box
+        self.main_window.show()
+
+    def cmd_test(self, code):
+        env = {"self": self, "toga": toga, "my_objs": self.my_objs, "Mock": Mock}
+        local = {}
+        try:
+            exec(code, env, local)
+            result = local.get("result", env.get("result"))
+            envelope = self._serialise_payload(result)
+            return to_js(envelope, dict_converter=js.Object.fromEntries)
+        except Exception as e:
+            return to_js(
+                {"type": "error", "value": str(e)}, dict_converter=js.Object.fromEntries
+            )
+
+    def _serialise_payload(self, x):
+        # primitives
+        if x is None:
+            return {"type": "none", "value": None}
+        if isinstance(x, bool):
+            return {"type": "bool", "value": x}
+        if isinstance(x, int):
+            return {"type": "int", "value": x}
+        if isinstance(x, float):
+            return {"type": "float", "value": x}
+        if isinstance(x, str):
+            return {"type": "str", "value": x}
+
+        # containers
+        if isinstance(x, list):
+            return {"type": "list", "items": [self._serialise_payload(i) for i in x]}
+        if isinstance(x, tuple):
+            return {"type": "tuple", "items": [self._serialise_payload(i) for i in x]}
+        if isinstance(x, dict):
+            items = []
+            for k, v in x.items():
+                if k is None:
+                    key_env = {"type": "none", "value": None}
+                elif isinstance(k, bool):
+                    key_env = {"type": "bool", "value": k}
+                elif isinstance(k, int):
+                    key_env = {"type": "int", "value": k}
+                elif isinstance(k, float):
+                    key_env = {"type": "float", "value": k}
+                elif isinstance(k, str):
+                    key_env = {"type": "str", "value": k}
+                else:
+                    key_env = {"type": "str", "value": str(k)}
+                items.append([key_env, self._serialise_payload(v)])
+            return {"type": "dict", "items": items}
+
+        # references by id
+        obj_id = self._key_for(x)
+        is_callable = callable(x) or isinstance(
+            x, (types.FunctionType, types.MethodType)
+        )
+        return {"type": "callable" if is_callable else "object", "id": obj_id}
+
+    def _key_for(self, x):
+        for k, v in self.my_objs.items():
+            if v is x:
+                return k
+        # If not registered, register it
+        k = str(id(x))
+        self.my_objs[k] = x
+        return k
+
+
+def main():
+    return HelloWorld()

web-testbed/tests/assertions.py

@@ -0,0 +1,64 @@
+from pytest import approx
+
+TRANSPARENT = "transparent"
+
+
+def assert_background_color(actual, expected):
+    # For platforms where alpha blending is manually implemented, the
+    # probe.background_color property returns a tuple consisting of:
+    #   - The widget's background color
+    #   - The widget's parent's background color
+    #   - The widget's original alpha value - Required for deblending
+    if isinstance(actual, tuple):
+        actual_widget_bg, actual_parent_bg, actual_widget_bg_alpha = actual
+        if actual_widget_bg_alpha == 0:
+            # Since a color having an alpha value of 0 cannot be deblended.
+            # So, the deblended widget color would be equal to the parent color.
+            deblended_actual_widget_bg = actual_parent_bg
+        else:
+            deblended_actual_widget_bg = actual_widget_bg.unblend_over(
+                actual_parent_bg, actual_widget_bg_alpha
+            )
+        if isinstance(expected, tuple):
+            expected_widget_bg, expected_parent_bg, expected_widget_bg_alpha = expected
+            if expected_widget_bg_alpha == 0:
+                # Since a color having an alpha value of 0 cannot be deblended.
+                # So, the deblended widget color would be equal to the parent color.
+                deblended_expected_widget_bg = expected_parent_bg
+            else:
+                deblended_expected_widget_bg = expected_widget_bg.unblend_over(
+                    expected_parent_bg, expected_widget_bg_alpha
+                )
+            assert_color(deblended_actual_widget_bg, deblended_expected_widget_bg)
+        # For comparison when expected is a single value object
+        else:
+            if (expected == TRANSPARENT) or (
+                expected.a == 0
+                # Since a color having an alpha value of 0 cannot be deblended to
+                # get the exact original color, as deblending in such cases would
+                # lead to a division by zero error. So, just check that widget and
+                # parent have the same color.
+            ):
+                assert_color(actual_widget_bg, actual_parent_bg)
+            elif expected.a != 1:
+                assert_color(deblended_actual_widget_bg, expected)
+            else:
+                assert_color(actual_widget_bg, expected)
+    # For other platforms
+    else:
+        assert_color(actual, expected)
+
+
+def assert_color(actual, expected):
+    if expected in {None, TRANSPARENT}:
+        assert expected == actual
+    else:
+        if actual in {None, TRANSPARENT}:
+            assert expected == actual
+        else:
+            assert (actual.r, actual.g, actual.b, actual.a) == (
+                expected.r,
+                expected.g,
+                expected.b,
+                approx(expected.a, abs=(1 / 255)),
+            )

web-testbed/tests/conftest.py

@@ -0,0 +1,32 @@
+# from pytest import fixture, register_assert_rewrite, skip
+# import toga
+
+import pytest
+
+from .tests_backend.playwright_page import BackgroundPage
+from .tests_backend.proxies.app_proxy import AppProxy
+from .tests_backend.proxies.base_proxy import BaseProxy
+from .tests_backend.widgets.base import SimpleProbe
+
+
+@pytest.fixture(scope="session")
+def page():
+    p = BackgroundPage()
+    return p
+
+
+# Inject Playwright page object into
+@pytest.fixture(scope="session", autouse=True)
+def _wire_page(page):
+    BaseProxy.page_provider = staticmethod(lambda: page)
+    SimpleProbe.page_provider = staticmethod(lambda: page)
+
+
+@pytest.fixture(scope="session")
+def app():
+    return AppProxy()
+
+
+@pytest.fixture(scope="session")
+def main_window(app):
+    return app.main_window

web-testbed/tests/data.py

@@ -0,0 +1,22 @@
+# A test object that can be used as data
+class MyObject:
+    def __str__(self):
+        return "My Test Object"
+
+
+# The text examples must both increase and decrease in size between examples to
+# ensure that reducing the size of a label doesn't prevent future labels from
+# increasing in size.
+TEXTS = [
+    "example",
+    "",
+    "a",
+    " ",
+    "ab",
+    "abc",
+    "hello world",
+    "hello\nworld",
+    "你好, wørłd!",
+    1234,
+    MyObject(),
+]