code-server-sync 0.0.0-stage → 0.1.0

package/cs_sync/self_test.py

@@ -0,0 +1,730 @@
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+import sys
+import tempfile
+import threading
+import urllib.parse
+from http.server import ThreadingHTTPServer
+
+from cs_sync.client import Client
+from cs_sync.config import compose, load_host, load_json, project_files, resolve_project
+from cs_sync.files import FileIndex, scan, sha256_bytes, sha256_file, write_file
+from cs_sync.git import (
+    apply_saved_patch,
+    build_watch_change,
+    change_from_contents,
+    collect_changes,
+    decode_bytes,
+    encode_bytes,
+    stage_changes,
+    transfer_line_changes,
+)
+from cs_sync.ignore import DEFAULT_IGNORE_DIRS, ignore_dirs
+from cs_sync.merge import apply_line_delta_onto, try_merge_cloud_onto_local
+from cs_sync.protocol import MAX_BYTES, ROUTE_PULL
+from cs_sync.server import listening_pids, make_handler, process_command_line
+from cs_sync.sync import (
+    copy_cloud_to_local,
+    copy_local_to_cloud,
+    preview_copy_cloud_to_local,
+    preview_copy_local_to_cloud,
+    preview_line_changes,
+    preview_sync_divergence,
+    push_watch_edit_to_cloud,
+)
+
+def cmd_self_test(_args: argparse.Namespace) -> None:
+    import secrets
+    import shutil
+
+    from cs_sync.cli import (
+        build_parser,
+        cmd_init,
+        cmd_remove,
+        normalize_remote_path,
+        package_version,
+        recv_command,
+    )
+
+    token = secrets.token_urlsafe(32)
+    local = tempfile.mkdtemp(prefix="cs-sync-local-")
+    remote = tempfile.mkdtemp(prefix="cs-sync-remote-")
+    port = 0
+    try:
+        index = FileIndex(remote)
+        server = ThreadingHTTPServer(("127.0.0.1", 0), make_handler(remote, token, index))
+        port = server.server_address[1]
+        thread = threading.Thread(target=server.serve_forever, daemon=True)
+        thread.start()
+        config = {
+            "localRoot": local,
+            "endpoint": "http://127.0.0.1:%d" % port,
+            "token": token,
+            "cookie": "",
+            "insecure": False,
+            "ignoreDirs": sorted(DEFAULT_IGNORE_DIRS),
+        }
+        client = Client(config)
+        status, body = client.health()
+        assert status == 200 and body.strip() == b"ok", body
+        if sys.platform.startswith("linux"):
+            seen = listening_pids(port)
+            assert os.getpid() in seen, "listening_pids 应能看到本机临时 recv：%s" % seen
+            assert process_command_line(os.getpid())
+        status, _ = client.put_file("../outside.txt", b"nope", "644")
+        assert status == 400
+        status, body = client.put_file("ok.txt", b"hello", "644")
+        assert status == 200 and body.strip() == b"ok", (status, body)
+        with open(os.path.join(remote, "ok.txt"), "rb") as handle:
+            assert handle.read() == b"hello"
+        bad = Client(dict(config, token="wrong-token-value-xxxx"))
+        status, _ = bad.put_file("ok.txt", b"hello", "644")
+        assert status == 403
+        status, body = client.put_file("sub/目录.txt", "内容".encode("utf-8"), "644")
+        assert status == 200 and body.strip() == b"ok", body
+        with open(os.path.join(remote, "sub", "目录.txt"), "rb") as handle:
+            assert handle.read() == "内容".encode("utf-8")
+        try:
+            os.symlink("/tmp", os.path.join(remote, "escape"))
+        except OSError:
+            pass
+        else:
+            status, _ = client.put_file("escape/pwned.txt", b"nope", "644")
+            assert status == 400
+            assert not os.path.exists("/tmp/pwned.txt")
+        nested = os.path.join(local, "node_modules")
+        os.makedirs(nested)
+        with open(os.path.join(nested, "skip.js"), "w", encoding="utf-8") as handle:
+            handle.write("nope")
+        with open(os.path.join(local, "keep.txt"), "w", encoding="utf-8") as handle:
+            handle.write("v1")
+        ignored = ignore_dirs(config)
+        found = scan(local, ignored)
+        assert "keep.txt" in found
+        assert "node_modules/skip.js" not in found
+        with open(os.path.join(local, ".cs-syncignore"), "w", encoding="utf-8") as handle:
+            handle.write("*.skip\nsecret/\n!keep.skip\n!node_modules\n!node_modules/\n")
+        os.makedirs(os.path.join(local, "secret"), exist_ok=True)
+        with open(os.path.join(local, "secret", "hidden.txt"), "w", encoding="utf-8") as handle:
+            handle.write("nope")
+        with open(os.path.join(local, "x.skip"), "w", encoding="utf-8") as handle:
+            handle.write("skip-me")
+        with open(os.path.join(local, "keep.skip"), "w", encoding="utf-8") as handle:
+            handle.write("keep-me")
+        found2 = scan(local, ignored)
+        assert "keep.txt" in found2 and "keep.skip" in found2
+        assert "x.skip" not in found2 and "secret/hidden.txt" not in found2
+        assert "node_modules/skip.js" not in found2  # 内置忽略不可被 ! 否定
+        with open(os.path.join(local, ".cs-syncignore"), "w", encoding="utf-8") as handle:
+            handle.write("/root-only.dat\n/rooted.skip\n")
+        os.makedirs(os.path.join(local, "nested"), exist_ok=True)
+        with open(os.path.join(local, "root-only.dat"), "w", encoding="utf-8") as handle:
+            handle.write("root-file")
+        with open(os.path.join(local, "nested", "root-only.dat"), "w", encoding="utf-8") as handle:
+            handle.write("nested-file")
+        with open(os.path.join(local, "rooted.skip"), "w", encoding="utf-8") as handle:
+            handle.write("root-skip")
+        with open(os.path.join(local, "nested", "rooted.skip"), "w", encoding="utf-8") as handle:
+            handle.write("nested-skip")
+        found3 = scan(local, ignored)
+        assert "root-only.dat" not in found3 and "rooted.skip" not in found3
+        assert "nested/root-only.dat" in found3  # /root-only.dat 不匹配嵌套路径
+        assert "nested/rooted.skip" in found3  # /rooted.skip 只忽略根下
+        with open(os.path.join(remote, ".cs-syncignore"), "w", encoding="utf-8") as handle:
+            handle.write("cloud-only.skip\n")
+        with open(os.path.join(remote, "cloud-only.skip"), "w", encoding="utf-8") as handle:
+            handle.write("x")
+        with open(os.path.join(remote, "cloud-ok.txt"), "w", encoding="utf-8") as handle:
+            handle.write("y")
+        index.scan()
+        status, files = client.manifest()
+        assert status == 200
+        assert "cloud-ok.txt" in files and "cloud-only.skip" not in files
+        status, _ = client.delete_file("sub/目录.txt")
+        assert status == 200
+        assert not os.path.exists(os.path.join(remote, "sub", "目录.txt"))
+        status, body = client.push_ignore(DEFAULT_IGNORE_DIRS)
+        assert status == 200 and body.strip() == b"ok"
+        with open(os.path.join(remote, "from-cloud.txt"), "wb") as handle:
+            handle.write(b"from-cloud")
+        index.scan()
+        status, files = client.manifest()
+        assert status == 200 and files.get("from-cloud.txt") == sha256_bytes(b"from-cloud")
+        status, payload, mode = client.pull_file("from-cloud.txt")
+        assert status == 200 and payload == b"from-cloud" and mode == 0o644
+        write_file(local, "from-cloud.txt", payload, mode)
+        global MAX_BYTES
+        import cs_sync.client as client_module
+        import cs_sync.files as files_module
+        import cs_sync.git as git_module
+        import cs_sync.protocol as protocol_module
+        import cs_sync.server as server_module
+        import cs_sync.sync as sync_module
+
+        max_bound = (
+            protocol_module,
+            server_module,
+            client_module,
+            files_module,
+            git_module,
+            sync_module,
+        )
+        saved_max = MAX_BYTES
+        saved_module_max = [module.MAX_BYTES for module in max_bound]
+        real_request = client.request
+        MAX_BYTES = 32
+        for module in max_bound:
+            module.MAX_BYTES = 32
+        try:
+            with open(os.path.join(remote, "too-big.bin"), "wb") as handle:
+                handle.write(b"x" * 64)
+            # 服务端拒绝：用 raw request，避免 pull_file 客户端夹断冒充 400
+            status, _headers, payload = client.request(
+                ROUTE_PULL,
+                headers={"X-Sync-Token": token, "X-Rel-Path": urllib.parse.quote("too-big.bin", safe="/")},
+                method="GET",
+            )
+            assert status == 400 and "文件过大" in payload.decode("utf-8", errors="replace"), (status, payload)
+
+            def fat_request(*_args, **_kwargs):
+                return 200, {"X-File-Mode": "644"}, b"z" * 64
+
+            client.request = fat_request
+            status, payload, _mode = client.pull_file("ignored-name.bin")
+            assert status == 400 and "文件过大" in payload.decode("utf-8", errors="replace"), (status, payload)
+        finally:
+            client.request = real_request
+            MAX_BYTES = saved_max
+            for module, previous in zip(max_bound, saved_module_max):
+                module.MAX_BYTES = previous
+        assert open(os.path.join(local, "from-cloud.txt"), "rb").read() == b"from-cloud"
+        with open(os.path.join(local, "only-local.txt"), "w", encoding="utf-8") as handle:
+            handle.write("local-only")
+        downloaded, skipped, failed = copy_cloud_to_local(client, local, files)
+        assert failed == 0 and downloaded >= 1 and skipped >= 1, (downloaded, skipped, failed)
+        assert open(os.path.join(local, "ok.txt"), "rb").read() == b"hello"
+        assert open(os.path.join(local, "only-local.txt"), encoding="utf-8").read() == "local-only"
+        with open(os.path.join(local, "keep.txt"), "w", encoding="utf-8") as handle:
+            handle.write("from-local")
+        uploaded, skipped, failed = copy_local_to_cloud(client, local, ignored, files)
+        assert failed == 0 and uploaded >= 1, (uploaded, skipped, failed)
+        with open(os.path.join(remote, "keep.txt"), "rb") as handle:
+            assert handle.read() == b"from-local"
+        assert open(os.path.join(remote, "from-cloud.txt"), "rb").read() == b"from-cloud"
+        assert not os.path.exists(os.path.join(remote, "node_modules", "skip.js"))
+
+        def make_repo(path: str, filename: str, content: str) -> None:
+            os.makedirs(path, exist_ok=True)
+            subprocess.check_call(["git", "init", "-q", path])
+            subprocess.check_call(["git", "-C", path, "config", "user.email", "cs-sync@example.com"])
+            subprocess.check_call(["git", "-C", path, "config", "user.name", "cs-sync"])
+            with open(os.path.join(path, filename), "w", encoding="utf-8") as handle:
+                handle.write(content)
+            subprocess.check_call(["git", "-C", path, "add", filename])
+            subprocess.check_call(["git", "-C", path, "-c", "commit.gpgsign=false", "commit", "-q", "-m", "init"])
+
+        mono = os.path.join(local, "mono")
+        os.makedirs(mono)
+        make_repo(os.path.join(mono, "one"), "a.txt", "v1\n")
+        make_repo(os.path.join(mono, "two"), "b.txt", "v1\n")
+        with open(os.path.join(mono, "one", "a.txt"), "w", encoding="utf-8") as handle:
+            handle.write("v2\n")
+        with open(os.path.join(mono, "one", "fresh.txt"), "w", encoding="utf-8") as handle:
+            handle.write("new\n")
+        staged, count = stage_changes(mono, set(DEFAULT_IGNORE_DIRS))
+        assert staged == ["one"] and count == 2, (staged, count)
+        cached = subprocess.check_output(["git", "-C", os.path.join(mono, "one"), "diff", "--cached", "--name-only"], text=True)
+        assert "a.txt" in cached and "fresh.txt" in cached, cached
+        assert subprocess.check_output(["git", "-C", os.path.join(mono, "two"), "diff", "--cached"], text=True) == ""
+        single = os.path.join(local, "single")
+        make_repo(single, "root.txt", "root\n")
+        make_repo(os.path.join(single, "nested"), "n.txt", "n\n")
+        with open(os.path.join(single, "nested", "n.txt"), "w", encoding="utf-8") as handle:
+            handle.write("n2\n")
+        with open(os.path.join(single, "root.txt"), "w", encoding="utf-8") as handle:
+            handle.write("root2\n")
+        staged, count = stage_changes(single, set(DEFAULT_IGNORE_DIRS))
+        assert staged == ["."] and count == 1, (staged, count)
+        assert subprocess.check_output(["git", "-C", os.path.join(single, "nested"), "diff", "--cached"], text=True) == ""
+        pkg = os.path.join(remote, "pkg")
+        make_repo(pkg, "c.txt", "c1\n")
+        with open(os.path.join(pkg, "c.txt"), "w", encoding="utf-8") as handle:
+            handle.write("c2\n")
+        stage_status, stage_info = client.stage()
+        assert stage_status == 200 and stage_info.get("staged") == ["pkg"], stage_info
+        assert "c2" in subprocess.check_output(["git", "-C", pkg, "diff", "--cached"], text=True)
+        line_repo = os.path.join(local, "lines")
+        make_repo(line_repo, "a.txt", "line1\nline2\nline3\n")
+        with open(os.path.join(line_repo, "a.txt"), "w", encoding="utf-8") as handle:
+            handle.write("line1\nchanged\nline3\n")
+        with open(os.path.join(line_repo, "new.txt"), "w", encoding="utf-8") as handle:
+            handle.write("brand-new\n")
+        found, repo_count = collect_changes(line_repo, set(DEFAULT_IGNORE_DIRS))
+        kinds = {item["path"]: item["kind"] for item in found}
+        assert repo_count == 1 and kinds.get("a.txt") == "modify" and kinds.get("new.txt") == "add", kinds
+        saved = {}
+
+        def read_dest(rel):
+            if rel == "a.txt":
+                return True, b"line1\nline2\nline3\nextra\n", "644"
+            return False, None, "644"
+
+        def write_dest(rel, payload, _mode):
+            saved[rel] = payload
+            return True
+
+        def delete_dest(_rel):
+            return True
+
+        applied, failed = transfer_line_changes(found, read_dest, write_dest, delete_dest)
+        assert failed == 0 and applied == 2, (applied, failed, saved)
+        assert saved["a.txt"] == b"line1\nchanged\nline3\nextra\n"
+        assert saved["new.txt"] == b"brand-new\n"
+        blocked = {}
+
+        def read_conflict(rel):
+            return True, b"line1\nother\nline3\n", "644"
+
+        def write_conflict(rel, payload, _mode):
+            blocked[rel] = payload
+            return True
+
+        modify_only = [item for item in found if item["path"] == "a.txt"]
+        applied, failed = transfer_line_changes(modify_only, read_conflict, write_conflict, delete_dest)
+        assert applied == 0 and failed == 1 and "a.txt" not in blocked, (applied, failed, blocked)
+        # 对端已是补丁结果：应跳过，不可再写入导致重复插入
+        already = {}
+
+        def read_already(rel):
+            return True, b"line1\nchanged\nline3\n", "644"
+
+        def write_already(rel, payload, _mode):
+            already[rel] = payload
+            return True
+
+        applied, failed = transfer_line_changes(modify_only, read_already, write_already, delete_dest)
+        assert applied == 1 and failed == 0 and "a.txt" not in already, (applied, failed, already)
+        # 无 content 字段时，靠反向 apply 也能识别已同步
+        no_content = [{k: v for k, v in item.items() if k != "content"} for item in modify_only]
+        already2 = {}
+
+        def write_already2(rel, payload, _mode):
+            already2[rel] = payload
+            return True
+
+        applied, failed = transfer_line_changes(no_content, read_already, write_already2, delete_dest)
+        assert applied == 1 and failed == 0 and "a.txt" not in already2, (applied, failed, already2)
+        status, info = client.changes()
+        assert status == 200 and any(item.get("path") == "pkg/c.txt" and item.get("kind") == "modify" for item in info.get("changes") or []), info
+        server.shutdown()
+        home = tempfile.mkdtemp(prefix="cs-sync-home-")
+        os.environ["CS_SYNC_HOME"] = home
+        try:
+            first = os.path.join(local, "alpha")
+            second = os.path.join(local, "beta")
+            os.makedirs(first)
+            os.makedirs(second)
+            cmd_init(argparse.Namespace(
+                name="alpha", local=first, remote="/srv/alpha", base="https://10.1.1.1:18888",
+                port=0, force=False,
+            ))
+            cmd_init(argparse.Namespace(
+                name="", local=second, remote="/srv/beta", base="", port=0, force=False,
+            ))
+            command = recv_command(resolve_project("alpha"))
+            assert command.startswith("cs-sync recv "), command
+            assert "--root" in command and "--token" in command and "--port" in command
+            files = project_files()
+            assert set(files) == {"alpha", "beta"}
+            host = load_host()
+            alpha = compose(host, load_json(files["alpha"]))
+            beta = compose(host, load_json(files["beta"]))
+            assert alpha["port"] == 27182
+            assert beta["port"] == 27183
+            assert alpha["endpoint"] == "https://10.1.1.1:18888/proxy/27182"
+            assert beta["endpoint"] == "https://10.1.1.1:18888/proxy/27183"
+            assert alpha["remoteRoot"] == "/srv/alpha"
+            assert resolve_project("beta")["localRoot"] == second
+            cmd_remove(argparse.Namespace(name="beta"))
+            assert "beta" not in project_files()
+            assert os.path.isdir(second)
+            assert resolve_project("alpha")["remoteRoot"] == "/srv/alpha"
+            upper = os.path.join(local, "case-upper")
+            lower = os.path.join(local, "case-lower")
+            os.makedirs(upper)
+            os.makedirs(lower)
+            cmd_init(argparse.Namespace(
+                name="Case", local=upper, remote="/srv/Case", base="", port=0, force=False,
+            ))
+            cmd_init(argparse.Namespace(
+                name="case", local=lower, remote="/srv/case", base="", port=0, force=False,
+            ))
+            names = project_files()
+            assert "Case" in names and "case" in names
+            assert os.path.basename(names["Case"]) != os.path.basename(names["case"])
+            cmd_remove(argparse.Namespace(name="case"))
+            assert "case" not in project_files()
+            assert resolve_project("Case")["remoteRoot"] == "/srv/Case"
+        finally:
+            os.environ.pop("CS_SYNC_HOME", None)
+            shutil.rmtree(home, ignore_errors=True)
+        parser = build_parser()
+        help_text = parser.format_help()
+        assert "to-local" in help_text and "to-cloud" in help_text
+        assert "--version" in help_text
+        assert package_version() == "0.1.0"
+        assert "监听 0.0.0.0" in help_text
+        assert "只听 127.0.0.1" not in help_text
+        try:
+            parser.parse_args(["sync", "--full"])
+        except SystemExit as exc:
+            assert exc.code == 2
+        else:
+            raise AssertionError("sync --full 应该已经删除")
+        assert normalize_remote_path("/opt/cs-sync.py") == "/opt/cs-sync.py"
+        assert normalize_remote_path("\\opt\\cs-sync.py") == "/opt/cs-sync.py"
+        try:
+            normalize_remote_path("C:/work/proj")
+        except SystemExit:
+            pass
+        else:
+            raise AssertionError("云端路径不应接受 Windows 盘符")
+
+        # --dry-run：预览清单且不改写工作区 / 不暂存
+        dry_local = tempfile.mkdtemp(prefix="cs-sync-dry-local-")
+        dry_remote = tempfile.mkdtemp(prefix="cs-sync-dry-remote-")
+        try:
+            with open(os.path.join(dry_local, "same.txt"), "w", encoding="utf-8") as handle:
+                handle.write("same")
+            with open(os.path.join(dry_remote, "same.txt"), "w", encoding="utf-8") as handle:
+                handle.write("same")
+            with open(os.path.join(dry_local, "newer.txt"), "w", encoding="utf-8") as handle:
+                handle.write("local-new")
+            with open(os.path.join(dry_remote, "cloud-only.txt"), "w", encoding="utf-8") as handle:
+                handle.write("cloud")
+            remote_map = {
+                "same.txt": sha256_file(os.path.join(dry_remote, "same.txt")),
+                "cloud-only.txt": sha256_file(os.path.join(dry_remote, "cloud-only.txt")),
+            }
+            up, sk, fl = preview_copy_local_to_cloud(dry_local, set(DEFAULT_IGNORE_DIRS), remote_map)
+            assert fl == 0 and up == 1 and sk == 1, (up, sk, fl)
+            down, sk2, fl2 = preview_copy_cloud_to_local(dry_local, remote_map)
+            assert fl2 == 0 and down == 1 and sk2 == 1, (down, sk2, fl2)
+            assert open(os.path.join(dry_local, "newer.txt"), encoding="utf-8").read() == "local-new"
+            assert not os.path.exists(os.path.join(dry_local, "cloud-only.txt"))
+            assert open(os.path.join(dry_remote, "cloud-only.txt"), encoding="utf-8").read() == "cloud"
+
+            line_dir = os.path.join(dry_local, "dry-lines")
+            make_repo(line_dir, "a.txt", "line1\nline2\nline3\n")
+            with open(os.path.join(line_dir, "a.txt"), "w", encoding="utf-8") as handle:
+                handle.write("line1\nchanged\nline3\n")
+            with open(os.path.join(line_dir, "brand.txt"), "w", encoding="utf-8") as handle:
+                handle.write("x\n")
+            found, repo_count = collect_changes(line_dir, set(DEFAULT_IGNORE_DIRS))
+            assert repo_count == 1 and found
+
+            def read_ok(rel):
+                if rel == "a.txt":
+                    return True, b"line1\nline2\nline3\n", "644"
+                return False, None, "644"
+
+            would, failed = preview_line_changes(found, read_ok)
+            assert failed == 0 and would == 2, (would, failed)
+            assert open(os.path.join(line_dir, "a.txt"), encoding="utf-8").read() == "line1\nchanged\nline3\n"
+
+            def read_conflict(rel):
+                return True, b"line1\nother\nline3\n", "644"
+
+            modify_only = [item for item in found if item["path"] == "a.txt"]
+            would, failed = preview_line_changes(modify_only, read_conflict)
+            assert would == 0 and failed == 1, (would, failed)
+
+            preview_sync_divergence(dry_local, set(DEFAULT_IGNORE_DIRS), remote_map, True)
+            assert not os.path.exists(os.path.join(dry_local, "cloud-only.txt"))
+
+            dry_parser = build_parser()
+            for command in ("to-cloud", "to-local", "diff-to-cloud", "diff-to-local", "sync"):
+                ns = dry_parser.parse_args([command, "--dry-run"])
+                assert ns.dry_run is True
+                assert ns.command == command
+        finally:
+            shutil.rmtree(dry_local, ignore_errors=True)
+            shutil.rmtree(dry_remote, ignore_errors=True)
+
+        # 边界：空文件保留、云端删除不复活、插入间隙不重复、无结尾换行补丁可 apply
+        empty_change = change_from_contents("e.txt", "e.txt", b"hello\n", b"", "644")
+        assert empty_change and empty_change["kind"] == "modify", empty_change
+        assert decode_bytes(empty_change["content"]) == b""
+        del_change = change_from_contents("e.txt", "e.txt", b"hello\n", b"", "644", deleted=True)
+        assert del_change and del_change["kind"] == "delete", del_change
+        empty_add = change_from_contents("e.txt", "e.txt", b"", b"hi\n", "644")
+        assert empty_add and empty_add["kind"] == "modify", empty_add
+
+        saved_empty = {}
+
+        def read_empty(rel):
+            return True, b"hello\n", "644"
+
+        def write_empty(rel, payload, _mode):
+            saved_empty[rel] = payload
+            return True
+
+        def delete_empty(_rel):
+            raise AssertionError("空内容不应 delete_dest")
+
+        applied, failed = transfer_line_changes(
+            [empty_change], read_empty, write_empty, delete_empty, success_verb="本地改动"
+        )
+        assert failed == 0 and applied == 1 and saved_empty.get("e.txt") == b"", (applied, failed, saved_empty)
+
+        nnl = change_from_contents("n.txt", "n.txt", b"hello", b"hello!", "644")
+        assert nnl and nnl["kind"] == "modify", nnl
+        saved_nnl = {}
+
+        def read_nnl(rel):
+            return True, b"hello", "644"
+
+        def write_nnl(rel, payload, _mode):
+            saved_nnl[rel] = payload
+            return True
+
+        applied, failed = transfer_line_changes(
+            [nnl], read_nnl, write_nnl, delete_empty, success_verb="本地改动"
+        )
+        assert failed == 0 and applied == 1 and saved_nnl.get("n.txt") == b"hello!", (applied, failed, saved_nnl)
+
+        base = b"alpha\nbeta\n"
+        local_delta = b"alpha\nSAME\nextra\nbeta\n"
+        cloud_delta = b"alpha\nSAME\nbeta\n"
+        assert apply_line_delta_onto(base, local_delta, cloud_delta) is None
+        # 间隙已含完整插入段：跳过，不重复
+        cloud_more = b"alpha\nSAME\nextra\nbeta\n"
+        local_same = b"alpha\nSAME\nbeta\n"
+        assert apply_line_delta_onto(base, local_same, cloud_more) == cloud_more
+        local_ins = b"alpha\nLocal1\nbeta\n"
+        assert apply_line_delta_onto(base, local_ins, cloud_delta) == b"alpha\nSAME\nLocal1\nbeta\n"
+
+        status, _payload, reason = push_watch_edit_to_cloud(
+            "gone.txt",
+            local,
+            b"local-edit\n",
+            {"gone.txt": b"old\n"},
+            lambda rel: (False, None, "644"),
+            lambda rel, payload, mode: (_ for _ in ()).throw(AssertionError("不应复活云端删除")),
+            lambda rel: True,
+            last_cloud_synced={"gone.txt": b"old\n"},
+        )
+        assert status == "conflict" and reason == "cloud-deleted", (status, reason)
+        wrote = {}
+        status, payload, _mode = push_watch_edit_to_cloud(
+            "fresh.txt",
+            local,
+            b"new\n",
+            {},
+            lambda rel: (False, None, "644"),
+            lambda rel, payload, mode: wrote.__setitem__(rel, payload) or True,
+            lambda rel: True,
+            last_cloud_synced={},
+        )
+        assert status == "ok" and wrote.get("fresh.txt") == b"new\n", (status, wrote)
+
+        # 仅末尾换行变化也必须能生成可 apply 的补丁
+        nl_only = change_from_contents("nl.txt", "nl.txt", b"hello\n", b"hello", "644")
+        assert nl_only and nl_only["kind"] == "modify", nl_only
+        patch_nl = decode_bytes(nl_only["patch"])
+        assert b"No newline at end of file" in patch_nl, patch_nl
+        saved_nl = {}
+
+        def read_nl(rel):
+            return True, b"hello\n", "644"
+
+        def write_nl(rel, payload, _mode):
+            saved_nl[rel] = payload
+            return True
+
+        applied, failed = transfer_line_changes(
+            [nl_only], read_nl, write_nl, delete_empty, success_verb="本地改动"
+        )
+        assert failed == 0 and applied == 1 and saved_nl.get("nl.txt") == b"hello", (applied, failed, saved_nl)
+
+        # 无结尾换行且改动不在最后一行：标记须跟在最后一行（上下文）之后
+        mid = change_from_contents("mid.txt", "mid.txt", b"a\nb\nc", b"a\nB\nc", "644")
+        assert mid and mid["kind"] == "modify", mid
+        patch_mid = decode_bytes(mid["patch"]).decode("utf-8")
+        assert patch_mid.rstrip().endswith("\"), patch_mid
+        assert "\n c\n\\ No newline" in patch_mid.replace("\r", ""), repr(patch_mid)
+        saved_mid = {}
+
+        def read_mid(rel):
+            return True, b"a\nb\nc", "644"
+
+        def write_mid(rel, payload, _mode):
+            saved_mid[rel] = payload
+            return True
+
+        applied, failed = transfer_line_changes(
+            [mid], read_mid, write_mid, delete_empty, success_verb="本地改动"
+        )
+        assert failed == 0 and applied == 1 and saved_mid.get("mid.txt") == b"a\nB\nc", (applied, failed, saved_mid)
+
+        # CRLF → LF 不能再被当成空 diff
+        crlf = change_from_contents("cr.txt", "cr.txt", b"hello\r\n", b"hello\n", "644")
+        assert crlf and crlf["kind"] == "modify", crlf
+
+        # 对端已删除：delete 应计为已同步，而非失败
+        del_gone = change_from_contents("gone2.txt", "gone2.txt", b"x\n", b"", "644", deleted=True)
+        assert del_gone and del_gone["kind"] == "delete"
+
+        def read_gone(rel):
+            return False, None, "644"
+
+        def write_gone(rel, payload, _mode):
+            raise AssertionError("不应写入")
+
+        def delete_gone(_rel):
+            raise AssertionError("对端已无文件不应再 delete_dest")
+
+        applied, failed = transfer_line_changes(
+            [del_gone], read_gone, write_gone, delete_gone, success_verb="本地改动"
+        )
+        assert applied == 1 and failed == 0, (applied, failed)
+
+        # 本地改过同一行后云端再删：应冲突，不能当成删除已满足
+        base_del = b"a\nkeep\nb\n"
+        local_chg = b"a\nCHANGED\nb\n"
+        cloud_del = b"a\nb\n"
+        assert apply_line_delta_onto(base_del, cloud_del, local_chg) is None
+        # 目标侧已删掉该行：跳过
+        assert apply_line_delta_onto(base_del, cloud_del, cloud_del) == cloud_del
+
+        # 锚点漂移：目标侧已在末尾有待插入行 → 跳过，不重复追加
+        cloud_base_dup = b"alpha\nEXTRA\nbeta\n"
+        cloud_new_dup = b"alpha\nEXTRA\nbeta\nNEW\n"
+        local_dup = b"alpha\nbeta\nNEW\n"
+        assert apply_line_delta_onto(cloud_base_dup, cloud_new_dup, local_dup) == local_dup
+
+        # 无后继基线锚点且插入点后有对不上的尾部 → 冲突，不插到中间
+        assert apply_line_delta_onto(b"alpha\n", b"alpha\nnew\n", b"alpha\nONLY_CLOUD\n") is None
+        assert apply_line_delta_onto(
+            b"alpha\nONLY_LOCAL\n", b"alpha\nONLY_LOCAL\nnew\n", b"alpha\nONLY_CLOUD\n"
+        ) is None
+
+        # 推送成功后同一轮：云端增量回灌本地，不应把已有 NEW 再插一遍
+        pushed = {}
+        status, cloud_after, _mode = push_watch_edit_to_cloud(
+            "round.txt",
+            local,
+            b"alpha\nbeta\nNEW\n",
+            {"round.txt": b"alpha\nbeta\n"},
+            lambda rel: (True, b"alpha\nEXTRA\nbeta\n", "644"),
+            lambda rel, payload, mode: pushed.__setitem__(rel, payload) or True,
+            lambda rel: True,
+            last_cloud_synced={"round.txt": b"alpha\nEXTRA\nbeta\n"},
+        )
+        assert status == "ok" and cloud_after == b"alpha\nEXTRA\nbeta\nNEW\n", (status, cloud_after)
+        local_round = {"round.txt": b"alpha\nbeta\nNEW\n"}
+
+        def read_round(rel):
+            return True, local_round[rel], "644"
+
+        def write_round(rel, payload, _mode):
+            local_round[rel] = payload
+            return True
+
+        ok_m, merged_m = try_merge_cloud_onto_local(
+            "round.txt",
+            local,
+            b"alpha\nEXTRA\nbeta\n",
+            cloud_after,
+            "644",
+            read_round,
+            write_round,
+            lambda rel: True,
+        )
+        assert ok_m and local_round["round.txt"] == b"alpha\nbeta\nNEW\n", (ok_m, merged_m, local_round)
+
+        # 无行级基线但云端已有文件：回退整份上传
+        wrote_nb = {}
+        status, payload, _mode = push_watch_edit_to_cloud(
+            "exist.txt",
+            local,
+            b"brand-new\n",
+            {},
+            lambda rel: (True, b"old-cloud\n", "644"),
+            lambda rel, payload, mode: wrote_nb.__setitem__(rel, payload) or True,
+            lambda rel: True,
+            last_cloud_synced={},
+        )
+        assert status == "ok" and wrote_nb.get("exist.txt") == b"brand-new\n", (status, wrote_nb)
+
+        # 删除以 -- 开头 / 新增以 ++ 开头的行：不得被当成 unified diff 文件头
+        dash_old = b"a\n--dash\nb\n"
+        dash_new = b"a\n++plus\nb\n"
+        dash_ch = change_from_contents("dash.txt", "dash.txt", dash_old, dash_new, "644")
+        assert dash_ch and dash_ch["kind"] == "modify", dash_ch
+        dash_patch = decode_bytes(dash_ch["patch"])
+        assert b"--- a/dash.txt" in dash_patch and b"+++ b/dash.txt" in dash_patch, dash_patch
+        # 正文里的 ---dash / +++plus 必须作为 +/- 行存在
+        assert b"---dash\n" in dash_patch or b"--dash" in dash_patch, dash_patch
+        outcome, dash_result = apply_saved_patch("dash.txt", dash_old, dash_patch)
+        assert outcome == "ok" and dash_result == dash_new, (outcome, dash_result)
+
+        # 无结尾换行 + 改动远离末尾：末行不在 hunk 内时不得输出 No newline 标记，
+        # 否则 git apply 返回 0 却把上下文行换行吃掉（L5\nL6 → L5L6）
+        far_old = b"".join(b"L%d\n" % i for i in range(1, 20)) + b"L20"
+        far_new = b"L1\nCHANGED\n" + b"".join(b"L%d\n" % i for i in range(3, 20)) + b"L20"
+        far_ch = change_from_contents("far.txt", "far.txt", far_old, far_new, "644")
+        assert far_ch and far_ch["kind"] == "modify", far_ch
+        far_patch = decode_bytes(far_ch["patch"])
+        assert b"No newline at end of file" not in far_patch, far_patch
+        outcome, far_result = apply_saved_patch("far.txt", far_old, far_patch)
+        assert outcome == "ok" and far_result == far_new, (outcome, far_result)
+        saved_far = {}
+
+        def read_far(rel):
+            return True, far_old, "644"
+
+        def write_far(rel, payload, _mode):
+            saved_far[rel] = payload
+            return True
+
+        applied, failed = transfer_line_changes(
+            [far_ch], read_far, write_far, delete_empty, success_verb="本地改动"
+        )
+        assert failed == 0 and applied == 1 and saved_far.get("far.txt") == far_new, (
+            applied, failed, saved_far.get("far.txt")
+        )
+
+        # 人为错误 No newline 标记：git apply 返回 0 但写坏；transfer 必须拒绝写入
+        corrupt_patch = (
+            b"--- a/far.txt\n+++ b/far.txt\n@@ -1,5 +1,5 @@\n L1\n-L2\n+CHANGED\n L3\n L4\n L5\n"
+            b"\\n"
+        )
+        corrupt_ch = {
+            "path": "far.txt",
+            "repoPath": "far.txt",
+            "kind": "modify",
+            "mode": "644",
+            "patch": encode_bytes(corrupt_patch),
+            "content": encode_bytes(far_new),
+        }
+        saved_bad = {}
+
+        def write_bad(rel, payload, _mode):
+            saved_bad[rel] = payload
+            return True
+
+        applied, failed = transfer_line_changes(
+            [corrupt_ch], read_far, write_bad, delete_empty, success_verb="本地改动"
+        )
+        assert failed == 1 and applied == 0 and "far.txt" not in saved_bad, (
+            applied, failed, saved_bad
+        )
+
+        print("self-test 通过")
+    finally:
+        shutil.rmtree(local, ignore_errors=True)
+        shutil.rmtree(remote, ignore_errors=True)