relenv 0.21.2__py3-none-any.whl → 0.22.1__py3-none-any.whl

tests/test_relocate.py

@@ -1,8 +1,9 @@
 # Copyright 2022-2025 Broadcom.
-# SPDX-License-Identifier: Apache-2
+# SPDX-License-Identifier: Apache-2.0
 import pathlib
 import shutil
 from textwrap import dedent
+from typing import Any
 from unittest.mock import MagicMock, call, patch
 
 import pytest
@@ -23,103 +24,108 @@ pytestmark = [
 
 
 class BaseProject:
-    def __init__(self, root_dir):
+    def __init__(self, root_dir: pathlib.Path) -> None:
         self.root_dir = root_dir
         self.libs_dir = self.root_dir / "lib"
 
-    def make_project(self):
+    def make_project(self) -> None:
         self.root_dir.mkdir(parents=True, exist_ok=True)
         self.libs_dir.mkdir(parents=True, exist_ok=True)
 
-    def destroy_project(self):
+    def destroy_project(self) -> None:
         # Make sure the project is torn down properly
-        if pathlib.Path(self.root_dir).exists():
+        if self.root_dir.exists():
             shutil.rmtree(self.root_dir, ignore_errors=True)
 
-    def add_file(self, name, contents, *relpath, binary=False):
+    def add_file(
+        self,
+        name: str,
+        contents: bytes | str,
+        *relpath: str,
+        binary: bool = False,
+    ) -> pathlib.Path:
         file_path = (self.root_dir / pathlib.Path(*relpath) / name).resolve()
         file_path.parent.mkdir(parents=True, exist_ok=True)
         if binary:
-            file_path.write_bytes(contents)
+            data = contents if isinstance(contents, bytes) else contents.encode()
+            file_path.write_bytes(data)
         else:
-            file_path.write_text(contents)
+            text = contents.decode() if isinstance(contents, bytes) else contents
+            file_path.write_text(text)
         return file_path
 
-    def __enter__(self):
+    def __enter__(self) -> "BaseProject":
         self.make_project()
         return self
 
-    def __exit__(self, *exc):
+    def __exit__(self, exc_type: Any, exc: Any, tb: Any) -> None:
         self.destroy_project()
 
 
 class LinuxProject(BaseProject):
-    def add_simple_elf(self, name, *relpath):
+    def add_simple_elf(self, name: str, *relpath: str) -> pathlib.Path:
         return self.add_file(name, b"\x7f\x45\x4c\x46", *relpath, binary=True)
 
 
-def test_is_macho_true(tmp_path):
+def test_is_macho_true(tmp_path: pathlib.Path) -> None:
     lib_path = tmp_path / "test.dylib"
     lib_path.write_bytes(b"\xcf\xfa\xed\xfe")
     assert is_macho(lib_path) is True
 
 
-def test_is_macho_false(tmp_path):
+def test_is_macho_false(tmp_path: pathlib.Path) -> None:
     lib_path = tmp_path / "test.dylib"
     lib_path.write_bytes(b"\xcf\xfa\xed\xfa")
     assert is_macho(lib_path) is False
 
 
-def test_is_macho_not_a_file(tmp_path):
+def test_is_macho_not_a_file(tmp_path: pathlib.Path) -> None:
     with pytest.raises(IsADirectoryError):
         assert is_macho(tmp_path) is False
 
 
-def test_is_macho_file_does_not_exist(tmp_path):
+def test_is_macho_file_does_not_exist(tmp_path: pathlib.Path) -> None:
     lib_path = tmp_path / "test.dylib"
     with pytest.raises(FileNotFoundError):
         assert is_macho(lib_path) is False
 
 
-def test_is_elf_true(tmp_path):
+def test_is_elf_true(tmp_path: pathlib.Path) -> None:
     lib_path = tmp_path / "test.so"
     lib_path.write_bytes(b"\x7f\x45\x4c\x46")
     assert is_elf(lib_path) is True
 
 
-def test_is_elf_false(tmp_path):
+def test_is_elf_false(tmp_path: pathlib.Path) -> None:
     lib_path = tmp_path / "test.so"
     lib_path.write_bytes(b"\xcf\xfa\xed\xfa")
     assert is_elf(lib_path) is False
 
 
-def test_is_elf_not_a_file(tmp_path):
+def test_is_elf_not_a_file(tmp_path: pathlib.Path) -> None:
     with pytest.raises(IsADirectoryError):
         assert is_elf(tmp_path) is False
 
 
-def test_is_elf_file_does_not_exist(tmp_path):
+def test_is_elf_file_does_not_exist(tmp_path: pathlib.Path) -> None:
     lib_path = tmp_path / "test.so"
     with pytest.raises(FileNotFoundError):
         assert is_elf(lib_path) is False
 
 
-def test_parse_otool_l():
-    # XXX
-    pass
+def test_parse_otool_l() -> None:
+    pytest.skip("Not implemented")
 
 
-def test_parse_macho():
-    # XXX
-    pass
+def test_parse_macho() -> None:
+    pytest.skip("Not implemented")
 
 
-def test_handle_macho():
-    # XXX
-    pass
+def test_handle_macho() -> None:
+    pytest.skip("Not implemented")
 
 
-def test_parse_readelf_d_no_rpath():
+def test_parse_readelf_d_no_rpath() -> None:
     section = dedent(
         """
     Dynamic section at offset 0xbdd40 contains 28 entries:
@@ -134,7 +140,7 @@ def test_parse_readelf_d_no_rpath():
     assert parse_readelf_d(section) == []
 
 
-def test_parse_readelf_d_rpath():
+def test_parse_readelf_d_rpath() -> None:
     section = dedent(
         """
     Dynamic section at offset 0x58000 contains 27 entries:
@@ -149,19 +155,19 @@ def test_parse_readelf_d_rpath():
     assert parse_readelf_d(section) == ["$ORIGIN/../.."]
 
 
-def test_is_in_dir(tmp_path):
+def test_is_in_dir(tmp_path: pathlib.Path) -> None:
     parent = tmp_path / "foo"
     child = tmp_path / "foo" / "bar" / "bang"
     assert is_in_dir(child, parent) is True
 
 
-def test_is_in_dir_false(tmp_path):
+def test_is_in_dir_false(tmp_path: pathlib.Path) -> None:
     parent = tmp_path / "foo"
     child = tmp_path / "bar" / "bang"
     assert is_in_dir(child, parent) is False
 
 
-def test_patch_rpath(tmp_path):
+def test_patch_rpath(tmp_path: pathlib.Path) -> None:
     path = str(tmp_path / "test")
     new_rpath = str(pathlib.Path("$ORIGIN", "..", "..", "lib"))
     with patch("subprocess.run", return_value=MagicMock(returncode=0)):
@@ -172,7 +178,7 @@ def test_patch_rpath(tmp_path):
             assert patch_rpath(path, new_rpath) == new_rpath
 
 
-def test_patch_rpath_failed(tmp_path):
+def test_patch_rpath_failed(tmp_path: pathlib.Path) -> None:
     path = str(tmp_path / "test")
     new_rpath = str(pathlib.Path("$ORIGIN", "..", "..", "lib"))
     with patch("subprocess.run", return_value=MagicMock(returncode=1)):
@@ -183,7 +189,7 @@ def test_patch_rpath_failed(tmp_path):
             assert patch_rpath(path, new_rpath) is False
 
 
-def test_patch_rpath_no_change(tmp_path):
+def test_patch_rpath_no_change(tmp_path: pathlib.Path) -> None:
     path = str(tmp_path / "test")
     new_rpath = str(pathlib.Path("$ORIGIN", "..", "..", "lib"))
     with patch("subprocess.run", return_value=MagicMock(returncode=0)):
@@ -191,7 +197,7 @@ def test_patch_rpath_no_change(tmp_path):
             assert patch_rpath(path, new_rpath, only_relative=False) == new_rpath
 
 
-def test_patch_rpath_remove_non_relative(tmp_path):
+def test_patch_rpath_remove_non_relative(tmp_path: pathlib.Path) -> None:
     path = str(tmp_path / "test")
     new_rpath = str(pathlib.Path("$ORIGIN", "..", "..", "lib"))
     with patch("subprocess.run", return_value=MagicMock(returncode=0)):
@@ -202,7 +208,7 @@ def test_patch_rpath_remove_non_relative(tmp_path):
             assert patch_rpath(path, new_rpath) == new_rpath
 
 
-def test_main_linux(tmp_path):
+def test_main_linux(tmp_path: pathlib.Path) -> None:
     proj = LinuxProject(tmp_path)
     simple = proj.add_simple_elf("simple.so", "foo", "bar")
     simple2 = proj.add_simple_elf("simple2.so", "foo", "bar", "bop")
@@ -218,7 +224,7 @@ def test_main_linux(tmp_path):
             elf_mock.assert_has_calls(calls, any_order=True)
 
 
-def test_handle_elf(tmp_path):
+def test_handle_elf(tmp_path: pathlib.Path) -> None:
     proj = LinuxProject(tmp_path / "proj")
     pybin = proj.add_simple_elf("python", "foo")
     libcrypt = tmp_path / "libcrypt.so.2"
@@ -245,7 +251,7 @@ def test_handle_elf(tmp_path):
                 patch_rpath_mock.assert_called_with(str(pybin), "$ORIGIN/../lib")
 
 
-def test_handle_elf_rpath_only(tmp_path):
+def test_handle_elf_rpath_only(tmp_path: pathlib.Path) -> None:
     proj = LinuxProject(tmp_path / "proj")
     pybin = proj.add_simple_elf("python", "foo")
     libcrypt = proj.libs_dir / "libcrypt.so.2"

tests/test_relocate_module.py

@@ -0,0 +1,257 @@
+# Copyright 2022-2025 Broadcom.
+# SPDX-License-Identifier: Apache-2.0
+#
+from __future__ import annotations
+
+import os
+import pathlib
+import shutil
+import subprocess
+from typing import Dict, List, Tuple
+
+import pytest
+
+from relenv import relocate
+
+
+def test_is_elf_on_text_file(tmp_path: pathlib.Path) -> None:
+    sample = tmp_path / "sample.txt"
+    sample.write_text("not an ELF binary\n")
+    assert relocate.is_elf(sample) is False
+
+
+def test_is_macho_on_text_file(tmp_path: pathlib.Path) -> None:
+    sample = tmp_path / "sample.txt"
+    sample.write_text("plain text\n")
+    assert relocate.is_macho(sample) is False
+
+
+def test_parse_readelf_output() -> None:
+    output = """
+ 0x000000000000000f (NEEDED)             Shared library: [libc.so.6]
+ 0x000000000000001d (RUNPATH)            Library runpath: [/usr/lib:/opt/lib]
+"""
+    result = relocate.parse_readelf_d(output)
+    assert result == ["/usr/lib", "/opt/lib"]
+
+
+def test_parse_otool_output_extracts_rpaths() -> None:
+    sample_output = """
+Load command 0
+      cmd LC_LOAD_DYLIB
+  cmdsize 56
+     name /usr/lib/libSystem.B.dylib (offset 24)
+Load command 1
+      cmd LC_RPATH
+  cmdsize 32
+     path @loader_path/../lib (offset 12)
+"""
+    parsed = relocate.parse_otool_l(sample_output)
+    assert parsed[relocate.LC_LOAD_DYLIB] == ["/usr/lib/libSystem.B.dylib"]
+    assert parsed[relocate.LC_RPATH] == ["@loader_path/../lib"]
+
+
+def test_patch_rpath_adds_new_entry(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    binary = tmp_path / "prog"
+    binary.write_text("dummy")
+
+    monkeypatch.setattr(
+        relocate,
+        "parse_rpath",
+        lambda path: ["$ORIGIN/lib", "/abs/lib"],
+    )
+
+    recorded: Dict[str, List[str]] = {}
+
+    def fake_run(
+        cmd: List[str], **kwargs: object
+    ) -> subprocess.CompletedProcess[bytes]:
+        recorded.setdefault("cmd", []).extend(cmd)
+        return subprocess.CompletedProcess(cmd, 0, stdout=b"", stderr=b"")
+
+    monkeypatch.setattr(relocate.subprocess, "run", fake_run)
+
+    result = relocate.patch_rpath(binary, "$ORIGIN/../lib")
+    assert result == "$ORIGIN/../lib:$ORIGIN/lib"
+    assert pathlib.Path(recorded["cmd"][-1]) == binary
+
+
+def test_patch_rpath_skips_when_present(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    binary = tmp_path / "prog"
+    binary.write_text("dummy")
+
+    monkeypatch.setattr(relocate, "parse_rpath", lambda path: ["$ORIGIN/lib"])
+
+    def fail_run(*_args: object, **_kwargs: object) -> None:
+        raise AssertionError("patchelf should not be invoked")
+
+    monkeypatch.setattr(relocate.subprocess, "run", fail_run)
+
+    result = relocate.patch_rpath(binary, "$ORIGIN/lib")
+    assert result == "$ORIGIN/lib"
+
+
+def test_handle_elf_sets_rpath(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    bin_dir = tmp_path / "bin"
+    lib_dir = tmp_path / "lib"
+    bin_dir.mkdir()
+    lib_dir.mkdir()
+
+    binary = bin_dir / "prog"
+    binary.write_text("binary")
+    resident = lib_dir / "libfoo.so"
+    resident.write_text("library")
+
+    def fake_run(
+        cmd: List[str], **kwargs: object
+    ) -> subprocess.CompletedProcess[bytes]:
+        if cmd[0] == "ldd":
+            stdout = f"libfoo.so => {resident} (0x00007)\nlibc.so.6 => /lib/libc.so.6 (0x00007)\n"
+            return subprocess.CompletedProcess(
+                cmd, 0, stdout=stdout.encode(), stderr=b""
+            )
+        raise AssertionError(f"Unexpected command {cmd}")
+
+    monkeypatch.setattr(relocate.subprocess, "run", fake_run)
+
+    captured: Dict[str, str] = {}
+
+    def fake_patch_rpath(path: str, relpath: str) -> str:
+        captured["path"] = path
+        captured["relpath"] = relpath
+        return relpath
+
+    monkeypatch.setattr(relocate, "patch_rpath", fake_patch_rpath)
+
+    relocate.handle_elf(binary, lib_dir, rpath_only=False, root=lib_dir)
+
+    assert pathlib.Path(captured["path"]) == binary
+    expected_rel = os.path.relpath(lib_dir, bin_dir)
+    if expected_rel == ".":
+        expected_rpath = "$ORIGIN"
+    else:
+        expected_rpath = str(pathlib.Path("$ORIGIN") / expected_rel)
+    assert captured["relpath"] == expected_rpath
+
+
+def test_patch_rpath_failure(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    binary = tmp_path / "prog"
+    binary.write_text("dummy")
+
+    monkeypatch.setattr(relocate, "parse_rpath", lambda path: [])
+
+    def fake_run(
+        cmd: List[str], **kwargs: object
+    ) -> subprocess.CompletedProcess[bytes]:
+        return subprocess.CompletedProcess(cmd, 1, stdout=b"", stderr=b"err")
+
+    monkeypatch.setattr(relocate.subprocess, "run", fake_run)
+
+    assert relocate.patch_rpath(binary, "$ORIGIN/lib") is False
+
+
+def test_parse_macho_non_object(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    output = "foo: is not an object file\n"
+    monkeypatch.setattr(
+        relocate.subprocess,
+        "run",
+        lambda cmd, **kwargs: subprocess.CompletedProcess(
+            cmd, 0, stdout=output.encode(), stderr=b""
+        ),
+    )
+    assert relocate.parse_macho(tmp_path / "lib.dylib") is None
+
+
+def test_handle_macho_copies_when_needed(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    binary = tmp_path / "bin" / "prog"
+    binary.parent.mkdir()
+    binary.write_text("exe")
+    source_lib = tmp_path / "src" / "libfoo.dylib"
+    source_lib.parent.mkdir()
+    source_lib.write_text("binary")
+    root_dir = tmp_path / "root"
+    root_dir.mkdir()
+
+    monkeypatch.setattr(
+        relocate,
+        "parse_macho",
+        lambda path: {relocate.LC_LOAD_DYLIB: [str(source_lib)]},
+    )
+
+    monkeypatch.setattr(os.path, "exists", lambda path: path == str(source_lib))
+
+    copied: Dict[str, Tuple[str, str]] = {}
+
+    monkeypatch.setattr(
+        shutil, "copy", lambda src, dst: copied.setdefault("copy", (src, dst))
+    )
+    monkeypatch.setattr(
+        shutil, "copymode", lambda src, dst: copied.setdefault("copymode", (src, dst))
+    )
+
+    recorded: Dict[str, List[str]] = {}
+
+    def fake_run(
+        cmd: List[str], **kwargs: object
+    ) -> subprocess.CompletedProcess[bytes]:
+        recorded.setdefault("cmd", []).extend(cmd)
+        return subprocess.CompletedProcess(cmd, 0, stdout=b"", stderr=b"")
+
+    monkeypatch.setattr(relocate.subprocess, "run", fake_run)
+
+    relocate.handle_macho(str(binary), str(root_dir), rpath_only=False)
+
+    assert copied["copy"][0] == str(source_lib)
+    assert pathlib.Path(copied["copy"][1]).name == source_lib.name
+    assert recorded["cmd"][0] == "install_name_tool"
+
+
+def test_handle_macho_rpath_only(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    binary = tmp_path / "bin" / "prog"
+    binary.parent.mkdir()
+    binary.write_text("exe")
+    source_lib = tmp_path / "src" / "libfoo.dylib"
+    source_lib.parent.mkdir()
+    source_lib.write_text("binary")
+    root_dir = tmp_path / "root"
+    root_dir.mkdir()
+
+    monkeypatch.setattr(
+        relocate,
+        "parse_macho",
+        lambda path: {relocate.LC_LOAD_DYLIB: [str(source_lib)]},
+    )
+
+    monkeypatch.setattr(
+        os.path,
+        "exists",
+        lambda path: path == str(source_lib),
+    )
+
+    monkeypatch.setattr(shutil, "copy", lambda *_args, **_kw: (_args, _kw))
+    monkeypatch.setattr(shutil, "copymode", lambda *_args, **_kw: (_args, _kw))
+
+    def fake_run(
+        cmd: List[str], **kwargs: object
+    ) -> subprocess.CompletedProcess[bytes]:
+        if cmd[0] == "install_name_tool":
+            raise AssertionError("install_name_tool should not run in rpath_only mode")
+        return subprocess.CompletedProcess(cmd, 0, stdout=b"", stderr=b"")
+
+    monkeypatch.setattr(relocate.subprocess, "run", fake_run)
+
+    relocate.handle_macho(str(binary), str(root_dir), rpath_only=True)