nat-engine 1__py3-none-any.whl

mannf/product/ingestors/playwright_ingestor.py

@@ -0,0 +1,449 @@
+# Copyright (C) 2026 Brad Guider
+# This file is part of NAT (Neural Agent Testing Framework).
+# Licensed under the AGPL-3.0. See LICENSE for details.
+# Commercial licensing available — see COMMERCIAL_LICENSE.md.
+
+"""Playwright test-file ingestor plugin.
+
+Parses Playwright ``.spec.ts`` / ``.spec.js`` test files using regex-based
+extraction (no AST or Node.js runtime required) and converts the discovered
+test actions into :class:`~mannf.product.ingestors.models.IngestedTestCase`
+objects that match the :class:`~mannf.core.functional_orchestrator.FunctionalTestOrchestrator`
+task shape.
+
+Supported Playwright patterns
+------------------------------
+* ``test('name', async ({ page }) => { ... })`` — top-level test blocks
+* ``page.goto('url')`` / ``page.goto("url")``
+* ``page.fill('selector', 'value')``
+* ``page.type('selector', 'value')``
+* ``page.click('selector')``
+* ``page.locator('selector').click()``
+* ``page.locator('selector').fill('value')``
+* ``page.getByRole('role', { name: 'text' }).click()``
+* ``page.getByText('text').click()``
+* ``page.getByLabel('label').fill('value')``
+* ``page.getByPlaceholder('ph').fill('value')``
+* ``page.getByTestId('id').click()``
+* ``expect(page).toHaveURL('url')`` — captured as assert steps
+* ``expect(locator).toBeVisible()`` / ``toBeEnabled()`` etc.
+* ``test.describe('suite', () => { ... })`` — nested describe blocks
+
+The extracted tests are tagged with ``["playwright"]`` and their source
+file reference is set to ``file.spec.ts::<test_name>``.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from pathlib import Path
+from typing import Any
+
+from mannf.product.ingestors.base import IngestorPlugin
+from mannf.product.ingestors.models import (
+    IngestedTestCase,
+    IngestorSource,
+    IngestResult,
+)
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Regex patterns
+# ---------------------------------------------------------------------------
+
+# test('name', ...) or test("name", ...) or test(`name`, ...)
+_RE_TEST_BLOCK = re.compile(
+    r"""test\s*\(\s*(['"`])(.*?)\1""",
+    re.DOTALL,
+)
+
+# test.describe('suite name', ...) or test.describe("suite name", ...)
+_RE_DESCRIBE_BLOCK = re.compile(
+    r"""test\.describe\s*\(\s*(['"`])(.*?)\1""",
+    re.DOTALL,
+)
+
+# page.goto('url') / page.goto("url") / page.goto(`url`)
+_RE_GOTO = re.compile(
+    r"""page\.goto\s*\(\s*(['"`])(.*?)\1""",
+)
+
+# page.fill('selector', 'value') or page.fill("sel", "val")
+_RE_FILL = re.compile(
+    r"""page\.fill\s*\(\s*(['"`])(.*?)\1\s*,\s*(['"`])(.*?)\3\s*\)""",
+)
+
+# page.type('selector', 'value')
+_RE_TYPE = re.compile(
+    r"""page\.type\s*\(\s*(['"`])(.*?)\1\s*,\s*(['"`])(.*?)\3\s*\)""",
+)
+
+# page.click('selector')
+_RE_CLICK = re.compile(
+    r"""page\.click\s*\(\s*(['"`])(.*?)\1\s*\)""",
+)
+
+# page.locator('selector').click()
+_RE_LOCATOR_CLICK = re.compile(
+    r"""page\.locator\s*\(\s*(['"`])(.*?)\1\s*\)\.click\s*\(\s*\)""",
+)
+
+# page.locator('selector').fill('value')
+_RE_LOCATOR_FILL = re.compile(
+    r"""page\.locator\s*\(\s*(['"`])(.*?)\1\s*\)\.fill\s*\(\s*(['"`])(.*?)\3\s*\)""",
+)
+
+# page.getByRole('role', { name: 'label' }).click() or .fill('value')
+_RE_GET_BY_ROLE = re.compile(
+    r"""page\.getByRole\s*\(\s*(['"`])(.*?)\1(?:\s*,\s*\{\s*name\s*:\s*(['"`])(.*?)\3\s*\})?\s*\)\.(click|fill)\s*\((?:\s*(['"`])(.*?)\6\s*)?\)""",
+)
+
+# page.getByText('text').click()
+_RE_GET_BY_TEXT_CLICK = re.compile(
+    r"""page\.getByText\s*\(\s*(['"`])(.*?)\1\s*\)\.click\s*\(\s*\)""",
+)
+
+# page.getByLabel('label').fill('value')
+_RE_GET_BY_LABEL_FILL = re.compile(
+    r"""page\.getByLabel\s*\(\s*(['"`])(.*?)\1\s*\)\.fill\s*\(\s*(['"`])(.*?)\3\s*\)""",
+)
+
+# page.getByLabel('label').click()
+_RE_GET_BY_LABEL_CLICK = re.compile(
+    r"""page\.getByLabel\s*\(\s*(['"`])(.*?)\1\s*\)\.click\s*\(\s*\)""",
+)
+
+# page.getByPlaceholder('placeholder').fill('value')
+_RE_GET_BY_PLACEHOLDER_FILL = re.compile(
+    r"""page\.getByPlaceholder\s*\(\s*(['"`])(.*?)\1\s*\)\.fill\s*\(\s*(['"`])(.*?)\3\s*\)""",
+)
+
+# page.getByTestId('testId').click()
+_RE_GET_BY_TESTID_CLICK = re.compile(
+    r"""page\.getByTestId\s*\(\s*(['"`])(.*?)\1\s*\)\.click\s*\(\s*\)""",
+)
+
+# page.getByTestId('testId').fill('value')
+_RE_GET_BY_TESTID_FILL = re.compile(
+    r"""page\.getByTestId\s*\(\s*(['"`])(.*?)\1\s*\)\.fill\s*\(\s*(['"`])(.*?)\3\s*\)""",
+)
+
+# expect(page).toHaveURL('url')
+_RE_EXPECT_URL = re.compile(
+    r"""expect\s*\(\s*page\s*\)\.toHaveURL\s*\(\s*(['"`])(.*?)\1\s*\)""",
+)
+
+# expect(locator).toBeVisible() / toBeEnabled() / toHaveText('...') etc.
+_RE_EXPECT_VISIBLE = re.compile(
+    r"""expect\s*\(.*?\)\.(toBeVisible|toBeEnabled|toBeDisabled|toBeChecked|toHaveText|toHaveValue|toBeHidden)\s*\(([^)]*)\)""",
+    re.DOTALL,
+)
+
+# Priority heuristics
+_HIGH_PRIORITY_KEYWORDS: tuple[str, ...] = (
+    "login", "auth", "register", "checkout", "payment", "critical",
+)
+_NEGATIVE_KEYWORDS: tuple[str, ...] = (
+    "invalid", "error", "fail", "negative", "reject", "wrong",
+)
+
+# ---------------------------------------------------------------------------
+# Helper — extract test blocks from source
+# ---------------------------------------------------------------------------
+
+
+def _extract_test_blocks(content: str) -> list[tuple[str, str]]:
+    """Return a list of (test_name, test_body) pairs from *content*.
+
+    This uses a simple brace-counting approach to extract the body of each
+    ``test('name', ...)`` call so that we can apply per-test regex extraction
+    without one test's steps leaking into another.
+    """
+    results: list[tuple[str, str]] = []
+
+    for m in _RE_TEST_BLOCK.finditer(content):
+        name = m.group(2)
+        # Find the opening '{' of the arrow function body.
+        # We skip past arrow functions like `async ({ page }) => {` by looking
+        # for `=> {` rather than the first bare `{` (which could be the argument
+        # destructuring `({ page })`).
+        pos = m.end()
+        arrow_match = content.find("=> {", pos)
+        if arrow_match != -1:
+            brace_pos = content.find("{", arrow_match)
+        else:
+            # Fallback: find the first '{' after the match
+            brace_pos = content.find("{", pos)
+        if brace_pos == -1:
+            continue
+        # Count braces to find the matching '}'
+        depth = 0
+        end_pos = brace_pos
+        for i, ch in enumerate(content[brace_pos:], start=brace_pos):
+            if ch == "{":
+                depth += 1
+            elif ch == "}":
+                depth -= 1
+                if depth == 0:
+                    end_pos = i
+                    break
+        body = content[brace_pos : end_pos + 1]
+        results.append((name, body))
+
+    return results
+
+
+def _extract_describe_name(content: str, pos: int) -> str | None:
+    """Return the ``test.describe`` suite name that contains position *pos*."""
+    for m in _RE_DESCRIBE_BLOCK.finditer(content):
+        if m.start() <= pos:
+            return m.group(2)
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Step extractors
+# ---------------------------------------------------------------------------
+
+
+def _extract_steps(body: str) -> list[dict[str, Any]]:
+    """Extract all recognisable browser actions from *body* as step dicts."""
+    steps: list[dict[str, Any]] = []
+
+    # page.goto
+    for m in _RE_GOTO.finditer(body):
+        steps.append(
+            {"action": "navigate", "selector": m.group(2), "url": m.group(2), "_pos": m.start()}
+        )
+
+    # page.fill
+    for m in _RE_FILL.finditer(body):
+        steps.append(
+            {"action": "fill", "selector": m.group(2), "value": m.group(4), "_pos": m.start()}
+        )
+
+    # page.type
+    for m in _RE_TYPE.finditer(body):
+        steps.append(
+            {"action": "fill", "selector": m.group(2), "value": m.group(4), "_pos": m.start()}
+        )
+
+    # page.click
+    for m in _RE_CLICK.finditer(body):
+        steps.append(
+            {"action": "click", "selector": m.group(2), "_pos": m.start()}
+        )
+
+    # page.locator().click()
+    for m in _RE_LOCATOR_CLICK.finditer(body):
+        steps.append(
+            {"action": "click", "selector": m.group(2), "_pos": m.start()}
+        )
+
+    # page.locator().fill()
+    for m in _RE_LOCATOR_FILL.finditer(body):
+        steps.append(
+            {"action": "fill", "selector": m.group(2), "value": m.group(4), "_pos": m.start()}
+        )
+
+    # page.getByRole().click() or .fill()
+    for m in _RE_GET_BY_ROLE.finditer(body):
+        role = m.group(2)
+        label = m.group(4) or ""
+        action_name = m.group(5)
+        value = m.group(7) or ""
+        selector = f"[role={role}]" + (f"[name='{label}']" if label else "")
+        if action_name == "click":
+            steps.append({"action": "click", "selector": selector, "_pos": m.start()})
+        else:
+            steps.append({"action": "fill", "selector": selector, "value": value, "_pos": m.start()})
+
+    # page.getByText().click()
+    for m in _RE_GET_BY_TEXT_CLICK.finditer(body):
+        steps.append(
+            {"action": "click", "selector": f"text={m.group(2)}", "_pos": m.start()}
+        )
+
+    # page.getByLabel().fill()
+    for m in _RE_GET_BY_LABEL_FILL.finditer(body):
+        steps.append(
+            {"action": "fill", "selector": f"label={m.group(2)}", "value": m.group(4), "_pos": m.start()}
+        )
+
+    # page.getByLabel().click()
+    for m in _RE_GET_BY_LABEL_CLICK.finditer(body):
+        steps.append(
+            {"action": "click", "selector": f"label={m.group(2)}", "_pos": m.start()}
+        )
+
+    # page.getByPlaceholder().fill()
+    for m in _RE_GET_BY_PLACEHOLDER_FILL.finditer(body):
+        steps.append(
+            {"action": "fill", "selector": f"placeholder={m.group(2)}", "value": m.group(4), "_pos": m.start()}
+        )
+
+    # page.getByTestId().click()
+    for m in _RE_GET_BY_TESTID_CLICK.finditer(body):
+        steps.append(
+            {"action": "click", "selector": f"[data-testid='{m.group(2)}']", "_pos": m.start()}
+        )
+
+    # page.getByTestId().fill()
+    for m in _RE_GET_BY_TESTID_FILL.finditer(body):
+        steps.append(
+            {"action": "fill", "selector": f"[data-testid='{m.group(2)}']", "value": m.group(4), "_pos": m.start()}
+        )
+
+    # expect(page).toHaveURL()
+    for m in _RE_EXPECT_URL.finditer(body):
+        steps.append(
+            {"action": "assert", "assertion": "toHaveURL", "value": m.group(2), "_pos": m.start()}
+        )
+
+    # expect(locator).toBeVisible / toBeEnabled / toHaveText etc.
+    for m in _RE_EXPECT_VISIBLE.finditer(body):
+        steps.append(
+            {"action": "assert", "assertion": m.group(1), "value": m.group(2).strip().strip("\"'`"), "_pos": m.start()}
+        )
+
+    # Sort by position so steps are in source order
+    steps.sort(key=lambda s: s.pop("_pos", 0))
+    return steps
+
+
+# ---------------------------------------------------------------------------
+# Priority / tag inference
+# ---------------------------------------------------------------------------
+
+
+def _infer_priority(name: str) -> str:
+    name_lower = name.lower()
+    if any(kw in name_lower for kw in _HIGH_PRIORITY_KEYWORDS):
+        return "high"
+    if any(kw in name_lower for kw in _NEGATIVE_KEYWORDS):
+        return "medium"
+    return "medium"
+
+
+def _infer_tags(name: str) -> list[str]:
+    tags = ["playwright"]
+    name_lower = name.lower()
+    if any(kw in name_lower for kw in _NEGATIVE_KEYWORDS):
+        tags.append("negative")
+    if any(kw in name_lower for kw in _HIGH_PRIORITY_KEYWORDS):
+        tags.append("smoke")
+    return tags
+
+
+# ---------------------------------------------------------------------------
+# PlaywrightIngestor
+# ---------------------------------------------------------------------------
+
+
+class PlaywrightIngestor(IngestorPlugin):
+    """Ingestor for Playwright ``.spec.ts`` / ``.spec.js`` test files.
+
+    Parses Playwright test files using regex-based extraction and converts
+    ``page.goto()``, ``page.fill()``, ``page.click()``, ``page.locator()``,
+    ``page.getByRole()``, ``page.getByText()``, and similar calls into
+    :class:`~mannf.product.ingestors.models.IngestedTestCase` objects.
+    """
+
+    name = "playwright"
+    display_name = "Playwright Test"
+    description = "Parse Playwright .spec.ts/.spec.js test files into test cases."
+    supported_extensions = [".spec.ts", ".spec.js", ".test.ts", ".test.js"]
+    supported_formats = ["playwright"]
+
+    # ------------------------------------------------------------------
+    # IngestorPlugin interface
+    # ------------------------------------------------------------------
+
+    async def ingest(
+        self, source: IngestorSource, config: dict
+    ) -> IngestResult:
+        """Parse the Playwright source and return an :class:`IngestResult`."""
+        try:
+            content = self._read_source(source)
+        except (FileNotFoundError, ValueError) as exc:
+            return self._make_error_result(source, str(exc))
+
+        if not content.strip():
+            return IngestResult(
+                success=True,
+                source=source,
+                warnings=["Playwright source is empty"],
+                stats={"test_case_count": 0},
+            )
+
+        source_name = Path(source.path).name if source.path else "playwright.spec.ts"
+        test_cases = self._parse(content, source_name)
+
+        return IngestResult(
+            success=True,
+            source=source,
+            test_cases=test_cases,
+            stats={"test_case_count": len(test_cases)},
+        )
+
+    def validate_config(self, config: dict) -> list[str]:
+        """No required configuration keys."""
+        return []
+
+    def can_handle(self, source: IngestorSource) -> bool:
+        """Return True for playwright format or matching file extension."""
+        if source.format == "playwright":
+            return True
+        if source.path is not None:
+            path = Path(source.path)
+            return (
+                path.suffix.lower() in (".ts", ".js")
+                and any(ext in path.name.lower() for ext in (".spec.", ".test."))
+            )
+        if source.raw_content is not None:
+            return (
+                "page.goto(" in source.raw_content
+                or "page.fill(" in source.raw_content
+                or "page.click(" in source.raw_content
+                or "test(" in source.raw_content
+            )
+        return False
+
+    # ------------------------------------------------------------------
+    # Internal parsing
+    # ------------------------------------------------------------------
+
+    def _parse(self, content: str, source_name: str) -> list[IngestedTestCase]:
+        """Extract all test cases from *content*."""
+        test_cases: list[IngestedTestCase] = []
+        seen_names: set[str] = set()
+
+        for name, body in _extract_test_blocks(content):
+            # Deduplicate test names (Playwright allows duplicate names in
+            # different describe blocks, but we disambiguate with a counter)
+            unique_name = name
+            if unique_name in seen_names:
+                counter = 2
+                while f"{name} ({counter})" in seen_names:
+                    counter += 1
+                unique_name = f"{name} ({counter})"
+            seen_names.add(unique_name)
+
+            steps = _extract_steps(body)
+            priority = _infer_priority(unique_name)
+            tags = _infer_tags(unique_name)
+
+            tc = IngestedTestCase(
+                name=unique_name,
+                description=f"Playwright test: {unique_name}",
+                steps=steps,
+                priority=priority,
+                tags=tags,
+                source_ref=f"{source_name}::{unique_name}",
+                metadata={"source_format": "playwright"},
+            )
+            test_cases.append(tc)
+
+        return test_cases