dsh-sansheng-liubu/workbench/panel/test/client.test.mjs

669 lines
26 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import test from "node:test";
import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import { fileURLToPath } from "node:url";
import vm from "node:vm";
const CLIENT_PATH = fileURLToPath(new URL("../lib/client.js", import.meta.url));
const SOURCE = readFileSync(CLIENT_PATH, "utf8");
function createStorage(initial) {
const map = new Map(Object.entries(initial || {}));
return {
getItem(key) {
return map.has(key) ? map.get(key) : null;
},
setItem(key, value) {
map.set(key, String(value));
},
removeItem(key) {
map.delete(key);
},
};
}
function createReact() {
function createElement(type, props) {
const children = Array.prototype.slice.call(arguments, 2);
return { type: type, props: props || {}, children: children };
}
class Component {
constructor(props) {
this.props = props;
this.state = {};
}
}
return {
createElement: createElement,
Component: Component,
useState: function (initial) {
return [initial, function () {}];
},
useRef: function (initial) {
return { current: initial };
},
useEffect: function () {},
useCallback: function (fn) {
return fn;
},
useMemo: function (fn) {
return fn();
},
useContext: function () {
return null;
},
createContext: function (value) {
return { _value: value };
},
Fragment: "Fragment",
};
}
function createDocument() {
const appended = [];
return {
appended: appended,
hidden: false,
head: {
appendChild: function (node) {
appended.push(node);
},
},
body: {},
querySelector: function () {
return null;
},
createElement: function (tagName) {
return {
tagName: tagName,
dataset: {},
textContent: "",
appendChild: function () {},
setAttribute: function () {},
};
},
addEventListener: function () {},
removeEventListener: function () {},
};
}
function loadPlugin(options) {
options = options || {};
const storage = createStorage(options.storage);
const document = createDocument();
const react = createReact();
let definition = null;
const window = {
__ModuleLoader__: {
load: function (loaded) {
definition = loaded;
},
},
};
const sandbox = {
window: window,
document: document,
console: console,
URL: URL,
Map: Map,
Set: Set,
WeakMap: WeakMap,
Promise: Promise,
setTimeout: setTimeout,
clearTimeout: clearTimeout,
localStorage: storage,
Symbol: Symbol,
};
vm.runInNewContext(SOURCE, sandbox, { filename: CLIENT_PATH });
assert.ok(definition, "bundle 应该调用 window.__ModuleLoader__.load");
assert.equal(definition.id, "dsh-sansheng-liubu-mode", "bundle id 必须是主包包名(面板已并回主包)");
const exports = definition.factory(function (id) {
if (id === "react") return react;
throw new Error("unexpected require: " + id);
});
return { exports: exports, react: react, storage: storage, document: document, definition: definition };
}
function createCtx(options) {
options = options || {};
const registrations = [];
const injections = [];
const tabs = [];
const effects = [];
const ctx = {
slots: {
inject: function (name, factory) {
injections.push(name);
const value = factory();
if (value !== undefined) registrations.push(value);
return function () {};
},
register: function (spec, component) {
const registration = { spec: spec, component: component };
registrations.push(registration);
return registration;
},
},
effect: function (factory, label) {
effects.push(label);
const value = factory();
return typeof value === "function" ? value : function () {};
},
get: function (name) {
return options.services ? options.services[name] : undefined;
},
uiWorkspace: {
currentWorkspaceId: options.workspaceId || "ws-1",
openSession: function () {},
},
};
if (!options.noTabs) {
ctx.sidebarRightTabs = {
register: function (spec) {
tabs.push(spec);
return function () {};
},
};
}
return { ctx: ctx, registrations: registrations, injections: injections, tabs: tabs, effects: effects };
}
test("bundle 契约:id、inject 与纯函数导出", function () {
const plugin = loadPlugin();
const api = plugin.exports;
assert.deepEqual(Array.from(api.inject), ["slots", "sessions", "workspaces", "uiWorkspace", "uiConversation"]);
assert.equal(typeof api.apply, "function");
assert.equal(typeof api.WorkbenchRail, "function");
assert.equal(typeof api.__test, "object");
const expected = ["computeRailLayout", "statusOf", "mergeEvents", "apiPath", "pickProjectId", "workspaceIdOf", "formatModelLine", "ROLE_META"];
for (const key of expected) assert.ok(key in api.__test, "__test 缺少 " + key);
assert.equal(Object.keys(api.__test.ROLE_META).length, 10);
assert.deepEqual(Object.keys(api.__test.ROLE_META).slice(0, 4), ["lead", "zhongshu", "shangshu", "menxia"]);
});
test("computeRailLayout:丞相跨三列居中、三省一列、六部 3×2", function () {
const layout = loadPlugin().exports.__test.computeRailLayout(400);
assert.equal(layout.width, 400);
assert.equal(layout.nodes.length, 10);
const byId = {};
for (const node of layout.nodes) {
assert.equal(typeof node.id, "string");
assert.equal(typeof node.x, "number");
assert.equal(typeof node.y, "number");
assert.equal(typeof node.col, "number");
assert.equal(typeof node.row, "number");
byId[node.id] = node;
}
const lead = byId.lead;
assert.equal(lead.col, 1);
assert.equal(lead.span, 3);
assert.ok(Math.abs(lead.x + lead.w / 2 - 200) < 0.001, "丞相应水平居中");
assert.ok(Math.abs(lead.x - (400 - lead.w) / 2) < 0.001);
const san = ["zhongshu", "shangshu", "menxia"].map((id) => byId[id]);
assert.deepEqual(Array.from(san, (node) => node.col), [0, 1, 2]);
assert.deepEqual(Array.from(san, (node) => node.row), [1, 1, 1]);
assert.equal(new Set(Array.from(san, (node) => node.y)).size, 1, "三省应在同一行");
assert.ok(san[0].x < san[1].x && san[1].x < san[2].x, "三省 x 必须递增");
const six = layout.nodes.filter((node) => node.row >= 2);
assert.equal(six.length, 6);
assert.deepEqual(Array.from(six, (node) => node.id), ["libu", "hubu", "lipu", "bingbu", "xingbu", "gongbu"]);
assert.equal(six[5].id, "gongbu", "第 6 个是工部");
assert.deepEqual(Array.from(six, (node) => node.col), [0, 1, 2, 0, 1, 2]);
assert.deepEqual(Array.from(six, (node) => node.row), [2, 2, 2, 3, 3, 3]);
assert.ok(layout.groups.ministries.y > layout.groups.sansheng.y + layout.groups.sansheng.h);
assert.ok(layout.height > 0);
});
test("computeRailLayout:窄栏仍是三列且不出现负宽度", function () {
const layout = loadPlugin().exports.__test.computeRailLayout(340);
assert.equal(layout.nodes.length, 10);
assert.equal(new Set(Array.from(layout.nodes, (node) => node.col)).size, 3);
for (const node of layout.nodes) assert.ok(node.w > 0, node.id + " 宽度必须为正");
assert.ok(layout.leadWidth <= 184);
});
test("statusOf:六种部门状态与未知值兜底", function () {
const { statusOf } = loadPlugin().exports.__test;
assert.equal(statusOf("uninitialized"), "未接通");
assert.equal(statusOf("idle"), "空闲");
assert.equal(statusOf("queued"), "排队");
assert.equal(statusOf("running"), "正在运行");
assert.equal(statusOf("unavailable"), "不可用");
assert.equal(statusOf("needs_attention"), "需人处理");
assert.equal(statusOf("something-new"), "未知");
assert.equal(statusOf(null), "未接通");
assert.equal(statusOf(""), "未接通");
});
test("mergeEvents:按 eventId 去重、按 seq 升序、忽略乱序重复", function () {
const { mergeEvents } = loadPlugin().exports.__test;
const merged = mergeEvents(
[{ eventId: "a", seq: 3 }, { eventId: "b", seq: 1 }],
[{ eventId: "b", seq: 1 }, { eventId: "c", seq: 2 }, { eventId: "a", seq: 3 }],
);
assert.equal(merged.length, 3);
assert.deepEqual(Array.from(merged, (event) => event.eventId), ["b", "c", "a"]);
assert.deepEqual(Array.from(merged, (event) => event.seq), [1, 2, 3]);
const again = mergeEvents(merged, []);
assert.deepEqual(Array.from(again, (event) => event.eventId), ["b", "c", "a"]);
assert.deepEqual(Array.from(mergeEvents([], [])), []);
});
test("formatModelLine:无配置跟随宿主,有配置拼 provider/model · effort", function () {
const { formatModelLine } = loadPlugin().exports.__test;
assert.equal(formatModelLine(null), "跟随宿主");
assert.equal(formatModelLine(undefined), "跟随宿主");
assert.equal(formatModelLine({}), "跟随宿主");
assert.equal(formatModelLine({ provider: "", model: "" }), "跟随宿主");
assert.equal(formatModelLine({ provider: "deepseek", model: "", reasoningEffort: "high" }), "跟随宿主");
assert.equal(formatModelLine({ provider: "deepseek", model: "deepseek-v4", reasoningEffort: "high" }), "deepseek/deepseek-v4 · 高");
assert.equal(formatModelLine({ provider: "deepseek", model: "deepseek-v4" }), "deepseek/deepseek-v4");
assert.equal(formatModelLine({ provider: "deepseek", model: "deepseek-v4", reasoningEffort: "custom" }), "deepseek/deepseek-v4 · custom");
// model 自带 provider 前缀时只留最后一段,完整路径放 title。
assert.equal(
formatModelLine({ provider: "magpie", model: "workbuddy/deepseek-v4", reasoningEffort: "high" }),
"deepseek-v4 · 高",
);
});
test("seatDisplayName:name 与 short 同时存在时必须用完整名", function () {
const { seatDisplayName, modelTitle } = loadPlugin().exports.__test;
assert.equal(seatDisplayName({ roleId: "lead", name: "丞相", short: "丞" }), "丞相");
assert.equal(seatDisplayName({ roleId: "zhongshu", name: "中书", short: "中" }), "中书");
assert.equal(seatDisplayName({ roleId: "lead" }), "丞相", "缺 name 时回落到 ROLE_META 的完整名");
assert.equal(seatDisplayName({ roleId: "lead", short: "丞" }), "丞相", "short 不能优先于 ROLE_META 的完整名");
assert.equal(seatDisplayName({ name: "", roleId: "unknown" }), "unknown");
assert.equal(modelTitle(null), "跟随宿主(未单独配置模型)");
assert.equal(
modelTitle({ provider: "magpie", model: "workbuddy/deepseek-v4", reasoningEffort: "high" }),
"magpie/workbuddy/deepseek-v4 · 高",
);
});
test("wirePathsFromLayout:量不到 DOM 时仍能生成三支 + 主干连线", function () {
const { computeRailLayout, wirePathsFromLayout } = loadPlugin().exports.__test;
const layout = computeRailLayout(400);
const paths = wirePathsFromLayout(layout);
assert.equal(paths.length, 4, "三省三支 + 尚书到六部一条主干");
const branch = paths.filter((item) => item.kind === "branch");
const trunk = paths.filter((item) => item.kind === "trunk");
assert.equal(branch.length, 3);
assert.equal(trunk.length, 1);
assert.deepEqual(Array.from(branch).map((item) => item.key), ["lead-zhongshu", "lead-shangshu", "lead-menxia"]);
for (const item of branch) {
const id = item.key.replace(/^lead-/, "");
const card = layout.sansheng.find((node) => node.id === id);
assert.ok(item.d.includes(" C "), "分支必须用三次贝塞尔收口,垂直进入卡片顶边");
assert.ok(!item.d.includes(" Q "), "不要退回二次贝塞尔(会在卡片顶边上方擦成一条横线)");
const tail = item.d.match(/ C [0-9.]+ [0-9.]+ [0-9.]+ [0-9.]+ ([0-9.]+) ([0-9.]+)$/);
assert.ok(tail, "分支末尾应是第二个控制点 + 终点");
assert.ok(Math.abs(Number(tail[1]) - card.cx) < 0.06, "终点 x 应等于卡片顶边中点");
assert.equal(Number(tail[2]), card.y, "终点 y 应落在卡片顶边");
}
const shangshu = layout.sansheng.find((node) => node.id === "shangshu");
assert.equal(trunk[0].d, "M 200 " + (shangshu.y + shangshu.h) + " L 200 " + layout.groups.ministries.y);
});
test("apiPath:拼出同源工作台路径并编码查询串", function () {
const { apiPath } = loadPlugin().exports.__test;
assert.equal(apiPath("bootstrap"), "/sansheng/workbench/bootstrap");
assert.equal(apiPath("/connect"), "/sansheng/workbench/connect");
assert.equal(apiPath("events", { projectId: "p-1", since: 7 }), "/sansheng/workbench/events?projectId=p-1&since=7");
assert.equal(apiPath("events", { projectId: "p 1", since: undefined }), "/sansheng/workbench/events?projectId=p%201");
assert.equal(apiPath("bootstrap", {}), "/sansheng/workbench/bootstrap");
});
test("pickProjectId:只按明确的 hostWorkspaceId 匹配,缺省不再退回首项目", function () {
const { pickProjectId } = loadPlugin().exports.__test;
const data = {
projectId: "p-default",
projects: [
{ id: "p-other", hostWorkspaceId: "ws-other" },
{ id: "p-mine", hostWorkspaceId: "ws-mine" },
],
};
assert.equal(pickProjectId(data, "ws-mine"), "p-mine");
assert.equal(pickProjectId(data, "ws-missing"), null);
assert.equal(pickProjectId(data), null, "没有工作区身份时不能回退到默认项目");
assert.equal(pickProjectId(data, ""), null);
assert.equal(pickProjectId({ projects: [{ id: "p-only" }] }, "ws-only"), null);
assert.equal(pickProjectId({ projects: [] }, "ws-x"), null);
});
test("workspaceIdOf:从当前 mainView 会话反查工作区,绝不猜第一个", function () {
const { workspaceIdOf } = loadPlugin().exports.__test;
const sessions = {
list: {
getSnapshot: () => ({
byId: {
"s-1": { id: "s-1", retainedBy: { mainView: 1 } },
"s-2": { id: "s-2", retainedBy: {} },
},
}),
},
};
const workspaces = {
list: {
getSnapshot: () => ({
items: [
{ workspaceId: "ws-first", sessionIds: ["s-2"] },
{ workspaceId: "ws-current", sessionIds: ["s-1"] },
],
}),
},
};
const ctx = {
get(name) {
if (name === "sessions") return sessions;
if (name === "workspaces") return workspaces;
return undefined;
},
};
assert.equal(workspaceIdOf(ctx), "ws-current");
// 没有 mainView 会话时返回 null,绝不拿列表第一项。
const noSelection = {
get(name) {
if (name === "sessions") return { list: { getSnapshot: () => ({ byId: {} }) } };
if (name === "workspaces") return workspaces;
return undefined;
},
};
assert.equal(workspaceIdOf(noSelection), null);
});
test("apply:注册朝堂页签、pane 槽与 priority -1 的 main.conversation", function () {
const plugin = loadPlugin();
const mock = createCtx();
plugin.exports.apply(mock.ctx);
assert.ok(mock.injections.includes("sidebar.right.pane.tab"));
assert.ok(mock.injections.includes("sidebar.right.pane.tab.title"));
assert.ok(mock.injections.includes("main.conversation"));
assert.equal(mock.tabs.length, 1);
assert.equal(mock.tabs[0].id, "sansheng-liubu-workbench");
assert.equal(mock.tabs[0].priority, "builtin");
assert.equal(mock.tabs[0].title(), "朝堂");
assert.ok(Array.isArray(mock.tabs[0].guide) && mock.tabs[0].guide.length === 1, "原生降级必须带 guide 入口");
assert.equal(mock.tabs[0].guide[0].id, "sansheng-liubu-workbench");
assert.equal(mock.tabs[0].guide[0].title(), "朝堂");
assert.equal(typeof mock.tabs[0].guide[0].description(), "string");
const main = mock.registrations.find((entry) => entry.spec && entry.spec.name === "main.conversation");
assert.ok(main, "必须注册 main.conversation");
assert.equal(main.spec.priority, -1);
assert.deepEqual(Array.from(Object.keys(main.spec.children)), ["conversation.header"]);
});
test("apply:服务晚到与重挂时只保留一个朝堂入口,先清理旧注册", function () {
const plugin = loadPlugin();
const registered = [];
const disposed = [];
const watchers = new Map();
const ctx = {
slots: {
inject: function () {},
register: function (spec) { return { spec: spec } },
},
effect: function (factory) {
const value = factory();
return typeof value === "function" ? value : function () {};
},
get: function () { return undefined; },
inject: function (names, callback) {
watchers.set(names[0], { callback: callback, cleanup: null });
return function () {};
},
};
plugin.exports.apply(ctx);
assert.equal(registered.length, 0, "服务未就绪时不能假装注册");
const better = {
registerTab: function (spec) {
registered.push({ kind: "better", spec: spec });
return function () { disposed.push("better"); };
},
};
const native = {
register: function (spec) {
registered.push({ kind: "native", spec: spec });
return function () { disposed.push("native"); };
},
};
const betterWatcher = watchers.get("betterSidebar");
betterWatcher.cleanup = betterWatcher.callback({ get: function () { return better; } });
assert.equal(registered.length, 1);
assert.equal(registered[0].kind, "better");
const nativeWatcher = watchers.get("sidebarRightTabs");
nativeWatcher.cleanup = nativeWatcher.callback({ get: function () { return native; } });
assert.equal(registered.length, 1, "betterSidebar 在场时不能重复注册原生入口");
betterWatcher.cleanup();
assert.equal(registered.length, 2, "betterSidebar 卸载后应补注册原生入口");
assert.equal(registered[1].kind, "native");
betterWatcher.cleanup = betterWatcher.callback({ get: function () { return better; } });
assert.equal(registered.length, 3, "betterSidebar 重挂后应重新注册 better 入口");
assert.equal(registered[2].kind, "better");
assert.ok(disposed.includes("native"), "切回 better 前必须先释放原生注册");
});
test("apply:localStorage 逃生开关 sansheng.workbench.main=off 时不接管主区", function () {
const plugin = loadPlugin({ storage: { "sansheng.workbench.main": "off" } });
const mock = createCtx();
plugin.exports.apply(mock.ctx);
assert.equal(mock.injections.includes("main.conversation"), false);
assert.ok(mock.injections.includes("sidebar.right.pane.tab"));
});
test("main.conversation:非绑定会话只透传原生 header/content,不加右栏", function () {
const plugin = loadPlugin();
const mock = createCtx();
plugin.exports.apply(mock.ctx);
const main = mock.registrations.find((entry) => entry.spec && entry.spec.name === "main.conversation");
const tree = main.component({
sessionId: "session-1",
useSession: function () {
return { openState: "open", blank: true, running: false, promptAttempted: false };
},
useSessions: function (select) {
return select({ byId: { "session-1": { blank: true } } });
},
useConversation: function () {
return { activeTargets: new Set() };
},
renderSlot: function (name) {
return { type: "header-slot", name: name };
},
renderFactorySlot: function (name, params) {
return { type: "content-slot", name: name, params: params };
},
widthControls: { width: 900 },
});
assert.equal(tree.props.className, "wb-main-native");
const children = tree.children[0];
assert.equal(children[0].type, "header-slot");
assert.equal(children[1].type, "content-slot");
assert.equal(children[1].params.phase, "hero");
assert.deepEqual(children[1].params.hero, true);
assert.ok(!JSON.stringify(tree).includes("wb-main-rail"), "非工作台会话不能出现右栏");
});
test("WorkbenchRail:无数据时也渲染完整骨架与三个内部页签", function () {
const plugin = loadPlugin();
const mock = createCtx();
const tree = plugin.exports.WorkbenchRail({ ctx: mock.ctx, compact: true });
assert.ok(tree.props.className.includes("wb-rail"));
assert.ok(tree.props.className.includes("is-compact"));
const serialized = JSON.stringify(tree);
assert.ok(serialized.includes("三省六部"));
assert.ok(serialized.includes("朝堂"));
assert.ok(serialized.includes("任务"));
assert.ok(serialized.includes("成果"));
assert.ok(serialized.includes("十席 · 0 席已接通"));
assert.ok(serialized.includes("六部 · 同级"));
assert.ok(serialized.includes("正在读取") === false);
});
test("main.conversation:接管逻辑抛错时回退原生会话,不白屏", function () {
const plugin = loadPlugin();
const mock = createCtx();
plugin.exports.apply(mock.ctx);
const main = mock.registrations.find((entry) => entry.spec && entry.spec.name === "main.conversation");
const warnings = [];
const originalWarn = console.warn;
console.warn = function () {
warnings.push(Array.from(arguments));
};
try {
const tree = main.component({
sessionId: "session-1",
useSession: function () {
// 模拟接管逻辑在渲染途中抛异常(理论上不应发生,但必须兜住)。
throw new Error("boom");
},
useSessions: function () {
return undefined;
},
useConversation: function () {
return { activeTargets: new Set() };
},
renderSlot: function (name) {
return { type: "header-slot", name: name };
},
renderFactorySlot: function (name, params) {
return { type: "content-slot", name: name, params: params };
},
});
assert.equal(tree.props.className, "wb-main-native");
assert.equal(tree.children[0][0].type, "header-slot");
assert.equal(tree.children[0][1].type, "content-slot");
assert.ok(!JSON.stringify(tree).includes("wb-main-split"), "回退时不能拼右栏");
assert.ok(!JSON.stringify(tree).includes("wb-main-resizer"), "回退时不能拼分隔条");
assert.ok(
warnings.some((args) => String(args[0]).includes("接管失败")),
"回退时要留下可诊断的 console.warn",
);
} finally {
console.warn = originalWarn;
}
});
test("existenceLabel:missing / unknown / ok 三态,unknown 不能被当成正常", function () {
const plugin = loadPlugin();
const { existenceLabel } = plugin.exports.__test;
assert.equal(existenceLabel("missing"), "文件已失效");
assert.equal(existenceLabel("unknown"), "位置未核验");
assert.equal(existenceLabel("ok"), "");
assert.equal(existenceLabel(undefined), "");
assert.notEqual(existenceLabel("unknown"), "");
assert.ok(!existenceLabel("unknown").includes("正常"), "unknown 不能显示成正常");
assert.ok(!existenceLabel("ok").includes("正常"), "ok 也不必写正常,静默即可");
});
test("verificationLabel:英文枚举翻成中文,别和「文件已失效」读成自相矛盾", function () {
const plugin = loadPlugin();
const { verificationLabel } = plugin.exports.__test;
assert.equal(verificationLabel("verified"), "已核验");
assert.equal(verificationLabel("unverified"), "未核验");
assert.equal(verificationLabel("rejected"), "未通过");
assert.equal(verificationLabel(undefined), "核验未知");
// 「已核验」说的是结果被核验过,不是文件还在——不能出现「存在」「有效」这类字眼。
assert.ok(!/存在|有效/.test(verificationLabel("verified")));
});
test("revisionLabel:第 N 版,只有真正修订且 N>1 才写「修订自上一版」", function () {
const plugin = loadPlugin();
const { revisionLabel } = plugin.exports.__test;
assert.equal(revisionLabel({ revision: 1, revisesArtifactId: "art-0" }), "第 1 版");
assert.ok(!revisionLabel({ revision: 1, revisesArtifactId: "art-0" }).includes("修订自"));
assert.equal(revisionLabel({ revision: 2, revisesArtifactId: "art-0" }), "第 2 版 · 修订自上一版");
assert.equal(revisionLabel({ revision: 3, revisesArtifactId: null }), "第 3 版");
assert.equal(revisionLabel({}), "第 1 版");
assert.equal(revisionLabel(null), "第 1 版");
});
test("taskKindLabel:只给 kind=revision 加「修订」标签", function () {
const plugin = loadPlugin();
const { taskKindLabel } = plugin.exports.__test;
assert.equal(taskKindLabel({ kind: "revision" }), "修订");
assert.equal(taskKindLabel({ kind: "normal" }), "");
assert.equal(taskKindLabel({}), "");
assert.equal(taskKindLabel(null), "");
});
test("A27 分隔条键盘:方向键 / Shift / Home / End 有确定步长,其它键不动", function () {
const { railResizeTarget } = loadPlugin().exports.__test;
// 默认 16px 一档,Shift 加速到 64px。
assert.equal(railResizeTarget("ArrowLeft", { width: 400 }), 384);
assert.equal(railResizeTarget("ArrowRight", { width: 400 }), 416);
assert.equal(railResizeTarget("ArrowRight", { width: 400, shift: true }), 464);
assert.equal(railResizeTarget("ArrowLeft", { width: 400, shift: true }), 340); // 400-64 撞下限 340
// 两端截断,不会跑出 340–600。
assert.equal(railResizeTarget("Home", { width: 500 }), 340);
assert.equal(railResizeTarget("End", { width: 500 }), 600);
assert.equal(railResizeTarget("ArrowLeft", { width: 340 }), 340);
assert.equal(railResizeTarget("ArrowRight", { width: 600 }), 600);
assert.equal(railResizeTarget("ArrowRight", { width: 595, shift: true }), 600);
// 不认识的键返回 null:调用方不能 preventDefault,浏览器的默认行为要保留。
assert.equal(railResizeTarget("Tab", { width: 400 }), null);
assert.equal(railResizeTarget("Enter", { width: 400 }), null);
assert.equal(railResizeTarget(undefined, { width: 400 }), null);
});
test("任务行动作:草稿可派工、排队可派可取消、终态不给按钮", () => {
const { taskActionKeys } = loadPlugin().exports.__test;
// 草稿只是记在账本里,还没进部门队列,只能派工。
assert.equal(taskActionKeys({ status: "draft" }).join(","), 'dispatch');
// 排队:既能补派(幂等键会去重),也能取消。
assert.equal(taskActionKeys({ status: "queued" }).join(","), 'dispatch,cancel');
// 正在跑 / 需人处理:只能取消,不再重复派。
assert.equal(taskActionKeys({ status: "running" }).join(","), 'cancel');
assert.equal(taskActionKeys({ status: "needs_attention" }).join(","), 'cancel');
// 终态不给动作:避免对已完成任务再派一次。
assert.equal(taskActionKeys({ status: "completed" }).join(","), '');
assert.equal(taskActionKeys({ status: "cancelled" }).join(","), '');
assert.equal(taskActionKeys({ status: "failed" }).join(","), '');
assert.equal(taskActionKeys(null).join(","), '');
});