""" FILE: tests/test_container_preflight.py DESCRIPTION: Prüft Container-Preflight (deploy/entrypoint.py) und statisch die Sicherheitszusagen der Compose-/Docker-Dateien. Läuft ohne Docker. """ import importlib.util import re from pathlib import Path import pytest import yaml ROOT = Path(__file__).resolve().parents[1] DEPLOY = ROOT / "deploy" SYSTEMD_PORTS = {8001, 8002, 8501, 8502} # WorkingDirectory der systemd-Units (llm-node), deren .env der Container unverändert liest. SYSTEMD_ENV_FILES = {"dev": "/home/llmadmin/mindnet_dev/.env", "prod": "/home/llmadmin/mindnet/.env"} def _load_deploy_module(name): spec = importlib.util.spec_from_file_location(f"mindnet_{name}", DEPLOY / f"{name}.py") module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) return module ep = _load_deploy_module("entrypoint") @pytest.fixture def env(monkeypatch): for key in ("MINDNET_ENV", "COLLECTION_PREFIX", "VECTOR_DIM", "MINDNET_EMBEDDING_MODEL", "OPENROUTER_API_KEY", "GOOGLE_API_KEY", "MINDNET_ALLOW_CLOUD_EGRESS", "MINDNET_VAULT_ROOT", "MINDNET_VAULT_SENTINEL", "MINDNET_VAULT_READONLY", "MINDNET_VAULT_REQUIRED", "MINDNET_EXPECTED_VECTOR_DIM"): monkeypatch.delenv(key, raising=False) monkeypatch.chdir(ROOT) return monkeypatch # --- Umgebung und Präfix --------------------------------------------------------- @pytest.mark.parametrize("menv, prefix", [("", "mindnet"), ("staging", "mindnet"), ("prod", ""), ("dev", "mindnet"), ("prod", "mindnet_dev")]) def test_environment_rejects_ambiguous_setups(env, menv, prefix): env.setenv("MINDNET_ENV", menv) env.setenv("COLLECTION_PREFIX", prefix) with pytest.raises(ep.PreflightError): ep.check_environment() @pytest.mark.parametrize("menv, prefix", [("dev", "mindnet_dev"), ("prod", "mindnet")]) def test_environment_accepts_explicit_setups(env, menv, prefix): env.setenv("MINDNET_ENV", menv) env.setenv("COLLECTION_PREFIX", prefix) assert ep.check_environment() == menv # --- Embeddings: keine stille Rückkehr zu 384 Dimensionen ----------------------- @pytest.mark.parametrize("dim", [None, "384", "3072"]) def test_embeddings_reject_wrong_or_missing_dim(env, dim): if dim: env.setenv("VECTOR_DIM", dim) with pytest.raises(ep.PreflightError, match="VECTOR_DIM"): ep.check_embeddings() def test_embeddings_accept_repository_profile(env): env.setenv("VECTOR_DIM", "768") ep.check_embeddings() def test_embeddings_reject_minilm_override(env): env.setenv("VECTOR_DIM", "768") env.setenv("MINDNET_EMBEDDING_MODEL", "sentence-transformers/all-MiniLM-L6-v2") with pytest.raises(ep.PreflightError, match="MINDNET_EMBEDDING_MODEL"): ep.check_embeddings() @pytest.mark.parametrize("profile", [ {"provider": "ollama", "model": "all-minilm", "dimensions": 384}, {"provider": "ollama", "model": "nomic-embed-text", "dimensions": 384}, {"provider": "ollama", "model": "nomic-embed-text"}, ]) def test_embeddings_reject_bad_profile(env, tmp_path, profile): env.setenv("VECTOR_DIM", "768") path = tmp_path / "profiles.yaml" path.write_text(yaml.safe_dump({"profiles": {"embedding_expert": profile}}), encoding="utf-8") with pytest.raises(ep.PreflightError, match="embedding_expert"): ep.check_embeddings(str(path)) # --- Cloud-Egress ------------------------------------------------------------------ def test_cloud_keys_require_explicit_ack(env): env.setenv("OPENROUTER_API_KEY", "sk-test") with pytest.raises(ep.PreflightError, match="MINDNET_ALLOW_CLOUD_EGRESS"): ep.check_cloud_egress() env.setenv("MINDNET_ALLOW_CLOUD_EGRESS", "true") ep.check_cloud_egress() def test_no_cloud_keys_needs_no_ack(env): ep.check_cloud_egress() # --- Vault / NAS ----------------------------------------------------------------------- def _vault(tmp_path, with_content=True): root = tmp_path / "vault" root.mkdir() if with_content: (root / "notiz.md").write_text("# Notiz", encoding="utf-8") return root def test_vault_missing_directory(env, tmp_path): env.setenv("MINDNET_VAULT_ROOT", str(tmp_path / "nope")) with pytest.raises(ep.PreflightError, match="fehlt"): ep.check_vault() def test_vault_empty_mountpoint_is_detected(env, tmp_path): # Ausgefallenes NAS: Mountpunkt existiert, ist aber leer. env.setenv("MINDNET_VAULT_ROOT", str(_vault(tmp_path, with_content=False))) with pytest.raises(ep.PreflightError, match="leer"): ep.check_vault() def test_vault_needs_no_specific_file_by_default(env, tmp_path): # Wie systemd: jeder Vault-Aufbau ist zulässig (vault_master hat kein _system/). env.setenv("MINDNET_VAULT_ROOT", str(_vault(tmp_path))) env.setattr(ep, "_is_read_only_mount", lambda path: True) ep.check_vault() def test_vault_optional_sentinel_is_enforced(env, tmp_path): env.setenv("MINDNET_VAULT_ROOT", str(_vault(tmp_path))) env.setenv("MINDNET_VAULT_SENTINEL", "_system/dictionary/edge_vocabulary.md") with pytest.raises(ep.PreflightError, match="Sentinel"): ep.check_vault() def test_vault_must_be_read_only(env, tmp_path): env.setenv("MINDNET_VAULT_ROOT", str(_vault(tmp_path))) env.setattr(ep, "_is_read_only_mount", lambda path: False) with pytest.raises(ep.PreflightError, match="schreibgeschützt"): ep.check_vault() env.setattr(ep, "_is_read_only_mount", lambda path: True) ep.check_vault() def test_read_only_check_fails_closed_without_statvfs(env, tmp_path): env.delattr(ep.os, "statvfs", raising=False) assert ep._is_read_only_mount(tmp_path) is False def test_unknown_mode_is_rejected(): assert ep.main(["entrypoint.py", "shell"]) == 2 # --- Statische Prüfung der Deployment-Dateien --------------------------------------- def _compose(name): return yaml.safe_load((DEPLOY / name).read_text(encoding="utf-8")) def _host_port(mapping): m = re.search(r":(?:\$\{[A-Z_]+:-)?(\d+)\}?:\d+$", mapping) return int(m.group(1)) COMPOSE = {"dev": _compose("compose.dev.yml"), "prod": _compose("compose.prod.yml")} APP_SERVICES = ("api", "ui") def test_compose_projects_are_separate(): assert COMPOSE["dev"]["name"] == "mindnet-dev" assert COMPOSE["prod"]["name"] == "mindnet-prod" assert set(COMPOSE["dev"]["networks"]).isdisjoint(COMPOSE["prod"]["networks"]) def test_compose_ports_do_not_collide(): ports = {e: {_host_port(p) for s in c["services"].values() for p in s.get("ports", [])} for e, c in COMPOSE.items()} assert ports["dev"].isdisjoint(ports["prod"]) assert not (ports["dev"] | ports["prod"]) & SYSTEMD_PORTS @pytest.mark.parametrize("envname", ["dev", "prod"]) def test_compose_app_services_hardened(envname): for name in APP_SERVICES: svc = COMPOSE[envname]["services"][name] assert svc["read_only"] is True assert svc["cap_drop"] == ["ALL"] assert "no-new-privileges:true" in svc["security_opt"] assert svc["environment"]["VECTOR_DIM"] == "768" assert svc["environment"]["MINDNET_VAULT_READONLY"] == "true" assert svc["healthcheck"]["test"][-1] == name @pytest.mark.parametrize("envname", ["dev", "prod"]) def test_compose_vault_is_read_only_bind_without_autocreate(envname): mounts = [v for v in COMPOSE[envname]["services"]["api"]["volumes"] if isinstance(v, dict) and v.get("type") == "bind"] assert len(mounts) == 1 assert mounts[0]["target"].startswith("${MINDNET_VAULT_TARGET:?") # aus der systemd-.env abgeleitet assert mounts[0]["read_only"] is True assert mounts[0]["bind"]["create_host_path"] is False assert not [v for v in COMPOSE[envname]["services"]["ui"]["volumes"] if isinstance(v, dict)] @pytest.mark.parametrize("envname", ["dev", "prod"]) def test_compose_api_defaults_to_loopback(envname): assert all(p.startswith("${MINDNET_API_BIND:-127.0.0.1}:") for p in COMPOSE[envname]["services"]["api"]["ports"]) @pytest.mark.parametrize("envname", ["dev", "prod"]) def test_compose_uses_existing_host_services_and_app_config(envname): # Wie systemd: gemeinsame Host-Qdrant und Host-Ollama; Präfix/Vault aus der systemd-.env. assert set(COMPOSE[envname]["services"]) == set(APP_SERVICES) for name in APP_SERVICES: env = COMPOSE[envname]["services"][name]["environment"] assert env["MINDNET_ENV"] == envname assert env["QDRANT_URL"] == "http://host.docker.internal:6333" assert env["MINDNET_OLLAMA_URL"] == "http://host.docker.internal:11434" assert not {"COLLECTION_PREFIX", "MINDNET_VAULT_ROOT", "MINDNET_VOCAB_PATH"} & set(env) def test_dockerfile_pinned_and_non_root(): text = (DEPLOY / "Dockerfile").read_text(encoding="utf-8") assert re.search(r"ARG PYTHON_IMAGE=python:3\.12-slim-bookworm@sha256:[0-9a-f]{64}", text) runtime = text.split("AS runtime", 1)[1].split("AS test", 1)[0] assert "USER mindnet:mindnet" in runtime assert "--require-hashes" in text def test_lock_excludes_torch_and_minilm_and_is_hashed(): lock = (DEPLOY / "requirements.lock").read_text(encoding="utf-8") pins = re.findall(r"^([a-z0-9][a-z0-9._-]*)==", lock, re.M) assert pins and not {"torch", "sentence-transformers", "transformers"} & set(pins) entries = re.split(r"\n(?=[a-z0-9])", lock.strip()) assert all("--hash=sha256:" in e for e in entries if re.match(r"[a-z0-9]", e)) def test_dockerignore_is_allowlist_without_env_files(): lines = [l.strip() for l in (ROOT / ".dockerignore").read_text(encoding="utf-8").splitlines() if l.strip() and not l.startswith("#")] assert lines[0] == "**" assert "config/*.env" in lines and "deploy/env/*.env" in lines assert not any(l.startswith("!") and ("vault" in l or ".env" in l) for l in lines) @pytest.mark.parametrize("envname", ["dev", "prod"]) def test_container_env_example_has_only_container_keys(envname): appenv = _load_deploy_module("appenv") values = appenv.parse(str(DEPLOY / "env" / f"{envname}.env.example")) assert set(values) <= appenv.CONTAINER_KEYS assert values["MINDNET_ALLOW_CLOUD_EGRESS"] == "false" # --- Gitea-Workflows und Deploy-Skript (Muster wie Kansho: develop -> dev, main -> prod) ---- WORKFLOWS = {"deploy-dev.yml": ROOT / ".gitea" / "workflows", # aktiv "deploy-prod.yml": DEPLOY / "gitea-workflows"} # Vorlage bis zur Umschaltung def _workflow(name): data = yaml.safe_load((WORKFLOWS[name] / name).read_text(encoding="utf-8")) return data, data.get("on", data.get(True)) # PyYAML liest den Schlüssel 'on' als True @pytest.mark.parametrize("name, branch, envname", [("deploy-dev.yml", "develop", "dev"), ("deploy-prod.yml", "main", "prod")]) def test_workflow_maps_branch_to_environment(name, branch, envname): wf, on = _workflow(name) assert on["push"]["branches"] == [branch] job = wf["jobs"]["deploy"] assert job["runs-on"] == "linux_host" assert job["env"]["MINDNET_ENV_FILE"].startswith("/") and job["env"]["MINDNET_ENV_FILE"].endswith("container.env") assert job["env"]["MINDNET_APP_ENV_FILE"] == SYSTEMD_ENV_FILES[envname] assert any(s.get("run") == f"bash deploy/deploy.sh {envname}" for s in job["steps"]) def test_prod_workflow_shares_concurrency_with_systemd_deploy(): wf, _ = _workflow("deploy-prod.yml") systemd = yaml.safe_load((ROOT / ".gitea" / "workflows" / "deploy.yml").read_text(encoding="utf-8")) assert wf["concurrency"]["group"] == systemd["concurrency"]["group"] def test_deploy_script_checks_before_touching_running_stack(): script = (DEPLOY / "deploy.sh").read_text(encoding="utf-8") assert "\r" not in script steps = script.split('step "1/5', 1)[1] # ohne Kopfkommentar und Funktionsdefinitionen order = [steps.index(s) for s in ("--network none", "preflight --live", "up -d --wait --no-build --remove-orphans && smoke")] assert order == sorted(order) assert "preflight --live" in script and "run --rm --no-deps api preflight" in script assert "--require-data" in script and "deploy/appenv.py" in script assert "last_good_tag" in script @pytest.mark.parametrize("envname", ["dev", "prod"]) def test_compose_reads_systemd_env_then_container_env(envname): files = COMPOSE[envname]["x-hardening"]["env_file"] assert files[0].startswith("${MINDNET_APP_ENV_FILE:?") assert files[1] == f"${{MINDNET_ENV_FILE:-env/{envname}.env}}" def test_prod_workflow_not_active_before_switchover(): assert not (ROOT / ".gitea" / "workflows" / "deploy-prod.yml").exists() @pytest.mark.parametrize("name", ["deploy-dev.yml", "deploy-prod.yml"]) def test_workflow_needs_no_external_actions(name): # Der Runner-Host soll ohne Internet/DNS deployen können (kein github.com). wf, _ = _workflow(name) assert not [s["uses"] for s in wf["jobs"]["deploy"]["steps"] if "uses" in s]