nvda-addon-testkit 0.1.3__tar.gz → 1.0.0__tar.gz

{nvda_addon_testkit-0.1.3 → nvda_addon_testkit-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: nvda-addon-testkit
-Version: 0.1.3
+Version: 1.0.0
 Summary: End-to-end testing for NVDA add-ons against a real NVDA
 Project-URL: Homepage, https://github.com/ZirekHQ/nvda-addon-testkit
 Project-URL: Issues, https://github.com/ZirekHQ/nvda-addon-testkit/issues
@@ -94,6 +94,18 @@ still on Extended Security Updates).
 | `nvda.log` | structured log records, and `assert_no_errors()` |
 | `nvda.addons` | two-phase install, remove, and state |
 
+`nvda.eval()` runs a single expression inside NVDA; `nvda.exec()` runs a
+full multi-statement scenario and returns whatever it binds to
+`__result__`. Both need `--nvda-allow-eval`. A bad scenario raises
+`ScenarioSyntaxError`, so catching bare `except Exception: pass` around
+either call still swallows it — catch the types you expect instead.
+
+`nvda.restart_harness()` kills and relaunches the NVDA process — use it to
+finish a two-phase add-on install or reset to a clean process. It does not
+exercise NVDA's own restart logic. For that, use `nvda.restart_nvda()`,
+which triggers NVDA's real `core.restart()` and waits for the replacement
+process — needs `--nvda-allow-eval`, since it is built on `nvda.eval()`.
+
 ## Requirements
 
 Windows to run the tests. NVDA is downloaded automatically — you do not need

{nvda_addon_testkit-0.1.3 → nvda_addon_testkit-1.0.0}/README.md

@@ -67,6 +67,18 @@ still on Extended Security Updates).
 | `nvda.log` | structured log records, and `assert_no_errors()` |
 | `nvda.addons` | two-phase install, remove, and state |
 
+`nvda.eval()` runs a single expression inside NVDA; `nvda.exec()` runs a
+full multi-statement scenario and returns whatever it binds to
+`__result__`. Both need `--nvda-allow-eval`. A bad scenario raises
+`ScenarioSyntaxError`, so catching bare `except Exception: pass` around
+either call still swallows it — catch the types you expect instead.
+
+`nvda.restart_harness()` kills and relaunches the NVDA process — use it to
+finish a two-phase add-on install or reset to a clean process. It does not
+exercise NVDA's own restart logic. For that, use `nvda.restart_nvda()`,
+which triggers NVDA's real `core.restart()` and waits for the replacement
+process — needs `--nvda-allow-eval`, since it is built on `nvda.eval()`.
+
 ## Requirements
 
 Windows to run the tests. NVDA is downloaded automatically — you do not need

{nvda_addon_testkit-0.1.3 → nvda_addon_testkit-1.0.0}/docs/modules/ROOT/examples/tests_e2e/conftest.py

@@ -65,3 +65,9 @@ def check_no_unexpected_errors(client, *, since: int = 0) -> None:
 @pytest.fixture
 def assert_no_unexpected_errors():
     return check_no_unexpected_errors
+
+
+@pytest.fixture
+def require_eval(pytestconfig):
+    if not pytestconfig.option.nvda_allow_eval:
+        pytest.skip("needs --nvda-allow-eval")

{nvda_addon_testkit-0.1.3 → nvda_addon_testkit-1.0.0}/docs/modules/ROOT/examples/tests_e2e/test_demo_addon.py

@@ -27,19 +27,19 @@ def test_install_is_two_phase_and_completes_on_restart(
     assert info.name == "testkit-demo"
     assert nvda.addons.state("testkit-demo") is AddonState.PENDING_INSTALL
 
-    nvda.restart()
+    nvda.restart_harness()
     assert nvda.addons.state("testkit-demo") is AddonState.ENABLED
     assert_no_unexpected_errors(nvda)
 
     nvda.addons.remove("testkit-demo")
-    nvda.restart()
+    nvda.restart_harness()
     assert nvda.addons.state("testkit-demo") is AddonState.NOT_INSTALLED
     # end::addons[]
 
 
 def test_the_installed_addon_logs_at_startup(nvda, addon_under_test):
     # tag::log[]
-    nvda.restart()
+    nvda.restart_harness()
     nvda.log.wait_for(re.escape(STARTUP_MESSAGE), since=0, timeout=20)
     # end::log[]
 
@@ -53,7 +53,7 @@ def test_its_gesture_produces_the_expected_speech(nvda, addon_under_test):
 
 def test_it_survives_a_restart(nvda, addon_under_test):
     # tag::fixtures[]
-    nvda.restart()
+    nvda.restart_harness()
     assert nvda.addons.state("testkit-demo") is AddonState.ENABLED
     before = nvda.speech.index()
     nvda.keys.press("NVDA+shift+control+d")
@@ -66,5 +66,5 @@ def test_removal_is_also_two_phase(nvda, addon_under_test):
     and that session-scoped fixture will not reinstall it."""
     nvda.addons.remove("testkit-demo")
     assert nvda.addons.state("testkit-demo") is AddonState.PENDING_REMOVE
-    nvda.restart()
+    nvda.restart_harness()
     assert nvda.addons.state("testkit-demo") is AddonState.NOT_INSTALLED

nvda_addon_testkit-1.0.0/docs/modules/ROOT/examples/tests_e2e/test_modal_dialog_investigation.py

@@ -0,0 +1,67 @@
+"""Investigation for issue #34, gaps 2 & 5: does a queued main-thread job
+start while a real ShowModal() dialog is up?
+
+This is not a regression test. It is a one-shot probe: run it once on
+Windows CI, read the result, and act on it per the plan (either open a new
+issue describing a real fix, or proceed with the simulate_modal() fallback
+in the next task). Delete or keep this file once the investigation is
+resolved -- it is not meant to run on every CI build.
+
+Everything happens inside a single exec_in_nvda call, entirely on NVDA's
+main thread: the spy's XML-RPC server (server.py) is a plain, unthreaded
+SimpleXMLRPCServer, so two separate RPC connections can never be genuinely
+concurrent at the transport level -- the second call simply can't be
+dispatched until the first's handler returns. Queuing the second job from
+*inside* the running scenario, via queueHandler.queueFunction directly,
+avoids needing RPC-level concurrency at all: it tests whether NVDA's own
+queue-draining mechanism still runs while the main thread is nested inside
+ShowModal()'s event loop, using a timestamp comparison instead of a second
+network round trip.
+
+A third, lower-probability outcome is possible: if the dialog's own
+wx.CallLater dismiss timer never fires for some unrelated reason, this
+scenario never returns from ShowModal(), so nvda.exec() raises an RpcError
+(wrapping exec_in_nvda's server-side "started on NVDA's main thread but did
+not return within 30.0s" timeout) instead of returning a __result__ to
+assert on. If you see that on a real run, it's worth investigating
+separately -- it doesn't confirm or refute the queue-blocking hypothesis
+either way.
+"""
+
+
+def test_a_second_job_while_a_real_modal_is_up(require_eval, nvda):
+    scenario = (
+        "import queueHandler\n"
+        "import time\n"
+        "import wx\n"
+        "job_b_ran_at = []\n"
+        # exec_in_nvda runs this with separate globals/locals dicts (like a
+        # class body), so a nested def can't see job_b_ran_at/time as
+        # globals -- bind both as defaults, evaluated now, in this scope.
+        "def job_b(sink=job_b_ran_at, now=time.monotonic):\n"
+        "    sink.append(now())\n"
+        "queueHandler.queueFunction(queueHandler.eventQueue, job_b)\n"
+        "dlg = wx.MessageDialog(None, 'probe', 'probe', wx.YES_NO)\n"
+        "wx.CallLater(1000, dlg.EndModal, wx.ID_YES)\n"
+        "before = time.monotonic()\n"
+        "dlg.ShowModal()\n"
+        "after = time.monotonic()\n"
+        "dlg.Destroy()\n"
+        "__result__ = {\n"
+        "    'ran_during_modal': bool(job_b_ran_at) and before <= job_b_ran_at[0] <= after,\n"
+        "    'ran_at_all': bool(job_b_ran_at),\n"
+        "}\n"
+    )
+
+    result = nvda.exec(scenario)
+
+    assert result["ran_during_modal"], (
+        "CONFIRMS THE DEADLOCK: a second main-thread job never ran while a "
+        f"real ShowModal() dialog was up (ran_at_all={result['ran_at_all']!r}). "
+        "Proceed with Task 7 (the simulate_modal() fallback)."
+    )
+    # If this assertion passes instead, the queue IS drained during
+    # ShowModal() in this NVDA version: STOP, do not proceed to Task 7, and
+    # open a new issue describing this finding plus what actually blocks
+    # input_api.py's keys_press() from dismissing the dialog (if anything
+    # still does).

{nvda_addon_testkit-0.1.3 → nvda_addon_testkit-1.0.0}/docs/modules/ROOT/examples/tests_e2e/test_smoke.py

@@ -37,5 +37,12 @@ def test_config_round_trips_through_a_real_nvda(nvda):
 
 
 def test_startup_produced_no_errors(nvda, assert_no_unexpected_errors):
-    nvda.restart()
+    nvda.restart_harness()
+    assert_no_unexpected_errors(nvda)
+
+
+def test_restart_nvda_exercises_core_restart(require_eval, nvda, assert_no_unexpected_errors):
+    old_pid = nvda.process.handshake.pid
+    nvda.restart_nvda(timeout=60)
+    assert nvda.process.handshake.pid != old_pid
     assert_no_unexpected_errors(nvda)

{nvda_addon_testkit-0.1.3 → nvda_addon_testkit-1.0.0}/docs/modules/ROOT/pages/troubleshooting.adoc

@@ -63,7 +63,7 @@ the current one; clean it out or narrow the pattern.
 fails.
 
 Install is two-phase by design — `install()` only reaches
-`PENDING_INSTALL`; a call to `nvda.restart()` is what completes it. See
+`PENDING_INSTALL`; a call to `nvda.restart_harness()` is what completes it. See
 xref:guide/addons.adoc[].
 
 == Speech assertion mismatches

nvda_addon_testkit-1.0.0/spy/globalPlugins/nvda_testkit_spy/eval_api.py

@@ -0,0 +1,52 @@
+# coding: utf-8
+"""Run code inside NVDA's own process: one expression, or a scenario.
+
+The host refuses to call either unless the session opted in, so the spy does
+not second-guess it: the point is to reach NVDA's live state, which means
+full builtins and real imports. Both run on the main thread for the same
+reason every other mutation does.
+
+eval_in_nvda evaluates a single expression and returns its value.
+exec_in_nvda runs one or more statements and returns whatever the code bound
+to a name called __result__, or None if it bound nothing -- multi-statement
+scenarios (e.g. "import core; core.restart()") do not compile under eval()
+and previously needed an unreadable immediately-invoked-lambda workaround.
+"""
+
+import builtins
+
+from .mainthread import run_on_main_thread
+from .registry import rpc_method
+
+_SCALARS = (str, int, float, bool, type(None))
+
+
+def _marshallable(value):
+    """xmlrpc carries scalars and containers of scalars; everything else is a repr."""
+    if isinstance(value, _SCALARS):
+        return value
+    if isinstance(value, dict):
+        return {str(key): _marshallable(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple, set, frozenset)):
+        return [_marshallable(item) for item in value]
+    return repr(value)
+
+
+def _evaluate(source):
+    return eval(source, {"__builtins__": builtins})
+
+
+@rpc_method
+def eval_in_nvda(source, timeout=30.0):
+    return _marshallable(run_on_main_thread(lambda: _evaluate(source), timeout=timeout))
+
+
+def _execute(source):
+    scope = {"__builtins__": builtins}
+    exec(compile(source, "<nvda-testkit>", "exec"), scope)
+    return scope.get("__result__")
+
+
+@rpc_method
+def exec_in_nvda(source, timeout=30.0):
+    return _marshallable(run_on_main_thread(lambda: _execute(source), timeout=timeout))

{nvda_addon_testkit-0.1.3 → nvda_addon_testkit-1.0.0}/spy/globalPlugins/nvda_testkit_spy/mainthread.py

@@ -24,8 +24,10 @@ def run_on_main_thread(fn, timeout=DEFAULT_TIMEOUT):
     outcome = {"value": _MISSING, "error": None}
     finished = threading.Event()
     timed_out = threading.Event()
+    started = threading.Event()
 
     def runner():
+        started.set()
         try:
             outcome["value"] = fn()
         except BaseException as error:  # NOSONAR -- forwarded verbatim, see raise below
@@ -38,9 +40,16 @@ def run_on_main_thread(fn, timeout=DEFAULT_TIMEOUT):
     queueHandler.queueFunction(queueHandler.eventQueue, runner)
     if not finished.wait(timeout):
         timed_out.set()
+        if started.is_set():
+            raise TimeoutError(
+                "%r started on NVDA's main thread but did not return "
+                "within %.1fs. It's hung, not queued behind something else."
+                % (getattr(fn, "__name__", fn), timeout)
+            )
         raise TimeoutError(
-            "Timed out after %.1fs waiting for NVDA's main thread to run %r. "
-            "NVDA is wedged or busy." % (timeout, getattr(fn, "__name__", fn))
+            "%r never started on NVDA's main thread within %.1fs. "
+            "The queue is backed up or NVDA is unresponsive to "
+            "queueFunction()." % (getattr(fn, "__name__", fn), timeout)
         )
     if outcome["error"] is not None:
         raise outcome["error"]

{nvda_addon_testkit-0.1.3 → nvda_addon_testkit-1.0.0}/spy/globalPlugins/nvda_testkit_spy/registry.py

@@ -22,7 +22,9 @@ class Dispatcher:
     Faults are raised as plain exceptions; SimpleXMLRPCServer turns them into
     Faults whose faultString is "<Type>: <message>". The host matches on the
     "AUTH:" prefix, so those two strings are a wire contract -- do not reword
-    them without changing rpcclient.py.
+    them without changing rpcclient.py. The "<TypeName>: <message>" shape of
+    that faultString is part of the same contract: rpcclient.py reads the type
+    name back out of it to recognise a SyntaxError as ScenarioSyntaxError.
     """
 
     def __init__(self, token):

{nvda_addon_testkit-0.1.3 → nvda_addon_testkit-1.0.0}/src/nvda_testkit/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.3'
-__version_tuple__ = version_tuple = (0, 1, 3)
+__version__ = version = '1.0.0'
+__version_tuple__ = version_tuple = (1, 0, 0)
 
 __commit_id__ = commit_id = None

{nvda_addon_testkit-0.1.3 → nvda_addon_testkit-1.0.0}/src/nvda_testkit/client.py

@@ -2,10 +2,11 @@
 
 from __future__ import annotations
 
+import contextlib
 from dataclasses import dataclass
 from typing import Any
 
-from .errors import TestkitError
+from .errors import ConnectionLost, TestkitError
 from .namespaces.addons import AddonsNamespace
 from .namespaces.braille import BrailleNamespace
 from .namespaces.config import ConfigNamespace
@@ -86,7 +87,9 @@ class NvdaClient:
         if failures:
             raise TestkitError("reset() failed for " + "; ".join(failures))
 
-    def restart(self, *, timeout: float = 60.0) -> None:
+    def restart_harness(self, *, timeout: float = 60.0) -> None:
+        """Kill and relaunch the NVDA process. Does not exercise NVDA's own
+        core.restart() -- see restart_nvda() for that."""
         handshake = self._process.restart(timeout=timeout)
         self._rpc.close()
         self._attach(
@@ -97,6 +100,36 @@ class NvdaClient:
             )
         )
 
+    def restart_nvda(self, *, timeout: float = 60.0) -> None:
+        """Trigger NVDA's own core.restart() and wait for its replacement
+        process to announce itself. Requires allow_eval, since it is built
+        on eval() internally. Use this, not restart_harness(), to verify
+        behavior that lives in NVDA's real self-relaunch path."""
+        if not self._settings.allow_eval:
+            raise TestkitError(
+                "nvda.restart_nvda() is disabled. It runs arbitrary code inside NVDA, so it is "
+                "opt-in: pass --nvda-allow-eval, or set allow-eval = true under "
+                "[tool.nvda-testkit]."
+            )
+        handshake = self._process.handshake
+        if handshake is None:
+            raise TestkitError("NVDA is not running; nothing to restart.")
+        old_pid = handshake.pid
+        self._process.handshake_path.unlink(missing_ok=True)
+        with contextlib.suppress(ConnectionLost):
+            self.eval("__import__('core').restart()")
+        new_handshake = self._process.adopt_relaunched_handshake(
+            exclude_pid=old_pid, timeout=timeout
+        )
+        self._rpc.close()
+        self._attach(
+            RpcClient.from_handshake(
+                new_handshake,
+                token=self._process.token,
+                timeout_scale=self._settings.timeout_scale,
+            )
+        )
+
     def eval(self, source: str) -> Any:
         if not self._settings.allow_eval:
             raise TestkitError(
@@ -106,5 +139,14 @@ class NvdaClient:
             )
         return self._rpc.call("eval_in_nvda", source)
 
+    def exec(self, source: str) -> Any:
+        if not self._settings.allow_eval:
+            raise TestkitError(
+                "nvda.exec() is disabled. It runs arbitrary code inside NVDA, so it is "
+                "opt-in: pass --nvda-allow-eval, or set allow-eval = true under "
+                "[tool.nvda-testkit]."
+            )
+        return self._rpc.call("exec_in_nvda", source)
+
     def close(self) -> None:
         self._rpc.close()

{nvda_addon_testkit-0.1.3 → nvda_addon_testkit-1.0.0}/src/nvda_testkit/errors.py

@@ -46,6 +46,20 @@ class AuthError(RpcError):
     """The spy rejected our token. Almost always a stale NVDA from a previous run."""
 
 
+class ConnectionLost(RpcError):
+    """The transport dropped before a response arrived -- expected when the
+    process answering the call is exiting (e.g. mid-restart)."""
+
+
+class ScenarioSyntaxError(RpcError):
+    """`nvda.eval()`/`nvda.exec()` was given source that doesn't compile.
+
+    Distinguished from a plain RpcError so a scenario's own `except
+    Exception:` doesn't have to be the only thing standing between a typo
+    and a silently-skipped assertion.
+    """
+
+
 class WaitTimeout(TestkitError):
     """A deadline-bounded poll expired before its predicate came true."""
 

{nvda_addon_testkit-0.1.3 → nvda_addon_testkit-1.0.0}/src/nvda_testkit/namespaces/addons.py

@@ -1,7 +1,7 @@
 """nvda.addons -- add-on install lifecycle.
 
 Installation is two-phase, and that is exposed rather than hidden: install()
-leaves the add-on PENDING_INSTALL, and only nvda.restart() makes it ENABLED.
+leaves the add-on PENDING_INSTALL, and only nvda.restart_harness() makes it ENABLED.
 A test of installTasks.onInstall depends on being able to see both halves.
 """
 

{nvda_addon_testkit-0.1.3 → nvda_addon_testkit-1.0.0}/src/nvda_testkit/plugin.py

@@ -78,7 +78,7 @@ def nvda_session(_nvda_provisioned, nvda_settings) -> NvdaClient:
 @pytest.fixture
 def nvda(request: pytest.FixtureRequest, nvda_session: NvdaClient) -> NvdaClient:
     if request.node.get_closest_marker("fresh_nvda"):
-        nvda_session.restart()
+        nvda_session.restart_harness()
     nvda_session.reset()
     return nvda_session
 
@@ -128,5 +128,5 @@ def addon_bundle(nvda_settings) -> Path:
 def addon_under_test(nvda_session: NvdaClient, addon_bundle: Path) -> Path:
     """The bundle, installed and enabled, with NVDA restarted to complete it."""
     nvda_session.addons.install(addon_bundle)
-    nvda_session.restart()
+    nvda_session.restart_harness()
     return addon_bundle

{nvda_addon_testkit-0.1.3 → nvda_addon_testkit-1.0.0}/src/nvda_testkit/process.py

@@ -97,6 +97,7 @@ class NvdaProcess:
         self._extra_env = dict(env or {})
         self._proc: subprocess.Popen | None = None
         self._handshake: Handshake | None = None
+        self._owns_current_process = True
 
     @property
     def handshake_path(self) -> Path:
@@ -108,7 +109,9 @@ class NvdaProcess:
 
     @property
     def is_running(self) -> bool:
-        return self._proc is not None and self._proc.poll() is None
+        if self._owns_current_process:
+            return self._proc is not None and self._proc.poll() is None
+        return self._handshake is not None
 
     def _environment(self) -> dict[str, str]:
         environment = dict(os.environ)
@@ -189,6 +192,7 @@ class NvdaProcess:
         self.out_dir.mkdir(parents=True, exist_ok=True)
         self.handshake_path.unlink(missing_ok=True)
         self._handshake = None
+        self._owns_current_process = True
         self._start_count += 1
         self._number_log_file()
 
@@ -221,6 +225,46 @@ class NvdaProcess:
             f"Log tail:\n{self.log_tail()}" + (f"\n\n{diagnostics}" if diagnostics else "")
         )
 
+    def adopt_relaunched_handshake(self, *, exclude_pid: int, timeout: float = 60) -> Handshake:
+        """Wait for NVDA's own replacement process to announce itself.
+
+        Unlike start(), this owns no subprocess handle to watch for an early
+        exit -- the process being waited for was not spawned by us, it was
+        spawned by the NVDA we are about to stop tracking via self._proc.
+        """
+        deadline_seconds = timeout * self.timeout_scale
+        deadline = time.monotonic() + deadline_seconds
+        while time.monotonic() < deadline:
+            if self.handshake_path.is_file():
+                try:
+                    payload = json.loads(self.handshake_path.read_text(encoding="utf-8"))
+                except json.JSONDecodeError:
+                    time.sleep(_POLL_INTERVAL)
+                    continue
+                candidate = Handshake.from_payload(payload)
+                if candidate.pid != exclude_pid:
+                    self._handshake = candidate
+                    self._owns_current_process = False
+                    return candidate
+            time.sleep(_POLL_INTERVAL)
+        raise HandshakeTimeout(
+            f"NVDA never announced a replacement process within {deadline_seconds:.1f}s of "
+            f"restarting (still waiting on a pid other than {exclude_pid}). "
+            f"Expected {self.handshake_path}."
+        )
+
+    def _kill_pid(self, pid: int) -> None:
+        """Best-effort: terminate a process we did not spawn ourselves."""
+        if sys.platform != "win32":
+            return
+        with contextlib.suppress(OSError, subprocess.TimeoutExpired):
+            subprocess.run(
+                ["taskkill", "/PID", str(pid), "/F"],
+                capture_output=True,
+                check=False,
+                timeout=30,
+            )
+
     def _request_quit(self) -> None:
         if self._quit_via == "rpc":
             if self._handshake is None:
@@ -242,6 +286,11 @@ class NvdaProcess:
             )
 
     def quit(self, timeout: float = 30) -> None:
+        if not self._owns_current_process:
+            if self._handshake is not None:
+                self._kill_pid(self._handshake.pid)
+            self._handshake = None
+            return
         if self._proc is None:
             return
         if self._proc.poll() is not None:
@@ -259,6 +308,11 @@ class NvdaProcess:
         self.kill()
 
     def kill(self) -> None:
+        if not self._owns_current_process:
+            if self._handshake is not None:
+                self._kill_pid(self._handshake.pid)
+            self._handshake = None
+            return
         if self._proc is None:
             return
         if self._proc.poll() is None:

{nvda_addon_testkit-0.1.3 → nvda_addon_testkit-1.0.0}/src/nvda_testkit/rpcclient.py

@@ -8,13 +8,14 @@ answering this run's questions.
 
 from __future__ import annotations
 
+import http.client
 import threading
 import time
 import xmlrpc.client
 from collections.abc import Callable
 from typing import Any
 
-from .errors import AuthError, RpcError, WaitTimeout
+from .errors import AuthError, ConnectionLost, RpcError, ScenarioSyntaxError, WaitTimeout
 from .process import Handshake
 
 _DEFAULT_INTERVAL = 0.05
@@ -71,14 +72,20 @@ class RpcClient:
                     "A stale NVDA from a previous run is the usual cause. "
                     f"Remote said: {message}"
                 ) from fault
+            if method in ("eval_in_nvda", "exec_in_nvda") and any(
+                name in message for name in ("SyntaxError", "IndentationError", "TabError")
+            ):
+                raise ScenarioSyntaxError(
+                    f"{method}() was given source that doesn't compile: {message}"
+                ) from fault
             raise RpcError(f"{method}() failed inside NVDA: {message}") from fault
         except xmlrpc.client.ProtocolError as error:
-            raise RpcError(
+            raise ConnectionLost(
                 f"The spy answered {method!r} with HTTP {error.errcode} "
                 f"{error.errmsg} at {error.url}."
             ) from error
-        except OSError as error:
-            raise RpcError(
+        except (OSError, http.client.HTTPException) as error:
+            raise ConnectionLost(
                 f"Could not reach the spy on 127.0.0.1:{self.port} calling {method!r}. "
                 "NVDA has probably died. "
                 f"Transport error: {error}"

{nvda_addon_testkit-0.1.3 → nvda_addon_testkit-1.0.0}/tests/fake_nvda.py

@@ -230,6 +230,11 @@ class FakeSpy:
     def rpc_eval_in_nvda(self, source, timeout=30.0):
         return _marshallable(eval(source, {"__builtins__": builtins}, {}))
 
+    def rpc_exec_in_nvda(self, source, timeout=30.0):
+        scope = {"__builtins__": builtins}
+        exec(compile(source, "<fake-nvda>", "exec"), scope)
+        return _marshallable(scope.get("__result__"))
+
     def rpc_addons_install(self, bundle_path, timeout=120.0):
         entry = {"name": "demo-addon", "version": "1.0.0", "state": "PENDING_INSTALL"}
         with self._lock: