[TEST] TASK-04: Implement End-to-End Browser Automation Suite using Python and Playwright

[ikostan]

TASK-04: Implement End-to-End Browser Automation Suite using Python and Playwright

Description

Develop a production-grade integration and regression test script (tests/splash_transition_flow_test.py) using Python and the Playwright framework to monitor the web loading layers, runtime initialization telemetry, and rendering handshake sequences. The script must mirror the codebase's existing architectural standards—utilizing Chrome DevTools Protocol (CDP) for V8 precision coverage mapping, custom logging hooks, isolated artifact generation on exceptions, and strict synchronization models.

Technical Steps

1. Create tests/splash_transition_flow_test.py conforming to the project's testing conventions, using explicit type annotations, and importing matching lifecycle dependencies.
2. Establish an active CDP session on the page context to handle accurate V8 execution coverage tracking metrics.
3. Inject a standard logging event handler to stream and parse raw console logs across execution boundaries, filtering specifically for the newly configured initialization hooks ("Telemetry - Assembly Transfer:").
4. Implement a robust synchronization chain: assert #loading visibility state on initial navigation, wait for window.godotInitialized to settle, and verify the #canvas target structure drops opacity overrides smoothly.
5. Construct a defensive execution trap (except Exception) that writes runtime crash states, current DOM content dumps, and timestamped browser screenshots into the shared artifacts/ folder on test failures.

Acceptance Criteria

• The automation runner deploys, instruments, and executes cleanly across automated continuous integration pipelines.
• Custom telemetry filters accurately detect progress assertions on clean profile iterations.
• Structural UI crashes, black frame regressions, or uncaught compilation breaks actively trip the failure trap to spit out timestamped log snapshots.

[ikostan]

Test Script Specification (tests/splash_transition_flow_test.py)

# Copyright (C) 2025 Egor Kostan
# SPDX-License-Identifier: GPL-3.0-or-later
# tests/splash_transition_flow_test.py
"""
Splash Screen Transition & Telemetry Test Suite (Playwright + UI Automation)
=============================================================================

Overview
--------
Verifies the asynchronous web loading workflow, custom shell initialization pipeline, 
and in-game progress transition mechanics. Eliminates race conditions by validating 
orderly handshakes between the DOM layout engine and the WebAssembly runtime graphics context.

Running
-------
pytest -k splash_transition_flow -q

Artifacts
---------
v8_coverage_splash_transition_flow_test.json, artifacts/test_splash_failure_*.png/txt/html
"""

import json
import os
import time
from playwright.sync_api import Page, expect

# Configuration matching the repository stability matrix
DEFAULT_TIMEOUT = int(os.getenv("TEST_TIMEOUT", "30000"))
TEST_TIMEOUT = int(os.getenv("TEST_TIMEOUT", "5000"))


def test_splash_transition_flow(page: Page) -> None:
    """
    Validates assembly stream metrics, WebGL frame canvas presentation, 
    and the removal of preloader DOM layers without structural rendering anomalies.
    """
    logs: list[dict[str, str]] = []
    cdp_session = None

    def on_console(msg) -> None:
        """Capture all console logs to track runtime lifecycle telemetry."""
        logs.append({"type": msg.type, "text": msg.text})

    page.on("console", on_console)

    try:
        # Start CDP session for V8 JS coverage calculation
        cdp_session = page.context.new_cdp_session(page)
        cdp_session.send("Profiler.enable")
        cdp_session.send(
            "Profiler.startPreciseCoverage", {"callCount": True, "detailed": True}
        )

        # 1. MONITOR INITIAL BROWSER LOADING LAYER
        page.goto(
            "http://localhost:8080/index.html",
            wait_until="networkidle",
            timeout=DEFAULT_TIMEOUT,
        )
        
        # Verify custom HTML layout preloader maps instantly to the screen
        loading_overlay = page.locator("#loading")
        expect(loading_overlay).to_be_visible(timeout=TEST_TIMEOUT)

        # 2. VERIFY ENGINE INITIALIZATION & RUNTIME TELEMETRY
        # Hold execution path parameters until the WebAssembly compilation resolves safely
        page.wait_for_timeout(TEST_TIMEOUT)
        page.wait_for_function("() => window.godotInitialized", timeout=DEFAULT_TIMEOUT)

        # Confirm the customized configuration object processed data transfers
        transfer_logs = [log["text"] for log in logs if "Telemetry - Assembly Transfer:" in log["text"]]
        print(f"Verified {len(transfer_logs)} active assembly streaming progress tracking marks.")

        # 3. ASSIGN RENDERING CANVASES HANDSHAKE INVARIANTS
        canvas_element = page.locator("#canvas")
        expect(canvas_element).to_be_visible(timeout=TEST_TIMEOUT)
        assert "SkyLockAssault" in page.title(), "Target application execution context title mismatch"

        # Verify HTML shell overlay deflates cleanly out of the frame
        expect(loading_overlay).to_be_hidden(timeout=TEST_TIMEOUT)
        assert page.evaluate("document.getElementById('loading').getAttribute('aria-hidden') === 'true'")

        # Confirm no critical engine parsing or initialization errors bubbled up during startup
        critical_faults = [
            log["text"] for log in logs 
            if log["type"] == "error" and not any(
                phrase in log["text"].lower() for phrase in ["encryption aborted", "salt is empty"]
            )
        ]
        assert len(critical_faults) == 0, f"Critical exceptions found during web handshake: {critical_faults}"

    except Exception as e:
        print(f"Test: 'test_splash_transition_flow' broken: {str(e)}")
        os.makedirs("artifacts", exist_ok=True)
        timestamp: int = int(time.time())
        
        # Isolate diagnostics files on execution crashes
        page.screenshot(path=f"artifacts/test_splash_failure_screenshot_{timestamp}.png")
        
        with open(f"artifacts/test_splash_failure_console_logs_{timestamp}.txt", "w", encoding="utf-8") as f:
            for log in logs:
                f.write(f"[{log['type']}] {log['text']}\n")
                
        with open(f"artifacts/test_splash_failure_html_{timestamp}.html", "w", encoding="utf-8") as f:
            f.write(page.content())
        raise
        
    finally:
        if cdp_session:
            # Safely serialize performance execution maps to disk before tearing down process targets
            coverage = cdp_session.send("Profiler.takePreciseCoverage")["result"]
            cdp_session.send("Profiler.stopPreciseCoverage")
            cdp_session.send("Profiler.disable")
            with open("v8_coverage_splash_transition_flow_test.json", "w", encoding="utf-8") as f:
                json.dump(coverage, f)


if __name__ == "__main__":
    import pytest
    pytest.main([__file__])