testmu-playwright-python 0.1.2__tar.gz → 0.1.4__tar.gz

{testmu_playwright_python-0.1.2 → testmu_playwright_python-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testmu-playwright-python
-Version: 0.1.2
+Version: 0.1.4
 Summary: Testmu binding for Playwright Python — thin test runtime for LambdaTest exports
 Author-email: LambdaTest <engineering@lambdatest.com>
 License-Expression: LicenseRef-Proprietary

{testmu_playwright_python-0.1.2 → testmu_playwright_python-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "testmu-playwright-python"
-version = "0.1.2"
+version = "0.1.4"
 description = "Testmu binding for Playwright Python — thin test runtime for LambdaTest exports"
 requires-python = ">=3.11"
 license = "LicenseRef-Proprietary"

{testmu_playwright_python-0.1.2 → testmu_playwright_python-0.1.4}/testmu/_decorator.py

@@ -34,13 +34,16 @@ def test(fn):
                 await rep.pass_test()
                 return result
             except Exception as e:
-                page = _find_page(args, kwargs)
-                if page is not None:
-                    try:
-                        screenshot = await page.screenshot()
-                        await rep.attach_screenshot(screenshot)
-                    except Exception:
-                        pass
+                # Screenshot-on-failure disabled — attach_screenshot is a stub
+                # that doesn't upload bytes anywhere. Re-enable once LT CDP upload
+                # is wired up.
+                # page = _find_page(args, kwargs)
+                # if page is not None:
+                #     try:
+                #         screenshot = await page.screenshot()
+                #         await rep.attach_screenshot(screenshot)
+                #     except Exception:
+                #         pass
                 await rep.fail_test(e)
                 raise
         return async_wrapper

{testmu_playwright_python-0.1.2 → testmu_playwright_python-0.1.4}/testmu/_helpers/_http.py

@@ -2,6 +2,11 @@
 
 All smart helpers (vision, assertion, wait, network) call LT-hosted
 endpoints that require Basic auth via LT_USERNAME + LT_ACCESS_KEY.
+
+Also threads session tracking headers (x-session-id, x-source) so the
+LT backend can distinguish local runs from HyperExecute runs. Forge
+sets TESTMUAI_SOURCE=hyperexecute in all cloud YAML paths; locally we
+default to "local".
 """
 import base64
 import os
@@ -10,11 +15,19 @@ import aiohttp
 
 
 def create_session(**kwargs) -> aiohttp.ClientSession:
-    """Create an aiohttp session with LT Basic auth headers."""
+    """Create an aiohttp session with LT Basic auth + tracking headers."""
     headers = kwargs.pop("headers", {})
+
     username = os.getenv("LT_USERNAME", "")
     access_key = os.getenv("LT_ACCESS_KEY", "")
     if username and access_key:
         auth = base64.b64encode(f"{username}:{access_key}".encode()).decode()
         headers["Authorization"] = f"Basic {auth}"
+
+    session_id = os.getenv("TESTMUAI_SESSION_ID", "")
+    if session_id:
+        headers["x-session-id"] = session_id
+
+    headers["x-source"] = os.getenv("TESTMUAI_SOURCE", "local")
+
     return aiohttp.ClientSession(headers=headers, **kwargs)

{testmu_playwright_python-0.1.2 → testmu_playwright_python-0.1.4}/testmu/_helpers/assertion.py

@@ -87,17 +87,16 @@ async def _call_evaluate_api(claim, composite_op, eval_sub_checks):
 
 async def _evaluate_deterministic(claim, composite_op, sub_checks):
     """Deterministic path: resolve variables then call /api/v1/evaluate."""
-    _log.debug(f"[AssertionAPI] Deterministic evaluation: '{claim}'")
+    _log.info("    [assertion] deterministic claim=%s", claim[:80])
     eval_sub_checks = await _resolve_sub_checks(sub_checks)
-    _log.debug(f"[AssertionAPI] resolved sub_checks={eval_sub_checks!r}")
     result = await _call_evaluate_api(claim, composite_op, eval_sub_checks)
-    _log.debug(f"[AssertionAPI] result={result!r}")
+    _log.info("    [assertion] result status=%s", result.get("status", "unknown"))
     return result
 
 
 async def _verify_visual(page, claim, composite_op, sub_checks, assertion_tree):
     """Visual path: screenshot + LLM-based assertion via /api/v1/assertions/verify."""
-    _log.debug(f"[AssertionAPI] Visual verification: '{claim}'")
+    _log.info("    [assertion] visual claim=%s", claim[:80])
 
     screenshot_bytes = await page.screenshot()
     screenshot_b64 = base64.b64encode(screenshot_bytes).decode("utf-8")
@@ -115,7 +114,6 @@ async def _verify_visual(page, claim, composite_op, sub_checks, assertion_tree):
     if verification:
         request_body["verification"] = verification
 
-    _log.debug("[AssertionAPI] Sending to assertions/verify API...")
     async with create_session() as session:
         async with session.post(
             f"{_AI_API_HOST}/api/v1/assertions/verify",
@@ -127,7 +125,7 @@ async def _verify_visual(page, claim, composite_op, sub_checks, assertion_tree):
                 raise Exception(f"Assertion API error {response.status}: {text}")
             result = await response.json()
 
-    _log.debug(f"[AssertionAPI] Result: {result.get('status', 'unknown')}")
+    _log.info("    [assertion] result status=%s", result.get("status", "unknown"))
     return result
 
 

{testmu_playwright_python-0.1.2 → testmu_playwright_python-0.1.4}/testmu/_helpers/execute_api.py

@@ -223,7 +223,7 @@ def _do_request(method, url, headers, body, params, authorization, timeout, veri
         raise RuntimeError(f"Unsupported HTTP method: {_method!r}")
 
     elapsed_ms = (time.time() - start) * 1000
-    _log.debug(f"execute_api response: status={response.status_code}, time={elapsed_ms:.0f}ms")
+    _log.info("    [execute_api] status=%d time=%.0fms", response.status_code, elapsed_ms)
 
     # -- Build response dict -------------------------------------------------
     resp = {
@@ -304,7 +304,7 @@ async def execute_api(
     Raises:
         RuntimeError: On invalid URL, unsupported method, or request failure.
     """
-    _log.debug(f"execute_api: {method} {url}")
+    _log.info("    [execute_api] %s %s", method, url[:80])
     try:
         return await asyncio.to_thread(
             _do_request, method, url, headers, body, params,

{testmu_playwright_python-0.1.2 → testmu_playwright_python-0.1.4}/testmu/_helpers/execute_db.py

@@ -106,7 +106,7 @@ async def execute_db(
     if not tunnel_id:
         tunnel_id = os.environ.get("LT_PROXY_TUNNEL_ID", "")
 
-    _log.debug(f"execute_db: db_id={db_id!r} db_name={db_name!r}")
+    _log.info("    [execute_db] db_id=%r db_name=%r", db_id, db_name)
     try:
         return await asyncio.to_thread(
             _do_query, query, db_id, db_name, timeout, tunnel_id, auth_header, automind_url

{testmu_playwright_python-0.1.2 → testmu_playwright_python-0.1.4}/testmu/_helpers/execute_js.py

@@ -35,7 +35,7 @@ async def execute_js(page, script: str):
     from testmu._vars import _variable_store
 
     preview = script[:100] + ("..." if len(script) > 100 else "")
-    _log.debug(f"execute_js: {preview}")
+    _log.info("    [execute_js] %s", preview)
 
     try:
         user_js_code = script + "\n"
@@ -88,7 +88,7 @@ async def execute_js(page, script: str):
         if result is None or result == "":
             result = "null"
 
-        _log.debug(f"execute_js result: {str(result)[:100]}")
+        _log.info("    [execute_js] result=%s", str(result)[:100])
         return result
 
     except RuntimeError:

{testmu_playwright_python-0.1.2 → testmu_playwright_python-0.1.4}/testmu/_helpers/vision.py

@@ -211,13 +211,8 @@ async def _wait_for_visibility(page, query: str) -> str:
             screenshot_bytes = await page.screenshot()
             screenshot_b64 = base64.b64encode(screenshot_bytes).decode("utf-8")
 
-            _log.debug(f"[vision] Visibility check attempt {attempt}/{_COORD_MAX_RETRIES}")
             result = await _check_visibility(session, screenshot_b64, query)
-            _log.debug(
-                f"[vision] visible={result.get('visible')}, "
-                f"confidence={result.get('confidence')}, "
-                f"reasoning={result.get('reasoning')}"
-            )
+            _log.info("    [visibility] attempt %d/%d visible=%s", attempt, _COORD_MAX_RETRIES, result.get("visible"))
 
             if result.get("visible", False):
                 return screenshot_b64
@@ -251,7 +246,7 @@ async def vision_query(page, description: str, return_type: str):
     if not _config.smart:
         return None
 
-    _log.debug(f"[vision_query] Extracting: '{description}'")
+    _log.info("    [vision_query] query=%s", description[:80])
 
     screenshot_bytes = await page.screenshot()
     screenshot_b64 = base64.b64encode(screenshot_bytes).decode("utf-8")
@@ -264,7 +259,7 @@ async def vision_query(page, description: str, return_type: str):
         }, timeout=_QUERY_TIMEOUT)
 
     extracted = result.get("extracted_value", "")
-    _log.debug(f"[vision_query] Extracted: {extracted!r}")
+    _log.info("    [vision_query] result=%s", repr(extracted)[:120])
     return extracted
 
 
@@ -287,7 +282,7 @@ async def textual_query(page, description: str, return_type: str):
     if not _config.smart:
         return None
 
-    _log.debug(f"[textual_query] Extracting: '{description}'")
+    _log.info("    [textual_query] query=%s", description[:80])
 
     cdp = await page.context.new_cdp_session(page)
     try:
@@ -326,7 +321,7 @@ async def textual_query(page, description: str, return_type: str):
             })
 
         extracted = extract_resp.get("extracted_value", "")
-        _log.debug(f"[textual_query] Extracted: {extracted!r}")
+        _log.info("    [textual_query] result=%s", repr(extracted)[:120])
         return extracted
 
     finally:
@@ -348,29 +343,24 @@ async def vision_wait(page, description: str, timeout_ms: int = 30000):
         await page.wait_for_timeout(timeout_ms)
         return
 
-    _log.debug(f"[vision_wait] Waiting for: '{description}' (timeout_ms={timeout_ms})")
+    _log.info("    [vision_wait] query=%s", description[:80])
 
     async with create_session() as session:
         for attempt in range(1, _WAIT_MAX_RETRIES + 1):
             screenshot_bytes = await page.screenshot()
             screenshot_b64 = base64.b64encode(screenshot_bytes).decode("utf-8")
 
-            _log.debug(f"[vision_wait] Check attempt {attempt}/{_WAIT_MAX_RETRIES}")
             result = await _check_wait_condition(session, screenshot_b64, description)
-            _log.debug(
-                f"[vision_wait] waiting={result.get('waiting')}, "
-                f"confidence={result.get('confidence')}, "
-                f"reasoning={result.get('reasoning')}"
-            )
-
-            if not result.get("waiting", True):
-                _log.debug(f"[vision_wait] Condition met: {result.get('description', 'done')}")
+            waiting = result.get("waiting", True)
+            _log.info("    [vision_wait] attempt %d/%d waiting=%s", attempt, _WAIT_MAX_RETRIES, waiting)
+
+            if not waiting:
                 return
 
             if attempt < _WAIT_MAX_RETRIES:
                 await asyncio.sleep(_WAIT_RETRY_INTERVAL)
 
-    _log.debug("[vision_wait] Max retries exhausted, continuing")
+    _log.info("    [vision_wait] max retries exhausted, continuing")
 
 
 async def vision_action(page, description: str, action_type: str, direction: str = "down", amount: int = 300) -> bool:
@@ -392,6 +382,8 @@ async def vision_action(page, description: str, action_type: str, direction: str
     if not _config.smart:
         return None
 
+    _log.info("    [vision_action] action=%s query=%s", action_type, description[:60])
+
     screenshot_bytes = await page.screenshot()
     screenshot_b64 = base64.b64encode(screenshot_bytes).decode("utf-8")
 
@@ -412,13 +404,17 @@ async def vision_action(page, description: str, action_type: str, direction: str
             timeout=aiohttp.ClientTimeout(total=30),
         ) as resp:
             if resp.status != 200:
+                _log.info("    [vision_action] API error status=%d", resp.status)
                 return False
             result = await resp.json()
             if not result.get("found", False):
+                _log.info("    [vision_action] element not found")
                 return False
             coord_x = result["x"]
             coord_y = result["y"]
 
+    _log.info("    [vision_action] executing %s at (%d, %d)", action_type, coord_x, coord_y)
+
     if action_type == "click":
         await page.mouse.click(coord_x, coord_y)
     elif action_type == "scroll":
@@ -439,16 +435,20 @@ async def vision_action(page, description: str, action_type: str, direction: str
 
 
 async def get_vision_coordinates(page, description: str, action_type: str = "click", x: int = None, y: int = None) -> dict:
-    """Get coordinates for an element via vision API with fallback to raw (x, y).
+    """Get coordinates for an element via vision API.
 
-    Smart-gated: returns {"x": x, "y": y} immediately when _config.smart is OFF.
+    When smart is ON: always uses vision API. No fallback to (x, y) — if the
+    API can't find the element or errors, raises instead of silently using
+    stale coordinates that may click the wrong thing.
+
+    When smart is OFF: returns {"x": x, "y": y} immediately.
 
     Args:
         page: Playwright page object.
         description: Description of the action/element to find.
         action_type: Type of action ("click", "type", etc.).
-        x: Fallback X coordinate if API fails or smart is OFF.
-        y: Fallback Y coordinate if API fails or smart is OFF.
+        x: X coordinate used only when smart is OFF.
+        y: Y coordinate used only when smart is OFF.
 
     Returns:
         dict with 'x' and 'y' keys.
@@ -456,46 +456,31 @@ async def get_vision_coordinates(page, description: str, action_type: str = "cli
     if not _config.smart:
         return {"x": x, "y": y}
 
-    _log.debug(f"[get_vision_coordinates] Looking up: '{description}' (action_type: {action_type})")
-    _log.debug(f"[get_vision_coordinates] Fallback: x={x}, y={y}")
+    _log.info("    [get_vision_coordinates] query=%s", description[:60])
 
-    try:
-        screenshot_b64 = await _wait_for_visibility(page, description)
+    screenshot_b64 = await _wait_for_visibility(page, description)
 
-        viewport = page.viewport_size
-        width = viewport["width"] if viewport else 1920
-        height = viewport["height"] if viewport else 1080
+    viewport = page.viewport_size
+    width = viewport["width"] if viewport else 1920
+    height = viewport["height"] if viewport else 1080
 
-        async with create_session() as session:
-            async with session.post(
-                f"{_VISION_API_HOST}/api/v1/vision/coordinates",
-                json={
-                    "screenshot_b64": screenshot_b64,
-                    "action_instruction": description,
-                    "action_type": action_type,
-                    "width": width,
-                    "height": height,
-                },
-                timeout=aiohttp.ClientTimeout(total=30),
-            ) as resp:
-                if resp.status == 200:
-                    result = await resp.json()
-                    if result.get("found", False):
-                        coords = {"x": result["x"], "y": result["y"]}
-                        _log.debug(f"[get_vision_coordinates] Found: {coords}")
-                        return coords
-                    if x is not None and y is not None:
-                        _log.debug("[get_vision_coordinates] Not found, using fallback")
-                        return {"x": x, "y": y}
-                    raise Exception("Vision API: element not found and no fallback provided")
-                if x is not None and y is not None:
-                    _log.debug(f"[get_vision_coordinates] API error {resp.status}, using fallback")
-                    return {"x": x, "y": y}
+    async with create_session() as session:
+        async with session.post(
+            f"{_VISION_API_HOST}/api/v1/vision/coordinates",
+            json={
+                "screenshot_b64": screenshot_b64,
+                "action_instruction": description,
+                "action_type": action_type,
+                "width": width,
+                "height": height,
+            },
+            timeout=aiohttp.ClientTimeout(total=30),
+        ) as resp:
+            if resp.status != 200:
                 raise Exception(f"Vision API error: {resp.status}")
-
-    except Exception as e:
-        _log.debug(f"[get_vision_coordinates] Exception: {type(e).__name__}: {e}")
-        if x is not None and y is not None:
-            _log.debug("[get_vision_coordinates] Using fallback due to error")
-            return {"x": x, "y": y}
-        raise
+            result = await resp.json()
+            if not result.get("found", False):
+                raise Exception(f"Vision API: element not found for query={description!r}")
+            coords = {"x": result["x"], "y": result["y"]}
+            _log.info("    [get_vision_coordinates] found (%d, %d)", coords["x"], coords["y"])
+            return coords

{testmu_playwright_python-0.1.2 → testmu_playwright_python-0.1.4}/testmu/_helpers/wait.py

@@ -41,7 +41,7 @@ async def check_until_condition(page, condition: str) -> bool:
 
     vision_api_host = os.getenv("TESTMU_AI_API_HOST", _AI_API_HOST_DEFAULT)
 
-    _log.info(f"[check_until_condition] checking condition: {condition!r}")
+    _log.info("    [check_until_condition] condition=%s", condition[:80])
 
     screenshot_bytes = await page.screenshot()
     screenshot_b64 = base64.b64encode(screenshot_bytes).decode("utf-8")

{testmu_playwright_python-0.1.2 → testmu_playwright_python-0.1.4}/testmu/_reporter/__init__.py

@@ -19,7 +19,7 @@ class Reporter(Protocol):
     async def fail_test(self, error: Exception) -> None: ...
     async def begin_step(self, description: str) -> None: ...
     async def end_step(self, description: str, ok: bool, error: Optional[Exception] = None) -> None: ...
-    async def attach_screenshot(self, data: bytes) -> None: ...
+    # async def attach_screenshot(self, data: bytes) -> None: ...
 
 
 def get_reporter() -> Reporter:

{testmu_playwright_python-0.1.2 → testmu_playwright_python-0.1.4}/testmu/_reporter/local.py

@@ -23,11 +23,9 @@ class LocalReporter:
         _log.info("  [STEP %d] %s", self._step_num, description)
 
     async def end_step(self, description, ok, error=None):
-        if ok:
-            _log.info("  [STEP %d OK] %s", self._step_num, description)
-        else:
-            status = f"FAIL: {error}"
-            _log.info("  [STEP %d %s] %s", self._step_num, status, description)
-
-    async def attach_screenshot(self, data):
-        _log.info("  [SCREENSHOT] %d bytes", len(data))
+        if not ok:
+            _log.error("  [STEP %d FAIL] %s", self._step_num, error)
+
+    # async def attach_screenshot(self, data):
+    #     # Stub — screenshot bytes aren't uploaded anywhere.
+    #     _log.info("  [SCREENSHOT] %d bytes", len(data))

{testmu_playwright_python-0.1.2 → testmu_playwright_python-0.1.4}/testmu/_reporter/lt.py

@@ -1,7 +1,8 @@
 """LambdaTest dashboard reporter.
 
-Uses page.evaluate('lambdatest_action: ...') for test status
-and page.evaluate('lambdatest_executor: ...') for step context.
+Uses page.evaluate('lambdatest_action: ...') for:
+  - setTestStatus (overall test verdict)
+  - testCaseStart / testCaseEnd (per-step annotations on LT timeline)
 
 All events are ALSO logged to stdout so HyperExecute console
 shows progress — the CDP calls alone are invisible in HE logs.
@@ -43,19 +44,16 @@ class LTReporter:
     async def begin_step(self, description):
         self._step_num += 1
         _log.info("  [STEP %d] %s", self._step_num, description)
-        await self._evaluate_executor("stepcontext", {
-            "data": description,
-            "type": "info",
-        })
+        await self._evaluate_action("testCaseStart", {"name": description})
 
     async def end_step(self, description, ok, error=None):
-        if ok:
-            _log.info("  [STEP %d OK] %s", self._step_num, description)
-        else:
-            _log.error("  [STEP %d FAIL] %s — %s", self._step_num, description, error)
+        if not ok:
+            _log.error("  [STEP %d FAIL] %s", self._step_num, error)
+        await self._evaluate_action("testCaseEnd", {"name": description})
 
-    async def attach_screenshot(self, data):
-        _log.info("  [SCREENSHOT] %d bytes", len(data))
+    # async def attach_screenshot(self, data):
+    #     # Stub — screenshot bytes aren't uploaded to LT dashboard yet.
+    #     _log.info("  [SCREENSHOT] %d bytes", len(data))
 
     async def _evaluate_action(self, action, arguments):
         if self._page is None:
@@ -66,11 +64,12 @@ class LTReporter:
         except Exception as e:
             _log.warning("lambdatest_action failed: %s", e)
 
-    async def _evaluate_executor(self, action, arguments):
-        if self._page is None:
-            return
-        try:
-            payload = json.dumps({"action": action, "arguments": arguments})
-            await self._page.evaluate("_ => {}", f"lambdatest_executor: {payload}")
-        except Exception as e:
-            _log.warning("lambdatest_executor failed: %s", e)
+    # async def _evaluate_executor(self, action, arguments):
+    #     # Unused — stepcontext was replaced by testCaseStart/End.
+    #     if self._page is None:
+    #         return
+    #     try:
+    #         payload = json.dumps({"action": action, "arguments": arguments})
+    #         await self._page.evaluate("_ => {}", f"lambdatest_executor: {payload}")
+    #     except Exception as e:
+    #         _log.warning("lambdatest_executor failed: %s", e)

{testmu_playwright_python-0.1.2 → testmu_playwright_python-0.1.4}/testmu/_reporter/null.py

@@ -7,4 +7,4 @@ class NullReporter:
     async def fail_test(self, error): pass
     async def begin_step(self, description): pass
     async def end_step(self, description, ok, error=None): pass
-    async def attach_screenshot(self, data): pass
+    # async def attach_screenshot(self, data): pass

{testmu_playwright_python-0.1.2 → testmu_playwright_python-0.1.4}/testmu_playwright_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testmu-playwright-python
-Version: 0.1.2
+Version: 0.1.4
 Summary: Testmu binding for Playwright Python — thin test runtime for LambdaTest exports
 Author-email: LambdaTest <engineering@lambdatest.com>
 License-Expression: LicenseRef-Proprietary

{testmu_playwright_python-0.1.2 → testmu_playwright_python-0.1.4}/tests/test_decorator.py

@@ -37,7 +37,9 @@ class TestDecorator:
             await failing_test(page=mock_page)
 
     @pytest.mark.asyncio
-    async def test_screenshot_captured_on_failure(self):
+    async def test_screenshot_not_captured_on_failure(self):
+        """Screenshot-on-failure is currently disabled (stub) — page.screenshot
+        should NOT be called by the decorator. Re-enable when LT upload is wired."""
         mock_page = AsyncMock()
         mock_page.screenshot = AsyncMock(return_value=b"png_data")
 
@@ -48,7 +50,7 @@ class TestDecorator:
         with pytest.raises(RuntimeError):
             await failing_test(page=mock_page)
 
-        mock_page.screenshot.assert_awaited_once()
+        mock_page.screenshot.assert_not_called()
 
     def test_sync_function_detected(self):
         @decorator_test

{testmu_playwright_python-0.1.2 → testmu_playwright_python-0.1.4}/tests/test_helper_vision.py

@@ -385,13 +385,14 @@ class TestGetVisionCoordinates:
         assert result == {"x": 500, "y": 300}
 
     @pytest.mark.asyncio
-    async def test_falls_back_to_xy_on_exception(self):
+    async def test_raises_on_exception_when_smart_on_even_with_xy(self):
+        """When smart is ON, no fallback to (x, y) — raise instead.
+        Silent fallback to stale coordinates can click the wrong element."""
         with patch.object(_config, "smart", True), \
              patch("testmu._helpers.vision._wait_for_visibility", AsyncMock(side_effect=Exception("network down"))):
             page = _make_page()
-            result = await get_vision_coordinates(page, "button", "click", x=42, y=99)
-
-        assert result == {"x": 42, "y": 99}
+            with pytest.raises(Exception, match="network down"):
+                await get_vision_coordinates(page, "button", "click", x=42, y=99)
 
     @pytest.mark.asyncio
     async def test_raises_when_no_fallback_and_exception(self):
@@ -402,7 +403,8 @@ class TestGetVisionCoordinates:
                 await get_vision_coordinates(page, "button", "click")
 
     @pytest.mark.asyncio
-    async def test_falls_back_when_not_found_and_has_fallback(self):
+    async def test_raises_when_not_found_even_with_fallback(self):
+        """When smart is ON, API returning 'not found' must raise — no fallback."""
         visibility_resp_cm = _mock_post_response(200, {"visible": True})
         coord_resp_cm = _mock_post_response(200, {"found": False})
 
@@ -420,9 +422,8 @@ class TestGetVisionCoordinates:
         with patch.object(_config, "smart", True), \
              patch("testmu._helpers.vision.aiohttp.ClientSession", return_value=session_cm):
             page = _make_page()
-            result = await get_vision_coordinates(page, "button", "click", x=77, y=88)
-
-        assert result == {"x": 77, "y": 88}
+            with pytest.raises(Exception, match="element not found"):
+                await get_vision_coordinates(page, "button", "click", x=77, y=88)
 
 
 # ---------------------------------------------------------------------------