@hutusi/amytis 1.15.0 → 1.17.0

package/tests/integration/normalize-vuepress-math.test.ts

@@ -0,0 +1,149 @@
+import { describe, expect, test } from "bun:test";
+import { normalizeVuepressBlockMath } from "../../src/lib/normalize-vuepress-math";
+import MarkdownRenderer from "@/components/MarkdownRenderer";
+import { renderAsync } from "@/test-utils/render";
+
+describe("Integration: normalizeVuepressBlockMath", () => {
+  test("splits an inline-style $$ opener+closer onto their own lines", () => {
+    const src = [
+      "$$ \\mathbf{A} = \\begin{bmatrix}",
+      "a & b \\\\",
+      "c & d",
+      "\\end{bmatrix} $$",
+    ].join("\n");
+    const out = normalizeVuepressBlockMath(src);
+    expect(out.split("\n")).toEqual([
+      "$$",
+      "\\mathbf{A} = \\begin{bmatrix}",
+      "a & b \\\\",
+      "c & d",
+      "\\end{bmatrix}",
+      "$$",
+    ]);
+  });
+
+  test("expands single-line $$ x $$ onto three lines so remark-math treats it as block", () => {
+    // micromark-extension-math requires `$$` on its own line; single-line
+    // collapses to inline (no katex-display, no centering, no block margin).
+    const src = "$$ x^2 + y^2 = 1 $$";
+    expect(normalizeVuepressBlockMath(src).split("\n")).toEqual([
+      "$$",
+      "x^2 + y^2 = 1",
+      "$$",
+    ]);
+  });
+
+  test("leaves degenerate empty $$$$ alone", () => {
+    expect(normalizeVuepressBlockMath("$$$$")).toBe("$$$$");
+    expect(normalizeVuepressBlockMath("$$  $$")).toBe("$$  $$");
+  });
+
+  test("preserves the opener indent when expanding a single-line block", () => {
+    const src = "    $$ y = mx + b $$";
+    expect(normalizeVuepressBlockMath(src).split("\n")).toEqual([
+      "    $$",
+      "    y = mx + b",
+      "    $$",
+    ]);
+  });
+
+  test("does not touch inline $...$ math", () => {
+    const src = "An equation: $x = 1$ in the middle of a paragraph.";
+    expect(normalizeVuepressBlockMath(src)).toBe(src);
+  });
+
+  test("is idempotent — already-normalized blocks pass through unchanged", () => {
+    const src = ["$$", "x = 1", "$$"].join("\n");
+    expect(normalizeVuepressBlockMath(src)).toBe(src);
+    expect(normalizeVuepressBlockMath(normalizeVuepressBlockMath(src))).toBe(src);
+  });
+
+  test("skips $$ inside fenced code blocks (doc examples)", () => {
+    const src = [
+      "Here is the source:",
+      "",
+      "```",
+      "$$ \\mathbf{A} = \\begin{bmatrix} a \\end{bmatrix} $$",
+      "```",
+      "",
+      "Real math follows:",
+      "",
+      "$$ y = mx + b $$",
+    ].join("\n");
+    const out = normalizeVuepressBlockMath(src);
+    // The code-block example is preserved verbatim — no split.
+    expect(out).toContain("$$ \\mathbf{A} = \\begin{bmatrix} a \\end{bmatrix} $$");
+    // The real single-line block math after the fence is expanded onto its
+    // own three lines so remark-math recognizes it as block.
+    expect(out).toContain("$$\ny = mx + b\n$$");
+    expect(out).not.toContain("$$ y = mx + b $$");
+  });
+
+  test("preserves opener indent on split lines for list-nested block math", () => {
+    // A 4-space-indented block inside a bullet item. Without indent
+    // preservation, the split body lines drop out of the list and the
+    // following inline math gets parsed as one big malformed math span.
+    const src = [
+      "- Item with embedded math:",
+      "",
+      "    $$\\mathbf{A} = \\begin{bmatrix}",
+      "    a & b",
+      "    \\end{bmatrix}$$",
+      "",
+      "- Next item with inline math: $\\mathbf{X}$, comma here.",
+    ].join("\n");
+    const out = normalizeVuepressBlockMath(src);
+    // Synthetic opener line carries the original 4-space indent so it stays
+    // inside the list item.
+    expect(out).toContain("    $$\n    \\mathbf{A}");
+    // Closer's `$$` likewise stays indented.
+    expect(out).toContain("    \\end{bmatrix}\n    $$");
+  });
+
+  test("handles multiple block-math runs in the same source", () => {
+    const src = [
+      "$$ a = 1",
+      "b = 2 $$",
+      "",
+      "Some prose.",
+      "",
+      "$$ c = 3",
+      "d = 4 $$",
+    ].join("\n");
+    const out = normalizeVuepressBlockMath(src);
+    // Both runs split, prose preserved.
+    expect(out.split(/^\$\$$/m).length).toBeGreaterThanOrEqual(5);
+    expect(out).toContain("Some prose.");
+  });
+});
+
+describe("Integration: end-to-end LaTeX rendering for VuePress-style block math", () => {
+  test("a multi-line bmatrix block renders as a katex-display, not katex-error", async () => {
+    const html = await renderAsync(
+      MarkdownRenderer({
+        content: [
+          "$$ \\mathbf{A} = \\begin{bmatrix}",
+          "a & b \\\\",
+          "c & d",
+          "\\end{bmatrix} $$",
+        ].join("\n"),
+        latex: true,
+      }),
+    );
+    expect(html).toContain("katex-display");
+    expect(html).not.toContain("katex-error");
+  });
+
+  test("normalization only runs when latex is true (idempotent so this is a perf hint)", async () => {
+    // With latex disabled, the math fences are passed through unchanged
+    // to ReactMarkdown — same input the engine would have always seen.
+    // We just verify the page renders without crashing.
+    const html = await renderAsync(
+      MarkdownRenderer({
+        content: "$$ x $$",
+        latex: false,
+      }),
+    );
+    expect(html).toContain("$$"); // not turned into math because latex was off
+  });
+});

package/tests/integration/reading-time-headings.test.ts

@@ -2,22 +2,24 @@ import { describe, expect, test } from "bun:test";
 import { getAllPosts, getPostBySlug } from "../../src/lib/markdown";
 
 describe("Integration: Reading Time & Headings", () => {
-  test("posts have readingTime matching expected format", () => {
+  test("posts have a positive whole-minute readingMinutes", () => {
     const posts = getAllPosts();
     expect(posts.length).toBeGreaterThan(0);
 
     posts.forEach((post) => {
-      expect(post.readingTime).toMatch(/^\d+ min read$/);
+      expect(Number.isInteger(post.readingMinutes)).toBe(true);
+      expect(post.readingMinutes).toBeGreaterThanOrEqual(1);
     });
   });
 
-  test("kitchen-sink post has readingTime in correct format", () => {
+  test("kitchen-sink post has a positive readingMinutes", () => {
     const post = getPostBySlug("kitchen-sink");
     if (!post) {
       console.warn("Skipping: kitchen-sink post not found");
       return;
     }
-    expect(post.readingTime).toMatch(/^\d+ min read$/);
+    expect(Number.isInteger(post.readingMinutes)).toBe(true);
+    expect(post.readingMinutes).toBeGreaterThanOrEqual(1);
   });
 
   test("headings on real posts have correct structure", () => {
@@ -49,13 +51,13 @@ describe("Integration: Reading Time & Headings", () => {
     });
   });
 
-  test("short posts have 1 min read", () => {
+  test("short posts have readingMinutes === 1 (floor)", () => {
     const shortPost = getPostBySlug("legacy-markdown");
     expect(shortPost).toBeDefined();
     if (!shortPost) {
       throw new Error("fixture 'legacy-markdown' not found");
     }
-    expect(shortPost.readingTime).toBe("1 min read");
+    expect(shortPost.readingMinutes).toBe(1);
   });
 
   test("multilingual post has headings with correct IDs", () => {

package/tests/integration/series-draft.test.ts

@@ -1,13 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { getSeriesData, getAllSeries } from "../../src/lib/markdown";
-
-function restoreEnvVar(key: string, value: string | undefined): void {
-  if (value === undefined) {
-    delete process.env[key];
-  } else {
-    process.env[key] = value;
-  }
-}
+import { setEnvVar, restoreEnvVar } from "../helpers/env";
 
 describe("Integration: Series Draft Support", () => {
   test("all series are included when NODE_ENV is not production", () => {
@@ -28,8 +21,8 @@ describe("Integration: Series Draft Support", () => {
     const originalEnv = process.env.NODE_ENV;
     const originalPythonRst = process.env.AMYTIS_ENABLE_PYTHON_RST;
     try {
-      process.env.NODE_ENV = "production";
-      process.env.AMYTIS_ENABLE_PYTHON_RST = "0";
+      setEnvVar("NODE_ENV", "production");
+      setEnvVar("AMYTIS_ENABLE_PYTHON_RST", "0");
       // This should not throw; draft series are simply excluded
       const series = getAllSeries();
       expect(typeof series).toBe("object");
@@ -43,10 +36,10 @@ describe("Integration: Series Draft Support", () => {
     const originalEnv = process.env.NODE_ENV;
     const originalPythonRst = process.env.AMYTIS_ENABLE_PYTHON_RST;
     try {
-      process.env.NODE_ENV = "production";
-      process.env.AMYTIS_ENABLE_PYTHON_RST = "0";
+      setEnvVar("NODE_ENV", "production");
+      setEnvVar("AMYTIS_ENABLE_PYTHON_RST", "0");
       const allSeries = getAllSeries();
-      
+
       // Verify that every series returned has draft: false (or undefined which defaults to false)
       Object.keys(allSeries).forEach(slug => {
         const seriesData = getSeriesData(slug);

package/tests/integration/series-index-cta.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, test } from "bun:test";
+import SeriesPage from "@/app/series/[slug]/page";
+import { renderAsync } from "@/test-utils/render";
+import { getSeriesData, getSeriesPosts } from "@/lib/markdown";
+import { t } from "@/lib/i18n";
+import { getPostUrl } from "@/lib/urls";
+
+// Renders the actual series landing page server component for a real fixture
+// series under content/series/. Same pattern as book-index-cta.test.ts —
+// catches accidental removal of either CTA or a broken ?immersive=1 href
+// without needing component-rendering test infrastructure.
+
+const FIXTURE_SERIES_SLUG = "digital-garden";
+
+function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// Returns the inner HTML of the smallest <a> element on the page whose href
+// attribute equals the given value, or null if no such anchor exists. We
+// match the anchor body rather than just `href="..."` so the label-text
+// assertion is bound to the same element — otherwise an unrelated link with
+// the same href (e.g. a post-row in the series list) would satisfy a naïve
+// `toContain('href="..."')` check and let an accidentally deleted CTA pass.
+function findAnchorBodyByHref(html: string, href: string): string | null {
+  const re = new RegExp(`<a[^>]*\\bhref="${escapeRegex(href)}"[^>]*>([\\s\\S]*?)</a>`);
+  const m = html.match(re);
+  return m ? m[1] : null;
+}
+
+// Picks the first installment respecting series sort order, mirroring the
+// inline logic in src/app/series/[slug]/page.tsx (the test would otherwise
+// have to assume a particular sort).
+function pickFirstPostHref(slug: string): string {
+  const posts = getSeriesPosts(slug);
+  if (posts.length === 0) {
+    throw new Error(`Fixture series "${slug}" has no posts`);
+  }
+  const data = getSeriesData(slug) as (Record<string, unknown> | null);
+  // Series sort lives on the index frontmatter — top-level on the resolved
+  // PostData blob, same access the page uses. Treated as unknown here to
+  // avoid leaning on internal PostData shape.
+  const sort = typeof data?.sort === 'string' ? data.sort : undefined;
+  const firstPost = sort === 'date-asc' || sort === 'manual' ? posts[0] : posts[posts.length - 1];
+  return getPostUrl(firstPost);
+}
+
+describe("Integration: series index Immersive reading CTA", () => {
+  test("renders an Immersive reading CTA linking to the first post with ?immersive=1", async () => {
+    const primaryHref = pickFirstPostHref(FIXTURE_SERIES_SLUG);
+    const expectedHref = `${primaryHref}?immersive=1`;
+
+    const html = await renderAsync(
+      SeriesPage({ params: Promise.resolve({ slug: FIXTURE_SERIES_SLUG }) }),
+    );
+
+    const body = findAnchorBodyByHref(html, expectedHref);
+    expect(body).not.toBeNull();
+    // Label text inside the same anchor — guards against the anchor existing
+    // but having been repurposed to a different CTA.
+    expect(body).toContain(t("immersive_reading"));
+  });
+
+  test("primary 'Start reading' CTA still renders alongside the immersive CTA", async () => {
+    const primaryHref = pickFirstPostHref(FIXTURE_SERIES_SLUG);
+
+    const html = await renderAsync(
+      SeriesPage({ params: Promise.resolve({ slug: FIXTURE_SERIES_SLUG }) }),
+    );
+
+    // Multiple links may share this href (the series posts list also points
+    // at the first post), so iterate over all matches and confirm at least
+    // one of them is the CTA — the one containing the start_reading label.
+    const re = new RegExp(
+      `<a[^>]*\\bhref="${escapeRegex(primaryHref)}"[^>]*>([\\s\\S]*?)</a>`,
+      "g",
+    );
+    const label = t("start_reading");
+    let foundCta = false;
+    for (const match of html.matchAll(re)) {
+      if (match[1].includes(label)) {
+        foundCta = true;
+        break;
+      }
+    }
+    expect(foundCta).toBe(true);
+  });
+});