Mappen van deze host
@@ -3991,6 +4012,7 @@ function app() {
network: '', ip: '', ips: {}, services: [], service_info: [],
app_services: [], depends_on: [],
extras: { volumes: [], devices: [] },
+ image_tags: {},
compatibility: { known: false, supported: true, architecture: '', reason: '' },
architecture_note: ''
};
@@ -4248,6 +4270,7 @@ function app() {
source_repo: d.source_repo || {},
extras: { volumes: (d.extras||{}).volumes || [],
devices: (d.extras||{}).devices || [] },
+ image_tags: { ...(d.image_tags || {}) },
};
await this.loadAppNets(stack);
this.fieldInfo = null;
@@ -4271,6 +4294,7 @@ function app() {
app_networks: this.install.app_networks || [],
app_services: this.install.app_services || [],
extras: this.install.extras || {},
+ image_tags: this.install.image_tags || {},
});
if (!d.job_id) { this.toast(d.msg || this.t('error'), 'er'); return; }
this.modal = null;
@@ -4306,6 +4330,10 @@ function app() {
body.app_networks = this.install.app_networks || [];
body.app_services = this.install.app_services || [];
body.extras = this.install.extras || {};
+ // Boilerplate-apps sturen hun versiekeuze hier mee; het klassieke
+ // formaat gebruikt hiervoor het imageTags-blok verderop.
+ if (this.install.format === 'boilerplate')
+ body.image_tags = this.install.image_tags || {};
if (this.install.format === 'boilerplate') body.values = this.install.values;
else { body.env_overrides = this.install.envOverrides; body.image_tags = this.install.imageTags; }
// Heb je het resultaat in de laatste stap zelf bewerkt, dan telt jouw
diff --git a/server-up/translations/en.json b/server-up/translations/en.json
index c522f32..ac72adc 100644
--- a/server-up/translations/en.json
+++ b/server-up/translations/en.json
@@ -69,6 +69,8 @@
"device_stable": "stable",
"no_devices": "No devices found on this host. You can type the path yourself, for example /dev/ttyUSB0.",
"path_unreachable": "Server Up cannot reach this path; check that the folder is mounted.",
+ "image_versions": "Versions",
+ "image_versions_hint": "Leave empty to follow the template (usually 'latest'). Enter a version to pin it, so updating cannot silently carry you across a major release.",
"add_repo": "Add repository",
"repo_name": "Name",
"repo_url": "Git URL",
diff --git a/server-up/translations/nl.json b/server-up/translations/nl.json
index 214b326..f013c24 100644
--- a/server-up/translations/nl.json
+++ b/server-up/translations/nl.json
@@ -69,6 +69,8 @@
"device_stable": "vast",
"no_devices": "Geen apparaten gevonden op deze host. Je kunt het pad zelf intikken, bijvoorbeeld /dev/ttyUSB0.",
"path_unreachable": "Server Up kan hier niet bij; controleer of deze map gemount is.",
+ "image_versions": "Versies",
+ "image_versions_hint": "Leeg laten volgt het sjabloon (meestal 'latest'). Vul een versie in om die vast te houden, zodat Bijwerken je niet ongemerkt over een grote versiesprong tilt.",
"add_repo": "Repository toevoegen",
"repo_name": "Naam",
"repo_url": "Git URL",
diff --git a/tests/test_compose_transform.py b/tests/test_compose_transform.py
index 6f37093..d91b14d 100644
--- a/tests/test_compose_transform.py
+++ b/tests/test_compose_transform.py
@@ -252,3 +252,43 @@ def test_geweigerd_pad_belandt_niet_in_compose():
def test_zonder_extras_verandert_er_niets():
assert ct.add_extras(EXTRA_BASIS, {}) == EXTRA_BASIS
assert ct.add_extras(EXTRA_BASIS, {"volumes": [], "devices": []}) == EXTRA_BASIS
+
+
+# ── Versietags ───────────────────────────────────────────────────────────────
+
+TAG_BASIS = """\
+services:
+ app:
+ image: lscr.io/linuxserver/unifi-network-application:latest
+ db:
+ image: registry.local:5000/mongo
+ var:
+ image: ${IMAGE}
+"""
+
+
+def test_images_per_service_splitst_repo_en_tag():
+ per_naam = {i["service"]: i for i in ct.images_per_service(TAG_BASIS)}
+ assert per_naam["app"]["repo"] == "lscr.io/linuxserver/unifi-network-application"
+ assert per_naam["app"]["tag"] == "latest"
+ # De dubbele punt in registry.local:5000 is een poort, geen tag.
+ assert per_naam["db"]["repo"] == "registry.local:5000/mongo"
+ assert per_naam["db"]["tag"] == "latest"
+ # Een image uit een variabele gaat over de .env, niet over dit scherm.
+ assert "var" not in per_naam
+
+
+def test_versietag_zetten():
+ uit = ct.zet_image_tags(TAG_BASIS, {"app": "10.4.57", "db": "7.0"})
+ doc = yaml.safe_load(uit)
+ assert doc["services"]["app"]["image"].endswith(":10.4.57")
+ assert doc["services"]["db"]["image"] == "registry.local:5000/mongo:7.0"
+ assert doc["services"]["var"]["image"] == "${IMAGE}"
+
+
+def test_lege_of_onbekende_tag_verandert_niets():
+ assert ct.zet_image_tags(TAG_BASIS, {}) == TAG_BASIS
+ assert ct.zet_image_tags(TAG_BASIS, {"app": " "}) == TAG_BASIS
+ assert ct.zet_image_tags(TAG_BASIS, {"bestaatniet": "1"}) == TAG_BASIS
+ # Dezelfde tag nog eens zetten laat het bestand ongemoeid.
+ assert ct.zet_image_tags(TAG_BASIS, {"app": "latest"}) == TAG_BASIS
diff --git a/tests/test_containers.py b/tests/test_containers.py
index 8885177..24184bd 100644
--- a/tests/test_containers.py
+++ b/tests/test_containers.py
@@ -257,3 +257,54 @@ def test_compose_ps_toont_alleen_werkelijk_gepubliceerde_poorten(host):
def test_compose_ps_valt_bij_oude_compose_terug_op_ports(host):
assert host._published_ports(
{"Ports": "0.0.0.0:8080->80/tcp"}) == "0.0.0.0:8080->80/tcp"
+
+
+# ── Eén docker-aanroep voor de hele lijst ────────────────────────────────────
+
+def test_stacklijst_doet_geen_aanroep_per_app(client, env, monkeypatch):
+ """De lijst deed een `docker compose ps` per stackmap: bij vijftien apps
+ vijftien processen per keer verversen, en nog eens zoveel bij elk openen
+ van de installatiemodal."""
+ from core import docker
+ for naam in ("een", "twee", "drie"):
+ d = env["lib"] / naam
+ d.mkdir(parents=True, exist_ok=True)
+ (d / "docker-compose.yml").write_text(f"services:\n {naam}:\n image: nginx\n")
+
+ aanroepen = {"ps": 0}
+
+ def _lijst(alle=True):
+ aanroepen["ps"] += 1
+ return [
+ {"id": "a", "name": "een-app-1", "image": "nginx", "state": "running",
+ "status": "Up", "ports": "0.0.0.0:8080->80/tcp", "project": "een",
+ "working_dir": str(env["lib"] / "een"), "service": "app",
+ "running": True},
+ {"id": "b", "name": "twee-app-1", "image": "nginx", "state": "exited",
+ "status": "Exited (0)", "ports": "", "project": "twee",
+ "working_dir": str(env["lib"] / "twee"), "service": "app",
+ "running": False},
+ ]
+
+ monkeypatch.setattr(docker, "list_containers", _lijst)
+ monkeypatch.setattr(docker, "compose_ps", lambda *a, **k: pytest.fail(
+ "er werd alsnog een aanroep per app gedaan"))
+ login(client)
+
+ per_naam = {s["name"]: s for s in client.get("/api/stacks").get_json()}
+ assert aanroepen["ps"] == 1, "meer dan één docker-aanroep voor de hele lijst"
+ assert per_naam["een"]["running"] is True
+ assert per_naam["een"]["containers"][0]["service"] == "app"
+ assert per_naam["twee"]["running"] is False
+ # Een app zonder containers blijft gewoon in de lijst staan.
+ assert per_naam["drie"]["running"] is False
+ assert per_naam["drie"]["containers"] == []
+
+
+def test_containers_worden_op_project_gegroepeerd(host):
+ per_project = host.containers_per_project()
+ assert set(per_project) == {"vaultwarden", "forgejo", "server-up"}
+ assert per_project["vaultwarden"][0]["name"] == "vaultwarden"
+ # Containers zonder compose-label horen bij geen enkele app.
+ assert all("act_runner" not in [c["name"] for c in v]
+ for v in per_project.values())
diff --git a/tests/test_dbwachtwoord.py b/tests/test_dbwachtwoord.py
new file mode 100644
index 0000000..0289d43
--- /dev/null
+++ b/tests/test_dbwachtwoord.py
@@ -0,0 +1,285 @@
+"""Een gewijzigd databasewachtwoord moet ook in de database terechtkomen.
+
+`POSTGRES_PASSWORD` en verwanten worden door de officiële images alleen bij een
+lege datamap gebruikt. Wie dat veld in de instellingen wijzigde, kreeg een app
+met een nieuw wachtwoord en een database met het oude — en dus een stack die
+niet meer kon inloggen, met een foutmelding die nergens naar het wachtwoord
+verwees.
+"""
+import json
+import sys
+import time
+from pathlib import Path
+
+import pytest
+import yaml
+
+WORTEL = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(WORTEL / "server-up"))
+
+from conftest import login
+
+COMPOSE = """\
+services:
+ web:
+ image: nginx
+ environment:
+ - DB_PASS=${DB_PASSWORD}
+ web-db:
+ image: postgres:16-alpine
+ container_name: web-db
+ environment:
+ - POSTGRES_USER=app
+ - POSTGRES_DB=app
+ - POSTGRES_PASSWORD=${DB_PASSWORD}
+"""
+
+
+def _diensten(env_waarden):
+ from core import backups
+ return backups.diensten_uit_compose(COMPOSE, env_waarden)
+
+
+# ── Herkennen ────────────────────────────────────────────────────────────────
+
+def test_gewijzigd_wachtwoord_wordt_herkend(env):
+ from core import dbwachtwoord
+ voor = _diensten({"DB_PASSWORD": "oud"})
+ na = _diensten({"DB_PASSWORD": "nieuw"})
+ veranderd = dbwachtwoord.wijzigingen(voor, na)
+ assert len(veranderd) == 1
+ assert veranderd[0]["service"] == "web-db"
+ assert veranderd[0]["oud_wachtwoord"] == "oud"
+ assert veranderd[0]["wachtwoord"] == "nieuw"
+
+
+def test_gelijk_wachtwoord_levert_geen_werk_op(env):
+ from core import dbwachtwoord
+ zelfde = _diensten({"DB_PASSWORD": "geheim"})
+ assert dbwachtwoord.wijzigingen(zelfde, zelfde) == []
+
+
+def test_nieuwe_database_telt_niet_mee(env):
+ """Een dienst die er nog niet was heeft geen oud wachtwoord om mee in te
+ loggen; die krijgt zijn wachtwoord gewoon bij de eerste start."""
+ from core import dbwachtwoord
+ assert dbwachtwoord.wijzigingen([], _diensten({"DB_PASSWORD": "x"})) == []
+
+
+# ── De commando's ────────────────────────────────────────────────────────────
+
+def _cmd(soort, oud="oud", nieuw="nieuw", gebruiker="app"):
+ from core import dbwachtwoord
+ dienst = {"soort": soort, "gebruiker": gebruiker, "database": "app",
+ "container": f"web-{soort}", "wachtwoord": nieuw,
+ "oud_wachtwoord": oud}
+ return dbwachtwoord.commando(dienst, nieuw)
+
+
+def test_postgres_zet_het_wachtwoord_om():
+ cmd, omgeving = _cmd("postgres", oud="Ou6-oudgeheim", nieuw="Zg3-nieuwgeheim")
+ assert "ALTER USER app WITH PASSWORD" in omgeving["SU_SQL"]
+ assert omgeving["PGPASSWORD"] == "Ou6-oudgeheim"
+ assert "| psql -v ON_ERROR_STOP=1 -U app -d app" in cmd[-1]
+ # Geen van beide wachtwoorden staat in het commando zelf: argumenten zijn
+ # op de host zichtbaar in de procestabel.
+ assert "Zg3-nieuwgeheim" not in cmd[-1]
+ assert "Ou6-oudgeheim" not in cmd[-1]
+
+
+def test_postgres_laat_een_backslash_met_rust():
+ """Postgres neemt een backslash letterlijk; verdubbelen zou het wachtwoord
+ veranderen en de app alsnog buitensluiten."""
+ _, omgeving = _cmd("postgres", nieuw="pas\\woord")
+ assert omgeving["SU_SQL"] == "ALTER USER app WITH PASSWORD 'pas\\woord';"
+ _, mysql_omgeving = _cmd("mysql", nieuw="pas\\woord")
+ assert "pas\\\\woord" in mysql_omgeving["SU_SQL"]
+
+
+def test_mysql_en_mariadb():
+ for soort, client in (("mysql", "mysql"), ("mariadb", "mariadb")):
+ cmd, omgeving = _cmd(soort, oud="Ou6-oudgeheim", nieuw="Zg3-nieuwgeheim")
+ assert f"| {client} -u app" in cmd[-1]
+ assert "ALTER USER USER() IDENTIFIED BY" in omgeving["SU_SQL"]
+ assert omgeving["SU_OUD"] == "Ou6-oudgeheim"
+ # Via stdin, dus geen wachtwoord in de procestabel van de host.
+ assert "Zg3-nieuwgeheim" not in cmd[-1]
+ assert "Ou6-oudgeheim" not in cmd[-1]
+
+
+def test_mongo_werkt_met_mongo_en_mongosh():
+ cmd, omgeving = _cmd("mongo", gebruiker="root", oud="Ou6-oud",
+ nieuw="Zg3-nieuw")
+ assert "updateUser" in omgeving["SU_JS"]
+ assert "mongosh" in cmd[-1] and "bin=mongo" in cmd[-1]
+ assert "Zg3-nieuw" not in cmd[-1] and "Ou6-oud" not in cmd[-1]
+
+
+def test_aanhalingstekens_breken_het_statement_niet():
+ """Een wachtwoord met een quote erin mag geen SQL of JavaScript openbreken."""
+ _, omgeving = _cmd("mysql", nieuw="pas'woord\\raar")
+ assert "pas''woord" in omgeving["SU_SQL"]
+ assert "\\\\raar" in omgeving["SU_SQL"]
+
+ _, mongo_omgeving = _cmd("mongo", nieuw='pas"woord\\raar')
+ assert '\\"woord' in mongo_omgeving["SU_JS"]
+
+
+def test_onbekend_soort_geeft_een_duidelijke_fout():
+ from core import dbwachtwoord
+ with pytest.raises(dbwachtwoord.WachtwoordFout):
+ dbwachtwoord.commando({"soort": "sqlite", "gebruiker": "",
+ "oud_wachtwoord": "x", "container": "c"}, "y")
+
+
+# ── Omzetten in de container ─────────────────────────────────────────────────
+
+def test_gestopte_database_wordt_gemeld(env, monkeypatch):
+ from core import dbwachtwoord, docker
+ monkeypatch.setattr(docker, "container_draait", lambda n: False)
+ ok, msg = dbwachtwoord.omzetten(
+ {"soort": "postgres", "gebruiker": "app", "database": "app",
+ "container": "web-db", "oud_wachtwoord": "oud"}, "nieuw")
+ assert ok is False
+ assert "draait niet" in msg
+
+
+def test_wachtwoord_lekt_niet_in_de_foutmelding(env, monkeypatch):
+ """Een joblog is zichtbaar voor iedereen die de app mag bedienen."""
+ from core import dbwachtwoord, docker
+
+ class Mislukt:
+ returncode = 1
+ stdout = ""
+ stderr = 'FATAL: password authentication failed voor "supergeheim123"'
+
+ monkeypatch.setattr(docker, "container_draait", lambda n: True)
+ monkeypatch.setattr(docker, "_run", lambda *a, **k: Mislukt())
+ ok, msg = dbwachtwoord.omzetten(
+ {"soort": "postgres", "gebruiker": "app", "database": "app",
+ "container": "web-db", "oud_wachtwoord": "supergeheim123"}, "nieuw")
+ assert ok is False
+ assert "supergeheim123" not in msg
+ assert "***" in msg
+
+
+# ── De hele weg door de wijziging heen ───────────────────────────────────────
+
+def _sjabloon(client, csrf):
+ from core import git
+ wortel = git.cache_dir("server-up") / "apps" / "dbapp"
+ (wortel / "files").mkdir(parents=True, exist_ok=True)
+ (wortel / "template.json").write_text(json.dumps({
+ "kind": "compose", "metadata": {"name": "dbapp"},
+ "variables": [{"title": "Algemeen", "items": [
+ {"name": "service_name", "type": "str", "title": "Naam",
+ "default": "dbapp", "required": True},
+ {"name": "db_password", "type": "str", "title": "Wachtwoord",
+ "default": "", "required": True, "secret": True,
+ "generate": "auto"},
+ ]}]}), encoding="utf-8")
+ (wortel / "files" / "compose.yaml").write_text(
+ 'services:\n'
+ ' << service_name >>:\n image: nginx\n'
+ ' << service_name >>-db:\n'
+ ' image: postgres:16-alpine\n'
+ ' container_name: << service_name >>-db\n'
+ ' environment:\n'
+ ' - POSTGRES_USER=app\n'
+ ' - POSTGRES_DB=app\n'
+ ' - POSTGRES_PASSWORD=<< db_password >>\n', encoding="utf-8")
+
+ r = client.post("/api/store/install",
+ json={"stack": "dbapp", "repo_id": "server-up",
+ "instance": "dbapp", "connect_apps": False,
+ "values": {"service_name": "dbapp",
+ "db_password": "eerstewachtwoord"}},
+ headers={"X-CSRF-Token": csrf})
+ assert r.status_code == 200, r.get_json()
+ _wacht(client, r.get_json()["job_id"])
+
+
+def _wacht(client, jid, tijdslimiet=10):
+ einde = time.time() + tijdslimiet
+ while time.time() < einde:
+ d = client.get(f"/api/jobs/{jid}").get_json() or {}
+ if d.get("status") in ("done", "error"):
+ return d
+ time.sleep(0.05)
+ return {}
+
+
+def _stub_docker(monkeypatch, app_module, omzetten_lukt=True):
+ monkeypatch.setattr(app_module.docker, "validate_compose", lambda *a, **k: (True, ""))
+ monkeypatch.setattr(app_module.docker, "compose_down", lambda *a, **k: 0)
+ monkeypatch.setattr(app_module.docker, "compose_up", lambda *a, **k: 0)
+ monkeypatch.setattr(app_module.backups, "create", lambda *a, **k: {"file": "x.tar.gz"})
+ gedaan = []
+
+ def _omzetten(dienst, nieuw, log_fn=None):
+ gedaan.append((dienst["container"], dienst["oud_wachtwoord"], nieuw))
+ if omzetten_lukt:
+ if log_fn:
+ log_fn("Wachtwoord omgezet")
+ return True, ""
+ return False, "Wachtwoord van web-db niet gewijzigd: verbinding geweigerd"
+
+ monkeypatch.setattr(app_module.dbwachtwoord, "omzetten", _omzetten)
+ return gedaan
+
+
+def test_wijziging_zet_het_wachtwoord_ook_in_de_database(client, env, monkeypatch):
+ import app as app_module
+ csrf = login(client)
+ _sjabloon(client, csrf)
+ gedaan = _stub_docker(monkeypatch, app_module)
+
+ r = client.post("/api/stacks/dbapp/reconfigure",
+ json={"values": {"service_name": "dbapp",
+ "db_password": "tweedewachtwoord"},
+ "connect_apps": False},
+ headers={"X-CSRF-Token": csrf})
+ assert r.status_code == 200, r.get_json()
+ d = _wacht(client, r.get_json()["job_id"])
+ assert d.get("status") == "done", d.get("lines")
+
+ assert gedaan == [("dbapp-db", "eerstewachtwoord", "tweedewachtwoord")]
+
+
+def test_zonder_wachtwoordwijziging_gebeurt_er_niets_met_de_database(
+ client, env, monkeypatch):
+ import app as app_module
+ csrf = login(client)
+ _sjabloon(client, csrf)
+ gedaan = _stub_docker(monkeypatch, app_module)
+
+ r = client.post("/api/stacks/dbapp/reconfigure",
+ json={"values": {"service_name": "dbapp",
+ "db_password": "eerstewachtwoord"},
+ "connect_apps": False},
+ headers={"X-CSRF-Token": csrf})
+ _wacht(client, r.get_json()["job_id"])
+ assert gedaan == []
+
+
+def test_mislukte_omzetting_breekt_de_wijziging_af(client, env, monkeypatch):
+ """Een instelling die niet doorgaat is beter dan een app die niet meer bij
+ zijn gegevens kan."""
+ import app as app_module
+ csrf = login(client)
+ _sjabloon(client, csrf)
+ _stub_docker(monkeypatch, app_module, omzetten_lukt=False)
+ hersteld = []
+ monkeypatch.setattr(app_module.backups, "restore",
+ lambda *a, **k: hersteld.append(a) or (True, "ok"))
+
+ r = client.post("/api/stacks/dbapp/reconfigure",
+ json={"values": {"service_name": "dbapp",
+ "db_password": "derdewachtwoord"},
+ "connect_apps": False},
+ headers={"X-CSRF-Token": csrf})
+ d = _wacht(client, r.get_json()["job_id"])
+ assert d.get("status") == "error"
+ tekst = "\n".join(x["text"] for x in d.get("lines", []))
+ assert "niet meer bij zijn database" in tekst
+ assert hersteld, "de backup hoort teruggezet te worden"
diff --git a/tests/test_reconfigure.py b/tests/test_reconfigure.py
index 0a813fb..8f31b17 100644
--- a/tests/test_reconfigure.py
+++ b/tests/test_reconfigure.py
@@ -383,3 +383,50 @@ def test_apparatenlijst_is_op_te_vragen(client, env):
assert "devices" in d and isinstance(d["devices"], list)
for dev in d["devices"]:
assert dev["path"].startswith("/dev/")
+
+
+# ── Versietags ───────────────────────────────────────────────────────────────
+
+def test_versietag_wordt_vastgehouden_over_wijzigingen_heen(client, env, monkeypatch):
+ """Sjablonen staan meestal op `latest`; wie een versie kiest wil niet dat
+ de eerstvolgende instellingswijziging hem daar weer af haalt."""
+ import yaml as _yaml
+ import app as app_module
+ csrf = login(client)
+ _installeer_keuzeapp(client, csrf)
+ monkeypatch.setattr(app_module.docker, "validate_compose", lambda *a, **k: (True, ""))
+ monkeypatch.setattr(app_module.docker, "compose_down", lambda *a, **k: 0)
+ monkeypatch.setattr(app_module.docker, "compose_up", lambda *a, **k: 0)
+ monkeypatch.setattr(app_module.backups, "create", lambda *a, **k: {"file": "x.tar.gz"})
+
+ r = client.post("/api/stacks/kz/reconfigure",
+ json={"values": {"service_name": "keuzeapp", "port": 9300},
+ "connect_apps": False,
+ "image_tags": {"keuzeapp": "1.25-alpine"}},
+ headers={"X-CSRF-Token": csrf})
+ assert _wacht_op_job(client, r.get_json()["job_id"]).get("status") == "done"
+
+ def _image():
+ compose = next(p for p in (env["lib"] / "kz").iterdir()
+ if p.name.startswith(("compose", "docker-compose")))
+ return _yaml.safe_load(compose.read_text())["services"]["keuzeapp"]["image"]
+
+ assert _image() == "nginx:1.25-alpine"
+
+ # Een volgende wijziging zonder tags: de keuze staat in de metadata en
+ # hoort te blijven staan, ook al rendert het sjabloon weer `nginx`.
+ r = client.post("/api/stacks/kz/reconfigure",
+ json={"values": {"service_name": "keuzeapp", "port": 9301},
+ "connect_apps": False},
+ headers={"X-CSRF-Token": csrf})
+ _wacht_op_job(client, r.get_json()["job_id"])
+ assert _image() == "nginx:1.25-alpine"
+
+
+def test_onzinnige_versietag_wordt_genegeerd(client, env, monkeypatch):
+ """De tag belandt in het compose-bestand; een waarde met een spatie of een
+ dubbele punt erin zou dat bestand stukmaken."""
+ import app as app_module
+ assert app_module._gekozen_image_tags({"image_tags": {"a": "1.2.3"}}) == {"a": "1.2.3"}
+ for onzin in ("mijn tag", "tag:met:dubbelepunt", "-begintmetstreepje", "", " "):
+ assert app_module._gekozen_image_tags({"image_tags": {"a": onzin}}) == {}
diff --git a/tests/test_stackslot.py b/tests/test_stackslot.py
new file mode 100644
index 0000000..5fd8718
--- /dev/null
+++ b/tests/test_stackslot.py
@@ -0,0 +1,140 @@
+"""Eén taak tegelijk per app.
+
+Zonder vergrendeling kan de nachtelijke backup starten terwijl een
+instellingswijziging net `compose down` heeft gedaan en de bestanden
+herschrijft. Het archief bevat dan een halve stack, terwijl de melding erna
+'Backup klaar' is.
+"""
+import sys
+import threading
+import time
+from pathlib import Path
+
+WORTEL = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(WORTEL / "server-up"))
+
+
+def test_tweede_taak_wacht_op_de_eerste(env):
+ from core import jobs
+ volgorde = []
+ eerste_bezig = threading.Event()
+ laat_los = threading.Event()
+
+ def taak_een(jid):
+ volgorde.append("een-start")
+ eerste_bezig.set()
+ laat_los.wait(5)
+ volgorde.append("een-klaar")
+ jobs.finish(jid, "done")
+ jobs.done(jobs.get_queue(jid))
+
+ def taak_twee(jid):
+ volgorde.append("twee-start")
+ jobs.finish(jid, "done")
+ jobs.done(jobs.get_queue(jid))
+
+ jid1, _ = jobs.create("update:web")
+ jid2, _ = jobs.create("backup:web")
+ jobs.run(jobs.met_slot("web", taak_een), jid1)
+ assert eerste_bezig.wait(5)
+ jobs.run(jobs.met_slot("web", taak_twee), jid2)
+ time.sleep(0.2)
+
+ assert volgorde == ["een-start"], "de tweede taak begon terwijl de eerste liep"
+ laat_los.set()
+ einde = time.time() + 5
+ while time.time() < einde and "twee-start" not in volgorde:
+ time.sleep(0.02)
+ assert volgorde == ["een-start", "een-klaar", "twee-start"]
+
+ # En de wachtende taak meldt dat ook in zijn eigen log.
+ tekst = " ".join(r["text"] for r in jobs.stream(jid2)["lines"])
+ assert "wacht" in tekst
+
+
+def test_andere_app_hoeft_niet_te_wachten(env):
+ """Twee verschillende apps mogen wél tegelijk."""
+ from core import jobs
+ bezig = threading.Event()
+ los = threading.Event()
+ gedraaid = []
+
+ def blokkeer(jid):
+ bezig.set()
+ los.wait(5)
+ jobs.finish(jid, "done")
+ jobs.done(jobs.get_queue(jid))
+
+ def snel(jid):
+ gedraaid.append(True)
+ jobs.finish(jid, "done")
+ jobs.done(jobs.get_queue(jid))
+
+ jid1, _ = jobs.create("update:web")
+ jid2, _ = jobs.create("update:andere")
+ jobs.run(jobs.met_slot("web", blokkeer), jid1)
+ assert bezig.wait(5)
+ jobs.run(jobs.met_slot("andere", snel), jid2)
+
+ einde = time.time() + 5
+ while time.time() < einde and not gedraaid:
+ time.sleep(0.02)
+ assert gedraaid, "een taak op een andere app werd onnodig geblokkeerd"
+ los.set()
+
+
+def test_slot_komt_vrij_na_een_fout(env):
+ """Een taak die klapt mag de app niet voor altijd op slot zetten, en mag
+ ook niet eeuwig op 'running' blijven staan met een interface die erop
+ blijft pollen."""
+ from core import jobs
+
+ def klapt(jid):
+ raise RuntimeError("boem")
+
+ jid, _ = jobs.create("update:web")
+ t = threading.Thread(target=jobs.met_slot("web", klapt), args=(jid,))
+ t.start(); t.join(5)
+
+ with jobs.stack_slot("web") as vrij:
+ assert vrij, "het slot bleef hangen na een mislukte taak"
+
+ d = jobs.stream(jid)
+ assert d["status"] == "error"
+ assert "boem" in " ".join(r["text"] for r in d["lines"])
+
+
+def test_geplande_backup_slaat_een_bezette_app_over(env, monkeypatch):
+ """Wachten heeft geen zin als er een lange update loopt; dan is overslaan
+ met een melding beter dan een archief van een halve stack."""
+ import app as app_module
+ from core import jobs
+ (env["lib"] / "web").mkdir(parents=True, exist_ok=True)
+ (env["lib"] / "web" / "docker-compose.yml").write_text(
+ "services:\n web:\n image: nginx\n")
+ env["core"].patch({"BACKUP_SCHEDULE": "daily"})
+ # Het tijdvenster zelf is elders getest; hier gaat het om de vergrendeling.
+ monkeypatch.setattr(app_module.scheduler, "binnen_venster",
+ lambda *a, **k: True)
+ gemaakt = []
+ monkeypatch.setattr(app_module.backups, "create",
+ lambda *a, **k: gemaakt.append(a) or {"file": "x.tar.gz"})
+
+ # Niet twee minuten wachten in een test; het gaat om de keuze die daarna
+ # gemaakt wordt. De originele functie eerst vastleggen, anders roept de
+ # vervanger zichzelf aan.
+ origineel = jobs.stack_slot
+ monkeypatch.setattr(app_module.jobs, "stack_slot",
+ lambda naam, wacht=0.0: origineel(naam))
+
+ slot = jobs._stackslot("web")
+ slot.acquire()
+ try:
+ app_module._geplande_backups()
+ finally:
+ slot.release()
+ assert gemaakt == [], "er werd een backup gemaakt van een bezette app"
+
+ # Zonder slot loopt hij gewoon.
+ app_module._geplande_backups()
+ assert gemaakt, "zonder bezetting hoort de backup gewoon te draaien"