added base tests with playwright

Author: Andrei Neagu

services/dynamic-scheduler/requirements/_test.in

@@ -15,6 +15,8 @@ asgi_lifespan
 coverage
 docker
 faker
+hypercorn
+playwright
 pytest
 pytest-asyncio
 pytest-cov

services/dynamic-scheduler/requirements/_test.txt

@@ -23,10 +23,20 @@ docker==7.1.0
     # via -r requirements/_test.in
 faker==33.0.0
     # via -r requirements/_test.in
+greenlet==3.1.1
+    # via
+    #   -c requirements/_base.txt
+    #   playwright
 h11==0.14.0
     # via
     #   -c requirements/_base.txt
     #   httpcore
+    #   hypercorn
+    #   wsproto
+h2==4.1.0
+    # via hypercorn
+hpack==4.0.0
+    # via h2
 httpcore==1.0.7
     # via
     #   -c requirements/_base.txt
@@ -36,6 +46,10 @@ httpx==0.27.2
     #   -c requirements/../../../requirements/constraints.txt
     #   -c requirements/_base.txt
     #   respx
+hypercorn==0.17.3
+    # via -r requirements/_test.in
+hyperframe==6.0.1
+    # via h2
 icdiff==2.0.7
     # via pytest-icdiff
 idna==3.10
@@ -51,10 +65,16 @@ packaging==24.2
     #   -c requirements/_base.txt
     #   pytest
     #   pytest-sugar
+playwright==1.49.0
+    # via -r requirements/_test.in
 pluggy==1.5.0
     # via pytest
 pprintpp==0.4.0
     # via pytest-icdiff
+priority==2.0.0
+    # via hypercorn
+pyee==12.0.0
+    # via playwright
 pytest==8.3.3
     # via
     #   -r requirements/_test.in
@@ -107,9 +127,14 @@ typing-extensions==4.12.2
     # via
     #   -c requirements/_base.txt
     #   faker
+    #   pyee
 urllib3==2.2.3
     # via
     #   -c requirements/../../../requirements/constraints.txt
     #   -c requirements/_base.txt
     #   docker
     #   requests
+wsproto==1.2.0
+    # via
+    #   -c requirements/_base.txt
+    #   hypercorn

services/dynamic-scheduler/src/simcore_service_dynamic_scheduler/api/frontend/routes/_index.py

@@ -11,7 +11,6 @@
 from ....services.service_tracker import TrackedServiceModel, get_all_tracked_services
 from ....services.service_tracker._models import SchedulerServiceState
 from .._utils import get_parent_app
-from . import markers
 from ._render_utils import base_page, get_iso_formatted_date
 
 router = APIRouter()
@@ -49,7 +48,7 @@ def _render_service_details(node_id: NodeID, service: TrackedServiceModel) -> No
             ),
         )
 
-    with ui.column().classes("gap-0").mark(markers.INDEX_SERVICE_CARD):
+    with ui.column().classes("gap-0"):
         for key, (widget, value) in dict_to_render.items():
             with ui.row(align_items="baseline"):
                 ui.label(key).classes("font-bold")
@@ -63,55 +62,42 @@ def _render_service_details(node_id: NodeID, service: TrackedServiceModel) -> No
 
 
 def _render_buttons(node_id: NodeID, service: TrackedServiceModel) -> None:
-    async def _display_confirm_dialog():
-        with ui.dialog() as confirm_dialog, ui.card():
-            confirm_dialog.mark(markers.INDEX_SERVICE_CARD_STOP_CONFIRM_DIALOG)
-
-            ui.markdown(f"Stop service **{node_id}**?")
-            ui.label("The service will be stopped and its data will be saved.")
-            with ui.row():
-                ui.button(
-                    "Stop",
-                    color="red",
-                    on_click=lambda: confirm_dialog.submit("Stop"),
-                )
-                ui.button("No", on_click=lambda: confirm_dialog.submit("No")).mark(
-                    markers.INDEX_SERVICE_CARD_STOP_CONFIRM_DIALOG_NO_BUTTON
-                )
 
-        click_result = await confirm_dialog
+    with ui.dialog() as confirm_dialog, ui.card():
 
-        if click_result != "Stop":
-            return
+        ui.markdown(f"Stop service **{node_id}**?")
+        ui.label("The service will be stopped and its data will be saved.")
+        with ui.row():
 
-        await httpx.AsyncClient(timeout=10).get(
-            f"http://localhost:{DEFAULT_FASTAPI_PORT}/service/{node_id}:stop"
-        )
+            async def _stop_service() -> None:
+                confirm_dialog.close()
+                await httpx.AsyncClient(timeout=10).get(
+                    f"http://localhost:{DEFAULT_FASTAPI_PORT}/service/{node_id}:stop"
+                )
 
-        ui.notify(
-            f"Submitted stop request for {node_id}. Please give the service some time to stop!"
-        )
+                ui.notify(
+                    f"Submitted stop request for {node_id}. Please give the service some time to stop!"
+                )
+
+            ui.button("Stop Now", color="red", on_click=_stop_service)
+            ui.button("Cancel", on_click=confirm_dialog.close)
 
     with ui.button_group():
         ui.button(
             "Details",
             icon="source",
             on_click=lambda: ui.navigate.to(f"/service/{node_id}:details"),
-        ).tooltip("Display more information about what the scheduler is tracking").mark(
-            markers.INDEX_SERVICE_CARD_DETAILS_BUTTON
-        )
+        ).tooltip("Display more information about what the scheduler is tracking")
 
         if service.current_state != SchedulerServiceState.RUNNING:
             return
 
         ui.button(
-            "Stop service",
+            "Stop Service",
             icon="stop",
             color="orange",
-            on_click=_display_confirm_dialog,
-        ).tooltip("Stops the service and saves the data").mark(
-            markers.INDEX_SERVICE_CARD_STOP_BUTTON
-        )
+            on_click=confirm_dialog.open,
+        ).tooltip("Stops the service and saves the data")
 
 
 def _render_card(
@@ -169,10 +155,10 @@ async def update(self) -> None:
 async def index():
     with base_page():
         with ui.row().classes("gap-0"):
-            ui.label("Total tracked services:").mark(markers.INDEX_TOTAL_SERVICES_LABEL)
+            ui.label("Total tracked services:")
             ui.label("").classes("w-1")
             with ui.label("0") as services_count_label:
-                services_count_label.mark(markers.INDEX_TOTAL_SERVICES_COUNT_LABEL)
+                pass
 
         card_container: Element = ui.row()
 

services/dynamic-scheduler/src/simcore_service_dynamic_scheduler/api/frontend/routes/markers.py

@@ -20,7 +20,6 @@
 from simcore_service_dynamic_scheduler.core.application import create_app
 
 pytest_plugins = [
-    "nicegui.testing.user_plugin",
     "pytest_simcore.cli_runner",
     "pytest_simcore.docker_compose",
     "pytest_simcore.docker_swarm",

services/dynamic-scheduler/tests/conftest.py

@@ -1,16 +1,23 @@
 # pylint:disable=redefined-outer-name
 # pylint:disable=unused-argument
 
-from typing import AsyncIterator
+import asyncio
+import subprocess
+from collections.abc import AsyncIterable
+from contextlib import suppress
 
 import pytest
-from fastapi import FastAPI
-from httpx import ASGITransport, AsyncClient
-from nicegui.testing.user import User
+from fastapi import FastAPI, status
+from httpx import AsyncClient
+from hypercorn.asyncio import serve
+from hypercorn.config import Config
+from playwright.async_api import Page, async_playwright
 from pytest_mock import MockerFixture
 from pytest_simcore.helpers.typing_env import EnvVarsDict
 from settings_library.rabbit import RabbitSettings
 from settings_library.redis import RedisSettings
+from simcore_service_dynamic_scheduler.core.application import create_app
+from tenacity import AsyncRetrying, stop_after_delay, wait_fixed
 
 
 @pytest.fixture
@@ -32,21 +39,61 @@ def app_environment(
 
 
 @pytest.fixture
-async def client(
-    app_environment: EnvVarsDict, app: FastAPI
-) -> AsyncIterator[AsyncClient]:
-    # - Needed for app to trigger start/stop event handlers
-    # - Prefer this client instead of fastapi.testclient.TestClient
-    async with AsyncClient(
-        app=app,
-        base_url="http://payments.testserver.io",
-        headers={"Content-Type": "application/json"},
-    ) as httpx_client:
-        # pylint:disable=protected-access
-        assert isinstance(httpx_client._transport, ASGITransport)  # noqa: SLF001
-        yield httpx_client
+def server_host_port() -> str:
+    return "127.0.0.1:7456"
 
 
 @pytest.fixture
-async def user(client: AsyncClient) -> User:
-    return User(client)
+def not_initialized_app(app_environment: EnvVarsDict) -> FastAPI:
+    return create_app()
+
+
+@pytest.fixture
+async def app_runner(
+    not_initialized_app: FastAPI, server_host_port: str
+) -> AsyncIterable[None]:
+
+    shutdown_event = asyncio.Event()
+
+    async def _wait_for_shutdown_event():
+        await shutdown_event.wait()
+
+    async def _run_server() -> None:
+        config = Config()
+        config.bind = [server_host_port]
+
+        with suppress(asyncio.CancelledError):
+            await serve(
+                not_initialized_app, config, shutdown_trigger=_wait_for_shutdown_event
+            )
+
+    server_task = asyncio.create_task(_run_server())
+
+    async for attempt in AsyncRetrying(
+        reraise=True, wait=wait_fixed(0.1), stop=stop_after_delay(2)
+    ):
+        with attempt:
+            async with AsyncClient(timeout=1) as client:
+                result = await client.get(f"http://{server_host_port}")
+                assert result.status_code == status.HTTP_200_OK
+
+    yield
+
+    shutdown_event.set()
+    await server_task
+
+
+@pytest.fixture
+def download_playwright_browser() -> None:
+    subprocess.run(  # noqa: S603
+        ["playwright", "install", "chromium"], check=True  # noqa: S607
+    )
+
+
+@pytest.fixture
+async def async_page(download_playwright_browser: None) -> AsyncIterable[Page]:
+    async with async_playwright() as p:
+        browser = await p.chromium.launch()
+        page = await browser.new_page()
+        yield page
+        await browser.close()

services/dynamic-scheduler/tests/unit/api_frontend/conftest.py

@@ -0,0 +1,88 @@
+# pylint:disable=redefined-outer-name
+# pylint:disable=unused-argument
+
+import sys
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Final
+from uuid import uuid4
+
+from playwright.async_api import Locator, Page
+from pydantic import NonNegativeFloat, NonNegativeInt
+from tenacity import AsyncRetrying, stop_after_delay, wait_fixed
+
+_HERE: Final[Path] = (
+    Path(sys.argv[0] if __name__ == "__main__" else __file__).resolve().parent
+)
+_DEFAULT_TIMEOUT: Final[NonNegativeFloat] = 10
+
+
+@asynccontextmanager
+async def _take_screenshot_on_error(
+    async_page: Page,
+) -> AsyncIterator[None]:
+    try:
+        yield
+    # allows to also capture exceptions form `with pytest.raise(...)``
+    except BaseException:
+        path = _HERE / f"{uuid4()}.ignore.png"
+        await async_page.screenshot(path=path)
+        print(f"Please check :{path}")
+
+        raise
+
+
+async def _get_locator(
+    async_page: Page,
+    text: str,
+    instances: NonNegativeInt | None,
+    timeout: float,  # noqa: ASYNC109
+) -> Locator:
+    async with _take_screenshot_on_error(async_page):
+        async for attempt in AsyncRetrying(
+            reraise=True, wait=wait_fixed(0.1), stop=stop_after_delay(timeout)
+        ):
+            with attempt:
+                locator = async_page.get_by_text(text)
+                count = await locator.count()
+                if instances is None:
+                    assert count > 0, f"cold not find text='{text}'"
+                else:
+                    assert (
+                        count == instances
+                    ), f"found {count} instances of text='{text}'. Expected {instances}"
+    return locator
+
+
+async def assert_contains_text(
+    async_page: Page,
+    text: str,
+    instances: NonNegativeInt | None = None,
+    timeout: float = _DEFAULT_TIMEOUT,  # noqa: ASYNC109
+) -> None:
+    await _get_locator(async_page, text, instances=instances, timeout=timeout)
+
+
+async def click_on_text(
+    async_page: Page,
+    text: str,
+    instances: NonNegativeInt | None = None,
+    timeout: float = _DEFAULT_TIMEOUT,  # noqa: ASYNC109
+) -> None:
+    locator = await _get_locator(async_page, text, instances=instances, timeout=timeout)
+    await locator.click()
+
+
+async def assert_not_contains_text(
+    async_page: Page,
+    text: str,
+    timeout: float = _DEFAULT_TIMEOUT,  # noqa: ASYNC109
+) -> None:
+    async with _take_screenshot_on_error(async_page):
+        async for attempt in AsyncRetrying(
+            reraise=True, wait=wait_fixed(0.1), stop=stop_after_delay(timeout)
+        ):
+            with attempt:
+                locator = async_page.get_by_text(text)
+                assert await locator.count() < 1, f"found text='{text}' in body"