chipwright 0.2.0__py3-none-any.whl

chipwright/tests/test_cache.py

@@ -0,0 +1,147 @@
+"""Content-addressed cache — sharded paths, hash of a file, membership, and fetch verification.
+
+No network: the one fetch test replaces urllib.request.urlretrieve with a local writer. CACHE_DIR is
+redirected to a temp dir so the real ~/.cache/chipwright is never touched. Runnable as
+`python3 test_cache.py`.
+"""
+import hashlib
+import os
+import sys
+import tempfile
+import urllib.request
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from chipwright import cache
+
+# a valid-looking sha256 (64 hex chars) that nothing in the cache will match
+_RANDOM_SHA = "0" * 63 + "1"
+
+
+def test_path_for_is_content_addressed_and_sharded():
+    sha = "ab" + "c" * 62
+    p = cache.path_for(sha)
+    # sharded by the first two chars, then the full digest as the filename
+    assert os.path.basename(p) == sha
+    assert os.path.basename(os.path.dirname(p)) == "ab"
+    assert os.path.dirname(os.path.dirname(p)).endswith(os.path.join("blobs"))
+    # same input -> same path (deterministic, no randomness)
+    assert cache.path_for(sha) == p
+
+
+def test_sha256_matches_hashlib():
+    payload = b"chipwright content-addressed blob \x00\x01\x02"
+    with tempfile.NamedTemporaryFile(delete=False) as f:
+        f.write(payload)
+        tmp = f.name
+    try:
+        assert cache._sha256(tmp) == hashlib.sha256(payload).hexdigest()
+    finally:
+        os.remove(tmp)
+
+
+def test_have_false_for_random_hash():
+    with _temp_cache():
+        assert cache.have(_RANDOM_SHA) is False
+
+
+def test_fetch_with_wrong_sha_raises_and_leaves_no_file():
+    payload = b"the actual downloaded bytes"
+    wrong_sha = "f" * 64  # deliberately not the sha of `payload`
+    assert hashlib.sha256(payload).hexdigest() != wrong_sha
+
+    def _fake_urlretrieve(url, filename):
+        with open(filename, "wb") as fh:
+            fh.write(payload)
+        return filename, None
+
+    with _temp_cache():
+        orig = urllib.request.urlretrieve
+        urllib.request.urlretrieve = _fake_urlretrieve
+        try:
+            raised = False
+            try:
+                cache.fetch("http://example.invalid/blob", wrong_sha)
+            except RuntimeError as e:
+                raised = True
+                assert "mismatch" in str(e)
+            assert raised, "expected RuntimeError on sha mismatch"
+            dst = cache.path_for(wrong_sha)
+            # neither the final blob nor the .part temp survives a failed verify
+            assert not os.path.exists(dst)
+            assert not os.path.exists(dst + ".part")
+        finally:
+            urllib.request.urlretrieve = orig
+
+
+def test_fetch_with_correct_sha_stores_and_is_have():
+    payload = b"a correctly-hashed blob"
+    good_sha = hashlib.sha256(payload).hexdigest()
+
+    def _fake_urlretrieve(url, filename):
+        with open(filename, "wb") as fh:
+            fh.write(payload)
+        return filename, None
+
+    with _temp_cache():
+        orig = urllib.request.urlretrieve
+        urllib.request.urlretrieve = _fake_urlretrieve
+        try:
+            path = cache.fetch("http://example.invalid/blob", good_sha)
+            assert path == cache.path_for(good_sha)
+            assert os.path.exists(path)
+            assert cache.have(good_sha) is True
+            # a second fetch is a cache hit (no re-download needed)
+            assert cache.fetch("http://example.invalid/blob", good_sha) == path
+        finally:
+            urllib.request.urlretrieve = orig
+
+
+def test_fetch_named_keeps_filename_and_fetches_sidecar():
+    """A run reference fetches with its ORIGINAL filename (so an ONNX's `.data` sidecar resolves), and
+    declared sidecars land in the same dir."""
+    onnx = b"onnx graph bytes (external-data)"
+    data = b"the external weight data"
+    onnx_sha = hashlib.sha256(onnx).hexdigest()
+    data_sha = hashlib.sha256(data).hexdigest()
+    payloads = {"http://x/m.onnx": onnx, "http://x/m.data": data}
+
+    def _fake(url, filename):
+        with open(filename, "wb") as fh:
+            fh.write(payloads[url])
+        return filename, None
+
+    with _temp_cache():
+        orig = urllib.request.urlretrieve
+        urllib.request.urlretrieve = _fake
+        try:
+            p = cache.fetch_named("http://x/m.onnx", onnx_sha, "m.onnx",
+                                  sidecars=[("http://x/m.data", data_sha, "m.data")])
+            assert os.path.basename(p) == "m.onnx"                 # keeps its name, not the hash
+            assert os.path.exists(os.path.join(os.path.dirname(p), "m.data"))  # sidecar beside it
+            assert cache._sha256(p) == onnx_sha
+        finally:
+            urllib.request.urlretrieve = orig
+
+
+class _temp_cache:
+    """Context manager: point cache.CACHE_DIR at a fresh temp dir, restore on exit."""
+
+    def __enter__(self):
+        self._orig = cache.CACHE_DIR
+        self._dir = tempfile.mkdtemp(prefix="cw-cache-test-")
+        cache.CACHE_DIR = self._dir
+        return self._dir
+
+    def __exit__(self, *exc):
+        cache.CACHE_DIR = self._orig
+        import shutil
+        shutil.rmtree(self._dir, ignore_errors=True)
+        return False
+
+
+if __name__ == "__main__":
+    fns = [f for n, f in sorted(globals().items()) if n.startswith("test_")]
+    for f in fns:
+        f(); print("ok", f.__name__)
+    print(f"\n{len(fns)} passed")

chipwright/tests/test_device_adb.py

@@ -0,0 +1,140 @@
+"""AdbDevice — the adb transport, with `adb` MOCKED (shutil.which + subprocess.run swapped).
+
+No board and no `adb` binary needed: the suite runs green on a laptop with nothing installed. Also
+runnable as `python3 test_device_adb.py`. Mirrors test_build.py's mock discipline (swap the module's
+`shutil.which` / `subprocess.run`, restore in finally).
+"""
+import os
+import subprocess
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from chipwright import device_adb
+from chipwright.device_adb import AdbDevice
+
+
+def _fake_run(returncode=0, stdout="", stderr=""):
+    """A subprocess.run replacement that records argv and returns a canned CompletedProcess."""
+    calls = []
+
+    def run(argv, capture_output=True, text=True, timeout=None):
+        calls.append(argv)
+        return subprocess.CompletedProcess(argv, returncode, stdout, stderr)
+
+    return run, calls
+
+
+def _patch(which=lambda n, path=None: "/usr/bin/adb", run=None):
+    """Swap device_adb's shutil.which / subprocess.run / time.sleep; return a restore() callable."""
+    orig = (device_adb.shutil.which, device_adb.subprocess.run, device_adb.time.sleep)
+    device_adb.shutil.which = which
+    if run is not None:
+        device_adb.subprocess.run = run
+    device_adb.time.sleep = lambda *a, **k: None  # never sleep on a retry in tests
+
+    def restore():
+        device_adb.shutil.which, device_adb.subprocess.run, device_adb.time.sleep = orig
+
+    return restore
+
+
+def test_require_adb_refuses_by_name_when_missing():
+    restore = _patch(which=lambda n, path=None: None)
+    try:
+        AdbDevice()
+    except RuntimeError as e:
+        assert "adb" in str(e) and "platform-tools" in str(e)
+    else:
+        raise AssertionError("AdbDevice() must refuse when `adb` is absent")
+    finally:
+        restore()
+
+
+def test_shell_returns_completed_process():
+    run, calls = _fake_run(returncode=0, stdout="hello\n")
+    restore = _patch(run=run)
+    try:
+        dev = AdbDevice(serial="ABC123")
+        r = dev.shell("echo hello")
+        assert r.returncode == 0 and r.stdout == "hello\n"
+        # the serial is pinned into the argv and `shell` is the verb
+        assert calls[-1][:4] == ["adb", "-s", "ABC123", "shell"]
+    finally:
+        restore()
+
+
+def test_push_file_one_file_pushes():
+    run, calls = _fake_run(returncode=0)
+    restore = _patch(run=run)
+    try:
+        with tempfile.NamedTemporaryFile("w", suffix=".bin", delete=False) as f:
+            f.write("x")
+            local = f.name
+        dev = AdbDevice()
+        remote = dev.push_file(local, "/data/local/tmp/chipwright/a.bin")
+        assert remote == "/data/local/tmp/chipwright/a.bin"
+        # exactly one `adb push` happened (the mkdir of the parent is a `shell`, not a push)
+        pushes = [c for c in calls if "push" in c]
+        assert len(pushes) == 1 and local in pushes[0]
+        os.unlink(local)
+    finally:
+        restore()
+
+
+def test_push_file_refuses_a_directory():
+    run, _ = _fake_run(returncode=0)
+    restore = _patch(run=run)
+    try:
+        dev = AdbDevice()
+        with tempfile.TemporaryDirectory() as d:
+            try:
+                dev.push_file(d, "/data/local/tmp/chipwright/dir")
+            except ValueError as e:
+                assert "directory" in str(e) and "wedge" in str(e)
+            else:
+                raise AssertionError("push_file must refuse a directory (it wedges the adb daemon)")
+    finally:
+        restore()
+
+
+def test_push_file_raises_on_adb_failure():
+    run, _ = _fake_run(returncode=1, stderr="no space left")
+    restore = _patch(run=run)
+    try:
+        with tempfile.NamedTemporaryFile("w", delete=False) as f:
+            f.write("x")
+            local = f.name
+        dev = AdbDevice()
+        try:
+            dev.push_file(local, "/data/local/tmp/x.bin")
+        except RuntimeError as e:
+            assert "adb push failed" in str(e) and "no space left" in str(e)
+        else:
+            raise AssertionError("a non-zero adb push must raise, naming the failure")
+        os.unlink(local)
+    finally:
+        restore()
+
+
+def test_exists_parses_ok_marker():
+    run_true, _ = _fake_run(returncode=0, stdout="OK\n")
+    restore = _patch(run=run_true)
+    try:
+        assert AdbDevice().exists("/data/local/tmp/present") is True
+    finally:
+        restore()
+    run_false, _ = _fake_run(returncode=0, stdout="")  # command ran, no OK => absent
+    restore = _patch(run=run_false)
+    try:
+        assert AdbDevice().exists("/data/local/tmp/absent") is False
+    finally:
+        restore()
+
+
+if __name__ == "__main__":
+    fns = [f for n, f in sorted(globals().items()) if n.startswith("test_")]
+    for f in fns:
+        f(); print("ok", f.__name__)
+    print(f"\n{len(fns)} passed")

chipwright/tests/test_env.py

@@ -0,0 +1,73 @@
+"""TargetKey — the pure parts of the board descriptor (no probe(), no board).
+
+Covers manual() spec parsing, str() formatting, and the SOC_ID lookup table. probe() is deliberately
+NOT exercised here; it needs a board over SSH/ADB. Also runnable as `python3 test_env.py`.
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from chipwright.env import SOC_ID, TargetKey
+
+
+def test_manual_parses_arch_and_qairt():
+    t = TargetKey.manual("htpv68,qnn2.37")
+    assert t.htp_arch == "v68"
+    assert t.qairt == "2.37"
+    # a hand-typed target is offline by construction
+    assert t.reachable is False
+
+
+def test_manual_tolerates_whitespace_and_order():
+    t = TargetKey.manual(" qnn2.38.0 , htpv73 ")
+    assert t.htp_arch == "v73"
+    assert t.qairt == "2.38.0"
+
+
+def test_manual_arch_only_leaves_qairt_none():
+    t = TargetKey.manual("htpv66")
+    assert t.htp_arch == "v66"
+    assert t.qairt is None
+
+
+def test_manual_without_arch_raises():
+    for bad in ["qnn2.37", "", "soc498"]:
+        try:
+            TargetKey.manual(bad)
+        except ValueError:
+            continue
+        raise AssertionError(f"expected ValueError for {bad!r}")
+
+
+def test_str_formats_arch_sdk_and_soc():
+    # arch only
+    assert str(TargetKey(htp_arch="v68")) == "htpv68"
+    # arch + qairt
+    assert str(TargetKey(htp_arch="v68", qairt="2.37.1")) == "htpv68, qnn2.37.1"
+    # arch + qairt + soc name
+    t = TargetKey(htp_arch="v68", qairt="2.37.1", soc_name="QCS6490 / RB3 Gen2")
+    assert str(t) == "htpv68, qnn2.37.1 [QCS6490 / RB3 Gen2]"
+
+
+def test_soc_id_map_resolves_498_to_qcs6490_v68():
+    name, arch = SOC_ID[498]
+    assert "QCS6490" in name
+    assert arch == "v68"
+
+
+def test_soc_id_map_covers_known_boards():
+    # the lookup returns a (name, arch) pair for each known SoC id
+    for soc_id in (498, 35, 30, 57, 69):
+        name, arch = SOC_ID[soc_id]
+        assert isinstance(name, str) and name
+        assert arch.startswith("v")
+    # an unknown id yields the caller's default via .get()
+    assert SOC_ID.get(9999, (None, "unknown")) == (None, "unknown")
+
+
+if __name__ == "__main__":
+    fns = [f for n, f in sorted(globals().items()) if n.startswith("test_")]
+    for f in fns:
+        f(); print("ok", f.__name__)
+    print(f"\n{len(fns)} passed")

chipwright/tests/test_env_adb.py

@@ -0,0 +1,120 @@
+"""env.py — the adb probe parse, the SM8750->v79 SoC mapping, and skel-load detection.
+
+All offline: `probe_adb` is exercised with `subprocess.run` MOCKED (no board, no `adb`); the skel
+detector takes a plain `shell` callable so it needs nothing at all. Also runnable as
+`python3 test_env_adb.py`.
+"""
+import os
+import subprocess
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from chipwright import env
+from chipwright.env import SOC_ID, SkelCheck, detect_skel_load, probe_adb
+
+
+# --- SoC table: SM8750 -> v79 (FR-L05, the one arch that was still missing) ----------------------
+def test_soc_id_maps_sm8750_to_v79():
+    name, arch = SOC_ID[618]
+    assert "SM8750" in name
+    assert arch == "v79"
+
+
+def test_soc_table_now_covers_v73_v79_v81():
+    archs = {arch for _name, arch in SOC_ID.values()}
+    for a in ("v73", "v79", "v81"):
+        assert a in archs, f"{a} missing from SOC_ID"
+
+
+# --- probe_adb: parse the on-device echo block into a TargetKey ----------------------------------
+def _fake_adb(stdout, returncode=0):
+    def run(argv, capture_output=True, text=True, timeout=None):
+        return subprocess.CompletedProcess(argv, returncode, stdout, "")
+    return run
+
+
+def _patch_run(run):
+    orig = env.subprocess.run
+    env.subprocess.run = run
+    return lambda: setattr(env.subprocess, "run", orig)
+
+
+def test_probe_adb_parses_sm8750_board():
+    out = ("SOC=618\n"
+           "NETRUN=/usr/bin/qnn-net-run\n"
+           "LIBS=libQnnHtpV79.so libQnnHtpV79Stub.so\n"
+           "QAIRT=2.38.0\n"
+           "RAM=16219136\n"
+           "TEMP=41200\n")
+    restore = _patch_run(_fake_adb(out))
+    try:
+        t = probe_adb(serial="PHONE1")
+        assert t.reachable is True
+        assert t.soc_id == 618
+        assert t.htp_arch == "v79"
+        assert "SM8750" in t.soc_name
+        assert t.qairt == "2.38.0"
+        assert t.ram_kb == 16219136
+        assert t.thermal_c == 41.2
+    finally:
+        restore()
+
+
+def test_probe_adb_arch_falls_back_to_lib_name_for_unknown_soc():
+    # an soc_id not in the table, but a single HTP lib on the board -> arch recovered from the lib name
+    out = "SOC=99999\nLIBS=libQnnHtpV79.so\nQAIRT=2.38.0\nRAM=8000000\nTEMP=\n"
+    restore = _patch_run(_fake_adb(out))
+    try:
+        t = probe_adb()
+        assert t.htp_arch == "v79"
+        assert t.soc_name is None       # unknown soc id -> no marketing name
+    finally:
+        restore()
+
+
+def test_probe_adb_unreachable_is_offline_not_error():
+    def boom(argv, capture_output=True, text=True, timeout=None):
+        raise FileNotFoundError("adb not found")
+    restore = _patch_run(boom)
+    try:
+        t = probe_adb()
+        assert t.reachable is False and t.htp_arch == "unknown"
+    finally:
+        restore()
+
+
+# --- skel-load detection: a locked image -> device-capability FAIL, not a hang -------------------
+def _shell(stdout="", stderr="", returncode=0):
+    def shell(cmd, timeout=60):
+        return subprocess.CompletedProcess(cmd, returncode, stdout, stderr)
+    return shell
+
+
+def test_detect_skel_load_flags_error_4000():
+    sh = _shell(stderr="GraphPrepare: Failed to load skel, error 4000\n")
+    r = detect_skel_load(sh)
+    assert isinstance(r, SkelCheck)
+    assert r.ok is False and bool(r) is False
+    assert r.code == 4000
+    assert "skel" in r.reason and "device-capability" in r.reason
+
+
+def test_detect_skel_load_passes_on_clean_init():
+    sh = _shell(stdout="qnn-net-run version 2.38.0\nbackend initialized\n")
+    r = detect_skel_load(sh)
+    assert r.ok is True and bool(r) is True and r.code is None
+
+
+def test_detect_skel_load_reports_unreachable_shell():
+    def shell(cmd, timeout=60):
+        raise RuntimeError("device offline")
+    r = detect_skel_load(shell)
+    assert r.ok is False and "could not run" in r.reason
+
+
+if __name__ == "__main__":
+    fns = [f for n, f in sorted(globals().items()) if n.startswith("test_")]
+    for f in fns:
+        f(); print("ok", f.__name__)
+    print(f"\n{len(fns)} passed")