@hutusi/amytis 1.15.0 → 1.16.0

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/sync-vuepress-book.test.ts

@@ -0,0 +1,240 @@
+import { describe, expect, test, beforeEach, afterEach } from "bun:test";
+import { spawnSync } from "child_process";
+import { mkdirSync, mkdtempSync, rmSync, existsSync, readFileSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import path from "path";
+import matter from "gray-matter";
+
+const FIXTURE_SOURCE = path.resolve("tests/fixtures/sync-vuepress-book/docs");
+
+// Invoke through the published `bun run sync-vuepress-book` entrypoint and the
+// `--source` / `--dest` flags so the test exercises everything a real user does:
+// the package.json script wiring + the CLI argv parser, not just the inner sync
+// pipeline.
+function runSync(source: string, dest: string) {
+  return spawnSync(
+    "bun",
+    ["run", "sync-vuepress-book", "--source", source, "--dest", dest],
+    {
+      encoding: "utf8",
+      cwd: process.cwd(),
+    },
+  );
+}
+
+describe("Integration: sync-vuepress-book script", () => {
+  let dest: string;
+
+  beforeEach(() => {
+    dest = mkdtempSync(path.join(tmpdir(), "sync-vuepress-book-"));
+  });
+
+  afterEach(() => {
+    if (dest && existsSync(dest)) rmSync(dest, { recursive: true, force: true });
+  });
+
+  test("runs end-to-end and produces the expected layout", () => {
+    const res = runSync(FIXTURE_SOURCE, dest);
+    expect(res.status).toBe(0);
+
+    // Markdown content was rsynced verbatim (no rewriting on copy).
+    expect(existsSync(path.join(dest, "intro", "welcome.md"))).toBe(true);
+    expect(existsSync(path.join(dest, "maths", "linear", "vectors.md"))).toBe(true);
+    expect(existsSync(path.join(dest, "maths", "linear", "matrices.md"))).toBe(true);
+
+    // Asset folders co-located with chapters were copied.
+    expect(existsSync(path.join(dest, "maths", "linear", "assets", "diagram.png"))).toBe(true);
+
+    // .vuepress was excluded.
+    expect(existsSync(path.join(dest, ".vuepress"))).toBe(false);
+
+    // index.mdx exists with parsed nested TOC.
+    const indexPath = path.join(dest, "index.mdx");
+    expect(existsSync(indexPath)).toBe(true);
+    const { data } = matter(readFileSync(indexPath, "utf8")) as unknown as { data: Record<string, unknown> };
+    expect(data.title).toBe("Fixture Book");
+    const chapters = data.chapters as Array<Record<string, unknown>>;
+    expect(chapters[0]).toMatchObject({ title: "Intro", id: "intro/welcome" });
+    expect(chapters[1]).toMatchObject({ section: "Maths" });
+    const mathsItems = (chapters[1].items as Array<Record<string, unknown>>);
+    expect(mathsItems[0]).toMatchObject({ section: "Linear Algebra" });
+    const linearItems = mathsItems[0].items as Array<Record<string, unknown>>;
+    expect(linearItems).toEqual([
+      { title: "Vectors", id: "maths/linear/vectors" },
+      { title: "Matrices", id: "maths/linear/matrices" },
+    ]);
+  });
+
+  test("preserves user-controlled frontmatter on re-run", () => {
+    // First run creates index.mdx.
+    expect(runSync(FIXTURE_SOURCE, dest).status).toBe(0);
+
+    // Author edits cover image + featured flag.
+    const indexPath = path.join(dest, "index.mdx");
+    const parsed = matter(readFileSync(indexPath, "utf8")) as unknown as { data: Record<string, unknown>; content: string };
+    const edited = matter.stringify(parsed.content, {
+      ...parsed.data,
+      coverImage: "text:FB",
+      featured: true,
+      excerpt: "A tiny book for tests.",
+    });
+    writeFileSync(indexPath, edited);
+
+    // Re-run should keep the edited fields and refresh `chapters`.
+    expect(runSync(FIXTURE_SOURCE, dest).status).toBe(0);
+    const { data: refreshed } = matter(readFileSync(indexPath, "utf8")) as unknown as { data: Record<string, unknown> };
+    expect(refreshed.coverImage).toBe("text:FB");
+    expect(refreshed.featured).toBe(true);
+    expect(refreshed.excerpt).toBe("A tiny book for tests.");
+    expect(Array.isArray(refreshed.chapters)).toBe(true);
+  });
+
+  test("prunes dest files removed upstream (mirror semantics)", () => {
+    // First sync — dest now has every fixture file.
+    expect(runSync(FIXTURE_SOURCE, dest).status).toBe(0);
+    expect(existsSync(path.join(dest, "maths", "linear", "matrices.md"))).toBe(true);
+
+    // Simulate an upstream deletion by syncing from a smaller temp source tree
+    // (just the bits we need for the still-listed chapters) and a config that
+    // no longer references matrices.
+    const trimmed = mkdtempSync(path.join(tmpdir(), "sync-trimmed-"));
+    try {
+      const docs = path.join(trimmed, "docs");
+      const vp = path.join(docs, ".vuepress");
+      mkdirSync(vp, { recursive: true });
+      writeFileSync(
+        path.join(vp, "config.js"),
+        `export default {
+          title: 'Fixture Book',
+          theme: { sidebar: [{ text: 'Vectors', link: '/maths/linear/vectors' }] },
+        }
+        `,
+      );
+      mkdirSync(path.join(docs, "maths", "linear"), { recursive: true });
+      writeFileSync(path.join(docs, "maths", "linear", "vectors.md"), "---\ntitle: Vectors\n---\n# Vectors\n");
+
+      expect(runSync(docs, dest).status).toBe(0);
+
+      // Vectors survives, matrices is gone, the now-empty assets/ dir is cleaned up.
+      expect(existsSync(path.join(dest, "maths", "linear", "vectors.md"))).toBe(true);
+      expect(existsSync(path.join(dest, "maths", "linear", "matrices.md"))).toBe(false);
+      expect(existsSync(path.join(dest, "intro"))).toBe(false);
+      expect(existsSync(path.join(dest, "maths", "linear", "assets"))).toBe(false);
+      // index.mdx is regenerated, not pruned.
+      expect(existsSync(path.join(dest, "index.mdx"))).toBe(true);
+    } finally {
+      rmSync(trimmed, { recursive: true, force: true });
+    }
+  });
+
+  test("preserves user-added dotfiles on re-run (out-of-band overlay state)", () => {
+    expect(runSync(FIXTURE_SOURCE, dest).status).toBe(0);
+    const dotfile = path.join(dest, ".gitkeep");
+    writeFileSync(dotfile, "");
+    expect(runSync(FIXTURE_SOURCE, dest).status).toBe(0);
+    expect(existsSync(dotfile)).toBe(true);
+  });
+
+  test("resolves folder-index sidebar links (e.g. /guide/ → guide/README.md)", () => {
+    const folder = mkdtempSync(path.join(tmpdir(), "sync-folder-"));
+    try {
+      const docs = path.join(folder, "docs");
+      const vp = path.join(docs, ".vuepress");
+      mkdirSync(vp, { recursive: true });
+      writeFileSync(
+        path.join(vp, "config.js"),
+        `export default {
+          title: 'Folder-Index Book',
+          theme: { sidebar: [{ text: 'Guide', link: '/guide/' }] },
+        }
+        `,
+      );
+      mkdirSync(path.join(docs, "guide"), { recursive: true });
+      writeFileSync(path.join(docs, "guide", "README.md"), "---\ntitle: Guide\n---\n# Guide\n");
+
+      const res = runSync(docs, dest);
+      expect(res.status).toBe(0);
+      // The chapter id strips the trailing slash, so the folder-index target
+      // exists at <dest>/guide/README.md and the TOC entry's id is `guide`.
+      const { data } = matter(readFileSync(path.join(dest, "index.mdx"), "utf8")) as unknown as { data: Record<string, unknown> };
+      expect((data.chapters as Array<{ id: string }>)[0].id).toBe("guide");
+      expect(existsSync(path.join(dest, "guide", "README.md"))).toBe(true);
+    } finally {
+      rmSync(folder, { recursive: true, force: true });
+    }
+  });
+
+  test("rejects a config.ts with a clear message instead of acorn parse failure", () => {
+    const tsConfig = mkdtempSync(path.join(tmpdir(), "sync-ts-config-"));
+    try {
+      const docs = path.join(tsConfig, "docs");
+      const vp = path.join(docs, ".vuepress");
+      mkdirSync(vp, { recursive: true });
+      writeFileSync(
+        path.join(vp, "config.ts"),
+        "const x: number = 1; export default { theme: { sidebar: [] } }\n",
+      );
+      const res = runSync(docs, dest);
+      expect(res.status).not.toBe(0);
+      expect(res.stderr).toMatch(/config\.ts/);
+      // Match the actionable phrasing only — if a regression let the raw
+      // acorn parse error through, that should fail this assertion.
+      expect(res.stderr).toMatch(/Compile to JavaScript|JS-only/);
+    } finally {
+      rmSync(tsConfig, { recursive: true, force: true });
+    }
+  });
+
+  test("drops a leaf with id 'contents' from the TOC (Amytis renders its own)", () => {
+    const withContents = mkdtempSync(path.join(tmpdir(), "sync-contents-"));
+    try {
+      const docs = path.join(withContents, "docs");
+      const vp = path.join(docs, ".vuepress");
+      mkdirSync(vp, { recursive: true });
+      writeFileSync(
+        path.join(vp, "config.js"),
+        `export default {
+          title: 'TOC-Heavy Book',
+          theme: {
+            sidebar: [
+              { text: '目录', link: 'contents' },
+              { text: 'Real', link: '/real-chapter' },
+            ],
+          },
+        }
+        `,
+      );
+      writeFileSync(path.join(docs, "contents.md"), "# Table of Contents\n- [Real](real-chapter.md)\n");
+      writeFileSync(path.join(docs, "real-chapter.md"), "---\ntitle: Real\n---\n# Real\n");
+
+      const res = runSync(docs, dest);
+      expect(res.status).toBe(0);
+      const { data } = matter(readFileSync(path.join(dest, "index.mdx"), "utf8")) as unknown as { data: Record<string, unknown> };
+      const chapterIds = (data.chapters as Array<{ id?: string; section?: string }>).map(c => c.id ?? c.section);
+      expect(chapterIds).toEqual(["real-chapter"]);
+      // The summary mentions the dropped leaf so the run isn't silent.
+      expect(res.stdout).toMatch(/contents/);
+    } finally {
+      rmSync(withContents, { recursive: true, force: true });
+    }
+  });
+
+  test("exits with an error when a sidebar leaf points to a missing source file", () => {
+    // Create a corrupt config with a broken link.
+    const broken = mkdtempSync(path.join(tmpdir(), "sync-broken-"));
+    try {
+      const docsDir = path.join(broken, "docs");
+      const vp = path.join(docsDir, ".vuepress");
+      mkdirSync(vp, { recursive: true });
+      writeFileSync(
+        path.join(vp, "config.js"),
+        "export default { theme: { sidebar: [{ text: 'Missing', link: '/nope' }] } }\n",
+      );
+      const res = runSync(docsDir, dest);
+      expect(res.status).not.toBe(0);
+      expect(res.stderr).toContain("source files that do not exist");
+    } finally {
+      rmSync(broken, { recursive: true, force: true });
+    }
+  });
+});

package/tests/integration/vuepress-containers.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from "bun:test";
+import MarkdownRenderer from "@/components/MarkdownRenderer";
+import { renderAsync } from "@/test-utils/render";
+
+describe("Integration: VuePress :::container alerts", () => {
+  test(":::note renders as a note GitHub Alert", async () => {
+    const html = await renderAsync(
+      MarkdownRenderer({ content: "::: note\n\nBody text\n:::" }),
+    );
+    expect(html).toContain('class="alert alert-note"');
+    expect(html).toContain("Body text");
+  });
+
+  test(":::tip preserves a custom title", async () => {
+    const html = await renderAsync(
+      MarkdownRenderer({ content: "::: tip 智慧的疆界\n\nBody\n:::" }),
+    );
+    expect(html).toContain('class="alert alert-tip"');
+    expect(html).toContain("智慧的疆界");
+    // The hardcoded default label should not appear when a custom title is given.
+    expect(html).not.toMatch(/<span>Tip<\/span>/);
+  });
+
+  test(":::warning renders as a warning alert", async () => {
+    const html = await renderAsync(
+      MarkdownRenderer({ content: "::: warning\n\nWatch out\n:::" }),
+    );
+    expect(html).toContain('class="alert alert-warning"');
+  });
+
+  test(":::danger maps to caution (GitHub Alert vocabulary)", async () => {
+    const html = await renderAsync(
+      MarkdownRenderer({ content: "::: danger\n\nUnsafe\n:::" }),
+    );
+    expect(html).toContain('class="alert alert-caution"');
+  });
+
+  test(":::info maps to note", async () => {
+    const html = await renderAsync(
+      MarkdownRenderer({ content: "::: info\n\nFYI\n:::" }),
+    );
+    expect(html).toContain('class="alert alert-note"');
+  });
+
+  test("unknown container names pass through without becoming alerts", async () => {
+    const html = await renderAsync(
+      MarkdownRenderer({ content: "::: random\n\nSomething\n:::" }),
+    );
+    expect(html).not.toContain('class="alert');
+  });
+
+  test("plain content is not rewritten", async () => {
+    const html = await renderAsync(
+      MarkdownRenderer({ content: "Plain paragraph." }),
+    );
+    expect(html).not.toContain('class="alert');
+  });
+
+  test("VuePress syntax inside a fenced code block is NOT rewritten", async () => {
+    // A documentation example showing VuePress syntax verbatim. The normalizer
+    // must skip fenced regions; otherwise the code sample silently becomes the
+    // syntax itself and the doc example breaks.
+    const html = await renderAsync(
+      MarkdownRenderer({
+        content: [
+          "Here is how to write a tip:",
+          "",
+          "```markdown",
+          "::: tip 智慧的疆界",
+          "Body of the tip.",
+          ":::",
+          "```",
+          "",
+          "And here is a real one:",
+          "",
+          "::: tip 真实的提示",
+          "Hello",
+          ":::",
+        ].join("\n"),
+      }),
+    );
+    // The code block keeps the relaxed `::: tip ...` form verbatim — no
+    // `:::tip[...]` rewrite leaks through.
+    expect(html).toContain("::: tip 智慧的疆界");
+    expect(html).not.toContain(":::tip[智慧的疆界]");
+    // The real container outside the code block still renders as an alert.
+    expect(html).toContain('class="alert alert-tip"');
+    expect(html).toContain("真实的提示");
+  });
+
+  test("fence character type matters (~~~ vs ```)", async () => {
+    // A `~~~` fence isn't closed by a ``` line, so the container after the
+    // ``` is still inside the open `~~~` fence and must NOT be rewritten.
+    const html = await renderAsync(
+      MarkdownRenderer({
+        content: [
+          "~~~",
+          "::: tip Inside tilde fence",
+          "```",
+          "::: tip Still inside",
+          "~~~",
+        ].join("\n"),
+      }),
+    );
+    expect(html).not.toContain('class="alert');
+  });
+});

package/tests/tooling/new-post.test.ts

@@ -16,7 +16,7 @@ describe("Tooling: New Post Script", () => {
       if (fs.existsSync(file)) fs.unlinkSync(file);
     });
     createdDirs.forEach(dir => {
-      if (fs.existsSync(dir)) fs.rmdirSync(dir, { recursive: true });
+      if (fs.existsSync(dir)) fs.rmSync(dir, { recursive: true, force: true });
     });
   });
 

package/tests/unit/static-params.test.ts

@@ -21,6 +21,7 @@
  *   • afterAll restores the real module so any subsequent tests see real data.
  */
 import { describe, test, expect, mock, beforeAll, beforeEach, afterAll, afterEach } from 'bun:test';
+import { setEnvVar, restoreEnvVar } from '../helpers/env';
 
 // ─── Capture real modules ─────────────────────────────────────────────────────
 // Static imports are hoisted and resolved before any executable code (including
@@ -36,7 +37,18 @@ import * as realUrls from '../../src/lib/urls';
 // reference, but they are never mutated during tests so this is safe.
 const snapshotUrls = { ...realUrls };
 
-let mockedPosts: Array<{ slug: string; series?: string; redirectFrom?: string[] }> = [];
+// Mock-post shape: only `slug` is required; the named fields are the ones
+// production code paths read. Extra fields (full Post shape) are allowed via
+// the index signature so individual tests can pass realistic fixtures without
+// every property having to be enumerated here.
+let mockedPosts: Array<{
+  slug: string;
+  series?: string;
+  redirectFrom?: string[];
+  draft?: boolean;
+  title?: string;
+  [key: string]: unknown;
+}> = [];
 let mockedNotes: Array<{ slug: string }> = [];
 let mockedSeries: Record<string, Array<{ slug: string }>> = {};
 let mockedSeriesData: Record<string, { redirectFrom?: string[]; title?: string }> = {};
@@ -148,7 +160,7 @@ beforeEach(() => {
   mockedNotes = [];
   mockedSeries = {};
   mockedSeriesData = {};
-  process.env.NODE_ENV = originalNodeEnv;
+  restoreEnvVar('NODE_ENV', originalNodeEnv);
 });
 
 afterEach(() => {
@@ -156,7 +168,7 @@ afterEach(() => {
   mockedNotes = [];
   mockedSeries = {};
   mockedSeriesData = {};
-  process.env.NODE_ENV = originalNodeEnv;
+  restoreEnvVar('NODE_ENV', originalNodeEnv);
 });
 
 // ─── Restore real modules ─────────────────────────────────────────────────────
@@ -201,7 +213,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('notes/[slug] includes raw and encoded Unicode slug in non-production', async () => {
       mockedNotes = [{ slug: '推理模型' }];
-      process.env.NODE_ENV = 'development';
+      setEnvVar('NODE_ENV', 'development');
       const { generateStaticParams } = await import('../../src/app/notes/[slug]/page');
       const params = generateStaticParams();
       expect(params).toContainEqual({ slug: '推理模型' });
@@ -210,7 +222,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('notes/[slug] includes only raw Unicode slug in production', async () => {
       mockedNotes = [{ slug: '推理模型' }];
-      process.env.NODE_ENV = 'production';
+      setEnvVar('NODE_ENV', 'production');
       const { generateStaticParams } = await import('../../src/app/notes/[slug]/page');
       const params = generateStaticParams();
       expect(params).toContainEqual({ slug: '推理模型' });
@@ -232,10 +244,10 @@ describe('generateStaticParams — placeholder when content is empty', () => {
       expect(params).toEqual([{ slug: '_' }]);
     });
 
-    test('books/[slug]/[chapter] returns [{ slug: "_", chapter: "_" }]', async () => {
-      const { generateStaticParams } = await import('../../src/app/books/[slug]/[chapter]/page');
+    test('books/[slug]/[...chapter] returns [{ slug: "_", chapter: ["_"] }]', async () => {
+      const { generateStaticParams } = await import('../../src/app/books/[slug]/[...chapter]/page');
       const params = await generateStaticParams();
-      expect(params).toEqual([{ slug: '_', chapter: '_' }]);
+      expect(params).toEqual([{ slug: '_', chapter: ['_'] }]);
     });
   });
 
@@ -257,7 +269,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('series/[slug] includes raw and encoded Unicode slug in non-production', async () => {
       mockedSeries = { '软件构架设计': [] };
-      process.env.NODE_ENV = 'development';
+      setEnvVar('NODE_ENV', 'development');
       const { generateStaticParams } = await import('../../src/app/series/[slug]/page');
       const params = await generateStaticParams();
       expect(params).toContainEqual({ slug: '软件构架设计' });
@@ -266,7 +278,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('series/[slug] includes only raw Unicode slug in production', async () => {
       mockedSeries = { '软件构架设计': [] };
-      process.env.NODE_ENV = 'production';
+      setEnvVar('NODE_ENV', 'production');
       const { generateStaticParams } = await import('../../src/app/series/[slug]/page');
       const params = await generateStaticParams();
       expect(params).toContainEqual({ slug: '软件构架设计' });
@@ -281,7 +293,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('series/[slug]/page/[page] includes encoded Unicode slug in non-production', async () => {
       mockedSeries = { '软件构架设计': Array.from({ length: 6 }, (_, i) => ({ slug: `p${i + 1}` })) };
-      process.env.NODE_ENV = 'development';
+      setEnvVar('NODE_ENV', 'development');
       const { generateStaticParams } = await import('../../src/app/series/[slug]/page/[page]/page');
       const params = await generateStaticParams();
       expect(params).toContainEqual({ slug: '软件构架设计', page: '2' });
@@ -361,7 +373,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('posts/[slug] includes raw and encoded Unicode slug in non-production', async () => {
       mockedPosts = [{ slug: '中文测试文章' }];
-      process.env.NODE_ENV = 'development';
+      setEnvVar('NODE_ENV', 'development');
       const { generateStaticParams } = await import('../../src/app/posts/[slug]/page');
       const params = await generateStaticParams();
 
@@ -371,7 +383,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('posts/[slug] includes only raw Unicode slug in production', async () => {
       mockedPosts = [{ slug: '中文测试文章' }];
-      process.env.NODE_ENV = 'production';
+      setEnvVar('NODE_ENV', 'production');
       const { generateStaticParams } = await import('../../src/app/posts/[slug]/page');
       const params = await generateStaticParams();
 
@@ -485,7 +497,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('[slug]/page does not include single-segment redirectFrom for draft posts in production', async () => {
       mockedPosts = [{ slug: 'my-post', draft: true, redirectFrom: ['/old-slug'] }];
-      process.env.NODE_ENV = 'production';
+      setEnvVar('NODE_ENV', 'production');
       const { generateStaticParams } = await import('../../src/app/[slug]/page');
       const params = await generateStaticParams();
       expect(params).not.toContainEqual({ slug: 'old-slug' });
@@ -588,7 +600,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
     test('[slug]/[postSlug] includes encoded Unicode postSlug variants in non-production', async () => {
       // Use redirectFrom to place a Unicode postSlug at a 2-segment path — no url mock needed.
       mockedPosts = [{ slug: 'my-post', redirectFrom: ['/old-prefix/中文文章'] }];
-      process.env.NODE_ENV = 'development';
+      setEnvVar('NODE_ENV', 'development');
       const { generateStaticParams } = await import('../../src/app/[slug]/[postSlug]/page');
       const params = await generateStaticParams();
       expect(params).toContainEqual({ slug: 'old-prefix', postSlug: '中文文章' });
@@ -597,7 +609,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('[slug]/[postSlug] includes encoded Unicode prefix variants in non-production', async () => {
       mockedSeries = { '软件构架设计': [{ slug: 'architecture-post' }] };
-      process.env.NODE_ENV = 'development';
+      setEnvVar('NODE_ENV', 'development');
       const { generateStaticParams } = await import('../../src/app/[slug]/[postSlug]/page');
       const params = await generateStaticParams();
       expect(params).toContainEqual({ slug: '软件构架设计', postSlug: 'architecture-post' });
@@ -606,7 +618,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('[slug]/[postSlug] includes encoded Unicode prefix and postSlug variants together in non-production', async () => {
       mockedSeries = { '软件构架设计': [{ slug: '中文文章' }] };
-      process.env.NODE_ENV = 'development';
+      setEnvVar('NODE_ENV', 'development');
       const { generateStaticParams } = await import('../../src/app/[slug]/[postSlug]/page');
       const params = await generateStaticParams();
       expect(params).toContainEqual({ slug: '软件构架设计', postSlug: '中文文章' });
@@ -617,7 +629,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('[slug]/[postSlug] does not include encoded Unicode postSlug variants in production', async () => {
       mockedPosts = [{ slug: 'my-post', redirectFrom: ['/old-prefix/中文文章'] }];
-      process.env.NODE_ENV = 'production';
+      setEnvVar('NODE_ENV', 'production');
       const { generateStaticParams } = await import('../../src/app/[slug]/[postSlug]/page');
       const params = await generateStaticParams();
       expect(params).toContainEqual({ slug: 'old-prefix', postSlug: '中文文章' });
@@ -641,7 +653,8 @@ describe('generateStaticParams — placeholder when content is empty', () => {
         imageBaseSlug: 'posts',
         category: 'Test',
         tags: [],
-        readingTime: '1 min read',
+        readingMinutes: 1,
+        wordCount: 0,
       }];
 
       const page = await import('../../src/app/[slug]/[postSlug]/page');