You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

190 lines
8.8 KiB

import copy
import json
from pathlib import Path
import tarfile
import tempfile
import threading
import unittest
from updater import CAPABILITY_LABEL, UpdateError, Updater, validate_image
class FakeDocker:
def __init__(self, data):
self.calls = []
self.fail = None
self.new_health = "healthy"
self.pull_started = threading.Event()
self.release_pull = threading.Event()
self.release_pull.set()
self.current = {
"Id": "container-before", "Image": "sha256:old",
"Config": {"Image": "example/vaultwarden:old", "Env": [], "Labels": {
"com.docker.compose.project": "vault-test", "com.docker.compose.service": "vaultwarden",
"com.docker.compose.config-hash": "test-config-hash",
}},
"Mounts": [{"Destination": "/data", "Source": str(data), "Type": "bind", "RW": True}],
"State": {"Running": True, "Health": {"Status": "healthy"}},
}
self.image = {"Id": "sha256:new", "Config": {
"Labels": {CAPABILITY_LABEL: "1"}, "Healthcheck": {"Test": ["CMD", "/healthcheck"]},
}}
def run(self, *args, timeout=60):
self.calls.append(args)
if args[0] == "pull":
self.pull_started.set()
if not self.release_pull.wait(5):
raise RuntimeError("Test pull timed out")
if self.fail == "pull":
raise UpdateError("Image download failed.")
return ""
if args[:2] == ("image", "inspect"):
return json.dumps([self.image])
if args[0] == "inspect":
return json.dumps([self.current])
if "ps" in args:
return self.current["Id"]
if "--hash" in args:
return "vaultwarden test-config-hash"
if "stop" in args:
self.current["State"]["Running"] = False
return ""
if "up" in args:
if self.fail == "up":
raise UpdateError("Container recreation failed.")
self.current["Id"] = "container-after"
self.current["Image"] = self.image["Id"]
self.current["State"] = {"Running": True, "Health": {"Status": self.new_health}}
return ""
raise AssertionError(args)
class UpdateFlowTests(unittest.TestCase):
def setUp(self):
self.temporary = tempfile.TemporaryDirectory()
self.addCleanup(self.temporary.cleanup)
self.root = Path(self.temporary.name)
self.data = self.root / "data"
self.data.mkdir()
(self.data / "db.sqlite3").write_bytes(b"original database")
(self.data / "attachments").mkdir()
(self.data / "attachments" / "file").write_bytes(b"original attachment")
self.state = self.root / "state"
self.state.mkdir()
self.compose = self.root / "compose.json"
self.compose.write_text("{}")
self.config = {
"state_directory": str(self.state), "data_directory": str(self.data),
"project_directory": str(self.root), "project": "vault-test", "service": "vaultwarden",
"compose_files": [str(self.compose)], "default_image": "example/vaultwarden:latest",
"image_repositories": ["example/vaultwarden"], "health_timeout": 1,
}
self.docker = FakeDocker(self.data)
self.updater = Updater(self.config, self.docker)
def run_update(self):
self.updater.state["busy"] = True
self.updater.work(self.updater.update)
return self.updater.status()
def test_success_backs_up_data_and_deploys_downloaded_id(self):
state = self.run_update()
self.assertEqual(state["result"], "updated")
self.assertFalse(state["recovery_required"])
archive_path, = self.state.glob("backups/*/data.tar")
with tarfile.open(archive_path) as archive:
self.assertEqual(archive.extractfile("data/db.sqlite3").read(), b"original database")
self.assertEqual(archive.extractfile("data/attachments/file").read(), b"original attachment")
override = json.loads(self.updater.override.read_text())
self.assertEqual(override["services"]["vaultwarden"]["image"], "sha256:new")
up, = [call for call in self.docker.calls if "up" in call]
self.assertIn("--no-deps", up)
self.assertIn("never", up)
def test_download_failure_keeps_running_service_and_data(self):
self.docker.fail = "pull"
state = self.run_update()
self.assertEqual(state["result"], "failed")
self.assertFalse(state["recovery_required"])
self.assertTrue(self.docker.current["State"]["Running"])
self.assertFalse(any("stop" in call for call in self.docker.calls))
self.assertFalse(self.updater.override.exists())
def test_same_image_does_not_restart(self):
self.docker.image["Id"] = self.docker.current["Image"]
self.assertEqual(self.run_update()["result"], "unchanged")
self.assertFalse(any("stop" in call for call in self.docker.calls))
def test_image_without_update_feature_is_rejected_before_stop(self):
self.docker.image["Config"]["Labels"] = {}
self.assertEqual(self.run_update()["result"], "failed")
self.assertFalse(any("stop" in call for call in self.docker.calls))
def test_unapplied_compose_changes_are_rejected_before_stop(self):
self.docker.current["Config"]["Labels"]["com.docker.compose.config-hash"] = "different-config"
self.assertEqual(self.run_update()["result"], "failed")
self.assertFalse(any("stop" in call for call in self.docker.calls))
def test_external_database_and_data_mounts_are_rejected(self):
original = copy.deepcopy(self.docker.current)
for environment in (["DATABASE_URL=postgresql://database/vault"], ["ATTACHMENTS_FOLDER=/external"],
["DATABASE_URL_FILE=/run/secrets/database"], ["ENV_FILE=/config/.env"]):
self.docker.current = copy.deepcopy(original)
self.docker.current["Config"]["Env"] = environment
with self.assertRaises(UpdateError):
self.updater.preflight(self.docker.current)
self.docker.current = original
self.docker.current["Mounts"].append({"Destination": "/external", "RW": True})
with self.assertRaises(UpdateError):
self.updater.preflight(self.docker.current)
def test_recreation_and_health_failures_preserve_backup_and_block_retry(self):
for failure in ("up", "health"):
with self.subTest(failure=failure):
self.docker.current["State"] = {"Running": True, "Health": {"Status": "healthy"}}
self.docker.current["Image"] = "sha256:old"
self.docker.fail = failure
self.docker.new_health = "unhealthy"
state = self.run_update()
self.assertTrue(state["recovery_required"])
self.assertEqual(state["result"], "failed")
self.assertTrue(list(self.state.glob("backups/*/data.tar")))
with self.assertRaises(UpdateError):
self.updater.submit()
self.assertEqual((self.data / "db.sqlite3").read_bytes(), b"original database")
def test_duplicate_requests_are_rejected_while_updating(self):
self.docker.release_pull.clear()
self.updater.submit()
self.assertTrue(self.docker.pull_started.wait(2))
try:
with self.assertRaises(UpdateError):
self.updater.submit()
finally:
self.docker.release_pull.set()
# Join this updater's non-daemon worker before temporary data is removed.
for thread in threading.enumerate():
if thread is not threading.current_thread() and not thread.daemon:
thread.join(5)
self.assertEqual(self.updater.status()["result"], "updated")
def test_interrupted_update_stays_blocked_after_restart(self):
self.updater.event("Stopping…", busy=True, recovery_required=True)
restarted = Updater(self.config, self.docker)
self.assertFalse(restarted.status()["busy"])
self.assertTrue(restarted.status()["recovery_required"])
with self.assertRaises(UpdateError):
restarted.submit()
def test_repository_and_tag_validation(self):
allowed = ["registry.example.com/vaultwarden", "localhost:5000/vaultwarden"]
for image in ("registry.example.com/vaultwarden:latest", "localhost:5000/vaultwarden:v1", "registry.example.com/vaultwarden@sha256:" + "a" * 64):
self.assertEqual(validate_image(image, allowed), image)
for image in ("--help", "registry.example.com/vaultwarden", "evil/vaultwarden:latest", "registry.example.com/vaultwarden:latest;id"):
with self.assertRaises(UpdateError):
validate_image(image, allowed)
if __name__ == "__main__":
unittest.main()