revitdevtool-pytest 0.0.2__tar.gz

revitdevtool_pytest-0.0.2/.github/workflows/publish.yml

@@ -0,0 +1,30 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/RevitDevTool.PyTest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install build tools
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

revitdevtool_pytest-0.0.2/.gitignore

@@ -0,0 +1,16 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+*.so
+*.dll
+.env
+.venv/
+venv/

revitdevtool_pytest-0.0.2/.vscode/settings.json

@@ -0,0 +1,31 @@
+{
+    "python.autoComplete.extraPaths": [
+        "~/AppData/Roaming/RevitDevTool/2025/Stubs",
+        "~/AppData/Roaming/pyRevit-Master/pyrevitlib",
+        "~/AppData/Roaming/pyRevit-Master/site-packages"
+    ],
+    "python.analysis.extraPaths": [
+        "~/AppData/Roaming/RevitDevTool/2025/Stubs",
+        "~/AppData/Roaming/pyRevit-Master/pyrevitlib",
+        "~/AppData/Roaming/pyRevit-Master/site-packages"
+    ],
+    "cursorpyright.analysis.extraPaths": [
+        "~/AppData/Roaming/RevitDevTool/2025/Stubs",
+        "~/AppData/Roaming/pyRevit-Master/pyrevitlib",
+        "~/AppData/Roaming/pyRevit-Master/site-packages"
+    ],
+    "basedpyright.analysis.extraPaths": [
+        "~/AppData/Roaming/RevitDevTool/2025/Stubs",
+        "~/AppData/Roaming/pyRevit-Master/pyrevitlib",
+        "~/AppData/Roaming/pyRevit-Master/site-packages"
+    ],
+    "basedpyright.importStrategy": "useBundled",
+    "basedpyright.analysis.typeCheckingMode": "off",
+    "python.testing.pytestEnabled": true,
+    "python.testing.pytestArgs": [
+        "--revit-launch",
+        "--revit-version=2025",
+        "--revit-launch-timeout=180",
+        "tests"
+    ]
+}

revitdevtool_pytest-0.0.2/CHANGELOG.md

@@ -0,0 +1,38 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.0.2] - 2026-04-10
+
+### Fixed
+
+- Fixed pytest plugin auto-loading via the `pytest11` entry point.
+- Fixed the `pytest_unconfigure` hook signature in `revitdevtool_pytest.plugin` so Pluggy accepts the plugin during pytest startup.
+- Restored the expected standalone package behavior so `RevitDevTool.PyTest` can be discovered and activated by a normal Python/pytest environment before connecting to Revit.
+
+### Changed
+
+- Aligned the published package metadata name with the recommended normalized package name `revitdevtool_pytest`.
+
+### Notes
+
+- This release is intended as a bugfix release for the `0.0.1` package.
+- No user-facing CLI options are changed in this release.
+- This name alignment is intended to remain compatible with existing PyPI installs because Python package indexes and installers normalize `.`, `-`, and `_` in distribution names.
+
+## [0.0.1] - 2026-04-09
+
+### Added
+
+- Initial standalone `pytest` plugin package for running Revit API tests through the RevitDevTool Named Pipe bridge.
+- Automatic discovery of running Revit instances through named pipes.
+- Optional Revit auto-launch flow via `--revit-launch` and `--revit-version`.
+- Remote test execution by intercepting `pytest_pyfunc_call` and forwarding serialized test code to Revit.
+- Support for explicit pipe targeting with `--revit-pipe`.
+- Per-test timeout and launch timeout configuration.
+- Revit startup dialog resolver integration.
+- Example test suite and VS Code integration guidance in the project documentation.
+
+### Notes
+
+- `0.0.1` introduced the core test bridge workflow, but the published package contains a plugin loading issue fixed in `0.0.2`.

revitdevtool_pytest-0.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Truong Giang Vu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

revitdevtool_pytest-0.0.2/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: revitdevtool_pytest
+Version: 0.0.2
+Summary: pytest plugin for testing Revit API code via RevitDevTool Named Pipe bridge
+Project-URL: Homepage, https://github.com/trgiangv/RevitDevTool.PyTest
+Project-URL: Repository, https://github.com/trgiangv/RevitDevTool.PyTest
+Project-URL: Issues, https://github.com/trgiangv/RevitDevTool.PyTest/issues
+Author: Truong Giang Vu
+License-Expression: MIT
+License-File: LICENSE
+Keywords: bim,pytest,revit,revit-api,revitdevtool,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Requires-Dist: pytest>=9.0
+Requires-Dist: pywin32>=311
+Description-Content-Type: text/markdown
+
+# RevitDevTool.PyTest
+
+[![PyPI version](https://img.shields.io/pypi/v/RevitDevTool.PyTest)](https://pypi.org/project/RevitDevTool.PyTest/)
+[![Python](https://img.shields.io/pypi/pyversions/RevitDevTool.PyTest)](https://pypi.org/project/RevitDevTool.PyTest/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+pytest plugin for testing Revit API code via RevitDevTool Named Pipe bridge.
+Tests run inside a live Revit process — write standard pytest, execute remotely.
+
+## Installation
+
+```bash
+pip install revitdevtool_pytest
+```
+
+Recommended package name for manifests and package managers such as Pixi:
+
+```bash
+revitdevtool_pytest
+```
+
+`pip` normalizes package names, so the following forms are equivalent when installing from PyPI:
+
+```bash
+pip install revitdevtool_pytest
+pip install revitdevtool-pytest
+pip install RevitDevTool.PyTest
+```
+
+The Python import/module name used by the package is:
+
+```python
+import revitdevtool_pytest
+```
+
+## Dependencies
+
+| Package | Version |
+|---|---|
+| Python | >= 3.10 |
+| pytest | >= 9.0 |
+| pywin32 | >= 311 |
+
+## Requirements
+
+- Windows (Named Pipes)
+- Revit with [RevitDevTool](https://github.com/trgiangv/RevitDevTool) add-in installed
+
+## Usage
+
+```python
+def test_revit_version():
+    app = __revit__.Application
+    assert "2025" in app.VersionName
+```
+
+```bash
+# Auto-detect running Revit 2025
+pytest --revit-version=2025 -v
+
+# Auto-launch Revit 2025 if not running
+pytest --revit-launch --revit-version=2025 -v
+```
+
+## CLI Options
+
+| Option | Description |
+|---|---|
+| `--revit-version` | Revit version year (e.g. 2025). Required with `--revit-launch`. |
+| `--revit-launch` | Auto-launch Revit if no running instance found. |
+| `--revit-timeout` | Per-test timeout in seconds (default: 60). |
+| `--revit-launch-timeout` | Revit startup timeout in seconds (default: 120). |
+| `--revit-pipe` | Explicit pipe name (bypasses auto-discovery). |
+
+## How It Works
+
+1. pytest discovers tests locally as usual
+2. The plugin intercepts test execution via `pytest_pyfunc_call`
+3. Test source code is serialized and sent over Named Pipe to Revit
+4. RevitDevTool add-in executes the test inside Revit's Python (pythonnet) environment
+5. Results are mapped back to pytest pass/fail/skip
+
+## VSCode Integration
+
+Add to `.vscode/settings.json`:
+
+```json
+{
+    "python.testing.pytestEnabled": true,
+    "python.testing.pytestArgs": [
+        "--revit-launch",
+        "--revit-version=2025",
+        "tests"
+    ]
+}
+```
+
+## License
+
+[MIT](LICENSE)

revitdevtool_pytest-0.0.2/README.md

@@ -0,0 +1,100 @@
+# RevitDevTool.PyTest
+
+[![PyPI version](https://img.shields.io/pypi/v/RevitDevTool.PyTest)](https://pypi.org/project/RevitDevTool.PyTest/)
+[![Python](https://img.shields.io/pypi/pyversions/RevitDevTool.PyTest)](https://pypi.org/project/RevitDevTool.PyTest/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+pytest plugin for testing Revit API code via RevitDevTool Named Pipe bridge.
+Tests run inside a live Revit process — write standard pytest, execute remotely.
+
+## Installation
+
+```bash
+pip install revitdevtool_pytest
+```
+
+Recommended package name for manifests and package managers such as Pixi:
+
+```bash
+revitdevtool_pytest
+```
+
+`pip` normalizes package names, so the following forms are equivalent when installing from PyPI:
+
+```bash
+pip install revitdevtool_pytest
+pip install revitdevtool-pytest
+pip install RevitDevTool.PyTest
+```
+
+The Python import/module name used by the package is:
+
+```python
+import revitdevtool_pytest
+```
+
+## Dependencies
+
+| Package | Version |
+|---|---|
+| Python | >= 3.10 |
+| pytest | >= 9.0 |
+| pywin32 | >= 311 |
+
+## Requirements
+
+- Windows (Named Pipes)
+- Revit with [RevitDevTool](https://github.com/trgiangv/RevitDevTool) add-in installed
+
+## Usage
+
+```python
+def test_revit_version():
+    app = __revit__.Application
+    assert "2025" in app.VersionName
+```
+
+```bash
+# Auto-detect running Revit 2025
+pytest --revit-version=2025 -v
+
+# Auto-launch Revit 2025 if not running
+pytest --revit-launch --revit-version=2025 -v
+```
+
+## CLI Options
+
+| Option | Description |
+|---|---|
+| `--revit-version` | Revit version year (e.g. 2025). Required with `--revit-launch`. |
+| `--revit-launch` | Auto-launch Revit if no running instance found. |
+| `--revit-timeout` | Per-test timeout in seconds (default: 60). |
+| `--revit-launch-timeout` | Revit startup timeout in seconds (default: 120). |
+| `--revit-pipe` | Explicit pipe name (bypasses auto-discovery). |
+
+## How It Works
+
+1. pytest discovers tests locally as usual
+2. The plugin intercepts test execution via `pytest_pyfunc_call`
+3. Test source code is serialized and sent over Named Pipe to Revit
+4. RevitDevTool add-in executes the test inside Revit's Python (pythonnet) environment
+5. Results are mapped back to pytest pass/fail/skip
+
+## VSCode Integration
+
+Add to `.vscode/settings.json`:
+
+```json
+{
+    "python.testing.pytestEnabled": true,
+    "python.testing.pytestArgs": [
+        "--revit-launch",
+        "--revit-version=2025",
+        "tests"
+    ]
+}
+```
+
+## License
+
+[MIT](LICENSE)

revitdevtool_pytest-0.0.2/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "revitdevtool_pytest"
+version = "0.0.2"
+description = "pytest plugin for testing Revit API code via RevitDevTool Named Pipe bridge"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "Truong Giang Vu" }]
+keywords = ["pytest", "revit", "revit-api", "testing", "bim", "revitdevtool"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Framework :: Pytest",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Testing",
+]
+dependencies = ["pytest>=9.0", "pywin32>=311"]
+
+[project.entry-points."pytest11"]
+revitdevtool = "revitdevtool_pytest.plugin"
+
+[project.urls]
+Homepage = "https://github.com/trgiangv/RevitDevTool.PyTest"
+Repository = "https://github.com/trgiangv/RevitDevTool.PyTest"
+Issues = "https://github.com/trgiangv/RevitDevTool.PyTest/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/revitdevtool_pytest"]

revitdevtool_pytest-0.0.2/src/revitdevtool_pytest/__init__.py

@@ -0,0 +1,3 @@
+"""RevitDevTool.PyTest: Run pytest tests inside a live Revit process via Named Pipe bridge."""
+
+__version__ = "0.0.1"

revitdevtool_pytest-0.0.2/src/revitdevtool_pytest/bridge.py

@@ -0,0 +1,127 @@
+"""Named Pipe client for the RevitDevTool bridge.
+
+Protocol: ``[4-byte LE body length][UTF-8 JSON body]``
+Matches ``RevitDevTool.McpParser.Models.BridgePipeConnection``.
+"""
+
+from __future__ import annotations
+
+import json
+import struct
+import time
+from typing import Any
+
+from .constants import (
+    BRIDGE_METHOD_TESTS_EXECUTE,
+    BRIDGE_MSG_TYPE_NOTIFICATION,
+    DEFAULT_CONNECT_TIMEOUT_MS,
+    DEFAULT_TEST_TIMEOUT_S,
+)
+from .models import BridgeRequest, BridgeResponse, TestOutcome, TestRequest, TestResult
+
+_MAX_FRAME_SIZE = 16 * 1024 * 1024
+_HEADER_FMT = "<I"
+_HEADER_LEN = struct.calcsize(_HEADER_FMT)
+
+
+class RevitBridge:
+    """Synchronous Named Pipe client for the RevitDevTool bridge."""
+
+    def __init__(self, pipe_name: str, *, connect_timeout_ms: int = DEFAULT_CONNECT_TIMEOUT_MS) -> None:
+        self._pipe_name = pipe_name
+        self._connect_timeout_ms = connect_timeout_ms
+        self._handle: Any = None
+
+    def connect(self) -> None:
+        import win32file  # type: ignore[import-untyped]
+        import win32pipe  # type: ignore[import-untyped]
+
+        pipe_path = rf"\\.\pipe\{self._pipe_name}"
+        deadline = time.monotonic() + self._connect_timeout_ms / 1000.0
+
+        while True:
+            try:
+                self._handle = win32file.CreateFile(
+                    pipe_path,
+                    win32file.GENERIC_READ | win32file.GENERIC_WRITE,
+                    0, None,
+                    win32file.OPEN_EXISTING, 0, None,
+                )
+                win32pipe.SetNamedPipeHandleState(
+                    self._handle, win32pipe.PIPE_READMODE_BYTE, None, None,
+                )
+                return
+            except Exception:
+                if time.monotonic() >= deadline:
+                    raise ConnectionError(
+                        f"Cannot connect to pipe '{self._pipe_name}' "
+                        f"within {self._connect_timeout_ms}ms"
+                    )
+                time.sleep(0.2)
+
+    def disconnect(self) -> None:
+        handle, self._handle = self._handle, None
+        if handle is None:
+            return
+        import win32file  # type: ignore[import-untyped]
+
+        try:
+            win32file.CloseHandle(handle)
+        except Exception:  # noqa: BLE001
+            pass
+
+    @property
+    def connected(self) -> bool:
+        return self._handle is not None
+
+    def execute_test(self, request: TestRequest, *, timeout_s: float = DEFAULT_TEST_TIMEOUT_S) -> TestResult:
+        response = self._request(
+            BridgeRequest(method=BRIDGE_METHOD_TESTS_EXECUTE, params=request.to_bridge_params()),
+            timeout_s,
+        )
+        if response.is_error:
+            return TestResult(outcome=TestOutcome.ERROR, message=response.error_message)
+        if isinstance(response.result, dict):
+            return TestResult.from_dict(response.result)
+        return TestResult(outcome=TestOutcome.ERROR, message=f"Unexpected response: {response.result}")
+
+    def _request(self, req: BridgeRequest, timeout_s: float) -> BridgeResponse:
+        self._write_frame(req.to_json_bytes())
+        deadline = time.monotonic() + timeout_s
+        while True:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                raise TimeoutError(f"Timed out waiting for response to {req.id}")
+            data = self._read_frame(remaining)
+            parsed = json.loads(data)
+            if parsed.get("type") == BRIDGE_MSG_TYPE_NOTIFICATION:
+                continue
+            resp = BridgeResponse.from_json(parsed)
+            if resp.id == req.id:
+                return resp
+
+    def _write_frame(self, body: bytes) -> None:
+        import win32file  # type: ignore[import-untyped]
+
+        win32file.WriteFile(self._handle, struct.pack(_HEADER_FMT, len(body)) + body)
+
+    def _read_frame(self, timeout_s: float) -> bytes:
+        header = self._read_exact(_HEADER_LEN, timeout_s)
+        (body_len,) = struct.unpack(_HEADER_FMT, header)
+        if body_len <= 0 or body_len > _MAX_FRAME_SIZE:
+            raise RuntimeError(f"Invalid frame length: {body_len}")
+        return self._read_exact(body_len, timeout_s)
+
+    def _read_exact(self, count: int, timeout_s: float) -> bytes:
+        import win32file  # type: ignore[import-untyped]
+
+        buf = bytearray()
+        deadline = time.monotonic() + timeout_s
+        while len(buf) < count:
+            if time.monotonic() >= deadline:
+                raise TimeoutError(f"Timed out reading {count} bytes (got {len(buf)})")
+            _, data = win32file.ReadFile(self._handle, count - len(buf))
+            if not data:
+                raise ConnectionError("Pipe closed while reading")
+            buf.extend(data)
+        return bytes(buf)

revitdevtool_pytest-0.0.2/src/revitdevtool_pytest/constants.py

@@ -0,0 +1,28 @@
+"""Centralized constants for RevitDevTool.PyTest."""
+
+PLUGIN_NAME = "RevitDevTool.PyTest"
+
+BRIDGE_METHOD_TESTS_EXECUTE = "tests/execute"
+BRIDGE_MSG_TYPE_NOTIFICATION = "notification"
+
+OPT_VERSION = "revit_version"
+OPT_TIMEOUT = "revit_timeout"
+OPT_PIPE = "revit_pipe"
+OPT_LAUNCH = "revit_launch"
+OPT_LAUNCH_TIMEOUT = "revit_launch_timeout"
+
+DEFAULT_TEST_TIMEOUT_S = 60.0
+DEFAULT_LAUNCH_TIMEOUT_S = 120.0
+DEFAULT_CONNECT_TIMEOUT_MS = 30_000
+DEFAULT_POLL_INTERVAL_S = 2.0
+
+PIPE_DIR = r"//./pipe"
+PIPE_PATTERN = r"^Revit_(\d{4})_(\d+)$"
+
+REVIT_EXE = "Revit.exe"
+REVIT_NOSPLASH = "/nosplash"
+REVIT_DEFAULT_DIR = r"C:\Program Files\Autodesk"
+REVIT_REGISTRY_KEY = r"SOFTWARE\Autodesk\Revit\Autodesk Revit {version}"
+REVIT_REGISTRY_VALUE = "InstallationLocation"
+
+EXIT_CODE_CONFIG_ERROR = 4

revitdevtool_pytest-0.0.2/src/revitdevtool_pytest/dialog_resolver.py

@@ -0,0 +1,149 @@
+"""Auto-dismiss Revit startup dialogs via Win32 polling.
+
+Ported from ``RevitDevTool.Console.Services.Hosting.StartupDialogResolver``.
+Runs in a background thread and clicks whitelisted buttons on known dialog
+windows belonging to the Revit process.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import ctypes.wintypes
+import threading
+from dataclasses import dataclass, field
+
+_BM_CLICK = 0x00F5
+_DIALOG_CLASS = "#32770"
+_BUTTON_CLASS = "button"
+
+_user32 = ctypes.windll.user32  # type: ignore[attr-defined]
+
+_EnumWindowsProc = ctypes.WINFUNCTYPE(
+    ctypes.wintypes.BOOL, ctypes.wintypes.HWND, ctypes.wintypes.LPARAM,
+)
+
+
+def _is_window_visible(hwnd: int) -> bool:
+    return bool(_user32.IsWindowVisible(hwnd))
+
+
+def _get_window_text(hwnd: int) -> str:
+    length = _user32.GetWindowTextLengthW(hwnd)
+    if length <= 0:
+        return ""
+    buf = ctypes.create_unicode_buffer(length + 1)
+    _user32.GetWindowTextW(hwnd, buf, len(buf))
+    return buf.value
+
+
+def _get_class_name(hwnd: int) -> str:
+    buf = ctypes.create_unicode_buffer(256)
+    _user32.GetClassNameW(hwnd, buf, 256)
+    return buf.value
+
+
+def _get_window_pid(hwnd: int) -> int:
+    pid = ctypes.wintypes.DWORD()
+    _user32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid))
+    return pid.value
+
+
+def _send_click(hwnd: int) -> None:
+    _user32.SendMessageW(hwnd, _BM_CLICK, 0, 0)
+
+
+@dataclass
+class DialogResolverOptions:
+    poll_interval_s: float = 0.5
+    dialog_title_keywords: list[str] = field(default_factory=lambda: [
+        "Autodesk", "Revit", "Load", "Security", "Warning", "Add-in", "Addin",
+    ])
+    preferred_button_keywords: list[str] = field(default_factory=lambda: [
+        "Always Load", "Load", "OK", "Yes", "Accept", "Continue", "Close",
+    ])
+
+
+class StartupDialogResolver:
+    """Poll for Revit startup dialogs and auto-click whitelisted buttons."""
+
+    def __init__(self, process_id: int, options: DialogResolverOptions | None = None) -> None:
+        self._pid = process_id
+        self._opts = options or DialogResolverOptions()
+        self._stop = threading.Event()
+        self._thread: threading.Thread | None = None
+        self._clicked: set[int] = set()
+
+    def start(self) -> None:
+        if self._thread is not None:
+            return
+        self._stop.clear()
+        self._thread = threading.Thread(target=self._run, daemon=True, name="revit-dialog-resolver")
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._stop.set()
+        if self._thread is not None:
+            self._thread.join(timeout=5.0)
+            self._thread = None
+
+    def _run(self) -> None:
+        while not self._stop.is_set():
+            self._scan()
+            self._stop.wait(self._opts.poll_interval_s)
+
+    def _scan(self) -> None:
+        for hwnd in self._enum_dialog_windows():
+            title = _get_window_text(hwnd)
+            if not title or not self._is_whitelisted(title):
+                continue
+            button = self._find_button(hwnd)
+            if button and button not in self._clicked:
+                _send_click(button)
+                self._clicked.add(button)
+
+    def _is_whitelisted(self, title: str) -> bool:
+        lower = title.lower()
+        return any(kw.lower() in lower for kw in self._opts.dialog_title_keywords)
+
+    def _find_button(self, parent: int) -> int | None:
+        result: list[int] = []
+
+        @_EnumWindowsProc
+        def _cb(child: int, _: int) -> bool:
+            if _is_preferred_button(child, self._opts.preferred_button_keywords):
+                result.append(child)
+                return False
+            return True
+
+        _user32.EnumChildWindows(parent, _cb, 0)
+        return result[0] if result else None
+
+    def _enum_dialog_windows(self) -> list[int]:
+        windows: list[int] = []
+
+        @_EnumWindowsProc
+        def _cb(hwnd: int, _: int) -> bool:
+            if _is_target_dialog(hwnd, self._pid):
+                windows.append(hwnd)
+            return True
+
+        _user32.EnumWindows(_cb, 0)
+        return windows
+
+
+def _is_preferred_button(hwnd: int, keywords: list[str]) -> bool:
+    if _get_class_name(hwnd).lower() != _BUTTON_CLASS:
+        return False
+    text = _get_window_text(hwnd)
+    if not text:
+        return False
+    text_lower = text.lower()
+    return any(kw.lower() in text_lower for kw in keywords)
+
+
+def _is_target_dialog(hwnd: int, target_pid: int) -> bool:
+    if not _is_window_visible(hwnd):
+        return False
+    if _get_class_name(hwnd) != _DIALOG_CLASS:
+        return False
+    return _get_window_pid(hwnd) == target_pid

revitdevtool_pytest-0.0.2/src/revitdevtool_pytest/discovery.py

@@ -0,0 +1,123 @@
+"""Discover running Revit instances and launch Revit if needed."""
+
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+import time
+import winreg
+from dataclasses import dataclass
+
+from .constants import (
+    DEFAULT_LAUNCH_TIMEOUT_S,
+    DEFAULT_POLL_INTERVAL_S,
+    PIPE_DIR,
+    PIPE_PATTERN,
+    REVIT_DEFAULT_DIR,
+    REVIT_EXE,
+    REVIT_NOSPLASH,
+    REVIT_REGISTRY_KEY,
+    REVIT_REGISTRY_VALUE,
+)
+
+_PIPE_RE = re.compile(PIPE_PATTERN)
+
+
+@dataclass(frozen=True, slots=True)
+class RevitInstance:
+    pipe_name: str
+    version: int
+    process_id: int
+
+
+def find_revit_pipes() -> list[RevitInstance]:
+    """Scan Named Pipes for pipes matching ``Revit_{year}_{pid}``."""
+    instances: list[RevitInstance] = []
+    for name in _list_named_pipes():
+        m = _PIPE_RE.match(name)
+        if m:
+            instances.append(RevitInstance(name, int(m.group(1)), int(m.group(2))))
+    return instances
+
+
+def select_instance(
+    instances: list[RevitInstance],
+    version: int | None = None,
+) -> RevitInstance | None:
+    """Find a running instance matching *version*, or the latest if unspecified.
+
+    When *version* is given, only an exact match is returned — no fallback.
+    """
+    if not instances:
+        return None
+    if version is not None:
+        matches = [i for i in instances if i.version == version]
+        return matches[0] if matches else None
+    return max(instances, key=lambda i: i.version)
+
+
+def find_revit_path(version: int) -> str | None:
+    """Locate ``Revit.exe`` via registry, falling back to the default path."""
+    path = _find_from_registry(version)
+    if path:
+        return path
+    default = os.path.join(REVIT_DEFAULT_DIR, f"Revit {version}", REVIT_EXE)
+    return default if os.path.isfile(default) else None
+
+
+def launch_revit(
+    version: int,
+    wait_timeout_s: float = DEFAULT_LAUNCH_TIMEOUT_S,
+) -> RevitInstance | None:
+    """Start Revit with ``/nosplash`` and wait for its Named Pipe to appear.
+
+    Returns the discovered ``RevitInstance``, or ``None`` on timeout.
+    Raises ``FileNotFoundError`` if the requested version is not installed.
+    """
+    exe_path = find_revit_path(version)
+    if exe_path is None:
+        raise FileNotFoundError(f"Revit {version} installation not found.")
+
+    subprocess.Popen(  # noqa: S603
+        [exe_path, REVIT_NOSPLASH],
+        creationflags=subprocess.DETACHED_PROCESS,
+    )
+
+    return wait_for_revit_pipe(version, timeout_s=wait_timeout_s)
+
+
+def wait_for_revit_pipe(
+    version: int | None = None,
+    timeout_s: float = DEFAULT_LAUNCH_TIMEOUT_S,
+    poll_interval_s: float = DEFAULT_POLL_INTERVAL_S,
+) -> RevitInstance | None:
+    """Block until a Revit pipe matching *version* appears."""
+    deadline = time.monotonic() + timeout_s
+    while time.monotonic() < deadline:
+        match = select_instance(find_revit_pipes(), version)
+        if match is not None:
+            return match
+        time.sleep(poll_interval_s)
+    return None
+
+
+def _find_from_registry(version: int) -> str | None:
+    try:
+        with winreg.OpenKey(
+            winreg.HKEY_LOCAL_MACHINE,
+            REVIT_REGISTRY_KEY.format(version=version),
+        ) as key:
+            install_dir, _ = winreg.QueryValueEx(key, REVIT_REGISTRY_VALUE)
+        exe = os.path.join(install_dir, REVIT_EXE)
+        return exe if os.path.isfile(exe) else None
+    except OSError:
+        return None
+
+
+def _list_named_pipes() -> list[str]:
+    """Return base names of all Named Pipes visible to the current user."""
+    try:
+        return os.listdir(PIPE_DIR)
+    except OSError:
+        return []

revitdevtool_pytest-0.0.2/src/revitdevtool_pytest/models.py

@@ -0,0 +1,95 @@
+"""Data models for the RevitDevTool bridge protocol.
+
+Mirrors ``RevitDevTool.McpParser.Models.BridgeMessage`` on the C# side.
+"""
+
+from __future__ import annotations
+
+import json
+import uuid
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+
+class TestOutcome(Enum):
+    PASSED = "passed"
+    FAILED = "failed"
+    SKIPPED = "skipped"
+    ERROR = "error"
+
+
+@dataclass(frozen=True, slots=True)
+class TestRequest:
+    module_source: str
+    test_name: str
+    file_path: str
+    class_name: str | None = None
+
+    def to_bridge_params(self) -> dict[str, Any]:
+        params: dict[str, Any] = {
+            "module_source": self.module_source,
+            "test_name": self.test_name,
+            "file_path": self.file_path,
+        }
+        if self.class_name:
+            params["class_name"] = self.class_name
+        return params
+
+
+@dataclass(frozen=True, slots=True)
+class TestResult:
+    outcome: TestOutcome = TestOutcome.ERROR
+    message: str = ""
+    traceback: str = ""
+    stdout: str = ""
+    duration_ms: float = 0.0
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> TestResult:
+        raw = data.get("outcome", "error")
+        try:
+            outcome = TestOutcome(raw)
+        except ValueError:
+            outcome = TestOutcome.ERROR
+        return cls(
+            outcome=outcome,
+            message=data.get("message", ""),
+            traceback=data.get("traceback", ""),
+            stdout=data.get("stdout", ""),
+            duration_ms=data.get("duration_ms", 0.0),
+        )
+
+
+@dataclass(slots=True)
+class BridgeRequest:
+    method: str
+    params: dict[str, Any] | None = None
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+
+    def to_json_bytes(self) -> bytes:
+        msg: dict[str, Any] = {
+            "type": "request",
+            "id": self.id,
+            "method": self.method,
+        }
+        if self.params is not None:
+            msg["params"] = self.params
+        return json.dumps(msg, ensure_ascii=False).encode("utf-8")
+
+
+@dataclass(frozen=True, slots=True)
+class BridgeResponse:
+    id: str
+    result: Any = None
+    is_error: bool = False
+    error_message: str = ""
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> BridgeResponse:
+        return cls(
+            id=data.get("id", ""),
+            result=data.get("result"),
+            is_error=data.get("isError", False),
+            error_message=data.get("errorMessage", ""),
+        )

revitdevtool_pytest-0.0.2/src/revitdevtool_pytest/plugin.py

@@ -0,0 +1,199 @@
+"""pytest plugin — redirect test execution to a running Revit instance.
+
+``--revit-launch`` requires ``--revit-version`` — no fallback guessing.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING
+
+import pytest
+
+from .bridge import RevitBridge
+from .constants import (
+    DEFAULT_LAUNCH_TIMEOUT_S,
+    DEFAULT_TEST_TIMEOUT_S,
+    EXIT_CODE_CONFIG_ERROR,
+    OPT_LAUNCH,
+    OPT_LAUNCH_TIMEOUT,
+    OPT_PIPE,
+    OPT_TIMEOUT,
+    OPT_VERSION,
+    PLUGIN_NAME,
+)
+from .discovery import find_revit_path, find_revit_pipes, launch_revit, select_instance
+from .models import TestOutcome
+from .serializer import serialize_test
+
+if TYPE_CHECKING:
+    from .dialog_resolver import StartupDialogResolver
+    from .discovery import RevitInstance
+
+_bridge: RevitBridge | None = None
+_dialog_resolver: StartupDialogResolver | None = None
+_no_revit_key = pytest.StashKey[bool]()
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    grp = parser.getgroup("revit", "Revit API testing")
+    grp.addoption("--revit-version", dest=OPT_VERSION, default=None, type=int,
+                   help="Revit version year (e.g. 2025). Required when --revit-launch is set.")
+    grp.addoption("--revit-timeout", dest=OPT_TIMEOUT, default=None, type=float,
+                   help=f"Per-test execution timeout in seconds (default: {DEFAULT_TEST_TIMEOUT_S}).")
+    grp.addoption("--revit-pipe", dest=OPT_PIPE, default=None,
+                   help="Explicit pipe name (bypasses auto-discovery).")
+    grp.addoption("--revit-launch", dest=OPT_LAUNCH, action="store_true", default=False,
+                   help="Auto-launch Revit if no running instance is found. Requires --revit-version.")
+    grp.addoption("--revit-launch-timeout", dest=OPT_LAUNCH_TIMEOUT, default=None, type=float,
+                   help=f"Seconds to wait for Revit to start (default: {DEFAULT_LAUNCH_TIMEOUT_S}).")
+
+    parser.addini(OPT_VERSION, "Revit version year", type="string", default=None)
+    parser.addini(OPT_TIMEOUT, "Per-test timeout (seconds)", type="string",
+                  default=str(DEFAULT_TEST_TIMEOUT_S))
+    parser.addini(OPT_PIPE, "Explicit pipe name", type="string", default=None)
+    parser.addini(OPT_LAUNCH, "Auto-launch Revit", type="bool", default=False)
+    parser.addini(OPT_LAUNCH_TIMEOUT, "Launch timeout (seconds)", type="string",
+                  default=str(DEFAULT_LAUNCH_TIMEOUT_S))
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    config.addinivalue_line("markers", "revit: mark test to run inside Revit process")
+
+    global _bridge, _dialog_resolver
+
+    explicit_pipe = _opt(config, OPT_PIPE, OPT_PIPE)
+    if explicit_pipe:
+        pipe_name = explicit_pipe
+    else:
+        version = _opt_int(config, OPT_VERSION, OPT_VERSION)
+        want_launch = _opt_bool(config, OPT_LAUNCH, OPT_LAUNCH)
+
+        if want_launch and version is None:
+            pytest.exit(
+                f"{PLUGIN_NAME}: --revit-launch requires --revit-version (e.g. --revit-version=2025)",
+                returncode=EXIT_CODE_CONFIG_ERROR,
+            )
+
+        instance = select_instance(find_revit_pipes(), version)
+
+        if instance is None and want_launch:
+            instance = _auto_launch(version, config)  # type: ignore[arg-type]
+
+        if instance is None:
+            config.stash[_no_revit_key] = True
+            return
+        pipe_name = instance.pipe_name
+
+    bridge = RevitBridge(pipe_name)
+    try:
+        bridge.connect()
+        _bridge = bridge
+        config.stash[_no_revit_key] = False
+    except ConnectionError as exc:
+        pytest.exit(f"{PLUGIN_NAME}: Could not connect to Revit: {exc}", returncode=EXIT_CODE_CONFIG_ERROR)
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_pyfunc_call(pyfuncitem: pytest.Function) -> object:
+    """Replace local execution with remote execution inside Revit.
+
+    Returning ``True`` tells pytest to skip calling the test function locally.
+    """
+    if pyfuncitem.config.stash.get(_no_revit_key, True):
+        pytest.skip("No Revit instance available")
+
+    if _bridge is None or not _bridge.connected:
+        pytest.skip("Not connected to Revit")
+
+    timeout = _opt_float(pyfuncitem.config, OPT_TIMEOUT, OPT_TIMEOUT) or DEFAULT_TEST_TIMEOUT_S
+    result = _bridge.execute_test(serialize_test(pyfuncitem), timeout_s=timeout)
+
+    if result.stdout:
+        sys.stdout.write(result.stdout)
+
+    if result.outcome == TestOutcome.PASSED:
+        return True
+
+    if result.outcome == TestOutcome.SKIPPED:
+        pytest.skip(result.message)
+
+    msg = result.message
+    if result.outcome != TestOutcome.FAILED:
+        msg = f"Test execution error: {msg}"
+    if result.traceback:
+        msg += "\n" + result.traceback
+    pytest.fail(msg, pytrace=False)
+
+
+def pytest_unconfigure(config: pytest.Config) -> None:
+    global _bridge, _dialog_resolver
+    if _dialog_resolver is not None:
+        _dialog_resolver.stop()
+        _dialog_resolver = None
+    if _bridge is not None:
+        _bridge.disconnect()
+        _bridge = None
+
+
+def _auto_launch(version: int, config: pytest.Config) -> RevitInstance:
+    """Launch exactly the requested Revit version, or fail fast.
+
+    Every failure path calls ``pytest.exit()`` — this function never returns ``None``.
+    """
+    global _dialog_resolver
+
+    timeout = _opt_float(config, OPT_LAUNCH_TIMEOUT, OPT_LAUNCH_TIMEOUT) or DEFAULT_LAUNCH_TIMEOUT_S
+
+    if find_revit_path(version) is None:
+        pytest.exit(
+            f"{PLUGIN_NAME}: Revit {version} is not installed on this machine.",
+            returncode=EXIT_CODE_CONFIG_ERROR,
+        )
+
+    print(f"{PLUGIN_NAME}: Launching Revit {version}...")
+    instance = launch_revit(version, wait_timeout_s=timeout)
+
+    if instance is None:
+        pytest.exit(
+            f"{PLUGIN_NAME}: Revit {version} launched but Named Pipe did not appear within {timeout}s.",
+            returncode=EXIT_CODE_CONFIG_ERROR,
+        )
+
+    try:
+        from .dialog_resolver import StartupDialogResolver as _Resolver
+
+        _dialog_resolver = _Resolver(instance.process_id)
+        _dialog_resolver.start()
+    except ImportError:
+        pass
+
+    print(f"{PLUGIN_NAME}: Connected to Revit {instance.version} (pid={instance.process_id})")
+    return instance
+
+
+def _opt(config: pytest.Config, cli: str, ini: str) -> str | None:
+    val = config.getoption(cli, default=None)
+    if val is not None:
+        return str(val)
+    ini_val = config.getini(ini)
+    return str(ini_val) if ini_val not in (None, "") else None
+
+
+def _opt_int(config: pytest.Config, cli: str, ini: str) -> int | None:
+    raw = _opt(config, cli, ini)
+    return int(raw) if raw else None
+
+
+def _opt_float(config: pytest.Config, cli: str, ini: str) -> float | None:
+    raw = _opt(config, cli, ini)
+    return float(raw) if raw else None
+
+
+def _opt_bool(config: pytest.Config, cli: str, ini: str) -> bool:
+    if config.getoption(cli, default=False):
+        return True
+    ini_val = config.getini(ini)
+    if isinstance(ini_val, bool):
+        return ini_val
+    return str(ini_val).lower() in ("true", "1", "yes") if ini_val else False

revitdevtool_pytest-0.0.2/src/revitdevtool_pytest/serializer.py

@@ -0,0 +1,21 @@
+"""Serialize a collected pytest item into a TestRequest for remote execution."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from .models import TestRequest
+
+if TYPE_CHECKING:
+    import pytest
+
+
+def serialize_test(item: pytest.Item) -> TestRequest:
+    """Read the full module source and extract test/class names."""
+    return TestRequest(
+        module_source=Path(str(item.fspath)).read_text(encoding="utf-8"),
+        test_name=item.name,
+        file_path=str(item.fspath),
+        class_name=item.cls.__name__ if item.cls is not None else None,
+    )

revitdevtool_pytest-0.0.2/tests/conftest.py

@@ -0,0 +1,21 @@
+"""Sample conftest.py — user-defined fixtures for Revit testing.
+
+The plugin only provides the connection to Revit and remote execution;
+everything else is user-controlled.
+"""
+
+import pytest
+
+
+@pytest.fixture(scope="session")
+def revit_app():
+    """Provide the Revit Application object for the entire test session."""
+    app = __revit__.Application  # noqa: F821
+    yield app
+
+
+@pytest.fixture(scope="session")
+def revit_doc():
+    """Provide the active Document. Assumes a document is already open in Revit."""
+    doc = __revit__.ActiveUIDocument.Document  # noqa: F821
+    yield doc

revitdevtool_pytest-0.0.2/tests/test_revit_basic.py

@@ -0,0 +1,35 @@
+"""Basic Revit API tests — demonstrates RevitDevTool.PyTest usage.
+
+All Revit API imports must be inside function bodies (lazy imports).
+__revit__ is available globally (injected by RevitDevTool).
+"""
+
+
+def test_revit_version():
+    """Verify Revit is running and we can read the version."""
+    app = __revit__.Application  # noqa: F821
+    assert app.VersionNumber is not None
+    print(f"Revit version: {app.VersionName}")
+
+
+def test_active_document_exists():
+    """Verify a document is open in Revit."""
+    uidoc = __revit__.ActiveUIDocument  # noqa: F821
+    assert uidoc is not None
+    assert uidoc.Document is not None
+    print(f"Active document: {uidoc.Document.Title}")
+
+
+def test_wall_collector():
+    """Query walls from the active document using FilteredElementCollector."""
+    from Autodesk.Revit.DB import FilteredElementCollector, BuiltInCategory
+
+    doc = __revit__.ActiveUIDocument.Document  # noqa: F821
+    collector = (
+        FilteredElementCollector(doc)
+        .OfCategory(BuiltInCategory.OST_Walls)
+        .WhereElementIsNotElementType()
+    )
+    walls = list(collector)
+    print(f"Found {len(walls)} wall instances")
+    assert isinstance(walls, list)

revitdevtool_pytest-0.0.2/tests/test_revit_transactions.py

@@ -0,0 +1,41 @@
+"""Transaction tests — demonstrates creating and rolling back changes.
+
+Shows how users can build their own transaction isolation patterns
+without any framework-imposed behavior.
+"""
+
+
+def test_create_and_delete_wall():
+    """Create a wall inside a transaction, then roll back."""
+    from Autodesk.Revit.DB import (
+        Transaction,
+        Line,
+        XYZ,
+        FilteredElementCollector,
+        BuiltInCategory,
+    )
+
+    doc = __revit__.ActiveUIDocument.Document  # noqa: F821
+
+    collector = FilteredElementCollector(doc).OfCategory(
+        BuiltInCategory.OST_Walls
+    ).WhereElementIsNotElementType()
+    count_before = len(list(collector))
+
+    tx = Transaction(doc, "pytest: create test wall")
+    tx.Start()
+    try:
+        line = Line.CreateBound(XYZ(0, 0, 0), XYZ(10, 0, 0))
+        print(f"Transaction started, walls before: {count_before}")
+    finally:
+        tx.RollBack()
+        print("Transaction rolled back")
+
+
+def test_read_project_info():
+    """Read project information — no transaction needed for read-only."""
+    doc = __revit__.ActiveUIDocument.Document  # noqa: F821
+    info = doc.ProjectInformation
+    assert info is not None
+    print(f"Project name: {info.Name}")
+    print(f"Project number: {info.Number}")

revitdevtool_pytest-0.0.2/tests/test_smoke.py

@@ -0,0 +1,18 @@
+"""Smoke test — minimal test to verify RevitDevTool.PyTest protocol works."""
+
+
+def test_revit_application_available():
+    """Verify __revit__ is injected and Application is accessible."""
+    app = __revit__.Application  # noqa: F821
+    version = app.VersionNumber
+    assert version is not None
+    assert len(version) == 4  # e.g. "2025"
+    print(f"Revit {app.VersionName} (build {app.VersionBuild})")
+
+
+def test_uiapplication_available():
+    """Verify UIApplication is accessible."""
+    uiapp = __revit__  # noqa: F821
+    assert uiapp is not None
+    assert uiapp.Application is not None
+    print(f"UIApplication OK — version {uiapp.Application.VersionNumber}")