mirror of
https://github.com/hansjone/dsh-im-ops.git
synced 2026-10-18 21:20: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
|
|
@ -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