You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
virt/engine/tests/test_database_http.py

440 lines
17 KiB
Python

"""First-run database and update routes with isolated in-memory dependencies."""
from __future__ import annotations
import json
import stat
import sys
import threading
import types
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from types import SimpleNamespace
from fastapi.testclient import TestClient
# The HTTP boundary is tested with fake VM services; native libvirt is not
# available on ordinary development machines.
try:
import libvirt # noqa: F401
except ModuleNotFoundError:
stub = types.ModuleType("libvirt")
stub.libvirtError = type("libvirtError", (Exception,), {})
sys.modules["libvirt"] = stub
from virsh_panel import app as app_module
from virsh_panel.auth import hash_password
from virsh_panel.config import Settings
from virsh_panel.database import DatabasePanelState, DatabaseTemplateStore
from virsh_panel.users import UserError, normalize_email
class MemoryUsers:
"""Only the SQL user-store boundary is replaced in isolated HTTP tests."""
def __init__(self, store):
self.store = store
def has_users(self):
return any(kind == "test_user" for kind, _key in self.store.records)
def get_by_username(self, username):
raw = self.store.get("test_user", username)
return json.loads(raw) if raw else None
def get_by_email(self, email):
try:
email = normalize_email(email)
except UserError:
return None
for (kind, _key), raw in self.store.records.items():
if kind == "test_user":
account = json.loads(raw)
if account["email"] == email:
return account
return None
def get_by_id(self, user_id):
for (kind, _key), raw in self.store.records.items():
if kind == "test_user":
user = json.loads(raw)
if user["id"] == user_id:
return user
return None
def create_initial_user(self, username, password, email=None):
email = normalize_email(email) if email is not None else None
account = {
"id": 1, "username": username, "email": email,
"password_hash": hash_password(password), "admin": False,
"approved": True, "email_verified": True, "created_at": 100,
}
self.store.set("test_user", username, json.dumps(account))
return account
def promote(self, username):
account = self.get_by_username(username)
account["admin"] = True
self.store.set("test_user", username, json.dumps(account))
def owns_vm(self, host_scope, vm_id, user_id):
return self.store.get("test_vm_owner", f"{host_scope}:{vm_id}") == str(user_id)
def assign_vm(self, host_scope, vm_id, user_id):
self.store.set("test_vm_owner", f"{host_scope}:{vm_id}", str(user_id))
def delete_vm_owner(self, host_scope, vm_id):
self.store.delete("test_vm_owner", f"{host_scope}:{vm_id}")
def list_owned_vm_ids(self, host_scope, user_id):
prefix = f"{host_scope}:"
return {key[len(prefix):] for key, owner in self.store.list("test_vm_owner").items()
if key.startswith(prefix) and owner == str(user_id)}
def list_pending_users(self):
pending = []
for (kind, _key), raw in self.store.records.items():
if kind == "test_user":
account = json.loads(raw)
if not account["approved"]:
pending.append({key: value for key, value in account.items()
if key != "password_hash"})
return pending
def approve_user(self, user_id):
account = self.get_by_id(user_id)
if account is None:
return None
account["approved"] = True
self.store.set("test_user", account["username"], json.dumps(account))
return account
@staticmethod
def generate_code():
return "123456"
def issue_registration_code(self, email, code):
if any(json.loads(raw)["email"] == email for (kind, _key), raw in self.store.records.items()
if kind == "test_user"):
return False
self.store.set("test_code", email, code)
return True
def revoke_registration_code(self, email, code):
if self.store.get("test_code", email) != code:
return False
self.store.delete("test_code", email)
return True
def register_with_code(self, username, email, password, code):
if self.store.get("test_code", email) != code:
raise UserError("验证码无效或已过期")
email = normalize_email(email)
if self.get_by_username(username) is not None or self.get_by_email(email) is not None:
raise UserError("用户名或邮箱已存在", 409)
account = {
"id": 1 + sum(kind == "test_user" for kind, _key in self.store.records),
"username": username, "email": email,
"password_hash": hash_password(password), "admin": False,
"approved": False, "email_verified": True, "created_at": 101,
}
self.store.set("test_user", username, json.dumps(account))
self.store.delete("test_code", email)
return account
class MemoryStore:
def __init__(self) -> None:
self.records = {}
self.users = MemoryUsers(self)
def get(self, kind, key):
return self.records.get((kind, key))
def set(self, kind, key, value):
self.records[(kind, key)] = value
def insert(self, kind, key, value):
if (kind, key) in self.records:
return False
self.set(kind, key, value)
return True
def delete(self, kind, key):
self.records.pop((kind, key), None)
def list(self, kind):
return {key: value for (record_type, key), value in self.records.items()
if record_type == kind}
def get_secret(self, key):
return self.get("secret", key)
def set_secret(self, key, value):
self.set("secret", key, value)
def get_value(self, key):
return self.get("value", key)
def set_value(self, key, value):
self.set("value", key, value)
class FakeManager:
def current(self):
return None
def close(self):
pass
def test_first_run_requires_database_then_admin_and_ignores_old_json(monkeypatch, tmp_path):
data_dir = tmp_path / "data"
data_dir.mkdir(mode=0o700)
(data_dir / "state.json").write_text(
'{"version":1,"admin":{"username":"old","password_hash":"old"}}',
encoding="utf-8",
)
store = MemoryStore()
calls = []
def make_components(directory, config, key, _ssh_binary):
calls.append((config, key))
return (DatabasePanelState(directory, store, store.users), FakeManager(),
DatabaseTemplateStore(store), store)
monkeypatch.setattr(app_module, "make_components", make_components)
settings = Settings(data_dir=data_dir,
static_dir=Path(__file__).resolve().parents[1] / "static")
app = app_module.create_app(settings)
token = (data_dir / "setup-token").read_text(encoding="ascii").strip()
config = {
"host": "127.0.0.1", "port": 3306, "database": "virsh_panel",
"username": "panel", "password": "test-database-password",
}
with TestClient(app, base_url="https://panel.example.test") as client:
assert client.get("/api/v1/database/status").json() == {
"configured": False, "setup_required": True,
}
assert client.get("/api/v1/setup/status").status_code == 409
assert client.post("/api/v1/database/setup", json={
**config, "setup_token": "invalid",
}).status_code == 403
assert calls == []
response = client.post("/api/v1/database/setup", json={
**config, "setup_token": token,
})
assert response.status_code == 200
assert response.json() == {"configured": True}
assert calls[0][0] == config and len(calls[0][1]) == 32
assert client.get("/api/v1/setup/status").json() == {"setup_required": True}
created = client.post("/api/v1/setup/admin", json={
"token": token, "username": "admin",
"password": "correct-horse-battery-staple",
})
assert created.status_code == 200
assert client.get("/api/v1/setup/status").json() == {"setup_required": False}
session_cookie = client.cookies.get("virsh_panel_session")
assert ("test_user", "admin") in store.records
assert store.users.get_by_username("admin")["admin"] is False
assert store.users.get_by_username("admin")["email"] is None
assert store.users.get_by_email("admin@example.test") is None
assert not (data_dir / "setup-token").exists()
encrypted = (data_dir / "database-config.json").read_bytes()
assert b"test-database-password" not in encrypted
assert stat.S_IMODE((data_dir / "master.key").stat().st_mode) == 0o600
store.set("import_job", "interrupted-job", json.dumps({
"status": "running", "scope": "previous-host",
}))
restarted = app_module.create_app(settings)
assert json.loads(store.get("import_job", "interrupted-job"))["status"] == "failed"
with TestClient(restarted, base_url="https://panel.example.test") as client:
client.cookies.set("virsh_panel_session", session_cookie)
assert client.get("/api/v1/session").json()["authenticated"] is True
def test_update_routes_require_auth_and_never_return_token(monkeypatch, tmp_path):
data_dir = tmp_path / "data"
store = MemoryStore()
monkeypatch.setattr(app_module, "make_components", lambda directory, *_: (
DatabasePanelState(directory, store, store.users), FakeManager(),
DatabaseTemplateStore(store), store,
))
settings = Settings(data_dir=data_dir,
static_dir=Path(__file__).resolve().parents[1] / "static")
app = app_module.create_app(settings)
token = (data_dir / "setup-token").read_text(encoding="ascii").strip()
class FakeUpdater:
def __init__(self, *_args):
self.token = None
self.job = None
def settings(self):
return {
"repository": "https://g.luoli.live/root/virt.git", "branch": "main",
"token_configured": self.token is not None, "checkout_ready": True,
"current_commit": "a" * 40, "active_job_id": None,
}
def set_token(self, token):
self.token = token
def check(self):
return {
"repository": "https://g.luoli.live/root/virt.git", "branch": "main",
"current_commit": "a" * 40, "remote_commit": "b" * 40,
"status": "update_available",
}
def create_job(self, *, expected_current_commit=None, expected_remote_commit=None):
assert expected_current_commit == "a" * 40
assert expected_remote_commit == "b" * 40
self.job = {"job_id": "test-job-00000001", "status": "queued"}
return self.job
def get_job(self, job_id):
return self.job if self.job and job_id == self.job["job_id"] else None
def fail_job(self, job_id, error):
self.job = {"job_id": job_id, "status": "failed", "error": error}
monkeypatch.setattr(app_module, "Updater", FakeUpdater)
monkeypatch.setattr(app_module.subprocess, "run", lambda *args, **kwargs:
SimpleNamespace(returncode=0, stdout="inactive"))
with TestClient(app, base_url="https://panel.example.test") as client:
assert client.get("/api/v1/update/settings").status_code == 401
client.post("/api/v1/database/setup", json={
"host": "127.0.0.1", "port": 3306, "database": "virsh_panel",
"username": "panel", "password": "test-database-password",
"setup_token": token,
})
response = client.post("/api/v1/setup/admin", json={
"token": token, "username": "admin",
"password": "correct-horse-battery-staple",
})
assert response.status_code == 200
store.users.promote("admin")
csrf = response.json()["csrf_token"]
assert client.put("/api/v1/update/settings", json={
"access_token": "some-very-private-gitea-token",
}).status_code == 403
saved = client.put("/api/v1/update/settings", json={
"access_token": "some-very-private-gitea-token",
}, headers={"X-CSRF-Token": csrf})
assert saved.status_code == 200
assert saved.json()["configured"] is True
assert "some-very-private-gitea-token" not in saved.text
checked = client.post("/api/v1/update/check", headers={
"X-CSRF-Token": csrf,
})
assert checked.status_code == 200
assert checked.json()["update_available"] is True
queued = client.post("/api/v1/update/apply", json={
"expected_current_commit": "a" * 40,
"expected_remote_commit": "b" * 40,
}, headers={
"X-CSRF-Token": csrf,
})
assert queued.status_code == 202
job_id = queued.json()["job_id"]
assert client.get(f"/api/v1/update/jobs/{job_id}").json()["status"] == "queued"
def test_vm_creation_finishes_before_update_is_queued(monkeypatch, tmp_path):
data_dir = tmp_path / "data"
store = MemoryStore()
vm_started = threading.Event()
release_vm = threading.Event()
update_received = threading.Event()
update_queued = threading.Event()
class ConfiguredManager(FakeManager):
def current(self):
return {"key_locked": False}
class BlockingVMService:
def create_vm(self, spec):
vm_started.set()
assert release_vm.wait(timeout=5), "test did not release VM creation"
return {"uuid": spec["vm_uuid"]}
class FakeUpdater:
def __init__(self, _repo_dir, data_store):
self.store = data_store
self.job = None
def create_job(self, **_kwargs):
self.job = {"job_id": "test-job-00000001", "status": "queued"}
self.store.set_value("update.active_job", self.job["job_id"])
update_queued.set()
return self.job
def get_job(self, job_id):
return self.job if self.job and job_id == self.job["job_id"] else None
def fail_job(self, _job_id, _message):
raise AssertionError("the mocked update service must start")
monkeypatch.setattr(app_module, "make_components", lambda directory, *_: (
DatabasePanelState(directory, store, store.users), ConfiguredManager(),
DatabaseTemplateStore(store), store,
))
monkeypatch.setattr(app_module, "Updater", FakeUpdater)
monkeypatch.setattr(
app_module.subprocess, "run",
lambda argv, **_kwargs: SimpleNamespace(
returncode=3 if "is-active" in argv else 0,
stdout="inactive" if "is-active" in argv else "",
),
)
settings = Settings(data_dir=data_dir,
static_dir=Path(__file__).resolve().parents[1] / "static")
app = app_module.create_app(settings, service_factory=lambda _profile: BlockingVMService())
@app.middleware("http")
async def observe_update(request, call_next):
if request.url.path == "/api/v1/update/apply":
update_received.set()
return await call_next(request)
token = (data_dir / "setup-token").read_text(encoding="ascii").strip()
with TestClient(app, base_url="https://panel.example.test") as client:
configured = client.post("/api/v1/database/setup", json={
"host": "127.0.0.1", "port": 3306, "database": "virsh_panel",
"username": "panel", "password": "test-database-password",
"setup_token": token,
})
assert configured.status_code == 200
admin = client.post("/api/v1/setup/admin", json={
"token": token, "username": "admin",
"password": "correct-horse-battery-staple",
})
assert admin.status_code == 200
store.users.promote("admin")
headers = {"X-CSRF-Token": admin.json()["csrf_token"]}
with ThreadPoolExecutor(max_workers=2) as executor:
creating = executor.submit(client.post, "/api/v1/vms", json={
"name": "new-vm", "vcpu": 2, "memory_mib": 2048,
"disk_gib": 20, "network": "default", "iso": "AlmaLinux-10.iso",
}, headers=headers)
assert vm_started.wait(timeout=5)
updating = executor.submit(client.post, "/api/v1/update/apply", json={
"expected_current_commit": "a" * 40,
"expected_remote_commit": "b" * 40,
}, headers=headers)
try:
assert update_received.wait(timeout=5)
assert not update_queued.wait(timeout=0.2)
assert not updating.done()
finally:
release_vm.set()
assert creating.result(timeout=5).status_code == 201
assert updating.result(timeout=5).status_code == 202
assert update_queued.is_set()
blocked = client.post("/api/v1/vms", json={
"name": "another-vm", "vcpu": 2, "memory_mib": 2048,
"disk_gib": 20, "network": "default", "iso": "AlmaLinux-10.iso",
}, headers=headers)
assert blocked.status_code == 409