Function runCase

e2e/telegram-run.ts:139–279

(spec: E2ECase)

}

async function runCase(spec: E2ECase): Promise<CaseResult> {
  const errors: string[] = [];
  const samples: CaseResult["samples"] = [];
  const t0 = Date.now();

  const sampleIntervalMs = spec.sampleIntervalMs ?? 1000;
  const maxWaitMs = spec.maxWaitMs ?? 30_000;

  // Drain stale updates so we don't accidentally match a previous run's reply.
  const drainFence = await drainUpdates();

  if (AUTOMATED) {
    // Automated mode: sender bot sends the prompt.
    await sendMessageAsSenderBot(TEST_CHAT_ID, spec.prompt).catch((e: Error) =>
      errors.push(`send failed: ${e.message}`),
    );
  } else {
    // Manual-trigger mode: give the operator 15 s to send the prompt manually.
    // This wait is BEFORE we start polling — the bot won't have replied yet.
    await waitForOperator(spec.prompt, 15_000);
  }

  const onSample = (s: { elapsedMs: number; text: string | undefined }) => {
    const text = s.text ?? "";
    const balanced = isBalanced(text);
    samples.push({
      elapsedMs: s.elapsedMs,
      balanced,
      len: text.length,
      preview: text.slice(0, 100),
      ...(text.length > 0 && !balanced ? { full: text } : {}),
    });
  };

  const result = await watchForReply({
    chatId: TEST_CHAT_ID,
    sinceUpdateId: drainFence,
    intervalMs: sampleIntervalMs,
    timeoutMs: maxWaitMs,
    onSample,
  });

  // Capture the highest update_id consumed so the follow-up baseline is
  // correct. getUpdates is destructive (advancing the offset confirms/deletes
  // prior updates server-side), so we must NOT reuse drainFence here.
  const firstReplyFence = result.reachedUpdateId;

  const finalText = result.finalText;
  const exp = spec.expectations ?? {};
  runExpectations(exp, finalText, errors);

  const unbalancedSamples = samples.filter(
    (s) => s.len > 0 && !s.balanced,
  ).length;
  if (exp.balancedBrackets && unbalancedSamples > 0) {
    errors.push(`${unbalancedSamples} mid-stream samples were not balanced`);
  }