Add a serial-driver rollback mode and guest scripts that exercise the real rollback path: record the /var/db/pkg fingerprint and a /home marker, create a recovery point with sys snapshot, install a small package as a controlled reversible update, run sys undo, power off, boot detached and compare the restored package state and /home against the pre-rollback values. Checks kernel modules, the snapshot recovery entry and sys rollback status. sys is fetched from the host, matching the existing harness evidence procedure; booting the recovery entry offline remains a documented manual gate. bash -n guards for every guest script are added to the no-VM unit tests.
253 lines
9 KiB
Bash
253 lines
9 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))
|
|
|
|
|
|
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)
|