Skip to content

Your lightweight open-source personal agent.

14.1 KB
Raw Blame
import { expect, test, type Locator } from "@playwright/test";

async function readMetrics(elements: Locator) {
  return elements.evaluateAll((nodes) => nodes.map((node) => {
    const style = getComputedStyle(node);
    return {
      size: parseFloat(style.fontSize), line: parseFloat(style.lineHeight), weight: style.fontWeight,
      family: style.fontFamily, letterSpacing: style.letterSpacing,
      padding: style.padding, autospace: style.getPropertyValue("text-autospace"),
    };
  }));
}

async function metrics(element: Locator): Promise<Awaited<ReturnType<typeof readMetrics>>[number]> {
  let value: Awaited<ReturnType<typeof readMetrics>>[number] | undefined;
  // Streamdown may replace a paragraph while settling its first render.
  await expect.poll(async () => {
    [value] = await readMetrics(element);
    return value !== undefined && Number.isFinite(value.size) && Number.isFinite(value.line);
  }).toBe(true);
  return value!;
}

for (const narrow of [false, true]) {
  test(`reading hierarchy and stable controls: ${narrow ? "narrow" : "desktop"}`, async ({ page }, info) => {
    await page.setViewportSize(narrow ? { width: 390, height: 844 } : { width: 1440, height: 1000 });
    await page.addInitScript(() => {
      localStorage.setItem("nanobot.locale", "zh-CN");
      localStorage.setItem("nanobot-webui.theme", "light");
    });
    await page.goto("/browser/fixture.html?case=typography");
    const group = page.getByRole("radiogroup", { name: "阅读字号", exact: true });
    await expect(group.getByRole("radio", { name: "阅读字号:标准", exact: true })).toBeChecked();
    await expect(group.getByRole("radio")).toHaveCount(3);
    const stable = await metrics(page.locator(".settings-row").first().locator(".text-control-label"));
    const tables = page.getByTestId("markdown-data-table");
    const formulaTable = tables.last();
    await expect(tables).toHaveCount(2);
    await expect(formulaTable.locator(".katex")).toHaveCount(7);
    await page.evaluate(() => document.fonts.ready);
    expect(await page.evaluate(() => Array.from(document.fonts).some((font) => font.family === "Open Sans" && font.status === "loaded"))).toBe(true);
    const observations = [];
    for (const [size, label, bodySize] of [
      ["small", "阅读字号:小", 15],
      ["standard", "阅读字号:标准", 16],
      ["large", "阅读字号:大", 18],
    ] as const) {
      await group.getByRole("radio", { name: label, exact: true }).click();
      await expect(page.locator("html")).toHaveAttribute("data-reading-text-size", size);
      const paragraph = page.locator('section[aria-label="Reading preview"] .markdown-content p').first();
      await expect(paragraph).toHaveCSS("font-size", `${bodySize}px`);
      const body = await metrics(paragraph);
      expect(body.size).toBe(bodySize);
      expect(body.line).toBeCloseTo(bodySize * 1.6);
      expect(body.weight).toBe("400");
      expect(body.family).toContain("Open Sans");
      expect((await metrics(page.locator("[data-user-text-bubble] p"))).size).toBe(bodySize);
      for (const selector of ["blockquote", "ol > li", ".task-list-item"]) {
        expect((await metrics(page.locator(`.markdown-content ${selector}`).first())).size).toBe(bodySize);
      }
      for (const [selector, ratio] of [["h1", 2], ["h2", 1.5], ["h3", 1.25], ["h4", 1.125]] as const) {
        const heading = await metrics(page.locator(`.markdown-content ${selector}`));
        expect(heading.size).toBeCloseTo(bodySize * ratio);
        expect(heading.weight).toBe("600");
      }
      for (const selector of ["table", "th", "td"]) {
        expect((await metrics(page.locator(`.markdown-content ${selector}`).first())).size).toBeCloseTo(bodySize * 0.875);
      }
      // Wide tables scroll within their wrapper instead of squeezing words into single letters.
      const textTable = tables.first();
      await expect(textTable).toHaveCSS("overflow-x", "auto");
      await textTable.evaluate(node => { node.scrollLeft = node.scrollWidth; });
      expect(await textTable.evaluate(node => {
        const bounds = node.getBoundingClientRect();
        const lastCell = node.querySelector("tbody td:last-child")!.getBoundingClientRect();
        return lastCell.right <= bounds.right + 1 && lastCell.right > bounds.left;
      })).toBe(true);
      await textTable.evaluate(node => { node.scrollLeft = 0; });
      await expect.poll(() => formulaTable.locator(".katex-html > .base").evaluateAll((nodes) => nodes.every((node) => {
        const formula = node.getBoundingClientRect();
        const cell = node.closest("th, td")!;
        const bounds = cell.getBoundingClientRect();
        const style = getComputedStyle(cell);
        return formula.width > 0
          && formula.left >= bounds.left + parseFloat(style.paddingLeft) - 1
          && formula.right <= bounds.right - parseFloat(style.paddingRight) + 1;
      }))).toBe(true);
      if (narrow) {
        expect(await formulaTable.evaluate(node => node.scrollWidth > node.clientWidth)).toBe(true);
        await formulaTable.evaluate(node => { node.scrollLeft = node.scrollWidth; });
        await expect.poll(() => formulaTable.evaluate((node) => {
          const bounds = node.getBoundingClientRect();
          const lastCell = node.querySelector("tbody td:last-child")!.getBoundingClientRect();
          return lastCell.left >= bounds.left - 1 && lastCell.right <= bounds.right + 1;
        })).toBe(true);
        await formulaTable.evaluate(node => { node.scrollLeft = 0; });
      }
      expect((await metrics(page.locator(".code-content pre"))).size).toBeCloseTo(bodySize * 0.875);
      expect((await metrics(page.locator(".markdown-inline-code"))).size).toBeCloseTo(bodySize * 0.875);
      expect((await metrics(page.locator("textarea"))).size).toBe(Math.max(16, bodySize));
      expect(await metrics(page.locator(".settings-row").first().locator(".text-control-label"))).toEqual(stable);
      const targets = await group.getByRole("radio").evaluateAll((nodes) => nodes.map((node) => {
        const { width, height } = node.getBoundingClientRect();
        return { width, height };
      }));
      // Fine-pointer presets are circular; the separate touch test protects 44px hit targets.
      for (const target of targets) {
        expect(target.width).toBeGreaterThanOrEqual(36);
        expect(target.width).toBe(target.height);
      }
      expect(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth)).toBe(true);
      observations.push({ size, body, targets });
      await page.locator(".markdown-content h1").evaluate(node => node.scrollIntoView({ block: "start" }));
      await page.screenshot({ path: info.outputPath(`${size}.png`) });
    }
    await info.attach("text-metrics", { body: JSON.stringify(observations, null, 2), contentType: "application/json" });
    await page.getByRole("button", { name: "复制代码", exact: true }).click();
    await expect(page.getByRole("button", { name: "已复制", exact: true })).toBeVisible();
    await page.locator("summary").click();
    await expect(page.getByText("这里的正文与折叠标题也应保持协调,不因字号变化发生裁切。")).toBeVisible();
  });
}

test("keyboard, tooltip, persistence and unchanged preferences", async ({ page }) => {
  await page.addInitScript(() => {
    localStorage.setItem("nanobot.locale", "en");
    if (!localStorage.getItem("nanobot-webui.settings-preferences")) {
      localStorage.setItem("nanobot-webui.settings-preferences", JSON.stringify({
        schemaVersion: 1, codeWrap: false, brandLogos: false, activityMode: "expanded", notificationSound: true,
      }));
    }
  });
  await page.goto("/browser/fixture.html?case=typography");
  const standard = page.getByRole("radio", { name: "Standard reading text", exact: true });
  await standard.focus();
  await expect(page.getByRole("tooltip")).toHaveText("Standard reading text");
  expect(await standard.evaluate(node => node.matches(":focus-visible"))).toBe(true);
  await page.keyboard.press("ArrowRight");
  const large = page.getByRole("radio", { name: "Large reading text", exact: true });
  await expect(large).toBeFocused();
  await expect(large).toBeChecked();
  await expect(page.locator(".markdown-content p").first()).toHaveCSS("line-height", `${18 * 1.6}px`);
  await page.reload();
  await expect(page.getByRole("radio", { name: "Large reading text", exact: true })).toBeChecked();
  expect(await page.evaluate(() => JSON.parse(localStorage.getItem("nanobot-webui.settings-preferences")!))).toMatchObject({
    readingTextSize: "large", codeWrap: false, brandLogos: false, activityMode: "expanded", notificationSound: true,
  });
});

test("touch composer keeps literal mention metrics and a safe editable minimum", async ({ browser, baseURL }, info) => {
  const context = await browser.newContext({ baseURL, viewport: { width: 390, height: 844 }, hasTouch: true, isMobile: true });
  try {
    const page = await context.newPage();
    await page.addInitScript(() => localStorage.setItem("nanobot.locale", "en"));
    await page.goto("/browser/fixture.html?case=typography");
    const readingGroup = page.getByRole("radiogroup", { name: "Reading text size", exact: true });
    await expect(readingGroup.getByRole("radio")).toHaveCount(3);
    const radios = await readingGroup.getByRole("radio").all();
    for (const [index, radio] of radios.entries()) {
      await radio.scrollIntoViewIfNeeded();
      const target = await radio.boundingBox();
      expect(target!.width).toBeGreaterThanOrEqual(44);
      expect(target!.height).toBeGreaterThanOrEqual(44);
      for (const edge of [-20, 20]) {
        await radios[(index + 1) % radios.length].tap();
        await page.touchscreen.tap(target!.x + target!.width / 2, target!.y + target!.height / 2 + edge);
        await expect(radio).toBeChecked();
      }
    }
    const input = page.getByRole("textbox", { name: "Message input", exact: true });
    const overlay = page.locator(".thread-composer-input > div[aria-hidden]");
    const layers = page.locator(".thread-composer-input > :is(div[aria-hidden], textarea)");
    const readingSizes = [
      ["small", "Small reading text", 16],
      ["standard", "Standard reading text", 16],
      ["large", "Large reading text", 18],
    ] as const;
    await input.fill("中文 English @typography 混排\n多行内容与光标保持一致,继续输入 more text.\n最后一行。");
    for (const [size, label, fontSize] of readingSizes) {
      await readingGroup.getByRole("radio", { name: label, exact: true }).click();
      await expect(page.locator("html")).toHaveAttribute("data-reading-text-size", size);
      await expect(input).toHaveCSS("font-size", `${fontSize}px`);
      await input.focus();
      await expect(overlay).toContainText("@typography");
      // Sample both layers together; preference updates must not split the comparison.
      const [decoration, text] = await readMetrics(layers);
      expect(text.size).toBe(fontSize);
      expect(decoration).toEqual(text);
      expect(text.autospace).toBe("no-autospace");
      expect(await input.evaluate(node => node.scrollHeight <= node.clientHeight + 1)).toBe(true);
      expect(await page.evaluate(() => visualViewport?.scale)).toBe(1);
    }
    await input.fill([...Array.from({ length: 18 }, (_, i) => `第 ${i + 1} 行 中文 English @typography 光标与装饰层。`), "最后一行。"].join("\n"));
    for (const [size, label, fontSize] of readingSizes) {
      await readingGroup.getByRole("radio", { name: label, exact: true }).click();
      await expect(page.locator("html")).toHaveAttribute("data-reading-text-size", size);
      await expect(input).toHaveCSS("font-size", `${fontSize}px`);
      await input.focus();
      await input.press("Control+End");
      expect(await input.evaluate(node => node.scrollHeight > node.clientHeight)).toBe(true);
      await expect.poll(async () => Math.abs(await input.evaluate(node => node.scrollTop) - await overlay.evaluate(node => node.scrollTop))).toBeLessThanOrEqual(1);
      const [decoration, text] = await readMetrics(layers);
      expect(text.size).toBe(fontSize);
      expect(decoration).toEqual(text);
    }
    await page.keyboard.press("End");
    await page.keyboard.type("追加文字");
    await expect(input).toHaveValue(/最后一行。追加文字$/);
    await page.screenshot({ path: info.outputPath("touch-mention-caret.png") });
    await page.getByRole("button", { name: "Send message", exact: true }).click();
    await expect(page.locator("[data-user-text-bubble]").last()).toContainText("最后一行。追加文字");
  } finally {
    await context.close();
  }
});


test("large narrow reading keeps long lists and code reachable", async ({ page }) => {
  await page.setViewportSize({ width: 390, height: 844 });
  await page.addInitScript(() => {
    localStorage.setItem("nanobot.locale", "en");
    localStorage.setItem("nanobot-webui.settings-preferences", JSON.stringify({ schemaVersion: 1, readingTextSize: "large" }));
  });
  await page.goto("/browser/fixture.html?case=typography&stress");
  const lastItem = page.getByText("第 30 项:中文与 English 混排的长列表内容,保持自然换行和清楚的编号。", { exact: true });
  await lastItem.click();
  await expect(lastItem).toBeVisible();
  await expect(lastItem).toHaveCSS("font-size", "18px");
  const pre = page.locator(".code-content pre").last();
  await expect(pre).toContainText('const item79 = "第 80 行 — readable code";');
  await expect(pre).toHaveCSS("font-size", "15.75px");
  const finalLine = pre.getByText('"第 80 行 — readable code"', { exact: true });
  await finalLine.click();
  await expect(finalLine).toBeVisible();
  expect(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth)).toBe(true);
  await page.getByRole("button", { name: "Copy code", exact: true }).last().click();
  await expect(page.getByRole("button", { name: "Copied", exact: true })).toBeVisible();
  const input = page.getByRole("textbox", { name: "Message input", exact: true });
  await input.fill("读完长内容后仍然可以发送。Still usable.");
  await page.getByRole("button", { name: "Send message", exact: true }).click();
  await expect(page.locator("[data-user-text-bubble]").last()).toContainText("Still usable.");
});