mhctools 4.4.2__tar.gz → 4.4.4__tar.gz

{mhctools-4.4.2/mhctools.egg-info → mhctools-4.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mhctools
-Version: 4.4.2
+Version: 4.4.4
 Summary: Python interface to MHC binding, presentation, immunogenicity, and antigen processing predictors
 Author-email: Alex Rubinsteyn <alex@openvax.org>, Julia Kodysh <julia@openvax.org>, Tim O'Donnell <tim@openvax.org>
 License-Expression: Apache-2.0 AND LGPL-2.1-only AND CC-BY-4.0 AND CC0-1.0

{mhctools-4.4.2 → mhctools-4.4.4}/mhctools/__init__.py

@@ -203,7 +203,7 @@ def __getattr__(name):
     raise AttributeError(
         "module %r has no attribute %r" % (__name__, name))
 
-__version__ = "4.4.2"
+__version__ = "4.4.4"
 
 __all__ = [
     "CleaveNet",

{mhctools-4.4.2 → mhctools-4.4.4}/mhctools/process_helpers.py

@@ -96,19 +96,31 @@ class AsyncProcess(object):
         return self.process.poll()
 
     def _terminate(self, grace_seconds):
-        """Terminate the process, escalating to kill after a short grace."""
+        """Terminate owned processes, including children after the leader exits."""
         if self.terminate_process_group and os.name == "posix":
-            process_group = os.getpgid(self.process.pid)
-            os.killpg(process_group, signal.SIGTERM)
-        else:
-            self.process.terminate()
+            # start_new_session makes this PID the group ID. getpgid(pid) can
+            # fail after the leader exits while its children are still alive.
+            process_group = self.process.pid
+            deadline = time.monotonic() + grace_seconds
+            try:
+                os.killpg(process_group, signal.SIGTERM)
+                while True:
+                    self.process.poll()  # Reap the leader, but keep checking children.
+                    os.killpg(process_group, 0)
+                    remaining = deadline - time.monotonic()
+                    if remaining <= 0:
+                        os.killpg(process_group, signal.SIGKILL)
+                        break
+                    time.sleep(min(0.05, remaining))
+            except ProcessLookupError:
+                pass  # The entire group has already exited.
+            self.process.wait()
+            return
+        self.process.terminate()
         try:
             self.process.wait(timeout=grace_seconds)
         except TimeoutExpired:
-            if self.terminate_process_group and os.name == "posix":
-                os.killpg(process_group, signal.SIGKILL)
-            else:
-                self.process.kill()
+            self.process.kill()
             self.process.wait()
 
     def wait(self, timeout=None, terminate_grace_seconds=5):

{mhctools-4.4.2 → mhctools-4.4.4/mhctools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mhctools
-Version: 4.4.2
+Version: 4.4.4
 Summary: Python interface to MHC binding, presentation, immunogenicity, and antigen processing predictors
 Author-email: Alex Rubinsteyn <alex@openvax.org>, Julia Kodysh <julia@openvax.org>, Tim O'Donnell <tim@openvax.org>
 License-Expression: Apache-2.0 AND LGPL-2.1-only AND CC-BY-4.0 AND CC0-1.0

{mhctools-4.4.2 → mhctools-4.4.4}/scripts/build_iedb_smm_subset.py

@@ -19,8 +19,9 @@ LIAI_license.txt is included because the bundle is Non-Profit Open Software
 License 3.0 and the terms travel with the material.
 
 Reproducibility: entries are sorted, and mtime, mode, uid/gid and uname/gname
-are normalized. Rebuilding with the same compression runtime yields the same
-SHA-256; different zlib versions may produce different compressed bytes.
+are normalized. The audit pins the uncompressed tar stream's SHA-256, so gzip
+encoding differences do not affect it. The installer separately pins the exact
+compressed bytes of the hosted artifact.
 
     python scripts/build_iedb_smm_subset.py \
         --archive env/test-backends/IEDB_MHC_I-3.1.7.tar.gz \
@@ -62,12 +63,13 @@ INCLUDED_PREFIXES = (
 
 EXCLUDED_NAMES = ("__pycache__", ".pyc")
 
-# The digest this script produces from the pinned archive. setup_test_backends
-# installs an artifact by checksum; asserting that checksum equals this one is
-# what ties the hosted copy to a build from the official release rather than to
-# whatever was uploaded.
+# Exact hosted archive bytes, also pinned by setup_test_backends. A rebuild
+# may use a different gzip encoding while preserving the normalized tar stream.
 EXPECTED_SUBSET_SHA256 = (
     "eef720a71991a76ceee64ce32fbb52e19684b91d9d44eb078c18c96f395e192e")
+# SHA-256 after gzip decompression, including normalized tar headers and padding.
+EXPECTED_SUBSET_TAR_SHA256 = (
+    "f1e3d6168644a33e64a8be00d77b4e56808db1bd9b72bcc704d4954828ad494e")
 
 
 def _digest(path):
@@ -78,6 +80,11 @@ def _digest(path):
     return sha256.hexdigest()
 
 
+def _tar_digest(path):
+    with gzip.open(path, "rb") as handle:
+        return hashlib.file_digest(handle, "sha256").hexdigest()
+
+
 MARKER = "mhc_i/"
 
 
@@ -194,16 +201,18 @@ def main():
     files = [entry for entry in entries if entry[1] is not None]
     total = sum(len(entry[1]) for entry in files)
     digest = _digest(args.output)
+    tar_digest = _tar_digest(args.output)
     print("files:      %d" % len(files))
     print("directories: %d" % (len(entries) - len(files)))
     print("bytes:      %d (%.1f MB uncompressed)" % (total, total / 1e6))
     print("output:     %s (%.1f MB)"
           % (args.output, args.output.stat().st_size / 1e6))
     print("sha256:     %s" % digest)
-    if EXPECTED_SUBSET_SHA256 not in ("PLACEHOLDER", digest):
+    print("tar_sha256: %s" % tar_digest)
+    if tar_digest != EXPECTED_SUBSET_TAR_SHA256:
         raise SystemExit(
-            "Built subset does not match EXPECTED_SUBSET_SHA256 (%s)"
-            % EXPECTED_SUBSET_SHA256)
+            "Built subset tar does not match EXPECTED_SUBSET_TAR_SHA256 (%s)"
+            % EXPECTED_SUBSET_TAR_SHA256)
 
 
 if __name__ == "__main__":

{mhctools-4.4.2 → mhctools-4.4.4}/scripts/setup_test_backends.py

@@ -220,7 +220,7 @@ def gfeller(root, python, config):
 # the Actions cache evicted, which blocked unrelated merges. The release
 # unpacks to 1031 MB, mostly bundled DTU executables SMM never runs, against
 # 9.4 MB it needs. scripts/build_iedb_smm_subset.py
-# derives this file reproducibly and documents exactly what it contains; the
+# audits the normalized tar contents independently of gzip encoding; the
 # upstream Non-Profit OSL 3.0 license ships inside it.
 SMM_SUBSET_URL = (
     "https://github.com/openvax/mhctools/releases/download/"

{mhctools-4.4.2 → mhctools-4.4.4}/tests/test_mixmhcpred_runtime_integration.py

@@ -3,8 +3,11 @@
 import os
 from pathlib import Path
 import shutil
+import signal
 import subprocess
 import sys
+from tempfile import TemporaryFile
+import time
 
 import pandas as pd
 import pytest
@@ -16,9 +19,10 @@ from mhctools.mixmhcpred import (
     resolve_mixmhcpred_path,
 )
 from mhctools.prime import parse_prime_results
+from mhctools.process_helpers import run_command
+from .common import process_is_running
 
 
-pytestmark = pytest.mark.requires_external_tool
 PEPTIDES = ["SIINFEKL", "MLDDFSAGA", "SIINFEKL"]
 ALLELES = ["HLA-A*02:01", "HLA-A*01:02"]
 
@@ -49,9 +53,62 @@ def native_runtime():
     assert changed == []
 
 
-def _native(args, environment):
-    completed = subprocess.run(args, env=environment, capture_output=True, text=True, timeout=180)
-    assert completed.returncode == 0, completed.stdout + completed.stderr
+def _native(args, environment, timeout=180):
+    started = time.monotonic()
+    with TemporaryFile() as output:
+        try:
+            run_command(
+                args, env=environment, timeout=timeout,
+                terminate_process_group=True,
+                redirect_stdout_file=output, redirect_stderr_to_stdout=True)
+        except (subprocess.TimeoutExpired, subprocess.CalledProcessError) as error:
+            output.seek(0, os.SEEK_END)
+            output.seek(max(0, output.tell() - 2000))
+            tail = output.read().decode("utf-8", errors="replace").strip()
+            reason = (f"timed out (limit {timeout:g}s)"
+                      if isinstance(error, subprocess.TimeoutExpired)
+                      else f"exited with status {error.returncode}")
+            pytest.fail(
+                f"{args[0]} {reason} after {time.monotonic() - started:.2f}s.\n"
+                f"Output tail:\n{tail or '(empty output)'}", pytrace=False)
+
+
+def test_native_reference_failure_reports_bounded_output():
+    command = [sys.executable, "-c",
+               "import sys; print('discarded-prefix' + 'x' * 5000, flush=True); "
+               "print('stdout marker', flush=True); "
+               "print('stderr marker', file=sys.stderr, flush=True); sys.exit(7)"]
+    with pytest.raises(pytest.fail.Exception) as error:
+        _native(command, dict(os.environ))
+    message = str(error.value)
+    assert "exited with status 7" in message
+    assert "stdout marker" in message and "stderr marker" in message
+    assert "discarded-prefix" not in message
+    assert len(message) < 2400
+
+
+@pytest.mark.skipif(os.name != "posix", reason="POSIX process-group behavior")
+def test_native_reference_timeout_stops_children(tmp_path):
+    child = tmp_path / "child.py"
+    child.write_text(
+        "import os, sys, time\nfrom pathlib import Path\n"
+        "print('reference child active', flush=True)\n"
+        "Path(sys.argv[1]).write_text(str(os.getpid()))\ntime.sleep(60)\n")
+    parent = tmp_path / "parent.py"
+    parent.write_text(
+        "import subprocess, sys\n"
+        "subprocess.run([sys.executable, sys.argv[1], sys.argv[2]])\n")
+    ready = tmp_path / "child.pid"
+    try:
+        with pytest.raises(pytest.fail.Exception, match="timed out \\(limit 3s\\)") as error:
+            _native([sys.executable, str(parent), str(child), str(ready)],
+                    dict(os.environ), timeout=3)
+        assert ready.is_file(), "Reference child did not start before the timeout"
+        assert "reference child active" in str(error.value)
+        assert not process_is_running(int(ready.read_text()))
+    finally:
+        if ready.exists() and process_is_running(int(ready.read_text())):
+            os.kill(int(ready.read_text()), signal.SIGKILL)
 
 
 def _input(tmp_path):
@@ -60,6 +117,7 @@ def _input(tmp_path):
     return str(path)
 
 
+@pytest.mark.requires_external_tool
 def test_isolated_multi_allele_rows_motifs_and_cli_match_native(native_runtime, tmp_path, monkeypatch):
     executable, selected, environment = native_runtime
     peptide_file = _input(tmp_path)
@@ -101,6 +159,7 @@ def test_isolated_multi_allele_rows_motifs_and_cli_match_native(native_runtime,
         pred.percentile_rank for row in expected.predictions for pred in row.preds], abs=5e-5)
 
 
+@pytest.mark.requires_external_tool
 def test_isolated_sequence_alignment_prediction_and_artifacts_match_native(native_runtime, tmp_path):
     executable, selected, environment = native_runtime
     assert shutil.which("mafft"), "provision MAFFT for the sequence regression"
@@ -127,6 +186,7 @@ def test_isolated_sequence_alignment_prediction_and_artifacts_match_native(nativ
     assert alignment_only.runtime_info["backend"]["python_executable"] == selected
 
 
+@pytest.mark.requires_external_tool
 def test_prime_nested_isolated_runtime_matches_native(native_runtime, tmp_path, monkeypatch):
     executable, selected, environment = native_runtime
     prime = os.environ.get("PRIME_EXECUTABLE")

{mhctools-4.4.2 → mhctools-4.4.4}/tests/test_process_helpers.py

@@ -10,7 +10,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Tests for process_helpers retry logic."""
+"""Process lifecycle, concurrency limits and runtime probes."""
 
 import errno
 import os
@@ -18,10 +18,12 @@ import signal
 import sys
 from subprocess import TimeoutExpired
 import tempfile
+import time
 from unittest.mock import patch, MagicMock
 
 import pytest
 
+from .common import process_is_running
 from mhctools.process_helpers import (
     AsyncProcess,
     legacy_keras_runtime_available,
@@ -31,37 +33,51 @@ from mhctools.process_helpers import (
 
 
 @pytest.mark.skipif(os.name != "posix", reason="POSIX process-group behavior")
-def test_timeout_terminates_process_group():
-    proc = AsyncProcess(["slow-command"], terminate_process_group=True)
-    proc.process = MagicMock(pid=123)
-    proc.process.wait.side_effect = [
-        TimeoutExpired("slow-command", 1),
-        0,
-    ]
-    with patch("mhctools.process_helpers.os.getpgid", return_value=456), \
-         patch("mhctools.process_helpers.os.killpg") as killpg:
+@pytest.mark.parametrize("parent_ignores_term,child_ignores_term", [
+    (False, False), (False, True), (True, True),
+])
+def test_timeout_stops_the_whole_process_group(
+        tmp_path, parent_ignores_term, child_ignores_term):
+    child = tmp_path / "child.py"
+    child.write_text(
+        "import os, signal, sys, time\nfrom pathlib import Path\n"
+        "signal.signal(signal.SIGTERM, signal.SIG_IGN if sys.argv[2] == '1' "
+        "else signal.SIG_DFL)\n"
+        "Path(sys.argv[1]).write_text(str(os.getpid()))\ntime.sleep(60)\n")
+    parent = tmp_path / "parent.py"
+    parent.write_text(
+        "import signal, subprocess, sys, time\n"
+        "signal.signal(signal.SIGTERM, signal.SIG_IGN if sys.argv[4] == '1' "
+        "else signal.SIG_DFL)\n"
+        "subprocess.Popen([sys.executable, sys.argv[1], sys.argv[2], sys.argv[3]])\n"
+        "time.sleep(60)\n")
+    ready = tmp_path / "child.pid"
+    proc = AsyncProcess(
+        [sys.executable, str(parent), str(child), str(ready),
+         str(int(child_ignores_term)), str(int(parent_ignores_term))],
+        terminate_process_group=True)
+    proc.start()
+    try:
+        deadline = time.monotonic() + 5
+        while not ready.exists():
+            assert proc.poll() is None
+            assert time.monotonic() < deadline, "Child did not become ready"
+            time.sleep(0.01)
+        child_pid = int(ready.read_text())
         with pytest.raises(TimeoutExpired):
-            proc.wait(timeout=1, terminate_grace_seconds=0.1)
-    killpg.assert_called_once_with(456, signal.SIGTERM)
-
-
-@pytest.mark.skipif(os.name != "posix", reason="POSIX process-group behavior")
-def test_timeout_kills_process_group_after_grace_period():
-    proc = AsyncProcess(["stubborn-command"], terminate_process_group=True)
-    proc.process = MagicMock(pid=123)
-    proc.process.wait.side_effect = [
-        TimeoutExpired("stubborn-command", 1),
-        TimeoutExpired("stubborn-command", 0.1),
-        0,
-    ]
-    with patch("mhctools.process_helpers.os.getpgid", return_value=456), \
-         patch("mhctools.process_helpers.os.killpg") as killpg:
-        with pytest.raises(TimeoutExpired):
-            proc.wait(timeout=1, terminate_grace_seconds=0.1)
-    assert killpg.call_args_list == [
-        ((456, signal.SIGTERM),),
-        ((456, signal.SIGKILL),),
-    ]
+            proc.wait(timeout=0.05, terminate_grace_seconds=0.1)
+        assert proc.process.returncode is not None
+        deadline = time.monotonic() + 2
+        while process_is_running(child_pid) and time.monotonic() < deadline:
+            time.sleep(0.01)
+        assert not process_is_running(child_pid), "Timeout left a running child"
+    finally:
+        # A failing regression must not leak its own sleeping child.
+        try:
+            os.killpg(proc.process.pid, signal.SIGKILL)
+        except ProcessLookupError:
+            pass
+        proc.process.wait()
 
 
 def test_start_retries_on_blocking_io_error():

{mhctools-4.4.2 → mhctools-4.4.4}/tests/test_smm_subset_provenance.py

@@ -12,16 +12,13 @@
 
 """The hosted SMM subset must stay traceable to one upstream IEDB release.
 
-The subset builder and the fixture recorder each pin the official archive by
-SHA-256, and the builder also pins the digest of the subset it derives from
-it. The installer pins only that derived digest, which carries no upstream
-version of its own -- so the chain from "what CI installs" back to "which
-IEDB release" holds only if the installer's digest equals the one the builder
-declares. Assert that, or a rebuilt-and-reuploaded asset could change what CI
-installs while the recorded fixtures keep describing the old release.
+The source archive, normalized tar stream and exact hosted gzip artifact have
+separate checksums. Rebuilds must preserve the normalized tar stream across gzip
+encodings; installation must still reject changes to the hosted archive bytes.
 """
 
 import importlib.util
+import gzip
 import hashlib
 import io
 from pathlib import Path
@@ -32,6 +29,10 @@ import tarfile
 import pytest
 
 SCRIPTS = Path(__file__).resolve().parent.parent / "scripts"
+# Fixed digest of the normalized tar for source_files, independently checked
+# against its member payloads and metadata below.
+SOURCE_FILES_TAR_SHA256 = (
+    "1220dc57900fd4be42e64a8513cc0bae94bd11713a3f183ac8adcc02852b75e0")
 
 
 def _load(name):
@@ -63,18 +64,23 @@ def test_installer_pins_a_subset_checksum():
     assert re.fullmatch(r"[0-9a-f]{64}", installer.SMM_SUBSET_SHA256)
 
 
-def test_installer_digest_is_the_one_the_builder_produces():
-    """Ties the installed artifact to a build from the pinned IEDB release.
-
-    Without this, uploading a modified asset and updating only
-    SMM_SUBSET_SHA256 passes every other check here.
-    """
+def test_installer_digest_matches_the_hosted_artifact_pin():
     builder = _load("build_iedb_smm_subset")
     installer = _load("setup_test_backends")
 
     assert installer.SMM_SUBSET_SHA256 == builder.EXPECTED_SUBSET_SHA256
 
 
+@pytest.mark.requires_external_tool
+def test_hosted_archive_matches_the_pinned_tar_content():
+    archive = SCRIPTS.parent / "env/test-backends/IEDB_MHC_I-3.1.7-smm-subset.tar.gz"
+    if not archive.is_file():
+        pytest.skip("Provision the SMM artifact: python scripts/setup_test_backends.py smm")
+    builder = _load("build_iedb_smm_subset")
+    assert builder._digest(archive) == builder.EXPECTED_SUBSET_SHA256
+    assert builder._tar_digest(archive) == builder.EXPECTED_SUBSET_TAR_SHA256
+
+
 def test_subset_carries_the_upstream_licenses():
     """NPOSL-3.0 material is redistributed, so its notices must travel."""
     builder = _load("build_iedb_smm_subset")
@@ -83,8 +89,7 @@ def test_subset_carries_the_upstream_licenses():
         assert notice in builder.INCLUDED_PREFIXES
 
 
-def test_installer_downloads_the_release_the_builder_produces():
-    """The installed artifact must be the one build_iedb_smm_subset writes."""
+def test_installer_downloads_the_pinned_subset_release():
     installer = _load("setup_test_backends")
 
     assert installer.SMM_SUBSET_URL.startswith(
@@ -143,8 +148,8 @@ def _build_subset(monkeypatch, archive, output, **pins):
     monkeypatch.setattr(builder, "ARCHIVE_SHA256", pins.get(
         "source", hashlib.sha256(archive.read_bytes()).hexdigest()))
     # Synthetic archives exercise the real builder without the 341 MB download.
-    monkeypatch.setattr(builder, "EXPECTED_SUBSET_SHA256",
-                        pins.get("subset", "PLACEHOLDER"))
+    monkeypatch.setattr(builder, "EXPECTED_SUBSET_TAR_SHA256",
+                        pins.get("subset", SOURCE_FILES_TAR_SHA256))
     monkeypatch.setattr(sys, "argv", [
         str(SCRIPTS / "build_iedb_smm_subset.py"),
         "--archive", str(archive), "--output", str(output)])
@@ -163,7 +168,7 @@ def test_builder_preserves_payload_and_normalizes_metadata(
     second = tmp_path / "second.tar.gz"
     _build_subset(monkeypatch, archive, first)
     _build_subset(monkeypatch, archive, second,
-                  subset=hashlib.sha256(first.read_bytes()).hexdigest())
+                  subset=hashlib.sha256(gzip.decompress(first.read_bytes())).hexdigest())
     assert first.read_bytes() == second.read_bytes()
     with tarfile.open(first) as subset:
         assert subset.getnames() == sorted(source_files)
@@ -212,13 +217,69 @@ def test_builder_rejects_wrong_source_checksum(tmp_path, monkeypatch, source_fil
     assert not output.exists()
 
 
-def test_builder_rejects_wrong_subset_checksum(tmp_path, monkeypatch, source_files):
+def test_builder_rejects_wrong_tar_checksum(tmp_path, monkeypatch, source_files):
     archive = tmp_path / "upstream.tar.gz"
     _write_archive(archive, source_files)
-    with pytest.raises(SystemExit, match="does not match EXPECTED_SUBSET_SHA256"):
+    with pytest.raises(SystemExit, match="does not match EXPECTED_SUBSET_TAR_SHA256"):
         _build_subset(monkeypatch, archive, tmp_path / "subset.tar.gz", subset="0" * 64)
 
 
+@pytest.mark.parametrize("encoding", [
+    {"compresslevel": 0},
+    {"compresslevel": 1},
+    {"filename": "another-name.tar", "mtime": 123456789},
+])
+def test_builder_accepts_different_gzip_encodings(
+        tmp_path, monkeypatch, source_files, capsys, encoding):
+    archive = tmp_path / "upstream.tar.gz"
+    _write_archive(archive, source_files)
+    first, second = tmp_path / "first.tar.gz", tmp_path / "second.tar.gz"
+    _build_subset(monkeypatch, archive, first)
+    original_gzip = gzip.GzipFile
+
+    def alternate_gzip(*args, **kwargs):
+        if kwargs.get("mode") == "wb":
+            kwargs.update(encoding)
+        return original_gzip(*args, **kwargs)
+
+    monkeypatch.setattr(gzip, "GzipFile", alternate_gzip)
+    _build_subset(monkeypatch, archive, second)
+    assert first.read_bytes() != second.read_bytes()
+    assert gzip.decompress(first.read_bytes()) == gzip.decompress(second.read_bytes())
+    assert capsys.readouterr().out.count("tar_sha256: " + SOURCE_FILES_TAR_SHA256) == 2
+
+
+@pytest.mark.parametrize("change", ["payload", "path"])
+def test_builder_rejects_changed_tar_content(
+        tmp_path, monkeypatch, source_files, change):
+    if change == "payload":
+        source_files["mhc_i/src/setupinfo.template"] += b"changed\n"
+    else:
+        source_files["mhc_i/src/renamed.template"] = source_files.pop(
+            "mhc_i/src/setupinfo.template")
+    archive = tmp_path / "upstream.tar.gz"
+    _write_archive(archive, source_files)
+    with pytest.raises(SystemExit, match="does not match EXPECTED_SUBSET_TAR_SHA256"):
+        _build_subset(monkeypatch, archive, tmp_path / "subset.tar.gz")
+
+
+def test_installer_rejects_reencoded_hosted_artifact(
+        tmp_path, monkeypatch, source_files):
+    archive = tmp_path / "upstream.tar.gz"
+    _write_archive(archive, source_files)
+    subset = tmp_path / "IEDB_MHC_I-3.1.7-smm-subset.tar.gz"
+    _build_subset(monkeypatch, archive, subset)
+    installer = _load("setup_test_backends")
+    monkeypatch.setattr(installer, "SMM_SUBSET_SHA256",
+                        hashlib.sha256(subset.read_bytes()).hexdigest())
+    payload = gzip.decompress(subset.read_bytes())
+    subset.write_bytes(gzip.compress(payload, compresslevel=0, mtime=0))
+    assert _load("build_iedb_smm_subset")._tar_digest(subset) == SOURCE_FILES_TAR_SHA256
+    with pytest.raises(SystemExit, match="Unexpected IEDB SMM subset checksum"):
+        installer.smm(tmp_path, sys.executable, {})
+    assert not (tmp_path / "iedb-3.1.7").exists()
+
+
 def test_installer_replaces_stale_tree_after_verifying_checksum(
         tmp_path, monkeypatch, source_files):
     archive = tmp_path / "upstream.tar.gz"