Skip to content

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

16.9 KB
Raw Blame
import * as assert from "node:assert/strict";
import {readFileSync} from "node:fs";
import {join} from "node:path";
import {test} from "node:test";
import {setImmediate} from "node:timers";
import {runInNewContext} from "node:vm";
import {ModuleKind, ScriptTarget, transpileModule} from "typescript";

const constants = {LOCAL_MOBILE_TABS: "local-mobile-tabs", LOCAL_FILEPOSITION: "local-fileposition"};
const source = (path: string) => transpileModule(readFileSync(join(__dirname, path), "utf8"), {
    compilerOptions: {module: ModuleKind.CommonJS, target: ScriptTarget.ES2020},
}).outputText;
const layoutSource = source("saveLayout.ts");
const timeoutSource = source("../../util/fetchTimeout.ts");
const clone = <T>(value: T): T => JSON.parse(JSON.stringify(value));
const flush = () => new Promise<void>(resolve => setImmediate(resolve));

type StorageRequest = {
    key: string;
    value: unknown;
    callback: () => void;
    timeout: number;
    resolve: () => void;
    reject: (error: Error) => void;
    signal?: AbortSignal;
};

const loadLayout = (timedRequests = false) => {
    let now = 0;
    let timerID = 0;
    const timers = new Map<number, {at: number, callback: () => void}>();
    const timeoutAPI = {} as typeof import("../../util/fetchTimeout");
    runInNewContext(timeoutSource, {
        exports: timeoutAPI,
        AbortController,
        DOMException,
        setTimeout: (callback: () => void, delay: number) => {
            timers.set(++timerID, {at: now + delay, callback});
            return timerID;
        },
        clearTimeout: (id: number) => timers.delete(id),
    });
    const requests: StorageRequest[] = [];
    const warnings: unknown[][] = [];
    const scrollCalls: {protyle: IProtyle, force: boolean}[] = [];
    const state = {
        config: {readonly: false},
        isPublish: false,
        mobile: {} as {tabs?: {save: () => Promise<boolean>}, editor?: {protyle: IProtyle}},
        storage: {[constants.LOCAL_FILEPOSITION]: {} as Record<string, unknown>},
    };
    const controls = {
        scroll: {id: "visible-block", top: 42} as unknown,
        storageError: undefined as Error | undefined,
    };
    const api = {} as typeof import("./saveLayout");
    const modules: Record<string, unknown> = {
        "../../constants": {Constants: constants},
        "../../protyle/scroll/saveScroll": {saveScroll: (protyle: IProtyle, force: boolean) => {
            scrollCalls.push({protyle, force});
            return controls.scroll;
        }},
        "../../protyle/util/compatibility": {setStorageVal: (
            key: string, value: unknown, callback: () => void, timeout: number,
        ) => {
            if (controls.storageError) {
                throw controls.storageError;
            }
            let resolve: () => void;
            let reject: (error: Error) => void;
            const promise = new Promise<void>((resolvePromise, rejectPromise) => {
                resolve = resolvePromise;
                reject = rejectPromise;
            });
            const request = {key, value, callback, timeout, resolve, reject} as StorageRequest;
            requests.push(request);
            return timedRequests ? timeoutAPI.withFetchTimeout((signal) => {
                request.signal = signal;
                return promise;
            }, undefined, timeout).catch(() => {}) : promise;
        }},
        "../../util/pathName": {isEncryptedBox: (id: string) => id === "encrypted-box"},
        "../../util/fetchTimeout": timeoutAPI,
    };
    runInNewContext(layoutSource, {
        exports: api,
        require: (name: string) => {
            assert.ok(name in modules, name);
            return modules[name];
        },
        window: {siyuan: state},
        console: {warn: (...args: unknown[]) => warnings.push(args)},
    });
    const advance = async (milliseconds: number) => {
        const end = now + milliseconds;
        await flush();
        while (true) {
            const next = Array.from(timers.entries()).filter(([, timer]) => timer.at <= end)
                .sort((a, b) => a[1].at - b[1].at || a[0] - b[0])[0];
            if (!next) {
                break;
            }
            now = next[1].at;
            timers.delete(next[0]);
            next[1].callback();
            await flush();
        }
        now = end;
    };
    return {api, state, controls, requests, warnings, scrollCalls, timers, advance};
};

const succeed = (request: StorageRequest) => {
    request.callback();
    request.resolve();
};
const editor = (notebookId = "public-box") => ({
    protyle: {notebookId, block: {rootID: "document"}} as IProtyle,
});
const entry = (id: string) => ({
    id, rootID: id, notebookID: "public-box", path: `/${id}.sy`, title: id,
    action: ["cb-get-scroll"], scroll: {id: `${id}-block`, top: 10},
});
const tabsState = () => ({
    version: 1,
    activeTabID: "tab-1",
    tabs: [{id: "tab-1", current: entry("current"), backStack: [entry("back")],
        forwardStack: [entry("forward")], activeAt: 100}],
    activationBackStack: ["tab-2"],
    activationForwardStack: ["tab-3"],
});

test("mobile storage snapshots nested tab data synchronously and writes snapshots in FIFO order", async () => {
    const {api, requests} = loadLayout();
    const state = tabsState();
    const firstSnapshot = clone(state);
    const first = api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, state);
    state.tabs[0].current.action.push("cb-get-focus");
    state.tabs[0].current.scroll.top = 20;
    state.tabs[0].backStack[0].action.push("cb-get-focus");
    state.tabs[0].backStack[0].scroll.top = 30;
    state.tabs[0].forwardStack[0].scroll.top = 40;
    state.activationBackStack.push("tab-4");
    state.activationForwardStack.splice(0, 1);
    const secondSnapshot = clone(state);
    const second = api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, state);
    state.tabs[0].current.action.length = 0;
    state.tabs[0].backStack.length = 0;
    state.tabs[0].forwardStack[0].action.length = 0;
    state.tabs[0].forwardStack.length = 0;
    state.tabs[0].current.scroll.top = 90;
    state.activationBackStack.length = 0;
    state.activationForwardStack.push("tab-5");
    const thirdSnapshot = clone(state);
    const third = api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, state);
    state.tabs.length = 0;
    state.activationForwardStack.length = 0;
    assert.equal(requests.length, 1);
    assert.deepEqual(clone(requests[0].value), firstSnapshot);
    succeed(requests[0]);
    assert.equal(await first, true);
    await flush();
    assert.equal(requests.length, 2);
    assert.deepEqual(clone(requests[1].value), secondSnapshot);
    succeed(requests[1]);
    assert.equal(await second, true);
    await flush();
    assert.equal(requests.length, 3);
    assert.deepEqual(clone(requests[2].value), thirdSnapshot);
    succeed(requests[2]);
    assert.equal(await third, true);
    assert.ok(requests.every(request => request.timeout === 10000));
});

test("a success callback does not settle storage or release its queue before the request settles", async () => {
    const {api, requests} = loadLayout();
    let settled = false;
    const first = api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, {revision: 1});
    void first.then(() => { settled = true; });
    const second = api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, {revision: 2});
    requests[0].callback();
    await flush();
    assert.equal(settled, false);
    assert.equal(requests.length, 1);
    requests[0].resolve();
    assert.equal(await first, true);
    await flush();
    assert.equal(requests.length, 2);
    succeed(requests[1]);
    assert.equal(await second, true);
});

test("a consumed request failure reports false and does not block the next snapshot", async () => {
    const {api, requests} = loadLayout();
    const first = api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, {revision: 1});
    const second = api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, {revision: 2});
    requests[0].resolve();
    assert.equal(await first, false);
    requests[0].callback();
    assert.equal(await first, false);
    await flush();
    assert.equal(requests.length, 2);
    succeed(requests[1]);
    assert.equal(await second, true);
});

test("a rejected request reports false and does not poison the tab storage queue", async () => {
    const {api, requests, warnings} = loadLayout();
    const first = api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, {revision: 1});
    const second = api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, {revision: 2});
    requests[0].reject(new Error("offline"));
    assert.equal(await first, false);
    assert.equal(warnings.length, 1);
    await flush();
    succeed(requests[1]);
    assert.equal(await second, true);
});

test("a storage callback followed by request rejection still reports failure", async () => {
    const {api, requests} = loadLayout();
    const saving = api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, {});
    requests[0].callback();
    requests[0].reject(new Error("response processing failed"));
    assert.equal(await saving, false);
});

test("a synchronous storage exception reports failure and permits a later save", async () => {
    const {api, requests, controls} = loadLayout();
    controls.storageError = new Error("request setup failed");
    assert.equal(await api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, {}), false);
    controls.storageError = undefined;
    const saving = api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, {revision: 2});
    await flush();
    assert.equal(requests.length, 1);
    succeed(requests[0]);
    assert.equal(await saving, true);
});

test("legacy position writes start immediately even while tab and position writes are pending", async () => {
    const {api, requests} = loadLayout();
    const first = api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, {revision: 1});
    const second = api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, {revision: 2});
    const positions = {document: {id: "block", top: 10}};
    const legacyFirst = api.saveMobileStorage(constants.LOCAL_FILEPOSITION, positions);
    positions.document.top = 20;
    const legacySecond = api.saveMobileStorage(constants.LOCAL_FILEPOSITION, positions);
    positions.document.top = 30;
    assert.deepEqual(requests.map(request => request.key), [
        constants.LOCAL_MOBILE_TABS, constants.LOCAL_FILEPOSITION, constants.LOCAL_FILEPOSITION,
    ]);
    assert.deepEqual(clone(requests[1].value), {document: {id: "block", top: 10}});
    assert.deepEqual(clone(requests[2].value), {document: {id: "block", top: 20}});
    requests.forEach(succeed);
    assert.deepEqual(await Promise.all([first, legacyFirst, legacySecond]), [true, true, true]);
    await flush();
    assert.equal(requests.length, 4);
    succeed(requests[3]);
    assert.equal(await second, true);
});

test("readonly and published storage saves succeed without cloning or sending data", async () => {
    for (const mode of ["readonly", "publish"]) {
        const {api, state, requests} = loadLayout();
        state.config.readonly = mode === "readonly";
        state.isPublish = mode === "publish";
        const circular: {self?: unknown} = {};
        circular.self = circular;
        assert.equal(await api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, circular), true);
        assert.equal(await api.saveMobileStorage(constants.LOCAL_FILEPOSITION, circular), true);
        assert.equal(requests.length, 0);
    }
});

test("layout save calls the tab saver synchronously and awaits its result", async () => {
    const {api, state, requests, scrollCalls, timers} = loadLayout();
    const snapshot = tabsState();
    state.mobile.editor = editor();
    let calls = 0;
    state.mobile.tabs = {save: () => {
        calls++;
        return api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, snapshot);
    }};
    const saving = api.saveMobileLayout();
    assert.equal(calls, 1);
    assert.equal(requests.length, 1);
    snapshot.tabs[0].current.scroll.top = 99;
    assert.equal((clone(requests[0].value) as typeof snapshot).tabs[0].current.scroll.top, 10);
    assert.equal(scrollCalls.length, 0);
    succeed(requests[0]);
    assert.equal(await saving, true);
    assert.equal(timers.size, 0);
});

test("layout save preserves a false tab result and converts thrown or rejected tab saves to false", async () => {
    for (const failure of ["false", "throw", "reject"]) {
        const {api, state, timers} = loadLayout();
        state.mobile.tabs = {save: () => {
            if (failure === "throw") {
                throw new Error("snapshot failed");
            }
            return failure === "reject" ? Promise.reject(new Error("save failed")) : Promise.resolve(false);
        }};
        assert.equal(await api.saveMobileLayout(), false);
        assert.equal(timers.size, 0);
    }
});

test("blank layouts and editors without a scroll snapshot need no storage write", async () => {
    const {api, state, controls, requests, scrollCalls} = loadLayout();
    assert.equal(await api.saveMobileLayout(), true);
    assert.equal(scrollCalls.length, 0);
    state.mobile.editor = editor();
    controls.scroll = undefined;
    assert.equal(await api.saveMobileLayout(), true);
    assert.equal(scrollCalls.length, 1);
    assert.equal(requests.length, 0);
});

test("legacy layout capture saves the current scroll synchronously and preserves other positions", async () => {
    const {api, state, controls, requests, scrollCalls} = loadLayout();
    state.mobile.editor = editor();
    state.storage[constants.LOCAL_FILEPOSITION].other = {id: "other-block", top: 15};
    const saving = api.saveMobileLayout();
    assert.equal(requests.length, 1);
    assert.equal(requests[0].key, constants.LOCAL_FILEPOSITION);
    assert.equal(scrollCalls[0].protyle, state.mobile.editor.protyle);
    assert.equal(scrollCalls[0].force, true);
    assert.deepEqual(clone(requests[0].value), {
        document: {id: "visible-block", top: 42}, other: {id: "other-block", top: 15},
    });
    assert.equal(state.storage[constants.LOCAL_FILEPOSITION].document, controls.scroll);
    (controls.scroll as {top: number}).top = 100;
    state.mobile.editor = editor("other-box");
    assert.equal((clone(requests[0].value) as {document: {top: number}}).document.top, 42);
    succeed(requests[0]);
    assert.equal(await saving, true);
});

test("encrypted legacy layout capture removes its global position before persisting", async () => {
    const {api, state, requests, scrollCalls} = loadLayout();
    state.mobile.editor = editor("encrypted-box");
    const positions = state.storage[constants.LOCAL_FILEPOSITION];
    positions.document = {id: "secret-block", top: 80};
    positions.other = {id: "public-block", top: 15};
    const saving = api.saveMobileLayout();
    assert.equal(scrollCalls.length, 1);
    assert.equal(scrollCalls[0].force, true);
    assert.equal(Object.prototype.hasOwnProperty.call(positions, "document"), false);
    assert.equal(requests.length, 1);
    assert.deepEqual(clone(requests[0].value), {other: {id: "public-block", top: 15}});
    succeed(requests[0]);
    assert.equal(await saving, true);
});

test("legacy layout saves report consumed storage failures", async () => {
    const {api, state, requests} = loadLayout();
    state.mobile.editor = editor();
    const saving = api.saveMobileLayout();
    requests[0].resolve();
    assert.equal(await saving, false);
});

test("the aggregate deadline bounds a queued layout save without letting later writes overtake it", async () => {
    const {api, state, requests, advance, timers} = loadLayout(true);
    const first = api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, {revision: 1});
    const second = api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, {revision: 2});
    state.mobile.tabs = {save: () => api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, {revision: 3})};
    let settled = false;
    const layout = api.saveMobileLayout();
    void layout.then(() => { settled = true; });
    await advance(9999);
    assert.equal(settled, false);
    assert.equal(requests.length, 1);
    await advance(1);
    assert.equal(await first, false);
    assert.equal(await layout, false);
    assert.equal(requests[0].signal.aborted, true);
    assert.equal(requests.length, 2);
    assert.deepEqual(clone(requests[1].value), {revision: 2});
    const fourth = api.saveMobileStorage(constants.LOCAL_MOBILE_TABS, {revision: 4});
    await advance(10000);
    assert.equal(await second, false);
    assert.equal(requests.length, 3);
    assert.deepEqual(clone(requests[2].value), {revision: 3});
    succeed(requests[2]);
    await flush();
    assert.equal(requests.length, 4);
    assert.deepEqual(clone(requests[3].value), {revision: 4});
    succeed(requests[3]);
    assert.equal(await fourth, true);
    assert.equal(timers.size, 0);
});

test("an unresponsive tab saver is bounded by the layout deadline", async () => {
    const {api, state, advance, timers} = loadLayout();
    state.mobile.tabs = {save: () => new Promise<boolean>(() => {})};
    const saving = api.saveMobileLayout();
    await advance(10000);
    assert.equal(await saving, false);
    assert.equal(timers.size, 0);
});