modify harness framework

scripts/msvc_harness/adapters/__init__.py

@@ -0,0 +1,5 @@
+from .base import AdapterError, ValidationAdapter
+from .cmake import CMakeAdapter
+from .msbuild import MSBuildAdapter
+
+__all__ = ["AdapterError", "CMakeAdapter", "MSBuildAdapter", "ValidationAdapter"]

scripts/msvc_harness/adapters/base.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+from typing import Protocol
+
+from ..models import HarnessConfig, ProjectSelection, Toolchain, ValidationPlan
+
+
+class AdapterError(RuntimeError):
+    pass
+
+
+class ValidationAdapter(Protocol):
+    def create_plan(
+        self,
+        root: Path,
+        selection: ProjectSelection,
+        config: HarnessConfig,
+        tools: Toolchain,
+    ) -> ValidationPlan:
+        raise NotImplementedError

scripts/msvc_harness/adapters/cmake.py

@@ -0,0 +1,99 @@
+from pathlib import Path
+
+from ..models import (
+    CommandSpec,
+    HarnessConfig,
+    ProjectKind,
+    ProjectSelection,
+    ResultCheck,
+    ResultCheckKind,
+    Toolchain,
+    ValidationPlan,
+    ValidationStep,
+)
+from .base import AdapterError
+
+
+class CMakeAdapter:
+    def create_plan(
+        self,
+        root: Path,
+        selection: ProjectSelection,
+        config: HarnessConfig,
+        tools: Toolchain,
+    ) -> ValidationPlan:
+        if selection.kind is not ProjectKind.CMAKE:
+            raise AdapterError("CMakeAdapter requires a CMake project selection")
+        if tools.cmake is None:
+            raise AdapterError("CMake tool is required")
+        if tools.ctest is None:
+            raise AdapterError("CTest tool is required")
+
+        if config.cmake.configure_preset is None:
+            command_cwd = root
+            binary = root / ".harness/build"
+            configure = (
+                str(tools.cmake),
+                "-S",
+                str(config.cmake.source_dir),
+                "-B",
+                str(binary),
+                "-A",
+                "x64",
+            )
+            build = (str(tools.cmake), "--build", str(binary), "--config", "Debug")
+            discover = (
+                str(tools.ctest),
+                "--test-dir",
+                str(binary),
+                "-C",
+                "Debug",
+                "--show-only=json-v1",
+            )
+            test = (
+                str(tools.ctest),
+                "--test-dir",
+                str(binary),
+                "-C",
+                "Debug",
+                "--output-on-failure",
+            )
+        else:
+            command_cwd = config.cmake.source_dir
+            binary = config.cmake.binary_dir
+            if (
+                binary is None
+                or config.cmake.build_preset is None
+                or config.cmake.test_preset is None
+            ):
+                raise AdapterError("CMake presets require binary, build, and test settings")
+            configure = (str(tools.cmake), "--preset", config.cmake.configure_preset)
+            build = (str(tools.cmake), "--build", "--preset", config.cmake.build_preset)
+            discover = (
+                str(tools.ctest),
+                "--preset",
+                config.cmake.test_preset,
+                "--show-only=json-v1",
+            )
+            test = (
+                str(tools.ctest),
+                "--preset",
+                config.cmake.test_preset,
+                "--output-on-failure",
+            )
+
+        return ValidationPlan(
+            ProjectKind.CMAKE,
+            (
+                ValidationStep(
+                    CommandSpec(configure, command_cwd, "configure"),
+                    (ResultCheck(ResultCheckKind.CMAKE_COMPILER_IS_MSVC, binary),),
+                ),
+                ValidationStep(CommandSpec(build, command_cwd, "build")),
+                ValidationStep(
+                    CommandSpec(discover, command_cwd, "test-discovery"),
+                    (ResultCheck(ResultCheckKind.CTEST_HAS_TESTS),),
+                ),
+                ValidationStep(CommandSpec(test, command_cwd, "test")),
+            ),
+        )

scripts/msvc_harness/adapters/msbuild.py

@@ -0,0 +1,60 @@
+from pathlib import Path
+
+from ..models import (
+    CommandSpec,
+    HarnessConfig,
+    ProjectKind,
+    ProjectSelection,
+    Toolchain,
+    ValidationPlan,
+    ValidationStep,
+)
+from .base import AdapterError
+
+
+def _test_argv(root: Path, command: tuple[str, ...]) -> tuple[str, ...]:
+    if "/" not in command[0] and "\\" not in command[0]:
+        return command
+    first = Path(command[0].replace("\\", "/"))
+    executable = first if first.is_absolute() else (root / first).resolve()
+    try:
+        executable.relative_to(root)
+    except ValueError as exc:
+        raise AdapterError(
+            "msbuild.testCommand resolves outside the repository"
+        ) from exc
+    return (str(executable), *command[1:])
+
+
+class MSBuildAdapter:
+    def create_plan(
+        self,
+        root: Path,
+        selection: ProjectSelection,
+        config: HarnessConfig,
+        tools: Toolchain,
+    ) -> ValidationPlan:
+        if selection.kind is not ProjectKind.MSBUILD:
+            raise AdapterError("MSBuildAdapter received a non-MSBuild project")
+        if not config.msbuild.test_command:
+            raise AdapterError(
+                "msbuild.testCommand is required for .sln/.vcxproj validation"
+            )
+        build = ValidationStep(
+            CommandSpec(
+                (
+                    str(tools.msbuild),
+                    str(selection.project_file),
+                    "/m",
+                    "/nologo",
+                    f"/p:Configuration={config.msbuild.configuration}",
+                    f"/p:Platform={config.msbuild.platform}",
+                ),
+                root,
+                "build",
+            )
+        )
+        test = ValidationStep(
+            CommandSpec(_test_argv(root, config.msbuild.test_command), root, "test")
+        )
+        return ValidationPlan(ProjectKind.MSBUILD, (build, test))