test_package_vllm_speculative_runtime.py

#!/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()