mirror of
https://github.com/hansjone/dsh-im-ops.git
synced 2026-10-09 03:03:24 +08:00
1018 lines
34 KiB
JavaScript
1018 lines
34 KiB
JavaScript
import assert from 'node:assert/strict';
|
||
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',
|
||
rawEventType: 'C2C_MESSAGE_CREATE',
|
||
senderId: 'owner-openid',
|
||
senderIsBot: false,
|
||
content: '请回答',
|
||
messageId: 'msg-1',
|
||
replyTarget: { scope: 'c2c', targetId: 'owner-openid', msgId: 'msg-1' },
|
||
...overrides,
|
||
};
|
||
}
|
||
|
||
test('QQ private messages stream Harness snapshots and finalize once', async () => {
|
||
const frames = [];
|
||
const sent = [];
|
||
const seen = new Set();
|
||
const bridge = new QqHarnessBridge({
|
||
bot: {
|
||
sendText: async (_target, text) => sent.push(text),
|
||
openStream: () => ({
|
||
update: async (text) => frames.push(text),
|
||
complete: async () => frames.push('DONE'),
|
||
cancel() {},
|
||
}),
|
||
},
|
||
ownerUserOpenid: 'owner-openid',
|
||
harness: {
|
||
sessionExists: async () => true,
|
||
createSession: async () => 'session-new',
|
||
ensureRunning: async () => true,
|
||
ask: async (_session, _text, { onUpdate }) => {
|
||
await onUpdate({ type: 'text', text: '回答中' });
|
||
return '最终回答';
|
||
},
|
||
},
|
||
state: {
|
||
hasSeen: (id) => seen.has(id),
|
||
markSeen: async (id) => seen.add(id),
|
||
sessionFor: () => 'session-existing',
|
||
setSession: async () => {},
|
||
clearSession: async () => {},
|
||
},
|
||
});
|
||
|
||
await bridge.accept(message());
|
||
assert.deepEqual(frames, ['回答中', '最终回答', 'DONE']);
|
||
assert.deepEqual(sent, []);
|
||
assert.equal(seen.has('msg-1'), true);
|
||
assert.equal(bridge.status.messagesReplied, 1);
|
||
});
|
||
|
||
test('QQ bridge accepts only the scanner and requires an at-message event in groups', async () => {
|
||
let asks = 0;
|
||
const state = {
|
||
hasSeen: () => false,
|
||
markSeen: async () => {},
|
||
sessionFor: () => 'session',
|
||
sessionExists: async () => true,
|
||
setSession: async () => {},
|
||
clearSession: async () => {},
|
||
};
|
||
const bridge = new QqHarnessBridge({
|
||
bot: { sendText: async () => {} },
|
||
ownerUserOpenid: 'owner-openid',
|
||
harness: { sessionExists: async () => true, ask: async () => { asks += 1; return 'ok'; } },
|
||
state,
|
||
});
|
||
await bridge.accept(message({ messageId: 'other', senderId: 'other-openid' }));
|
||
await bridge.accept(message({
|
||
messageId: 'group', kind: 'group', groupOpenid: 'group-1', rawEventType: 'GROUP_MESSAGE_CREATE',
|
||
replyTarget: { scope: 'group', targetId: 'group-1', msgId: 'group' },
|
||
}));
|
||
assert.equal(asks, 0);
|
||
assert.equal(bridge.status.messagesRejected, 1);
|
||
});
|
||
|
||
test('QQ credential-bound bots accept senders within the platform visibility scope', async () => {
|
||
let asks = 0;
|
||
const bridge = new QqHarnessBridge({
|
||
bot: { sendText: async () => {} },
|
||
ownerUserOpenid: '*',
|
||
harness: {
|
||
sessionExists: async () => true,
|
||
ask: async () => { asks += 1; return 'ok'; },
|
||
},
|
||
state: {
|
||
hasSeen: () => false,
|
||
markSeen: async () => {},
|
||
sessionFor: () => 'session',
|
||
setSession: async () => {},
|
||
clearSession: async () => {},
|
||
},
|
||
});
|
||
await bridge.accept(message({ messageId: 'visible', senderId: 'visible-user' }));
|
||
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 presents concurrent approvals in FIFO order without a code and consumes exact decisions', async () => {
|
||
const fixture = stateFixture([['c2c:owner-openid', 'session-approval']]);
|
||
const sent = [];
|
||
const asked = [];
|
||
const completed = deferred();
|
||
const responses = [];
|
||
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);
|
||
for (const [approvalId, reason, command] of [
|
||
['qq-approval-one', '允许执行第一步', "printf 'first-step\\n'"],
|
||
['qq-approval-two', '允许执行第二步', "printf 'second-step\\n'"],
|
||
]) {
|
||
await options.onInteraction({
|
||
kind: 'approval',
|
||
interactionId: approvalId,
|
||
rpcId: `${approvalId}-rpc`,
|
||
sessionId,
|
||
payload: {
|
||
type: 'approval/requested',
|
||
sessionId,
|
||
approvalId,
|
||
toolName: 'bash',
|
||
callId: `${approvalId}-call`,
|
||
reason,
|
||
},
|
||
toolCall: {
|
||
callId: `${approvalId}-call`,
|
||
name: 'bash',
|
||
arguments: JSON.stringify({ command }),
|
||
},
|
||
respond: async (result) => {
|
||
responses.push(result);
|
||
if (responses.length === 2) completed.resolve();
|
||
return { accepted: true };
|
||
},
|
||
});
|
||
}
|
||
await completed.promise;
|
||
return '审批完成';
|
||
},
|
||
},
|
||
state: fixture.state,
|
||
});
|
||
|
||
const prompt = bridge.accept(message({
|
||
messageId: 'approval-start',
|
||
content: '启动两个审批',
|
||
}));
|
||
await eventually(() => sent.some(({ text }) => text.includes('允许执行第一步')));
|
||
assert.equal(sent.some(({ text }) => text.includes('允许执行第二步')), false);
|
||
assert.match(sent.find(({ text }) => text.includes('允许执行第一步')).text, /bash/);
|
||
assert.match(sent.find(({ text }) => text.includes('允许执行第一步')).text, /批准.*拒绝/s);
|
||
assert.doesNotMatch(sent.find(({ text }) => text.includes('允许执行第一步')).text, /qq-approval-one/);
|
||
|
||
await bridge.accept(message({
|
||
messageId: 'approval-allow',
|
||
content: '批准',
|
||
replyTarget: { scope: 'c2c', targetId: 'owner-openid', msgId: 'approval-allow' },
|
||
}));
|
||
await eventually(() => sent.some(({ text }) => text.includes('允许执行第二步')));
|
||
assert.doesNotMatch(sent.find(({ text }) => text.includes('允许执行第二步')).text, /qq-approval-two/);
|
||
|
||
await Promise.all([
|
||
bridge.accept(message({
|
||
messageId: 'approval-reject',
|
||
content: '拒绝',
|
||
replyTarget: { scope: 'c2c', targetId: 'owner-openid', msgId: 'approval-reject' },
|
||
})),
|
||
prompt,
|
||
]);
|
||
|
||
assert.deepEqual(responses, [
|
||
{
|
||
ok: true,
|
||
value: {
|
||
sessionId: 'session-approval',
|
||
approvalId: 'qq-approval-one',
|
||
outcome: 'allowed-once',
|
||
},
|
||
},
|
||
{
|
||
ok: true,
|
||
value: {
|
||
sessionId: 'session-approval',
|
||
approvalId: 'qq-approval-two',
|
||
outcome: 'rejected',
|
||
},
|
||
},
|
||
]);
|
||
assert.deepEqual(asked, ['启动两个审批']);
|
||
assert.equal(sent.at(-1).text, '审批完成');
|
||
});
|
||
|
||
test('QQ deduplicates question replays, cancels orphan questions, and keeps approvals fail-closed', async () => {
|
||
const fixture = stateFixture();
|
||
const sent = [];
|
||
let approvalResponse;
|
||
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 (result) => { approvalResponse = result; },
|
||
});
|
||
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.deepEqual(approvalResponse, {
|
||
ok: true,
|
||
value: {
|
||
sessionId: 'session-replay',
|
||
approvalId: 'qq-approval',
|
||
outcome: 'rejected',
|
||
},
|
||
});
|
||
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);
|
||
});
|