fix: support Harness interactions across IM channels

test/channels/weixin/weixin-bridge.test.mjs

@@ -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;