pathfinder: streamline compatibility test coverage

Drop redundant mocked happy-path checks that now overlap with the real-host CI matrix, and add explicit ELF/CUBIN pipeline cases so the remaining mocks stay focused on platform, ordering, and version-corner behavior. This keeps the guard-rails suite easier to maintain without giving up the synthetic coverage that real installs still cannot exercise reliably.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: rwgk

cuda_pathfinder/tests/test_compatibility_guard_rails.py

@@ -113,6 +113,16 @@ def _loaded_dl(abs_path: str, *, found_via: str = "CUDA_PATH") -> LoadedDL:
     )
 
 
+def _patch_dynamic_lib_loader(monkeypatch, **loaded_by_libname: LoadedDL) -> None:
+    def fake_load_nvidia_dynamic_lib(libname: str) -> LoadedDL:
+        loaded = loaded_by_libname.get(libname)
+        if loaded is None:
+            raise AssertionError(f"Unexpected libname: {libname!r}")
+        return loaded
+
+    monkeypatch.setattr(compatibility_module, "_load_nvidia_dynamic_lib", fake_load_nvidia_dynamic_lib)
+
+
 def _located_static_lib(name: str, abs_path: str) -> LocatedStaticLib:
     return LocatedStaticLib(
         name=name,
@@ -492,53 +502,6 @@ def test_public_apis_share_process_wide_guard_rails_state(monkeypatch, tmp_path)
         pathfinder.find_nvidia_header_directory("nvrtc")
 
 
-def test_load_dynamic_lib_then_find_headers_same_ctk_version(monkeypatch, tmp_path):
-    ctk_root = tmp_path / "cuda-12.9"
-    _write_cuda_h(ctk_root, "12.9.20250531")
-    lib_path = _touch(ctk_root / "targets" / "x86_64-linux" / "lib" / "libnvrtc.so.12")
-    hdr_dir = ctk_root / "targets" / "x86_64-linux" / "include"
-    _touch(hdr_dir / "nvrtc.h")
-
-    monkeypatch.setattr(compatibility_module, "_load_nvidia_dynamic_lib", lambda _libname: _loaded_dl(lib_path))
-    monkeypatch.setattr(
-        compatibility_module,
-        "_locate_nvidia_header_directory",
-        lambda _libname: LocatedHeaderDir(abs_path=str(hdr_dir), found_via="CUDA_PATH"),
-    )
-
-    guard_rails = CompatibilityGuardRails(driver_cuda_version=_driver_cuda_version(13000))
-
-    loaded = guard_rails.load_nvidia_dynamic_lib("nvrtc")
-    hdr_path = guard_rails.find_nvidia_header_directory("nvrtc")
-
-    assert loaded.abs_path == lib_path
-    assert hdr_path == str(hdr_dir)
-
-
-def test_same_api_companions_require_exact_ctk_major_minor_match(monkeypatch, tmp_path):
-    lib_root = tmp_path / "cuda-12.8"
-    hdr_root = tmp_path / "cuda-12.9"
-    _write_cuda_h(lib_root, "12.8.20250303")
-    _write_cuda_h(hdr_root, "12.9.20250531")
-
-    lib_path = _touch(lib_root / "targets" / "x86_64-linux" / "lib" / "libnvrtc.so.12")
-    hdr_dir = hdr_root / "targets" / "x86_64-linux" / "include"
-    _touch(hdr_dir / "nvrtc.h")
-
-    monkeypatch.setattr(compatibility_module, "_load_nvidia_dynamic_lib", lambda _libname: _loaded_dl(lib_path))
-    monkeypatch.setattr(
-        compatibility_module,
-        "_locate_nvidia_header_directory",
-        lambda _libname: LocatedHeaderDir(abs_path=str(hdr_dir), found_via="CUDA_PATH"),
-    )
-
-    guard_rails = CompatibilityGuardRails(driver_cuda_version=_driver_cuda_version(13000))
-    guard_rails.load_nvidia_dynamic_lib("nvrtc")
-
-    with pytest.raises(CompatibilityCheckError, match=r"companion tag 'api_nvrtc'"):
-        guard_rails.find_nvidia_header_directory("nvrtc")
-
-
 def test_same_dynamic_link_component_requires_exact_ctk_major_minor_match(monkeypatch, tmp_path):
     cublas_root = tmp_path / "cuda-12.8"
     cusolver_root = tmp_path / "cuda-12.9"
@@ -548,14 +511,11 @@ def test_same_dynamic_link_component_requires_exact_ctk_major_minor_match(monkey
     cublas_path = _touch(cublas_root / "targets" / "x86_64-linux" / "lib" / "libcublas.so.12")
     cusolver_path = _touch(cusolver_root / "targets" / "x86_64-linux" / "lib" / "libcusolver.so.12")
 
-    def fake_load_nvidia_dynamic_lib(libname: str) -> LoadedDL:
-        if libname == "cublas":
-            return _loaded_dl(cublas_path)
-        if libname == "cusolver":
-            return _loaded_dl(cusolver_path)
-        raise AssertionError(f"Unexpected libname: {libname!r}")
-
-    monkeypatch.setattr(compatibility_module, "_load_nvidia_dynamic_lib", fake_load_nvidia_dynamic_lib)
+    _patch_dynamic_lib_loader(
+        monkeypatch,
+        cublas=_loaded_dl(cublas_path),
+        cusolver=_loaded_dl(cusolver_path),
+    )
 
     guard_rails = CompatibilityGuardRails(driver_cuda_version=_driver_cuda_version(13000))
     guard_rails.load_nvidia_dynamic_lib("cublas")
@@ -576,14 +536,11 @@ def test_independent_dynamic_libs_may_resolve_to_different_ctk_minors(monkeypatc
     nvrtc_path = _touch(nvrtc_root / "targets" / "x86_64-linux" / "lib" / "libnvrtc.so.12")
     nvjitlink_path = _touch(nvjitlink_root / "targets" / "x86_64-linux" / "lib" / "libnvJitLink.so.12")
 
-    def fake_load_nvidia_dynamic_lib(libname: str) -> LoadedDL:
-        if libname == "nvrtc":
-            return _loaded_dl(nvrtc_path)
-        if libname == "nvJitLink":
-            return _loaded_dl(nvjitlink_path)
-        raise AssertionError(f"Unexpected libname: {libname!r}")
-
-    monkeypatch.setattr(compatibility_module, "_load_nvidia_dynamic_lib", fake_load_nvidia_dynamic_lib)
+    _patch_dynamic_lib_loader(
+        monkeypatch,
+        nvrtc=_loaded_dl(nvrtc_path),
+        nvJitLink=_loaded_dl(nvjitlink_path),
+    )
 
     guard_rails = CompatibilityGuardRails(driver_cuda_version=_driver_cuda_version(13000))
 
@@ -594,36 +551,6 @@ def fake_load_nvidia_dynamic_lib(libname: str) -> LoadedDL:
     assert loaded_nvjitlink.abs_path == nvjitlink_path
 
 
-def test_public_apis_allow_independent_dynamic_libs_to_differ_by_minor(monkeypatch, tmp_path):
-    nvrtc_root = tmp_path / "cuda-12.8"
-    nvjitlink_root = tmp_path / "cuda-12.9"
-    _write_cuda_h(nvrtc_root, "12.8.20250303")
-    _write_cuda_h(nvjitlink_root, "12.9.20250531")
-
-    nvrtc_path = _touch(nvrtc_root / "targets" / "x86_64-linux" / "lib" / "libnvrtc.so.12")
-    nvjitlink_path = _touch(nvjitlink_root / "targets" / "x86_64-linux" / "lib" / "libnvJitLink.so.12")
-
-    def fake_load_nvidia_dynamic_lib(libname: str) -> LoadedDL:
-        if libname == "nvrtc":
-            return _loaded_dl(nvrtc_path)
-        if libname == "nvJitLink":
-            return _loaded_dl(nvjitlink_path)
-        raise AssertionError(f"Unexpected libname: {libname!r}")
-
-    monkeypatch.setattr(compatibility_module, "_load_nvidia_dynamic_lib", fake_load_nvidia_dynamic_lib)
-    monkeypatch.setattr(
-        pathfinder,
-        "process_wide_compatibility_guard_rails",
-        CompatibilityGuardRails(driver_cuda_version=_driver_cuda_version(13000)),
-    )
-
-    loaded_nvrtc = pathfinder.load_nvidia_dynamic_lib("nvrtc")
-    loaded_nvjitlink = pathfinder.load_nvidia_dynamic_lib("nvJitLink")
-
-    assert loaded_nvrtc.abs_path == nvrtc_path
-    assert loaded_nvjitlink.abs_path == nvjitlink_path
-
-
 def test_toolchain_companions_require_exact_ctk_major_minor_match(monkeypatch, tmp_path):
     static_root = tmp_path / "cuda-12.8"
     binary_root = tmp_path / "cuda-12.9"
@@ -663,14 +590,11 @@ def test_declared_ltoir_pipeline_requires_nvjitlink_not_older_than_nvrtc(monkeyp
     nvrtc_path = _touch(nvrtc_root / "targets" / "x86_64-linux" / "lib" / "libnvrtc.so.12")
     nvjitlink_path = _touch(nvjitlink_root / "targets" / "x86_64-linux" / "lib" / "libnvJitLink.so.12")
 
-    def fake_load_nvidia_dynamic_lib(libname: str) -> LoadedDL:
-        if libname == "nvrtc":
-            return _loaded_dl(nvrtc_path)
-        if libname == "nvJitLink":
-            return _loaded_dl(nvjitlink_path)
-        raise AssertionError(f"Unexpected libname: {libname!r}")
-
-    monkeypatch.setattr(compatibility_module, "_load_nvidia_dynamic_lib", fake_load_nvidia_dynamic_lib)
+    _patch_dynamic_lib_loader(
+        monkeypatch,
+        nvrtc=_loaded_dl(nvrtc_path),
+        nvJitLink=_loaded_dl(nvjitlink_path),
+    )
 
     guard_rails = CompatibilityGuardRails(driver_cuda_version=_driver_cuda_version(13000))
     guard_rails.load_nvidia_dynamic_lib("nvrtc")
@@ -693,14 +617,11 @@ def test_declared_ltoir_pipeline_allows_same_major_newer_nvjitlink(monkeypatch,
     nvrtc_path = _touch(nvrtc_root / "targets" / "x86_64-linux" / "lib" / "libnvrtc.so.12")
     nvjitlink_path = _touch(nvjitlink_root / "targets" / "x86_64-linux" / "lib" / "libnvJitLink.so.12")
 
-    def fake_load_nvidia_dynamic_lib(libname: str) -> LoadedDL:
-        if libname == "nvrtc":
-            return _loaded_dl(nvrtc_path)
-        if libname == "nvJitLink":
-            return _loaded_dl(nvjitlink_path)
-        raise AssertionError(f"Unexpected libname: {libname!r}")
-
-    monkeypatch.setattr(compatibility_module, "_load_nvidia_dynamic_lib", fake_load_nvidia_dynamic_lib)
+    _patch_dynamic_lib_loader(
+        monkeypatch,
+        nvrtc=_loaded_dl(nvrtc_path),
+        nvJitLink=_loaded_dl(nvjitlink_path),
+    )
 
     guard_rails = CompatibilityGuardRails(driver_cuda_version=_driver_cuda_version(13000))
     loaded_nvrtc = guard_rails.load_nvidia_dynamic_lib("nvrtc")
@@ -715,7 +636,8 @@ def fake_load_nvidia_dynamic_lib(libname: str) -> LoadedDL:
     assert loaded_nvjitlink.abs_path == nvjitlink_path
 
 
-def test_declared_ptx_pipeline_allows_cross_major_nvrtc_to_nvjitlink(monkeypatch, tmp_path):
+@pytest.mark.parametrize("artifact_kind", ("ptx", "elf", "cubin"))
+def test_declared_non_lto_pipeline_allows_cross_major_nvrtc_to_nvjitlink(monkeypatch, tmp_path, artifact_kind):
     nvrtc_root = tmp_path / "cuda-12.8"
     nvjitlink_root = tmp_path / "cuda-13.0"
     _write_cuda_h(nvrtc_root, "12.8.20250303")
@@ -724,22 +646,19 @@ def test_declared_ptx_pipeline_allows_cross_major_nvrtc_to_nvjitlink(monkeypatch
     nvrtc_path = _touch(nvrtc_root / "targets" / "x86_64-linux" / "lib" / "libnvrtc.so.12")
     nvjitlink_path = _touch(nvjitlink_root / "targets" / "x86_64-linux" / "lib" / "libnvJitLink.so.13")
 
-    def fake_load_nvidia_dynamic_lib(libname: str) -> LoadedDL:
-        if libname == "nvrtc":
-            return _loaded_dl(nvrtc_path)
-        if libname == "nvJitLink":
-            return _loaded_dl(nvjitlink_path)
-        raise AssertionError(f"Unexpected libname: {libname!r}")
-
-    monkeypatch.setattr(compatibility_module, "_load_nvidia_dynamic_lib", fake_load_nvidia_dynamic_lib)
+    _patch_dynamic_lib_loader(
+        monkeypatch,
+        nvrtc=_loaded_dl(nvrtc_path),
+        nvJitLink=_loaded_dl(nvjitlink_path),
+    )
 
     guard_rails = CompatibilityGuardRails(driver_cuda_version=_driver_cuda_version(13000))
     loaded_nvrtc = guard_rails.load_nvidia_dynamic_lib("nvrtc")
     loaded_nvjitlink = guard_rails.load_nvidia_dynamic_lib("nvJitLink")
     guard_rails._declare_dynamic_lib_pipeline(
         producer_libname="nvrtc",
         consumer_libname="nvJitLink",
-        artifact_kind="ptx",
+        artifact_kind=artifact_kind,
     )
 
     assert loaded_nvrtc.abs_path == nvrtc_path
@@ -755,14 +674,11 @@ def test_declared_nvvm_pipeline_remains_conservative(monkeypatch, tmp_path):
     nvvm_path = _touch(nvvm_root / "nvvm" / "lib64" / "libnvvm.so.4")
     nvjitlink_path = _touch(nvjitlink_root / "targets" / "x86_64-linux" / "lib" / "libnvJitLink.so.12")
 
-    def fake_load_nvidia_dynamic_lib(libname: str) -> LoadedDL:
-        if libname == "nvvm":
-            return _loaded_dl(nvvm_path)
-        if libname == "nvJitLink":
-            return _loaded_dl(nvjitlink_path)
-        raise AssertionError(f"Unexpected libname: {libname!r}")
-
-    monkeypatch.setattr(compatibility_module, "_load_nvidia_dynamic_lib", fake_load_nvidia_dynamic_lib)
+    _patch_dynamic_lib_loader(
+        monkeypatch,
+        nvvm=_loaded_dl(nvvm_path),
+        nvJitLink=_loaded_dl(nvjitlink_path),
+    )
 
     guard_rails = CompatibilityGuardRails(driver_cuda_version=_driver_cuda_version(13000))
     guard_rails.load_nvidia_dynamic_lib("nvvm")
@@ -849,14 +765,11 @@ def test_driver_libs_do_not_lock_ctk_anchor(monkeypatch, tmp_path):
     _write_cuda_h(ctk_root, "12.9.20250531")
     ctk_lib_path = _touch(ctk_root / "targets" / "x86_64-linux" / "lib" / "libnvrtc.so.12")
 
-    def fake_load_nvidia_dynamic_lib(libname: str) -> LoadedDL:
-        if libname == "nvml":
-            return _loaded_dl(driver_lib_path, found_via="system-search")
-        if libname == "nvrtc":
-            return _loaded_dl(ctk_lib_path)
-        raise AssertionError(f"Unexpected libname: {libname!r}")
-
-    monkeypatch.setattr(compatibility_module, "_load_nvidia_dynamic_lib", fake_load_nvidia_dynamic_lib)
+    _patch_dynamic_lib_loader(
+        monkeypatch,
+        nvml=_loaded_dl(driver_lib_path, found_via="system-search"),
+        nvrtc=_loaded_dl(ctk_lib_path),
+    )
 
     guard_rails = CompatibilityGuardRails(driver_cuda_version=_driver_cuda_version(13000))
 
@@ -878,14 +791,11 @@ def test_driver_libs_do_not_mask_later_ctk_mismatch(monkeypatch, tmp_path):
     hdr_dir = hdr_root / "targets" / "x86_64-linux" / "include"
     _touch(hdr_dir / "nvrtc.h")
 
-    def fake_load_nvidia_dynamic_lib(libname: str) -> LoadedDL:
-        if libname == "nvml":
-            return _loaded_dl(driver_lib_path, found_via="system-search")
-        if libname == "nvrtc":
-            return _loaded_dl(lib_path)
-        raise AssertionError(f"Unexpected libname: {libname!r}")
-
-    monkeypatch.setattr(compatibility_module, "_load_nvidia_dynamic_lib", fake_load_nvidia_dynamic_lib)
+    _patch_dynamic_lib_loader(
+        monkeypatch,
+        nvml=_loaded_dl(driver_lib_path, found_via="system-search"),
+        nvrtc=_loaded_dl(lib_path),
+    )
     monkeypatch.setattr(
         compatibility_module,
         "_locate_nvidia_header_directory",

cuda_pathfinder/tests/test_find_nvidia_binaries.py

@@ -160,38 +160,3 @@ def test_find_binary_without_site_packages_entry(monkeypatch, mocker):
         os.path.join(cuda_home, "bin"),
     ]
     which_mock.assert_called_once_with("nvcc", path=os.pathsep.join(expected_dirs))
-
-
-@pytest.mark.usefixtures("clear_find_binary_cache")
-def test_find_binary_cache_negative_result(monkeypatch, mocker):
-    mocker.patch.object(binary_finder_module, "IS_WINDOWS", new=False)
-    mocker.patch.object(binary_finder_module.supported_nvidia_binaries, "SITE_PACKAGES_BINDIRS", {})
-    mocker.patch.object(binary_finder_module, "find_sub_dirs_all_sitepackages", return_value=[])
-    monkeypatch.delenv("CONDA_PREFIX", raising=False)
-    mocker.patch.object(binary_finder_module, "get_cuda_path_or_home", return_value=None)
-    which_mock = mocker.patch.object(binary_finder_module.shutil, "which", return_value=None)
-
-    first = find_nvidia_binary_utility("nvcc")
-    second = find_nvidia_binary_utility("nvcc")
-
-    assert first is None
-    assert second is None
-    which_mock.assert_called_once_with("nvcc", path="")
-
-
-@pytest.mark.usefixtures("clear_find_binary_cache")
-def test_caching_per_utility():
-    """Verify that different utilities have independent cache entries."""
-    nvdisasm1 = find_nvidia_binary_utility("nvdisasm")
-    nvcc1 = find_nvidia_binary_utility("nvcc")
-    nvdisasm2 = find_nvidia_binary_utility("nvdisasm")
-    nvcc2 = find_nvidia_binary_utility("nvcc")
-
-    # Same utility should return cached result
-    assert nvdisasm1 is nvdisasm2
-    assert nvcc1 is nvcc2
-
-    # Different utilities should have different results (unless at least one of
-    # them is None)
-    if nvdisasm1 is not None and nvcc1 is not None:
-        assert nvdisasm1 != nvcc1

cuda_pathfinder/tests/test_utils_driver_info.py

@@ -102,16 +102,6 @@ def test_driver_release_version_from_text_parses_branch():
     )
 
 
-def test_query_driver_release_version_returns_parsed_dataclass(monkeypatch):
-    monkeypatch.setattr(driver_info, "_query_driver_release_version_text", lambda: "595.58.03")
-
-    assert driver_info.query_driver_release_version() == driver_info.DriverReleaseVersion(
-        text="595.58.03",
-        components=(595, 58, 3),
-        branch=595,
-    )
-
-
 def test_query_driver_release_version_wraps_internal_failures(monkeypatch):
     root_cause = RuntimeError("low-level release query failed")
 
@@ -186,16 +176,6 @@ def fake_windll(abs_path: str):
     assert loaded_paths == [r"C:\Windows\System32\nvcuda.dll"]
 
 
-def test_query_driver_cuda_version_returns_parsed_dataclass(monkeypatch):
-    monkeypatch.setattr(driver_info, "_query_driver_cuda_version_int", lambda: 12080)
-
-    assert driver_info.query_driver_cuda_version() == driver_info.DriverCudaVersion(
-        encoded=12080,
-        major=12,
-        minor=8,
-    )
-
-
 def test_driver_cuda_version_from_encoded_returns_subclass_instance():
     version = driver_info.DriverCudaVersion.from_encoded(12080)