#!/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)) class HarnessScriptsTest(unittest.TestCase): """Guest scripts must be valid shell before any VM is allowed to run them.""" VM_DIR = Path(__file__).resolve().parent def test_guest_scripts_are_syntactically_valid(self): scripts = sorted(self.VM_DIR.glob("*.sh")) self.assertTrue(scripts, "no guest scripts found") for script in scripts: proc = subprocess.run( ["bash", "-n", str(script)], capture_output=True, text=True ) self.assertEqual( proc.returncode, 0, f"bash -n failed for {script.name}: {proc.stderr}", ) def test_rollback_fixtures_and_mode_are_present(self): for name in ("rollback-guest.sh", "rollback-verify.sh"): self.assertTrue((self.VM_DIR / name).is_file(), f"missing {name}") driver = (self.VM_DIR / "serial-driver.py").read_text() self.assertIn('"rollback"', driver) self.assertIn("do_rollback", driver) if __name__ == "__main__": unittest.main(verbosity=2)