An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作
TypeScript agentic-aiai-agentknowledge-baselocal-firstmarkdownmcpmindmapnote-takingself-hostedsiyuanworkspace
import {after, before, describe, it} from "node:test";
import * as assert from "node:assert/strict";
import {cancelSearchRequest, scheduleSearchRequest} from "./request";
const nextTimer = () => new Promise<void>((resolve) => {
setTimeout(resolve, 0);
});
const deferred = () => {
let resolve!: () => void;
const promise = new Promise<void>((promiseResolve) => {
resolve = promiseResolve;
});
return {
promise,
resolve: () => resolve(),
};
};
describe("search request scheduling", () => {
const windowDescriptor = Object.getOwnPropertyDescriptor(globalThis, "window");
before(() => {
Object.defineProperty(globalThis, "window", {
configurable: true,
value: {
clearTimeout,
setTimeout,
},
});
});
after(() => {
if (windowDescriptor) {
Object.defineProperty(globalThis, "window", windowDescriptor);
} else {
Reflect.deleteProperty(globalThis, "window");
}
});
it("runs one request at a time and invalidates stale responses", async () => {
const element = {isConnected: true} as Element;
const firstDone = deferred();
const firstStarted = deferred();
const secondStarted = deferred();
const idle = deferred();
let firstIsCurrent!: () => boolean;
let activeRequests = 0;
let maxActiveRequests = 0;
scheduleSearchRequest({
element,
delay: 0,
onIdle: idle.resolve,
createTask(version) {
return {
version,
run(_signal, isCurrent) {
firstIsCurrent = isCurrent;
activeRequests++;
maxActiveRequests = Math.max(maxActiveRequests, activeRequests);
firstStarted.resolve();
return firstDone.promise.finally(() => {
activeRequests--;
});
},
};
},
});
await firstStarted.promise;
scheduleSearchRequest({
element,
delay: 0,
onIdle: idle.resolve,
createTask(version) {
return {
version,
run() {
activeRequests++;
maxActiveRequests = Math.max(maxActiveRequests, activeRequests);
secondStarted.resolve();
activeRequests--;
},
};
},
});
await nextTimer();
assert.equal(firstIsCurrent(), false);
assert.equal(activeRequests, 1);
firstDone.resolve();
await secondStarted.promise;
await idle.promise;
assert.equal(maxActiveRequests, 1);
});
it("aborts a running search when a newer search is scheduled", async () => {
const element = {isConnected: true} as Element;
const firstStarted = deferred();
const secondStarted = deferred();
const idle = deferred();
let firstSignal!: AbortSignal;
scheduleSearchRequest({
element,
delay: 0,
onIdle: idle.resolve,
createTask(version) {
return {
version,
run(signal) {
firstSignal = signal;
firstStarted.resolve();
return new Promise<void>((resolve) => {
signal.addEventListener("abort", () => resolve(), {once: true});
});
},
};
},
});
await firstStarted.promise;
scheduleSearchRequest({
element,
delay: 0,
onIdle: idle.resolve,
createTask(version) {
return {
version,
run() {
secondStarted.resolve();
},
};
},
});
assert.equal(firstSignal.aborted, true);
await secondStarted.promise;
await idle.promise;
});
it("keeps non-cancelable backend searches serialized while invalidating their response", async () => {
const element = {isConnected: true} as Element;
const started = deferred();
const done = deferred();
const idle = deferred();
let signal: AbortSignal;
let isCurrent: () => boolean;
let nextRuns = 0;
scheduleSearchRequest({
element, delay: 0, onIdle: idle.resolve,
createTask: version => ({version, abortable: false, run(currentSignal, current) {
signal = currentSignal;
isCurrent = current;
started.resolve();
return done.promise;
}}),
});
await started.promise;
scheduleSearchRequest({
element, delay: 0, onIdle: idle.resolve,
createTask: version => ({version, run() { nextRuns++; }}),
});
await nextTimer();
assert.equal(signal.aborted, false);
assert.equal(isCurrent(), false);
assert.equal(nextRuns, 0);
done.resolve();
await idle.promise;
assert.equal(nextRuns, 1);
});
it("continues with the newest request after an aborted request rejects", async () => {
const element = {isConnected: true} as Element;
const started = deferred();
const idle = deferred();
let obsoleteRuns = 0;
let currentRuns = 0;
scheduleSearchRequest({
element, delay: 0, onIdle: idle.resolve,
createTask: version => ({version, run(signal) {
started.resolve();
return new Promise<void>((_resolve, reject) => {
signal.addEventListener("abort", () => reject(new DOMException("Aborted", "AbortError")), {once: true});
});
}}),
});
await started.promise;
scheduleSearchRequest({
element, delay: 10, onIdle: idle.resolve,
createTask: version => ({version, run() { obsoleteRuns++; }}),
});
scheduleSearchRequest({
element, delay: 0, onIdle: idle.resolve,
createTask: version => ({version, run(_signal, isCurrent) {
assert.equal(isCurrent(), true);
currentRuns++;
}}),
});
await idle.promise;
assert.equal(obsoleteRuns, 0);
assert.equal(currentRuns, 1);
});
it("does not dispatch a search after its scope is disconnected", async () => {
const element = {isConnected: true} as Element;
let runs = 0;
scheduleSearchRequest({
element, delay: 0, onIdle() { /* 已销毁的作用域无需更新 */ },
createTask: version => ({version, run() { runs++; }}),
});
Object.assign(element, {isConnected: false});
await nextTimer();
assert.equal(runs, 0);
cancelSearchRequest(element);
});
it("aborts the active request and drops the queued request when canceled", async () => {
const element = {isConnected: true} as Element;
const firstStarted = deferred();
const firstDone = deferred();
let firstSignal!: AbortSignal;
let secondStarted = false;
scheduleSearchRequest({
element,
delay: 0,
onIdle() {
// 搜索作用域销毁后无需更新界面
},
createTask(version) {
return {
version,
run(signal) {
firstSignal = signal;
firstStarted.resolve();
// 保持旧请求未结束,让新任务真正排队后再销毁作用域。
return firstDone.promise;
},
};
},
});
await firstStarted.promise;
scheduleSearchRequest({
element,
delay: 0,
onIdle() {
// 搜索作用域销毁后无需更新界面
},
createTask(version) {
return {
version,
run() {
secondStarted = true;
},
};
},
});
await nextTimer();
cancelSearchRequest(element);
firstDone.resolve();
await nextTimer();
assert.equal(firstSignal.aborted, true);
assert.equal(secondStarted, false);
});
});