mirror of
https://github.com/hansjone/dsh-im-ops.git
synced 2026-10-09 06:30:45 +08:00
665 lines
22 KiB
JavaScript
665 lines
22 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import * as React from 'react';
|
|
import TestRenderer from 'react-test-renderer';
|
|
|
|
import {
|
|
WorkspaceDirectoryPickerContext,
|
|
WorkspaceEditor,
|
|
} from '../plugin-src/client/workspace-editor.js';
|
|
import { DiscordSettingsTab } from '../plugin-src/client/channels/discord/index.js';
|
|
import { en, setImTranslator } from '../plugin-src/client/i18n.js';
|
|
|
|
const { act, create } = TestRenderer;
|
|
|
|
function deferred() {
|
|
let resolve;
|
|
const promise = new Promise((onResolve) => { resolve = onResolve; });
|
|
return { promise, resolve };
|
|
}
|
|
|
|
async function flushMicrotasks() {
|
|
for (let index = 0; index < 6; index += 1) await Promise.resolve();
|
|
}
|
|
|
|
function directoryListing(path, childNames = [], { home = '/workspace', truncated = false } = {}) {
|
|
let cursor = '';
|
|
const crumbs = [{ name: '/', path: '/', hidden: false }];
|
|
for (const name of path.split('/').filter(Boolean)) {
|
|
cursor += `/${name}`;
|
|
crumbs.push({ name, path: cursor, hidden: false });
|
|
}
|
|
return {
|
|
path,
|
|
home,
|
|
crumbs,
|
|
entries: childNames.map((name) => ({
|
|
name,
|
|
path: `${path === '/' ? '' : path}/${name}`,
|
|
hidden: name.startsWith('.'),
|
|
})),
|
|
truncated,
|
|
};
|
|
}
|
|
|
|
function nativeUnavailable() {
|
|
const error = new Error('Directory browsing is unavailable');
|
|
error.rpcError = {
|
|
code: 'directory-picker-unavailable',
|
|
message: error.message,
|
|
details: { capability: 'native' },
|
|
};
|
|
return error;
|
|
}
|
|
|
|
function nativeDirectoryPicker(selected) {
|
|
const calls = { list: 0, pick: 0 };
|
|
return {
|
|
calls,
|
|
async listDirectory() {
|
|
calls.list += 1;
|
|
throw nativeUnavailable();
|
|
},
|
|
async pickDirectory() {
|
|
calls.pick += 1;
|
|
return selected;
|
|
},
|
|
};
|
|
}
|
|
|
|
function withDirectoryPicker(element, picker) {
|
|
return React.createElement(
|
|
WorkspaceDirectoryPickerContext.Provider,
|
|
{ value: picker },
|
|
element,
|
|
);
|
|
}
|
|
|
|
function textOf(node) {
|
|
if (typeof node === 'string' || typeof node === 'number') return String(node);
|
|
return node?.children?.map(textOf).join('') ?? '';
|
|
}
|
|
|
|
function buttonNamed(root, name) {
|
|
return root.findAllByType('button').find((button) => textOf(button) === name);
|
|
}
|
|
|
|
function discordSnapshot(workspace) {
|
|
return {
|
|
revision: 1,
|
|
bots: [{
|
|
botId: 'discord_test',
|
|
connected: true,
|
|
state: 'connected',
|
|
workspace,
|
|
bot: { name: 'Harness Bot', username: 'HarnessBot', idMasked: '123•••' },
|
|
health: { summary: 'Discord Gateway 长连接运行正常', lastCheckedAt: Date.now() },
|
|
error: null,
|
|
}],
|
|
};
|
|
}
|
|
|
|
function twoBotDiscordSnapshot(firstWorkspace) {
|
|
const first = discordSnapshot(firstWorkspace).bots[0];
|
|
return {
|
|
revision: 1,
|
|
bots: [
|
|
{ ...first, botId: 'discord_first', bot: { ...first.bot, name: 'First Bot' } },
|
|
{
|
|
...first,
|
|
botId: 'discord_second',
|
|
workspace: '/workspace/second',
|
|
bot: { ...first.bot, name: 'Second Bot' },
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
test('WorkspaceEditor browses from the current path and saves the selected directory', async () => {
|
|
const saved = [];
|
|
const listed = [];
|
|
const picker = {
|
|
async listDirectory(path) {
|
|
listed.push(path);
|
|
if (path === '/workspace/current') {
|
|
return directoryListing(path, ['next project', '.hidden']);
|
|
}
|
|
if (path === '/workspace/current/next project') return directoryListing(path);
|
|
throw new Error(`Unexpected directory: ${path}`);
|
|
},
|
|
async pickDirectory() { throw new Error('native picker should not run'); },
|
|
};
|
|
function Fixture() {
|
|
const [workspace, setWorkspace] = React.useState('/workspace/current');
|
|
return React.createElement(WorkspaceEditor, {
|
|
workspace,
|
|
directoryPicker: picker,
|
|
async onSave(value) {
|
|
saved.push(value);
|
|
setWorkspace(value);
|
|
},
|
|
});
|
|
}
|
|
|
|
const bodyNode = { scrollTop: 0 };
|
|
let renderer;
|
|
await act(async () => {
|
|
renderer = create(React.createElement(Fixture), {
|
|
createNodeMock(element) {
|
|
if (element.props?.className === 'dim-directoryPickerBody') return bodyNode;
|
|
return {};
|
|
},
|
|
});
|
|
});
|
|
assert.equal(renderer.root.findByType('code').props.title, '/workspace/current');
|
|
|
|
await act(async () => {
|
|
renderer.root.findByProps({ className: 'dim-workspaceEdit' }).props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
const dialog = renderer.root.findByProps({ role: 'dialog' });
|
|
assert.equal(dialog.props['aria-modal'], 'true');
|
|
assert.equal(
|
|
textOf(renderer.root.findByProps({ id: dialog.props['aria-describedby'] })),
|
|
'切换后会清除这个机器人的旧会话映射。',
|
|
);
|
|
assert.equal(renderer.root.findAllByProps({ title: '/workspace/current/.hidden' }).length, 0);
|
|
bodyNode.scrollTop = 240;
|
|
await act(async () => {
|
|
renderer.root.findByProps({ title: '/workspace/current/next project' }).props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
await act(async () => {
|
|
renderer.root.findByProps({ className: 'dim-directoryPickerPrimary' }).props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
|
|
assert.deepEqual(listed, ['/workspace/current', '/workspace/current/next project']);
|
|
assert.equal(bodyNode.scrollTop, 0);
|
|
assert.deepEqual(saved, ['/workspace/current/next project']);
|
|
assert.equal(renderer.root.findByType('code').props.title, '/workspace/current/next project');
|
|
});
|
|
|
|
test('WorkspaceEditor keeps the picker open and presents a rejected workspace error', async () => {
|
|
const picker = {
|
|
async listDirectory(path) {
|
|
return path === '/workspace/current'
|
|
? directoryListing(path, ['missing'])
|
|
: directoryListing(path);
|
|
},
|
|
};
|
|
let renderer;
|
|
await act(async () => {
|
|
renderer = create(React.createElement(WorkspaceEditor, {
|
|
workspace: '/workspace/current',
|
|
directoryPicker: picker,
|
|
async onSave() {
|
|
const error = new Error('工作区路径不存在。');
|
|
error.code = 'workspace-not-found';
|
|
throw error;
|
|
},
|
|
}));
|
|
});
|
|
await act(async () => {
|
|
renderer.root.findByProps({ className: 'dim-workspaceEdit' }).props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
await act(async () => {
|
|
renderer.root.findByProps({ title: '/workspace/current/missing' }).props.onClick();
|
|
await flushMicrotasks();
|
|
renderer.root.findByProps({ className: 'dim-directoryPickerPrimary' }).props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
|
|
assert.equal(textOf(renderer.root.findByProps({ role: 'alert' })), '工作区路径不存在。');
|
|
assert.equal(renderer.root.findByProps({ role: 'dialog' }).props['aria-modal'], 'true');
|
|
assert.equal(renderer.root.findByType('code').props.title, '/workspace/current');
|
|
});
|
|
|
|
test('WorkspaceEditor closes without saving when the current directory is selected', async () => {
|
|
let saves = 0;
|
|
const picker = { async listDirectory(path) { return directoryListing(path); } };
|
|
let renderer;
|
|
await act(async () => {
|
|
renderer = create(React.createElement(WorkspaceEditor, {
|
|
workspace: '/workspace/current',
|
|
directoryPicker: picker,
|
|
async onSave() { saves += 1; },
|
|
}));
|
|
});
|
|
await act(async () => {
|
|
renderer.root.findByProps({ className: 'dim-workspaceEdit' }).props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
await act(async () => {
|
|
renderer.root.findByProps({ className: 'dim-directoryPickerPrimary' }).props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
|
|
assert.equal(saves, 0);
|
|
assert.equal(renderer.root.findAllByProps({ role: 'dialog' }).length, 0);
|
|
});
|
|
|
|
test('WorkspaceEditor falls back to one native picker without restarting after save', async () => {
|
|
const saved = [];
|
|
const picker = nativeDirectoryPicker('/workspace/native');
|
|
function Fixture() {
|
|
const [workspace, setWorkspace] = React.useState('/workspace/current');
|
|
return React.createElement(WorkspaceEditor, {
|
|
workspace,
|
|
directoryPicker: picker,
|
|
async onSave(value) {
|
|
saved.push(value);
|
|
setWorkspace(value);
|
|
},
|
|
});
|
|
}
|
|
|
|
let renderer;
|
|
await act(async () => { renderer = create(React.createElement(Fixture)); });
|
|
await act(async () => {
|
|
renderer.root.findByProps({ className: 'dim-workspaceEdit' }).props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
|
|
assert.deepEqual(saved, ['/workspace/native']);
|
|
assert.deepEqual(picker.calls, { list: 1, pick: 1 });
|
|
assert.equal(renderer.root.findByType('code').props.title, '/workspace/native');
|
|
assert.equal(renderer.root.findAllByProps({ role: 'dialog' }).length, 0);
|
|
});
|
|
|
|
test('WorkspaceEditor treats native picker cancellation as cancellation, not an error', async () => {
|
|
let saves = 0;
|
|
const picker = nativeDirectoryPicker(null);
|
|
let renderer;
|
|
await act(async () => {
|
|
renderer = create(React.createElement(WorkspaceEditor, {
|
|
workspace: '/workspace/current',
|
|
directoryPicker: picker,
|
|
async onSave() { saves += 1; },
|
|
}));
|
|
});
|
|
await act(async () => {
|
|
renderer.root.findByProps({ className: 'dim-workspaceEdit' }).props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
|
|
assert.equal(saves, 0);
|
|
assert.deepEqual(picker.calls, { list: 1, pick: 1 });
|
|
assert.equal(renderer.root.findAllByProps({ role: 'alert' }).length, 0);
|
|
assert.equal(renderer.root.findAllByProps({ role: 'dialog' }).length, 0);
|
|
});
|
|
|
|
test('WorkspaceEditor falls back to the Host home when the saved path is unreadable', async () => {
|
|
const listed = [];
|
|
const saved = [];
|
|
const picker = {
|
|
async listDirectory(path) {
|
|
listed.push(path);
|
|
if (path === '/workspace/gone') {
|
|
const error = new Error('missing');
|
|
error.rpcError = { code: 'directory-unreadable', message: 'missing', details: { path } };
|
|
throw error;
|
|
}
|
|
return directoryListing('/workspace', ['projects']);
|
|
},
|
|
};
|
|
let renderer;
|
|
await act(async () => {
|
|
renderer = create(React.createElement(WorkspaceEditor, {
|
|
workspace: '/workspace/gone',
|
|
directoryPicker: picker,
|
|
async onSave(value) { saved.push(value); },
|
|
}));
|
|
});
|
|
await act(async () => {
|
|
renderer.root.findByProps({ className: 'dim-workspaceEdit' }).props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
|
|
assert.deepEqual(listed, ['/workspace/gone', undefined]);
|
|
await act(async () => {
|
|
renderer.root.findByProps({ className: 'dim-directoryPickerPrimary' }).props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
assert.deepEqual(saved, ['/workspace']);
|
|
});
|
|
|
|
test('WorkspaceEditor moves keyboard focus into and back out of the picker', async () => {
|
|
let dialogFocus = 0;
|
|
let editFocus = 0;
|
|
const picker = { async listDirectory(path) { return directoryListing(path); } };
|
|
let renderer;
|
|
await act(async () => {
|
|
renderer = create(React.createElement(WorkspaceEditor, {
|
|
workspace: '/workspace/current',
|
|
directoryPicker: picker,
|
|
async onSave() {},
|
|
}), {
|
|
createNodeMock(element) {
|
|
if (element.props?.className === 'dim-directoryPicker') {
|
|
return { focus() { dialogFocus += 1; } };
|
|
}
|
|
if (element.props?.className === 'dim-workspaceEdit') {
|
|
return { focus() { editFocus += 1; } };
|
|
}
|
|
return {};
|
|
},
|
|
});
|
|
});
|
|
await act(async () => {
|
|
renderer.root.findByProps({ className: 'dim-workspaceEdit' }).props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
assert.equal(dialogFocus, 1);
|
|
await act(async () => {
|
|
buttonNamed(renderer.root, '取消').props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
assert.equal(editFocus, 1);
|
|
});
|
|
|
|
test('WorkspaceEditor never translates Host filesystem names in the English UI', async (t) => {
|
|
setImTranslator((key) => en[key] ?? key);
|
|
t.after(() => setImTranslator(null));
|
|
const picker = {
|
|
async listDirectory(path) { return directoryListing(path, ['微信']); },
|
|
};
|
|
let renderer;
|
|
await act(async () => {
|
|
renderer = create(React.createElement(WorkspaceEditor, {
|
|
workspace: '/workspace/current',
|
|
directoryPicker: picker,
|
|
async onSave() {},
|
|
}));
|
|
await flushMicrotasks();
|
|
});
|
|
await act(async () => {
|
|
renderer.root.findByProps({ className: 'dim-workspaceEdit' }).props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
|
|
const directory = renderer.root.findByProps({ title: '/workspace/current/微信' });
|
|
assert.equal(textOf(directory), '微信');
|
|
assert.doesNotMatch(textOf(directory), /WeChat/);
|
|
await act(async () => { renderer.unmount(); });
|
|
});
|
|
|
|
test('a status response started before saving cannot restore the old workspace', async (t) => {
|
|
const previousWindow = globalThis.window;
|
|
let intervalCallback;
|
|
globalThis.window = {
|
|
setInterval(callback) { intervalCallback = callback; return 1; },
|
|
clearInterval() {},
|
|
};
|
|
t.after(() => {
|
|
if (previousWindow === undefined) delete globalThis.window;
|
|
else globalThis.window = previousWindow;
|
|
});
|
|
const staleStatus = deferred();
|
|
let statusCalls = 0;
|
|
const rpcCall = async (endpoint) => {
|
|
if (endpoint === 'connection.status') {
|
|
statusCalls += 1;
|
|
if (statusCalls === 1) return { ok: true, value: discordSnapshot('/workspace/current') };
|
|
if (statusCalls === 2) return staleStatus.promise;
|
|
return { ok: true, value: discordSnapshot('/workspace/new') };
|
|
}
|
|
if (endpoint === 'bot.workspace.set') {
|
|
return { ok: true, value: discordSnapshot('/workspace/new') };
|
|
}
|
|
throw new Error(`Unexpected endpoint: ${endpoint}`);
|
|
};
|
|
|
|
let renderer;
|
|
const picker = nativeDirectoryPicker('/workspace/new');
|
|
await act(async () => {
|
|
renderer = create(withDirectoryPicker(
|
|
React.createElement(DiscordSettingsTab, { rpcCall }),
|
|
picker,
|
|
));
|
|
await flushMicrotasks();
|
|
});
|
|
await act(async () => {
|
|
intervalCallback();
|
|
await flushMicrotasks();
|
|
});
|
|
await act(async () => {
|
|
buttonNamed(renderer.root, '选择目录').props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
assert.equal(renderer.root.findByType('code').props.title, '/workspace/new');
|
|
|
|
await act(async () => {
|
|
staleStatus.resolve({ ok: true, value: discordSnapshot('/workspace/old') });
|
|
await flushMicrotasks();
|
|
});
|
|
assert.equal(renderer.root.findByType('code').props.title, '/workspace/new');
|
|
await act(async () => { renderer.unmount(); });
|
|
});
|
|
|
|
test('an older reconnect snapshot from another bot cannot restore a saved workspace', async (t) => {
|
|
const previousWindow = globalThis.window;
|
|
globalThis.window = { setInterval() { return 1; }, clearInterval() {} };
|
|
t.after(() => {
|
|
if (previousWindow === undefined) delete globalThis.window;
|
|
else globalThis.window = previousWindow;
|
|
});
|
|
const staleReconnect = deferred();
|
|
let statusCalls = 0;
|
|
const rpcCall = async (endpoint) => {
|
|
if (endpoint === 'connection.status') {
|
|
statusCalls += 1;
|
|
return {
|
|
ok: true,
|
|
value: twoBotDiscordSnapshot(statusCalls === 1 ? '/workspace/current' : '/workspace/new'),
|
|
};
|
|
}
|
|
if (endpoint === 'bot.reconnect') return staleReconnect.promise;
|
|
if (endpoint === 'bot.workspace.set') {
|
|
return { ok: true, value: twoBotDiscordSnapshot('/workspace/new') };
|
|
}
|
|
throw new Error(`Unexpected endpoint: ${endpoint}`);
|
|
};
|
|
|
|
let renderer;
|
|
const picker = nativeDirectoryPicker('/workspace/new');
|
|
await act(async () => {
|
|
renderer = create(withDirectoryPicker(
|
|
React.createElement(DiscordSettingsTab, { rpcCall }),
|
|
picker,
|
|
));
|
|
await flushMicrotasks();
|
|
});
|
|
const firstCard = renderer.root.findByProps({ 'data-bot-id': 'discord_first' });
|
|
const secondCard = renderer.root.findByProps({ 'data-bot-id': 'discord_second' });
|
|
await act(async () => {
|
|
secondCard.findAllByType('button')
|
|
.find((button) => button.children.join('') === '检查连接').props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
await act(async () => {
|
|
buttonNamed(firstCard, '选择目录').props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
|
|
staleReconnect.resolve({ ok: true, value: twoBotDiscordSnapshot('/workspace/old') });
|
|
await act(async () => { await flushMicrotasks(); });
|
|
assert.equal(
|
|
renderer.root.findByProps({ 'data-bot-id': 'discord_first' }).findByType('code').props.title,
|
|
'/workspace/new',
|
|
);
|
|
await act(async () => { renderer.unmount(); });
|
|
});
|
|
|
|
test('connection check requests a test message and shows its delivery result', async (t) => {
|
|
const previousWindow = globalThis.window;
|
|
globalThis.window = { setInterval() { return 1; }, clearInterval() {} };
|
|
t.after(() => {
|
|
if (previousWindow === undefined) delete globalThis.window;
|
|
else globalThis.window = previousWindow;
|
|
});
|
|
const calls = [];
|
|
const snapshot = discordSnapshot('/workspace/current');
|
|
const rpcCall = async (endpoint, payload) => {
|
|
calls.push({ endpoint, payload });
|
|
if (endpoint === 'connection.status') return { ok: true, value: snapshot };
|
|
if (endpoint === 'bot.reconnect') {
|
|
return { ok: true, value: { ...snapshot, testMessage: { sent: true } } };
|
|
}
|
|
throw new Error(`Unexpected endpoint: ${endpoint}`);
|
|
};
|
|
|
|
let renderer;
|
|
await act(async () => {
|
|
renderer = create(React.createElement(DiscordSettingsTab, { rpcCall }));
|
|
await flushMicrotasks();
|
|
});
|
|
const card = renderer.root.findByProps({ 'data-bot-id': 'discord_test' });
|
|
await act(async () => {
|
|
buttonNamed(card, '检查连接').props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
|
|
assert.deepEqual(calls.find((call) => call.endpoint === 'bot.reconnect')?.payload, {
|
|
botId: 'discord_test',
|
|
sendTest: true,
|
|
});
|
|
assert.equal(
|
|
textOf(renderer.root.findByProps({ role: 'status' })),
|
|
'测试消息已发送，请到对应机器人会话中确认。',
|
|
);
|
|
await act(async () => { renderer.unmount(); });
|
|
});
|
|
|
|
test('shared token target-unavailable feedback asks for any direct message', async (t) => {
|
|
const previousWindow = globalThis.window;
|
|
globalThis.window = { setInterval() { return 1; }, clearInterval() {} };
|
|
setImTranslator((key) => en[key] ?? key);
|
|
t.after(() => {
|
|
setImTranslator(null);
|
|
if (previousWindow === undefined) delete globalThis.window;
|
|
else globalThis.window = previousWindow;
|
|
});
|
|
const snapshot = discordSnapshot('/workspace/current');
|
|
const rpcCall = async (endpoint) => {
|
|
if (endpoint === 'connection.status') return { ok: true, value: snapshot };
|
|
if (endpoint === 'bot.reconnect') {
|
|
return {
|
|
ok: true,
|
|
value: {
|
|
...snapshot,
|
|
testMessage: { sent: false, code: 'test-target-unavailable' },
|
|
},
|
|
};
|
|
}
|
|
throw new Error(`Unexpected endpoint: ${endpoint}`);
|
|
};
|
|
|
|
let renderer;
|
|
await act(async () => {
|
|
renderer = create(React.createElement(DiscordSettingsTab, { rpcCall }));
|
|
await flushMicrotasks();
|
|
});
|
|
const card = renderer.root.findByProps({ 'data-bot-id': 'discord_test' });
|
|
await act(async () => {
|
|
buttonNamed(card, 'Check connection').props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
|
|
const notice = textOf(renderer.root.findByProps({ role: 'status' }));
|
|
assert.equal(
|
|
notice,
|
|
'Connection check completed. The bot has not received a direct message it can use for testing.',
|
|
);
|
|
assert.doesNotMatch(notice, /\/status|[\p{Script=Han}]/u);
|
|
await act(async () => { renderer.unmount(); });
|
|
});
|
|
|
|
test('shared token connection failures render a fixed English-safe notice', async (t) => {
|
|
const previousWindow = globalThis.window;
|
|
globalThis.window = { setInterval() { return 1; }, clearInterval() {} };
|
|
setImTranslator((key) => en[key] ?? key);
|
|
t.after(() => {
|
|
setImTranslator(null);
|
|
if (previousWindow === undefined) delete globalThis.window;
|
|
else globalThis.window = previousWindow;
|
|
});
|
|
const snapshot = discordSnapshot('/workspace/current');
|
|
const rpcCall = async (endpoint) => {
|
|
if (endpoint === 'connection.status') return { ok: true, value: snapshot };
|
|
if (endpoint === 'bot.reconnect') {
|
|
return {
|
|
ok: false,
|
|
error: { code: 'discord-operation-failed', message: 'Discord 操作失败，请稍后重试。' },
|
|
};
|
|
}
|
|
throw new Error(`Unexpected endpoint: ${endpoint}`);
|
|
};
|
|
|
|
let renderer;
|
|
await act(async () => {
|
|
renderer = create(React.createElement(DiscordSettingsTab, { rpcCall }));
|
|
await flushMicrotasks();
|
|
});
|
|
const card = renderer.root.findByProps({ 'data-bot-id': 'discord_test' });
|
|
await act(async () => {
|
|
buttonNamed(card, 'Check connection').props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
|
|
const notice = textOf(renderer.root.findByProps({ role: 'status' }));
|
|
assert.equal(notice, 'Connection check failed. Try again later.');
|
|
assert.doesNotMatch(notice, /[\p{Script=Han}]/u);
|
|
await act(async () => { renderer.unmount(); });
|
|
});
|
|
|
|
test('an older reconnect snapshot cannot resurrect a bot deleted by a newer mutation', async (t) => {
|
|
const previousWindow = globalThis.window;
|
|
globalThis.window = { setInterval() { return 1; }, clearInterval() {} };
|
|
t.after(() => {
|
|
if (previousWindow === undefined) delete globalThis.window;
|
|
else globalThis.window = previousWindow;
|
|
});
|
|
const staleReconnect = deferred();
|
|
const initialSnapshot = twoBotDiscordSnapshot('/workspace/first');
|
|
const deletedSnapshot = { ...initialSnapshot, bots: initialSnapshot.bots.slice(1) };
|
|
let statusCalls = 0;
|
|
const rpcCall = async (endpoint) => {
|
|
if (endpoint === 'connection.status') {
|
|
statusCalls += 1;
|
|
return { ok: true, value: statusCalls === 1 ? initialSnapshot : deletedSnapshot };
|
|
}
|
|
if (endpoint === 'bot.reconnect') return staleReconnect.promise;
|
|
if (endpoint === 'bot.delete') return { ok: true, value: deletedSnapshot };
|
|
throw new Error(`Unexpected endpoint: ${endpoint}`);
|
|
};
|
|
|
|
let renderer;
|
|
await act(async () => {
|
|
renderer = create(React.createElement(DiscordSettingsTab, { rpcCall }));
|
|
await flushMicrotasks();
|
|
});
|
|
const firstCard = renderer.root.findByProps({ 'data-bot-id': 'discord_first' });
|
|
const secondCard = renderer.root.findByProps({ 'data-bot-id': 'discord_second' });
|
|
await act(async () => {
|
|
secondCard.findAllByType('button')
|
|
.find((button) => button.children.join('') === '检查连接').props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
await act(async () => {
|
|
firstCard.findAllByType('button')
|
|
.find((button) => button.children.join('') === '移除接入').props.onClick();
|
|
});
|
|
await act(async () => {
|
|
await firstCard.findAllByType('button')
|
|
.find((button) => button.children.join('') === '确认移除接入').props.onClick();
|
|
await flushMicrotasks();
|
|
});
|
|
assert.equal(renderer.root.findAllByProps({ 'data-bot-id': 'discord_first' }).length, 0);
|
|
|
|
staleReconnect.resolve({ ok: true, value: initialSnapshot });
|
|
await act(async () => { await flushMicrotasks(); });
|
|
assert.equal(renderer.root.findAllByProps({ 'data-bot-id': 'discord_first' }).length, 0);
|
|
await act(async () => { renderer.unmount(); });
|
|
});
|