mirror of
https://github.com/hansjone/dsh-im-ops.git
synced 2026-10-13 03:50:44 +08:00
fix: support Harness interactions across IM channels
This commit is contained in:
xmanrui
parent
3e7e1dcdd7
commit
cd8175d341
30 changed files with 5433 additions and 555 deletions
|
|
@ -44,6 +44,25 @@ function credentials() {
|
|||
};
|
||||
}
|
||||
|
||||
function deferred() {
|
||||
let resolve;
|
||||
let reject;
|
||||
const promise = new Promise((resolvePromise, rejectPromise) => {
|
||||
resolve = resolvePromise;
|
||||
reject = rejectPromise;
|
||||
});
|
||||
return { promise, resolve, reject };
|
||||
}
|
||||
|
||||
async function eventually(predicate, timeoutMs = 1_000) {
|
||||
const deadline = Date.now() + timeoutMs;
|
||||
while (Date.now() < deadline) {
|
||||
if (predicate()) return;
|
||||
await new Promise((resolve) => setTimeout(resolve, 5));
|
||||
}
|
||||
assert.fail('condition was not met before timeout');
|
||||
}
|
||||
|
||||
test('Discord API authenticates with a Bot header and validates the current bot', async () => {
|
||||
assert.equal(validDiscordToken(TOKEN), true);
|
||||
assert.equal(validDiscordToken('not-a-token'), false);
|
||||
|
|
@ -233,6 +252,9 @@ class FakeSocket {
|
|||
|
||||
test('Discord runtime identifies on Gateway v10 and becomes ready', async () => {
|
||||
let socket;
|
||||
const abortMark = deferred();
|
||||
let abortMarkStarted = false;
|
||||
const errors = [];
|
||||
const runtime = new DiscordRuntime({
|
||||
config: {
|
||||
botId: 'discord_test',
|
||||
|
|
@ -246,7 +268,13 @@ test('Discord runtime identifies on Gateway v10 and becomes ready', async () =>
|
|||
setSession: async () => {},
|
||||
clearSession: async () => {},
|
||||
hasSeen: () => false,
|
||||
markSeen: async () => {},
|
||||
markSeen: async (messageId) => {
|
||||
if (messageId === '111111111111111199') {
|
||||
abortMarkStarted = true;
|
||||
return abortMark.promise;
|
||||
}
|
||||
throw new Error(`Discord state write failed for ${messageId}`);
|
||||
},
|
||||
},
|
||||
createApi: () => ({
|
||||
getCurrentUser: async () => ({ id: '1234567890123456789', bot: true }),
|
||||
|
|
@ -260,6 +288,10 @@ test('Discord runtime identifies on Gateway v10 and becomes ready', async () =>
|
|||
return socket;
|
||||
},
|
||||
random: () => 0.5,
|
||||
logger: {
|
||||
warn() {},
|
||||
error(...args) { errors.push(args); },
|
||||
},
|
||||
});
|
||||
await runtime.start();
|
||||
assert.equal(runtime.status.ready, true);
|
||||
|
|
@ -267,6 +299,46 @@ test('Discord runtime identifies on Gateway v10 and becomes ready', async () =>
|
|||
assert.equal(identify.d.token, TOKEN);
|
||||
assert.equal(identify.d.intents, 4_609);
|
||||
assert.equal(identify.d.properties.browser, 'dsh-im');
|
||||
await runtime.stop();
|
||||
|
||||
for (const [id, sequence] of [
|
||||
['111111111111111190', 2],
|
||||
['111111111111111191', 3],
|
||||
]) {
|
||||
socket.emit('message', {
|
||||
data: JSON.stringify({
|
||||
op: 0,
|
||||
t: 'MESSAGE_CREATE',
|
||||
s: sequence,
|
||||
d: {
|
||||
id,
|
||||
channel_id: '222222222222222222',
|
||||
author: { id: '333333333333333333', bot: false },
|
||||
content: 'trigger state failure',
|
||||
},
|
||||
}),
|
||||
});
|
||||
}
|
||||
await eventually(() => errors.length === 2);
|
||||
assert.equal(errors.every((args) => args[0].includes('message handling failed')), true);
|
||||
|
||||
socket.emit('message', {
|
||||
data: JSON.stringify({
|
||||
op: 0,
|
||||
t: 'MESSAGE_CREATE',
|
||||
s: 4,
|
||||
d: {
|
||||
id: '111111111111111199',
|
||||
channel_id: '222222222222222222',
|
||||
author: { id: '333333333333333333', bot: false },
|
||||
content: 'abort state write',
|
||||
},
|
||||
}),
|
||||
});
|
||||
await eventually(() => abortMarkStarted);
|
||||
const stopping = runtime.stop();
|
||||
abortMark.reject(new Error('Discord state write aborted'));
|
||||
await stopping;
|
||||
await new Promise((resolve) => setImmediate(resolve));
|
||||
assert.equal(errors.length, 2);
|
||||
assert.equal(runtime.status.ready, false);
|
||||
});
|
||||
|
|
|
|||
|
|
@ -3,6 +3,41 @@ import test from 'node:test';
|
|||
|
||||
import { QqHarnessBridge } from '../../../src/channels/qq/qq-bridge.mjs';
|
||||
|
||||
function deferred() {
|
||||
let resolve;
|
||||
let reject;
|
||||
const promise = new Promise((promiseResolve, promiseReject) => {
|
||||
resolve = promiseResolve;
|
||||
reject = promiseReject;
|
||||
});
|
||||
return { promise, resolve, reject };
|
||||
}
|
||||
|
||||
async function eventually(predicate, messageText = 'condition was not met') {
|
||||
const deadline = Date.now() + 1_000;
|
||||
while (Date.now() < deadline) {
|
||||
if (predicate()) return;
|
||||
await new Promise((resolve) => setTimeout(resolve, 5));
|
||||
}
|
||||
assert.fail(messageText);
|
||||
}
|
||||
|
||||
function stateFixture(initialSessions = []) {
|
||||
const sessions = new Map(initialSessions);
|
||||
const seen = new Set();
|
||||
return {
|
||||
sessions,
|
||||
seen,
|
||||
state: {
|
||||
hasSeen: (id) => seen.has(id),
|
||||
markSeen: async (id) => seen.add(id),
|
||||
sessionFor: (key) => sessions.get(key) ?? null,
|
||||
setSession: async (key, sessionId) => sessions.set(key, sessionId),
|
||||
clearSession: async (key) => sessions.delete(key),
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function message(overrides = {}) {
|
||||
return {
|
||||
kind: 'c2c',
|
||||
|
|
@ -101,3 +136,777 @@ test('QQ credential-bound bots accept senders within the platform visibility sco
|
|||
assert.equal(asks, 1);
|
||||
assert.equal(bridge.status.messagesRejected, 0);
|
||||
});
|
||||
|
||||
test('QQ group questions require the initiating actor to mention the bot and preserve multi-question answers', async () => {
|
||||
const fixture = stateFixture([['group:group-1', 'session-group']]);
|
||||
const sent = [];
|
||||
const asked = [];
|
||||
const submitted = deferred();
|
||||
const secondQuestionDelivered = deferred();
|
||||
const releaseSecondQuestion = deferred();
|
||||
const bridge = new QqHarnessBridge({
|
||||
bot: {
|
||||
sendText: async (target, text) => {
|
||||
sent.push({ target, text });
|
||||
if (text.includes('选择交付内容')) {
|
||||
secondQuestionDelivered.resolve();
|
||||
await releaseSecondQuestion.promise;
|
||||
}
|
||||
},
|
||||
},
|
||||
ownerUserOpenid: '*',
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
createSession: async () => assert.fail('the existing session should be reused'),
|
||||
ask: async (sessionId, text, options) => {
|
||||
asked.push({ sessionId, text });
|
||||
if (text === '旁观者的普通问题') return '旁观者问题已回答';
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'qq-group-multi',
|
||||
rpcId: 'qq-group-multi',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [
|
||||
{
|
||||
id: 'language',
|
||||
question: '选择回答语言',
|
||||
options: [{ label: '中文' }, { label: 'English' }],
|
||||
},
|
||||
{
|
||||
id: 'deliverables',
|
||||
question: '选择交付内容',
|
||||
multiSelect: true,
|
||||
options: [{ label: '测试' }, { label: '文档' }],
|
||||
},
|
||||
],
|
||||
},
|
||||
respond: async (result) => {
|
||||
submitted.resolve(result);
|
||||
return { accepted: true };
|
||||
},
|
||||
});
|
||||
await submitted.promise;
|
||||
return '发起者交互完成';
|
||||
},
|
||||
},
|
||||
state: fixture.state,
|
||||
});
|
||||
|
||||
const first = bridge.accept(message({
|
||||
kind: 'group',
|
||||
rawEventType: 'GROUP_AT_MESSAGE_CREATE',
|
||||
senderId: 'initiator',
|
||||
groupOpenid: 'group-1',
|
||||
content: '启动群聊交互',
|
||||
messageId: 'group-start',
|
||||
replyTarget: { scope: 'group', targetId: 'group-1', msgId: 'group-start' },
|
||||
}));
|
||||
await eventually(() => sent.some(({ text }) => text.includes('选择回答语言')));
|
||||
assert.equal(sent.find(({ text }) => text.includes('选择回答语言')).text
|
||||
.includes('群聊中请 @机器人 后发送答案。'), true);
|
||||
|
||||
let submittedResult;
|
||||
submitted.promise.then((result) => { submittedResult = result; });
|
||||
const bystander = bridge.accept(message({
|
||||
kind: 'group',
|
||||
rawEventType: 'GROUP_AT_MESSAGE_CREATE',
|
||||
senderId: 'bystander',
|
||||
groupOpenid: 'group-1',
|
||||
content: '旁观者的普通问题',
|
||||
messageId: 'group-bystander',
|
||||
replyTarget: { scope: 'group', targetId: 'group-1', msgId: 'group-bystander' },
|
||||
}));
|
||||
await bridge.accept(message({
|
||||
kind: 'group',
|
||||
rawEventType: 'GROUP_MESSAGE_CREATE',
|
||||
senderId: 'initiator',
|
||||
groupOpenid: 'group-1',
|
||||
content: '未提及机器人的答案',
|
||||
messageId: 'group-unmentioned',
|
||||
replyTarget: { scope: 'group', targetId: 'group-1', msgId: 'group-unmentioned' },
|
||||
}));
|
||||
assert.equal(submittedResult, undefined);
|
||||
|
||||
const firstAnswer = bridge.accept(message({
|
||||
kind: 'group',
|
||||
rawEventType: 'GROUP_AT_MESSAGE_CREATE',
|
||||
senderId: 'initiator',
|
||||
groupOpenid: 'group-1',
|
||||
content: '2',
|
||||
messageId: 'group-language',
|
||||
replyTarget: { scope: 'group', targetId: 'group-1', msgId: 'group-language' },
|
||||
}));
|
||||
await secondQuestionDelivered.promise;
|
||||
const secondAnswer = bridge.accept(message({
|
||||
kind: 'group',
|
||||
rawEventType: 'GROUP_AT_MESSAGE_CREATE',
|
||||
senderId: 'initiator',
|
||||
groupOpenid: 'group-1',
|
||||
content: '1，文档，发布说明',
|
||||
messageId: 'group-deliverables',
|
||||
replyTarget: { scope: 'group', targetId: 'group-1', msgId: 'group-deliverables' },
|
||||
}));
|
||||
releaseSecondQuestion.resolve();
|
||||
await Promise.all([firstAnswer, secondAnswer]);
|
||||
|
||||
assert.deepEqual(await submitted.promise, {
|
||||
ok: true,
|
||||
value: {
|
||||
sessionId: 'session-group',
|
||||
answer: {
|
||||
answers: [
|
||||
{ id: 'language', selected: ['English'] },
|
||||
{ id: 'deliverables', selected: ['测试', '文档'], custom: '发布说明' },
|
||||
],
|
||||
},
|
||||
},
|
||||
});
|
||||
await Promise.all([first, bystander]);
|
||||
assert.deepEqual(asked, [
|
||||
{ sessionId: 'session-group', text: '启动群聊交互' },
|
||||
{ sessionId: 'session-group', text: '旁观者的普通问题' },
|
||||
]);
|
||||
assert.equal(asked.some(({ text }) => [
|
||||
'未提及机器人的答案',
|
||||
'2',
|
||||
'1，文档，发布说明',
|
||||
].includes(text)), false);
|
||||
assert.deepEqual(sent.slice(-2).map(({ text }) => text), ['发起者交互完成', '旁观者问题已回答']);
|
||||
});
|
||||
|
||||
test('QQ pending questions stay isolated between private conversations', async () => {
|
||||
const fixture = stateFixture([
|
||||
['c2c:user-a', 'session-a'],
|
||||
['c2c:user-b', 'session-b'],
|
||||
]);
|
||||
const sent = [];
|
||||
const asked = [];
|
||||
const answeredA = deferred();
|
||||
const responseA = deferred();
|
||||
const bridge = new QqHarnessBridge({
|
||||
bot: { sendText: async (target, text) => sent.push({ target, text }) },
|
||||
ownerUserOpenid: '*',
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
createSession: async () => assert.fail('the existing sessions should be reused'),
|
||||
ask: async (sessionId, text, options) => {
|
||||
asked.push({ sessionId, text });
|
||||
if (sessionId === 'session-b') return '乙会话的普通回答';
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'qq-isolated-a',
|
||||
rpcId: 'qq-isolated-a',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [{ id: 'answer-a', question: '甲会话的问题' }],
|
||||
},
|
||||
respond: async (result) => {
|
||||
responseA.resolve(result);
|
||||
answeredA.resolve();
|
||||
return { accepted: true };
|
||||
},
|
||||
});
|
||||
await answeredA.promise;
|
||||
return '甲会话完成';
|
||||
},
|
||||
},
|
||||
state: fixture.state,
|
||||
});
|
||||
|
||||
const firstA = bridge.accept(message({
|
||||
senderId: 'user-a',
|
||||
content: '启动甲会话',
|
||||
messageId: 'private-a-start',
|
||||
replyTarget: { scope: 'c2c', targetId: 'user-a', msgId: 'private-a-start' },
|
||||
}));
|
||||
await eventually(() => sent.some(({ text }) => text.includes('甲会话的问题')));
|
||||
await bridge.accept(message({
|
||||
senderId: 'user-b',
|
||||
content: '乙会话的消息',
|
||||
messageId: 'private-b',
|
||||
replyTarget: { scope: 'c2c', targetId: 'user-b', msgId: 'private-b' },
|
||||
}));
|
||||
assert.equal(sent.some(({ target, text }) => (
|
||||
target.targetId === 'user-b' && text === '乙会话的普通回答'
|
||||
)), true);
|
||||
|
||||
await bridge.accept(message({
|
||||
senderId: 'user-a',
|
||||
content: '甲的答案',
|
||||
messageId: 'private-a-answer',
|
||||
replyTarget: { scope: 'c2c', targetId: 'user-a', msgId: 'private-a-answer' },
|
||||
}));
|
||||
await firstA;
|
||||
assert.deepEqual((await responseA.promise).value.answer.answers, [
|
||||
{ id: 'answer-a', selected: [], custom: '甲的答案' },
|
||||
]);
|
||||
assert.deepEqual(asked, [
|
||||
{ sessionId: 'session-a', text: '启动甲会话' },
|
||||
{ sessionId: 'session-b', text: '乙会话的消息' },
|
||||
]);
|
||||
});
|
||||
|
||||
test('QQ deduplicates question replays, cancels orphan questions, and keeps approvals fail-closed', async () => {
|
||||
const fixture = stateFixture();
|
||||
const sent = [];
|
||||
let approvalResponses = 0;
|
||||
let parallelResponse;
|
||||
let orphanResponse;
|
||||
const bridge = new QqHarnessBridge({
|
||||
bot: { sendText: async (target, text) => sent.push({ target, text }) },
|
||||
ownerUserOpenid: 'owner-openid',
|
||||
harness: {
|
||||
sessionExists: async () => false,
|
||||
createSession: async () => 'session-replay',
|
||||
ask: async (sessionId, _text, options) => {
|
||||
const replayedQuestion = {
|
||||
kind: 'question',
|
||||
interactionId: 'qq-replayed-question',
|
||||
rpcId: 'qq-replayed-question',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [{ id: 'choice', question: '只应显示一次' }],
|
||||
},
|
||||
respond: async () => ({ accepted: true }),
|
||||
};
|
||||
await options.onInteraction(replayedQuestion);
|
||||
await options.onInteraction(replayedQuestion);
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'qq-parallel-question',
|
||||
rpcId: 'qq-parallel-question',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [{ id: 'parallel', question: '不应展示的并行问题' }],
|
||||
},
|
||||
respond: async (result) => {
|
||||
parallelResponse = result;
|
||||
return { accepted: true };
|
||||
},
|
||||
});
|
||||
await options.onInteraction({
|
||||
kind: 'approval',
|
||||
interactionId: 'qq-approval',
|
||||
rpcId: 'qq-approval',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'approval/requested',
|
||||
sessionId,
|
||||
approvalId: 'qq-approval',
|
||||
toolName: 'bash',
|
||||
},
|
||||
respond: async () => { approvalResponses += 1; },
|
||||
});
|
||||
await options.onInteractionResolved({
|
||||
kind: 'question',
|
||||
interactionId: 'qq-replayed-question',
|
||||
sessionId,
|
||||
outcome: 'cancelled',
|
||||
});
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'qq-orphan-question',
|
||||
rpcId: 'qq-orphan-question',
|
||||
sessionId,
|
||||
recovered: true,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [{ id: 'secret', question: '旧会话中的敏感问题内容' }],
|
||||
},
|
||||
respond: async (result) => {
|
||||
orphanResponse = result;
|
||||
return { accepted: true };
|
||||
},
|
||||
});
|
||||
return '交互恢复完成';
|
||||
},
|
||||
},
|
||||
state: fixture.state,
|
||||
logger: { warn() {}, error() {} },
|
||||
});
|
||||
|
||||
await bridge.accept(message({ messageId: 'qq-replay', content: '测试交互重放' }));
|
||||
|
||||
assert.equal(sent.filter(({ text }) => text.includes('只应显示一次')).length, 1);
|
||||
assert.deepEqual(parallelResponse, {
|
||||
ok: false,
|
||||
error: {
|
||||
code: 'cancelled',
|
||||
message: 'QQ is already handling another user interaction.',
|
||||
details: {},
|
||||
},
|
||||
});
|
||||
assert.equal(approvalResponses, 0);
|
||||
assert.equal(sent.some(({ text }) => text.includes('approval')), false);
|
||||
assert.deepEqual(orphanResponse, {
|
||||
ok: false,
|
||||
error: {
|
||||
code: 'cancelled',
|
||||
message: 'QQ safely cancelled an interaction left by an earlier client.',
|
||||
details: {},
|
||||
},
|
||||
});
|
||||
assert.equal(sent.some(({ text }) => text.includes('旧会话中的敏感问题内容')), false);
|
||||
assert.equal(sent.some(({ text }) => text.includes('遗留的待回答问题')), true);
|
||||
assert.equal(sent.at(-1).text, '交互恢复完成');
|
||||
});
|
||||
|
||||
test('QQ keeps a queued prompt separate while a failed interaction answer is retried', async () => {
|
||||
const fixture = stateFixture([['c2c:owner-openid', 'session-submit-retry']]);
|
||||
const sent = [];
|
||||
const asked = [];
|
||||
const firstSubmitStarted = deferred();
|
||||
const releaseFirstSubmit = deferred();
|
||||
const answered = deferred();
|
||||
const submittedAnswers = [];
|
||||
let submitAttempts = 0;
|
||||
const bridge = new QqHarnessBridge({
|
||||
bot: { sendText: async (target, text) => sent.push({ target, text }) },
|
||||
ownerUserOpenid: 'owner-openid',
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
createSession: async () => assert.fail('the existing session should be reused'),
|
||||
ask: async (sessionId, text, options) => {
|
||||
asked.push(text);
|
||||
if (text === '排队的下一个问题') return '第二轮完成';
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'qq-submit-retry',
|
||||
rpcId: 'qq-submit-retry',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [{ id: 'answer', question: '请回答后再继续' }],
|
||||
},
|
||||
respond: async (result) => {
|
||||
submittedAnswers.push(result.value.answer.answers[0].custom);
|
||||
submitAttempts += 1;
|
||||
if (submitAttempts === 1) {
|
||||
firstSubmitStarted.resolve();
|
||||
await releaseFirstSubmit.promise;
|
||||
throw new Error('temporary response failure');
|
||||
}
|
||||
answered.resolve();
|
||||
return { accepted: true };
|
||||
},
|
||||
});
|
||||
await answered.promise;
|
||||
return '第一轮完成';
|
||||
},
|
||||
},
|
||||
state: fixture.state,
|
||||
logger: { warn() {}, error() {} },
|
||||
});
|
||||
|
||||
const first = bridge.accept(message({ messageId: 'retry-start', content: '启动可重试交互' }));
|
||||
await eventually(() => sent.some(({ text }) => text.includes('请回答后再继续')));
|
||||
const firstAnswer = bridge.accept(message({
|
||||
messageId: 'retry-first-answer',
|
||||
content: '第一次答案',
|
||||
replyTarget: { scope: 'c2c', targetId: 'owner-openid', msgId: 'retry-first-answer' },
|
||||
}));
|
||||
await firstSubmitStarted.promise;
|
||||
|
||||
let nextSettled = false;
|
||||
const next = bridge.accept(message({
|
||||
messageId: 'retry-next',
|
||||
content: '排队的下一个问题',
|
||||
replyTarget: { scope: 'c2c', targetId: 'owner-openid', msgId: 'retry-next' },
|
||||
})).finally(() => { nextSettled = true; });
|
||||
releaseFirstSubmit.resolve();
|
||||
await firstAnswer;
|
||||
await eventually(() => sent.some(({ text }) => text.includes('回答提交失败')));
|
||||
assert.equal(nextSettled, false);
|
||||
assert.deepEqual(asked, ['启动可重试交互']);
|
||||
|
||||
await Promise.all([
|
||||
bridge.accept(message({
|
||||
messageId: 'retry-second-answer',
|
||||
content: '重试后的答案',
|
||||
replyTarget: { scope: 'c2c', targetId: 'owner-openid', msgId: 'retry-second-answer' },
|
||||
})),
|
||||
first,
|
||||
next,
|
||||
]);
|
||||
|
||||
assert.deepEqual(submittedAnswers, ['第一次答案', '重试后的答案']);
|
||||
assert.deepEqual(asked, ['启动可重试交互', '排队的下一个问题']);
|
||||
assert.deepEqual(sent.slice(-2).map(({ text }) => text), ['第一轮完成', '第二轮完成']);
|
||||
});
|
||||
|
||||
test('QQ discards an already-claimed answer when the interaction resolves elsewhere', async () => {
|
||||
const fixture = stateFixture([['c2c:owner-openid', 'session-resolved-race']]);
|
||||
const originalMarkSeen = fixture.state.markSeen;
|
||||
const answerMarkStarted = deferred();
|
||||
const releaseAnswerMark = deferred();
|
||||
fixture.state.markSeen = async (id) => {
|
||||
if (id === 'resolved-answer') {
|
||||
answerMarkStarted.resolve();
|
||||
await releaseAnswerMark.promise;
|
||||
}
|
||||
await originalMarkSeen(id);
|
||||
};
|
||||
const sent = [];
|
||||
const asked = [];
|
||||
const resolved = deferred();
|
||||
let resolveInteraction;
|
||||
const bridge = new QqHarnessBridge({
|
||||
bot: { sendText: async (target, text) => sent.push({ target, text }) },
|
||||
ownerUserOpenid: 'owner-openid',
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
createSession: async () => assert.fail('the existing session should be reused'),
|
||||
ask: async (sessionId, text, options) => {
|
||||
asked.push(text);
|
||||
if (text === '后来的普通问题') return '后来问题的回答';
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'qq-resolved-race',
|
||||
rpcId: 'qq-resolved-race',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [{ id: 'answer', question: '可能在其他客户端回答' }],
|
||||
},
|
||||
respond: async () => ({ accepted: true }),
|
||||
});
|
||||
resolveInteraction = async () => {
|
||||
await options.onInteractionResolved({
|
||||
kind: 'question',
|
||||
interactionId: 'qq-resolved-race',
|
||||
sessionId,
|
||||
outcome: 'answered',
|
||||
});
|
||||
resolved.resolve();
|
||||
};
|
||||
await resolved.promise;
|
||||
return '第一轮已由其他客户端完成';
|
||||
},
|
||||
},
|
||||
state: fixture.state,
|
||||
});
|
||||
|
||||
const first = bridge.accept(message({ messageId: 'resolved-start', content: '启动外部解决竞态' }));
|
||||
await eventually(() => typeof resolveInteraction === 'function');
|
||||
const answer = bridge.accept(message({
|
||||
messageId: 'resolved-answer',
|
||||
content: '原本的问题答案',
|
||||
replyTarget: { scope: 'c2c', targetId: 'owner-openid', msgId: 'resolved-answer' },
|
||||
}));
|
||||
await answerMarkStarted.promise;
|
||||
const later = bridge.accept(message({
|
||||
messageId: 'resolved-later',
|
||||
content: '后来的普通问题',
|
||||
replyTarget: { scope: 'c2c', targetId: 'owner-openid', msgId: 'resolved-later' },
|
||||
}));
|
||||
await resolveInteraction();
|
||||
releaseAnswerMark.resolve();
|
||||
|
||||
await Promise.all([answer, first, later]);
|
||||
assert.deepEqual(asked, ['启动外部解决竞态', '后来的普通问题']);
|
||||
assert.equal(asked.includes('原本的问题答案'), false);
|
||||
assert.equal(sent.some(({ text }) => text.includes('已在其他客户端处理')), true);
|
||||
});
|
||||
|
||||
test('QQ keeps an answer that arrives after the first question is delivered but before its send ACK', async () => {
|
||||
const fixture = stateFixture([['c2c:owner-openid', 'session-first-delivery']]);
|
||||
const questionDelivered = deferred();
|
||||
const releaseQuestionAck = deferred();
|
||||
const answered = deferred();
|
||||
const sent = [];
|
||||
const asked = [];
|
||||
let submitted;
|
||||
let questionSends = 0;
|
||||
const bridge = new QqHarnessBridge({
|
||||
bot: {
|
||||
sendText: async (target, text) => {
|
||||
sent.push({ target, text });
|
||||
if (text.includes('首问 ACK 窗口')) {
|
||||
questionSends += 1;
|
||||
questionDelivered.resolve();
|
||||
await releaseQuestionAck.promise;
|
||||
}
|
||||
},
|
||||
},
|
||||
ownerUserOpenid: 'owner-openid',
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (sessionId, text, options) => {
|
||||
asked.push(text);
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'qq-first-delivery',
|
||||
rpcId: 'qq-first-delivery',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [{ id: 'answer', question: '首问 ACK 窗口' }],
|
||||
},
|
||||
respond: async (result) => {
|
||||
submitted = result;
|
||||
answered.resolve();
|
||||
return { accepted: true };
|
||||
},
|
||||
});
|
||||
await answered.promise;
|
||||
return '首问已完成';
|
||||
},
|
||||
},
|
||||
state: fixture.state,
|
||||
});
|
||||
|
||||
const first = bridge.accept(message({
|
||||
messageId: 'first-delivery-start',
|
||||
content: '启动首问窗口',
|
||||
}));
|
||||
await questionDelivered.promise;
|
||||
const answer = bridge.accept(message({
|
||||
messageId: 'first-delivery-answer',
|
||||
content: '窗口内答案',
|
||||
replyTarget: { scope: 'c2c', targetId: 'owner-openid', msgId: 'first-delivery-answer' },
|
||||
}));
|
||||
await new Promise((resolve) => setImmediate(resolve));
|
||||
assert.equal(submitted, undefined);
|
||||
releaseQuestionAck.resolve();
|
||||
await Promise.all([first, answer]);
|
||||
|
||||
assert.equal(questionSends, 1);
|
||||
assert.deepEqual(asked, ['启动首问窗口']);
|
||||
assert.deepEqual(submitted.value.answer.answers, [{
|
||||
id: 'answer',
|
||||
selected: [],
|
||||
custom: '窗口内答案',
|
||||
}]);
|
||||
assert.equal(fixture.seen.has('first-delivery-answer'), true);
|
||||
});
|
||||
|
||||
test('QQ tombstones a q2 answer accepted before its send ACK when the interaction resolves', async () => {
|
||||
const fixture = stateFixture([['c2c:owner-openid', 'session-q2-resolved']]);
|
||||
const secondQuestionDelivered = deferred();
|
||||
const releaseSecondQuestionAck = deferred();
|
||||
const turnResolved = deferred();
|
||||
const sent = [];
|
||||
const asked = [];
|
||||
let resolveInteraction;
|
||||
const bridge = new QqHarnessBridge({
|
||||
bot: {
|
||||
sendText: async (target, text) => {
|
||||
sent.push({ target, text });
|
||||
if (text.includes('会在 ACK 前 resolved 的第二问')) {
|
||||
secondQuestionDelivered.resolve();
|
||||
await releaseSecondQuestionAck.promise;
|
||||
}
|
||||
},
|
||||
},
|
||||
ownerUserOpenid: 'owner-openid',
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (sessionId, text, options) => {
|
||||
asked.push(text);
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'qq-q2-resolved',
|
||||
rpcId: 'qq-q2-resolved',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [
|
||||
{ id: 'first', question: '先回答第一问' },
|
||||
{ id: 'second', question: '会在 ACK 前 resolved 的第二问' },
|
||||
],
|
||||
},
|
||||
respond: async () => assert.fail('the externally resolved interaction must not be answered'),
|
||||
});
|
||||
resolveInteraction = () => {
|
||||
options.onInteractionResolved({
|
||||
kind: 'question',
|
||||
interactionId: 'qq-q2-resolved',
|
||||
sessionId,
|
||||
outcome: 'answered',
|
||||
});
|
||||
turnResolved.resolve();
|
||||
};
|
||||
await turnResolved.promise;
|
||||
return '已由其他客户端完成';
|
||||
},
|
||||
},
|
||||
state: fixture.state,
|
||||
});
|
||||
|
||||
const first = bridge.accept(message({
|
||||
messageId: 'q2-resolved-start',
|
||||
content: '启动 q2 resolved 窗口',
|
||||
}));
|
||||
await eventually(() => typeof resolveInteraction === 'function');
|
||||
const firstAnswer = bridge.accept(message({
|
||||
messageId: 'q2-resolved-first',
|
||||
content: '第一问答案',
|
||||
replyTarget: { scope: 'c2c', targetId: 'owner-openid', msgId: 'q2-resolved-first' },
|
||||
}));
|
||||
await secondQuestionDelivered.promise;
|
||||
const secondAnswer = bridge.accept(message({
|
||||
messageId: 'q2-resolved-second',
|
||||
content: '第二问答案',
|
||||
replyTarget: { scope: 'c2c', targetId: 'owner-openid', msgId: 'q2-resolved-second' },
|
||||
}));
|
||||
resolveInteraction();
|
||||
releaseSecondQuestionAck.resolve();
|
||||
await Promise.all([firstAnswer, secondAnswer, first]);
|
||||
|
||||
assert.deepEqual(asked, ['启动 q2 resolved 窗口']);
|
||||
assert.equal(fixture.seen.has('q2-resolved-second'), true);
|
||||
assert.equal(sent.some(({ text }) => text.includes('已在其他客户端处理')), true);
|
||||
});
|
||||
|
||||
test('QQ reports resolved when an in-flight response becomes not-pending', async () => {
|
||||
const fixture = stateFixture([['c2c:owner-openid', 'session-respond-resolved']]);
|
||||
const responseStarted = deferred();
|
||||
const releaseResponse = deferred();
|
||||
const turnResolved = deferred();
|
||||
const sent = [];
|
||||
let resolveInteraction;
|
||||
const bridge = new QqHarnessBridge({
|
||||
bot: { sendText: async (target, text) => sent.push({ target, text }) },
|
||||
ownerUserOpenid: 'owner-openid',
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (sessionId, _text, options) => {
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'qq-respond-resolved',
|
||||
rpcId: 'qq-respond-resolved',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [{ id: 'answer', question: '提交中会被外部解决' }],
|
||||
},
|
||||
respond: async () => {
|
||||
responseStarted.resolve();
|
||||
await releaseResponse.promise;
|
||||
const error = new Error('already resolved');
|
||||
error.code = 'interaction-not-pending';
|
||||
throw error;
|
||||
},
|
||||
});
|
||||
resolveInteraction = () => {
|
||||
options.onInteractionResolved({
|
||||
kind: 'question',
|
||||
interactionId: 'qq-respond-resolved',
|
||||
sessionId,
|
||||
outcome: 'answered',
|
||||
});
|
||||
turnResolved.resolve();
|
||||
};
|
||||
await turnResolved.promise;
|
||||
return '外部处理完成';
|
||||
},
|
||||
},
|
||||
state: fixture.state,
|
||||
});
|
||||
|
||||
const first = bridge.accept(message({
|
||||
messageId: 'respond-resolved-start',
|
||||
content: '启动提交竞态',
|
||||
}));
|
||||
await eventually(() => typeof resolveInteraction === 'function');
|
||||
const answer = bridge.accept(message({
|
||||
messageId: 'respond-resolved-answer',
|
||||
content: '我的答案',
|
||||
replyTarget: { scope: 'c2c', targetId: 'owner-openid', msgId: 'respond-resolved-answer' },
|
||||
}));
|
||||
await responseStarted.promise;
|
||||
resolveInteraction();
|
||||
releaseResponse.resolve();
|
||||
await Promise.all([answer, first]);
|
||||
|
||||
assert.equal(sent.some(({ text, target }) => (
|
||||
target.msgId === 'respond-resolved-answer'
|
||||
&& text.includes('已在其他客户端处理')
|
||||
)), true);
|
||||
});
|
||||
|
||||
test('QQ propagates the stop signal and cancels its pending question on abort', async () => {
|
||||
const fixture = stateFixture();
|
||||
fixture.sessions.set('c2c:owner-openid', 'stale-session');
|
||||
const controller = new AbortController();
|
||||
const interactionReady = deferred();
|
||||
let existsSignal;
|
||||
let createSignal;
|
||||
let askSignal;
|
||||
let cancellation;
|
||||
let cancellationSignal;
|
||||
const bridge = new QqHarnessBridge({
|
||||
bot: { sendText: async () => {} },
|
||||
ownerUserOpenid: 'owner-openid',
|
||||
signal: controller.signal,
|
||||
harness: {
|
||||
sessionExists: async (_sessionId, options) => {
|
||||
existsSignal = options.signal;
|
||||
return false;
|
||||
},
|
||||
createSession: async (options) => {
|
||||
createSignal = options.signal;
|
||||
return 'session-abort';
|
||||
},
|
||||
ask: async (sessionId, _text, options) => {
|
||||
askSignal = options.signal;
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'qq-abort-question',
|
||||
rpcId: 'qq-abort-question',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [{ id: 'answer', question: '等待进程停止' }],
|
||||
},
|
||||
respond: async (result, respondOptions) => {
|
||||
cancellation = result;
|
||||
cancellationSignal = respondOptions.signal;
|
||||
return { accepted: true };
|
||||
},
|
||||
});
|
||||
interactionReady.resolve();
|
||||
await new Promise((resolve, reject) => {
|
||||
options.signal.addEventListener('abort', () => reject(options.signal.reason), { once: true });
|
||||
});
|
||||
},
|
||||
},
|
||||
state: fixture.state,
|
||||
logger: { warn() {}, error() {} },
|
||||
});
|
||||
|
||||
const turn = bridge.accept(message({ messageId: 'abort-start', content: '启动后停止' }));
|
||||
await interactionReady.promise;
|
||||
controller.abort(new Error('runtime stopped'));
|
||||
await turn;
|
||||
|
||||
assert.equal(existsSignal, controller.signal);
|
||||
assert.equal(createSignal, controller.signal);
|
||||
assert.equal(askSignal, controller.signal);
|
||||
assert.deepEqual(cancellation, {
|
||||
ok: false,
|
||||
error: {
|
||||
code: 'cancelled',
|
||||
message: 'The QQ interaction ended before the user answered.',
|
||||
details: {},
|
||||
},
|
||||
});
|
||||
assert.notEqual(cancellationSignal, controller.signal);
|
||||
assert.equal(cancellationSignal.aborted, false);
|
||||
});
|
||||
|
|
|
|||
|
|
@ -4,6 +4,12 @@ import test from 'node:test';
|
|||
|
||||
import { QqRuntime } from '../../../src/channels/qq/qq-runtime.mjs';
|
||||
|
||||
function deferred() {
|
||||
let resolve;
|
||||
const promise = new Promise((done) => { resolve = done; });
|
||||
return { promise, resolve };
|
||||
}
|
||||
|
||||
class FakeBot extends EventEmitter {
|
||||
middlewares = [];
|
||||
stopped = false;
|
||||
|
|
@ -70,3 +76,59 @@ test('QQ runtime never reports ready when the gateway does not emit ready', asyn
|
|||
await assert.rejects(() => runtime.start(), /did not become ready/);
|
||||
assert.equal(runtime.status.ready, false);
|
||||
});
|
||||
|
||||
test('QQ runtime aborts an in-flight Harness interaction when stopped', async () => {
|
||||
const bot = new FakeBot();
|
||||
const askStarted = deferred();
|
||||
let askSignal;
|
||||
const runtime = new QqRuntime({
|
||||
config: { botId: 'qq_bot', appId: 'app', ownerUserOpenid: 'owner' },
|
||||
appSecret: 'secret',
|
||||
harness: {
|
||||
ensureRunning: async () => true,
|
||||
sessionExists: async () => true,
|
||||
ask: async (_sessionId, _text, options) => {
|
||||
askSignal = options.signal;
|
||||
askStarted.resolve();
|
||||
await new Promise((_resolve, reject) => options.signal.addEventListener('abort', () => {
|
||||
reject(options.signal.reason);
|
||||
}, { once: true }));
|
||||
},
|
||||
},
|
||||
state: {
|
||||
hasSeen: () => false,
|
||||
markSeen: async () => {},
|
||||
sessionFor: () => 'session-existing',
|
||||
setSession: async () => {},
|
||||
clearSession: async () => {},
|
||||
},
|
||||
createBot: () => bot,
|
||||
typingMiddleware: () => 'typing',
|
||||
connectTimeoutMs: 100,
|
||||
logger: { error() {}, warn() {}, info() {} },
|
||||
});
|
||||
|
||||
await runtime.start();
|
||||
bot.emit('message', {}, {
|
||||
kind: 'c2c',
|
||||
rawEventType: 'C2C_MESSAGE_CREATE',
|
||||
senderId: 'owner',
|
||||
senderIsBot: false,
|
||||
content: '需要交互',
|
||||
messageId: 'interaction-message',
|
||||
replyTarget: { scope: 'c2c', targetId: 'owner', msgId: 'interaction-message' },
|
||||
});
|
||||
await askStarted.promise;
|
||||
assert.equal(askSignal.aborted, false);
|
||||
bot.emit('message', {}, {
|
||||
kind: 'c2c',
|
||||
rawEventType: 'C2C_MESSAGE_CREATE',
|
||||
senderId: 'owner',
|
||||
senderIsBot: false,
|
||||
content: '排队中的下一条消息',
|
||||
messageId: 'queued-message',
|
||||
replyTarget: { scope: 'c2c', targetId: 'owner', msgId: 'queued-message' },
|
||||
});
|
||||
await runtime.stop();
|
||||
assert.equal(askSignal.aborted, true);
|
||||
});
|
||||
|
|
|
|||
634
test/channels/shared/text-harness-bridge.test.mjs
Normal file
634
test/channels/shared/text-harness-bridge.test.mjs
Normal file
|
|
@ -0,0 +1,634 @@
|
|||
import assert from 'node:assert/strict';
|
||||
import test from 'node:test';
|
||||
|
||||
import { TextHarnessBridge } from '../../../src/channels/shared/text-harness-bridge.mjs';
|
||||
|
||||
function deferred() {
|
||||
let resolve;
|
||||
let reject;
|
||||
const promise = new Promise((resolvePromise, rejectPromise) => {
|
||||
resolve = resolvePromise;
|
||||
reject = rejectPromise;
|
||||
});
|
||||
return { promise, resolve, reject };
|
||||
}
|
||||
|
||||
async function eventually(predicate, timeoutMs = 1_000) {
|
||||
const deadline = Date.now() + timeoutMs;
|
||||
while (Date.now() < deadline) {
|
||||
if (predicate()) return;
|
||||
await new Promise((resolve) => setTimeout(resolve, 5));
|
||||
}
|
||||
assert.fail('condition was not met before timeout');
|
||||
}
|
||||
|
||||
function stateFixture(initialSessions = {}) {
|
||||
const sessions = new Map(Object.entries(initialSessions));
|
||||
const seen = new Set();
|
||||
return {
|
||||
sessions,
|
||||
seen,
|
||||
state: {
|
||||
sessionFor(key) { return sessions.get(key) ?? null; },
|
||||
async setSession(key, sessionId) {
|
||||
sessions.set(key, sessionId);
|
||||
return true;
|
||||
},
|
||||
async clearSession(key) { sessions.delete(key); },
|
||||
hasSeen(messageId) { return seen.has(messageId); },
|
||||
async markSeen(messageId) { seen.add(messageId); },
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function message(messageId, content, overrides = {}) {
|
||||
return {
|
||||
messageId,
|
||||
senderId: 'actor-a',
|
||||
senderIsBot: false,
|
||||
kind: 'direct',
|
||||
conversationId: 'chat-a',
|
||||
content,
|
||||
addressed: true,
|
||||
replyTarget: { id: `target-${messageId}` },
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
function questionInteraction({
|
||||
id = 'question-one',
|
||||
sessionId = 'session-one',
|
||||
questions = [{ id: 'answer', question: '请回答' }],
|
||||
respond = async () => ({ accepted: true }),
|
||||
...rest
|
||||
} = {}) {
|
||||
return {
|
||||
kind: 'question',
|
||||
interactionId: id,
|
||||
rpcId: id,
|
||||
sessionId,
|
||||
payload: { type: 'question/requested', sessionId, questions },
|
||||
respond,
|
||||
...rest,
|
||||
};
|
||||
}
|
||||
|
||||
function createBridge({ harness, state, bot, signal, logger } = {}) {
|
||||
return new TextHarnessBridge({
|
||||
descriptor: { key: 'test', label: 'Test' },
|
||||
bot,
|
||||
harness,
|
||||
state,
|
||||
signal,
|
||||
logger: logger ?? { warn() {}, error() {} },
|
||||
});
|
||||
}
|
||||
|
||||
test('answers a multi-question interaction on the fast lane with canonical values', async () => {
|
||||
const fixture = stateFixture();
|
||||
const sent = [];
|
||||
const asked = [];
|
||||
const submitted = deferred();
|
||||
const bridge = createBridge({
|
||||
state: fixture.state,
|
||||
bot: { sendText: async (target, text) => sent.push({ target, text }) },
|
||||
harness: {
|
||||
createSession: async () => 'session-one',
|
||||
ask: async (sessionId, text, options) => {
|
||||
asked.push({ sessionId, text });
|
||||
await options.onInteraction(questionInteraction({
|
||||
sessionId,
|
||||
questions: [
|
||||
{
|
||||
id: 'language',
|
||||
question: '选择回答语言',
|
||||
options: [{ label: '中文' }, { label: 'English' }],
|
||||
},
|
||||
{
|
||||
id: 'deliverables',
|
||||
question: '选择交付内容',
|
||||
multiSelect: true,
|
||||
options: [{ label: '测试' }, { label: '文档' }],
|
||||
},
|
||||
],
|
||||
respond: async (result) => {
|
||||
submitted.resolve(result);
|
||||
return { accepted: true };
|
||||
},
|
||||
}));
|
||||
await submitted.promise;
|
||||
return '交互已完成';
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
const processing = bridge.accept(message('prompt', '请分步提问'));
|
||||
await eventually(() => sent.some(({ text }) => text.includes('选择回答语言')));
|
||||
await bridge.accept(message('language', '2'));
|
||||
await eventually(() => sent.some(({ text }) => text.includes('选择交付内容')));
|
||||
await bridge.accept(message('deliverables', '1，文档，发布说明'));
|
||||
|
||||
assert.deepEqual(await submitted.promise, {
|
||||
ok: true,
|
||||
value: {
|
||||
sessionId: 'session-one',
|
||||
answer: {
|
||||
answers: [
|
||||
{ id: 'language', selected: ['English'] },
|
||||
{ id: 'deliverables', selected: ['测试', '文档'], custom: '发布说明' },
|
||||
],
|
||||
},
|
||||
},
|
||||
});
|
||||
await processing;
|
||||
assert.deepEqual(asked, [{ sessionId: 'session-one', text: '请分步提问' }]);
|
||||
assert.equal(sent.at(-1).text, '交互已完成');
|
||||
assert.deepEqual(sent[1].target, { id: 'target-language' });
|
||||
});
|
||||
|
||||
test('isolates pending questions by normalized conversation key', async () => {
|
||||
const fixture = stateFixture({
|
||||
'direct:chat-a': 'session-a',
|
||||
'direct:chat-b': 'session-b',
|
||||
});
|
||||
const sent = [];
|
||||
const answeredA = deferred();
|
||||
const asked = [];
|
||||
const bridge = createBridge({
|
||||
state: fixture.state,
|
||||
bot: { sendText: async (target, text) => sent.push({ target, text }) },
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (sessionId, text, options) => {
|
||||
asked.push({ sessionId, text });
|
||||
if (sessionId === 'session-b') return '乙会话完成';
|
||||
await options.onInteraction(questionInteraction({
|
||||
id: 'question-a',
|
||||
sessionId,
|
||||
questions: [{ id: 'a', question: '甲会话的问题' }],
|
||||
respond: async (result) => {
|
||||
answeredA.resolve(result);
|
||||
return { accepted: true };
|
||||
},
|
||||
}));
|
||||
await answeredA.promise;
|
||||
return '甲会话完成';
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
const first = bridge.accept(message('a-start', '启动甲'));
|
||||
await eventually(() => sent.some(({ text }) => text.includes('甲会话的问题')));
|
||||
await bridge.accept(message('b-normal', '乙的普通问题', {
|
||||
senderId: 'actor-b',
|
||||
conversationId: 'chat-b',
|
||||
}));
|
||||
assert.deepEqual(asked, [
|
||||
{ sessionId: 'session-a', text: '启动甲' },
|
||||
{ sessionId: 'session-b', text: '乙的普通问题' },
|
||||
]);
|
||||
|
||||
await bridge.accept(message('a-answer', '甲的答案'));
|
||||
assert.deepEqual((await answeredA.promise).value.answer.answers, [
|
||||
{ id: 'a', selected: [], custom: '甲的答案' },
|
||||
]);
|
||||
await first;
|
||||
});
|
||||
|
||||
test('a group question only accepts an addressed reply from the initiating actor', async () => {
|
||||
const fixture = stateFixture({ 'group:room': 'session-group' });
|
||||
const sent = [];
|
||||
const submitted = deferred();
|
||||
const asked = [];
|
||||
let responseCalls = 0;
|
||||
const bridge = createBridge({
|
||||
state: fixture.state,
|
||||
bot: { sendText: async (target, text) => sent.push({ target, text }) },
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (sessionId, text, options) => {
|
||||
asked.push(text);
|
||||
if (text !== '甲发起交互') return '普通群消息已处理';
|
||||
await options.onInteraction(questionInteraction({
|
||||
id: 'group-question',
|
||||
sessionId,
|
||||
questions: [{ id: 'actor', question: '只能由甲回答' }],
|
||||
respond: async (result) => {
|
||||
responseCalls += 1;
|
||||
submitted.resolve(result);
|
||||
return { accepted: true };
|
||||
},
|
||||
}));
|
||||
await submitted.promise;
|
||||
return '甲的交互完成';
|
||||
},
|
||||
},
|
||||
});
|
||||
const group = { kind: 'group', conversationId: 'room' };
|
||||
|
||||
const first = bridge.accept(message('group-start', '甲发起交互', { ...group }));
|
||||
await eventually(() => sent.some(({ text }) => text.includes('只能由甲回答')));
|
||||
assert.match(sent[0].text, /群聊中请 @机器人/);
|
||||
|
||||
await bridge.accept(message('group-unaddressed', '没有 @ 的回答', {
|
||||
...group,
|
||||
addressed: false,
|
||||
}));
|
||||
const intruder = bridge.accept(message('group-intruder', '乙试图代答', {
|
||||
...group,
|
||||
senderId: 'actor-b',
|
||||
}));
|
||||
await new Promise((resolve) => setTimeout(resolve, 20));
|
||||
assert.equal(responseCalls, 0);
|
||||
assert.deepEqual(asked, ['甲发起交互']);
|
||||
|
||||
await bridge.accept(message('group-answer', '甲的真正答案', { ...group }));
|
||||
assert.deepEqual((await submitted.promise).value.answer.answers, [{
|
||||
id: 'actor',
|
||||
selected: [],
|
||||
custom: '甲的真正答案',
|
||||
}]);
|
||||
await Promise.all([first, intruder]);
|
||||
assert.deepEqual(asked, ['甲发起交互', '乙试图代答']);
|
||||
assert.equal(bridge.status.messagesRejected, 1);
|
||||
});
|
||||
|
||||
test('deduplicates replays, cancels parallel and recovered questions, and leaves approval pending', async () => {
|
||||
const fixture = stateFixture();
|
||||
const sent = [];
|
||||
let parallelResponse;
|
||||
let recoveredResponse;
|
||||
let approvalResponses = 0;
|
||||
const bridge = createBridge({
|
||||
state: fixture.state,
|
||||
bot: { sendText: async (target, text) => sent.push({ target, text }) },
|
||||
harness: {
|
||||
createSession: async () => 'session-one',
|
||||
ask: async (sessionId, _text, options) => {
|
||||
const current = questionInteraction({
|
||||
id: 'replayed-question',
|
||||
sessionId,
|
||||
questions: [{ id: 'current', question: '只应显示一次' }],
|
||||
});
|
||||
await options.onInteraction(current);
|
||||
await options.onInteraction(current);
|
||||
await options.onInteraction(questionInteraction({
|
||||
id: 'parallel-question',
|
||||
sessionId,
|
||||
questions: [{ id: 'parallel', question: '不应显示的并行问题' }],
|
||||
respond: async (result) => { parallelResponse = result; },
|
||||
}));
|
||||
await options.onInteraction({
|
||||
kind: 'approval',
|
||||
interactionId: 'approval-one',
|
||||
rpcId: 'approval-rpc',
|
||||
sessionId,
|
||||
payload: { type: 'approval/requested', approvalId: 'approval-one' },
|
||||
respond: async () => { approvalResponses += 1; },
|
||||
});
|
||||
await options.onInteraction(questionInteraction({
|
||||
id: 'orphan-question',
|
||||
sessionId,
|
||||
recovered: true,
|
||||
questions: [{ id: 'secret', question: '旧会话中的敏感问题内容' }],
|
||||
respond: async (result) => { recoveredResponse = result; },
|
||||
}));
|
||||
await options.onInteractionResolved({
|
||||
kind: 'question',
|
||||
interactionId: 'replayed-question',
|
||||
sessionId,
|
||||
outcome: 'cancelled',
|
||||
});
|
||||
return '已继续处理';
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
await bridge.accept(message('replay', '测试交互重放'));
|
||||
assert.equal(sent.filter(({ text }) => text.includes('只应显示一次')).length, 1);
|
||||
assert.equal(sent.some(({ text }) => text.includes('旧会话中的敏感问题内容')), false);
|
||||
assert.equal(sent.some(({ text }) => text.includes('遗留的待回答问题')), true);
|
||||
assert.deepEqual(parallelResponse?.error, {
|
||||
code: 'cancelled',
|
||||
message: 'Test is already handling another user interaction.',
|
||||
details: {},
|
||||
});
|
||||
assert.deepEqual(recoveredResponse?.error, {
|
||||
code: 'cancelled',
|
||||
message: 'Test safely cancelled an interaction left by an earlier client.',
|
||||
details: {},
|
||||
});
|
||||
assert.equal(approvalResponses, 0);
|
||||
});
|
||||
|
||||
test('keeps a failed interaction response pending so the actor can retry', async () => {
|
||||
const fixture = stateFixture();
|
||||
const sent = [];
|
||||
const completed = deferred();
|
||||
const submittedAnswers = [];
|
||||
const bridge = createBridge({
|
||||
state: fixture.state,
|
||||
bot: { sendText: async (target, text) => sent.push({ target, text }) },
|
||||
harness: {
|
||||
createSession: async () => 'session-one',
|
||||
ask: async (sessionId, _text, options) => {
|
||||
await options.onInteraction(questionInteraction({
|
||||
id: 'retry-question',
|
||||
sessionId,
|
||||
respond: async (result) => {
|
||||
submittedAnswers.push(result.value.answer.answers[0].custom);
|
||||
if (submittedAnswers.length === 1) throw new Error('temporary failure');
|
||||
completed.resolve();
|
||||
return { accepted: true };
|
||||
},
|
||||
}));
|
||||
await completed.promise;
|
||||
return '重试成功';
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
const processing = bridge.accept(message('retry-start', '启动可重试交互'));
|
||||
await eventually(() => sent.some(({ text }) => text.includes('请回答')));
|
||||
await bridge.accept(message('retry-first', '第一次答案'));
|
||||
assert.equal(sent.some(({ text }) => text.includes('回答提交失败')), true);
|
||||
await bridge.accept(message('retry-second', '重试后的答案'));
|
||||
await processing;
|
||||
|
||||
assert.deepEqual(submittedAnswers, ['第一次答案', '重试后的答案']);
|
||||
assert.equal(sent.at(-1).text, '重试成功');
|
||||
});
|
||||
|
||||
test('notifies the actor when an in-flight response resolves elsewhere before rejection', async () => {
|
||||
const fixture = stateFixture();
|
||||
const sent = [];
|
||||
const responseStarted = deferred();
|
||||
const asked = [];
|
||||
const bridge = createBridge({
|
||||
state: fixture.state,
|
||||
bot: { sendText: async (target, text) => sent.push({ target, text }) },
|
||||
harness: {
|
||||
createSession: async () => 'session-one',
|
||||
ask: async (sessionId, text, options) => {
|
||||
asked.push(text);
|
||||
await options.onInteraction(questionInteraction({
|
||||
id: 'response-resolved-race',
|
||||
sessionId,
|
||||
respond: async () => {
|
||||
options.onInteractionResolved({
|
||||
kind: 'question',
|
||||
interactionId: 'response-resolved-race',
|
||||
sessionId,
|
||||
outcome: 'answered',
|
||||
});
|
||||
responseStarted.resolve();
|
||||
const error = new Error('interaction no longer pending');
|
||||
error.code = 'interaction-not-pending';
|
||||
throw error;
|
||||
},
|
||||
}));
|
||||
await responseStarted.promise;
|
||||
return '原会话已结束';
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
const processing = bridge.accept(message('response-race-start', '启动提交竞态'));
|
||||
await eventually(() => sent.some(({ text }) => text.includes('请回答')));
|
||||
await bridge.accept(message('response-race-answer', '已经收到的答案'));
|
||||
await processing;
|
||||
|
||||
assert.deepEqual(asked, ['启动提交竞态']);
|
||||
assert.equal(sent.some(({ text }) => text.includes('已在其他客户端处理')), true);
|
||||
});
|
||||
|
||||
test('discards a claimed answer when the interaction resolves during message recording', async () => {
|
||||
const fixture = stateFixture({ 'direct:chat-a': 'session-one' });
|
||||
const originalMarkSeen = fixture.state.markSeen;
|
||||
const answerMarkStarted = deferred();
|
||||
const releaseAnswerMark = deferred();
|
||||
fixture.state.markSeen = async (messageId) => {
|
||||
if (messageId === 'racing-answer') {
|
||||
answerMarkStarted.resolve();
|
||||
await releaseAnswerMark.promise;
|
||||
}
|
||||
await originalMarkSeen(messageId);
|
||||
};
|
||||
const sent = [];
|
||||
const asked = [];
|
||||
const externallyResolved = deferred();
|
||||
let resolveInteraction;
|
||||
const bridge = createBridge({
|
||||
state: fixture.state,
|
||||
bot: { sendText: async (target, text) => sent.push({ target, text }) },
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (sessionId, text, options) => {
|
||||
asked.push(text);
|
||||
if (text === '后来的普通问题') return '后来问题的回答';
|
||||
await options.onInteraction(questionInteraction({
|
||||
id: 'resolved-race-question',
|
||||
sessionId,
|
||||
}));
|
||||
resolveInteraction = () => {
|
||||
options.onInteractionResolved({
|
||||
kind: 'question',
|
||||
interactionId: 'resolved-race-question',
|
||||
sessionId,
|
||||
outcome: 'answered',
|
||||
});
|
||||
externallyResolved.resolve();
|
||||
};
|
||||
await externallyResolved.promise;
|
||||
return '第一轮已由其他客户端完成';
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
const processing = bridge.accept(message('race-start', '启动外部解决竞态'));
|
||||
await eventually(() => typeof resolveInteraction === 'function');
|
||||
const answer = bridge.accept(message('racing-answer', '原本的问题答案'));
|
||||
await answerMarkStarted.promise;
|
||||
resolveInteraction();
|
||||
releaseAnswerMark.resolve();
|
||||
await Promise.all([processing, answer]);
|
||||
await bridge.accept(message('later-prompt', '后来的普通问题'));
|
||||
|
||||
assert.deepEqual(asked, ['启动外部解决竞态', '后来的普通问题']);
|
||||
assert.equal(asked.includes('原本的问题答案'), false);
|
||||
assert.equal(sent.some(({ text }) => text.includes('已在其他客户端处理')), true);
|
||||
});
|
||||
|
||||
test('accepts a first answer received while its question presentation is still in flight', async () => {
|
||||
const fixture = stateFixture();
|
||||
const presentationStarted = deferred();
|
||||
const releasePresentation = deferred();
|
||||
const submitted = deferred();
|
||||
const sent = [];
|
||||
const asked = [];
|
||||
let questionPresentations = 0;
|
||||
const bridge = createBridge({
|
||||
state: fixture.state,
|
||||
bot: {
|
||||
sendText: async (target, text) => {
|
||||
sent.push({ target, text });
|
||||
if (text.includes('发送仍在进行的问题')) {
|
||||
questionPresentations += 1;
|
||||
presentationStarted.resolve();
|
||||
await releasePresentation.promise;
|
||||
}
|
||||
},
|
||||
},
|
||||
harness: {
|
||||
createSession: async () => 'session-one',
|
||||
ask: async (sessionId, text, options) => {
|
||||
asked.push(text);
|
||||
await options.onInteraction(questionInteraction({
|
||||
id: 'first-presentation-race',
|
||||
sessionId,
|
||||
questions: [{ id: 'first', question: '发送仍在进行的问题' }],
|
||||
respond: async (result) => {
|
||||
submitted.resolve(result);
|
||||
return { accepted: true };
|
||||
},
|
||||
}));
|
||||
await submitted.promise;
|
||||
return '首问已回答';
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
const processing = bridge.accept(message('presentation-start', '启动首问竞态'));
|
||||
await presentationStarted.promise;
|
||||
const answer = bridge.accept(message('presentation-answer', '首问答案'));
|
||||
releasePresentation.resolve();
|
||||
await Promise.all([processing, answer]);
|
||||
|
||||
assert.deepEqual((await submitted.promise).value.answer.answers, [{
|
||||
id: 'first',
|
||||
selected: [],
|
||||
custom: '首问答案',
|
||||
}]);
|
||||
assert.deepEqual(asked, ['启动首问竞态']);
|
||||
assert.equal(questionPresentations, 1);
|
||||
assert.equal(sent.at(-1).text, '首问已回答');
|
||||
});
|
||||
|
||||
test('discards an answer already received when a later question resolves during presentation', async () => {
|
||||
const fixture = stateFixture();
|
||||
const secondPresentationStarted = deferred();
|
||||
const releaseSecondPresentation = deferred();
|
||||
const externallyResolved = deferred();
|
||||
const sent = [];
|
||||
const asked = [];
|
||||
let resolveInteraction;
|
||||
const bridge = createBridge({
|
||||
state: fixture.state,
|
||||
bot: {
|
||||
sendText: async (target, text) => {
|
||||
sent.push({ target, text });
|
||||
if (text.includes('仍在发送的第二问')) {
|
||||
secondPresentationStarted.resolve();
|
||||
await releaseSecondPresentation.promise;
|
||||
}
|
||||
},
|
||||
},
|
||||
harness: {
|
||||
createSession: async () => 'session-one',
|
||||
ask: async (sessionId, text, options) => {
|
||||
asked.push(text);
|
||||
if (text !== '启动第二问竞态') return '不应把第二问答案作为新 prompt';
|
||||
await options.onInteraction(questionInteraction({
|
||||
id: 'second-presentation-race',
|
||||
sessionId,
|
||||
questions: [
|
||||
{ id: 'first', question: '第一问' },
|
||||
{ id: 'second', question: '仍在发送的第二问' },
|
||||
],
|
||||
}));
|
||||
resolveInteraction = () => {
|
||||
options.onInteractionResolved({
|
||||
kind: 'question',
|
||||
interactionId: 'second-presentation-race',
|
||||
sessionId,
|
||||
outcome: 'answered',
|
||||
});
|
||||
externallyResolved.resolve();
|
||||
};
|
||||
await externallyResolved.promise;
|
||||
return '已由其他客户端完成';
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
const processing = bridge.accept(message('second-race-start', '启动第二问竞态'));
|
||||
await eventually(() => typeof resolveInteraction === 'function');
|
||||
const firstAnswer = bridge.accept(message('second-race-first', '第一问答案'));
|
||||
await secondPresentationStarted.promise;
|
||||
const secondAnswer = bridge.accept(message('second-race-second', '第二问已收到的答案'));
|
||||
resolveInteraction();
|
||||
releaseSecondPresentation.resolve();
|
||||
await Promise.all([processing, firstAnswer, secondAnswer]);
|
||||
|
||||
assert.deepEqual(asked, ['启动第二问竞态']);
|
||||
assert.equal(asked.includes('第二问已收到的答案'), false);
|
||||
assert.equal(sent.some(({ text }) => text.includes('已在其他客户端处理')), true);
|
||||
});
|
||||
|
||||
test('passes the runtime signal to Harness and safely cancels a pending question on abort', async () => {
|
||||
const controller = new AbortController();
|
||||
const fixture = stateFixture({ 'direct:chat-a': 'stale-session' });
|
||||
const sent = [];
|
||||
const cancelled = deferred();
|
||||
let existsSignal;
|
||||
let createSignal;
|
||||
let askSignal;
|
||||
const bridge = createBridge({
|
||||
state: fixture.state,
|
||||
signal: controller.signal,
|
||||
bot: { sendText: async (target, text) => sent.push({ target, text }) },
|
||||
harness: {
|
||||
sessionExists: async (_sessionId, options) => {
|
||||
existsSignal = options?.signal;
|
||||
return false;
|
||||
},
|
||||
createSession: async (options) => {
|
||||
createSignal = options?.signal;
|
||||
return 'session-one';
|
||||
},
|
||||
ask: async (sessionId, _text, options) => {
|
||||
askSignal = options.signal;
|
||||
await options.onInteraction(questionInteraction({
|
||||
id: 'abort-question',
|
||||
sessionId,
|
||||
respond: async (result) => {
|
||||
cancelled.resolve(result);
|
||||
return { accepted: true };
|
||||
},
|
||||
}));
|
||||
await new Promise((resolve, reject) => {
|
||||
options.signal.addEventListener('abort', () => reject(options.signal.reason), {
|
||||
once: true,
|
||||
});
|
||||
});
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
const processing = bridge.accept(message('abort-start', '启动后停止'));
|
||||
await eventually(() => sent.some(({ text }) => text.includes('请回答')));
|
||||
controller.abort(new DOMException('runtime stopped', 'AbortError'));
|
||||
await processing;
|
||||
|
||||
assert.equal(existsSignal, controller.signal);
|
||||
assert.equal(createSignal, controller.signal);
|
||||
assert.equal(askSignal, controller.signal);
|
||||
assert.deepEqual(await cancelled.promise, {
|
||||
ok: false,
|
||||
error: {
|
||||
code: 'cancelled',
|
||||
message: 'The Test interaction ended before the user answered.',
|
||||
details: {},
|
||||
},
|
||||
});
|
||||
});
|
||||
|
|
@ -46,6 +46,25 @@ function credentials() {
|
|||
};
|
||||
}
|
||||
|
||||
function deferred() {
|
||||
let resolve;
|
||||
let reject;
|
||||
const promise = new Promise((resolvePromise, rejectPromise) => {
|
||||
resolve = resolvePromise;
|
||||
reject = rejectPromise;
|
||||
});
|
||||
return { promise, resolve, reject };
|
||||
}
|
||||
|
||||
async function eventually(predicate, timeoutMs = 1_000) {
|
||||
const deadline = Date.now() + timeoutMs;
|
||||
while (Date.now() < deadline) {
|
||||
if (predicate()) return;
|
||||
await new Promise((resolve) => setTimeout(resolve, 5));
|
||||
}
|
||||
assert.fail('condition was not met before timeout');
|
||||
}
|
||||
|
||||
test('Slack validates both tokens and inspects Bot and Socket Mode credentials', async () => {
|
||||
assert.equal(validSlackBotToken(BOT_TOKEN), true);
|
||||
assert.equal(validSlackAppToken(APP_TOKEN), true);
|
||||
|
|
@ -269,6 +288,9 @@ class FakeSocket {
|
|||
|
||||
test('Slack runtime opens Socket Mode, acknowledges envelopes, and becomes ready', async () => {
|
||||
let socket;
|
||||
const abortMark = deferred();
|
||||
let abortMarkStarted = false;
|
||||
const errors = [];
|
||||
const runtime = new SlackRuntime({
|
||||
config: {
|
||||
botId: 'slack_test',
|
||||
|
|
@ -283,7 +305,13 @@ test('Slack runtime opens Socket Mode, acknowledges envelopes, and becomes ready
|
|||
setSession: async () => {},
|
||||
clearSession: async () => {},
|
||||
hasSeen: () => false,
|
||||
markSeen: async () => {},
|
||||
markSeen: async (messageId) => {
|
||||
if (messageId === 'Ev-abort') {
|
||||
abortMarkStarted = true;
|
||||
return abortMark.promise;
|
||||
}
|
||||
throw new Error(`Slack state write failed for ${messageId}`);
|
||||
},
|
||||
},
|
||||
createApi: () => ({
|
||||
authTest: async () => ({ team_id: 'T12345678', user_id: 'U12345678' }),
|
||||
|
|
@ -299,6 +327,10 @@ test('Slack runtime opens Socket Mode, acknowledges envelopes, and becomes ready
|
|||
}));
|
||||
return socket;
|
||||
},
|
||||
logger: {
|
||||
warn() {},
|
||||
error(...args) { errors.push(args); },
|
||||
},
|
||||
});
|
||||
await runtime.start();
|
||||
assert.equal(runtime.status.ready, true);
|
||||
|
|
@ -310,6 +342,55 @@ test('Slack runtime opens Socket Mode, acknowledges envelopes, and becomes ready
|
|||
}),
|
||||
});
|
||||
assert.deepEqual(socket.sent.at(-1), { envelope_id: 'env-1' });
|
||||
await runtime.stop();
|
||||
|
||||
for (const eventId of ['Ev-failed-first', 'Ev-failed-queued']) {
|
||||
socket.emit('message', {
|
||||
data: JSON.stringify({
|
||||
envelope_id: `env-${eventId}`,
|
||||
type: 'events_api',
|
||||
payload: {
|
||||
type: 'event_callback',
|
||||
api_app_id: 'A12345678',
|
||||
event_id: eventId,
|
||||
event: {
|
||||
type: 'message',
|
||||
channel_type: 'im',
|
||||
channel: 'D12345678',
|
||||
user: 'U87654321',
|
||||
ts: eventId === 'Ev-failed-first' ? '1700000000.010' : '1700000000.011',
|
||||
text: 'trigger state failure',
|
||||
},
|
||||
},
|
||||
}),
|
||||
});
|
||||
}
|
||||
await eventually(() => errors.length === 2);
|
||||
assert.equal(errors.every((args) => args[0].includes('message handling failed')), true);
|
||||
|
||||
socket.emit('message', {
|
||||
data: JSON.stringify({
|
||||
envelope_id: 'env-abort',
|
||||
type: 'events_api',
|
||||
payload: {
|
||||
type: 'event_callback',
|
||||
api_app_id: 'A12345678',
|
||||
event_id: 'Ev-abort',
|
||||
event: {
|
||||
type: 'message',
|
||||
channel_type: 'im',
|
||||
channel: 'D12345678',
|
||||
user: 'U87654321',
|
||||
ts: '1700000000.012',
|
||||
text: 'abort state write',
|
||||
},
|
||||
},
|
||||
}),
|
||||
});
|
||||
await eventually(() => abortMarkStarted);
|
||||
const stopping = runtime.stop();
|
||||
abortMark.reject(new Error('Slack state write aborted'));
|
||||
await stopping;
|
||||
await new Promise((resolve) => setImmediate(resolve));
|
||||
assert.equal(errors.length, 2);
|
||||
assert.equal(runtime.status.ready, false);
|
||||
});
|
||||
|
|
|
|||
|
|
@ -58,6 +58,30 @@ function memoryState() {
|
|||
};
|
||||
}
|
||||
|
||||
function deferred() {
|
||||
let resolve;
|
||||
let reject;
|
||||
const promise = new Promise((resolvePromise, rejectPromise) => {
|
||||
resolve = resolvePromise;
|
||||
reject = rejectPromise;
|
||||
});
|
||||
return { promise, resolve, reject };
|
||||
}
|
||||
|
||||
async function bounded(promise, message, timeoutMs = 1_000) {
|
||||
let timer;
|
||||
try {
|
||||
return await Promise.race([
|
||||
promise,
|
||||
new Promise((_, reject) => {
|
||||
timer = setTimeout(() => reject(new Error(message)), timeoutMs);
|
||||
}),
|
||||
]);
|
||||
} finally {
|
||||
clearTimeout(timer);
|
||||
}
|
||||
}
|
||||
|
||||
test('Telegram API validates a Bot Token without exposing it in requests or errors', async () => {
|
||||
assert.equal(validTelegramToken(TOKEN), true);
|
||||
assert.equal(validTelegramToken('short'), false);
|
||||
|
|
@ -198,6 +222,34 @@ test('Telegram normalizes private messages and requires an explicit group addres
|
|||
assert.equal(groupMessage.kind, 'group');
|
||||
assert.equal(groupMessage.addressed, true);
|
||||
assert.equal(groupMessage.content, 'run this');
|
||||
|
||||
const topicOne = normalizeTelegramUpdate({
|
||||
update_id: 12,
|
||||
message: {
|
||||
message_id: 6,
|
||||
message_thread_id: 100,
|
||||
chat: { id: -1001, type: 'supergroup' },
|
||||
from: { id: 43, is_bot: false },
|
||||
text: '@HarnessBot first topic',
|
||||
entities: [{ type: 'mention', offset: 0, length: 11 }],
|
||||
},
|
||||
}, { botId: '123456789', username: 'HarnessBot' });
|
||||
const topicTwo = normalizeTelegramUpdate({
|
||||
update_id: 13,
|
||||
message: {
|
||||
message_id: 7,
|
||||
message_thread_id: 200,
|
||||
chat: { id: -1001, type: 'supergroup' },
|
||||
from: { id: 43, is_bot: false },
|
||||
text: '@HarnessBot second topic',
|
||||
entities: [{ type: 'mention', offset: 0, length: 11 }],
|
||||
},
|
||||
}, { botId: '123456789', username: 'HarnessBot' });
|
||||
assert.equal(topicOne.conversationId, '-1001:100');
|
||||
assert.equal(topicTwo.conversationId, '-1001:200');
|
||||
assert.notEqual(topicOne.conversationId, topicTwo.conversationId);
|
||||
assert.equal(topicOne.replyTarget.messageThreadId, 100);
|
||||
assert.equal(topicTwo.replyTarget.messageThreadId, 200);
|
||||
});
|
||||
|
||||
test('Telegram bridge ignores unaddressed groups and streams direct replies', async () => {
|
||||
|
|
@ -272,3 +324,171 @@ test('Telegram runtime validates webhook state and starts a cancellable long pol
|
|||
assert.deepEqual(calls[0], { offset: -1, timeout: 0 });
|
||||
await rm(directory, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
test('Telegram runtime keeps polling while a Harness question waits for its answer', async () => {
|
||||
const directory = await mkdtemp(join(tmpdir(), 'dsh-im-telegram-interaction-'));
|
||||
const state = await new TelegramStateStore(join(directory, 'state.json')).load();
|
||||
const questionSent = deferred();
|
||||
const secondPollStarted = deferred();
|
||||
const answerSubmitted = deferred();
|
||||
const releaseTurn = deferred();
|
||||
const finalReplySent = deferred();
|
||||
const pollOffsets = [];
|
||||
const asked = [];
|
||||
let answerUpdateDelivered = false;
|
||||
let originalTurnEnded = false;
|
||||
let nextOutboundMessageId = 500;
|
||||
|
||||
const promptUpdate = {
|
||||
update_id: 10,
|
||||
message: {
|
||||
message_id: 100,
|
||||
chat: { id: 42, type: 'private' },
|
||||
from: { id: 7, is_bot: false },
|
||||
text: '请先询问测试环境',
|
||||
},
|
||||
};
|
||||
const answerUpdate = {
|
||||
update_id: 11,
|
||||
message: {
|
||||
message_id: 101,
|
||||
chat: { id: 42, type: 'private' },
|
||||
from: { id: 7, is_bot: false },
|
||||
text: '2',
|
||||
},
|
||||
};
|
||||
const fakeApi = {
|
||||
getMe: async () => ({ id: 123456789, is_bot: true }),
|
||||
getWebhookInfo: async () => ({ url: '' }),
|
||||
getUpdates: async ({ offset, timeout, signal }) => {
|
||||
pollOffsets.push(offset);
|
||||
if (timeout === 0) return [];
|
||||
if (offset === 0) return [promptUpdate];
|
||||
if (offset === 11) {
|
||||
secondPollStarted.resolve(originalTurnEnded);
|
||||
await questionSent.promise;
|
||||
answerUpdateDelivered = true;
|
||||
return [answerUpdate];
|
||||
}
|
||||
assert.equal(offset, 12);
|
||||
return new Promise((resolve, reject) => {
|
||||
if (signal.aborted) {
|
||||
reject(signal.reason);
|
||||
return;
|
||||
}
|
||||
signal.addEventListener('abort', () => reject(signal.reason), { once: true });
|
||||
});
|
||||
},
|
||||
sendChatAction: async () => true,
|
||||
sendMessage: async ({ text }) => {
|
||||
const messageId = nextOutboundMessageId;
|
||||
nextOutboundMessageId += 1;
|
||||
if (text.includes('请选择测试环境')) questionSent.resolve();
|
||||
return { message_id: messageId };
|
||||
},
|
||||
editMessageText: async ({ text }) => {
|
||||
if (text === '已选择生产环境') finalReplySent.resolve();
|
||||
return true;
|
||||
},
|
||||
};
|
||||
const harness = {
|
||||
ensureRunning: async () => true,
|
||||
createSession: async () => 'session-runtime-interaction',
|
||||
ask: async (sessionId, text, options) => {
|
||||
asked.push({ sessionId, text });
|
||||
if (text !== '请先询问测试环境') return '不应将答案当成新 prompt';
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'telegram-runtime-question',
|
||||
rpcId: 'telegram-runtime-question',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [{
|
||||
id: 'environment',
|
||||
question: '请选择测试环境',
|
||||
options: [{ label: '测试环境' }, { label: '生产环境' }],
|
||||
}],
|
||||
},
|
||||
respond: async (result) => {
|
||||
assert.equal(answerUpdateDelivered, true);
|
||||
assert.equal(originalTurnEnded, false);
|
||||
answerSubmitted.resolve(result);
|
||||
return { accepted: true };
|
||||
},
|
||||
});
|
||||
await Promise.race([
|
||||
answerSubmitted.promise,
|
||||
new Promise((_, reject) => {
|
||||
options.signal.addEventListener('abort', () => reject(options.signal.reason), {
|
||||
once: true,
|
||||
});
|
||||
}),
|
||||
]);
|
||||
await releaseTurn.promise;
|
||||
originalTurnEnded = true;
|
||||
return '已选择生产环境';
|
||||
},
|
||||
};
|
||||
const runtime = new TelegramRuntime({
|
||||
config: {
|
||||
botId: 'telegram_interaction',
|
||||
platformId: '123456789',
|
||||
username: 'HarnessBot',
|
||||
},
|
||||
token: TOKEN,
|
||||
harness,
|
||||
state,
|
||||
createApi: () => fakeApi,
|
||||
logger: { error() {}, warn() {} },
|
||||
});
|
||||
|
||||
try {
|
||||
await runtime.start();
|
||||
assert.equal(await bounded(
|
||||
secondPollStarted.promise,
|
||||
'poller did not request the answer update while the first turn was active',
|
||||
), false);
|
||||
const submitted = await bounded(
|
||||
answerSubmitted.promise,
|
||||
'the Telegram answer was not submitted through the interaction fast path',
|
||||
);
|
||||
assert.deepEqual(submitted, {
|
||||
ok: true,
|
||||
value: {
|
||||
sessionId: 'session-runtime-interaction',
|
||||
answer: {
|
||||
answers: [{ id: 'environment', selected: ['生产环境'] }],
|
||||
},
|
||||
},
|
||||
});
|
||||
assert.equal(originalTurnEnded, false);
|
||||
assert.deepEqual(asked, [{
|
||||
sessionId: 'session-runtime-interaction',
|
||||
text: '请先询问测试环境',
|
||||
}]);
|
||||
|
||||
await bounded((async () => {
|
||||
while (state.cursor() !== 12) {
|
||||
await new Promise((resolve) => setTimeout(resolve, 5));
|
||||
}
|
||||
})(), 'Telegram cursor did not advance past the answer update');
|
||||
assert.deepEqual(pollOffsets.slice(0, 4), [-1, 0, 11, 12]);
|
||||
assert.equal(state.hasSeen('10'), true);
|
||||
assert.equal(state.hasSeen('11'), true);
|
||||
|
||||
releaseTurn.resolve();
|
||||
await bounded(finalReplySent.promise, 'the original Harness turn did not finish');
|
||||
await new Promise((resolve) => setTimeout(resolve, 20));
|
||||
assert.equal(originalTurnEnded, true);
|
||||
assert.deepEqual(asked, [{
|
||||
sessionId: 'session-runtime-interaction',
|
||||
text: '请先询问测试环境',
|
||||
}]);
|
||||
} finally {
|
||||
releaseTurn.resolve();
|
||||
await runtime.stop();
|
||||
await rm(directory, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
|
|
|||
|
|
@ -30,6 +30,67 @@ function state() {
|
|||
};
|
||||
}
|
||||
|
||||
function deferred() {
|
||||
let resolve;
|
||||
let reject;
|
||||
const promise = new Promise((resolvePromise, rejectPromise) => {
|
||||
resolve = resolvePromise;
|
||||
reject = rejectPromise;
|
||||
});
|
||||
return { promise, resolve, reject };
|
||||
}
|
||||
|
||||
async function eventually(predicate, timeoutMs = 1_000) {
|
||||
const deadline = Date.now() + timeoutMs;
|
||||
while (Date.now() < deadline) {
|
||||
if (predicate()) return;
|
||||
await new Promise((resolve) => setTimeout(resolve, 1));
|
||||
}
|
||||
throw new Error('condition did not become true');
|
||||
}
|
||||
|
||||
function testClient() {
|
||||
const streamed = [];
|
||||
const active = [];
|
||||
return {
|
||||
streamed,
|
||||
active,
|
||||
client: {
|
||||
replyStream: async (source, streamId, content, finish) => {
|
||||
streamed.push({ messageId: source.body.msgid, streamId, content, finish });
|
||||
},
|
||||
replyStreamNonBlocking: async (source, streamId, content, finish) => {
|
||||
streamed.push({ messageId: source.body.msgid, streamId, content, finish });
|
||||
},
|
||||
sendMessage: async (chatId, body) => active.push({ chatId, body }),
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function questionInteraction({
|
||||
interactionId = 'question-1',
|
||||
sessionId = 'session-existing',
|
||||
questions = [{
|
||||
id: 'environment',
|
||||
question: '请选择测试环境',
|
||||
options: [{ label: '测试环境' }, { label: '生产环境' }],
|
||||
}],
|
||||
recovered = false,
|
||||
respond = async () => {},
|
||||
reconnect = () => {},
|
||||
} = {}) {
|
||||
return {
|
||||
kind: 'question',
|
||||
interactionId,
|
||||
rpcId: interactionId,
|
||||
sessionId,
|
||||
payload: { questions },
|
||||
recovered,
|
||||
respond,
|
||||
reconnect,
|
||||
};
|
||||
}
|
||||
|
||||
test('Enterprise WeChat messages stream Harness progress and finalize once', async () => {
|
||||
const replies = [];
|
||||
const active = [];
|
||||
|
|
@ -109,3 +170,625 @@ test('Enterprise WeChat finalizes an existing progress stream when Harness fails
|
|||
]);
|
||||
assert.equal(store.seen.has('msg-1'), true);
|
||||
});
|
||||
|
||||
test('an Enterprise WeChat answer bypasses the original conversation queue', async () => {
|
||||
const transport = testClient();
|
||||
const answered = deferred();
|
||||
const responses = [];
|
||||
const bridge = new WecomHarnessBridge({
|
||||
client: transport.client,
|
||||
generateStreamId: (() => { let index = 0; return () => `stream-${++index}`; })(),
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (_sessionId, _text, options) => {
|
||||
await options.onInteraction(questionInteraction({
|
||||
respond: async (result) => {
|
||||
responses.push(result);
|
||||
answered.resolve();
|
||||
},
|
||||
}));
|
||||
await answered.promise;
|
||||
return '你选择了：测试环境';
|
||||
},
|
||||
},
|
||||
state: state(),
|
||||
});
|
||||
|
||||
const prompt = bridge.accept(frame({ msgid: 'question-start' }));
|
||||
await eventually(() => transport.active.some(({ body }) => (
|
||||
body.markdown.content.includes('请选择测试环境')
|
||||
)));
|
||||
const answer = bridge.accept(frame({
|
||||
msgid: 'question-answer',
|
||||
text: { content: '1' },
|
||||
}));
|
||||
await Promise.all([prompt, answer]);
|
||||
|
||||
assert.deepEqual(responses, [{
|
||||
ok: true,
|
||||
value: {
|
||||
sessionId: 'session-existing',
|
||||
answer: { answers: [{ id: 'environment', selected: ['测试环境'] }] },
|
||||
},
|
||||
}]);
|
||||
assert.equal(transport.streamed.at(-1).content, '你选择了：测试环境');
|
||||
assert.equal(transport.streamed.at(-1).finish, true);
|
||||
});
|
||||
|
||||
test('an answer waits for the first Enterprise WeChat question delivery acknowledgement', async () => {
|
||||
const questionSendStarted = deferred();
|
||||
const questionAcknowledged = deferred();
|
||||
const answered = deferred();
|
||||
const streamed = [];
|
||||
const active = [];
|
||||
const prompts = [];
|
||||
const responses = [];
|
||||
const bridge = new WecomHarnessBridge({
|
||||
client: {
|
||||
replyStream: async (source, streamId, content, finish) => {
|
||||
streamed.push({ messageId: source.body.msgid, streamId, content, finish });
|
||||
},
|
||||
sendMessage: async (chatId, body) => {
|
||||
active.push({ chatId, body });
|
||||
questionSendStarted.resolve();
|
||||
await questionAcknowledged.promise;
|
||||
},
|
||||
},
|
||||
generateStreamId: (() => { let index = 0; return () => `first-ack-${++index}`; })(),
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (_sessionId, text, options) => {
|
||||
prompts.push(text);
|
||||
await options.onInteraction(questionInteraction({
|
||||
interactionId: 'first-ack-question',
|
||||
respond: async (result) => {
|
||||
responses.push(result);
|
||||
answered.resolve();
|
||||
},
|
||||
}));
|
||||
await answered.promise;
|
||||
return '首问回答完成';
|
||||
},
|
||||
},
|
||||
state: state(),
|
||||
});
|
||||
|
||||
const prompt = bridge.accept(frame({ msgid: 'first-ack-start' }));
|
||||
await questionSendStarted.promise;
|
||||
let answerSettled = false;
|
||||
const answer = bridge.accept(frame({
|
||||
msgid: 'first-ack-answer',
|
||||
text: { content: '1' },
|
||||
}));
|
||||
answer.then(
|
||||
() => { answerSettled = true; },
|
||||
() => { answerSettled = true; },
|
||||
);
|
||||
await new Promise((resolve) => setImmediate(resolve));
|
||||
|
||||
assert.equal(answerSettled, false);
|
||||
assert.equal(active.length, 1);
|
||||
assert.deepEqual(responses, []);
|
||||
|
||||
questionAcknowledged.resolve();
|
||||
await eventually(() => responses.length === 1);
|
||||
await Promise.all([prompt, answer]);
|
||||
|
||||
assert.deepEqual(prompts, ['请回答']);
|
||||
assert.equal(active.length, 1);
|
||||
assert.deepEqual(responses[0].value.answer.answers, [
|
||||
{ id: 'environment', selected: ['测试环境'] },
|
||||
]);
|
||||
assert.equal(streamed.at(-1).content, '首问回答完成');
|
||||
});
|
||||
|
||||
test('pending Enterprise WeChat questions stay isolated by conversation', async () => {
|
||||
const transport = testClient();
|
||||
const gates = new Map([
|
||||
['ask-a', deferred()],
|
||||
['ask-b', deferred()],
|
||||
]);
|
||||
const responses = [];
|
||||
const bridge = new WecomHarnessBridge({
|
||||
client: transport.client,
|
||||
generateStreamId: (() => { let index = 0; return () => `isolation-${++index}`; })(),
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (_sessionId, text, options) => {
|
||||
const gate = gates.get(text);
|
||||
await options.onInteraction(questionInteraction({
|
||||
interactionId: `question-${text}`,
|
||||
respond: async (result) => {
|
||||
responses.push({ text, result });
|
||||
gate.resolve();
|
||||
},
|
||||
}));
|
||||
await gate.promise;
|
||||
return `done-${text}`;
|
||||
},
|
||||
},
|
||||
state: state(),
|
||||
});
|
||||
|
||||
const first = bridge.accept(frame({
|
||||
msgid: 'isolation-a',
|
||||
from: { userid: 'member-a' },
|
||||
text: { content: 'ask-a' },
|
||||
}));
|
||||
const second = bridge.accept(frame({
|
||||
msgid: 'isolation-b',
|
||||
from: { userid: 'member-b' },
|
||||
text: { content: 'ask-b' },
|
||||
}));
|
||||
await eventually(() => transport.active.filter(({ body }) => (
|
||||
body.markdown.content.includes('请选择测试环境')
|
||||
)).length === 2);
|
||||
|
||||
const answerA = bridge.accept(frame({
|
||||
msgid: 'isolation-answer-a',
|
||||
from: { userid: 'member-a' },
|
||||
text: { content: '1' },
|
||||
}));
|
||||
await Promise.all([first, answerA]);
|
||||
assert.deepEqual(responses.map(({ text }) => text), ['ask-a']);
|
||||
|
||||
const answerB = bridge.accept(frame({
|
||||
msgid: 'isolation-answer-b',
|
||||
from: { userid: 'member-b' },
|
||||
text: { content: '2' },
|
||||
}));
|
||||
await Promise.all([second, answerB]);
|
||||
assert.deepEqual(responses.map(({ text }) => text), ['ask-a', 'ask-b']);
|
||||
assert.deepEqual(
|
||||
responses[1].result.value.answer.answers,
|
||||
[{ id: 'environment', selected: ['生产环境'] }],
|
||||
);
|
||||
});
|
||||
|
||||
test('question replays are deduplicated and approvals remain fail-closed', async () => {
|
||||
const transport = testClient();
|
||||
const answered = deferred();
|
||||
let approvalResponses = 0;
|
||||
let questionResponses = 0;
|
||||
const bridge = new WecomHarnessBridge({
|
||||
client: transport.client,
|
||||
generateStreamId: () => 'replay-stream',
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (_sessionId, _text, options) => {
|
||||
await options.onInteraction({
|
||||
kind: 'approval',
|
||||
interactionId: 'approval-1',
|
||||
rpcId: 'approval-rpc-1',
|
||||
sessionId: 'session-existing',
|
||||
payload: { type: 'approval/requested', toolName: 'bash' },
|
||||
respond: async () => { approvalResponses += 1; },
|
||||
});
|
||||
const interaction = questionInteraction({
|
||||
interactionId: 'replayed-question',
|
||||
respond: async () => {
|
||||
questionResponses += 1;
|
||||
answered.resolve();
|
||||
},
|
||||
});
|
||||
await options.onInteraction(interaction);
|
||||
await options.onInteraction({ ...interaction });
|
||||
await answered.promise;
|
||||
return 'done';
|
||||
},
|
||||
},
|
||||
state: state(),
|
||||
});
|
||||
|
||||
const prompt = bridge.accept(frame({ msgid: 'replay-start' }));
|
||||
await eventually(() => transport.active.length === 1);
|
||||
const answer = bridge.accept(frame({ msgid: 'replay-answer', text: { content: '1' } }));
|
||||
await Promise.all([prompt, answer]);
|
||||
|
||||
assert.equal(transport.active.length, 1);
|
||||
assert.equal(approvalResponses, 0);
|
||||
assert.equal(questionResponses, 1);
|
||||
});
|
||||
|
||||
test('a failed Enterprise WeChat interaction response can be retried', async () => {
|
||||
const transport = testClient();
|
||||
const answered = deferred();
|
||||
const attempts = [];
|
||||
const bridge = new WecomHarnessBridge({
|
||||
client: transport.client,
|
||||
generateStreamId: (() => { let index = 0; return () => `retry-${++index}`; })(),
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (_sessionId, _text, options) => {
|
||||
await options.onInteraction(questionInteraction({
|
||||
respond: async (result) => {
|
||||
attempts.push(structuredClone(result.value.answer.answers));
|
||||
if (attempts.length === 1) throw new Error('temporary response failure');
|
||||
answered.resolve();
|
||||
},
|
||||
}));
|
||||
await answered.promise;
|
||||
return 'retry complete';
|
||||
},
|
||||
},
|
||||
state: state(),
|
||||
logger: { error() {} },
|
||||
});
|
||||
|
||||
const prompt = bridge.accept(frame({ msgid: 'retry-start' }));
|
||||
await eventually(() => transport.active.length === 1);
|
||||
await bridge.accept(frame({ msgid: 'retry-first', text: { content: '1' } }));
|
||||
assert.equal(transport.streamed.some(({ content }) => content.includes('回答提交失败')), true);
|
||||
|
||||
const second = bridge.accept(frame({ msgid: 'retry-second', text: { content: '2' } }));
|
||||
await Promise.all([prompt, second]);
|
||||
assert.deepEqual(attempts, [
|
||||
[{ id: 'environment', selected: ['测试环境'] }],
|
||||
[{ id: 'environment', selected: ['生产环境'] }],
|
||||
]);
|
||||
});
|
||||
|
||||
test('an externally resolved Enterprise WeChat answer is not submitted as a new prompt', async () => {
|
||||
const transport = testClient();
|
||||
const resolved = deferred();
|
||||
let interactionOptions;
|
||||
const prompts = [];
|
||||
const bridge = new WecomHarnessBridge({
|
||||
client: transport.client,
|
||||
generateStreamId: (() => { let index = 0; return () => `resolved-${++index}`; })(),
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (_sessionId, text, options) => {
|
||||
prompts.push(text);
|
||||
interactionOptions = options;
|
||||
await options.onInteraction(questionInteraction({ interactionId: 'resolved-question' }));
|
||||
await resolved.promise;
|
||||
return '外部客户端已处理';
|
||||
},
|
||||
},
|
||||
state: state(),
|
||||
});
|
||||
|
||||
const prompt = bridge.accept(frame({ msgid: 'resolved-start' }));
|
||||
await eventually(() => transport.active.length === 1 && interactionOptions);
|
||||
const lateAnswer = bridge.accept(frame({
|
||||
msgid: 'resolved-answer',
|
||||
text: { content: '1' },
|
||||
}));
|
||||
interactionOptions.onInteractionResolved({
|
||||
kind: 'question',
|
||||
interactionId: 'resolved-question',
|
||||
});
|
||||
resolved.resolve();
|
||||
await Promise.all([prompt, lateAnswer]);
|
||||
|
||||
assert.deepEqual(prompts, ['请回答']);
|
||||
assert.equal(transport.streamed.some(({ messageId, content }) => (
|
||||
messageId === 'resolved-answer' && content === '这个问题已在其他客户端处理，无需再次回答。'
|
||||
)), true);
|
||||
});
|
||||
|
||||
test('an Enterprise WeChat answer reports resolution when respond loses an in-flight race', async () => {
|
||||
const transport = testClient();
|
||||
const responseStarted = deferred();
|
||||
const releaseResponse = deferred();
|
||||
const turnResolved = deferred();
|
||||
const prompts = [];
|
||||
let interactionOptions;
|
||||
const bridge = new WecomHarnessBridge({
|
||||
client: transport.client,
|
||||
generateStreamId: (() => { let index = 0; return () => `respond-race-${++index}`; })(),
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (_sessionId, text, options) => {
|
||||
prompts.push(text);
|
||||
interactionOptions = options;
|
||||
await options.onInteraction(questionInteraction({
|
||||
interactionId: 'respond-race-question',
|
||||
respond: async () => {
|
||||
responseStarted.resolve();
|
||||
await releaseResponse.promise;
|
||||
const error = new Error('interaction resolved elsewhere');
|
||||
error.code = 'interaction-not-pending';
|
||||
throw error;
|
||||
},
|
||||
}));
|
||||
await turnResolved.promise;
|
||||
return '外部客户端已完成';
|
||||
},
|
||||
},
|
||||
state: state(),
|
||||
});
|
||||
|
||||
const prompt = bridge.accept(frame({ msgid: 'respond-race-start' }));
|
||||
await eventually(() => transport.active.length === 1 && interactionOptions);
|
||||
const answer = bridge.accept(frame({
|
||||
msgid: 'respond-race-answer',
|
||||
text: { content: '1' },
|
||||
}));
|
||||
await responseStarted.promise;
|
||||
|
||||
interactionOptions.onInteractionResolved({
|
||||
kind: 'question',
|
||||
interactionId: 'respond-race-question',
|
||||
});
|
||||
turnResolved.resolve();
|
||||
releaseResponse.resolve();
|
||||
await Promise.all([prompt, answer]);
|
||||
|
||||
assert.deepEqual(prompts, ['请回答']);
|
||||
assert.equal(transport.streamed.filter(({ messageId, content }) => (
|
||||
messageId === 'respond-race-answer'
|
||||
&& content === '这个问题已在其他客户端处理，无需再次回答。'
|
||||
)).length, 1);
|
||||
});
|
||||
|
||||
test('a recovered orphan question is cancelled without exposing its content', async () => {
|
||||
const transport = testClient();
|
||||
const responses = [];
|
||||
const bridge = new WecomHarnessBridge({
|
||||
client: transport.client,
|
||||
generateStreamId: () => 'orphan-stream',
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (_sessionId, _text, options) => {
|
||||
await options.onInteraction(questionInteraction({
|
||||
recovered: true,
|
||||
questions: [{ id: 'secret', question: '不应显示的旧问题' }],
|
||||
respond: async (result) => responses.push(result),
|
||||
}));
|
||||
return '新消息继续完成';
|
||||
},
|
||||
},
|
||||
state: state(),
|
||||
});
|
||||
|
||||
await bridge.accept(frame({ msgid: 'orphan-start' }));
|
||||
assert.equal(responses[0].ok, false);
|
||||
assert.equal(responses[0].error.code, 'cancelled');
|
||||
assert.equal(transport.active.some(({ body }) => (
|
||||
body.markdown.content.includes('不应显示的旧问题')
|
||||
)), false);
|
||||
assert.equal(transport.active.some(({ body }) => (
|
||||
body.markdown.content.includes('遗留的待回答问题')
|
||||
)), true);
|
||||
});
|
||||
|
||||
test('multi-question Enterprise WeChat interactions preserve canonical answer order', async () => {
|
||||
const transport = testClient();
|
||||
const answered = deferred();
|
||||
let submitted;
|
||||
const questions = [
|
||||
{
|
||||
id: 'environment',
|
||||
question: '请选择环境',
|
||||
options: [{ label: '测试环境' }, { label: '生产环境' }],
|
||||
},
|
||||
{
|
||||
id: 'features',
|
||||
question: '请选择功能',
|
||||
multiSelect: true,
|
||||
options: [{ label: '日志' }, { label: '指标' }],
|
||||
},
|
||||
];
|
||||
const bridge = new WecomHarnessBridge({
|
||||
client: transport.client,
|
||||
generateStreamId: (() => { let index = 0; return () => `batch-${++index}`; })(),
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (_sessionId, _text, options) => {
|
||||
await options.onInteraction(questionInteraction({
|
||||
interactionId: 'batch-question',
|
||||
questions,
|
||||
respond: async (result) => {
|
||||
submitted = result;
|
||||
answered.resolve();
|
||||
},
|
||||
}));
|
||||
await answered.promise;
|
||||
return 'batch complete';
|
||||
},
|
||||
},
|
||||
state: state(),
|
||||
});
|
||||
|
||||
const prompt = bridge.accept(frame({ msgid: 'batch-start' }));
|
||||
await eventually(() => transport.active.length === 1);
|
||||
await bridge.accept(frame({ msgid: 'batch-first', text: { content: '2' } }));
|
||||
await eventually(() => transport.active.length === 2);
|
||||
const second = bridge.accept(frame({
|
||||
msgid: 'batch-second',
|
||||
text: { content: '1, 指标, 自定义' },
|
||||
}));
|
||||
await Promise.all([prompt, second]);
|
||||
|
||||
assert.deepEqual(submitted.value.answer.answers, [
|
||||
{ id: 'environment', selected: ['生产环境'] },
|
||||
{ id: 'features', selected: ['日志', '指标'], custom: '自定义' },
|
||||
]);
|
||||
});
|
||||
|
||||
test('a second answer stays claimed while its Enterprise WeChat question awaits acknowledgement', async () => {
|
||||
const secondQuestionStarted = deferred();
|
||||
const secondQuestionAcknowledged = deferred();
|
||||
const turnResolved = deferred();
|
||||
const streamed = [];
|
||||
const active = [];
|
||||
const prompts = [];
|
||||
let interactionOptions;
|
||||
let responseCalls = 0;
|
||||
const bridge = new WecomHarnessBridge({
|
||||
client: {
|
||||
replyStream: async (source, streamId, content, finish) => {
|
||||
streamed.push({ messageId: source.body.msgid, streamId, content, finish });
|
||||
},
|
||||
sendMessage: async (chatId, body) => {
|
||||
active.push({ chatId, body });
|
||||
if (body.markdown.content.includes('请选择功能')) {
|
||||
secondQuestionStarted.resolve();
|
||||
await secondQuestionAcknowledged.promise;
|
||||
}
|
||||
},
|
||||
},
|
||||
generateStreamId: (() => { let index = 0; return () => `second-ack-${++index}`; })(),
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (_sessionId, text, options) => {
|
||||
prompts.push(text);
|
||||
interactionOptions = options;
|
||||
await options.onInteraction(questionInteraction({
|
||||
interactionId: 'second-ack-question',
|
||||
questions: [
|
||||
{
|
||||
id: 'environment',
|
||||
question: '请选择环境',
|
||||
options: [{ label: '测试环境' }, { label: '生产环境' }],
|
||||
},
|
||||
{
|
||||
id: 'features',
|
||||
question: '请选择功能',
|
||||
options: [{ label: '日志' }, { label: '指标' }],
|
||||
},
|
||||
],
|
||||
respond: async () => { responseCalls += 1; },
|
||||
}));
|
||||
await turnResolved.promise;
|
||||
return '外部客户端已处理多问';
|
||||
},
|
||||
},
|
||||
state: state(),
|
||||
});
|
||||
|
||||
const prompt = bridge.accept(frame({ msgid: 'second-ack-start' }));
|
||||
await eventually(() => active.some(({ body }) => body.markdown.content.includes('请选择环境')));
|
||||
const firstAnswer = bridge.accept(frame({
|
||||
msgid: 'second-ack-first',
|
||||
text: { content: '1' },
|
||||
}));
|
||||
await secondQuestionStarted.promise;
|
||||
const secondAnswer = bridge.accept(frame({
|
||||
msgid: 'second-ack-answer',
|
||||
text: { content: '2' },
|
||||
}));
|
||||
|
||||
interactionOptions.onInteractionResolved({
|
||||
kind: 'question',
|
||||
interactionId: 'second-ack-question',
|
||||
});
|
||||
turnResolved.resolve();
|
||||
secondQuestionAcknowledged.resolve();
|
||||
await Promise.all([prompt, firstAnswer, secondAnswer]);
|
||||
|
||||
assert.deepEqual(prompts, ['请回答']);
|
||||
assert.equal(responseCalls, 0);
|
||||
assert.equal(streamed.filter(({ messageId, content }) => (
|
||||
messageId === 'second-ack-answer'
|
||||
&& content === '这个问题已在其他客户端处理，无需再次回答。'
|
||||
)).length, 1);
|
||||
});
|
||||
|
||||
test('only the initiating actor can answer an Enterprise WeChat group question', async () => {
|
||||
const transport = testClient();
|
||||
const answered = deferred();
|
||||
const order = [];
|
||||
let groupResponse;
|
||||
const bridge = new WecomHarnessBridge({
|
||||
client: transport.client,
|
||||
generateStreamId: (() => { let index = 0; return () => `group-${++index}`; })(),
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (_sessionId, text, options) => {
|
||||
if (text !== '启动问题') {
|
||||
order.push(`normal:${text}`);
|
||||
return '普通消息完成';
|
||||
}
|
||||
await options.onInteraction(questionInteraction({
|
||||
interactionId: 'group-question',
|
||||
respond: async (result) => {
|
||||
groupResponse = result;
|
||||
order.push('answered');
|
||||
answered.resolve();
|
||||
},
|
||||
}));
|
||||
await answered.promise;
|
||||
return '问题完成';
|
||||
},
|
||||
},
|
||||
state: state(),
|
||||
});
|
||||
|
||||
const prompt = bridge.accept(frame({
|
||||
msgid: 'group-start',
|
||||
chattype: 'group',
|
||||
chatid: 'group-1',
|
||||
from: { userid: 'member-a' },
|
||||
text: { content: '@RobotA 启动问题' },
|
||||
}));
|
||||
await eventually(() => transport.active.some(({ chatId }) => chatId === 'group-1'));
|
||||
assert.match(
|
||||
transport.active.find(({ chatId }) => chatId === 'group-1').body.markdown.content,
|
||||
/群聊中请 @机器人 后发送答案/,
|
||||
);
|
||||
const outsider = bridge.accept(frame({
|
||||
msgid: 'group-outsider',
|
||||
chattype: 'group',
|
||||
chatid: 'group-1',
|
||||
from: { userid: 'member-b' },
|
||||
text: { content: '@RobotA 1' },
|
||||
}));
|
||||
await new Promise((resolve) => setImmediate(resolve));
|
||||
assert.deepEqual(order, []);
|
||||
|
||||
const actor = bridge.accept(frame({
|
||||
msgid: 'group-actor',
|
||||
chattype: 'group',
|
||||
chatid: 'group-1',
|
||||
from: { userid: 'member-a' },
|
||||
text: { content: '@RobotA 2' },
|
||||
}));
|
||||
await Promise.all([prompt, actor, outsider]);
|
||||
assert.deepEqual(order, ['answered', 'normal:1']);
|
||||
assert.deepEqual(groupResponse.value.answer.answers, [
|
||||
{ id: 'environment', selected: ['生产环境'] },
|
||||
]);
|
||||
});
|
||||
|
||||
test('aborting Enterprise WeChat work cancels its pending question without a failure reply', async () => {
|
||||
const transport = testClient();
|
||||
const controller = new AbortController();
|
||||
const cancellations = [];
|
||||
const bridge = new WecomHarnessBridge({
|
||||
client: transport.client,
|
||||
generateStreamId: () => 'abort-stream',
|
||||
signal: controller.signal,
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (_sessionId, _text, options) => {
|
||||
assert.equal(options.signal, controller.signal);
|
||||
await options.onInteraction(questionInteraction({
|
||||
interactionId: 'abort-question',
|
||||
respond: async (result, responseOptions) => {
|
||||
cancellations.push({ result, responseOptions });
|
||||
},
|
||||
}));
|
||||
await new Promise((resolve, reject) => {
|
||||
if (options.signal.aborted) reject(options.signal.reason);
|
||||
else options.signal.addEventListener('abort', () => reject(options.signal.reason), { once: true });
|
||||
});
|
||||
return 'unreachable';
|
||||
},
|
||||
},
|
||||
state: state(),
|
||||
});
|
||||
|
||||
const prompt = bridge.accept(frame({ msgid: 'abort-start' }));
|
||||
await eventually(() => transport.active.length === 1);
|
||||
controller.abort(new DOMException('runtime stopped', 'AbortError'));
|
||||
await prompt;
|
||||
|
||||
assert.equal(cancellations.length, 1);
|
||||
assert.equal(cancellations[0].result.ok, false);
|
||||
assert.equal(cancellations[0].result.error.code, 'cancelled');
|
||||
assert.equal(cancellations[0].responseOptions.signal.aborted, false);
|
||||
assert.equal(transport.streamed.some(({ content }) => content === '消息处理失败，请稍后重试。'), false);
|
||||
});
|
||||
|
|
|
|||
|
|
@ -4,6 +4,12 @@ import test from 'node:test';
|
|||
|
||||
import { WecomRuntime } from '../../../src/channels/wecom/wecom-runtime.mjs';
|
||||
|
||||
function deferred() {
|
||||
let resolve;
|
||||
const promise = new Promise((done) => { resolve = done; });
|
||||
return { promise, resolve };
|
||||
}
|
||||
|
||||
class FakeClient extends EventEmitter {
|
||||
disconnected = false;
|
||||
connect() { queueMicrotask(() => this.emit('authenticated')); }
|
||||
|
|
@ -78,3 +84,50 @@ test('Enterprise WeChat runtime stop cancels an in-flight authentication wait',
|
|||
assert.equal(client.disconnected, true);
|
||||
assert.equal(runtime.status.wecomConnectionState, 'idle');
|
||||
});
|
||||
|
||||
test('Enterprise WeChat runtime aborts an in-flight Harness interaction when stopped', async () => {
|
||||
const client = new FakeClient();
|
||||
const askStarted = deferred();
|
||||
let askSignal;
|
||||
const runtime = new WecomRuntime({
|
||||
config: { botId: 'wecom_bot', remoteBotId: 'remote-bot' },
|
||||
secret: 'private-secret',
|
||||
harness: {
|
||||
ensureRunning: async () => true,
|
||||
sessionExists: async () => true,
|
||||
ask: async (_sessionId, _text, options) => {
|
||||
askSignal = options.signal;
|
||||
askStarted.resolve();
|
||||
await new Promise((_resolve, reject) => options.signal.addEventListener('abort', () => {
|
||||
reject(options.signal.reason);
|
||||
}, { once: true }));
|
||||
},
|
||||
},
|
||||
state: {
|
||||
hasSeen: () => false,
|
||||
markSeen: async () => {},
|
||||
sessionFor: () => 'session-existing',
|
||||
setSession: async () => {},
|
||||
clearSession: async () => {},
|
||||
},
|
||||
createClient: () => client,
|
||||
connectTimeoutMs: 100,
|
||||
logger: { error() {}, warn() {} },
|
||||
});
|
||||
|
||||
await runtime.start();
|
||||
client.emit('message', {
|
||||
headers: { req_id: 'req-interaction' },
|
||||
body: {
|
||||
msgid: 'msg-interaction',
|
||||
chattype: 'single',
|
||||
from: { userid: 'member-1' },
|
||||
msgtype: 'text',
|
||||
text: { content: '需要交互' },
|
||||
},
|
||||
});
|
||||
await askStarted.promise;
|
||||
assert.equal(askSignal.aborted, false);
|
||||
await runtime.stop();
|
||||
assert.equal(askSignal.aborted, true);
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1,7 +1,49 @@
|
|||
import assert from 'node:assert/strict';
|
||||
import test from 'node:test';
|
||||
|
||||
import { DiscordHarnessClient } from '../../../src/channels/discord/harness-client.mjs';
|
||||
import { QqHarnessClient } from '../../../src/channels/qq/harness-client.mjs';
|
||||
import { SlackHarnessClient } from '../../../src/channels/slack/harness-client.mjs';
|
||||
import { TelegramHarnessClient } from '../../../src/channels/telegram/harness-client.mjs';
|
||||
import { WecomHarnessClient } from '../../../src/channels/wecom/harness-client.mjs';
|
||||
import { HarnessClient, HarnessReplyTracker } from '../../../src/channels/weixin/harness-client.mjs';
|
||||
import { WhatsappHarnessClient } from '../../../src/channels/whatsapp/harness-client.mjs';
|
||||
|
||||
test('all legacy channel clients now use the shared Harness RPC transport', async () => {
|
||||
const channelClients = [
|
||||
[HarnessClient, 'weixin'],
|
||||
[WecomHarnessClient, 'wecom'],
|
||||
[QqHarnessClient, 'qq'],
|
||||
[SlackHarnessClient, 'slack'],
|
||||
[DiscordHarnessClient, 'discord'],
|
||||
[TelegramHarnessClient, 'telegram'],
|
||||
[WhatsappHarnessClient, 'whatsapp'],
|
||||
];
|
||||
|
||||
for (const [Client, prefix] of channelClients) {
|
||||
let request;
|
||||
const client = new Client({
|
||||
baseUrl: 'http://127.0.0.1:3080',
|
||||
workspace: '/tmp/default-workspace',
|
||||
fetchImpl: async (url, options) => {
|
||||
request = { url: String(url), ...options, body: JSON.parse(options.body) };
|
||||
return {
|
||||
ok: true,
|
||||
json: async () => ({
|
||||
type: 'server-response',
|
||||
rpcId: request.body.rpcId,
|
||||
result: { ok: true, value: { ready: true } },
|
||||
}),
|
||||
};
|
||||
},
|
||||
});
|
||||
|
||||
assert.deepEqual(await client.rpc('host.describe'), { ready: true });
|
||||
assert.equal(request.url, 'http://127.0.0.1:3080/api/host.describe');
|
||||
assert.match(request.body.rpcId, new RegExp(`^${prefix}-`));
|
||||
assert.equal(request.body.type, 'client-request');
|
||||
}
|
||||
});
|
||||
|
||||
test('HarnessClient lists only absolute workspace paths', async () => {
|
||||
const client = new HarnessClient({
|
||||
|
|
|
|||
|
|
@ -3,6 +3,39 @@ import test from 'node:test';
|
|||
|
||||
import { createWeixinBridgeStatus, WeixinHarnessBridge } from '../../../src/channels/weixin/weixin-bridge.mjs';
|
||||
|
||||
function deferred() {
|
||||
let resolve;
|
||||
let reject;
|
||||
const promise = new Promise((promiseResolve, promiseReject) => {
|
||||
resolve = promiseResolve;
|
||||
reject = promiseReject;
|
||||
});
|
||||
return { promise, resolve, reject };
|
||||
}
|
||||
|
||||
async function eventually(predicate, messageText = 'condition was not met') {
|
||||
const deadline = Date.now() + 1_000;
|
||||
while (Date.now() < deadline) {
|
||||
if (predicate()) return;
|
||||
await new Promise((resolve) => setTimeout(resolve, 5));
|
||||
}
|
||||
assert.fail(messageText);
|
||||
}
|
||||
|
||||
async function within(promise, milliseconds, messageText) {
|
||||
let timer;
|
||||
try {
|
||||
return await Promise.race([
|
||||
promise,
|
||||
new Promise((_, reject) => {
|
||||
timer = setTimeout(() => reject(new Error(messageText)), milliseconds);
|
||||
}),
|
||||
]);
|
||||
} finally {
|
||||
clearTimeout(timer);
|
||||
}
|
||||
}
|
||||
|
||||
function message(id, text, overrides = {}) {
|
||||
return {
|
||||
message_id: id,
|
||||
|
|
@ -68,6 +101,698 @@ test('bridge maps the scanning Weixin user to one persistent Harness session and
|
|||
assert.equal(status.messagesReplied, 2);
|
||||
});
|
||||
|
||||
test('Weixin answers a multi-question interaction before the original turn queue', async () => {
|
||||
const fixture = stateFixture();
|
||||
fixture.sessions.set('p2p:owner-user', 'session-question');
|
||||
const sent = [];
|
||||
const asked = [];
|
||||
const submitted = deferred();
|
||||
const secondQuestionDelivered = deferred();
|
||||
const releaseSecondQuestion = deferred();
|
||||
const bridge = new WeixinHarnessBridge({
|
||||
api: {
|
||||
sendText: async (request) => {
|
||||
sent.push(request);
|
||||
if (request.text.includes('选择交付物')) {
|
||||
secondQuestionDelivered.resolve();
|
||||
await releaseSecondQuestion.promise;
|
||||
}
|
||||
},
|
||||
},
|
||||
baseUrl: 'https://ilinkai.weixin.qq.com/',
|
||||
token: 'host-token',
|
||||
ownerUserId: 'owner-user',
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
createSession: async () => assert.fail('the existing session should be reused'),
|
||||
ask: async (sessionId, text, options) => {
|
||||
asked.push(text);
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'weixin-multi',
|
||||
rpcId: 'weixin-multi',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [
|
||||
{
|
||||
id: 'language',
|
||||
question: '选择语言',
|
||||
options: [{ label: '中文' }, { label: 'English' }],
|
||||
},
|
||||
{
|
||||
id: 'deliverables',
|
||||
question: '选择交付物',
|
||||
multiSelect: true,
|
||||
options: [{ label: '测试' }, { label: '文档' }],
|
||||
},
|
||||
],
|
||||
},
|
||||
respond: async (result) => {
|
||||
submitted.resolve(result);
|
||||
return { accepted: true };
|
||||
},
|
||||
});
|
||||
await submitted.promise;
|
||||
return '交互完成';
|
||||
},
|
||||
},
|
||||
state: fixture.state,
|
||||
});
|
||||
|
||||
const first = bridge.accept(message('multi-start', '请分步提问'));
|
||||
await eventually(() => sent.some(({ text }) => text.includes('选择语言')));
|
||||
const firstAnswer = bridge.accept(message('multi-language', '2'));
|
||||
await secondQuestionDelivered.promise;
|
||||
const secondAnswer = bridge.accept(message('multi-deliverables', '1，文档，发布说明'));
|
||||
releaseSecondQuestion.resolve();
|
||||
await within(
|
||||
Promise.all([firstAnswer, secondAnswer]),
|
||||
500,
|
||||
'the second Weixin answer deadlocked behind delivery of the second question',
|
||||
);
|
||||
|
||||
assert.deepEqual(await submitted.promise, {
|
||||
ok: true,
|
||||
value: {
|
||||
sessionId: 'session-question',
|
||||
answer: {
|
||||
answers: [
|
||||
{ id: 'language', selected: ['English'] },
|
||||
{ id: 'deliverables', selected: ['测试', '文档'], custom: '发布说明' },
|
||||
],
|
||||
},
|
||||
},
|
||||
});
|
||||
await first;
|
||||
assert.deepEqual(asked, ['请分步提问']);
|
||||
assert.equal(sent.at(-1).text, '交互完成');
|
||||
assert.equal(sent.find(({ text }) => text.includes('选择交付物')).contextToken, 'context-multi-language');
|
||||
});
|
||||
|
||||
test('Weixin deduplicates question replays, rejects parallel questions, and keeps approvals fail-closed', async () => {
|
||||
const fixture = stateFixture();
|
||||
const sent = [];
|
||||
let approvalResponses = 0;
|
||||
let parallelResponse;
|
||||
let orphanResponse;
|
||||
const bridge = new WeixinHarnessBridge({
|
||||
api: { sendText: async (request) => sent.push(request) },
|
||||
baseUrl: 'https://ilinkai.weixin.qq.com/',
|
||||
token: 'host-token',
|
||||
ownerUserId: 'owner-user',
|
||||
harness: {
|
||||
sessionExists: async () => false,
|
||||
createSession: async () => 'session-replay',
|
||||
ask: async (sessionId, _text, options) => {
|
||||
const replayedQuestion = {
|
||||
kind: 'question',
|
||||
interactionId: 'weixin-replayed-question',
|
||||
rpcId: 'weixin-replayed-question',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [{ id: 'choice', question: '只应显示一次' }],
|
||||
},
|
||||
respond: async () => ({ accepted: true }),
|
||||
};
|
||||
await options.onInteraction(replayedQuestion);
|
||||
await options.onInteraction(replayedQuestion);
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'weixin-parallel-question',
|
||||
rpcId: 'weixin-parallel-question',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [{ id: 'parallel', question: '不应展示的并行问题' }],
|
||||
},
|
||||
respond: async (result) => {
|
||||
parallelResponse = result;
|
||||
return { accepted: true };
|
||||
},
|
||||
});
|
||||
await options.onInteraction({
|
||||
kind: 'approval',
|
||||
interactionId: 'weixin-approval',
|
||||
rpcId: 'weixin-approval',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'approval/requested',
|
||||
sessionId,
|
||||
approvalId: 'weixin-approval',
|
||||
toolName: 'bash',
|
||||
},
|
||||
respond: async () => { approvalResponses += 1; },
|
||||
});
|
||||
await options.onInteractionResolved({
|
||||
kind: 'question',
|
||||
interactionId: 'weixin-replayed-question',
|
||||
sessionId,
|
||||
outcome: 'cancelled',
|
||||
});
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'weixin-orphan-question',
|
||||
rpcId: 'weixin-orphan-question',
|
||||
sessionId,
|
||||
recovered: true,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [{ id: 'secret', question: '旧会话中的敏感问题内容' }],
|
||||
},
|
||||
respond: async (result) => {
|
||||
orphanResponse = result;
|
||||
return { accepted: true };
|
||||
},
|
||||
});
|
||||
return '交互恢复完成';
|
||||
},
|
||||
},
|
||||
state: fixture.state,
|
||||
logger: { warn() {}, error() {} },
|
||||
});
|
||||
|
||||
await bridge.accept(message('replay', '测试交互重放'));
|
||||
|
||||
assert.equal(sent.filter(({ text }) => text.includes('只应显示一次')).length, 1);
|
||||
assert.deepEqual(parallelResponse, {
|
||||
ok: false,
|
||||
error: {
|
||||
code: 'cancelled',
|
||||
message: 'Weixin is already handling another user interaction.',
|
||||
details: {},
|
||||
},
|
||||
});
|
||||
assert.equal(approvalResponses, 0);
|
||||
assert.equal(sent.some(({ text }) => text.includes('approval')), false);
|
||||
assert.deepEqual(orphanResponse, {
|
||||
ok: false,
|
||||
error: {
|
||||
code: 'cancelled',
|
||||
message: 'Weixin safely cancelled an interaction left by an earlier client.',
|
||||
details: {},
|
||||
},
|
||||
});
|
||||
assert.equal(sent.some(({ text }) => text.includes('旧会话中的敏感问题内容')), false);
|
||||
assert.equal(sent.some(({ text }) => text.includes('遗留的待回答问题')), true);
|
||||
assert.equal(sent.at(-1).text, '交互恢复完成');
|
||||
});
|
||||
|
||||
test('Weixin keeps a queued prompt separate while a failed interaction answer is retried', async () => {
|
||||
const fixture = stateFixture();
|
||||
fixture.sessions.set('p2p:owner-user', 'session-submit-retry');
|
||||
const sent = [];
|
||||
const asked = [];
|
||||
const firstSubmitStarted = deferred();
|
||||
const releaseFirstSubmit = deferred();
|
||||
const answered = deferred();
|
||||
const submittedAnswers = [];
|
||||
let submitAttempts = 0;
|
||||
const bridge = new WeixinHarnessBridge({
|
||||
api: { sendText: async (request) => sent.push(request) },
|
||||
baseUrl: 'https://ilinkai.weixin.qq.com/',
|
||||
token: 'host-token',
|
||||
ownerUserId: 'owner-user',
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
createSession: async () => assert.fail('the existing session should be reused'),
|
||||
ask: async (sessionId, text, options) => {
|
||||
asked.push(text);
|
||||
if (text === '排队的下一个问题') return '第二轮完成';
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'weixin-submit-retry',
|
||||
rpcId: 'weixin-submit-retry',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [{ id: 'answer', question: '请回答后再继续' }],
|
||||
},
|
||||
respond: async (result) => {
|
||||
submittedAnswers.push(result.value.answer.answers[0].custom);
|
||||
submitAttempts += 1;
|
||||
if (submitAttempts === 1) {
|
||||
firstSubmitStarted.resolve();
|
||||
await releaseFirstSubmit.promise;
|
||||
throw new Error('temporary response failure');
|
||||
}
|
||||
answered.resolve();
|
||||
return { accepted: true };
|
||||
},
|
||||
});
|
||||
await answered.promise;
|
||||
return '第一轮完成';
|
||||
},
|
||||
},
|
||||
state: fixture.state,
|
||||
logger: { warn() {}, error() {} },
|
||||
});
|
||||
|
||||
const first = bridge.accept(message('retry-start', '启动可重试交互'));
|
||||
await eventually(() => sent.some(({ text }) => text.includes('请回答后再继续')));
|
||||
const firstAnswer = bridge.accept(message('retry-first-answer', '第一次答案'));
|
||||
await firstSubmitStarted.promise;
|
||||
|
||||
let nextSettled = false;
|
||||
const next = bridge.accept(message('retry-next', '排队的下一个问题'))
|
||||
.finally(() => { nextSettled = true; });
|
||||
releaseFirstSubmit.resolve();
|
||||
await firstAnswer;
|
||||
await eventually(() => sent.some(({ text }) => text.includes('回答提交失败')));
|
||||
assert.equal(nextSettled, false);
|
||||
assert.deepEqual(asked, ['启动可重试交互']);
|
||||
|
||||
await Promise.all([
|
||||
bridge.accept(message('retry-second-answer', '重试后的答案')),
|
||||
first,
|
||||
next,
|
||||
]);
|
||||
|
||||
assert.deepEqual(submittedAnswers, ['第一次答案', '重试后的答案']);
|
||||
assert.deepEqual(asked, ['启动可重试交互', '排队的下一个问题']);
|
||||
assert.deepEqual(sent.slice(-2).map(({ text }) => text), ['第一轮完成', '第二轮完成']);
|
||||
});
|
||||
|
||||
test('Weixin serializes an invalid pending reply before the following valid answer', async () => {
|
||||
const fixture = stateFixture();
|
||||
fixture.sessions.set('p2p:owner-user', 'session-invalid-answer');
|
||||
const sent = [];
|
||||
const invalidNoticeStarted = deferred();
|
||||
const releaseInvalidNotice = deferred();
|
||||
const answered = deferred();
|
||||
let submitted;
|
||||
const bridge = new WeixinHarnessBridge({
|
||||
api: {
|
||||
sendText: async (request) => {
|
||||
if (request.text === '请用文字回答当前问题。') {
|
||||
invalidNoticeStarted.resolve();
|
||||
await releaseInvalidNotice.promise;
|
||||
}
|
||||
sent.push(request);
|
||||
},
|
||||
},
|
||||
baseUrl: 'https://ilinkai.weixin.qq.com/',
|
||||
token: 'host-token',
|
||||
ownerUserId: 'owner-user',
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
createSession: async () => assert.fail('the existing session should be reused'),
|
||||
ask: async (sessionId, _text, options) => {
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'weixin-invalid-answer',
|
||||
rpcId: 'weixin-invalid-answer',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [{ id: 'answer', question: '请给出有效文字答案' }],
|
||||
},
|
||||
respond: async (result) => {
|
||||
submitted = result;
|
||||
answered.resolve();
|
||||
return { accepted: true };
|
||||
},
|
||||
});
|
||||
await answered.promise;
|
||||
return '有效答案已收到';
|
||||
},
|
||||
},
|
||||
state: fixture.state,
|
||||
});
|
||||
|
||||
const first = bridge.accept(message('invalid-start', '启动交互'));
|
||||
await eventually(() => sent.some(({ text }) => text.includes('请给出有效文字答案')));
|
||||
const invalid = bridge.accept(message('invalid-image', '', {
|
||||
message_type: 3,
|
||||
item_list: [{ type: 2 }],
|
||||
}));
|
||||
await invalidNoticeStarted.promise;
|
||||
const valid = bridge.accept(message('invalid-valid', '真正的答案'));
|
||||
releaseInvalidNotice.resolve();
|
||||
|
||||
await Promise.all([invalid, valid, first]);
|
||||
assert.deepEqual(submitted.value.answer.answers, [{
|
||||
id: 'answer',
|
||||
selected: [],
|
||||
custom: '真正的答案',
|
||||
}]);
|
||||
assert.equal(sent.at(-1).text, '有效答案已收到');
|
||||
});
|
||||
|
||||
test('Weixin discards an already-claimed answer when the interaction resolves elsewhere', async () => {
|
||||
const fixture = stateFixture();
|
||||
fixture.sessions.set('p2p:owner-user', 'session-resolved-race');
|
||||
const originalMarkSeen = fixture.state.markSeen;
|
||||
const answerMarkStarted = deferred();
|
||||
const releaseAnswerMark = deferred();
|
||||
fixture.state.markSeen = async (id) => {
|
||||
if (id === 'resolved-answer') {
|
||||
answerMarkStarted.resolve();
|
||||
await releaseAnswerMark.promise;
|
||||
}
|
||||
await originalMarkSeen(id);
|
||||
};
|
||||
const sent = [];
|
||||
const asked = [];
|
||||
const resolved = deferred();
|
||||
let resolveInteraction;
|
||||
const bridge = new WeixinHarnessBridge({
|
||||
api: { sendText: async (request) => sent.push(request) },
|
||||
baseUrl: 'https://ilinkai.weixin.qq.com/',
|
||||
token: 'host-token',
|
||||
ownerUserId: 'owner-user',
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
createSession: async () => assert.fail('the existing session should be reused'),
|
||||
ask: async (sessionId, text, options) => {
|
||||
asked.push(text);
|
||||
if (text === '后来的普通问题') return '后来问题的回答';
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'weixin-resolved-race',
|
||||
rpcId: 'weixin-resolved-race',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [{ id: 'answer', question: '可能在其他客户端回答' }],
|
||||
},
|
||||
respond: async () => ({ accepted: true }),
|
||||
});
|
||||
resolveInteraction = async () => {
|
||||
await options.onInteractionResolved({
|
||||
kind: 'question',
|
||||
interactionId: 'weixin-resolved-race',
|
||||
sessionId,
|
||||
outcome: 'answered',
|
||||
});
|
||||
resolved.resolve();
|
||||
};
|
||||
await resolved.promise;
|
||||
return '第一轮已由其他客户端完成';
|
||||
},
|
||||
},
|
||||
state: fixture.state,
|
||||
});
|
||||
|
||||
const first = bridge.accept(message('resolved-start', '启动外部解决竞态'));
|
||||
await eventually(() => typeof resolveInteraction === 'function');
|
||||
const answer = bridge.accept(message('resolved-answer', '原本的问题答案'));
|
||||
await answerMarkStarted.promise;
|
||||
const later = bridge.accept(message('resolved-later', '后来的普通问题'));
|
||||
await resolveInteraction();
|
||||
releaseAnswerMark.resolve();
|
||||
|
||||
await Promise.all([answer, first, later]);
|
||||
assert.deepEqual(asked, ['启动外部解决竞态', '后来的普通问题']);
|
||||
assert.equal(asked.includes('原本的问题答案'), false);
|
||||
assert.equal(sent.some(({ text }) => text.includes('已在其他客户端处理')), true);
|
||||
});
|
||||
|
||||
test('Weixin keeps an answer that arrives after the first question is delivered but before its send ACK', async () => {
|
||||
const fixture = stateFixture();
|
||||
fixture.sessions.set('p2p:owner-user', 'session-first-delivery');
|
||||
const questionDelivered = deferred();
|
||||
const releaseQuestionAck = deferred();
|
||||
const answered = deferred();
|
||||
const sent = [];
|
||||
const asked = [];
|
||||
let submitted;
|
||||
let questionSends = 0;
|
||||
const bridge = new WeixinHarnessBridge({
|
||||
api: {
|
||||
sendText: async (request) => {
|
||||
sent.push(request);
|
||||
if (request.text.includes('首问 ACK 窗口')) {
|
||||
questionSends += 1;
|
||||
questionDelivered.resolve();
|
||||
await releaseQuestionAck.promise;
|
||||
}
|
||||
},
|
||||
},
|
||||
baseUrl: 'https://ilinkai.weixin.qq.com/',
|
||||
token: 'host-token',
|
||||
ownerUserId: 'owner-user',
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (sessionId, text, options) => {
|
||||
asked.push(text);
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'weixin-first-delivery',
|
||||
rpcId: 'weixin-first-delivery',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [{ id: 'answer', question: '首问 ACK 窗口' }],
|
||||
},
|
||||
respond: async (result) => {
|
||||
submitted = result;
|
||||
answered.resolve();
|
||||
return { accepted: true };
|
||||
},
|
||||
});
|
||||
await answered.promise;
|
||||
return '首问已完成';
|
||||
},
|
||||
},
|
||||
state: fixture.state,
|
||||
});
|
||||
|
||||
const first = bridge.accept(message('first-delivery-start', '启动首问窗口'));
|
||||
await questionDelivered.promise;
|
||||
const answer = bridge.accept(message('first-delivery-answer', '窗口内答案'));
|
||||
await new Promise((resolve) => setImmediate(resolve));
|
||||
assert.equal(submitted, undefined);
|
||||
releaseQuestionAck.resolve();
|
||||
await Promise.all([first, answer]);
|
||||
|
||||
assert.equal(questionSends, 1);
|
||||
assert.deepEqual(asked, ['启动首问窗口']);
|
||||
assert.deepEqual(submitted.value.answer.answers, [{
|
||||
id: 'answer',
|
||||
selected: [],
|
||||
custom: '窗口内答案',
|
||||
}]);
|
||||
assert.equal(fixture.seen.has('first-delivery-answer'), true);
|
||||
});
|
||||
|
||||
test('Weixin tombstones a q2 answer accepted before its send ACK when the interaction resolves', async () => {
|
||||
const fixture = stateFixture();
|
||||
fixture.sessions.set('p2p:owner-user', 'session-q2-resolved');
|
||||
const secondQuestionDelivered = deferred();
|
||||
const releaseSecondQuestionAck = deferred();
|
||||
const turnResolved = deferred();
|
||||
const sent = [];
|
||||
const asked = [];
|
||||
let resolveInteraction;
|
||||
const bridge = new WeixinHarnessBridge({
|
||||
api: {
|
||||
sendText: async (request) => {
|
||||
sent.push(request);
|
||||
if (request.text.includes('会在 ACK 前 resolved 的第二问')) {
|
||||
secondQuestionDelivered.resolve();
|
||||
await releaseSecondQuestionAck.promise;
|
||||
}
|
||||
},
|
||||
},
|
||||
baseUrl: 'https://ilinkai.weixin.qq.com/',
|
||||
token: 'host-token',
|
||||
ownerUserId: 'owner-user',
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (sessionId, text, options) => {
|
||||
asked.push(text);
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'weixin-q2-resolved',
|
||||
rpcId: 'weixin-q2-resolved',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [
|
||||
{ id: 'first', question: '先回答第一问' },
|
||||
{ id: 'second', question: '会在 ACK 前 resolved 的第二问' },
|
||||
],
|
||||
},
|
||||
respond: async () => assert.fail('the externally resolved interaction must not be answered'),
|
||||
});
|
||||
resolveInteraction = () => {
|
||||
options.onInteractionResolved({
|
||||
kind: 'question',
|
||||
interactionId: 'weixin-q2-resolved',
|
||||
sessionId,
|
||||
outcome: 'answered',
|
||||
});
|
||||
turnResolved.resolve();
|
||||
};
|
||||
await turnResolved.promise;
|
||||
return '已由其他客户端完成';
|
||||
},
|
||||
},
|
||||
state: fixture.state,
|
||||
});
|
||||
|
||||
const first = bridge.accept(message('q2-resolved-start', '启动 q2 resolved 窗口'));
|
||||
await eventually(() => typeof resolveInteraction === 'function');
|
||||
const firstAnswer = bridge.accept(message('q2-resolved-first', '第一问答案'));
|
||||
await secondQuestionDelivered.promise;
|
||||
const secondAnswer = bridge.accept(message('q2-resolved-second', '第二问答案'));
|
||||
resolveInteraction();
|
||||
releaseSecondQuestionAck.resolve();
|
||||
await Promise.all([firstAnswer, secondAnswer, first]);
|
||||
|
||||
assert.deepEqual(asked, ['启动 q2 resolved 窗口']);
|
||||
assert.equal(fixture.seen.has('q2-resolved-second'), true);
|
||||
assert.equal(sent.some(({ text }) => text.includes('已在其他客户端处理')), true);
|
||||
});
|
||||
|
||||
test('Weixin reports resolved when an in-flight response becomes not-pending', async () => {
|
||||
const fixture = stateFixture();
|
||||
fixture.sessions.set('p2p:owner-user', 'session-respond-resolved');
|
||||
const responseStarted = deferred();
|
||||
const releaseResponse = deferred();
|
||||
const turnResolved = deferred();
|
||||
const sent = [];
|
||||
let resolveInteraction;
|
||||
const bridge = new WeixinHarnessBridge({
|
||||
api: { sendText: async (request) => sent.push(request) },
|
||||
baseUrl: 'https://ilinkai.weixin.qq.com/',
|
||||
token: 'host-token',
|
||||
ownerUserId: 'owner-user',
|
||||
harness: {
|
||||
sessionExists: async () => true,
|
||||
ask: async (sessionId, _text, options) => {
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'weixin-respond-resolved',
|
||||
rpcId: 'weixin-respond-resolved',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [{ id: 'answer', question: '提交中会被外部解决' }],
|
||||
},
|
||||
respond: async () => {
|
||||
responseStarted.resolve();
|
||||
await releaseResponse.promise;
|
||||
const error = new Error('already resolved');
|
||||
error.code = 'interaction-not-pending';
|
||||
throw error;
|
||||
},
|
||||
});
|
||||
resolveInteraction = () => {
|
||||
options.onInteractionResolved({
|
||||
kind: 'question',
|
||||
interactionId: 'weixin-respond-resolved',
|
||||
sessionId,
|
||||
outcome: 'answered',
|
||||
});
|
||||
turnResolved.resolve();
|
||||
};
|
||||
await turnResolved.promise;
|
||||
return '外部处理完成';
|
||||
},
|
||||
},
|
||||
state: fixture.state,
|
||||
});
|
||||
|
||||
const first = bridge.accept(message('respond-resolved-start', '启动提交竞态'));
|
||||
await eventually(() => typeof resolveInteraction === 'function');
|
||||
const answer = bridge.accept(message('respond-resolved-answer', '我的答案'));
|
||||
await responseStarted.promise;
|
||||
resolveInteraction();
|
||||
releaseResponse.resolve();
|
||||
await Promise.all([answer, first]);
|
||||
|
||||
assert.equal(sent.some(({ text, contextToken }) => (
|
||||
contextToken === 'context-respond-resolved-answer'
|
||||
&& text.includes('已在其他客户端处理')
|
||||
)), true);
|
||||
});
|
||||
|
||||
test('Weixin propagates the stop signal and cancels its pending question on abort', async () => {
|
||||
const fixture = stateFixture();
|
||||
fixture.sessions.set('p2p:owner-user', 'stale-session');
|
||||
const controller = new AbortController();
|
||||
const interactionReady = deferred();
|
||||
let existsSignal;
|
||||
let createSignal;
|
||||
let askSignal;
|
||||
let cancellation;
|
||||
let cancellationSignal;
|
||||
const bridge = new WeixinHarnessBridge({
|
||||
api: { sendText: async () => {} },
|
||||
baseUrl: 'https://ilinkai.weixin.qq.com/',
|
||||
token: 'host-token',
|
||||
ownerUserId: 'owner-user',
|
||||
signal: controller.signal,
|
||||
harness: {
|
||||
sessionExists: async (_sessionId, options) => {
|
||||
existsSignal = options.signal;
|
||||
return false;
|
||||
},
|
||||
createSession: async (options) => {
|
||||
createSignal = options.signal;
|
||||
return 'session-abort';
|
||||
},
|
||||
ask: async (sessionId, _text, options) => {
|
||||
askSignal = options.signal;
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
interactionId: 'weixin-abort-question',
|
||||
rpcId: 'weixin-abort-question',
|
||||
sessionId,
|
||||
payload: {
|
||||
type: 'question/requested',
|
||||
sessionId,
|
||||
questions: [{ id: 'answer', question: '等待进程停止' }],
|
||||
},
|
||||
respond: async (result, respondOptions) => {
|
||||
cancellation = result;
|
||||
cancellationSignal = respondOptions.signal;
|
||||
return { accepted: true };
|
||||
},
|
||||
});
|
||||
interactionReady.resolve();
|
||||
await new Promise((resolve, reject) => {
|
||||
options.signal.addEventListener('abort', () => reject(options.signal.reason), { once: true });
|
||||
});
|
||||
},
|
||||
},
|
||||
state: fixture.state,
|
||||
logger: { warn() {}, error() {} },
|
||||
});
|
||||
|
||||
const turn = bridge.accept(message('abort-start', '启动后停止'));
|
||||
await interactionReady.promise;
|
||||
controller.abort(new Error('runtime stopped'));
|
||||
await turn;
|
||||
|
||||
assert.equal(existsSignal, controller.signal);
|
||||
assert.equal(createSignal, controller.signal);
|
||||
assert.equal(askSignal, controller.signal);
|
||||
assert.deepEqual(cancellation, {
|
||||
ok: false,
|
||||
error: {
|
||||
code: 'cancelled',
|
||||
message: 'The Weixin interaction ended before the user answered.',
|
||||
details: {},
|
||||
},
|
||||
});
|
||||
assert.notEqual(cancellationSignal, controller.signal);
|
||||
assert.equal(cancellationSignal.aborted, false);
|
||||
});
|
||||
|
||||
test('bridge rejects every user except the account owner returned by QR login', async () => {
|
||||
const fixture = stateFixture();
|
||||
let asked = 0;
|
||||
|
|
|
|||
|
|
@ -6,9 +6,54 @@ import { WeixinRuntime } from '../../../src/channels/weixin/weixin-runtime.mjs';
|
|||
|
||||
const flush = () => new Promise((resolve) => setImmediate(resolve));
|
||||
|
||||
function deferred() {
|
||||
let resolve;
|
||||
let reject;
|
||||
const promise = new Promise((resolvePromise, rejectPromise) => {
|
||||
resolve = resolvePromise;
|
||||
reject = rejectPromise;
|
||||
});
|
||||
return { promise, resolve, reject };
|
||||
}
|
||||
|
||||
async function eventually(predicate, message, timeoutMs = 1_000) {
|
||||
const deadline = Date.now() + timeoutMs;
|
||||
while (Date.now() < deadline) {
|
||||
if (predicate()) return;
|
||||
await new Promise((resolve) => setTimeout(resolve, 5));
|
||||
}
|
||||
assert.fail(message);
|
||||
}
|
||||
|
||||
function abortable(promise, signal) {
|
||||
return new Promise((resolve, reject) => {
|
||||
const cleanup = () => signal?.removeEventListener('abort', onAbort);
|
||||
const onAbort = () => {
|
||||
cleanup();
|
||||
reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));
|
||||
};
|
||||
if (signal?.aborted) {
|
||||
onAbort();
|
||||
return;
|
||||
}
|
||||
signal?.addEventListener('abort', onAbort, { once: true });
|
||||
promise.then(
|
||||
(value) => {
|
||||
cleanup();
|
||||
resolve(value);
|
||||
},
|
||||
(error) => {
|
||||
cleanup();
|
||||
reject(error);
|
||||
},
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
test('runtime verifies the token, consumes getUpdates, replies, persists cursor, and aborts on stop', async () => {
|
||||
const calls = [];
|
||||
let pollCount = 0;
|
||||
let askSignal;
|
||||
const stateData = { cursor: '', seen: new Set(), session: null };
|
||||
const api = {
|
||||
notifyStart: async (request) => calls.push(['start', request.token]),
|
||||
|
|
@ -55,7 +100,10 @@ test('runtime verifies the token, consumes getUpdates, replies, persists cursor,
|
|||
ensureRunning: async () => true,
|
||||
sessionExists: async () => true,
|
||||
createSession: async () => 'session-1',
|
||||
ask: async () => '回答',
|
||||
ask: async (_sessionId, _text, options) => {
|
||||
askSignal = options.signal;
|
||||
return '回答';
|
||||
},
|
||||
},
|
||||
state,
|
||||
logger: { warn() {}, error() {} },
|
||||
|
|
@ -70,11 +118,149 @@ test('runtime verifies the token, consumes getUpdates, replies, persists cursor,
|
|||
['start', 'bot-token'],
|
||||
['send', '回答', 'context-7'],
|
||||
]);
|
||||
assert.equal(askSignal.aborted, false);
|
||||
await runtime.stop();
|
||||
assert.equal(askSignal.aborted, true);
|
||||
assert.deepEqual(calls.at(-1), ['stop', 'bot-token']);
|
||||
assert.equal(runtime.status.ready, false);
|
||||
});
|
||||
|
||||
test('runtime keeps polling while a Harness interaction waits and consumes its answer in the open turn', async () => {
|
||||
const questionPresented = deferred();
|
||||
const answerSubmitted = deferred();
|
||||
const sends = [];
|
||||
const askTexts = [];
|
||||
const interactionResponses = [];
|
||||
const polledCursors = [];
|
||||
const cursorWrites = [];
|
||||
let pollCount = 0;
|
||||
let turnFinished = false;
|
||||
let secondPollStartedWhileTurnOpen = false;
|
||||
let respondedWhileTurnOpen = false;
|
||||
const stateData = { cursor: '', seen: new Set(), session: 'session-1' };
|
||||
|
||||
const api = {
|
||||
notifyStart: async () => {},
|
||||
notifyStop: async () => {},
|
||||
sendText: async (request) => sends.push(request),
|
||||
getUpdates: async ({ getUpdatesBuf, signal }) => {
|
||||
pollCount += 1;
|
||||
polledCursors.push(getUpdatesBuf);
|
||||
if (pollCount === 1) {
|
||||
return {
|
||||
ret: 0,
|
||||
get_updates_buf: 'cursor-question',
|
||||
msgs: [{
|
||||
message_id: 101,
|
||||
message_type: 1,
|
||||
from_user_id: 'owner',
|
||||
context_token: 'context-question',
|
||||
item_list: [{ type: 1, text_item: { text: '请调用 ask_user_question' } }],
|
||||
}],
|
||||
};
|
||||
}
|
||||
if (pollCount === 2) {
|
||||
secondPollStartedWhileTurnOpen = !turnFinished;
|
||||
await questionPresented.promise;
|
||||
return {
|
||||
ret: 0,
|
||||
get_updates_buf: 'cursor-answer',
|
||||
msgs: [{
|
||||
message_id: 102,
|
||||
message_type: 1,
|
||||
from_user_id: 'owner',
|
||||
context_token: 'context-answer',
|
||||
item_list: [{ type: 1, text_item: { text: '1' } }],
|
||||
}],
|
||||
};
|
||||
}
|
||||
return new Promise((_resolve, reject) => {
|
||||
const abort = () => reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));
|
||||
if (signal.aborted) abort();
|
||||
else signal.addEventListener('abort', abort, { once: true });
|
||||
});
|
||||
},
|
||||
};
|
||||
const state = {
|
||||
getUpdatesBuf: () => stateData.cursor,
|
||||
setGetUpdatesBuf: async (value) => {
|
||||
stateData.cursor = value;
|
||||
cursorWrites.push(value);
|
||||
},
|
||||
hasSeen: (id) => stateData.seen.has(id),
|
||||
markSeen: async (id) => stateData.seen.add(id),
|
||||
sessionFor: () => stateData.session,
|
||||
setSession: async (_key, value) => { stateData.session = value; },
|
||||
clearSession: async () => { stateData.session = null; },
|
||||
};
|
||||
const runtime = new WeixinRuntime({
|
||||
api,
|
||||
config: {
|
||||
botId: 'wx_interaction',
|
||||
baseUrl: 'https://ilinkai.weixin.qq.com/',
|
||||
ownerUserId: 'owner',
|
||||
},
|
||||
token: 'bot-token',
|
||||
harness: {
|
||||
ensureRunning: async () => true,
|
||||
sessionExists: async () => true,
|
||||
createSession: async () => 'session-1',
|
||||
ask: async (sessionId, text, options) => {
|
||||
askTexts.push(text);
|
||||
await options.onInteraction({
|
||||
kind: 'question',
|
||||
rpcId: 'rpc-runtime-question',
|
||||
interactionId: 'interaction-runtime-question',
|
||||
sessionId,
|
||||
payload: {
|
||||
questions: [{
|
||||
id: 'environment',
|
||||
question: '请选择测试环境',
|
||||
options: [{ label: '测试环境' }, { label: '生产环境' }],
|
||||
}],
|
||||
},
|
||||
respond: async (response) => {
|
||||
interactionResponses.push(response);
|
||||
respondedWhileTurnOpen = !turnFinished;
|
||||
answerSubmitted.resolve();
|
||||
},
|
||||
});
|
||||
questionPresented.resolve();
|
||||
await abortable(answerSubmitted.promise, options.signal);
|
||||
turnFinished = true;
|
||||
return '你选择了：测试环境';
|
||||
},
|
||||
},
|
||||
state,
|
||||
logger: { warn() {}, error() {} },
|
||||
});
|
||||
|
||||
await runtime.start();
|
||||
try {
|
||||
await eventually(
|
||||
() => turnFinished && stateData.seen.size === 2
|
||||
&& sends.some((request) => request.text === '你选择了：测试环境'),
|
||||
'the answer should resolve the original Harness turn',
|
||||
);
|
||||
|
||||
assert.equal(secondPollStartedWhileTurnOpen, true);
|
||||
assert.equal(respondedWhileTurnOpen, true);
|
||||
assert.deepEqual(askTexts, ['请调用 ask_user_question']);
|
||||
assert.deepEqual(interactionResponses, [{
|
||||
ok: true,
|
||||
value: {
|
||||
sessionId: 'session-1',
|
||||
answer: { answers: [{ id: 'environment', selected: ['测试环境'] }] },
|
||||
},
|
||||
}]);
|
||||
assert.deepEqual(cursorWrites, ['cursor-question', 'cursor-answer']);
|
||||
assert.deepEqual(polledCursors.slice(0, 3), ['', 'cursor-question', 'cursor-answer']);
|
||||
assert.equal(stateData.cursor, 'cursor-answer');
|
||||
} finally {
|
||||
await runtime.stop();
|
||||
}
|
||||
});
|
||||
|
||||
test('runtime refuses to report ready when notifyStart rejects the stored token', async () => {
|
||||
const runtime = new WeixinRuntime({
|
||||
api: {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue