"""Tests for amateurfunk_fetch.

Network-bound tests are not included; the real BNetzA fetch lives in
the manual smoke-test invocation. Everything here runs against fixture
ZIPs built in temp directories.
"""

import hashlib
import json
import os
import shutil
import stat
import tempfile
import unittest
import zipfile
from pathlib import Path
from unittest import mock

import amateurfunk_fetch as af


# ---------------------------------------------------------------- helpers


def make_minimal_json(extra_questions=()):
    return {
        "metadata": {
            "edition": "3. Auflage, März 2024",
            "issued_on": "2024-03-20",
            "valid_from": "2024-06-24",
            "license": "DL-DE->BY-2.0",
        },
        "sections": [
            {
                "title": "Technische Kenntnisse",
                "sections": [
                    {
                        "title": "Mathe",
                        "questions": [
                            {
                                "number": "NA101",
                                "class": "1",
                                "question": "Frage?",
                                "answer_a": "A",
                                "answer_b": "B",
                                "answer_c": "C",
                                "answer_d": "D",
                            },
                            *list(extra_questions),
                        ],
                    }
                ],
            }
        ],
    }


def make_zip(
    path,
    *,
    json_payload=None,
    json_name="fragenkatalog3b.json",
    svg_count=150,
    include_readme=True,
    extra_files=(),
    symlink_entry=None,
    abs_path_entry=None,
    dotdot_entry=None,
):
    if json_payload is None:
        json_payload = make_minimal_json()
    with zipfile.ZipFile(path, "w", zipfile.ZIP_DEFLATED) as zf:
        zf.writestr(
            json_name,
            json.dumps(json_payload, ensure_ascii=False).encode("utf-8"),
        )
        if include_readme:
            zf.writestr(
                "README.txt",
                'Some preamble.\n"Attribution string, Bundesnetzagentur"\nMore text.\n',
            )
        for i in range(svg_count):
            zf.writestr(f"svgs/AB{i:03d}_q.svg", b"<svg/>")
        for name, payload in extra_files:
            zf.writestr(name, payload)
        if symlink_entry:
            zi = zipfile.ZipInfo(symlink_entry)
            zi.external_attr = (stat.S_IFLNK | 0o777) << 16
            zf.writestr(zi, b"target")
        if abs_path_entry:
            zf.writestr(abs_path_entry, b"x")
        if dotdot_entry:
            zf.writestr(dotdot_entry, b"x")


# ---------------------------------------------------------------- unit tests


class TestSlug(unittest.TestCase):
    def test_normal(self):
        meta = {"edition": "3. Auflage, März 2024", "issued_on": "2024-03-20"}
        self.assertEqual(af.derive_slug(meta), "2024-03-20-3-auflage")

    def test_missing_ordinal(self):
        meta = {"edition": "Sonderdruck", "issued_on": "2025-01-01"}
        self.assertEqual(af.derive_slug(meta), "2025-01-01-unknown-auflage")

    def test_missing_issued_on(self):
        meta = {"edition": "4. Auflage, Mai 2026", "issued_on": ""}
        self.assertEqual(af.derive_slug(meta), "unknown-4-auflage")

    def test_multi_digit_ordinal(self):
        meta = {"edition": "12. Auflage", "issued_on": "2030-01-01"}
        self.assertEqual(af.derive_slug(meta), "2030-01-01-12-auflage")


class TestValidateZip(unittest.TestCase):
    def _tmp(self):
        d = tempfile.TemporaryDirectory()
        self.addCleanup(d.cleanup)
        return Path(d.name)

    def test_valid_minimal(self):
        d = self._tmp()
        zp = d / "a.zip"
        make_zip(zp)
        arch = af.validate_zip(zp)
        self.assertEqual(arch.json_filename, "fragenkatalog3b.json")
        self.assertEqual(arch.missing_pictures, [])
        self.assertIn("Attribution string", arch.attribution)

    def test_no_json(self):
        d = self._tmp()
        zp = d / "a.zip"
        with zipfile.ZipFile(zp, "w") as zf:
            zf.writestr("README.txt", "x")
            for i in range(120):
                zf.writestr(f"svgs/{i}.svg", b"x")
        with self.assertRaisesRegex(af.ValidationError, "fragenkatalog"):
            af.validate_zip(zp)

    def test_multiple_json(self):
        d = self._tmp()
        zp = d / "a.zip"
        make_zip(zp, extra_files=(("fragenkatalog4a.json", b"{}"),))
        with self.assertRaisesRegex(af.ValidationError, "exactly one"):
            af.validate_zip(zp)

    def test_too_few_svgs(self):
        d = self._tmp()
        zp = d / "a.zip"
        make_zip(zp, svg_count=10)
        with self.assertRaisesRegex(af.ValidationError, "svgs/"):
            af.validate_zip(zp)

    def test_malformed_json(self):
        d = self._tmp()
        zp = d / "a.zip"
        with zipfile.ZipFile(zp, "w") as zf:
            zf.writestr("fragenkatalog3b.json", b"{not json")
            for i in range(150):
                zf.writestr(f"svgs/{i}.svg", b"x")
        with self.assertRaisesRegex(af.ValidationError, "malformed JSON"):
            af.validate_zip(zp)

    def test_missing_top_level_key(self):
        d = self._tmp()
        zp = d / "a.zip"
        bad = make_minimal_json()
        del bad["metadata"]
        make_zip(zp, json_payload=bad)
        with self.assertRaisesRegex(af.ValidationError, "metadata"):
            af.validate_zip(zp)

    def test_missing_metadata_keys(self):
        d = self._tmp()
        zp = d / "a.zip"
        bad = make_minimal_json()
        del bad["metadata"]["edition"]
        make_zip(zp, json_payload=bad)
        with self.assertRaisesRegex(af.ValidationError, "edition"):
            af.validate_zip(zp)

    def test_section_both_sections_and_questions(self):
        d = self._tmp()
        zp = d / "a.zip"
        bad = make_minimal_json()
        bad["sections"][0]["questions"] = []  # Inner node now has both.
        make_zip(zp, json_payload=bad)
        with self.assertRaisesRegex(af.ValidationError, "both"):
            af.validate_zip(zp)

    def test_section_neither(self):
        d = self._tmp()
        zp = d / "a.zip"
        bad = make_minimal_json()
        del bad["sections"][0]["sections"]
        make_zip(zp, json_payload=bad)
        with self.assertRaisesRegex(af.ValidationError, "neither"):
            af.validate_zip(zp)

    def test_question_missing_required_key(self):
        d = self._tmp()
        zp = d / "a.zip"
        bad = make_minimal_json()
        del bad["sections"][0]["sections"][0]["questions"][0]["answer_d"]
        make_zip(zp, json_payload=bad)
        with self.assertRaisesRegex(af.ValidationError, "answer_d"):
            af.validate_zip(zp)

    def test_zipslip_absolute_path(self):
        d = self._tmp()
        zp = d / "a.zip"
        make_zip(zp, abs_path_entry="/etc/passwd")
        with self.assertRaisesRegex(af.ValidationError, "absolute path"):
            af.validate_zip(zp)

    def test_zipslip_dotdot(self):
        d = self._tmp()
        zp = d / "a.zip"
        make_zip(zp, dotdot_entry="../etc/passwd")
        with self.assertRaisesRegex(af.ValidationError, "escape"):
            af.validate_zip(zp)

    def test_zipslip_embedded_dotdot(self):
        """Regression: a `..` segment embedded mid-path must still be
        rejected even though `posixpath.normpath` would collapse it
        into an in-bounds filename. The DESIGN contract is to reject
        any `..` segment in the raw path, regardless of where it sits
        or whether the normalized form happens to escape.
        """
        d = self._tmp()
        zp = d / "a.zip"
        payload = make_minimal_json()
        with zipfile.ZipFile(zp, "w") as zf:
            zf.writestr(
                "fragenkatalog3b.json",
                json.dumps(payload, ensure_ascii=False).encode("utf-8"),
            )
            zf.writestr("README.txt", 'preamble\n"Attribution"\n')
            for i in range(150):
                zf.writestr(f"svgs/AB{i:03d}_q.svg", b"<svg/>")
            # Embedded `..` that normpath simplifies to "svgs/bar.svg":
            zf.writestr("svgs/foo/../bar.svg", b"<svg/>")
        with self.assertRaisesRegex(af.ValidationError, "escape"):
            af.validate_zip(zp)

    def test_zipslip_symlink(self):
        d = self._tmp()
        zp = d / "a.zip"
        make_zip(zp, symlink_entry="link")
        with self.assertRaisesRegex(af.ValidationError, "symlink"):
            af.validate_zip(zp)

    def test_uncompressed_cap(self):
        d = self._tmp()
        zp = d / "a.zip"
        make_zip(zp)
        with self.assertRaisesRegex(af.ValidationError, "uncompressed"):
            af.validate_zip(zp, max_uncompressed=100)

    def test_missing_picture_soft_check(self):
        d = self._tmp()
        zp = d / "a.zip"
        payload = make_minimal_json()
        payload["sections"][0]["sections"][0]["questions"][0]["picture_question"] = "missing.svg"
        payload["sections"][0]["sections"][0]["questions"][0]["picture_a"] = "AB001_q.svg"  # exists
        make_zip(zp, json_payload=payload)
        arch = af.validate_zip(zp)
        self.assertEqual(len(arch.missing_pictures), 1)
        self.assertEqual(arch.missing_pictures[0]["file"], "missing.svg")
        self.assertEqual(arch.missing_pictures[0]["field"], "picture_question")
        self.assertEqual(arch.missing_pictures[0]["question_number"], "NA101")

    def test_picture_reference_as_stem(self):
        """Regression: real BNetzA JSON ships picture refs as stems
        (e.g. "AB109_q"), not full filenames. Verify stems resolve."""
        d = self._tmp()
        zp = d / "a.zip"
        payload = make_minimal_json()
        q = payload["sections"][0]["sections"][0]["questions"][0]
        q["picture_question"] = "AB001_q"  # stem only, matches AB001_q.svg
        q["picture_a"] = "AB002_q"  # stem only
        q["picture_b"] = "NOPE"  # stem only, no matching file
        make_zip(zp, json_payload=payload)
        arch = af.validate_zip(zp)
        missing = {(m["field"], m["file"]) for m in arch.missing_pictures}
        self.assertEqual(missing, {("picture_b", "NOPE")})


# ---------------------------------------------------------------- atomic write


class TestAtomicWrite(unittest.TestCase):
    def test_replaces_existing(self):
        with tempfile.TemporaryDirectory() as d:
            p = Path(d) / "x.json"
            af.atomic_write_json(p, {"a": 1})
            af.atomic_write_json(p, {"a": 2})
            self.assertEqual(json.loads(p.read_text())["a"], 2)
            self.assertEqual(list(Path(d).glob("*.tmp")), [])

    def test_no_tmp_left_on_failure(self):
        with tempfile.TemporaryDirectory() as d:
            p = Path(d) / "x.json"
            with mock.patch("os.replace", side_effect=OSError("boom")):
                with self.assertRaises(OSError):
                    af.atomic_write_json(p, {"a": 1})
            # os.replace failed, but os.fsync etc. succeeded; .tmp may or may
            # not exist depending on platform. We only assert the final file
            # is not present.
            self.assertFalse(p.exists())


# ---------------------------------------------------------------- end-to-end


def _patch_http(zip_path: Path, *, last_modified: str):
    """Returns a pair of context managers patching HEAD and GET."""

    def fake_head(url, *, timeout=60):
        return last_modified

    def fake_get(url, dest, *, max_bytes, timeout=60):
        shutil.copyfile(zip_path, dest)
        return (
            hashlib.sha256(zip_path.read_bytes()).hexdigest(),
            last_modified,
            zip_path.stat().st_size,
        )

    return (
        mock.patch.object(af, "http_head_last_modified", fake_head),
        mock.patch.object(af, "http_get_to_file", fake_get),
    )


class TestEndToEnd(unittest.TestCase):
    def setUp(self):
        self.tmp = tempfile.TemporaryDirectory()
        self.addCleanup(self.tmp.cleanup)
        self.out = Path(self.tmp.name) / "out"
        self.url = "https://example.invalid/test.zip"

    def _make_default_zip(self, name="a.zip", **kwargs):
        zp = Path(self.tmp.name) / name
        make_zip(zp, **kwargs)
        return zp

    def test_first_run_extracts_everything(self):
        zp = self._make_default_zip()
        ph, pg = _patch_http(zp, last_modified="Wed, 01 Jan 2025 00:00:00 GMT")
        with ph, pg:
            rc = af.main(["--out", str(self.out)])
        self.assertEqual(rc, af.EXIT_OK)

        slug_dir = self.out / "2024-03-20-3-auflage"
        self.assertTrue((slug_dir / "fragenkatalog3b.json").exists())
        self.assertTrue((slug_dir / "README.txt").exists())
        self.assertTrue((slug_dir / "manifest.json").exists())
        self.assertGreater(len(list((slug_dir / "svgs").iterdir())), 100)

        manifest = json.loads((slug_dir / "manifest.json").read_text())
        self.assertEqual(manifest["slug"], "2024-03-20-3-auflage")
        self.assertEqual(manifest["json_filename"], "fragenkatalog3b.json")
        self.assertEqual(manifest["metadata"]["edition"], "3. Auflage, März 2024")
        self.assertEqual(manifest["missing_pictures"], [])
        self.assertIn("Attribution string", manifest["attribution"])
        self.assertEqual(manifest["http_last_modified"], "Wed, 01 Jan 2025 00:00:00 GMT")

        latest = json.loads((self.out / "manifest-latest.json").read_text())
        self.assertEqual(latest["slug"], "2024-03-20-3-auflage")
        self.assertEqual(latest["http_last_modified"], "Wed, 01 Jan 2025 00:00:00 GMT")

        # No raw ZIP left in default mode.
        self.assertFalse((slug_dir / "source.zip").exists())

    def test_keep_zip(self):
        zp = self._make_default_zip()
        ph, pg = _patch_http(zp, last_modified="Wed, 01 Jan 2025 00:00:00 GMT")
        with ph, pg:
            af.main(["--out", str(self.out), "--keep-zip"])
        slug_dir = self.out / "2024-03-20-3-auflage"
        self.assertTrue((slug_dir / "source.zip").exists())

    def test_rerun_skips_via_last_modified(self):
        zp = self._make_default_zip()
        get_calls = {"n": 0}

        def fake_head(url, *, timeout=60):
            return "Wed, 01 Jan 2025 00:00:00 GMT"

        def fake_get(url, dest, *, max_bytes, timeout=60):
            get_calls["n"] += 1
            shutil.copyfile(zp, dest)
            return (
                hashlib.sha256(zp.read_bytes()).hexdigest(),
                "Wed, 01 Jan 2025 00:00:00 GMT",
                zp.stat().st_size,
            )

        with mock.patch.object(af, "http_head_last_modified", fake_head), mock.patch.object(
            af, "http_get_to_file", fake_get
        ):
            self.assertEqual(af.main(["--out", str(self.out)]), af.EXIT_OK)
            self.assertEqual(get_calls["n"], 1)
            self.assertEqual(af.main(["--out", str(self.out)]), af.EXIT_OK)
            self.assertEqual(get_calls["n"], 1)  # GET not re-issued.

    def test_rerun_with_same_content_but_new_last_modified(self):
        """Server bumped Last-Modified but the ZIP bytes are identical."""
        zp = self._make_default_zip()
        ph1, pg1 = _patch_http(zp, last_modified="Wed, 01 Jan 2025 00:00:00 GMT")
        with ph1, pg1:
            af.main(["--out", str(self.out)])
        ph2, pg2 = _patch_http(zp, last_modified="Fri, 03 Jan 2025 00:00:00 GMT")
        with ph2, pg2:
            rc = af.main(["--out", str(self.out)])
        self.assertEqual(rc, af.EXIT_OK)
        # sha256 matched, so manifest-latest should now show the newer Last-Modified.
        latest = json.loads((self.out / "manifest-latest.json").read_text())
        self.assertEqual(latest["http_last_modified"], "Fri, 03 Jan 2025 00:00:00 GMT")

    def test_force_replaces_changed_content(self):
        zp1 = self._make_default_zip("a.zip")
        ph, pg = _patch_http(zp1, last_modified="Wed, 01 Jan 2025 00:00:00 GMT")
        with ph, pg:
            af.main(["--out", str(self.out)])

        # New ZIP, same slug (same metadata) but different bytes.
        payload = make_minimal_json()
        payload["sections"][0]["sections"][0]["questions"][0]["answer_a"] = "modified"
        zp2 = self._make_default_zip("b.zip", json_payload=payload)
        ph2, pg2 = _patch_http(zp2, last_modified="Thu, 02 Jan 2025 00:00:00 GMT")
        with ph2, pg2:
            # Without --force the existing non-matching dir should fail BAD_STATE.
            rc = af.main(["--out", str(self.out)])
            self.assertEqual(rc, af.EXIT_BAD_STATE)
            # With --force it should replace.
            rc = af.main(["--out", str(self.out), "--force"])
            self.assertEqual(rc, af.EXIT_OK)

        slug_dir = self.out / "2024-03-20-3-auflage"
        manifest = json.loads((slug_dir / "manifest.json").read_text())
        self.assertEqual(
            hashlib.sha256(zp2.read_bytes()).hexdigest(), manifest["zip_sha256"]
        )
        # No leftover .bak/.tmp directories.
        self.assertFalse((self.out / "2024-03-20-3-auflage.bak").exists())
        self.assertFalse((self.out / "2024-03-20-3-auflage.tmp").exists())

    def test_bak_collision_blocks_force(self):
        zp = self._make_default_zip("a.zip")
        ph, pg = _patch_http(zp, last_modified="Wed, 01 Jan 2025 00:00:00 GMT")
        with ph, pg:
            af.main(["--out", str(self.out)])

        # Plant a stale .bak directory.
        bak = self.out / "2024-03-20-3-auflage.bak"
        bak.mkdir()
        (bak / "stale-file").write_text("leftover")

        # Different content so we don't short-circuit on sha256 match.
        payload = make_minimal_json()
        payload["sections"][0]["sections"][0]["questions"][0]["answer_a"] = "modified"
        zp2 = self._make_default_zip("b.zip", json_payload=payload)
        ph2, pg2 = _patch_http(zp2, last_modified="Thu, 02 Jan 2025 00:00:00 GMT")
        with ph2, pg2:
            rc = af.main(["--out", str(self.out), "--force"])
        self.assertEqual(rc, af.EXIT_BAD_STATE)
        # Stale .bak left untouched (operator's call to inspect).
        self.assertTrue((bak / "stale-file").exists())

    def test_missing_picture_recorded_does_not_block(self):
        payload = make_minimal_json()
        payload["sections"][0]["sections"][0]["questions"][0][
            "picture_question"
        ] = "missing.svg"
        zp = self._make_default_zip(json_payload=payload)
        ph, pg = _patch_http(zp, last_modified="Wed, 01 Jan 2025 00:00:00 GMT")
        with ph, pg:
            rc = af.main(["--out", str(self.out)])
        self.assertEqual(rc, af.EXIT_OK)
        slug_dir = self.out / "2024-03-20-3-auflage"
        manifest = json.loads((slug_dir / "manifest.json").read_text())
        self.assertEqual(len(manifest["missing_pictures"]), 1)

    def test_validation_failure_returns_error(self):
        # ZIP with a symlink should fail validation and return EXIT_ERROR.
        zp = self._make_default_zip(symlink_entry="link-name")
        ph, pg = _patch_http(zp, last_modified="Wed, 01 Jan 2025 00:00:00 GMT")
        with ph, pg:
            rc = af.main(["--out", str(self.out)])
        self.assertEqual(rc, af.EXIT_ERROR)
        # Nothing extracted.
        self.assertFalse((self.out / "2024-03-20-3-auflage").exists())

    def test_force_reextracts_when_sha_matches(self):
        """--force must repair a corrupted tree even when the manifest's
        recorded sha256 matches the freshly downloaded ZIP."""
        zp = self._make_default_zip()
        ph, pg = _patch_http(zp, last_modified="Wed, 01 Jan 2025 00:00:00 GMT")
        with ph, pg:
            af.main(["--out", str(self.out)])
        slug_dir = self.out / "2024-03-20-3-auflage"
        json_file = slug_dir / "fragenkatalog3b.json"

        # Simulate a corrupted on-disk tree: the manifest still claims
        # the right sha, but a critical file is missing.
        json_file.unlink()
        self.assertFalse(json_file.exists())

        # Without --force the sha-match shortcut would skip; with
        # --force we expect re-extraction to restore the missing file.
        ph2, pg2 = _patch_http(zp, last_modified="Wed, 01 Jan 2025 00:00:00 GMT")
        with ph2, pg2:
            rc = af.main(["--out", str(self.out), "--force"])
        self.assertEqual(rc, af.EXIT_OK)
        self.assertTrue(json_file.exists())


class TestAttribution(unittest.TestCase):
    """Attribution is stored verbatim in the manifest so that consumers
    can reproduce the Quellenvermerk byte-for-byte under the DL-DE
    license."""

    def test_attribution_preserves_internal_whitespace(self):
        # Multi-line quoted block with deliberate spacing the verbatim
        # contract has to preserve.
        readme = (
            "Preamble.\n"
            '"Prüfungsfragen, Bundesnetzagentur,\n'
            "3. Auflage,\n"
            '(www.bundesnetzagentur.de/amateurfunk)"\n'
            "Trailing text.\n"
        )
        result = af._extract_attribution_from_readme(readme)
        self.assertIn("\n", result)
        self.assertIn("3. Auflage,", result)
        self.assertIn("(www.bundesnetzagentur.de/amateurfunk)", result)
        # No collapsing: the original line breaks are still there.
        self.assertEqual(result.count("\n"), 2)

    def test_attribution_missing_quotes(self):
        self.assertEqual(af._extract_attribution_from_readme("no quotes here"), "")
        self.assertEqual(af._extract_attribution_from_readme(""), "")


class TestPostExtractionFailures(unittest.TestCase):
    """`main()` documents that it returns an exit code and never
    raises. These tests force failures in the manifest-write and
    directory-swap phases and verify that contract holds."""

    def setUp(self):
        self.tmp = tempfile.TemporaryDirectory()
        self.addCleanup(self.tmp.cleanup)
        self.out = Path(self.tmp.name) / "out"

    def test_manifest_write_failure_returns_error_and_cleans_tmp(self):
        zp = Path(self.tmp.name) / "a.zip"
        make_zip(zp)
        ph, pg = _patch_http(zp, last_modified="Wed, 01 Jan 2025 00:00:00 GMT")

        # Fail the very first atomic_write_json call (which is the
        # per-edition manifest in edition_tmp_dir).
        def faulty_write(path, payload):
            raise OSError("simulated manifest write failure")

        with ph, pg, mock.patch.object(af, "atomic_write_json", faulty_write):
            rc = af.main(["--out", str(self.out)])

        self.assertEqual(rc, af.EXIT_ERROR)
        # main() promises not to raise — already satisfied above by
        # the fact that we got back an int. The cleanup contract:
        # neither the new edition dir nor the abandoned tmp dir
        # should be left behind.
        self.assertFalse((self.out / "2024-03-20-3-auflage").exists())
        self.assertFalse((self.out / "2024-03-20-3-auflage.tmp").exists())

    def test_swap_failure_returns_error_and_restores_previous(self):
        # First run: extract a baseline edition.
        zp1 = Path(self.tmp.name) / "a.zip"
        make_zip(zp1)
        baseline_sha = hashlib.sha256(zp1.read_bytes()).hexdigest()
        ph1, pg1 = _patch_http(zp1, last_modified="Wed, 01 Jan 2025 00:00:00 GMT")
        with ph1, pg1:
            af.main(["--out", str(self.out)])

        slug_dir = self.out / "2024-03-20-3-auflage"
        tmp_dir = self.out / "2024-03-20-3-auflage.tmp"

        # Second run with --force using a ZIP that has the same slug
        # but different content. We mock os.replace to fail
        # specifically on the tmp->slug rename, which exercises the
        # rollback path.
        payload = make_minimal_json()
        payload["sections"][0]["sections"][0]["questions"][0]["answer_a"] = "DIFFERENT"
        zp2 = Path(self.tmp.name) / "b.zip"
        make_zip(zp2, json_payload=payload)

        real_replace = os.replace

        def selective_replace(src, dst):
            # Only the tmp->slug swap fails; all other renames
            # (manifest tmp writes, the rollback, etc.) pass through.
            if str(src) == str(tmp_dir) and str(dst) == str(slug_dir):
                raise OSError("simulated swap failure")
            return real_replace(src, dst)

        ph2, pg2 = _patch_http(zp2, last_modified="Thu, 02 Jan 2025 00:00:00 GMT")
        with ph2, pg2, mock.patch("os.replace", side_effect=selective_replace):
            rc = af.main(["--out", str(self.out), "--force"])

        # Contract: EXIT_ERROR, no raise, previous edition restored.
        self.assertEqual(rc, af.EXIT_ERROR)
        self.assertTrue(slug_dir.exists())
        self.assertFalse(tmp_dir.exists())
        self.assertFalse((self.out / "2024-03-20-3-auflage.bak").exists())

        # The restored manifest still describes the baseline content.
        restored_manifest = json.loads((slug_dir / "manifest.json").read_text())
        self.assertEqual(restored_manifest["zip_sha256"], baseline_sha)


if __name__ == "__main__":
    unittest.main()