✅ 补充 synchronize 测试并保留 orphan 状态

CodFrm · CodFrm · commit 462a25e941ca · 2026-04-27T12:00:48.000+08:00
- 新增 deleteScript/pushScript 等待 digest 更新的回归测试
- 新增 orphan uuid cloudStatus 保留的回归测试
- syncOnce 加 try/catch 避免错误冒泡破坏队列后续任务
- 跳过 orphan 时保留其云端 status，避免覆盖另一台设备的半上传状态
diff --git a/src/app/service/service_worker/synchronize.test.ts b/src/app/service/service_worker/synchronize.test.ts
@@ -29,6 +29,13 @@ const createFs = (overrides: Partial<FileSystem> = {}): FileSystem =>
     ...overrides,
   }) as unknown as FileSystem;
 
+// 等待若干轮微任务，确保所有已就绪的 await 都被推进
+const flushMicrotasks = async (rounds = 10) => {
+  for (let i = 0; i < rounds; i++) {
+    await Promise.resolve();
+  }
+};
+
 describe("SynchronizeService", () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -41,25 +48,26 @@ describe("SynchronizeService", () => {
       releaseFirst = resolve;
     });
     const order: string[] = [];
-    const fs1 = createFs({
-      list: vi
-        .fn()
-        .mockImplementationOnce(async () => {
-          order.push("first:start");
-          await firstGate;
-          order.push("first:end");
-          return [];
-        })
-        .mockResolvedValue([]),
-    });
+    // gate 放在第一轮的最后一步（updateFileDigest 内部的 fs.list）
+    // 这样如果未来锁粒度被改小，第二轮提前进入也会被这个测试捕获
+    const fs1List = vi
+      .fn()
+      .mockImplementationOnce(async () => {
+        order.push("first:list");
+        return [];
+      })
+      .mockImplementationOnce(async () => {
+        order.push("first:digest");
+        await firstGate;
+        order.push("first:end");
+        return [];
+      });
+    const fs1 = createFs({ list: fs1List });
     const fs2 = createFs({
-      list: vi
-        .fn()
-        .mockImplementationOnce(async () => {
-          order.push("second:start");
-          return [];
-        })
-        .mockResolvedValue([]),
+      list: vi.fn().mockImplementation(async () => {
+        order.push("second:list");
+        return [];
+      }),
     });
     const service = new SynchronizeService(
       {} as any,
@@ -76,17 +84,18 @@ describe("SynchronizeService", () => {
     );
 
     const first = service.syncOnce(syncConfig, fs1);
-    await Promise.resolve();
     const second = service.syncOnce(syncConfig, fs2);
-    await Promise.resolve();
+    await flushMicrotasks();
 
-    expect(order).toEqual(["first:start"]);
+    // 第一轮已经跑到末尾的 updateFileDigest，第二轮一步都没开始
+    expect(order).toEqual(["first:list", "first:digest"]);
     expect((fs2.list as any).mock.calls.length).toBe(0);
 
     releaseFirst();
     await Promise.all([first, second]);
 
-    expect(order).toEqual(["first:start", "first:end", "second:start"]);
+    // 第一轮整体结束（first:end）后第二轮才能开始（second:list）
+    expect(order.slice(0, 4)).toEqual(["first:list", "first:digest", "first:end", "second:list"]);
   });
 
   it("does not delete orphan cloud script without meta", async () => {
@@ -121,6 +130,61 @@ describe("SynchronizeService", () => {
     expect(fs.delete).not.toHaveBeenCalled();
   });
 
+  it("preserves cloudStatus for skipped orphan uuid when writing scriptcat-sync.json", async () => {
+    const orphanStatus = { enable: false, sort: 7, updatetime: 100 };
+    const writeMock = vi.fn().mockResolvedValue(undefined);
+    const fs = createFs({
+      list: vi.fn().mockResolvedValue([
+        {
+          name: "orphan.user.js",
+          path: "orphan.user.js",
+          size: 1,
+          digest: "d1",
+          createtime: 1,
+          updatetime: 1,
+        },
+        {
+          name: "scriptcat-sync.json",
+          path: "scriptcat-sync.json",
+          size: 1,
+          digest: "d2",
+          createtime: 1,
+          updatetime: 1,
+        },
+      ]),
+      open: vi.fn().mockResolvedValue({
+        read: vi.fn().mockResolvedValue(
+          JSON.stringify({
+            version: "1.0.0",
+            status: { scripts: { orphan: orphanStatus } },
+          })
+        ),
+      }),
+      create: vi.fn().mockResolvedValue({ write: writeMock }),
+    });
+    const service = new SynchronizeService(
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {
+        scriptCodeDAO: {},
+        all: vi.fn().mockResolvedValue([]),
+      } as any
+    );
+
+    await service.syncOnce(syncConfig, fs);
+
+    // 第一次 write 是 scriptcat-sync.json 的内容
+    expect(writeMock).toHaveBeenCalled();
+    const writtenContent = writeMock.mock.calls[0][0] as string;
+    const written = JSON.parse(writtenContent);
+    expect(written.status.scripts.orphan).toEqual(orphanStatus);
+  });
+
   it("waits for installScript during pullScript", async () => {
     let releaseInstall!: () => void;
     const installGate = new Promise<void>((resolve) => {
@@ -193,4 +257,142 @@ console.log("ok");`
     expect(installScript).toHaveBeenCalledTimes(1);
     expect(settled).toBe(true);
   });
+
+  it("waits for deleteScript before updating file digest", async () => {
+    let releaseDelete!: () => void;
+    const deleteGate = new Promise<void>((resolve) => {
+      releaseDelete = resolve;
+    });
+    const order: string[] = [];
+    const deleteScript = vi.fn().mockImplementation(async () => {
+      order.push("delete:start");
+      await deleteGate;
+      order.push("delete:end");
+    });
+    // fs.list 第二次调用对应 updateFileDigest，这是 syncOnce 的最后一步
+    const fsList = vi
+      .fn()
+      .mockImplementationOnce(async () => [
+        {
+          name: "del-uuid.meta.json",
+          path: "del-uuid.meta.json",
+          size: 1,
+          digest: "d1",
+          createtime: 1,
+          updatetime: 1,
+        },
+      ])
+      .mockImplementationOnce(async () => {
+        order.push("digest:list");
+        return [];
+      });
+    const fs = createFs({
+      list: fsList,
+      open: vi.fn().mockResolvedValue({
+        read: vi.fn().mockResolvedValue(JSON.stringify({ uuid: "del-uuid", isDeleted: true })),
+      }),
+    });
+    const service = new SynchronizeService(
+      {} as any,
+      {} as any,
+      { deleteScript } as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {
+        scriptCodeDAO: {},
+        all: vi.fn().mockResolvedValue([
+          {
+            uuid: "del-uuid",
+            name: "del",
+            updatetime: 1,
+            createtime: 1,
+            status: 1,
+            sort: 0,
+            metadata: {},
+          },
+        ]),
+      } as any
+    );
+
+    const promise = service.syncOnce(syncConfig, fs);
+    await flushMicrotasks();
+
+    // delete 已经开始但没结束，updateFileDigest 还没被调用
+    expect(order).toEqual(["delete:start"]);
+
+    releaseDelete();
+    await promise;
+
+    // delete 必须在 updateFileDigest 之前完成
+    expect(order).toEqual(["delete:start", "delete:end", "digest:list"]);
+  });
+
+  it("waits for pushScript before updating file digest", async () => {
+    let releasePush!: () => void;
+    const pushGate = new Promise<void>((resolve) => {
+      releasePush = resolve;
+    });
+    const order: string[] = [];
+    // pushScript 内部第一步是 fs.create(uuid.user.js)，gate 在这里就能拦住整个 push
+    const fsCreate = vi.fn().mockImplementation(async (filename: string) => {
+      if (filename === "push-uuid.user.js") {
+        order.push("push:start");
+        await pushGate;
+        order.push("push:end");
+      }
+      return { write: vi.fn().mockResolvedValue(undefined) };
+    });
+    const fsList = vi
+      .fn()
+      .mockImplementationOnce(async () => [])
+      .mockImplementationOnce(async () => {
+        order.push("digest:list");
+        return [];
+      });
+    const fs = createFs({
+      list: fsList,
+      create: fsCreate,
+    });
+    const service = new SynchronizeService(
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {
+        scriptCodeDAO: {
+          get: vi.fn().mockResolvedValue({ code: "// code" }),
+        },
+        all: vi.fn().mockResolvedValue([
+          {
+            uuid: "push-uuid",
+            name: "push",
+            updatetime: 1,
+            createtime: 1,
+            status: 1,
+            sort: 0,
+            metadata: {},
+          },
+        ]),
+      } as any
+    );
+
+    const promise = service.syncOnce(syncConfig, fs);
+    await flushMicrotasks();
+
+    // push 已经开始但没结束，updateFileDigest 还没被调用
+    expect(order).toEqual(["push:start"]);
+
+    releasePush();
+    await promise;
+
+    // push 必须在 updateFileDigest 之前完成
+    expect(order).toContain("push:end");
+    expect(order).toContain("digest:list");
+    expect(order.indexOf("push:end")).toBeLessThan(order.indexOf("digest:list"));
+  });
 });
diff --git a/src/app/service/service_worker/synchronize.ts b/src/app/service/service_worker/synchronize.ts
@@ -67,7 +67,7 @@ type ScriptcatSyncStatus = {
 
 type PushScriptParam = TInstallScriptParams;
 
-const SYNC_SERVICE_TASK_KEY = "cloud_sync";
+const SYNC_SERVICE_TASK_KEY = "cloud_sync_queue";
 
 export class SynchronizeService {
   logger: Logger;
@@ -332,7 +332,13 @@ export class SynchronizeService {
 
   // 同步一次
   async syncOnce(syncConfig: CloudSyncConfig, fs: FileSystem) {
-    return stackAsyncTask(SYNC_SERVICE_TASK_KEY, () => this.syncOnceInternal(syncConfig, fs));
+    return stackAsyncTask(SYNC_SERVICE_TASK_KEY, async () => {
+      try {
+        await this.syncOnceInternal(syncConfig, fs);
+      } catch (e) {
+        this.logger.error("sync once error", Logger.E(e));
+      }
+    });
   }
 
   private async syncOnceInternal(syncConfig: CloudSyncConfig, fs: FileSystem) {
@@ -393,6 +399,9 @@ export class SynchronizeService {
     // 对比脚本列表和文件列表,进行同步
     const result: Promise<void>[] = [];
     const updateScript: Map<string, boolean> = new Map();
+    // 记录被跳过的孤儿云端脚本（仅 .user.js 无 .meta.json）
+    // 避免本机回写 scriptcat-sync.json 时丢失对应 uuid 的云端 status
+    const skippedOrphanUuids = new Set<string>();
     // 需要是同步操作，后续上传剩下的脚本
     // 最后使用 Promise.allSettled 进行等待
     uuidMap.forEach((file, uuid) => {
@@ -448,6 +457,7 @@ export class SynchronizeService {
             uuid,
             file: file.script.name,
           });
+          skippedOrphanUuids.add(uuid);
           return;
         }
         updateScript.set(uuid, true);
@@ -509,6 +519,13 @@ export class SynchronizeService {
           }
         })
       );
+      // 保留被跳过的 orphan uuid 的云端 status，避免覆盖另一台设备半上传的状态
+      skippedOrphanUuids.forEach((uuid) => {
+        const status = cloudStatus[uuid];
+        if (status) {
+          scriptcatSync.status.scripts[uuid] = status;
+        }
+      });
       // 保存脚本猫同步状态
       const syncFile = await fs.create("scriptcat-sync.json");
       await syncFile.write(JSON.stringify(scriptcatSync, null, 2));
