Gate checkout-only tests with a root fixture (isaac-sim#7389)

# Description

A handful of unit tests inspect repository artifacts that only exist in
a source checkout (`apps`, `scripts`, the root `pyproject.toml`,
`uv.lock`, `tools/wheel_builder`, and the workflow files). Run from an
installed package they fail because those paths are absent. This gates
them behind a shared `source_checkout_root` session fixture that locates
the checkout and skips the test when it is not present, and returns the
root path so the tests stop recomputing it by hand.

The fixture lives in `source/isaaclab/test/conftest.py`. The affected
tests now take `source_checkout_root` and drop their local
`_repo_root()` helpers, so the gating is explicit at the test and the
requirement is hard to forget: a checkout-only test needs the root
anyway, so it asks for the fixture and gets the skip for free.

## Type of change

- Bug fix (non-breaking change which fixes an issue)

## Release backport

- [x] <!-- backport-active-release --> Backport this pull request to the
active release branch after it merges into `develop`

## Checklist

- [x] I have read and understood the contribution guidelines
- [x] I have run the `pre-commit` checks with `./isaaclab.sh --format`
- [x] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [x] I have added tests that prove my fix is effective or that my
feature works
- [x] I have added a changelog fragment under
`source/<pkg>/changelog.d/` for every touched package
- [ ] I have added my name to the `CONTRIBUTORS.md` or my name already
exists there

Author: diegoferigo-rai

source/isaaclab/changelog.d/skip-checkout-only-unit-tests.skip

@@ -0,0 +1 @@
+Test-only: added a source checkout root fixture for tests that inspect repository artifacts.

source/isaaclab/test/app/test_experience_files.py

@@ -12,19 +12,17 @@
 
 pytestmark = pytest.mark.unit
 
-APPS_DIR = Path(__file__).resolve().parents[4] / "apps"
-
 # ``.kit`` files repeat section headers, so they cannot be parsed as TOML.
 _SECTION_RE = re.compile(r"^\s*\[+(?P<name>[^\[\]]+)\]+\s*$")
 _DEPENDENCY_RE = re.compile(r'^\s*"(?P<name>[^"]+)"\s*=')
 
 
-def _kit_dependencies(experience: str) -> set[str]:
+def _kit_dependencies(apps_dir: Path, experience: str) -> set[str]:
     """Collect the extension names declared in an experience file's dependency sections."""
     dependencies: set[str] = set()
     in_dependencies = False
 
-    for line in (APPS_DIR / experience).read_text(encoding="utf-8").splitlines():
+    for line in (apps_dir / experience).read_text(encoding="utf-8").splitlines():
         section = _SECTION_RE.match(line)
         if section is not None:
             in_dependencies = section.group("name").strip() == "dependencies"
@@ -38,9 +36,9 @@ def _kit_dependencies(experience: str) -> set[str]:
 
 
 @pytest.mark.parametrize("experience", ["isaaclab.python.kit", "isaaclab.python.headless.kit"])
-def test_base_experiences_enable_native_storage(experience: str):
+def test_base_experiences_enable_native_storage(source_checkout_root: Path, experience: str):
     """Test the base experiences load the extension that applies ``ISAACSIM_ASSET_ROOT``."""
-    assert "isaacsim.storage.native" in _kit_dependencies(experience)
+    assert "isaacsim.storage.native" in _kit_dependencies(source_checkout_root / "apps", experience)
 
 
 @pytest.mark.parametrize(
@@ -52,6 +50,6 @@ def test_base_experiences_enable_native_storage(experience: str):
         ("isaaclab.python.xr.openxr.headless.kit", "isaaclab.python.xr.openxr"),
     ],
 )
-def test_derived_experiences_inherit_native_storage(experience: str, base: str):
+def test_derived_experiences_inherit_native_storage(source_checkout_root: Path, experience: str, base: str):
     """Test the derived experiences inherit native storage from a base experience."""
-    assert base in _kit_dependencies(experience)
+    assert base in _kit_dependencies(source_checkout_root / "apps", experience)

source/isaaclab/test/cli/test_install.py

@@ -476,11 +476,12 @@ class TestPinkIkStack:
     stack from there instead of mirroring the versions.
     """
 
-    def test_stack_derived_from_root_pyproject_pins(self):
+    def test_stack_derived_from_root_pyproject_pins(self, source_checkout_root: Path):
         """The derived stack covers every stack package, exactly pinned, markers stripped."""
         from isaaclab.cli.commands import install
 
-        stack = install._pink_ik_stack()
+        with mock.patch.object(install, "ISAACLAB_ROOT", source_checkout_root):
+            stack = install._pink_ik_stack()
         assert [install._requirement_name(r) for r in stack] == list(install._PINK_IK_PACKAGES)
         assert any(r.startswith("pin-pink==") for r in stack), "pin-pink must stay exactly pinned"
         assert any(r.startswith("daqp==") for r in stack), "daqp must stay exactly pinned"

source/isaaclab/test/cli/test_source_package_metadata.py

@@ -15,22 +15,14 @@
 pytestmark = pytest.mark.unit
 
 
-def _repo_root() -> Path:
-    """Find the Isaac Lab repository root from this test file."""
-    for parent in Path(__file__).resolve().parents:
-        if (parent / "pyproject.toml").is_file() and (parent / "source").is_dir():
-            return parent
-    raise RuntimeError("Could not find Isaac Lab repository root.")
-
-
-def test_isaaclab_uses_one_standalone_usd_provider():
+def test_isaaclab_uses_one_standalone_usd_provider(source_checkout_root: Path):
     """Isaac Lab must install only the USD provider shared with its importer dependencies.
 
     ``usd-core`` and ``usd-exchange`` each install a complete ``pxr`` into the same directory, so
     a second provider silently overwrites the first and removing either one leaves ``pxr`` broken.
     Nothing detects that, because the two are separate distributions.
     """
-    with (_repo_root() / "pyproject.toml").open("rb") as f:
+    with (source_checkout_root / "pyproject.toml").open("rb") as f:
         pyproject = tomllib.load(f)
 
     dependencies = pyproject["project"]["dependencies"]
@@ -43,14 +35,14 @@ def test_isaaclab_uses_one_standalone_usd_provider():
     assert usd_providers == ["usd-exchange==2.3.0"]
 
 
-def test_resolved_environment_has_no_second_usd_provider():
+def test_resolved_environment_has_no_second_usd_provider(source_checkout_root: Path):
     """No dependency may pull ``usd-core`` back in behind an extra.
 
     ``newton[importers]``, ``mujoco[usd]`` and ``warp-lang[examples]`` all require it, so selecting
     any of them would reinstate the overlap that the direct dependencies avoid. Checking the lock
     catches that, where checking ``pyproject.toml`` alone would not.
     """
-    with (_repo_root() / "uv.lock").open("rb") as f:
+    with (source_checkout_root / "uv.lock").open("rb") as f:
         lock = tomllib.load(f)
 
     locked = {package["name"] for package in lock["package"]}
@@ -59,9 +51,9 @@ def test_resolved_environment_has_no_second_usd_provider():
     assert "usd-exchange" in locked
 
 
-def test_standalone_importers_are_opt_in():
+def test_standalone_importers_are_opt_in(source_checkout_root: Path):
     """Standalone URDF/MJCF importers must not constrain the base environment."""
-    with (_repo_root() / "pyproject.toml").open("rb") as f:
+    with (source_checkout_root / "pyproject.toml").open("rb") as f:
         pyproject = tomllib.load(f)
 
     project = pyproject["project"]

source/isaaclab/test/cli/test_teleop_entrypoints.py

@@ -47,7 +47,7 @@ def test_teleop_workflow_help_exposes_task_preset_selectors(command, script_part
 
 
 @pytest.mark.parametrize(("command", "script_parts"), TELEOP_WORKFLOWS.items())
-def test_teleop_dispatches_to_an_existing_script(command, script_parts):
+def test_teleop_dispatches_to_an_existing_script(source_checkout_root: Path, command, script_parts):
     """``isaaclab teleop`` forwards the remaining arguments to a script that exists."""
     args = [command, "--task", "IsaacContrib-PickPlace-Locomanipulation-G1-Abs", "--xr"]
 
@@ -57,7 +57,7 @@ def test_teleop_dispatches_to_an_existing_script(command, script_parts):
     ):
         cli.cli()
 
-    script = cli.ISAACLAB_ROOT.joinpath(*script_parts)
+    script = source_checkout_root.joinpath(*script_parts)
     run_python.assert_called_once_with(script, args[1:], check=True)
     assert script.is_file()
 
@@ -73,21 +73,21 @@ def _requirement_names(requirements: list[str]) -> set[str]:
 
 
 @pytest.mark.parametrize(("command", "script_parts"), TELEOP_WORKFLOWS.items())
-def test_teleop_workflow_isaaclab_imports_are_covered_by_the_extras(command, script_parts):
+def test_teleop_workflow_isaaclab_imports_are_covered_by_the_extras(source_checkout_root: Path, command, script_parts):
     """Every ``isaaclab_*`` package a teleop script imports must ship with the extras.
 
     ``record_demos.py`` imports ``isaaclab_mimic`` at module level, so an environment built
     from ``--extra teleop`` alone used to die with ``ModuleNotFoundError`` only after Isaac Sim
     had finished booting. This catches that class of gap without needing an install.
     """
-    with (cli.ISAACLAB_ROOT / "pyproject.toml").open("rb") as f:
+    with (source_checkout_root / "pyproject.toml").open("rb") as f:
         pyproject = tomllib.load(f)
     project = pyproject["project"]
 
     available = _requirement_names(project["dependencies"])
     available |= _requirement_names(project["optional-dependencies"]["teleop"])
 
-    source = Path(cli.ISAACLAB_ROOT).joinpath(*script_parts).read_text(encoding="utf-8")
+    source = source_checkout_root.joinpath(*script_parts).read_text(encoding="utf-8")
     imported = set(re.findall(r"^\s*(?:import|from)\s+(isaaclab_\w+)", source, re.MULTILINE))
 
     missing = imported - available

source/isaaclab/test/cli/test_uv_run_pyproject.py

@@ -16,34 +16,26 @@
 pytestmark = pytest.mark.unit
 
 
-def _repo_root() -> Path:
-    """Find the Isaac Lab repository root from this test file."""
-    for parent in Path(__file__).resolve().parents:
-        if (parent / "pyproject.toml").is_file() and (parent / "source").is_dir():
-            return parent
-    raise RuntimeError("Could not find Isaac Lab repository root.")
-
-
-def _root_pyproject() -> dict:
+def _root_pyproject(source_checkout_root: Path) -> dict:
     """Load the root development ``pyproject.toml``."""
-    with (_repo_root() / "pyproject.toml").open("rb") as f:
+    with (source_checkout_root / "pyproject.toml").open("rb") as f:
         return tomllib.load(f)
 
 
-def test_uv_run_extra_names_match_documented_workflow():
+def test_uv_run_extra_names_match_documented_workflow(source_checkout_root: Path):
     """Docs must only reference ``uv run --extra`` names that pyproject defines."""
-    repo_root = _repo_root()
+    repo_root = source_checkout_root
     docs = (repo_root / "docs/source/setup/installation/index.rst").read_text(encoding="utf-8")
     documented_extras = set(re.findall(r"--extra\s+([A-Za-z0-9_-]+)", docs))
-    optional_dependencies = _root_pyproject()["project"]["optional-dependencies"]
+    optional_dependencies = _root_pyproject(source_checkout_root)["project"]["optional-dependencies"]
 
     assert documented_extras
     assert documented_extras <= set(optional_dependencies)
 
 
-def test_uv_run_exposes_centralized_feature_extras():
+def test_uv_run_exposes_centralized_feature_extras(source_checkout_root: Path):
     """The root project centralizes optional third-party deps into named extras."""
-    optional_dependencies = _root_pyproject()["project"]["optional-dependencies"]
+    optional_dependencies = _root_pyproject(source_checkout_root)["project"]["optional-dependencies"]
 
     # Feature extras a user can activate with ``uv run --extra``.
     expected_extras = {
@@ -84,9 +76,9 @@ def test_uv_run_exposes_centralized_feature_extras():
     assert any(dep.startswith("ovstage") for dep in optional_dependencies["ovrtx"])
 
 
-def test_all_extra_aggregates_curated_ov_rl_and_visualizer_extras():
+def test_all_extra_aggregates_curated_ov_rl_and_visualizer_extras(source_checkout_root: Path):
     """``all`` aggregates only the curated OV, RL, and visualizer extras."""
-    optional = _root_pyproject()["project"]["optional-dependencies"]
+    optional = _root_pyproject(source_checkout_root)["project"]["optional-dependencies"]
 
     assert len(optional["all"]) == 1
     aggregated = set(re.fullmatch(r"isaaclab-dev\[(.+)\]", optional["all"][0]).group(1).split(","))
@@ -108,9 +100,9 @@ def test_all_extra_aggregates_curated_ov_rl_and_visualizer_extras():
     }
 
 
-def test_tetrahedralization_is_explicit_extra_only():
+def test_tetrahedralization_is_explicit_extra_only(source_checkout_root: Path):
     """TetWild and its visualization stack are installed only when requested."""
-    project = _root_pyproject()["project"]
+    project = _root_pyproject(source_checkout_root)["project"]
     optional = project["optional-dependencies"]
 
     assert not any(dep.startswith("pytetwild") for dep in project["dependencies"])
@@ -122,14 +114,14 @@ def test_tetrahedralization_is_explicit_extra_only():
         assert not any("tetrahedralization" in dep or dep.startswith("pytetwild") for dep in deps)
 
 
-def test_version_single_source_matches_literal_pins():
+def test_version_single_source_matches_literal_pins(source_checkout_root: Path):
     """``[tool.isaaclab.versions]`` is the single source for externally-pinned versions.
 
     TOML cannot interpolate, so the literal pins in ``[project.dependencies]``,
     ``[project.optional-dependencies]``, and ``[tool.uv].override-dependencies`` must
     mirror the table exactly. This test fails if any of them drift apart.
     """
-    pyproject = _root_pyproject()
+    pyproject = _root_pyproject(source_checkout_root)
     versions = pyproject["tool"]["isaaclab"]["versions"]
     dependencies = pyproject["project"]["dependencies"]
     optional = pyproject["project"]["optional-dependencies"]
@@ -156,7 +148,7 @@ def spec(package: str) -> str:
     # ovrtx`` ignores this ceiling). Each such install must therefore be pinned:
     # either by carrying the literal range, or by referencing the ``resolve-ov-pins``
     # action output, which reads the pin from this same table. Never a bare ``ovrtx``.
-    build_workflow = (_repo_root() / ".github/workflows/build.yaml").read_text(encoding="utf-8")
+    build_workflow = (source_checkout_root / ".github/workflows/build.yaml").read_text(encoding="utf-8")
     assert "ovphysx==0.4.13" not in build_workflow
     ovrtx_install_lines = [
         line.strip() for line in build_workflow.splitlines() if "extra-pip-packages:" in line and "ovrtx" in line
@@ -179,9 +171,9 @@ def spec(package: str) -> str:
     assert warp_spec in dependencies
 
 
-def test_public_ov_packages_use_public_pypi_index():
+def test_public_ov_packages_use_public_pypi_index(source_checkout_root: Path):
     """Public OV packages must not resolve from the NVIDIA package index."""
-    pyproject = _root_pyproject()
+    pyproject = _root_pyproject(source_checkout_root)
     indexes = {index.get("name"): index for index in pyproject["tool"]["uv"]["index"]}
     sources = pyproject["tool"]["uv"]["sources"]
 
@@ -194,7 +186,7 @@ def test_public_ov_packages_use_public_pypi_index():
         assert sources[package] == {"index": "pypi-public"}
 
 
-def test_uv_run_declares_no_extra_conflicts():
+def test_uv_run_declares_no_extra_conflicts(source_checkout_root: Path):
     """No extra is forked: every combination resolves into a single environment.
 
     ``[tool.uv].conflicts`` used to fork ``isaacsim`` / ``teleop`` away from the OV runtimes,
@@ -203,21 +195,21 @@ def test_uv_run_declares_no_extra_conflicts():
     importers install beside Isaac Sim without displacing it: the two distributions share no
     files, and Kit serves ``isaacsim.asset`` from its extension roots either way.
     """
-    tool_uv = _root_pyproject()["tool"]["uv"]
+    tool_uv = _root_pyproject(source_checkout_root)["tool"]["uv"]
 
     assert "conflicts" not in tool_uv
     for override in ("packaging>=20,<27", "websockets>=14.0,<17.0.0", "coverage>=7.6.1"):
         assert override in tool_uv["override-dependencies"]
 
 
-def test_uv_run_isaacsim_is_an_opt_in_extra():
+def test_uv_run_isaacsim_is_an_opt_in_extra(source_checkout_root: Path):
     """Isaac Sim is never a base dependency, but it is a real workspace extra.
 
     PhysX/Isaac Sim must stay out of ``[project.dependencies]`` so the bare ``uv run``
     keeps working without Kit, while still being an ``optional-dependencies`` entry so
     ``uv run --extra isaacsim`` resolves.
     """
-    pyproject = _root_pyproject()
+    pyproject = _root_pyproject(source_checkout_root)
     project = pyproject["project"]
     base_dependency_names = {re.split(r"[\s<>=!~\[;]", dep, maxsplit=1)[0] for dep in project["dependencies"]}
 
@@ -230,14 +222,14 @@ def test_uv_run_isaacsim_is_an_opt_in_extra():
     assert "wheel-extras" not in pyproject.get("tool", {}).get("isaaclab", {})
 
 
-def test_uv_run_teleop_extra_excludes_isaacsim():
+def test_uv_run_teleop_extra_excludes_isaacsim(source_checkout_root: Path):
     """``teleop`` carries the teleop stack only; Isaac Sim stays its own extra.
 
     XR teleop needs the Kit XR runtime, but environments that already provide Kit (the
     container images) must not install a second copy of it. Users who need the wheel run
     ``--extra teleop,isaacsim``.
     """
-    optional_dependencies = _root_pyproject()["project"]["optional-dependencies"]
+    optional_dependencies = _root_pyproject(source_checkout_root)["project"]["optional-dependencies"]
     teleop = optional_dependencies["teleop"]
 
     assert not any(dep.startswith("isaacsim") for dep in teleop)
@@ -247,18 +239,18 @@ def test_uv_run_teleop_extra_excludes_isaacsim():
     assert not any(dep.startswith("robomimic") for dep in teleop)
 
 
-def test_uv_run_base_dependencies_cover_newton_rsl_rl_training():
+def test_uv_run_base_dependencies_cover_newton_rsl_rl_training(source_checkout_root: Path):
     """The documented bare ``uv run isaaclab train`` command needs Newton and RSL-RL in core."""
-    dependencies = _root_pyproject()["project"]["dependencies"]
+    dependencies = _root_pyproject(source_checkout_root)["project"]["dependencies"]
 
     # Newton is the default physics engine and RSL-RL the default training library,
     # so both ship as core third-party requirements (not opt-in extras).
     assert any(dep.startswith("newton[sim]") for dep in dependencies)
     assert any(dep.startswith("rsl-rl-lib") for dep in dependencies)
 
 
-def test_uv_run_uses_managed_python():
+def test_uv_run_uses_managed_python(source_checkout_root: Path):
     """Avoid building the project venv from conda Python and its older C++ runtime."""
-    tool_uv = _root_pyproject()["tool"]["uv"]
+    tool_uv = _root_pyproject(source_checkout_root)["tool"]["uv"]
 
     assert tool_uv["python-preference"] == "only-managed"