#!/usr/bin/env python3 """Run offline: python3 -B scripts/test_package_vllm_speculative_runtime.py.""" import ast import csv import importlib.util import io import json from pathlib import Path import stat import tempfile import unittest from unittest import mock import warnings import zipfile SPEC = importlib.util.spec_from_file_location( "packager", Path(__file__).with_name("package-vllm-speculative-runtime.py")) p = importlib.util.module_from_spec(SPEC) SPEC.loader.exec_module(p) OLD = b"# synthetic original backend\n" NEW = b"# synthetic fixed backend\n" VERSION_SOURCE = b'''# file generated by vcs-versioning\nfrom __future__ import annotations __all__ = ["__version__", "__version_tuple__", "version", "version_tuple", "__commit_id__", "commit_id"] __version__: str version: str __version_tuple__: tuple[int | str, ...] version_tuple: tuple[int | str, ...] __commit_id__: str | None commit_id: str | None __version__ = version = '0.24.0' __version_tuple__ = version_tuple = (0, 24, 0) __commit_id__ = commit_id = 'gee0da84ab' ''' class PackagerTests(unittest.TestCase): def setUp(self): self.temp = tempfile.TemporaryDirectory() self.addCleanup(self.temp.cleanup) self.root = Path(self.temp.name) self.wheel = self.root / next(iter(p.UPSTREAM_HASHES)) self.output = self.root / "output" self.patches = mock.patch.multiple( p, OLD_BACKEND_SHA=p.sha256(OLD), NEW_BACKEND_SHA=p.sha256(NEW)) self.patches.start() self.addCleanup(self.patches.stop) def fixture(self, changes=None, extra=(), record_edit=None): tag = p.UPSTREAM_WHEEL_TAGS[self.wheel.name][0] members = { p.BACKEND: OLD, p.VERSION_FILE: VERSION_SOURCE, p.DIST + "/METADATA": ( b"Metadata-Version: 2.4\r\nName: vllm\r\nVersion: 0.24.0\r\n" b"Requires-Dist: torch==2.11.0\r\nRequires-Dist: example;\r\n" b" python_version >= '3.8'\r\nLicense-Expression: Apache-2.0\r\n" b"\r\nDescription\r\nVersion: not a header\r\n"), p.DIST + "/WHEEL": ("Wheel-Version: 1.0\nGenerator: fixture\n" "Root-Is-Purelib: false\nTag: " + tag + "\n").encode(), p.DIST + "/licenses/LICENSE": b"untouched license\n", "vllm/_C.abi3.so": bytes(range(256)) * 10000, "vllm/unchanged.py": b"raise RuntimeError('must never execute')\n", p.DIST + "/": b"", } members.update(changes or {}) entries = list(members.items()) + list(extra) rows = [(n, p.record_hash(p.sha256(d)), str(len(d))) for n, d in entries if not n.endswith("/")] rows.append((p.RECORD, "", "")) if record_edit: record_edit(rows) record = io.StringIO(newline="") csv.writer(record, lineterminator="\n").writerows(rows) with warnings.catch_warnings(): warnings.simplefilter("ignore", UserWarning) with zipfile.ZipFile(self.wheel, "w", zipfile.ZIP_DEFLATED) as wheel: for name, data in entries: wheel.writestr(name, data) wheel.writestr(p.RECORD, record.getvalue().encode()) return members def run_package(self, output=None): return p._package(self.wheel, output or self.output, NEW, p.sha256(self.wheel.read_bytes())) def assert_rejected(self, pattern=None): with self.assertRaisesRegex((p.InvalidWheel, zipfile.BadZipFile, ValueError), pattern or "."): self.run_package() if self.output.exists(): self.assertEqual(list(self.output.iterdir()), []) def test_deterministic_rewrite_and_complete_record(self): for name in p.UPSTREAM_HASHES: with self.subTest(name=name): self.wheel = self.root / name members = self.fixture() first, provenance_path = self.run_package(self.root / (name + "-a")) second, second_provenance = self.run_package(self.root / (name + "-b")) self.assertEqual(first.read_bytes(), second.read_bytes()) self.assertEqual(provenance_path.read_bytes(), second_provenance.read_bytes()) provenance = json.loads(provenance_path.read_bytes()) self.assertEqual(provenance["output_wheel"]["sha256"], p.sha256(first.read_bytes())) self.assertEqual(provenance["base_commit"], p.BASE_COMMIT) self.assertEqual(provenance["fix_commit"], p.FIX_COMMIT) with zipfile.ZipFile(first) as result: expected_names = {p.renamed(n) for n in members} | {p.renamed(p.RECORD)} self.assertEqual(set(result.namelist()), expected_names) for member, data in members.items(): if member not in (p.BACKEND, p.VERSION_FILE, p.DIST + "/METADATA"): self.assertEqual(result.read(p.renamed(member)), data) self.assertEqual(result.read(p.BACKEND), NEW) version = ast.parse(result.read(p.VERSION_FILE)) values = {node.targets[0].id: ast.literal_eval(node.value) for node in version.body if isinstance(node, ast.Assign)} self.assertEqual(values["__version__"], p.VERSION) self.assertEqual(values["__version_tuple__"], (0, 24, 0, "mayhem.specmeta1")) self.assertEqual(values["__commit_id__"], "g" + p.FIX_COMMIT[:9]) self.assertEqual(result.read(p.NEW_DIST + "/METADATA"), members[p.DIST + "/METADATA"].replace( b"Version: 0.24.0\r\n", b"Version: " + p.VERSION.encode() + b"\r\n")) record = list(csv.reader(io.StringIO(result.read(p.renamed(p.RECORD)).decode()))) self.assertEqual({r[0] for r in record}, {n for n in expected_names if not n.endswith("/")}) for member, digest, size in record: data = result.read(member) if member == p.renamed(p.RECORD): self.assertEqual((digest, size), ("", "")) else: self.assertEqual((digest, size), (p.record_hash(p.sha256(data)), str(len(data)))) self.assertTrue(all(i.date_time == (1980, 1, 1, 0, 0, 0) and i.compress_type == zipfile.ZIP_STORED for i in result.infolist())) changed = {row["original"] for row in provenance["changed_members"]} self.assertEqual(changed, {p.BACKEND, p.VERSION_FILE, p.RECORD} | {n for n in members if n.startswith(p.DIST + "/")}) def test_production_hash_gate_has_no_fixture_override(self): self.fixture() with mock.patch.object(p, "fixed_source", return_value=NEW): with self.assertRaisesRegex(p.InvalidWheel, "upstream wheel SHA256"): p.package(self.wheel, self.root, self.output) self.assertFalse(self.output.exists()) self.assertEqual(len(p.UPSTREAM_HASHES), 2) def test_pinned_internal_linux_tags_are_preserved(self): for arch, other in (("aarch64", "x86_64"), ("x86_64", "aarch64")): with self.subTest(architecture=arch): self.wheel = self.root / ("vllm-0.24.0-cp38-abi3-manylinux_2_28_" + arch + ".whl") self.output = self.root / arch tag = ("cp38-abi3-linux_" + arch).encode() metadata = (b"Wheel-Version: 1.0\nGenerator: setuptools (80.10.2)\n" b"Root-Is-Purelib: false\nTag: " + tag + b"\n") self.fixture({p.DIST + "/WHEEL": metadata}) output, _ = self.run_package() with zipfile.ZipFile(output) as wheel: self.assertEqual(wheel.read(p.NEW_DIST + "/WHEEL"), metadata) self.output = self.root / (arch + "-rejected") for wrong in ("cp38-abi3-manylinux_2_28_" + arch, "cp38-abi3-linux_" + other): self.fixture({p.DIST + "/WHEEL": metadata.replace(tag, wrong.encode())}) self.assert_rejected("unknown original WHEEL metadata") def test_unknown_filename(self): self.fixture() self.wheel = self.wheel.rename(self.root / "vllm-0.24.0-py3-none-any.whl") self.assert_rejected("filename") def test_malicious_and_duplicate_paths(self): for name in ("../escape", "/absolute", "a/../../b", "a\\b", "C:/bad", "a//b", "a/./b", "a/space /b", "a\x00bad", "a\nb", p.BACKEND, p.BACKEND.upper(), "vllm/_C.abi3.so/child", "other.dist-info/METADATA"): with self.subTest(name=name): self.fixture(extra=[(name, b"bad")]) self.assert_rejected() def test_symlink_and_special_file(self): for mode in (stat.S_IFLNK, stat.S_IFIFO, stat.S_IFCHR): self.fixture() with zipfile.ZipFile(self.wheel, "a") as wheel: info = zipfile.ZipInfo("link") info.create_system = 3 info.external_attr = (mode | 0o777) << 16 wheel.writestr(info, b"../outside") self.assert_rejected("symlink or special") def test_record_hash_size_coverage_and_duplicates(self): edits = [ lambda rows: rows.__setitem__(0, (rows[0][0], p.record_hash("00" * 32), rows[0][2])), lambda rows: rows.__setitem__(0, (rows[0][0], rows[0][1], "999")), lambda rows: rows.pop(0), lambda rows: rows.append(rows[0]), lambda rows: rows.append(("ghost", "", "")), lambda rows: rows.__setitem__(-1, (p.RECORD, "sha256=bad", "0")), lambda rows: rows.__setitem__(0, (rows[0][0], "", rows[0][2])), ] for edit in edits: self.fixture(record_edit=edit) self.assert_rejected() def test_streamed_binary_hash_failure_cleans_owned_temps(self): def corrupt(rows): for i, row in enumerate(rows): if row[0].endswith(".so"): rows[i] = (row[0], p.record_hash("00" * 32), row[2]) self.fixture(record_edit=corrupt) self.assert_rejected("RECORD hash/size mismatch") def test_unknown_backend_version_and_metadata(self): for changes in ( {p.BACKEND: b"unrecognized"}, {p.VERSION_FILE: VERSION_SOURCE.replace(b"gee0da84ab", b"gunknown0")}, {p.VERSION_FILE: VERSION_SOURCE.replace(b"(0, 24, 0)", b"(0, 23, 0)")}, {p.VERSION_FILE: VERSION_SOURCE + b"raise RuntimeError('never run')\n"}, {p.VERSION_FILE: VERSION_SOURCE + b"version = '0.24.0'\n"}, {p.DIST + "/METADATA": b"Name: vllm\nVersion: 0.25.0\n\n"}, {p.DIST + "/METADATA": b"Name: vllm\nVersion: 0.24.0\nVersion: 0.24.0\n\n"}, {p.DIST + "/WHEEL": b"Wheel-Version: 1.0\nTag: py3-none-any\n"}, {p.DIST + "/RECORD.jws": b"signature"}, ): self.fixture(changes) self.assert_rejected() def test_size_bounds(self): self.fixture() for field in ("MAX_ARCHIVE", "MAX_CENTRAL", "MAX_ENTRIES", "MAX_MEMBER", "MAX_TOTAL", "MAX_SMALL"): with self.subTest(field=field), mock.patch.object(p, field, 1): self.assert_rejected() def test_no_overwrite_and_cleanup_publication_race(self): self.fixture() wheel, sidecar = self.run_package() saved = (wheel.read_bytes(), sidecar.read_bytes()) with self.assertRaisesRegex(p.InvalidWheel, "output already exists"): self.run_package() self.assertEqual((wheel.read_bytes(), sidecar.read_bytes()), saved) wheel.unlink() sidecar.unlink() real_link = p.os.link def race(source, destination): if str(destination).endswith(".json"): Path(destination).write_bytes(b"other owner") real_link(source, destination) with mock.patch.object(p.os, "link", side_effect=race): with self.assertRaises(FileExistsError): self.run_package() self.assertFalse(wheel.exists()) self.assertEqual(sidecar.read_bytes(), b"other owner") self.assertEqual(list(self.output.iterdir()), [sidecar]) def test_large_members_are_streamed(self): self.fixture() original_read = zipfile.ZipExtFile.read def bounded_read(stream, size=-1): if stream.name.endswith(".so"): self.assertGreater(size, 0) self.assertLessEqual(size, p.CHUNK) return original_read(stream, size) with mock.patch.object(zipfile.ZipExtFile, "read", bounded_read): self.run_package() def test_minimal_export_source_and_pinned_identity(self): source = self.root / "source" backend = source / p.BACKEND backend.parent.mkdir(parents=True) backend.write_bytes(NEW) manifest = source / "vllm-specmeta-source.json" identity = {"base_commit": p.BASE_COMMIT, "fix_commit": p.FIX_COMMIT, "backend_sha256": p.NEW_BACKEND_SHA} manifest.write_text(json.dumps(identity)) with mock.patch.object(p, "git", side_effect=AssertionError("no git for export")): self.assertEqual(p.fixed_source(source), NEW) for key in identity: manifest.write_text(json.dumps({**identity, key: "wrong"})) with self.assertRaisesRegex(p.InvalidWheel, "identity mismatch"): p.fixed_source(source) manifest.write_text(json.dumps(identity)) backend.write_bytes(OLD) with self.assertRaisesRegex(p.InvalidWheel, "backend SHA256"): p.fixed_source(source) def test_sparse_git_source_identity_and_index(self): source = self.root / "source" backend = source / p.BACKEND backend.parent.mkdir(parents=True) backend.write_bytes(NEW) (source / ".git").mkdir() blob = p.hashlib.sha1(b"blob " + str(len(NEW)).encode() + b"\0" + NEW).hexdigest().encode() replies = [p.FIX_COMMIT.encode(), p.BASE_COMMIT.encode(), b"100644 blob " + blob + b"\t" + p.BACKEND.encode() + b"\0", b"100644 " + blob + b" 0\t" + p.BACKEND.encode() + b"\0"] for mode in (b"100644", b"100755"): for local_mode in (0o644, 0o755): backend.chmod(local_mode) matching = [row.replace(b"100644", mode) for row in replies] with self.subTest(git_mode=mode, local_mode=local_mode): with mock.patch.object(p, "git", side_effect=matching): self.assertEqual(p.fixed_source(source), NEW) mismatched_index = replies.copy() mismatched_index[-1] = mismatched_index[-1].replace(b"100644", b"100755") with mock.patch.object(p, "git", side_effect=mismatched_index): with self.assertRaisesRegex(p.InvalidWheel, "index is not clean"): p.fixed_source(source) for i in range(len(replies)): changed = replies.copy() changed[i] = b"wrong" with mock.patch.object(p, "git", side_effect=changed): with self.assertRaises(p.InvalidWheel): p.fixed_source(source) if __name__ == "__main__": unittest.main()