"""HTTP and WebSocket boundary tests without a real remote libvirt host.""" from __future__ import annotations import hashlib import re import stat import sys import threading import time import types from pathlib import Path from types import SimpleNamespace from unittest.mock import AsyncMock, patch import pytest from fastapi.testclient import TestClient from starlette.websockets import WebSocketDisconnect from uvicorn.middleware.proxy_headers import ProxyHeadersMiddleware # The API is injected with FakeVMService. Test machines need no native libvirt. try: import libvirt # noqa: F401 except ModuleNotFoundError: stub = types.ModuleType("libvirt") stub.libvirtError = type("libvirtError", (Exception,), {}) sys.modules["libvirt"] = stub from virsh_panel.app import create_app # noqa: E402 from virsh_panel.cloud_templates import ( # noqa: E402 TemplateError, TemplateStore, template_id_for, template_scope, template_volume_name, ) from virsh_panel.config import Settings # noqa: E402 from virsh_panel.libvirt_service import ( # noqa: E402 FIREWALL_FILTER_COMPILER_VERSION, VMError, build_firewall_filter_xml, firewall_policy_digest, normalize_firewall_rules, snapshot_restore_volume_name, snapshot_volume_name, ) from virsh_panel.metrics import host_scope, query_interval_seconds # noqa: E402 from virsh_panel.panel_state import PanelState # noqa: E402 from virsh_panel.platform_network_policy import ( # noqa: E402 default_platform_policy_snapshot, ) from virsh_panel.remote_host import RemoteHostError, validate_public_pool # noqa: E402 PASSWORD = "correct-horse-battery-staple" GUEST_PASSWORD = "A-strong-guest-password-2026" VM_ID = "00000000-0000-4000-8000-000000000001" ORIGIN = "https://panel.example.test" STATIC_DIR = Path(__file__).resolve().parents[1] / "static" CREATE_BODY = { "name": "alma-test", "vcpu": 2, "memory_mib": 2048, "disk_gib": 20, "network": "default", "iso": "AlmaLinux-10.iso", } CLOUD_CREATE_BODY = { "source": "cloud", "template_id": "alma10-template", "name": "cloud-vm", "vcpu": 2, "memory_mib": 2048, "disk_gib": 20, "network": "bridge:br0", "public_ip_cidr": "8.8.8.18/24", "gateway": "8.8.8.1", "dns_servers": ["1.1.1.1"], "guest_ssh_public_key": ( "ssh-ed25519 " "AAAAC3NzaC1lZDI1NTE5AAAAIF7mFh4aYz3lRzNqjoFQasAQLpm7BdSULhe1iWuvj3y5 " "panel-test" ), } OFFICIAL_CLOUD_URL = ( "https://repo.almalinux.org/almalinux/10/cloud/x86_64/images/" "AlmaLinux-10-GenericCloud-10.1-20260101.x86_64.qcow2" ) OFFICIAL_ALMA9_URL = ( "https://repo.almalinux.org/almalinux/9/cloud/x86_64/images/" "AlmaLinux-9-GenericCloud-latest.x86_64.qcow2" ) OFFICIAL_DEBIAN12_URL = ( "https://cloud.debian.org/images/cloud/bookworm/latest/" "debian-12-generic-amd64.qcow2" ) HOST_BODY = { "host": "vmhost.example.test", "port": 2222, "private_key": "-----BEGIN OPENSSH PRIVATE KEY-----\ntest\n-----END OPENSSH PRIVATE KEY-----", "host_key": "vp-managed ssh-ed25519 AAAATEST", "confirmed_fingerprint": "SHA256:example", "storage_pool": "images", "iso_pool": "iso", "rescue_iso_pool": "rescue", "default_network": "default", } class FakeVMService: def __init__(self) -> None: self.calls: list[tuple] = [] self.resource_error = False self.list_error = False self.reinstall_gate: threading.Event | None = None self.reinstall_started = threading.Event() self.reinstall_result: dict | None = None self.reinstall_emit_progress = True self.rescue_enter_error: VMError | None = None self.rescue_delete_error: VMError | None = None self.rescue_pending_manual_restart = False self.user_iso_storage_error: VMError | None = None self.user_iso_storage_available = 90 * 1024**3 self.user_iso_import_error: VMError | None = None self.user_iso_delete_error: VMError | None = None self.user_iso_delete_started = threading.Event() self.user_iso_delete_release: threading.Event | None = None self.user_iso_volumes: set[tuple[int, str]] = set() self.user_iso_cache_started = threading.Event() self.user_iso_cache_release: threading.Event | None = None self.user_iso_create_started = threading.Event() self.user_iso_create_release: threading.Event | None = None self.snapshot_create_error: VMError | None = None self.snapshot_restore_error: VMError | None = None self.snapshot_delete_error: VMError | None = None self.snapshot_delete_release: threading.Event | None = None self.snapshot_delete_started = threading.Event() self.snapshot_thaw_error: VMError | None = None self.delete_vm_error: VMError | None = None self.snapshot_reconcile_create = None self.snapshot_reconcile_restore = None self.snapshot_reconcile_delete = None self.snapshot_backup_active = False self.firewall_enabled = False self.firewall_rules: list[dict] = [] self.firewall_filter_digest: str | None = None self.platform_policy_snapshot = default_platform_policy_snapshot() self.firewall_apply_error: VMError | None = None self.firewall_cleanup_error: VMError | None = None self.vm = { "uuid": VM_ID, "name": "alma-test", "state": "running", "vcpu": 2, "memory_mib": 2048, "disks": [], "autostart": False, } self.other_vms: list[dict] = [] def resources(self): self.calls.append(("resources",)) if self.resource_error: raise VMError("ISO 池尚未就绪", 409) return {"networks": ["default"], "isos": ["AlmaLinux-10.iso"], "storage_pool": "images"} def ensure_storage_pools(self): self.calls.append(("ensure_storage_pools",)) return {"storage_pool": "panel-dir-kvm", "iso_pool": "panel-dir-iso"} def list_vms(self): self.calls.append(("list_vms",)) if self.list_error: raise VMError("libvirt API 不可用", 502) return [self.vm, *self.other_vms] def list_vm_states(self, vm_ids=None): self.calls.append(("list_vm_states",) if vm_ids is None else ("list_vm_states", tuple(vm_ids))) if self.list_error: raise VMError("libvirt API 不可用", 502) rows = [ {"uuid": vm["uuid"], "name": vm["name"], "state": vm["state"]} for vm in [self.vm, *self.other_vms] ] if vm_ids is None: return rows allowed = set(vm_ids) return [row for row in rows if row["uuid"] in allowed] def list_vm_metadata(self, vm_ids): self.calls.append(("list_vm_metadata", tuple(vm_ids))) if self.list_error: raise VMError("libvirt API 不可用", 502) by_id = {vm["uuid"]: vm for vm in [self.vm, *self.other_vms]} rows = [] for vm_id in vm_ids: if vm_id not in by_id: continue vm = by_id[vm_id] source = vm.get("os_source", "unknown") disks = [ {"capacity_gib": disk.get("capacity_gib")} for disk in vm.get("disks", []) ] capacities = [ disk["capacity_gib"] for disk in disks if isinstance(disk.get("capacity_gib"), (int, float)) and disk["capacity_gib"] > 0 ] rows.append({ "uuid": vm["uuid"], "name": vm["name"], "vcpu": vm.get("vcpu"), "memory_mib": vm.get("memory_mib"), "disks": disks, "disk_gib": round(sum(capacities), 2) if capacities else None, "autostart": vm.get("autostart", False), "managed": vm.get("managed", False), "public_ip_cidr": vm.get("public_ip_cidr"), "created_at": vm.get("created_at"), "os_name": vm.get("os_name"), "os_source": source, "install_iso": vm.get("install_iso"), "login_name": "root" if source == "cloud_template" else None, }) return rows def get_vm(self, vm_id): self.calls.append(("get_vm", vm_id)) if vm_id != self.vm["uuid"]: raise VMError("虚拟机不存在", 404) return self.vm def get_vm_state(self, vm_id): self.calls.append(("get_vm_state", vm_id)) if vm_id != self.vm["uuid"]: raise VMError("虚拟机不存在", 404) return {"uuid": self.vm["uuid"], "name": self.vm["name"], "state": self.vm["state"]} def create_vm(self, spec): self.calls.append(("create_vm", spec)) return self.vm def create_user_iso_vm(self, spec, user_id, volume_name, iso_id, display_name): self.calls.append(("create_user_iso_vm", spec, user_id, volume_name, iso_id, display_name)) if (user_id, volume_name) not in self.user_iso_volumes: raise VMError("用户 ISO 不存在", 404) self.user_iso_create_started.set() if self.user_iso_create_release is not None: assert self.user_iso_create_release.wait(timeout=5) self.vm = { **self.vm, "uuid": spec.get("vm_uuid", self.vm["uuid"]), "name": spec["name"], "managed": True, "os_source": "iso", } return self.vm def create_cloud_vm(self, spec, template_volume_name): self.calls.append(("create_cloud_vm", spec, template_volume_name)) self.platform_policy_snapshot = spec.get( "platform_network_policy_snapshot", default_platform_policy_snapshot(), ) if self.vm.get("os_source") == "cloud_template": self.other_vms.append(self.vm.copy()) self.vm = { **self.vm, "uuid": spec["vm_uuid"], "name": spec["name"], "managed": True, "os_source": "cloud_template", "public_ip_cidr": spec["public_ip_cidr"], "os_name": spec["os_name"], "public_pool_key": spec.get("public_pool_key"), "credential_generation": f"panel-seed-{spec['vm_uuid']}.iso", } return self.vm def reinstall_cloud_vm(self, vm_id, template_volume_name, *, os_name=None, ssh_public_key="", root_password_hash=None, progress=None): self.calls.append(("reinstall_cloud_vm", vm_id, template_volume_name, ssh_public_key, root_password_hash, os_name)) self.reinstall_started.set() if self.reinstall_gate is not None: assert self.reinstall_gate.wait(timeout=5), "test did not release reinstall job" if progress is not None and self.reinstall_emit_progress: progress("completed") generation = f"panel-seed-reinstall-{len(self.calls)}.iso" self.vm["credential_generation"] = generation result = {"vm": self.vm, "credential_generation": generation} if self.reinstall_result is not None: result.update(self.reinstall_result) return result def import_template(self, image_path, volume_name, virtual_size): self.calls.append(("import_template", volume_name, virtual_size)) return {"volume_name": volume_name, "virtual_size": virtual_size, "image_bytes": image_path.stat().st_size} def cache_template(self, image_path, volume_name, virtual_size, *, trusted_replica_volume_name=None, trusted_replica_identity=None): self.calls.append(("cache_template", volume_name, virtual_size, image_path.stat().st_size, trusted_replica_volume_name, trusted_replica_identity)) cached_volume_name = trusted_replica_volume_name or volume_name replica_identity = trusted_replica_identity or hashlib.sha256( f"{cached_volume_name}:{virtual_size}".encode("ascii") ).hexdigest() return {"volume_name": cached_volume_name, "virtual_size": virtual_size, "image_bytes": image_path.stat().st_size, "already_cached": trusted_replica_volume_name is not None, "replica_identity": replica_identity} def import_rescue_iso(self, image_path, volume_name): self.calls.append(("import_rescue_iso", volume_name, image_path.stat().st_size)) return {"volume_name": volume_name, "image_bytes": image_path.stat().st_size} def import_user_iso(self, image_path, user_id, volume_name): self.calls.append(("import_user_iso", user_id, volume_name, image_path.stat().st_size)) if self.user_iso_import_error is not None: raise self.user_iso_import_error self.user_iso_volumes.add((user_id, volume_name)) return {"volume_name": volume_name, "image_bytes": image_path.stat().st_size} def cache_user_iso(self, image_path, user_id, volume_name, active_volume_names=None, *, trusted_existing=False): self.calls.append(("cache_user_iso", user_id, volume_name, image_path.stat().st_size, trusted_existing, set(active_volume_names or ()))) self.user_iso_cache_started.set() if self.user_iso_cache_release is not None: assert self.user_iso_cache_release.wait(timeout=5) if self.user_iso_import_error is not None: raise self.user_iso_import_error already_cached = (user_id, volume_name) in self.user_iso_volumes self.user_iso_volumes.add((user_id, volume_name)) return {"volume_name": volume_name, "image_bytes": image_path.stat().st_size, "already_cached": already_cached} def check_user_iso_storage(self, user_id): self.calls.append(("check_user_iso_storage", user_id)) if self.user_iso_storage_error is not None: raise self.user_iso_storage_error return {"available_bytes": self.user_iso_storage_available} def delete_user_iso(self, user_id, volume_name): self.calls.append(("delete_user_iso", user_id, volume_name)) self.user_iso_delete_started.set() if self.user_iso_delete_release is not None: assert self.user_iso_delete_release.wait(timeout=5) if self.user_iso_delete_error is not None: raise self.user_iso_delete_error if (user_id, volume_name) not in self.user_iso_volumes: raise VMError( "用户 ISO 不存在", 404, error_code="user_iso_volume_not_found", ) self.user_iso_volumes.remove((user_id, volume_name)) return {"volume_name": volume_name, "deleted": True} def delete_rescue_iso(self, volume_name): self.calls.append(("delete_rescue_iso", volume_name)) if self.rescue_delete_error is not None: raise self.rescue_delete_error return {"volume_name": volume_name, "deleted": True} def prepare_rescue_vm(self, vm_id, volume_name): self.calls.append(("prepare_rescue_vm", vm_id, volume_name)) if self.vm.get("rescue_mode") or self.vm.get("rescue_staged"): raise VMError("已经处于救援模式", 409) return f'{self.vm["name"]}' def enter_rescue_vm(self, vm_id, volume_name, original_xml): self.calls.append(("enter_rescue_vm", vm_id, volume_name, original_xml)) if self.rescue_enter_error is not None: raise self.rescue_enter_error if self.rescue_pending_manual_restart: self.vm["rescue_staged"] = True self.vm["rescue_mode"] = False return {"vm": self.vm, "pending_manual_restart": True, "warning": "救援 ISO 已配置为下次冷启动;请手动强制断电后开机"} self.vm["rescue_mode"] = True self.vm["rescue_staged"] = False self.vm["rescue_volume_name"] = volume_name return {"vm": self.vm} def exit_rescue_vm(self, vm_id, original_xml, *, network_suspended=False): self.calls.append(("exit_rescue_vm", vm_id, original_xml, network_suspended)) self.vm["rescue_mode"] = False self.vm["rescue_staged"] = False self.vm["rescue_volume_name"] = None self.vm["network_suspended"] = network_suspended self.vm["state"] = "running" return {"vm": self.vm} def force_start_staged_rescue_vm(self, vm_id, original_xml): self.calls.append(("force_start_staged_rescue_vm", vm_id, original_xml)) if not self.vm.get("rescue_staged"): raise VMError("救援 ISO 尚未预挂载", 409) self.vm["state"] = "running" self.vm["rescue_staged"] = False self.vm["rescue_mode"] = True return {"vm": self.vm} def action(self, vm_id, action): self.calls.append(("action", vm_id, action)) if self.vm.get("rescue_staged") and action == "poweroff": self.vm["state"] = "shutoff" self.vm["rescue_mode"] = True elif self.vm.get("rescue_staged") and action == "start": self.vm["state"] = "running" self.vm["rescue_mode"] = True self.vm["rescue_staged"] = False return self.vm def service_suspend(self, vm_id): self.calls.append(("service_suspend", vm_id)) if self.snapshot_backup_active: raise VMError("虚拟机仍在执行在线快照备份", 409) was_running = self.vm["state"] == "running" self.vm["state"] = "shutoff" self.vm["autostart"] = False return {**self.vm, "service_was_running": was_running} def service_resume(self, vm_id, *, start_if_suspended=False): self.calls.append(("service_resume", vm_id, start_if_suspended)) self.vm["autostart"] = True if start_if_suspended: self.vm["state"] = "running" return self.vm def network_suspend(self, vm_id): self.calls.append(("network_suspend", vm_id)) if self.snapshot_backup_active: raise VMError("虚拟机仍在执行在线快照备份", 409) self.vm["network_suspended"] = True return self.vm def network_resume(self, vm_id): self.calls.append(("network_resume", vm_id)) self.vm["network_suspended"] = False return self.vm def get_firewall_policy(self, vm_id): self.calls.append(("get_firewall_policy", vm_id)) policy_evidence = { "platform_policy_snapshot": self.platform_policy_snapshot, "platform_policy_digest": self.platform_policy_snapshot["digest"], } if self.firewall_filter_digest is None: return { **policy_evidence, "enabled": False, "filter_mode": "baseline", "filter_digest": None, "sync_state": "active", "matches": True, "coherent": True, } return { **policy_evidence, "enabled": self.firewall_enabled, "filter_mode": "managed", "filter_digest": self.firewall_filter_digest, "sync_state": "active", "matches": True, "coherent": True, } def apply_firewall_policy(self, vm_id, *, enabled, rules): self.calls.append(("apply_firewall_policy", vm_id, enabled, rules)) if self.firewall_apply_error is not None: raise self.firewall_apply_error normalized = normalize_firewall_rules(rules) digest = firewall_policy_digest(enabled, normalized) self.firewall_enabled = enabled self.firewall_rules = normalized self.firewall_filter_digest = build_firewall_filter_xml( vm_id, enabled, normalized, platform_policy_snapshot=self.platform_policy_snapshot, )[3] return { "enabled": enabled, "rules": normalized, "policy_digest": digest, "filter_digest": self.firewall_filter_digest, "platform_policy_snapshot": self.platform_policy_snapshot, "platform_policy_digest": self.platform_policy_snapshot["digest"], "sync_state": "active", "matches": True, "coherent": True, } def reconcile_firewall_policy( self, vm_id, *, enabled, rules, compiler_version=FIREWALL_FILTER_COMPILER_VERSION, ): self.calls.append(( "reconcile_firewall_policy", vm_id, enabled, rules, compiler_version, )) normalized = normalize_firewall_rules(rules) digest = firewall_policy_digest(enabled, normalized) expected_filter = build_firewall_filter_xml( vm_id, enabled, normalized, compiler_version=compiler_version, platform_policy_snapshot=self.platform_policy_snapshot, )[3] matches = ( self.firewall_filter_digest == expected_filter and self.firewall_enabled == enabled and self.firewall_rules == normalized ) return { "enabled": self.firewall_enabled, "filter_mode": "managed" if self.firewall_filter_digest else "baseline", "filter_digest": self.firewall_filter_digest, "platform_policy_snapshot": self.platform_policy_snapshot, "platform_policy_digest": self.platform_policy_snapshot["digest"], "sync_state": "active", "matches": matches, "coherent": True, "policy_digest": digest, "expected_filter_digest": expected_filter, "rules": normalized, } def delete_firewall_filter(self, vm_id): self.calls.append(("delete_firewall_filter", vm_id)) if self.firewall_cleanup_error is not None: raise self.firewall_cleanup_error self.firewall_filter_digest = None self.firewall_enabled = False self.firewall_rules = [] return {"deleted": True} def delete_vm(self, vm_id, delete_disks): self.calls.append(("delete_vm", vm_id, delete_disks)) if self.delete_vm_error is not None: raise self.delete_vm_error return {"uuid": vm_id, "deleted": True, "deleted_disks": []} def create_live_snapshot(self, vm_id, snapshot_key, *, consistency, progress=None): self.calls.append(("create_live_snapshot", vm_id, snapshot_key, consistency)) if self.snapshot_create_error is not None: raise self.snapshot_create_error if progress is not None: progress("copying") progress("verifying") return { "snapshot_key": snapshot_key, "created": True, "consistency": consistency, "size_bytes": 20 * 1024**3, "power_state": "running", "volume_name": snapshot_volume_name(vm_id, snapshot_key), "volume_identity": "a" * 64, } def thaw_guest_filesystems(self, vm_id): self.calls.append(("thaw_guest_filesystems", vm_id)) if self.snapshot_thaw_error is not None: raise self.snapshot_thaw_error return {"uuid": vm_id, "thawed": True, "count": 1, "power_state": self.vm["state"]} def release_live_snapshot_completed_evidence(self, vm_id): self.calls.append(("release_live_snapshot_completed_evidence", vm_id)) def snapshot_restore_plan(self, vm_id, operation_id): self.calls.append(("snapshot_restore_plan", vm_id, operation_id)) return { "old_volume_name": f"panel-{vm_id}.qcow2", "replacement_volume_name": snapshot_restore_volume_name( vm_id, operation_id), "was_running": self.vm["state"] == "running", } def restore_live_snapshot(self, vm_id, snapshot_key, snapshot_volume, operation_id, *, expected_old_volume=None, progress=None): self.calls.append(("restore_live_snapshot", vm_id, snapshot_key, snapshot_volume, operation_id, expected_old_volume)) if self.snapshot_restore_error is not None: raise self.snapshot_restore_error if progress is not None: progress("cloning") progress("switching") return { "snapshot_key": snapshot_key, "restored": True, "power_state": self.vm["state"], } def reconcile_live_snapshot_create(self, vm_id, snapshot_key, snapshot_volume, *, verified_capacity=None, verified_identity=None): self.calls.append(("reconcile_live_snapshot_create", vm_id, snapshot_key, snapshot_volume, verified_capacity, verified_identity)) return self.snapshot_reconcile_create or { "outcome": "succeeded", "snapshot_key": snapshot_key, "size_bytes": 20 * 1024**3, "power_state": "running", } def reconcile_live_snapshot_restore(self, vm_id, snapshot_key, snapshot_volume, operation_id, old_volume_name, was_running): self.calls.append(("reconcile_live_snapshot_restore", vm_id, snapshot_key, snapshot_volume, operation_id, old_volume_name, was_running)) return self.snapshot_reconcile_restore or { "outcome": "succeeded", "snapshot_key": snapshot_key, "power_state": "running", } def reconcile_live_snapshot_delete(self, vm_id, snapshot_key, snapshot_volume): self.calls.append(("reconcile_live_snapshot_delete", vm_id, snapshot_key, snapshot_volume)) return self.snapshot_reconcile_delete or { "outcome": "succeeded", "snapshot_key": snapshot_key, } def validate_snapshot_volume(self, vm_id, snapshot_key, snapshot_volume): self.calls.append(("validate_snapshot_volume", vm_id, snapshot_key, snapshot_volume)) return {"snapshot_key": snapshot_key, "deletable": True} def delete_snapshot_volume(self, vm_id, snapshot_key, snapshot_volume, *, allow_missing_vm=False): self.calls.append(("delete_snapshot_volume", vm_id, snapshot_key, snapshot_volume, allow_missing_vm)) self.snapshot_delete_started.set() if self.snapshot_delete_release is not None: assert self.snapshot_delete_release.wait(timeout=5) if self.snapshot_delete_error is not None: raise self.snapshot_delete_error return {"snapshot_key": snapshot_key, "deleted": True} def change_cloud_vm_settings(self, vm_id, *, hostname=None, root_password_hash=None, ssh_public_key=None, confirm_restart=False, progress=None): self.calls.append(("change_cloud_vm_settings", vm_id, hostname, root_password_hash, ssh_public_key, confirm_restart)) if hostname is not None: self.vm["name"] = hostname return {"vm": dict(self.vm), "was_running": True} def console_port(self, vm_id): self.calls.append(("console_port", vm_id)) return 5907 class FakeRemoteManager: def __init__(self) -> None: self.calls: list[tuple] = [] self.profile: dict | None = None self.staged_profiles: list = [] self.unlock_passphrase: str | None = None def current(self): return self.profile def scan(self, host, port): self.calls.append(("scan", host, port)) return {"host": host, "port": port, "key_type": "ssh-ed25519", "fingerprint": "SHA256:example", "known_hosts_line": HOST_BODY["host_key"]} def stage(self, profile, confirmed_fingerprint): validate_public_pool( profile.public_pool_cidr, profile.public_gateway, profile.public_dns_servers, profile.public_reserved_ips, profile.host, profile.public_vm_prefix, ) self.calls.append(("stage", profile.host, profile.port, confirmed_fingerprint)) self.staged_profiles.append(profile) return SimpleNamespace( libvirt_uri="qemu+ssh://root@vp-managed/system?command=staged", profile=profile, ) def test(self, staged): self.calls.append(("test", staged.libvirt_uri)) return {"ok": True, "ssh": "connected", "libvirt": "available"} def abort(self, staged): self.calls.append(("abort", staged.libvirt_uri)) def commit(self, staged): self.calls.append(("commit", staged.libvirt_uri)) self.unlock_passphrase = staged.profile.private_key_passphrase or None self.profile = { "host": staged.profile.host, "port": staged.profile.port, "key_type": "ssh-ed25519", "fingerprint": "SHA256:example", "private_key_configured": True, "private_key_encrypted": bool(self.unlock_passphrase), "key_locked": False, "private_key_passphrase_saved": bool(self.unlock_passphrase), "storage_pool": staged.profile.storage_pool, "iso_pool": staged.profile.iso_pool, "rescue_iso_pool": staged.profile.rescue_iso_pool, "default_network": staged.profile.default_network, "region": staged.profile.region, "fabric_endpoint_ip": staged.profile.fabric_endpoint_ip, "public_pool_cidr": getattr(staged.profile, "public_pool_cidr", ""), "public_gateway": getattr(staged.profile, "public_gateway", ""), "public_dns_servers": list(getattr(staged.profile, "public_dns_servers", [])), "public_reserved_ips": list(getattr(staged.profile, "public_reserved_ips", [])), "public_vm_prefix": getattr(staged.profile, "public_vm_prefix", None), "libvirt_uri": "qemu+ssh://root@vp-managed/system?no_tty=1&command=/fake/ssh-wrapper", "ssh_target": "vp-managed", "ssh_config_file": "/fake/config", "ssh_known_hosts_file": "/fake/known_hosts", } return self.profile def unlock_current(self, passphrase): self.calls.append(("unlock_current", passphrase)) if passphrase != self.unlock_passphrase or self.profile is None: raise RemoteHostError("私钥口令错误", 400) self.profile["key_locked"] = False return self.profile @pytest.fixture def web(tmp_path): state = PanelState(tmp_path / "panel-data") service = FakeVMService() manager = FakeRemoteManager() seen_profiles: list[dict] = [] def service_factory(profile): seen_profiles.append(profile) return service settings = Settings(data_dir=state.data_dir, static_dir=STATIC_DIR) app = create_app(settings, panel_state=state, remote_manager=manager, service_factory=service_factory) token = state.token_file.read_text(encoding="ascii").strip() with TestClient( app, base_url=ORIGIN, ) as client: yield client, state, token, service, manager, seen_profiles def test_first_start_creates_token_and_restarts_reuse_it(tmp_path): state = PanelState(tmp_path / "panel-data") settings = Settings(data_dir=state.data_dir, static_dir=STATIC_DIR) manager = FakeRemoteManager() with patch("virsh_panel.app.STARTUP_LOG.warning") as warning: create_app(settings, panel_state=state, remote_manager=manager) token = state.token_file.read_text(encoding="ascii").strip() assert warning.call_args.args == ("VIRSH_PANEL_SETUP_TOKEN=%s", token) assert len(token) >= 32 create_app(settings, panel_state=PanelState(state.data_dir), remote_manager=manager) assert state.token_file.read_text(encoding="ascii").strip() == token assert warning.call_count == 2 state.create_admin(token, "admin", PASSWORD) create_app(settings, panel_state=PanelState(state.data_dir), remote_manager=manager) assert warning.call_count == 2 assert not state.token_file.exists() @pytest.mark.parametrize("operation", [ "service-suspend", "service-resume", "network-suspend", "network-resume", ]) def test_service_target_routes_are_not_exposed_by_browser_panel(web, operation): client, *_ = web response = client.post(f"/api/v1/vms/{VM_ID}/{operation}") assert response.status_code == 404 def test_lifespan_closes_real_manager_interface(tmp_path): state = PanelState(tmp_path / "panel-data") settings = Settings(data_dir=state.data_dir, static_dir=STATIC_DIR) manager = FakeRemoteManager() closed: list[bool] = [] manager.close = lambda: closed.append(True) app = create_app(settings, panel_state=state, remote_manager=manager) with TestClient(app, base_url=ORIGIN) as client: assert client.get("/api/v1/health").status_code == 200 assert closed == [] assert closed == [True] def setup_admin(client: TestClient, token: str) -> str: response = client.post("/api/v1/setup/admin", json={ "token": token, "username": "admin", "password": PASSWORD, }) assert response.status_code == 200 return response.json()["csrf_token"] def login(client: TestClient) -> str: response = client.post("/api/v1/login", json={"username": "admin", "password": PASSWORD}) assert response.status_code == 200 return response.json()["csrf_token"] def configure_host(client: TestClient, csrf: str) -> dict: response = client.put("/api/v1/host", json=HOST_BODY, headers={"X-CSRF-Token": csrf}) assert response.status_code == 200 return response.json() def wait_for_import_job(client: TestClient, job_id: str) -> dict: for _ in range(100): response = client.get(f"/api/v1/vm-templates/import-jobs/{job_id}") assert response.status_code == 200 result = response.json() if result["status"] != "running": return result time.sleep(0.01) pytest.fail("云镜像导入任务未在测试等待时间内结束") def wait_for_reinstall_job(client: TestClient, job_id: str, csrf: str) -> dict: for _ in range(100): response = client.get( f"/api/v1/reinstall-jobs/{job_id}", headers={"X-CSRF-Token": csrf}, ) assert response.status_code == 200 result = response.json() if result["status"] not in ("queued", "running"): return result time.sleep(0.01) pytest.fail("重装任务未在测试等待时间内结束") def wait_for_snapshot_state(client: TestClient, snapshot_key: str, expected: str = "ready") -> dict: for _ in range(100): response = client.get( f"/api/v1/vms/{VM_ID}/snapshots/{snapshot_key}") if response.status_code == 200: result = response.json() if result["state"] == expected: return result time.sleep(0.01) pytest.fail(f"快照未进入预期状态: {expected}") def configure_snapshot_case(web): client, _state, token, service, _manager, _seen = web csrf = setup_admin(client, token) configure_host(client, csrf) service.vm.update( managed=True, os_source="cloud_template", rescue_mode=False, rescue_staged=False, ) return client, service, csrf def create_ready_snapshot(client: TestClient, csrf: str, snapshot_key: str): response = client.post( f"/api/v1/vms/{VM_ID}/snapshots", json={ "snapshot_key": snapshot_key, "name": "发布前恢复点", "consistency_mode": "filesystem", }, headers={"X-CSRF-Token": csrf}, ) assert response.status_code == 202, response.text return wait_for_snapshot_state(client, snapshot_key) def test_snapshot_engine_limit_and_public_records_hide_host_paths(web): client, service, csrf = configure_snapshot_case(web) first = create_ready_snapshot(client, csrf, "a" * 32) second = create_ready_snapshot(client, csrf, "b" * 32) assert first["consistency"] == "filesystem" assert second["state"] == "ready" listed = client.get(f"/api/v1/vms/{VM_ID}/snapshots") assert listed.status_code == 200 assert listed.json()["limit"] == 2 assert len(listed.json()["items"]) == 2 assert all("volume_name" not in row for row in listed.json()["items"]) rejected = client.post( f"/api/v1/vms/{VM_ID}/snapshots", json={ "snapshot_key": "c" * 32, "name": "第三个快照", "consistency_mode": "crash", }, headers={"X-CSRF-Token": csrf}, ) assert rejected.status_code == 409 assert len([ call for call in service.calls if call[0] == "create_live_snapshot" ]) == 2 def test_snapshot_restore_uses_stable_browser_operation_id(web): client, service, csrf = configure_snapshot_case(web) snapshot_key = "9" * 32 create_ready_snapshot(client, csrf, snapshot_key) queued = client.post( f"/api/v1/vms/{VM_ID}/snapshots/{snapshot_key}/restore", json={}, headers={"X-CSRF-Token": csrf}, ) assert queued.status_code == 202, queued.text wait_for_snapshot_state(client, snapshot_key) restore_call = next( call for call in service.calls if call[0] == "restore_live_snapshot") assert restore_call[4] == queued.json()["job_id"] def test_vm_delete_failure_keeps_snapshots_and_never_calls_volume_delete(web): client, service, csrf = configure_snapshot_case(web) snapshot_key = "d" * 32 create_ready_snapshot(client, csrf, snapshot_key) service.delete_vm_error = VMError("虚拟机仍在运行", 409) response = client.delete( f"/api/v1/vms/{VM_ID}?delete_disks=true", headers={"X-CSRF-Token": csrf}, ) assert response.status_code == 409 ordered = [call[0] for call in service.calls if call[0] in {"validate_snapshot_volume", "delete_vm", "delete_snapshot_volume"}] assert ordered[-2:] == ["validate_snapshot_volume", "delete_vm"] assert "delete_snapshot_volume" not in ordered assert client.get( f"/api/v1/vms/{VM_ID}/snapshots/{snapshot_key}").status_code == 200 def test_vm_delete_commits_before_snapshot_cleanup_and_preserves_failed_catalog(web): client, service, csrf = configure_snapshot_case(web) snapshot_key = "e" * 32 create_ready_snapshot(client, csrf, snapshot_key) service.snapshot_delete_error = VMError("快照卷删除响应丢失", 502) response = client.delete( f"/api/v1/vms/{VM_ID}?delete_disks=true", headers={"X-CSRF-Token": csrf}, ) assert response.status_code == 503 assert response.json()["error_code"] == "vm_delete_snapshot_cleanup_pending" ordered = [call[0] for call in service.calls if call[0] in {"validate_snapshot_volume", "delete_vm", "delete_snapshot_volume"}] assert ordered[-3:] == [ "validate_snapshot_volume", "delete_vm", "delete_snapshot_volume", ] assert client.get( f"/api/v1/vms/{VM_ID}/snapshots/{snapshot_key}").status_code == 200 def test_retained_snapshot_blocks_reinstall_but_allows_settings_and_power(web): client, _state, _token, service, _manager, _seen = web csrf, template_id, _volume_name = configure_reinstall_case(web) snapshot_key = "f" * 32 create_ready_snapshot(client, csrf, snapshot_key) headers = {"X-CSRF-Token": csrf} reinstall_body = { "template_id": template_id, "ssh_public_key": "", "confirmation_name": service.vm["name"], } allowed_power = client.post( f"/api/v1/vms/{VM_ID}/actions", json={"action": "reset"}, headers=headers, ) blocked_reinstall = client.post( f"/api/v1/vms/{VM_ID}/reinstall", json=reinstall_body, headers=headers, ) allowed_settings = client.post( f"/api/v1/vms/{VM_ID}/settings", json={"hostname": "node.example.test", "confirm_restart": True}, headers=headers, ) allowed_password_reset = client.post( f"/api/v1/vms/{VM_ID}/settings", json={"root_password": "Snapshot-safe-Password!42", "confirm_restart": True}, headers=headers, ) assert allowed_power.status_code == 200 assert blocked_reinstall.status_code == 409 assert allowed_settings.status_code == 200 assert allowed_password_reset.status_code == 200 assert not any(call[0] == "reinstall_cloud_vm" for call in service.calls) assert len([call for call in service.calls if call[0] == "change_cloud_vm_settings"]) == 2 queued_delete = client.request( "DELETE", f"/api/v1/vms/{VM_ID}/snapshots/{snapshot_key}", json={}, headers=headers, ) assert queued_delete.status_code == 202, queued_delete.text for _ in range(100): if client.get( f"/api/v1/vms/{VM_ID}/snapshots/{snapshot_key}").status_code == 404: break time.sleep(0.01) else: pytest.fail("最后一个快照未在测试等待时间内删除") reinstall_body["confirmation_name"] = service.vm["name"] queued_reinstall = client.post( f"/api/v1/vms/{VM_ID}/reinstall", json=reinstall_body, headers=headers, ) assert queued_reinstall.status_code == 202, queued_reinstall.text assert wait_for_reinstall_job( client, queued_reinstall.json()["job_id"], csrf)["status"] == "succeeded" def test_retained_snapshot_only_blocks_host_identity_or_storage_pool_change(web): client, _service, csrf = configure_snapshot_case(web) create_ready_snapshot(client, csrf, "8" * 32) headers = {"X-CSRF-Token": csrf} same_remote_key_rotation = client.put( "/api/v1/host", json={**HOST_BODY, "private_key": HOST_BODY["private_key"] + "\n"}, headers=headers, ) assert same_remote_key_rotation.status_code == 200, same_remote_key_rotation.text changed_pool = client.put( "/api/v1/host", json={**HOST_BODY, "storage_pool": "other-images"}, headers=headers, ) changed_host = client.put( "/api/v1/host", json={**HOST_BODY, "host": "other-host.example.test"}, headers=headers, ) assert changed_pool.status_code == 409 assert changed_host.status_code == 409 assert "本地快照" in changed_pool.text def configure_reinstall_case(web): client, state, token, service, manager, _ = web csrf = setup_admin(client, token) assert client.put( "/api/v1/host", json={**HOST_BODY, "default_network": "bridge:br0"}, headers={"X-CSRF-Token": csrf}, ).status_code == 200 scope = template_scope(manager.current()) template_id = template_id_for(scope, "d" * 64) volume_name = template_volume_name(template_id) TemplateStore(state.data_dir).add( scope, {"id": template_id, "volume_name": volume_name, "name": "AlmaLinux 10"}, ) service.vm.update({ "name": "cloud-vm", "managed": True, "os_source": "cloud_template", "public_ip_cidr": "8.8.8.18/24", "credential_generation": "legacy-seed.iso", }) return csrf, template_id, volume_name def test_setup_token_is_single_use_and_admin_survives_restart(web): client, state, token, service, manager, _ = web assert client.get("/api/v1/setup/status").json() == {"setup_required": True} assert client.get("/api/v1/vms").status_code == 401 assert client.post("/api/v1/login", json={"username": "admin", "password": PASSWORD}).status_code == 409 wrong = client.post("/api/v1/setup/admin", json={ "token": "wrong", "username": "admin", "password": PASSWORD, }) assert wrong.status_code == 403 csrf = setup_admin(client, token) assert csrf cookie = client.cookies.get("virsh_panel_session") assert cookie header = client.post("/api/v1/logout", headers={"X-CSRF-Token": csrf}).headers["set-cookie"] assert "virsh_panel_session=" in header assert client.get("/api/v1/setup/status").json() == {"setup_required": False} assert not state.token_file.exists() assert stat.S_IMODE(state.state_file.stat().st_mode) == 0o600 assert state.initialize_setup_token() is None assert PanelState(state.data_dir).admin()[0] == "admin" assert client.post("/api/v1/setup/admin", json={ "token": token, "username": "other", "password": PASSWORD, }).status_code == 409 assert login(client) assert service.calls == [] and manager.calls == [] def test_login_cookie_csrf_and_logout(web): client, _, token, service, manager, _ = web setup_admin(client, token) assert client.post("/api/v1/login", json={"username": "admin", "password": "bad"}).status_code == 401 response = client.post("/api/v1/login", json={"username": "admin", "password": PASSWORD}) csrf = response.json()["csrf_token"] cookie = response.headers["set-cookie"].lower() assert "httponly" in cookie and "secure" in cookie and "samesite=strict" in cookie assert client.get("/api/v1/session").json()["authenticated"] is True assert client.post("/api/v1/logout").status_code == 403 assert client.post("/api/v1/logout", headers={"X-CSRF-Token": csrf}).status_code == 200 assert client.get("/api/v1/session").json()["authenticated"] is False assert service.calls == [] and manager.calls == [] def test_raw_x_real_ip_cannot_reset_login_limit(web): client, _, token, *_ = web setup_admin(client, token) for index in range(5): response = client.post( "/api/v1/login", json={"username": "admin", "password": "wrong"}, headers={"X-Real-IP": f"198.51.100.{index + 1}"}, ) assert response.status_code == 401 blocked = client.post( "/api/v1/login", json={"username": "admin", "password": PASSWORD}, headers={"X-Real-IP": "203.0.113.99"}, ) assert blocked.status_code == 429 def test_host_scan_test_save_and_secret_is_never_returned(web): client, _, token, service, manager, seen = web csrf = setup_admin(client, token) assert client.get("/api/v1/host").json() == {"configured": False} assert client.get("/api/v1/vms").status_code == 409 assert client.post("/api/v1/host/scan", json={"host": HOST_BODY["host"], "port": 2222}).status_code == 403 headers = {"X-CSRF-Token": csrf} scan = client.post("/api/v1/host/scan", json={"host": HOST_BODY["host"], "port": 2222}, headers=headers) assert scan.json()["fingerprint"] == "SHA256:example" tested = client.post("/api/v1/host/test", json=HOST_BODY, headers=headers) assert tested.status_code == 200 assert tested.json()["resources"]["storage_pool"] == "images" assert manager.current() is None saved = configure_host(client, csrf) assert saved["configured"] is True assert saved["private_key_configured"] is True assert "private_key" not in saved and "host_key" not in saved assert "ssh_config_file" not in saved and "libvirt_uri" not in saved assert saved["warnings"] == [] assert client.get("/api/v1/host").json() == {k: v for k, v in saved.items() if k != "warnings"} assert seen[0]["libvirt_uri"].endswith("command=staged") assert seen[-1]["libvirt_uri"].endswith("command=staged") assert manager.calls.count(("commit", manager.calls[-1][1])) == 1 assert service.calls == [("resources",), ("ensure_storage_pools",), ("resources",)] def test_host_region_is_returned_with_host_and_vms(web): client, _, token, _service, _manager, _ = web csrf = setup_admin(client, token) body = {**HOST_BODY, "region": "中国香港"} headers = {"X-CSRF-Token": csrf} assert client.put("/api/v1/host", json=body, headers=headers).json()["region"] == "中国香港" assert client.get("/api/v1/host").json()["region"] == "中国香港" assert client.get("/api/v1/vms").json()["items"][0]["region"] == "中国香港" assert client.get(f"/api/v1/vms/{VM_ID}").json()["region"] == "中国香港" assert client.post("/api/v1/vms", json=CREATE_BODY, headers=headers).json()["region"] == "中国香港" assert client.put("/api/v1/host", json={**body, "region": "a\nline"}, headers=headers).status_code == 422 def test_host_fabric_endpoint_round_trips_without_changing_ssh_host(web): client, _, token, _service, manager, _ = web csrf = setup_admin(client, token) body = {**HOST_BODY, "fabric_endpoint_ip": "10.20.30.40"} headers = {"X-CSRF-Token": csrf} assert client.post("/api/v1/host/test", json=body, headers=headers).status_code == 200 saved = client.put("/api/v1/host", json=body, headers=headers) assert saved.status_code == 200 assert saved.json()["fabric_endpoint_ip"] == "10.20.30.40" assert saved.json()["host"] == HOST_BODY["host"] assert manager.staged_profiles[-1].fabric_endpoint_ip == "10.20.30.40" assert client.get("/api/v1/host").json()[ "fabric_endpoint_ip"] == "10.20.30.40" def test_host_public_pool_round_trips_and_rejects_invalid_networks(web): client, _, token, _service, manager, _ = web csrf = setup_admin(client, token) headers = {"X-CSRF-Token": csrf} body = { **HOST_BODY, "host": "8.8.8.3", "default_network": "bridge:br0", "public_pool_cidr": "8.8.8.0/24", "public_gateway": "8.8.8.1", "public_dns_servers": ["1.1.1.1", "8.8.4.4"], "public_reserved_ips": ["8.8.8.2", "8.8.8.5"], } tested = client.post("/api/v1/host/test", json=body, headers=headers) assert tested.status_code == 200 saved = client.put("/api/v1/host", json=body, headers=headers) assert saved.status_code == 200 current = client.get("/api/v1/host") assert current.status_code == 200 for key in ("public_pool_cidr", "public_gateway", "public_dns_servers", "public_reserved_ips"): assert getattr(manager.staged_profiles[0], key) == body[key] assert saved.json()[key] == current.json()[key] == body[key] assert manager.current()[key] == body[key] for changes in ( {"public_pool_cidr": "8.8.8.18/24"}, {"public_pool_cidr": "8.8.8.0/23"}, {"public_vm_prefix": 25}, {"public_vm_prefix": 23}, {"public_pool_cidr": "10.0.0.0/24", "public_gateway": "10.0.0.1"}, {"public_gateway": "9.9.9.1"}, {"public_dns_servers": ["invalid-dns"]}, {"public_reserved_ips": ["9.9.9.2"]}, ): rejected = client.put("/api/v1/host", json={**body, **changes}, headers=headers) assert rejected.status_code in (400, 422) assert manager.current()["public_pool_cidr"] == body["public_pool_cidr"] def test_host_inventory_endpoints_are_removed(web): client, _, token, _service, _manager, _ = web csrf = setup_admin(client, token) assert client.put("/api/v1/host", json=HOST_BODY, headers={"X-CSRF-Token": csrf}).status_code == 200 before = client.get("/api/v1/host/network-options") assert before.status_code == 404 assert client.get("/api/v1/host/capacity").status_code == 404 def test_host_accepts_provider_28_and_gateway_address_form(web): client, _, token, _service, manager, _ = web csrf = setup_admin(client, token) body = { **HOST_BODY, "host": "123.123.123.113", "default_network": "bridge:br0", "public_pool_cidr": "123.123.123.113/28", "public_gateway": "123.123.123.113", "public_dns_servers": ["1.1.1.1"], "public_reserved_ips": ["123.123.123.114"], "public_vm_prefix": 24, } headers = {"X-CSRF-Token": csrf} assert client.post("/api/v1/host/test", json=body, headers=headers).status_code == 200 assert client.put("/api/v1/host", json=body, headers=headers).status_code == 200 assert manager.current()["public_pool_cidr"] == body["public_pool_cidr"] assert manager.current()["public_vm_prefix"] == 24 def test_private_key_passphrase_reaches_host_profile_but_is_never_echoed(web): client, _, token, _, manager, _ = web csrf = setup_admin(client, token) secret = "a strong SSH key passphrase" body = {**HOST_BODY, "private_key_passphrase": secret} headers = {"X-CSRF-Token": csrf} tested = client.post("/api/v1/host/test", json=body, headers=headers) saved = client.put("/api/v1/host", json=body, headers=headers) current = client.get("/api/v1/host") assert tested.status_code == saved.status_code == current.status_code == 200 assert len(manager.staged_profiles) == 2 assert all(profile.private_key_passphrase == secret for profile in manager.staged_profiles) assert all(secret not in response.text for response in (tested, saved, current)) assert saved.json()["private_key_encrypted"] is True assert saved.json()["private_key_passphrase_saved"] is True assert current.json()["private_key_passphrase_saved"] is True assert "private_key_passphrase" not in manager.current() def test_host_error_response_has_safe_code_without_echoing_private_key(web, monkeypatch): client, _, token, _, manager, _ = web csrf = setup_admin(client, token) secret = ( "-----BEGIN OPENSSH PRIVATE KEY-----\n" "private-material-must-not-leak\n" "-----END OPENSSH PRIVATE KEY-----" ) def reject_private_key(profile, confirmed_fingerprint): assert profile.private_key == secret assert confirmed_fingerprint == HOST_BODY["confirmed_fingerprint"] raise RemoteHostError( "请提供 PEM 或 OpenSSH 格式的私钥", error_code="host_private_key_format_invalid", ) monkeypatch.setattr(manager, "stage", reject_private_key) response = client.post( "/api/v1/host/test", json={**HOST_BODY, "private_key": secret}, headers={"X-CSRF-Token": csrf}, ) assert response.status_code == 400 assert response.json() == { "error": "请提供 PEM 或 OpenSSH 格式的私钥", "error_code": "host_private_key_format_invalid", } assert secret not in response.text def test_locked_host_returns_423_and_unlock_requires_csrf(web): client, _, token, service, manager, _ = web csrf = setup_admin(client, token) secret = "only held in memory" body = {**HOST_BODY, "private_key_passphrase": secret} saved = client.put("/api/v1/host", json=body, headers={"X-CSRF-Token": csrf}) assert saved.status_code == 200 manager.profile["key_locked"] = True service.calls.clear() current = client.get("/api/v1/host") locked_vms = client.get("/api/v1/vms") assert current.status_code == 200 assert current.json()["key_locked"] is True assert locked_vms.status_code == 423 assert locked_vms.json()["error_code"] == "key_locked" assert service.calls == [] no_csrf = client.post("/api/v1/host/unlock", json={"passphrase": secret}) wrong = client.post("/api/v1/host/unlock", json={"passphrase": "wrong"}, headers={"X-CSRF-Token": csrf}) unlocked = client.post("/api/v1/host/unlock", json={"passphrase": secret}, headers={"X-CSRF-Token": csrf}) assert no_csrf.status_code == 403 assert wrong.status_code == 400 assert unlocked.status_code == 200 assert unlocked.json()["key_locked"] is False assert secret not in unlocked.text assert client.get("/api/v1/vms").status_code == 200 assert manager.calls[-1] == ("unlock_current", secret) def test_unlock_limits_wrong_passphrase_attempts(web): client, _, token, _, manager, _ = web csrf = setup_admin(client, token) secret = "only held in memory" body = {**HOST_BODY, "private_key_passphrase": secret} assert client.put("/api/v1/host", json=body, headers={"X-CSRF-Token": csrf}).status_code == 200 manager.profile["key_locked"] = True headers = {"X-CSRF-Token": csrf} for _ in range(5): assert client.post("/api/v1/host/unlock", json={"passphrase": "wrong"}, headers=headers).status_code == 400 blocked = client.post("/api/v1/host/unlock", json={"passphrase": secret}, headers=headers) assert blocked.status_code == 429 assert manager.profile["key_locked"] is True def test_directory_pool_selectors_are_ensured_only_on_save(web): client, _, token, service, manager, _ = web csrf = setup_admin(client, token) body = {**HOST_BODY, "storage_pool": "/home/kvm", "iso_pool": "/home/iso", "rescue_iso_pool": "/home/rescue-iso"} headers = {"X-CSRF-Token": csrf} tested = client.post("/api/v1/host/test", json=body, headers=headers) assert tested.status_code == 200 assert service.calls == [("resources",)] assert manager.current() is None saved = client.put("/api/v1/host", json=body, headers=headers) assert saved.status_code == 200 assert saved.json()["storage_pool"] == "/home/kvm" assert saved.json()["iso_pool"] == "/home/iso" assert saved.json()["rescue_iso_pool"] == "/home/rescue-iso" assert service.calls == [ ("resources",), ("ensure_storage_pools",), ("resources",), ] def test_rescue_template_upload_requires_separate_host_pool(web): client, _, token, _, _, _ = web csrf = setup_admin(client, token) headers = {"X-CSRF-Token": csrf} saved = client.put("/api/v1/host", json={**HOST_BODY, "rescue_iso_pool": ""}, headers=headers) assert saved.status_code == 200, saved.text assert saved.json()["rescue_iso_pool"] == "" assert client.get("/api/v1/resources").status_code == 200 assert client.post("/api/v1/vms", json=CREATE_BODY, headers=headers).status_code == 201 response = client.get("/api/v1/rescue-templates") assert response.status_code == 409 assert "救援 ISO 目录" in response.json()["error"] response = client.post("/api/v1/rescue-templates?name=Rescue", content=b"not an iso", headers=headers) assert response.status_code == 409 def test_explicit_bridge_selector_round_trips_through_host_api(web): client, _, token, _, manager, seen = web csrf = setup_admin(client, token) body = {**HOST_BODY, "default_network": "bridge:br0"} headers = {"X-CSRF-Token": csrf} tested = client.post("/api/v1/host/test", json=body, headers=headers) saved = client.put("/api/v1/host", json=body, headers=headers) assert tested.status_code == saved.status_code == 200 assert all(profile.default_network == "bridge:br0" for profile in manager.staged_profiles) assert seen[-1]["default_network"] == "bridge:br0" assert saved.json()["default_network"] == "bridge:br0" assert client.get("/api/v1/host").json()["default_network"] == "bridge:br0" def test_record_free_platform_default_firewall_is_revision_zero(web): client, _state, token, service, _manager, _seen = web csrf = setup_admin(client, token) configure_host(client, csrf) service.vm.update( managed=True, os_source="cloud_template", public_ip_cidr="8.8.8.18/24", ) service.firewall_enabled = False service.firewall_rules = [] service.firewall_filter_digest = build_firewall_filter_xml( VM_ID, False, [])[3] response = client.get(f"/api/v1/vms/{VM_ID}/firewall") assert response.status_code == 200, response.text payload = response.json() assert payload["enabled"] is False assert payload["revision"] == 0 assert payload["rules"] == [] assert payload["sync_state"] == "active" assert payload["filter_version"] == FIREWALL_FILTER_COMPILER_VERSION assert payload["filter_digest"] == service.firewall_filter_digest def test_missing_resource_pool_warns_but_allows_host_connection(web): client, _, token, service, manager, _ = web csrf = setup_admin(client, token) service.resource_error = True headers = {"X-CSRF-Token": csrf} tested = client.post("/api/v1/host/test", json=HOST_BODY, headers=headers) assert tested.status_code == 200 assert tested.json()["resources"] is None assert tested.json()["warnings"] == ["ISO 池尚未就绪"] assert manager.current() is None saved = client.put("/api/v1/host", json=HOST_BODY, headers=headers) assert saved.status_code == 200 assert saved.json()["configured"] is True assert saved.json()["warnings"] == ["ISO 池尚未就绪"] def test_vm_crud_actions_and_error_mapping(web): client, _, token, service, _, seen = web csrf = setup_admin(client, token) configure_host(client, csrf) service.calls.clear() seen.clear() headers = {"X-CSRF-Token": csrf} assert client.get("/api/v1/resources").json()["isos"] == ["AlmaLinux-10.iso"] assert client.get("/api/v1/vms").json()["items"][0]["uuid"] == VM_ID assert client.get("/api/v1/vm-states").json() == {"items": [{ "uuid": VM_ID, "name": "alma-test", "state": "running", }]} assert client.get(f"/api/v1/vm-states?ids={VM_ID}").json() == {"items": [{ "uuid": VM_ID, "name": "alma-test", "state": "running", }]} assert client.get(f"/api/v1/vms/{VM_ID}/state").json() == { "uuid": VM_ID, "name": "alma-test", "state": "running", } assert client.get(f"/api/v1/vms/{VM_ID}").json()["name"] == "alma-test" missing = client.get("/api/v1/vms/missing") assert missing.status_code == 404 and missing.json() == {"error": "虚拟机不存在"} assert client.post("/api/v1/vms", json=CREATE_BODY).status_code == 403 assert client.post("/api/v1/vms", json={**CREATE_BODY, "vcpu": 0}, headers=headers).status_code == 422 created = client.post("/api/v1/vms", json=CREATE_BODY, headers=headers) assert created.status_code == 201 and created.json()["uuid"] == VM_ID action = client.post(f"/api/v1/vms/{VM_ID}/actions", json={"action": "reboot"}, headers=headers) assert action.status_code == 200 deleted = client.delete(f"/api/v1/vms/{VM_ID}?delete_disks=true", headers=headers) assert deleted.status_code == 200 and deleted.json()["deleted"] is True assert service.calls == [ ("resources",), ("list_vms",), ("list_vm_states",), ("list_vm_states", (VM_ID,)), ("get_vm_state", VM_ID), ("get_vm", VM_ID), ("get_vm", "missing"), ("create_vm", CREATE_BODY), ("get_vm", VM_ID), ("action", VM_ID, "reboot"), ("get_vm", VM_ID), ("delete_vm", VM_ID, True), ("delete_firewall_filter", VM_ID), ] assert all("command=/fake/ssh-wrapper" in p["libvirt_uri"] for p in seen) def test_vm_metadata_reads_only_selected_ids_and_has_no_credentials(web): client, _, token, service, _, _ = web csrf = setup_admin(client, token) configure_host(client, csrf) service.calls.clear() service.vm.update({ "managed": True, "os_source": "cloud_template", "os_name": "AlmaLinux 10", "public_ip_cidr": "192.0.2.10/24", "created_at": "2026-09-28T00:00:00Z", }) response = client.get(f"/api/v1/vm-metadata?ids={VM_ID}") assert response.status_code == 200, response.text assert response.json() == {"items": [{ "uuid": VM_ID, "name": "alma-test", "vcpu": 2, "memory_mib": 2048, "disks": [], "disk_gib": None, "autostart": False, "managed": True, "public_ip_cidr": "192.0.2.10/24", "created_at": "2026-09-28T00:00:00Z", "os_name": "AlmaLinux 10", "os_source": "cloud_template", "install_iso": None, "login_name": "root", }]} assert service.calls == [("list_vm_metadata", (VM_ID,))] assert "credential" not in response.text and "password" not in response.text assert "console" not in response.text assert all(set(disk) == {"capacity_gib"} for disk in response.json()["items"][0]["disks"]) stale_id = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa" mixed = client.get(f"/api/v1/vm-metadata?ids={stale_id},{VM_ID}") assert mixed.status_code == 200, mixed.text assert [item["uuid"] for item in mixed.json()["items"]] == [VM_ID] invalid = client.get("/api/v1/vm-metadata?ids=not-a-uuid") assert invalid.status_code == 400 too_many = client.get("/api/v1/vm-metadata?ids=" + ",".join([VM_ID] * 101)) assert too_many.status_code == 400 def test_vm_create_uses_vcpu_without_a_separate_nic_queue_field(web): client, _, token, service, _, _ = web csrf = setup_admin(client, token) configure_host(client, csrf) headers = {"X-CSRF-Token": csrf} body = {**CREATE_BODY, "vcpu": 8} created = client.post("/api/v1/vms", json=body, headers=headers) assert created.status_code == 201 assert ("create_vm", body) in service.calls assert client.post("/api/v1/vms", json={**body, "nic_queues": 8}, headers=headers).status_code == 422 def test_rescue_iso_upload_enter_exit_and_safe_lifecycle(web): client, _state, token, service, _manager, _seen = web csrf = setup_admin(client, token) configure_host(client, csrf) headers = {"X-CSRF-Token": csrf, "Content-Type": "application/octet-stream"} json_headers = {"X-CSRF-Token": csrf} assert client.get("/api/v1/rescue-templates").json() == {"templates": []} iso = bytearray(1024 * 1024) for sector, kind in ((16, 1), (17, 0), (18, 255)): offset = sector * 2048 iso[offset] = kind iso[offset + 1:offset + 6] = b"CD001" iso[offset + 6] = 1 iso[17 * 2048 + 7:17 * 2048 + 30] = b"EL TORITO SPECIFICATION" iso[17 * 2048 + 71:17 * 2048 + 75] = (20).to_bytes(4, "little") assert client.post("/api/v1/rescue-templates?name=Rescue", content=iso).status_code == 403 invalid = client.post("/api/v1/rescue-templates?name=Invalid", content=b"invalid", headers=headers) assert invalid.status_code in (413, 422) queued = client.post("/api/v1/rescue-templates?name=Rescue", content=bytes(iso), headers=headers) assert queued.status_code == 202, queued.text import_job_id = queued.json()["job_id"] for _ in range(100): job = client.get(f"/api/v1/rescue-templates/import-jobs/{import_job_id}").json() if job["status"] in {"completed", "failed"}: break time.sleep(0.01) assert job["status"] == "completed", job template = client.get("/api/v1/rescue-templates").json()["templates"][0] assert template["name"] == "Rescue" assert ("import_rescue_iso", template["volume_name"], len(iso)) in service.calls rescue_url = f"/api/v1/vms/{VM_ID}/rescue" wrong = client.post(rescue_url, json={"template_id": template["id"], "confirmation_name": "wrong"}, headers=json_headers) assert wrong.status_code == 422 started = client.post(rescue_url, json={"template_id": template["id"], "confirmation_name": "alma-test"}, headers=json_headers) assert started.status_code == 202, started.text for _ in range(100): rescue_job = client.get( f"/api/v1/rescue-jobs/{started.json()['job_id']}").json() if rescue_job["status"] in {"completed", "failed"}: break time.sleep(0.01) assert rescue_job["status"] == "completed", rescue_job assert client.get(rescue_url).json()["active"] is True assert client.post(f"/api/v1/vms/{VM_ID}/actions", json={"action": "reboot"}, headers=json_headers).status_code == 409 assert client.delete(f"/api/v1/rescue-templates/{template['id']}", headers=headers).status_code == 409 exited = client.post(f"{rescue_url}/exit", json={"confirmation_name": "alma-test", "network_suspended": True}, headers=json_headers) assert exited.status_code == 202, exited.text for _ in range(100): exit_job = client.get(f"/api/v1/rescue-jobs/{exited.json()['job_id']}").json() if exit_job["status"] in {"completed", "failed"}: break time.sleep(0.01) assert exit_job["status"] == "completed", exit_job assert client.get(rescue_url).json()["active"] is False assert service.vm["network_suspended"] is True assert any(call[0] == "exit_rescue_vm" and call[3] is True for call in service.calls) # If a worker dies after saving its recovery record but the original # persistent definition is still present, reading status safely clears # the stale record and allows ordinary VM operations again. restarted = client.post(rescue_url, json={"template_id": template["id"], "confirmation_name": "alma-test"}, headers=json_headers) assert restarted.status_code == 202, restarted.text for _ in range(100): rescue_job = client.get( f"/api/v1/rescue-jobs/{restarted.json()['job_id']}").json() if rescue_job["status"] in {"completed", "failed"}: break time.sleep(0.01) assert rescue_job["status"] == "completed", rescue_job service.vm["rescue_mode"] = False service.vm["rescue_volume_name"] = None assert client.get(rescue_url).json()["status"] is None assert client.post(f"/api/v1/vms/{VM_ID}/actions", json={"action": "reboot"}, headers=json_headers).status_code == 200 # A staged rescue definition survives a graceful-shutdown timeout. The # owner can power off and cold-start it, while reset/reboot stay blocked. service.rescue_pending_manual_restart = True staged_request = client.post(rescue_url, json={"template_id": template["id"], "confirmation_name": "alma-test"}, headers=json_headers) assert staged_request.status_code == 202, staged_request.text for _ in range(100): staged_job = client.get( f"/api/v1/rescue-jobs/{staged_request.json()['job_id']}").json() if staged_job["status"] in {"completed", "failed"}: break time.sleep(0.01) assert staged_job["status"] == "completed", staged_job assert staged_job["pending_manual_restart"] is True staged_state = client.get(rescue_url).json() assert staged_state["staged"] is True and staged_state["active"] is False assert staged_state["can_exit"] is True assert client.post(f"/api/v1/vms/{VM_ID}/actions", json={"action": "reset"}, headers=json_headers).status_code == 409 assert client.post(f"/api/v1/vms/{VM_ID}/actions", json={"action": "poweroff"}, headers=json_headers).status_code == 200 assert client.get(rescue_url).json()["staged"] is True assert client.post(f"/api/v1/vms/{VM_ID}/actions", json={"action": "start"}, headers=json_headers).status_code == 200 assert client.get(rescue_url).json()["active"] is True assert client.get(rescue_url).json()["staged"] is False restored = client.post(f"{rescue_url}/exit", json={"confirmation_name": "alma-test"}, headers=json_headers) assert restored.status_code == 202, restored.text for _ in range(100): restored_job = client.get( f"/api/v1/rescue-jobs/{restored.json()['job_id']}").json() if restored_job["status"] in {"completed", "failed"}: break time.sleep(0.01) assert restored_job["status"] == "completed", restored_job staged_request = client.post(rescue_url, json={"template_id": template["id"], "confirmation_name": "alma-test"}, headers=json_headers) assert staged_request.status_code == 202, staged_request.text for _ in range(100): staged_job = client.get( f"/api/v1/rescue-jobs/{staged_request.json()['job_id']}").json() if staged_job["status"] in {"completed", "failed"}: break time.sleep(0.01) assert staged_job["status"] == "completed", staged_job force_url = f"{rescue_url}/force-start" assert client.post(force_url, json={"confirmation_name": "alma-test"}, headers=json_headers).status_code == 422 assert client.post(force_url, json={"confirmation_name": "wrong", "ack_data_loss": True}, headers=json_headers).status_code == 422 forced = client.post(force_url, json={"confirmation_name": "alma-test", "ack_data_loss": True}, headers=json_headers) assert forced.status_code == 202, forced.text for _ in range(100): force_job = client.get( f"/api/v1/rescue-jobs/{forced.json()['job_id']}").json() if force_job["status"] in {"completed", "failed"}: break time.sleep(0.01) assert force_job["status"] == "completed", force_job assert force_job["operation"] == "force" assert client.get(rescue_url).json()["active"] is True assert client.post(force_url, json={"confirmation_name": "alma-test", "ack_data_loss": True}, headers=json_headers).status_code == 409 restored = client.post(f"{rescue_url}/exit", json={"confirmation_name": "alma-test"}, headers=json_headers) assert restored.status_code == 202, restored.text for _ in range(100): restored_job = client.get( f"/api/v1/rescue-jobs/{restored.json()['job_id']}").json() if restored_job["status"] in {"completed", "failed"}: break time.sleep(0.01) assert restored_job["status"] == "completed", restored_job assert client.delete(f"/api/v1/rescue-templates/{template['id']}", headers=headers).json() == {"deleted": True} def test_rescue_template_delete_preserves_catalog_on_pool_404(web): client, _state, token, service, _manager, _seen = web csrf = setup_admin(client, token) configure_host(client, csrf) headers = {"X-CSRF-Token": csrf, "Content-Type": "application/octet-stream"} iso = bytearray(1024 * 1024) for sector, kind in ((16, 1), (17, 0), (18, 255)): offset = sector * 2048 iso[offset] = kind iso[offset + 1:offset + 6] = b"CD001" iso[offset + 6] = 1 iso[17 * 2048 + 7:17 * 2048 + 30] = b"EL TORITO SPECIFICATION" iso[17 * 2048 + 71:17 * 2048 + 75] = (20).to_bytes(4, "little") queued = client.post( "/api/v1/rescue-templates?name=Deletion boundary", content=bytes(iso), headers=headers, ) assert queued.status_code == 202, queued.text for _ in range(100): job = client.get( f"/api/v1/rescue-templates/import-jobs/{queued.json()['job_id']}" ).json() if job["status"] in {"completed", "failed"}: break time.sleep(0.01) assert job["status"] == "completed", job template = client.get("/api/v1/rescue-templates").json()["templates"][0] service.rescue_delete_error = VMError("存储池 rescue 不存在", 404) failed = client.delete( f"/api/v1/rescue-templates/{template['id']}", headers=headers) assert failed.status_code == 404 assert client.get("/api/v1/rescue-templates").json()["templates"] == [template] service.rescue_delete_error = VMError( "救援镜像仍在使用", 409, error_code="rescue_volume_not_found", ) failed = client.delete( f"/api/v1/rescue-templates/{template['id']}", headers=headers) assert failed.status_code == 409 assert client.get("/api/v1/rescue-templates").json()["templates"] == [template] service.rescue_delete_error = VMError( "救援镜像在宿主机上不存在,请重新上传", 404, error_code="rescue_volume_not_found", ) deleted = client.delete( f"/api/v1/rescue-templates/{template['id']}", headers=headers) assert deleted.status_code == 200 assert client.get("/api/v1/rescue-templates").json() == {"templates": []} def test_orphan_rescue_marker_blocks_vm_actions_even_without_database_record(web): client, _state, token, service, _manager, _seen = web csrf = setup_admin(client, token) configure_host(client, csrf) service.vm["rescue_mode"] = True headers = {"X-CSRF-Token": csrf} assert client.post(f"/api/v1/vms/{VM_ID}/actions", json={"action": "reboot"}, headers=headers).status_code == 409 assert client.delete(f"/api/v1/vms/{VM_ID}", headers=headers).status_code == 409 service.vm["rescue_mode"] = False service.vm["rescue_staged"] = True assert client.post(f"/api/v1/vms/{VM_ID}/actions", json={"action": "reboot"}, headers=headers).status_code == 409 assert client.delete(f"/api/v1/vms/{VM_ID}", headers=headers).status_code == 409 def test_orphan_staged_rescue_marker_blocks_reinstall(web): client, _state, _token, service, _manager, _seen = web csrf, template_id, _volume_name = configure_reinstall_case(web) service.vm["rescue_staged"] = True response = client.post( f"/api/v1/vms/{VM_ID}/reinstall", json={"template_id": template_id, "confirmation_name": "cloud-vm", "root_password": GUEST_PASSWORD}, headers={"X-CSRF-Token": csrf}, ) assert response.status_code == 409, response.text def test_rescue_premount_failure_does_not_enable_force_restart(web): client, _state, token, service, _manager, _seen = web csrf = setup_admin(client, token) configure_host(client, csrf) headers = {"X-CSRF-Token": csrf} iso = bytearray(1024 * 1024) for sector, kind in ((16, 1), (17, 0), (18, 255)): offset = sector * 2048 iso[offset] = kind iso[offset + 1:offset + 6] = b"CD001" iso[offset + 6] = 1 iso[17 * 2048 + 7:17 * 2048 + 30] = b"EL TORITO SPECIFICATION" iso[17 * 2048 + 71:17 * 2048 + 75] = (20).to_bytes(4, "little") imported = client.post("/api/v1/rescue-templates?name=Rescue", content=bytes(iso), headers=headers) assert imported.status_code == 202, imported.text for _ in range(100): import_job = client.get( f"/api/v1/rescue-templates/import-jobs/{imported.json()['job_id']}").json() if import_job["status"] in {"completed", "failed"}: break time.sleep(0.01) assert import_job["status"] == "completed", import_job template = client.get("/api/v1/rescue-templates").json()["templates"][0] service.rescue_enter_error = VMError( "救援 ISO 预挂载失败,原虚拟机未受影响;宿主机路径 /var/lib/libvirt/qemu/secret.xml", 502) started = client.post(f"/api/v1/vms/{VM_ID}/rescue", json={"template_id": template["id"], "confirmation_name": "alma-test"}, headers=headers) assert started.status_code == 202, started.text for _ in range(100): job = client.get(f"/api/v1/rescue-jobs/{started.json()['job_id']}").json() if job["status"] in {"completed", "failed"}: break time.sleep(0.01) assert job["status"] == "failed", job assert "救援 ISO 预挂载失败" in job["error"] assert "/var/lib/libvirt" not in job["error"] assert job["phase"] == "救援操作失败" assert client.get(f"/api/v1/vms/{VM_ID}/rescue").json()["status"] is None assert client.post(f"/api/v1/vms/{VM_ID}/rescue/force-start", json={"confirmation_name": "alma-test", "ack_data_loss": True}, headers=headers).status_code == 409 assert client.post(f"/api/v1/vms/{VM_ID}/actions", json={"action": "poweroff"}, headers=headers).status_code == 200 def test_cloud_template_and_creation_routes_enforce_auth_csrf_and_fields(web): client, _, token, service, _, _ = web import_body = { "name": "AlmaLinux 10 Generic Cloud", "url": "https://example.invalid/AlmaLinux-10-GenericCloud.qcow2", "sha256": "a" * 64, } assert client.get("/api/v1/vm-templates").status_code == 401 assert client.post("/api/v1/vm-templates/import", json=import_body).status_code == 401 assert client.post("/api/v1/vms", json=CLOUD_CREATE_BODY).status_code == 401 csrf = setup_admin(client, token) configure_host(client, csrf) assert client.get("/api/v1/vm-templates").json() == {"templates": []} assert client.post("/api/v1/vm-templates/import", json=import_body).status_code == 403 assert client.post("/api/v1/vms", json=CLOUD_CREATE_BODY).status_code == 403 headers = {"X-CSRF-Token": csrf} assert client.post("/api/v1/vm-templates/import", json={**import_body, "sha256": "bad"}, headers=headers).status_code == 422 assert client.post("/api/v1/vms", json={**CLOUD_CREATE_BODY, "source": "unknown"}, headers=headers).status_code == 422 assert client.post("/api/v1/vms", json={k: v for k, v in CLOUD_CREATE_BODY.items() if k != "public_ip_cidr"}, headers=headers).status_code == 422 assert client.post("/api/v1/vms", json=CLOUD_CREATE_BODY, headers=headers).status_code == 404 assert not any(call[0] == "create_cloud_vm" for call in service.calls) def test_cloud_template_import_job_and_create_dispatch(web): client, state, token, service, manager, _ = web csrf = setup_admin(client, token) host_body = {**HOST_BODY, "default_network": "bridge:br0"} assert client.put("/api/v1/host", json=host_body, headers={"X-CSRF-Token": csrf}).status_code == 200 service.calls.clear() headers = {"X-CSRF-Token": csrf} digest = "a" * 64 image = state.data_dir / "verified-cloud.qcow2" image.write_bytes(b"QFI\xfbverified test image") with patch("virsh_panel.app.download_verified_image", return_value=(image, 2 * 1024**3, digest)): queued = client.post("/api/v1/vm-templates/import", json={ "name": "AlmaLinux 10", "url": OFFICIAL_CLOUD_URL, }, headers=headers) assert queued.status_code == 202 job_id = queued.json()["job_id"] assert queued.json()["status"] == "running" job = wait_for_import_job(client, job_id) assert job["status"] == "completed" scope = template_scope(manager.current()) template_id = template_id_for(scope, digest) volume_name = template_volume_name(template_id) assert job["template"]["id"] == template_id assert ("import_template", volume_name, 2 * 1024**3) in service.calls for _ in range(100): if not image.exists(): break time.sleep(0.01) assert not image.exists() listed = client.get("/api/v1/vm-templates") assert listed.status_code == 200 assert listed.json()["templates"][0]["id"] == template_id assert "scope" not in listed.text cloud_body = {**CLOUD_CREATE_BODY, "template_id": template_id} created = client.post("/api/v1/vms", json=cloud_body, headers=headers) assert created.status_code == 201 assert created.json()["name"] == "cloud-vm" expected_spec = {key: value for key, value in cloud_body.items() if key not in {"source", "template_id"}} expected_spec["os_name"] = "AlmaLinux 10" expected_spec["vm_uuid"] = created.json()["uuid"] created_cloud_calls = [call for call in service.calls if call[0] == "create_cloud_vm"] assert len(created_cloud_calls) == 1 _operation, actual_spec, actual_volume = created_cloud_calls[0] assert actual_volume == volume_name assert actual_spec["root_password_hash"].startswith("$6$") assert {key: value for key, value in actual_spec.items() if key != "root_password_hash"} == expected_spec assert ("create_vm", expected_spec) not in service.calls def test_almalinux_9_template_import_exposes_stable_version_and_prevents_duplicate_name(web): client, state, token, service, manager, _ = web csrf = setup_admin(client, token) configure_host(client, csrf) headers = {"X-CSRF-Token": csrf} image = state.data_dir / "alma9-verified.qcow2" image.write_bytes(b"QFI\xfbverified test image") digest = "b" * 64 with patch("virsh_panel.app.download_verified_image", return_value=(image, 2 * 1024**3, digest)): queued = client.post("/api/v1/vm-templates/import", json={ "name": "AlmaLinux 9", "url": OFFICIAL_ALMA9_URL, "sha256": digest, }, headers=headers) assert queued.status_code == 202 job = wait_for_import_job(client, queued.json()["job_id"]) assert job["status"] == "completed" template_id = template_id_for(template_scope(manager.current()), digest, "9") volume_name = template_volume_name(template_id) template = job["template"] assert template["id"] == template_id assert template["volume_name"] == volume_name assert template["os_family"] == "AlmaLinux" assert template["os_version"] == "9" assert ("import_template", volume_name, 2 * 1024**3) in service.calls assert client.get("/api/v1/vm-templates").json()["templates"] == [template] duplicate = client.post("/api/v1/vm-templates/import", json={ "name": "ALMALINUX 9", "url": OFFICIAL_ALMA9_URL, "sha256": "c" * 64, }, headers=headers) assert duplicate.status_code == 409 assert len([call for call in service.calls if call[0] == "import_template"]) == 1 def test_debian_template_import_persists_detected_family_and_version(web): client, state, token, service, manager, _ = web csrf = setup_admin(client, token) configure_host(client, csrf) headers = {"X-CSRF-Token": csrf} image = state.data_dir / "debian12-verified.qcow2" image.write_bytes(b"QFI\xfbverified test image") digest = "d" * 64 with patch("virsh_panel.app.download_verified_image", return_value=(image, 2 * 1024**3, digest)): queued = client.post("/api/v1/vm-templates/import", json={ "name": "Debian 12", "url": OFFICIAL_DEBIAN12_URL, }, headers=headers) assert queued.status_code == 202 job = wait_for_import_job(client, queued.json()["job_id"]) assert job["status"] == "completed" template_id = template_id_for( template_scope(manager.current()), digest, "12", "Debian" ) template = job["template"] assert template["id"] == template_id assert template["os_family"] == "Debian" assert template["os_version"] == "12" assert ( "import_template", template_volume_name(template_id), 2 * 1024**3 ) in service.calls def test_cloud_vm_root_login_supports_key_and_hashed_initial_password(web): client, state, token, service, manager, _ = web csrf = setup_admin(client, token) host_body = {**HOST_BODY, "default_network": "bridge:br0"} assert client.put("/api/v1/host", json=host_body, headers={"X-CSRF-Token": csrf}).status_code == 200 scope = template_scope(manager.current()) template_id = template_id_for(scope, "c" * 64) volume_name = template_volume_name(template_id) TemplateStore(state.data_dir).add( scope, {"id": template_id, "volume_name": volume_name}, ) headers = {"X-CSRF-Token": csrf} service.calls.clear() key_body = {**CLOUD_CREATE_BODY, "template_id": template_id} key_response = client.post("/api/v1/vms", json=key_body, headers=headers) assert key_response.status_code == 201 key_spec = service.calls[-1][1] assert service.calls[-1][0] == "create_cloud_vm" assert key_spec["guest_ssh_public_key"] == CLOUD_CREATE_BODY["guest_ssh_public_key"] assert "root_password" not in key_spec assert key_spec["root_password_hash"].startswith("$6$") assert key_response.json()["login_name"] == "root" assert key_response.json()["auth_mode"] == "ssh_key_password" assert key_response.json()["password_available"] key_uuid = key_response.json()["uuid"] key_credential = client.post( f"/api/v1/vms/{key_uuid}/credential", headers=headers, ) assert key_credential.headers["Cache-Control"] == "no-store" generated_key_password = key_credential.json()["password"] assert key_credential.json()["login_name"] == "root" assert key_credential.json()["auth_mode"] == "ssh_key_password" assert len(generated_key_password) == 32 assert re.search(r"[A-Z]", generated_key_password) assert re.search(r"[a-z]", generated_key_password) assert re.search(r"[0-9]", generated_key_password) assert re.search(r"[^A-Za-z0-9]", generated_key_password) assert set(generated_key_password) <= set( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" "0123456789!@#$%*-_=+?" ) from passlib.hash import sha512_crypt assert sha512_crypt.verify(generated_key_password, key_spec["root_password_hash"]) assert generated_key_password not in key_response.text assert generated_key_password not in client.get("/api/v1/vms").text assert generated_key_password not in repr(service.calls) both_body = {**key_body, "name": "key-password-vm", "root_password": GUEST_PASSWORD} both_response = client.post("/api/v1/vms", json=both_body, headers=headers) assert both_response.status_code == 201 both_spec = service.calls[-1][1] assert both_spec["guest_ssh_public_key"] == CLOUD_CREATE_BODY["guest_ssh_public_key"] assert both_spec["root_password_hash"].startswith("$6$") assert GUEST_PASSWORD not in repr(service.calls) assert both_response.json()["auth_mode"] == "ssh_key_password" assert client.post( f"/api/v1/vms/{both_response.json()['uuid']}/credential", headers=headers, ).json()["password"] == GUEST_PASSWORD password_body = { **key_body, "guest_ssh_public_key": "", "root_password": GUEST_PASSWORD, } password_response = client.post("/api/v1/vms", json=password_body, headers=headers) assert password_response.status_code == 201 password_spec = service.calls[-1][1] assert service.calls[-1][0] == "create_cloud_vm" assert password_spec["guest_ssh_public_key"] == "" assert password_spec["root_password_hash"].startswith("$6$") assert "root_password" not in password_spec assert GUEST_PASSWORD not in password_response.text assert GUEST_PASSWORD not in repr(service.calls) password_uuid = password_response.json()["uuid"] assert password_response.json()["password_available"] assert GUEST_PASSWORD not in client.get("/api/v1/vms").text assert GUEST_PASSWORD not in client.get(f"/api/v1/vms/{password_uuid}").text assert client.post(f"/api/v1/vms/{password_uuid}/credential").status_code == 403 assert client.post( f"/api/v1/vms/{password_uuid}/credential", headers=headers, ).json() == { "login_name": "root", "auth_mode": "password", "password": GUEST_PASSWORD, } original_generation = service.vm["credential_generation"] service.vm["credential_generation"] = "new-system-seed.iso" assert not client.get(f"/api/v1/vms/{password_uuid}").json()["password_available"] assert client.post(f"/api/v1/vms/{password_uuid}/credential", headers=headers).json()["password"] is None service.vm["credential_generation"] = original_generation for invalid_body in ( {**password_body, "root_password": "too-short"}, {**password_body, "root_password": "X" * 129}, {**key_body, "root_password": "alllowercase123!"}, {**key_body, "root_password": "ALLUPPERCASE123!"}, {**key_body, "root_password": "NoDigitsPassword!"}, {**key_body, "root_password": "NoSymbolPassword123"}, {**key_body, "root_password": "Password WithSpace1!"}, ): rejected = client.post("/api/v1/vms", json=invalid_body, headers=headers) assert rejected.status_code == 422 assert len([call for call in service.calls if call[0] == "create_cloud_vm"]) == 3 no_credential = {**key_body, "guest_ssh_public_key": ""} generated = client.post("/api/v1/vms", json=no_credential, headers=headers) assert generated.status_code == 201 assert generated.json()["password_available"] generated_password = client.post( f"/api/v1/vms/{generated.json()['uuid']}/credential", headers=headers, ).json()["password"] assert len(generated_password) == 32 assert re.search(r"[A-Z]", generated_password) assert re.search(r"[a-z]", generated_password) assert re.search(r"[0-9]", generated_password) assert re.search(r"[^A-Za-z0-9]", generated_password) assert generated_password not in generated.text assert generated_password not in client.get("/api/v1/vms").text assert generated_password not in repr(service.calls) assert len([call for call in service.calls if call[0] == "create_cloud_vm"]) == 4 assert client.delete( f"/api/v1/vms/{generated.json()['uuid']}", headers=headers, ).status_code == 200 assert not client.get(f"/api/v1/vms/{generated.json()['uuid']}").json()["password_available"] def test_unknown_vm_has_no_recoverable_password(web): client, _state, token, service, _manager, _ = web csrf = setup_admin(client, token) configure_host(client, csrf) listed = client.get("/api/v1/vms") assert listed.status_code == 200 assert listed.json()["items"][0]["login_name"] is None assert listed.json()["items"][0]["auth_mode"] == "unknown" assert not listed.json()["items"][0]["password_available"] assert client.post( f"/api/v1/vms/{VM_ID}/credential", headers={"X-CSRF-Token": csrf}, ).json()["password"] is None service.vm.update({"managed": True, "os_source": "cloud_template"}) old_cloud = client.get(f"/api/v1/vms/{VM_ID}").json() assert old_cloud["login_name"] == "root" assert old_cloud["auth_mode"] == "unknown" assert not old_cloud["password_available"] def test_reinstall_key_without_password_removes_old_password(web): client, _state, _token, _service, _manager, _ = web csrf, template_id, _volume_name = configure_reinstall_case(web) headers = {"X-CSRF-Token": csrf} password_job = client.post( f"/api/v1/vms/{VM_ID}/reinstall", json={"template_id": template_id, "confirmation_name": "cloud-vm", "root_password": GUEST_PASSWORD}, headers=headers, ) assert password_job.status_code == 202 assert wait_for_reinstall_job(client, password_job.json()["job_id"], csrf)["status"] == "succeeded" assert client.post(f"/api/v1/vms/{VM_ID}/credential", headers=headers).json()["password"] == GUEST_PASSWORD key_job = client.post( f"/api/v1/vms/{VM_ID}/reinstall", json={"template_id": template_id, "confirmation_name": "cloud-vm", "ssh_public_key": CLOUD_CREATE_BODY["guest_ssh_public_key"]}, headers=headers, ) assert key_job.status_code == 202 completed = wait_for_reinstall_job(client, key_job.json()["job_id"], csrf) assert completed["status"] == "succeeded" assert "generated_password" not in completed assert client.post(f"/api/v1/vms/{VM_ID}/credential", headers=headers).json()["password"] is None assert client.get(f"/api/v1/vms/{VM_ID}").json()["auth_mode"] == "ssh_key" deleted = client.delete(f"/api/v1/vms/{VM_ID}", headers=headers) assert deleted.status_code == 200 assert client.get(f"/api/v1/vms/{VM_ID}").json()["auth_mode"] == "unknown" def test_reinstall_cleanup_pending_is_not_reported_success(web): client, _state, _token, service, _manager, _ = web csrf, template_id, _volume_name = configure_reinstall_case(web) service.reinstall_result = { "status": "uncertain", "error_code": "reinstall_cleanup_pending", "error": "重装已完成,但旧系统盘清理待核对", "warning": "旧存储卷 panel-old.qcow2 删除失败,请检查宿主机", "reinstall_committed": True, "cleanup_pending": True, } queued = client.post( f"/api/v1/vms/{VM_ID}/reinstall", json={"template_id": template_id, "confirmation_name": "cloud-vm", "root_password": GUEST_PASSWORD}, headers={"X-CSRF-Token": csrf}, ) assert queued.status_code == 202, queued.text result = wait_for_reinstall_job(client, queued.json()["job_id"], csrf) assert result["status"] == "uncertain" assert result["error_code"] == "reinstall_cleanup_pending" assert result["phase"] == "重装完成,但旧系统盘清理待核对" assert "待核对" in result["error"] assert "旧系统盘清理需要管理员检查" in result["warning"] credential = client.post(f"/api/v1/vms/{VM_ID}/credential", headers={"X-CSRF-Token": csrf}) assert credential.status_code == 200 assert credential.json()["password"] == GUEST_PASSWORD replay = client.post( f"/api/v1/vms/{VM_ID}/reinstall", json={"template_id": template_id, "confirmation_name": "cloud-vm", "root_password": GUEST_PASSWORD}, headers={"X-CSRF-Token": csrf}, ) assert replay.status_code == 409, replay.text assert "待核对" in replay.json()["detail"] def test_reinstall_failed_result_is_not_reported_success(web): client, _state, _token, service, _manager, _ = web csrf, template_id, _volume_name = configure_reinstall_case(web) service.reinstall_emit_progress = False service.reinstall_result = {"status": "failed"} queued = client.post( f"/api/v1/vms/{VM_ID}/reinstall", json={"template_id": template_id, "confirmation_name": "cloud-vm", "root_password": GUEST_PASSWORD}, headers={"X-CSRF-Token": csrf}, ) assert queued.status_code == 202, queued.text result = wait_for_reinstall_job(client, queued.json()["job_id"], csrf) assert result["status"] == "uncertain" assert "待核对" in result["error"] replay = client.post( f"/api/v1/vms/{VM_ID}/reinstall", json={"template_id": template_id, "confirmation_name": "cloud-vm", "root_password": GUEST_PASSWORD}, headers={"X-CSRF-Token": csrf}, ) assert replay.status_code == 409, replay.text def test_reinstall_auto_password_job_ack_keeps_vm_credential(web): client, state, _token, service, _manager, _ = web csrf, template_id, volume_name = configure_reinstall_case(web) headers = {"X-CSRF-Token": csrf} body = {"template_id": template_id, "confirmation_name": "cloud-vm"} assert client.post(f"/api/v1/vms/{VM_ID}/reinstall", json=body).status_code == 403 queued = client.post( f"/api/v1/vms/{VM_ID}/reinstall", json=body, headers=headers, ) assert queued.status_code == 202 assert queued.json()["status"] == "queued" assert "generated_password" not in queued.json() job_id = queued.json()["job_id"] assert client.get(f"/api/v1/reinstall-jobs/{job_id}").status_code == 403 completed = wait_for_reinstall_job(client, job_id, csrf) assert completed["status"] == "succeeded" generated_password = completed["generated_password"] assert len(generated_password) == 32 assert re.search(r"[A-Z]", generated_password) assert re.search(r"[a-z]", generated_password) assert re.search(r"[0-9]", generated_password) assert re.search(r"[^A-Za-z0-9]", generated_password) assert completed["vm_id"] == VM_ID service_calls = [call for call in service.calls if call[0] == "reinstall_cloud_vm"] assert len(service_calls) == 1 assert service_calls[0][1:4] == (VM_ID, volume_name, "") assert service_calls[0][4].startswith("$6$") assert service_calls[0][5] == "AlmaLinux 10" assert generated_password not in repr(service.calls) second = client.get(f"/api/v1/reinstall-jobs/{job_id}", headers=headers) assert second.status_code == 200 assert second.json()["status"] == "succeeded" assert second.json()["generated_password"] == generated_password ack_url = f"/api/v1/reinstall-jobs/{job_id}/ack-password" assert client.post(ack_url).status_code == 403 ack = client.post(ack_url, headers=headers) assert ack.status_code == 200 assert ack.json() == {"acknowledged": True} assert client.post(ack_url, headers=headers).json() == {"acknowledged": True} after_ack = client.get(f"/api/v1/reinstall-jobs/{job_id}", headers=headers) assert after_ack.status_code == 200 assert "generated_password" not in after_ack.json() assert generated_password not in after_ack.text assert client.get(f"/api/v1/vms/{VM_ID}").json()["password_available"] revealed = client.post(f"/api/v1/vms/{VM_ID}/credential", headers=headers) assert revealed.json()["password"] == generated_password for path in state.data_dir.rglob("*"): if path.is_file(): assert generated_password.encode() not in path.read_bytes() assert client.post("/api/v1/logout", headers=headers).status_code == 200 assert client.get(f"/api/v1/reinstall-jobs/{job_id}", headers=headers).status_code == 401 assert client.post(ack_url, headers=headers).status_code == 401 def test_reinstall_key_and_manual_password_has_no_generated_password(web): client, _state, _token, service, _manager, _ = web csrf, template_id, volume_name = configure_reinstall_case(web) public_key = CLOUD_CREATE_BODY["guest_ssh_public_key"] queued = client.post( f"/api/v1/vms/{VM_ID}/reinstall", json={"template_id": template_id, "confirmation_name": "cloud-vm", "ssh_public_key": public_key, "root_password": GUEST_PASSWORD}, headers={"X-CSRF-Token": csrf}, ) assert queued.status_code == 202 completed = wait_for_reinstall_job(client, queued.json()["job_id"], csrf) assert completed["status"] == "succeeded" assert "generated_password" not in completed assert client.get(f"/api/v1/vms/{VM_ID}").json()["auth_mode"] == "ssh_key_password" assert client.post(f"/api/v1/vms/{VM_ID}/credential", headers={"X-CSRF-Token": csrf}).json()["password"] == GUEST_PASSWORD reinstall_call = next(call for call in service.calls if call[0] == "reinstall_cloud_vm") assert reinstall_call[1:4] == (VM_ID, volume_name, public_key) assert reinstall_call[4].startswith("$6$") assert reinstall_call[5] == "AlmaLinux 10" @pytest.mark.parametrize("weak_password", [ "short-A!", "alllowercase123!", "ALLUPPERCASE123!", "NoDigitsPassword!", "NoSymbolPassword123", "Password WithSpace1!", ]) def test_reinstall_rejects_weak_manual_root_password(web, weak_password): client, _state, _token, service, _manager, _ = web csrf, template_id, _volume_name = configure_reinstall_case(web) response = client.post( f"/api/v1/vms/{VM_ID}/reinstall", json={"template_id": template_id, "confirmation_name": "cloud-vm", "ssh_public_key": CLOUD_CREATE_BODY["guest_ssh_public_key"], "root_password": weak_password}, headers={"X-CSRF-Token": csrf}, ) assert response.status_code == 422 assert "初始 root 密码" in response.json()["detail"] assert not any(call[0] == "reinstall_cloud_vm" for call in service.calls) def test_reinstall_requires_exact_name_and_blocks_duplicate_or_lifecycle_actions(web): client, _state, _token, service, _manager, _ = web csrf, template_id, _volume_name = configure_reinstall_case(web) headers = {"X-CSRF-Token": csrf} body = {"template_id": template_id, "confirmation_name": "cloud-vm"} wrong = client.post( f"/api/v1/vms/{VM_ID}/reinstall", json={**body, "confirmation_name": "wrong-vm"}, headers=headers, ) assert wrong.status_code == 422 assert not any(call[0] == "reinstall_cloud_vm" for call in service.calls) service.reinstall_gate = threading.Event() try: queued = client.post(f"/api/v1/vms/{VM_ID}/reinstall", json=body, headers=headers) assert queued.status_code == 202 assert service.reinstall_started.wait(timeout=2) duplicate = client.post(f"/api/v1/vms/{VM_ID}/reinstall", json=body, headers=headers) assert duplicate.status_code == 409 action = client.post(f"/api/v1/vms/{VM_ID}/actions", json={"action": "shutdown"}, headers=headers) assert action.status_code == 409 deletion = client.delete(f"/api/v1/vms/{VM_ID}?delete_disks=true", headers=headers) assert deletion.status_code == 409 finally: service.reinstall_gate.set() completed = wait_for_reinstall_job(client, queued.json()["job_id"], csrf) assert completed["status"] == "succeeded" assert len([call for call in service.calls if call[0] == "reinstall_cloud_vm"]) == 1 def test_cloud_template_import_job_reports_failure_without_registering_template(web): client, _, token, service, _, _ = web csrf = setup_admin(client, token) configure_host(client, csrf) headers = {"X-CSRF-Token": csrf} with patch("virsh_panel.app.download_verified_image", side_effect=TemplateError("云镜像 SHA-256 不匹配", 422)): queued = client.post("/api/v1/vm-templates/import", json={ "name": "AlmaLinux 10", "url": OFFICIAL_CLOUD_URL, "sha256": "b" * 64, }, headers=headers) assert queued.status_code == 202 job = wait_for_import_job(client, queued.json()["job_id"]) assert job["status"] == "failed" assert "SHA-256" in job["error"] assert client.get("/api/v1/vm-templates").json() == {"templates": []} assert not any(call[0] == "import_template" for call in service.calls) def test_static_assets_and_security_headers(web): client, _, _, service, _, _ = web page = client.get("/") assert page.status_code == 200 and "text/html" in page.headers["content-type"] assert page.headers["cache-control"] == "no-store" assert "frame-ancestors 'none'" in page.headers["content-security-policy"] script_url = re.search(r'src="(/static/app\.js\?v=[^"]+)"', page.text) style_url = re.search(r'href="(/static/styles\.css\?v=[^"]+)"', page.text) assert script_url is not None and style_url is not None script = client.get(script_url.group(1)) style = client.get(style_url.group(1)) assert script.status_code == 200 and script.headers["cache-control"] == "no-store" assert style.status_code == 200 and style.headers["cache-control"] == "no-store" assert "function updateCreateSource()" in script.text assert ".create-source-picker" in style.text assert client.get("/vendor/novnc/core/rfb.js").status_code == 200 assert service.calls == [] def test_non_loopback_plain_http_is_rejected(web): client, *_ = web with TestClient(client.app, base_url="http://panel.example.test") as insecure: response = insecure.get("/api/v1/health") assert response.status_code == 400 assert response.json() == {"error": "请使用 HTTPS 访问面板"} def test_plain_loopback_only_exposes_health(web): client, _, token, *_ = web with TestClient(client.app, base_url="http://127.0.0.1:8000", client=("127.0.0.1", 50000)) as local: assert local.get("/api/v1/health").json() == {"status": "ok"} assert local.get("/").status_code == 400 assert local.get("/api/v1/setup/status").status_code == 400 assert local.post("/api/v1/setup/admin", json={ "token": token, "username": "admin", "password": PASSWORD, }).status_code == 400 def test_trusted_local_reverse_proxy_https_and_websocket(web): client, _, token, service, manager, _ = web app = ProxyHeadersMiddleware(client.app, trusted_hosts=["127.0.0.1"]) proxy_headers = { "host": "panel.example.test", "x-forwarded-proto": "https", "x-forwarded-for": "198.51.100.100", } with TestClient(app, base_url="http://panel.example.test", client=("127.0.0.1", 50000)) as proxy: assert proxy.get("/api/v1/health", headers=proxy_headers).status_code == 200 assert proxy.get("/api/v1/health", headers={"host": "panel.example.test"}).status_code == 400 setup = proxy.post("/api/v1/setup/admin", json={ "token": token, "username": "admin", "password": PASSWORD, }, headers=proxy_headers) assert setup.status_code == 200 assert "secure" in setup.headers["set-cookie"].lower() csrf = setup.json()["csrf_token"] cookie = f"virsh_panel_session={proxy.cookies['virsh_panel_session']}" save = proxy.put("/api/v1/host", json=HOST_BODY, headers={ **proxy_headers, "X-CSRF-Token": csrf, "cookie": cookie, }) assert save.status_code == 200 assert save.json()["configured"] is True service.calls.clear() with patch("virsh_panel.app.relay_console", new_callable=AsyncMock) as relay: with proxy.websocket_connect( f"ws://panel.example.test/api/v1/vms/{VM_ID}/console", headers={**proxy_headers, "origin": ORIGIN, "cookie": cookie}, ): pass assert service.calls == [("console_port", VM_ID)] relay.assert_awaited_once() with pytest.raises(WebSocketDisconnect) as plain_ws: with proxy.websocket_connect( f"ws://panel.example.test/api/v1/vms/{VM_ID}/console", headers={"host": "panel.example.test", "origin": ORIGIN, "cookie": cookie}, ): pass assert plain_ws.value.code == 4403 assert manager.current() is not None def test_untrusted_forwarded_proto_and_spoofed_local_host_are_rejected(web): client, *_ = web app = ProxyHeadersMiddleware(client.app, trusted_hosts=["127.0.0.1"]) with TestClient(app, base_url="http://panel.example.test", client=("198.51.100.10", 50000)) as direct: spoofed_https = direct.get("/api/v1/health", headers={ "host": "panel.example.test", "x-forwarded-proto": "https", }) spoofed_local_host = direct.get("/api/v1/health", headers={ "host": "localhost", "x-forwarded-proto": "http", }) with pytest.raises(WebSocketDisconnect) as spoofed_ws: with direct.websocket_connect( f"ws://panel.example.test/api/v1/vms/{VM_ID}/console", headers={"host": "panel.example.test", "origin": ORIGIN, "x-forwarded-proto": "https"}, ): pass assert spoofed_https.status_code == 400 assert spoofed_local_host.status_code == 400 assert spoofed_ws.value.code == 4403 def test_websocket_origin_auth_and_console_relay(web): client, _, token, service, _, _ = web with pytest.raises(WebSocketDisconnect) as unauthenticated: with client.websocket_connect( f"wss://panel.example.test/api/v1/vms/{VM_ID}/console", headers={"origin": ORIGIN, "host": "panel.example.test"}, ): pass assert unauthenticated.value.code == 4401 csrf = setup_admin(client, token) configure_host(client, csrf) service.calls.clear() cookie = f"virsh_panel_session={client.cookies['virsh_panel_session']}" with pytest.raises(WebSocketDisconnect) as wrong_origin: with client.websocket_connect( f"wss://panel.example.test/api/v1/vms/{VM_ID}/console", headers={"origin": "https://attacker.example", "cookie": cookie, "host": "panel.example.test"}, ): pass assert wrong_origin.value.code == 4403 with patch("virsh_panel.app.relay_console", new_callable=AsyncMock) as relay: with client.websocket_connect( f"wss://panel.example.test/api/v1/vms/{VM_ID}/console", headers={"origin": ORIGIN, "cookie": cookie, "host": "panel.example.test"}, ): pass assert service.calls == [("console_port", VM_ID)] relay.assert_awaited_once() assert relay.await_args.kwargs["port"] == 5907 assert relay.await_args.kwargs["ssh_target"] == "vp-managed" assert relay.await_args.kwargs["ssh_config_file"] == "/fake/config" def test_vm_metrics_requires_auth_validates_vm_and_isolates_host(tmp_path): state = PanelState(tmp_path / "panel-data") manager = FakeRemoteManager() service = FakeVMService() class FakeMetricStore: def __init__(self): self.calls = [] self.allowed_scope = None def query_metric_samples(self, scope, vm_id, **kwargs): self.calls.append((scope, vm_id, kwargs)) if scope != self.allowed_scope: return [] return [{"timestamp": 2_999_900, "cpu_percent": 25, "memory_used_mib": None, "memory_total_mib": None, "disk_read_bps": 128, "disk_write_bps": 0, "network_rx_bps": 4096, "network_tx_bps": 1024}] metric_store = FakeMetricStore() app = create_app(Settings(data_dir=state.data_dir, static_dir=STATIC_DIR), panel_state=state, remote_manager=manager, service_factory=lambda _profile: service, metric_store=metric_store) with TestClient(app, base_url=ORIGIN) as client: endpoint = f"/api/v1/vms/{VM_ID}/metrics" assert client.get(endpoint).status_code == 401 token = state.token_file.read_text(encoding="ascii").strip() csrf = setup_admin(client, token) configure_host(client, csrf) metric_store.allowed_scope = host_scope(manager.current()) with patch("virsh_panel.app.time.time", return_value=3_000_000): response = client.get(endpoint + "?range=30d") assert response.status_code == 200 body = response.json() assert body["vm_id"] == VM_ID assert body["range"] == "30d" assert body["interval_seconds"] == query_interval_seconds(30 * 24 * 3600) assert len(body["points"]) == 1 scope, vm_id, args = metric_store.calls[-1] assert scope == metric_store.allowed_scope and vm_id == VM_ID assert args["since"] == 3_000_000 - 30 * 24 * 3600 assert args["until"] == 3_000_000 and args["limit"] == 600 assert client.get(endpoint + "?range=60d").status_code == 422 assert client.get("/api/v1/vms/not-a-uuid/metrics").status_code == 400 assert client.get( "/api/v1/vms/00000000-0000-4000-8000-000000000002/metrics" ).status_code == 404 before = len(metric_store.calls) manager.profile["fingerprint"] = "SHA256:another-host" with patch("virsh_panel.app.time.time", return_value=3_000_000): changed_host = client.get(endpoint) assert changed_host.status_code == 200 assert changed_host.json()["points"] == [] assert len(metric_store.calls) == before + 1 def test_vm_daily_traffic_uses_utc_days_and_validates_access_and_range(tmp_path): state = PanelState(tmp_path / "panel-data") manager = FakeRemoteManager() service = FakeVMService() class FakeMetricStore: def __init__(self): self.calls = [] def query_daily_traffic(self, scope, vm_id, **kwargs): self.calls.append((scope, vm_id, kwargs)) return [{"day_start": 2_937_600, "download_bytes": 2048, "upload_bytes": 1024, "total_bytes": 3072}] metric_store = FakeMetricStore() app = create_app(Settings(data_dir=state.data_dir, static_dir=STATIC_DIR), panel_state=state, remote_manager=manager, service_factory=lambda _profile: service, metric_store=metric_store) with TestClient(app, base_url=ORIGIN) as client: endpoint = f"/api/v1/vms/{VM_ID}/traffic/daily" assert client.get(endpoint).status_code == 401 token = state.token_file.read_text(encoding="ascii").strip() csrf = setup_admin(client, token) configure_host(client, csrf) scope = host_scope(manager.current()) with patch("virsh_panel.app.time.time", return_value=3_000_000): response = client.get(endpoint + "?days=2") assert response.status_code == 200 body = response.json() assert body == { "vm_id": VM_ID, "days": 2, "timezone": "UTC", "from": 2_851_200, "until": 3_000_000, "points": [ {"date": "1970-02-03", "day_start": 2_851_200, "download_bytes": None, "upload_bytes": None, "total_bytes": None}, {"date": "1970-02-04", "day_start": 2_937_600, "download_bytes": 2048, "upload_bytes": 1024, "total_bytes": 3072}, ], } assert metric_store.calls == [(scope, VM_ID, { "host_id": None, "user_id": None, "since": 2_851_200, "until": 3_000_000, "limit": 2, })] assert client.get(endpoint + "?days=0").status_code == 422 assert client.get(endpoint + "?days=31").status_code == 422 assert client.get("/api/v1/vms/not-a-uuid/traffic/daily").status_code == 400 assert client.get( "/api/v1/vms/00000000-0000-4000-8000-000000000002/traffic/daily" ).status_code == 404