""" 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} def _load_entrypoint(): spec = importlib.util.spec_from_file_location("mindnet_entrypoint", DEPLOY / "entrypoint.py") module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) return module ep = _load_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_sentinel=True): root = tmp_path / "vault" root.mkdir() if with_sentinel: sentinel = root / "_system" / "dictionary" / "edge_vocabulary.md" sentinel.parent.mkdir(parents=True) sentinel.write_text("# vocab", 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_sentinel=False))) 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("target") == "/vault"] assert len(mounts) == 1 assert mounts[0]["read_only"] is True assert mounts[0]["bind"]["create_host_path"] is False assert all(":/vault" not in v for v in COMPOSE[envname]["services"]["ui"]["volumes"] if isinstance(v, str)) @pytest.mark.parametrize("envname", ["dev", "prod"]) def test_compose_api_only_on_loopback(envname): assert all(p.startswith("127.0.0.1:") for p in COMPOSE[envname]["services"]["api"]["ports"]) def test_prod_uses_existing_qdrant_and_dev_its_own(): assert "qdrant" not in COMPOSE["prod"]["services"] dev_qdrant = COMPOSE["dev"]["services"]["qdrant"] assert "@sha256:" in dev_qdrant["image"] for name in APP_SERVICES: dev_env = COMPOSE["dev"]["services"][name]["environment"] assert dev_env["QDRANT_URL"] == "http://qdrant:6333" assert dev_env["COLLECTION_PREFIX"].endswith("_dev") 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) def test_prod_env_example_blocks_cloud_egress(): values = dict(l.split("=", 1) for l in (DEPLOY / "env" / "prod.env.example").read_text(encoding="utf-8").splitlines() if "=" in l and not l.startswith("#")) assert values["OPENROUTER_API_KEY"] == "" and values["GOOGLE_API_KEY"] == "" 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(f"{envname}.env") 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 && smoke")] assert order == sorted(order) assert "RUN_DEPS=(--no-deps)" in script and "SMOKE_ARGS=(--require-data)" in script assert "last_good_tag" in script @pytest.mark.parametrize("envname", ["dev", "prod"]) def test_compose_reads_env_file_from_host(envname): assert COMPOSE[envname]["x-hardening"]["env_file"] == [f"${{MINDNET_ENV_FILE:-env/{envname}.env}}"] def test_prod_workflow_not_active_before_switchover(): assert not (ROOT / ".gitea" / "workflows" / "deploy-prod.yml").exists() def test_dev_testvault_is_synthetic_and_parseable(): vault = DEPLOY / "testvault" vocab = (vault / "_system" / "dictionary" / "edge_vocabulary.md").read_text(encoding="utf-8") # Gleiches Muster wie app/services/edge_registry.py rows = re.findall(r"\|\s*\*\*`?([a-zA-Z0-9_-]+)`?\*\*\s*\|\s*`?([a-zA-Z0-9_-]+)`?\s*\|\s*([^|]+)\|", vocab) assert len(rows) >= 10 assert (vault / "_system" / "dictionary" / "graph_schema.md").is_file() notes = [f for f in vault.rglob("*.md") if "_system" not in f.parts] assert notes and all("topic/test" in f.read_text(encoding="utf-8") for f in notes)