235 lines
11 KiB
TypeScript
235 lines
11 KiB
TypeScript
import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
|
|
import { QueryObserver } from "@tanstack/react-query";
|
|
import { readFileSync } from "node:fs";
|
|
import localforage from "localforage";
|
|
|
|
import { apiClient } from "@/services/api/request";
|
|
import { deleteAssetsWithRemoteSync, initializeRemoteUserDataSession, loadAssetLibraryPage, resetRemoteUserDataSync } from "@/services/user-data-sync";
|
|
import { flushAssetStorePersistence, useAssetStore, type Asset } from "@/stores/use-asset-store";
|
|
import { appQueryClient } from "@/lib/query-client";
|
|
|
|
const originalAdapter = apiClient.defaults.adapter;
|
|
let originalWindow: PropertyDescriptor | undefined;
|
|
const originalGet = localforage.getItem;
|
|
const originalSet = localforage.setItem;
|
|
const originalRemove = localforage.removeItem;
|
|
async function within<T>(promise: Promise<T>): Promise<T> {
|
|
let timer: ReturnType<typeof setTimeout> | undefined;
|
|
try {
|
|
return await Promise.race([
|
|
promise,
|
|
new Promise<never>((_, reject) => {
|
|
timer = setTimeout(() => reject(new Error("删除或刷新链路未结束")), 1000);
|
|
}),
|
|
]);
|
|
} finally {
|
|
clearTimeout(timer);
|
|
}
|
|
}
|
|
const asset = (id: string): Asset =>
|
|
({
|
|
id,
|
|
kind: "text",
|
|
title: id,
|
|
coverUrl: "",
|
|
tags: [],
|
|
createdAt: "2026-09-21T00:00:00.000Z",
|
|
updatedAt: "2026-09-21T00:00:00.000Z",
|
|
data: { content: "测试素材" },
|
|
}) as Asset;
|
|
|
|
beforeEach(async () => {
|
|
originalWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
|
|
const storage = new Map<string, string>();
|
|
const indexed = new Map<string, unknown>();
|
|
localforage.getItem = (async (key: string) => indexed.get(key) ?? null) as typeof localforage.getItem;
|
|
localforage.setItem = (async (key: string, value: unknown) => {
|
|
indexed.set(key, value);
|
|
return value;
|
|
}) as typeof localforage.setItem;
|
|
localforage.removeItem = async (key: string) => {
|
|
indexed.delete(key);
|
|
};
|
|
Object.defineProperty(globalThis, "window", {
|
|
configurable: true,
|
|
value: {
|
|
setTimeout: globalThis.setTimeout,
|
|
clearTimeout: globalThis.clearTimeout,
|
|
localStorage: { getItem: (key: string) => storage.get(key) ?? null, setItem: (key: string, value: string) => storage.set(key, value), removeItem: (key: string) => storage.delete(key) },
|
|
},
|
|
});
|
|
useAssetStore.setState({ assets: [] });
|
|
await flushAssetStorePersistence();
|
|
await initializeRemoteUserDataSession("batch-test-user");
|
|
});
|
|
|
|
afterEach(async () => {
|
|
try {
|
|
await appQueryClient.cancelQueries();
|
|
appQueryClient.clear();
|
|
apiClient.defaults.adapter = originalAdapter;
|
|
resetRemoteUserDataSync();
|
|
useAssetStore.setState({ assets: [] });
|
|
await flushAssetStorePersistence();
|
|
} finally {
|
|
localforage.getItem = originalGet;
|
|
localforage.setItem = originalSet;
|
|
localforage.removeItem = originalRemove;
|
|
if (originalWindow) Object.defineProperty(globalThis, "window", originalWindow);
|
|
else delete (globalThis as { window?: unknown }).window;
|
|
}
|
|
});
|
|
|
|
describe("素材批量删除", () => {
|
|
test("100 个素材只发一个 POST 数组请求，成功后只更新一次本地素材集合", async () => {
|
|
const ids = Array.from({ length: 100 }, (_, i) => `asset-${i}`);
|
|
useAssetStore.setState({ assets: [...ids.map(asset), asset("keep")] });
|
|
const requests: unknown[] = [];
|
|
apiClient.defaults.adapter = async (config) => {
|
|
requests.push({ method: config.method, url: config.url, body: JSON.parse(config.data) });
|
|
expect(useAssetStore.getState().assets).toHaveLength(101);
|
|
return { config, headers: {}, status: 200, statusText: "OK", data: { code: 0, data: { ids }, msg: "ok" } };
|
|
};
|
|
let updates = 0;
|
|
const stop = useAssetStore.subscribe((state, previous) => {
|
|
if (state.assets !== previous.assets) updates++;
|
|
});
|
|
try {
|
|
await deleteAssetsWithRemoteSync(ids);
|
|
expect(requests).toEqual([{ method: "post", url: "/assets/batch-delete", body: ids }]);
|
|
expect(useAssetStore.getState().assets.map((item) => item.id)).toEqual(["keep"]);
|
|
expect(updates).toBe(1);
|
|
} finally {
|
|
stop();
|
|
}
|
|
});
|
|
|
|
test.each([false, true])("真实分页查询刷新不阻塞删除完成（刷新失败：%s）", async (failRefresh) => {
|
|
const initialPage = {
|
|
assets: [asset("first"), asset("keep")],
|
|
total: 2,
|
|
page: 1,
|
|
pageSize: 20,
|
|
kindCounts: {},
|
|
categoryCounts: {},
|
|
folderCounts: {},
|
|
hasMore: false,
|
|
};
|
|
useAssetStore.setState({ assets: initialPage.assets });
|
|
let releaseRefresh!: () => void;
|
|
const refreshGate = new Promise<void>((resolve) => {
|
|
releaseRefresh = resolve;
|
|
});
|
|
const requests: string[] = [];
|
|
apiClient.defaults.adapter = async (config) => {
|
|
requests.push(`${config.method} ${config.url}`);
|
|
if (config.method === "post") {
|
|
return { config, headers: {}, status: 200, statusText: "OK", data: { code: 0, data: { ids: ["first"] }, msg: "ok" } };
|
|
}
|
|
await refreshGate;
|
|
if (failRefresh) throw new Error("列表暂时不可用");
|
|
return {
|
|
config,
|
|
headers: {},
|
|
status: 200,
|
|
statusText: "OK",
|
|
data: {
|
|
code: 0,
|
|
data: { ...initialPage, assets: [asset("keep")], total: 1 },
|
|
msg: "ok",
|
|
},
|
|
};
|
|
};
|
|
const warning = spyOn(console, "warn").mockImplementation(() => {});
|
|
const observers = ["asset-library", "asset-picker"].map(
|
|
(key) =>
|
|
new QueryObserver(appQueryClient, {
|
|
queryKey: [key, "delete-regression"],
|
|
queryFn: () => loadAssetLibraryPage({ page: 1, pageSize: 20 }),
|
|
initialData: initialPage,
|
|
}),
|
|
);
|
|
const stops: (() => void)[] = [];
|
|
const refreshed = observers.map(
|
|
(observer) =>
|
|
new Promise<void>((resolve) => {
|
|
stops.push(
|
|
observer.subscribe((result) => {
|
|
if (result.fetchStatus === "idle" && (result.isError || result.data?.total === 1)) resolve();
|
|
}),
|
|
);
|
|
}),
|
|
);
|
|
try {
|
|
// GET 尚未返回，删除必须已返回，调用方才能关闭 Modal / Popconfirm。
|
|
await within(deleteAssetsWithRemoteSync(["first"]));
|
|
expect(useAssetStore.getState().assets.map((item) => item.id)).toEqual(["keep"]);
|
|
expect(requests).toEqual(["post /assets/batch-delete", "get /assets", "get /assets"]);
|
|
for (const observer of observers) expect(observer.getCurrentResult().fetchStatus).toBe("fetching");
|
|
|
|
releaseRefresh();
|
|
// 真实 loadAssetLibraryPage 要再次进入同步队列；不能与删除互相等待。
|
|
await within(Promise.all(refreshed));
|
|
for (const observer of observers) {
|
|
const result = observer.getCurrentResult();
|
|
if (failRefresh) expect(result.error?.message).toBe("列表暂时不可用");
|
|
else expect(result.data?.assets.map((item) => item.id)).toEqual(["keep"]);
|
|
}
|
|
await new Promise((resolve) => setTimeout(resolve, 0));
|
|
if (failRefresh) expect(warning).toHaveBeenCalledWith("素材删除后列表刷新失败", expect.any(Error));
|
|
expect(requests.filter((request) => request.startsWith("post"))).toHaveLength(1);
|
|
} finally {
|
|
releaseRefresh();
|
|
await appQueryClient.cancelQueries();
|
|
stops.forEach((stop) => stop());
|
|
observers.forEach((observer) => observer.destroy());
|
|
warning.mockRestore();
|
|
}
|
|
});
|
|
|
|
test("业务失败不会先删本地素材或回退到逐条请求", async () => {
|
|
useAssetStore.setState({ assets: [asset("first"), asset("second")] });
|
|
let requests = 0;
|
|
apiClient.defaults.adapter = async (config) => {
|
|
requests++;
|
|
return { config, headers: {}, status: 200, statusText: "OK", data: { code: 400, data: null, msg: "拒绝删除", reason: "invalid_argument" } };
|
|
};
|
|
await expect(deleteAssetsWithRemoteSync(["first", "second"])).rejects.toThrow("拒绝删除");
|
|
expect(requests).toBe(1);
|
|
expect(useAssetStore.getState().assets.map((item) => item.id)).toEqual(["first", "second"]);
|
|
});
|
|
|
|
test("删除响应返回前切换账号，不删除新账号本地素材", async () => {
|
|
useAssetStore.setState({ assets: [asset("same-id")] });
|
|
apiClient.defaults.adapter = async (config) => {
|
|
resetRemoteUserDataSync();
|
|
useAssetStore.setState({ assets: [asset("same-id")] });
|
|
return { config, headers: {}, status: 200, statusText: "OK", data: { code: 0, data: { ids: ["same-id"] }, msg: "ok" } };
|
|
};
|
|
await expect(deleteAssetsWithRemoteSync(["same-id"])).rejects.toThrow("账号已切换");
|
|
expect(useAssetStore.getState().assets).toHaveLength(1);
|
|
});
|
|
|
|
test("空 ID 不发请求，重复 ID 合并到一个请求", async () => {
|
|
const bodies: string[][] = [];
|
|
apiClient.defaults.adapter = async (config) => {
|
|
const ids = JSON.parse(config.data);
|
|
bodies.push(ids);
|
|
return { config, headers: {}, status: 200, statusText: "OK", data: { code: 0, data: { ids }, msg: "ok" } };
|
|
};
|
|
await expect(deleteAssetsWithRemoteSync(["good", " "])).rejects.toThrow("素材 ID 不能为空");
|
|
expect(bodies).toHaveLength(0);
|
|
await deleteAssetsWithRemoteSync([" first ", "first", "second"]);
|
|
expect(bodies).toEqual([["first", "second"]]);
|
|
});
|
|
|
|
test("素材页和选择器的批量及清空入口使用数组同步方法", () => {
|
|
const page = readFileSync(new URL("../src/pages/assets/index.tsx", import.meta.url), "utf8");
|
|
const picker = readFileSync(new URL("../src/components/assets/asset-library-picker-modal.tsx", import.meta.url), "utf8");
|
|
expect(page).toContain("deleteAssetsWithRemoteSync(trashAssets.map");
|
|
expect(page).toContain("deleteAssetsWithRemoteSync(selectedAssets.map");
|
|
expect(picker).toContain("deleteAssetsWithRemoteSync(archivedSelectedIds)");
|
|
expect(picker).toContain("deleteAssetsWithRemoteSync(toDelete.map");
|
|
});
|
|
});
|