Skip to content

An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作

7.5 KB
Raw Blame
import contextlib
import argparse
import importlib.util
import io
import os
from pathlib import Path
import subprocess
import tempfile
import unittest
from unittest.mock import patch


SPEC = importlib.util.spec_from_file_location("clean_release", Path(__file__).with_name("clean-release.py"))
CLEAN = importlib.util.module_from_spec(SPEC)
SPEC.loader.exec_module(CLEAN)


class CleanupTests(unittest.TestCase):
    def setUp(self):
        self.temporary = tempfile.TemporaryDirectory()
        self.addCleanup(self.temporary.cleanup)
        self.root = Path(self.temporary.name).resolve()
        self.output = self.root / "Desktop/siyuan"
        self.output.mkdir(parents=True)
        (self.output / "release.app").write_bytes(b"signed package")
        self.build = self.root / "repo/app/build"
        self.build.mkdir(parents=True)
        (self.build / "release.app").write_bytes(b"signed package")

    def test_preview_preserves_artifacts(self):
        CLEAN.clean([(self.root, self.build)], [self.output])
        self.assertTrue((self.build / "release.app").exists())

    def test_execute_preserves_desktop(self):
        CLEAN.clean([(self.root, self.build)], [self.output], execute=True)
        self.assertFalse(self.build.exists())
        self.assertEqual((self.output / "release.app").read_bytes(), b"signed package")

    def test_main_preserves_default_release_records(self):
        records = self.root / "release-records/3.8.4/run"
        records.mkdir(parents=True)
        (records / "build.log").write_text("build output", encoding="utf-8")
        with patch.object(CLEAN, "ROOT", self.root / "repo"), \
                patch.object(CLEAN.sys, "argv", ["clean-release.py", "--execute"]), \
                patch.object(CLEAN.BUILD.VERIFY, "desktop_folder", return_value=self.output), \
                patch.object(CLEAN, "collect_targets", return_value=[(self.root, self.build)]), \
                contextlib.redirect_stdout(io.StringIO()):
            self.assertEqual(CLEAN.main(), 0)
        self.assertEqual((records / "build.log").read_text(), "build output")
        self.assertFalse(self.build.exists())

    def test_custom_release_records_prevent_overlapping_cleanup(self):
        records = self.build / "records"
        records.mkdir()
        (records / "progress.json").write_text("{}", encoding="utf-8")
        with patch.object(CLEAN.sys, "argv", ["clean-release.py", "--execute", "--records-dir", str(records)]), \
                patch.object(CLEAN.BUILD.VERIFY, "desktop_folder", return_value=self.output), \
                patch.object(CLEAN, "collect_targets", return_value=[(self.root, self.build)]), \
                contextlib.redirect_stdout(io.StringIO()), self.assertRaises(CLEAN.CleanupError):
            CLEAN.main()
        self.assertTrue((records / "progress.json").exists())
        self.assertTrue((self.build / "release.app").exists())

    def test_protected_directory_and_ancestors_rejected_before_any_deletion(self):
        for path in (self.output, self.output.parent, self.output / "release.app"):
            with self.subTest(path=path), self.assertRaises(CLEAN.CleanupError):
                CLEAN.clean([(self.root, self.build), (self.root, path)], [self.output], execute=True)
            self.assertTrue(self.build.exists())

    def test_root_and_outside_rejected(self):
        for path in (self.root, self.root.parent):
            with self.subTest(path=path), self.assertRaises(CLEAN.CleanupError):
                CLEAN.clean([(self.root, path)], [], execute=True)

    def test_nested_link_only_removes_link(self):
        link = self.build / "external"
        try:
            link.symlink_to(self.output, target_is_directory=True)
        except OSError:
            if os.name != "nt":
                raise
            import _winapi
            _winapi.CreateJunction(str(self.output), str(link))
        CLEAN.clean([(self.root, self.build)], [self.output], execute=True)
        self.assertFalse(self.build.exists())
        self.assertTrue((self.output / "release.app").exists())

    def test_link_as_cleanup_root_rejected(self):
        link = self.root / "link"
        try:
            link.symlink_to(self.build, target_is_directory=True)
        except OSError:
            if os.name != "nt":
                raise
            import _winapi
            _winapi.CreateJunction(str(self.build), str(link))
        with self.assertRaises(CLEAN.CleanupError):
            CLEAN.clean([(self.root, link)], [self.output], execute=True)
        self.assertTrue(self.build.exists())

    def test_tracked_files_preserved(self):
        repo = self.root / "repo"
        subprocess.run(["git", "init", str(repo)], check=True, capture_output=True)
        marker = repo / "build.gradle"
        marker.touch()
        subprocess.run(["git", "-C", str(repo), "add", "app/build/release.app"], check=True)
        self.assertEqual(CLEAN.repository_targets(repo, "build.gradle", ["app/build"]), [])
        untracked = repo / "app/kernel.aar"
        untracked.write_bytes(b"kernel")
        targets = CLEAN.repository_targets(repo, "build.gradle", ["app/build", "app/kernel.aar"])
        CLEAN.clean(targets, [self.output], execute=True)
        self.assertTrue((self.build / "release.app").exists())
        self.assertFalse(untracked.exists())

    def test_mobile_inputs_survive_cleanup_while_build_outputs_are_removed(self):
        main = self.root / "main"
        android = self.root / "android"
        harmony = self.root / "harmony"
        temporary = self.root / "temporary"
        temporary.mkdir()
        preserved = {
            main: ["kernel/kernel.aar", "kernel/harmony/libkernel.so", "kernel/harmony/libkernel.h"],
            android: ["app/libs/kernel.aar", "app/src/main/assets/app.zip"],
            harmony: ["entry/src/main/resources/rawfile/app.zip", "entry/src/main/cpp/include/libkernel.h",
                      "entry/src/main/cpp/include/lan_sync_bridge.h"] +
                     [f"entry/libs/{abi}/{name}" for abi in ("arm64-v8a", "x86_64")
                      for name in ("libkernel.so", "libkernel.h", "lan_sync_bridge.h")],
        }
        outputs = {main: ["app/build", "app/kernel-linux", "app/kernel-linux-arm64"],
                   android: ["build", "app/build", "app/build-release", "app/.cxx"],
                   harmony: ["build", "entry/build", "entry/.cxx"]}
        for repo, marker in ((main, "kernel/go.mod"), (android, "build.gradle"), (harmony, "AppScope/app.json5")):
            for relative in [marker] + preserved[repo] + [path + "/output.bin" for path in outputs[repo]]:
                path = repo / relative
                path.parent.mkdir(parents=True, exist_ok=True)
                path.write_bytes(b"preserved content")
        args = argparse.Namespace(android_dir=android, harmony_dir=harmony, skip_wsl=True)
        with patch.object(CLEAN, "ROOT", main), patch.object(CLEAN.tempfile, "gettempdir", return_value=str(temporary)), \
                patch.object(CLEAN.subprocess, "run", return_value=subprocess.CompletedProcess([], 0, stdout=b"")), \
                contextlib.redirect_stdout(io.StringIO()):
            targets = CLEAN.collect_targets(args)
            CLEAN.clean(targets, [self.output], execute=True)
        for repo, relatives in preserved.items():
            for relative in relatives:
                self.assertEqual((repo / relative).read_bytes(), b"preserved content")
        for repo, relatives in outputs.items():
            for relative in relatives:
                self.assertFalse((repo / relative).exists())


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