@hutusi/amytis 1.12.0 → 1.14.0

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

@@ -22,14 +22,24 @@
  */
 import { describe, test, expect, mock, beforeAll, beforeEach, afterAll, afterEach } from 'bun:test';
 
-// ─── Capture real markdown module ────────────────────────────────────────────
+// ─── Capture real modules ─────────────────────────────────────────────────────
 // Static imports are hoisted and resolved before any executable code (including
 // beforeAll / mock.module calls), so this always captures the real module.
 import * as realMarkdown from '../../src/lib/markdown';
+import * as realUrls from '../../src/lib/urls';
+
+// `import * as ns` creates a live namespace — its properties update when
+// mock.module() patches the registry.  Spread into a plain object here
+// (before any mocking) to get a shallow snapshot of the real exports so
+// restore calls always put back the originals, not the current mock state.
+// Note: nested objects (e.g. RESERVED_ROUTE_SEGMENTS Set) share the same
+// reference, but they are never mutated during tests so this is safe.
+const snapshotUrls = { ...realUrls };
 
 let mockedPosts: Array<{ slug: string; series?: string; redirectFrom?: string[] }> = [];
 let mockedNotes: Array<{ slug: string }> = [];
 let mockedSeries: Record<string, Array<{ slug: string }>> = {};
+let mockedSeriesData: Record<string, { redirectFrom?: string[]; title?: string }> = {};
 const originalNodeEnv = process.env.NODE_ENV;
 
 // ─── Next.js runtime stubs (module-level — safe) ─────────────────────────────
@@ -118,7 +128,7 @@ beforeAll(() => {
     getBookChapter: () => null,
     getBooksByAuthor: () => [],
 
-    getSeriesData: () => null,
+    getSeriesData: (slug: string) => mockedSeriesData[slug] ?? null,
     getSeriesPosts: () => [],
     getSeriesAuthors: () => [],
 
@@ -136,6 +146,7 @@ beforeEach(() => {
   mockedPosts = [];
   mockedNotes = [];
   mockedSeries = {};
+  mockedSeriesData = {};
   process.env.NODE_ENV = originalNodeEnv;
 });
 
@@ -143,12 +154,14 @@ afterEach(() => {
   mockedPosts = [];
   mockedNotes = [];
   mockedSeries = {};
+  mockedSeriesData = {};
   process.env.NODE_ENV = originalNodeEnv;
 });
 
-// ─── Restore real markdown module ─────────────────────────────────────────────
+// ─── Restore real modules ─────────────────────────────────────────────────────
 afterAll(() => {
   mock.module('@/lib/markdown', () => realMarkdown);
+  mock.module('@/lib/urls', () => snapshotUrls);
 });
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -232,6 +245,15 @@ describe('generateStaticParams — placeholder when content is empty', () => {
       expect(params).toEqual([{ slug: '_' }]);
     });
 
+    test('series/[slug] includes redirectFrom slug when series is renamed', async () => {
+      mockedSeries = { 'new-name': [] };
+      mockedSeriesData = { 'new-name': { redirectFrom: ['/series/old-name'], title: 'New Series' } };
+      const { generateStaticParams } = await import('../../src/app/series/[slug]/page');
+      const params = await generateStaticParams();
+      expect(params).toContainEqual({ slug: 'new-name' });
+      expect(params).toContainEqual({ slug: 'old-name' });
+    });
+
     test('series/[slug]/page/[page] returns [{ slug: "_", page: "2" }]', async () => {
       const { generateStaticParams } = await import('../../src/app/series/[slug]/page/[page]/page');
       const params = await generateStaticParams();
@@ -296,35 +318,64 @@ describe('generateStaticParams — placeholder when content is empty', () => {
   });
 
   describe('autoPaths series routing', () => {
-    // autoPaths defaults to false — series posts are served at /posts/[slug] unless explicitly enabled
-
-    test('posts/[slug] includes series posts when autoPaths is disabled (default)', async () => {
-      mockedPosts = [{ slug: 'series-post', series: 'my-series' }];
-      const { generateStaticParams } = await import('../../src/app/posts/[slug]/page');
-      const params = await generateStaticParams();
-      expect(params).toContainEqual({ slug: 'series-post' });
+    // autoPaths defaults to true — series posts are served at /[series-slug]/[post-slug]
+
+    describe('autoPaths disabled', () => {
+      // Override getSeriesAutoPaths to false and use /posts/[slug] as canonical URL.
+      beforeEach(() => {
+        mock.module('@/lib/urls', () => ({
+          ...snapshotUrls,
+          getSeriesAutoPaths: () => false,
+          getPostUrl: (post: { slug: string; series?: string }) => `/posts/${post.slug}`,
+        }));
+      });
+
+      afterEach(() => {
+        mock.module('@/lib/urls', () => snapshotUrls);
+      });
+
+      test('posts/[slug] includes series posts when autoPaths is disabled', async () => {
+        mockedPosts = [{ slug: 'series-post', series: 'my-series' }];
+        const { generateStaticParams } = await import('../../src/app/posts/[slug]/page');
+        const params = await generateStaticParams();
+        expect(params).toContainEqual({ slug: 'series-post' });
+      });
+
+      test('[slug]/[postSlug] does not include series auto-path params when autoPaths is disabled', async () => {
+        mockedSeries = { 'my-series': [{ slug: 'my-post' }] };
+        const { generateStaticParams } = await import('../../src/app/[slug]/[postSlug]/page');
+        const params = await generateStaticParams();
+        expect(params).not.toContainEqual({ slug: 'my-series', postSlug: 'my-post' });
+      });
+
+      test('posts/[slug] includes series post when canonical matches /posts/[slug]', async () => {
+        mockedPosts = [{ slug: 'my-post', series: 'my-series' }];
+        const { generateStaticParams } = await import('../../src/app/posts/[slug]/page');
+        const params = await generateStaticParams();
+        expect(params).toContainEqual({ slug: 'my-post' });
+      });
     });
 
-    test('[slug]/[postSlug] does not include series auto-path params when autoPaths is disabled', async () => {
-      mockedSeries = { 'my-series': [{ slug: 'my-post' }] };
+    test('[slug]/[postSlug] includes redirectFrom paths as additional params', async () => {
+      mockedPosts = [{ slug: 'my-post', series: 'my-series', redirectFrom: ['/old-prefix/my-post'] }];
       const { generateStaticParams } = await import('../../src/app/[slug]/[postSlug]/page');
       const params = await generateStaticParams();
-      expect(params).not.toContainEqual({ slug: 'my-series', postSlug: 'my-post' });
+      expect(params).toContainEqual({ slug: 'old-prefix', postSlug: 'my-post' });
     });
 
-    test('posts/[slug] includes series post when canonical matches /posts/[slug]', async () => {
-      // With autoPaths: false, getPostUrl returns /posts/[slug] for series posts
-      mockedPosts = [{ slug: 'my-post', series: 'my-series' }];
-      const { generateStaticParams } = await import('../../src/app/posts/[slug]/page');
+    test('[slug]/[postSlug] does not include /posts/* redirectFrom when basePath is "posts"', async () => {
+      mockedPosts = [{ slug: 'new-name', redirectFrom: ['/posts/old-name'] }];
+      const { generateStaticParams } = await import('../../src/app/[slug]/[postSlug]/page');
       const params = await generateStaticParams();
-      expect(params).toContainEqual({ slug: 'my-post' });
+      expect(params).not.toContainEqual({ slug: 'posts', postSlug: 'old-name' });
     });
 
-    test('[slug]/[postSlug] includes redirectFrom paths as additional params', async () => {
-      mockedPosts = [{ slug: 'my-post', series: 'my-series', redirectFrom: ['/old-prefix/my-post'] }];
-      const { generateStaticParams } = await import('../../src/app/[slug]/[postSlug]/page');
+    test('posts/[slug] includes redirectFrom slug when post is renamed within /posts/', async () => {
+      mockedPosts = [{ slug: 'new-name', redirectFrom: ['/posts/old-name'] }];
+      const { generateStaticParams } = await import('../../src/app/posts/[slug]/page');
       const params = await generateStaticParams();
-      expect(params).toContainEqual({ slug: 'old-prefix', postSlug: 'my-post' });
+      expect(params).toContainEqual({ slug: 'new-name' });
+      expect(params).toContainEqual({ slug: 'old-name' });
     });
 
     test('[slug]/page includes single-segment redirectFrom paths as additional params', async () => {
@@ -363,6 +414,69 @@ describe('generateStaticParams — placeholder when content is empty', () => {
       const { generateStaticParams } = await import('../../src/app/[slug]/page');
       expect(() => generateStaticParams()).toThrow('[amytis] redirectFrom "/old-slug"');
     });
+
+    test('[slug]/page throws when redirectFrom alias conflicts with "posts" (RESERVED_ROUTE_SEGMENTS)', async () => {
+      mockedPosts = [{ slug: 'my-post', redirectFrom: ['/posts'] }];
+      const { generateStaticParams } = await import('../../src/app/[slug]/page');
+      expect(() => generateStaticParams()).toThrow('[amytis] redirectFrom "/posts"');
+    });
+
+    test('[slug]/page includes Unicode single-segment redirectFrom slug as param', async () => {
+      mockedPosts = [{ slug: 'my-post', redirectFrom: ['/中文路由'] }];
+      const { generateStaticParams } = await import('../../src/app/[slug]/page');
+      const params = await generateStaticParams();
+      expect(params).toContainEqual({ slug: '中文路由' });
+    });
+
+    describe('autoPaths enabled', () => {
+      // Use beforeEach (not beforeAll) so each test starts with a clean base mock,
+      // preventing stale state from tests that inline-override the mock.
+      beforeEach(() => {
+        mock.module('@/lib/urls', () => ({
+          ...snapshotUrls,
+          getSeriesAutoPaths: () => true,
+          getSeriesCustomPaths: () => ({}),
+          getPostUrl: (post: { slug: string; series?: string }) =>
+            post.series ? `/${post.series}/${post.slug}` : `/posts/${post.slug}`,
+          validateSeriesAutoPaths: () => {},
+        }));
+      });
+
+      afterEach(() => {
+        mock.module('@/lib/urls', () => snapshotUrls);
+      });
+
+      test('[slug]/page includes auto-path series slug when autoPaths enabled', async () => {
+        mockedSeries = { 'my-series': [{ slug: 'my-post' }] };
+        const { generateStaticParams } = await import('../../src/app/[slug]/page');
+        const params = await generateStaticParams();
+        expect(params).toContainEqual({ slug: 'my-series' });
+      });
+
+      test('[slug]/page includes Unicode auto-path series slug when autoPaths enabled', async () => {
+        mockedSeries = { '中文系列': [{ slug: 'post-one' }] };
+        const { generateStaticParams } = await import('../../src/app/[slug]/page');
+        const params = await generateStaticParams();
+        expect(params).toContainEqual({ slug: '中文系列' });
+      });
+
+      test('[slug]/page uses customPaths prefix for series with override, not the series slug', async () => {
+        // Override the base mock to add a customPaths entry for this test.
+        mock.module('@/lib/urls', () => ({
+          ...snapshotUrls,
+          getSeriesAutoPaths: () => true,
+          getSeriesCustomPaths: () => ({ 'my-series': 'articles' }),
+          getPostUrl: (post: { slug: string; series?: string }) =>
+            post.series === 'my-series' ? `/articles/${post.slug}` : `/posts/${post.slug}`,
+          validateSeriesAutoPaths: () => {},
+        }));
+        mockedSeries = { 'my-series': [{ slug: 'my-post' }] };
+        const { generateStaticParams } = await import('../../src/app/[slug]/page');
+        const params = await generateStaticParams();
+        expect(params).toContainEqual({ slug: 'articles' });
+        expect(params).not.toContainEqual({ slug: 'my-series' });
+      });
+    });
   });
 
   describe('custom path routes', () => {
@@ -380,6 +494,25 @@ describe('generateStaticParams — placeholder when content is empty', () => {
       expect(params).toEqual([{ slug: '_', postSlug: '_' }]);
     });
 
+    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';
+      const { generateStaticParams } = await import('../../src/app/[slug]/[postSlug]/page');
+      const params = await generateStaticParams();
+      expect(params).toContainEqual({ slug: 'old-prefix', postSlug: '中文文章' });
+      expect(params).toContainEqual({ slug: 'old-prefix', postSlug: encodeURIComponent('中文文章') });
+    });
+
+    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';
+      const { generateStaticParams } = await import('../../src/app/[slug]/[postSlug]/page');
+      const params = await generateStaticParams();
+      expect(params).toContainEqual({ slug: 'old-prefix', postSlug: '中文文章' });
+      expect(params).not.toContainEqual({ slug: 'old-prefix', postSlug: encodeURIComponent('中文文章') });
+    });
+
     test('[slug]/page/[page]/page returns placeholder when no custom paths', async () => {
       const { generateStaticParams } = await import('../../src/app/[slug]/page/[page]/page');
       const params = await generateStaticParams();

package/tests/unit/urls.test.ts

@@ -2,29 +2,27 @@ import { describe, test, expect } from 'bun:test';
 import { getPostUrl, getSeriesAutoPaths, validateSeriesAutoPaths } from '../../src/lib/urls';
 
 describe('getSeriesAutoPaths', () => {
-  test('returns false by default', () => {
-    expect(getSeriesAutoPaths()).toBe(false);
+  test('returns true by default', () => {
+    expect(getSeriesAutoPaths()).toBe(true);
   });
 });
 
-describe('getPostUrl — autoPaths disabled (default)', () => {
+describe('getPostUrl — autoPaths enabled (default)', () => {
   test('post with no series uses basePath', () => {
     expect(getPostUrl({ slug: 'hello' })).toBe('/posts/hello');
   });
 
-  test('post with series falls back to basePath when autoPaths is disabled', () => {
-    expect(getPostUrl({ slug: 'hello', series: 'my-series' })).toBe('/posts/hello');
+  test('post with series uses series slug as prefix when autoPaths is enabled', () => {
+    expect(getPostUrl({ slug: 'hello', series: 'my-series' })).toBe('/my-series/hello');
   });
 });
 
-describe('validateSeriesAutoPaths — autoPaths disabled (default)', () => {
-  test('does not throw for any slug when autoPaths is false', () => {
-    // validateSeriesAutoPaths is a no-op when autoPaths is disabled
-    const reserved = ['tags', 'series', 'books', 'flows', 'archive', 'posts'];
-    expect(() => validateSeriesAutoPaths(reserved)).not.toThrow();
+describe('validateSeriesAutoPaths — autoPaths enabled (default)', () => {
+  test('throws for a reserved route slug', () => {
+    expect(() => validateSeriesAutoPaths(['tags'])).toThrow('[amytis]');
   });
 
-  test('does not throw even with extraReserved slugs when autoPaths is false', () => {
-    expect(() => validateSeriesAutoPaths(['about'], ['about'])).not.toThrow();
+  test('throws for an extra reserved slug', () => {
+    expect(() => validateSeriesAutoPaths(['about'], ['about'])).toThrow('[amytis]');
   });
 });