phoebus_os/installer/tests/vm/test_vmsafety.py
Phoebus cc23df69de test(vm): enforce harness disk safety and structured results
Validate every writable drive (qcow2, inside PHOEBUS_VM_DISKS, no /dev/*,
block/char devices, raw images, escaping symlinks or outside backing
chains), give each run its own OVMF variable file, QMP socket and state
directory, and use QMP plus argument arrays instead of shell interpolation.
Return nonzero on any failed assertion, timeout, EOF or missing result and
record PASS/FAIL/BLOCKED/SKIPPED/NOT RUN. Add 16 unit tests, a report
generator and a findings register; make test runs the harness suite.
2026-09-21 20:01:50 -07:00

227 lines
8 KiB
Bash

#!/usr/bin/env python3
"""Unit tests for the VM harness safety and result logic.
These run on any host (no VM, no QEMU required) so the safety rules are checked
in CI, not only during a live install:
python3 installer/tests/vm/test_vmsafety.py
"""
from __future__ import annotations
import os
import socket
import subprocess
import tempfile
import threading
import unittest
from pathlib import Path
import vmsafety
from vmsafety import (
BLOCKED,
FAIL,
PASS,
Results,
UnsafeDiskError,
validate_disposable_disk,
validate_writable_drives,
)
def make_qcow2(path: Path, size: str = "8M") -> Path:
subprocess.run(
["qemu-img", "create", "-f", "qcow2", str(path), size],
check=True,
capture_output=True,
)
return path
class DisposableDiskTests(unittest.TestCase):
def setUp(self):
self._tmp = tempfile.TemporaryDirectory()
self.dir = Path(self._tmp.name)
def tearDown(self):
self._tmp.cleanup()
def test_rejects_dev_path(self):
with self.assertRaises(UnsafeDiskError):
validate_disposable_disk("/dev/sda", self.dir)
def test_rejects_block_device(self):
# /dev/loop-control or /dev/null are char/regular; the explicit /dev
# check fires first. Use a char device outside /dev to isolate.
with self.assertRaises(UnsafeDiskError):
validate_disposable_disk("/dev/null", self.dir)
def test_rejects_non_qcow2_regular_file(self):
raw = self.dir / "raw.img"
raw.write_bytes(b"\x00" * 4096)
with self.assertRaises(UnsafeDiskError):
validate_disposable_disk(raw, self.dir)
def test_rejects_qcow2_outside_test_dir(self):
outside = self.dir.parent / "outside-disposable.qcow2"
make_qcow2(outside)
self.addCleanup(outside.unlink)
with self.assertRaises(UnsafeDiskError):
validate_disposable_disk(outside, self.dir)
def test_rejects_symlink_escaping_test_dir(self):
target = self.dir.parent / "real-disk.qcow2"
make_qcow2(target)
self.addCleanup(target.unlink)
link = self.dir / "link.qcow2"
link.symlink_to(target)
with self.assertRaises(UnsafeDiskError):
validate_disposable_disk(link, self.dir)
def test_accepts_qcow2_inside_test_dir(self):
good = make_qcow2(self.dir / "good.qcow2")
self.assertEqual(validate_disposable_disk(good, self.dir), good)
def test_rejects_backing_chain_outside_test_dir(self):
backing = self.dir.parent / "backing.qcow2"
make_qcow2(backing)
self.addCleanup(backing.unlink)
overlay = self.dir / "overlay.qcow2"
subprocess.run(
["qemu-img", "create", "-f", "qcow2", "-b", str(backing), "-F", "qcow2",
str(overlay)],
check=True,
capture_output=True,
)
with self.assertRaises(UnsafeDiskError):
validate_disposable_disk(overlay, self.dir)
def test_accepts_backing_chain_inside_test_dir(self):
backing = make_qcow2(self.dir / "backing.qcow2")
overlay = self.dir / "overlay.qcow2"
subprocess.run(
["qemu-img", "create", "-f", "qcow2", "-b", str(backing), "-F", "qcow2",
str(overlay)],
check=True,
capture_output=True,
)
self.assertEqual(validate_disposable_disk(overlay, self.dir), overlay)
def test_rejects_root_as_test_dir(self):
good = make_qcow2(self.dir / "good.qcow2")
with self.assertRaises(UnsafeDiskError):
validate_disposable_disk(good, "/")
def test_validate_all_drives_not_just_disk(self):
a = make_qcow2(self.dir / "a.qcow2")
b = make_qcow2(self.dir / "b.qcow2")
checked = validate_writable_drives([a, "", None, b], self.dir)
self.assertEqual(checked, [a, b])
with self.assertRaises(UnsafeDiskError):
validate_writable_drives([a, "/dev/sdb"], self.dir)
class ResultsTests(unittest.TestCase):
def test_fail_sets_nonzero_exit(self):
results = Results("unit")
results.assert_true("ok", True)
results.assert_true("bad", False, "boom")
self.assertTrue(results.failed)
self.assertEqual(results.exit_code(), 1)
def test_all_pass_is_zero(self):
results = Results("unit")
results.assert_true("ok", True)
self.assertEqual(results.exit_code(), 0)
def test_blocked_only_fails_when_strict(self):
results = Results("unit", strict=False)
results.blocked("needs hardware", "no GPU")
self.assertEqual(results.exit_code(), 0)
strict = Results("unit", strict=True)
strict.blocked("needs hardware", "no GPU")
self.assertEqual(strict.exit_code(), 2)
def test_no_checks_is_not_run(self):
results = Results("unit")
self.assertEqual(results.counts()[vmsafety.NOT_RUN], 0)
self.assertEqual(results.exit_code(), 0)
self.assertEqual(results.summary().split(": ")[1], "no checks")
def test_write_round_trips(self):
results = Results("unit")
results.pass_("one")
path = results.write(self._tmp_results())
import json
data = json.loads(path.read_text())
self.assertEqual(data["scenario"], "unit")
self.assertEqual(data["counts"][PASS], 1)
self.assertEqual(data["exit_code"], 0)
def _tmp_results(self):
tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".json")
tmp.close()
self.addCleanup(os.unlink, tmp.name)
return Path(tmp.name)
class FakeQmpServer(threading.Thread):
"""A tiny QMP server that records HMP commands and answers them."""
def __init__(self):
super().__init__(daemon=True)
self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
self.path = tempfile.mktemp(prefix="fake-qmp-", suffix=".sock")
self.sock.bind(self.path)
self.sock.listen(1)
self.commands = []
self.screendump_path = None
def run(self):
conn, _ = self.sock.accept()
with conn:
conn.sendall(b'{"QMP": {"version": {"qemu": {"major": 8}}}}' + b"\r\n")
reader = conn.makefile("rb")
writer = conn.makefile("wb")
for line in reader:
message = __import__("json").loads(line)
if message.get("execute") == "qmp_capabilities":
writer.write(b'{"return": {}}\r\n')
elif message.get("execute") == "human-monitor-command":
cmd = message["arguments"]["command-line"]
self.commands.append(cmd)
if cmd.startswith("screendump"):
# Emulate QEMU writing the file.
name = cmd.split(" ", 1)[1].strip().strip('"')
Path(name).write_bytes(b"P6 fake-ppm")
writer.write(b'{"return": ""}\r\n')
else:
writer.write(b'{"return": {}}\r\n')
writer.flush()
class QmpClientTests(unittest.TestCase):
def test_hmp_and_screendump(self):
server = FakeQmpServer()
server.start()
self.addCleanup(lambda: (server.sock.close(), os.path.exists(server.path) and os.unlink(server.path)))
deadline = 50
while not os.path.exists(server.path) and deadline:
deadline -= 1
with vmsafety.QmpClient(server.path) as client:
client.sendkey("ret")
# Wait until the fake server has created the file before returning.
target = Path(tempfile.mkdtemp()) / "shot with spaces.ppm"
client.hmp(f'screendump "{target}"')
# Give the server thread a moment to record the command.
for _ in range(50):
if len(server.commands) >= 2:
break
__import__("time").sleep(0.05)
self.assertTrue(any(cmd.startswith("sendkey ret") for cmd in server.commands))
self.assertTrue(any(cmd.startswith("screendump") for cmd in server.commands))
if __name__ == "__main__":
unittest.main(verbosity=2)