create-ailk 0.1.0

package/templates/apps/web/__tests__/sitemap-locales.test.ts

@@ -0,0 +1,415 @@
+/**
+ * @jest-environment node
+ */
+
+/**
+ * i18n S3 — sitemap locale alternates (#974)
+ *
+ * Validates:
+ * - xmlns:xhtml namespace in <urlset>
+ * - Per-locale <xhtml:link rel="alternate"> children per <url>
+ * - x-default alternate present and pointing at default-locale URL
+ * - URL composition: default-locale bare path; non-default with /<locale>/ prefix
+ * - lastmod, cache-control, content-type preserved (regression)
+ * - Response XML is structurally well-formed
+ *
+ * Adapter is injected via createSitemapHandler({ getContentAdapter }) instead of
+ * jest.mock("../src/lib/content") — no internal-module mocking.
+ */
+
+import { createSitemapHandler } from "../app/sitemap.xml/route";
+import type { ContentAdapter } from "@working-theory/content-adapters";
+
+/** Mock page with publishedAt. */
+const MOCK_PAGE_WITH_DATE = {
+  type: "BlogPosting",
+  slug: "hello-world",
+  title: "Hello World",
+  description: "A test post.",
+  publishedAt: "2026-01-15",
+};
+
+/** Mock page without publishedAt. */
+const MOCK_PAGE_NO_DATE: {
+  type: string;
+  slug: string;
+  title: string;
+  description: string;
+  publishedAt?: string;
+} = {
+  type: "BlogPosting",
+  slug: "no-date-post",
+  title: "No Date",
+  description: "No publishedAt.",
+};
+
+type MockPage = {
+  type: string;
+  slug: string;
+  title: string;
+  description: string;
+  publishedAt?: string;
+};
+
+/**
+ * Adapter stub that returns the provided pages for the first type call in
+ * EACH locale, and empty arrays for every other type call. Phase 3 S3:
+ * `listPages` is now called as `listPages(type, locale)` per (locale, type)
+ * tuple. Returning pages for the first type per locale gives a predictable
+ * `<page>×<locale>` count for sitemap assertions.
+ *
+ * The implementation tracks the first call per distinct locale arg. When the
+ * caller passes no locale at all (default-locale code path), `locale=undefined`
+ * is treated as its own bucket — preserves single-call-returns-pages behavior
+ * for legacy callers that omit locale.
+ */
+function makeAdapter(pages: MockPage[] = [MOCK_PAGE_WITH_DATE]): ContentAdapter {
+  const firstCallSeenForLocale = new Set<string | undefined>();
+  // eslint-disable-next-line no-restricted-syntax -- jest.fn() stubs are not assignable to ContentAdapter's generic return types; partial stub is intentional, tracked in #1073
+  return {
+    listPages: jest.fn().mockImplementation((_type: string, locale?: string) => {
+      const key = locale;
+      if (!firstCallSeenForLocale.has(key)) {
+        firstCallSeenForLocale.add(key);
+        return Promise.resolve(pages);
+      }
+      return Promise.resolve([]);
+    }),
+    listDetail: jest.fn().mockResolvedValue([]),
+    getPageBySlug: jest.fn().mockResolvedValue(null),
+    getDetailBySlug: jest.fn().mockResolvedValue(null),
+    searchPages: jest.fn().mockResolvedValue([]),
+    extractStructuredData: jest.fn().mockResolvedValue(null),
+    createPage: jest.fn(),
+    updatePage: jest.fn(),
+    deletePage: jest.fn(),
+    getPageVersion: jest.fn(),
+  } as unknown as ContentAdapter;
+}
+
+/** Extract all <xhtml:link .../> elements from an XML string. */
+function extractXhtmlLinks(xml: string): string[] {
+  const re = /<xhtml:link[^>]*\/>/g;
+  return xml.match(re) ?? [];
+}
+
+/** Extract hreflang attribute value from an xhtml:link element string. */
+function getHreflang(linkEl: string): string | null {
+  const m = linkEl.match(/hreflang="([^"]+)"/);
+  return m ? (m[1] ?? null) : null;
+}
+
+/** Extract href attribute value from an xhtml:link element string. */
+function getHref(linkEl: string): string | null {
+  const m = linkEl.match(/href="([^"]+)"/);
+  return m ? (m[1] ?? null) : null;
+}
+
+/** Split an XML sitemap body into individual <url>…</url> blocks. */
+function splitUrlBlocks(xml: string): string[] {
+  const re = /<url>[\s\S]*?<\/url>/g;
+  return xml.match(re) ?? [];
+}
+
+/** Read <loc> value from a <url> block. */
+function getLoc(urlBlock: string): string | null {
+  const m = urlBlock.match(/<loc>([^<]+)<\/loc>/);
+  return m ? (m[1] ?? null) : null;
+}
+
+/** Read <lastmod> value from a <url> block. */
+function getLastmod(urlBlock: string): string | null {
+  const m = urlBlock.match(/<lastmod>([^<]+)<\/lastmod>/);
+  return m ? (m[1] ?? null) : null;
+}
+
+// ─── Single-locale: locales: [en] ───────────────────────────────────────────
+
+describe("GET /sitemap.xml — single locale (en)", () => {
+  let GET: () => Promise<Response>;
+
+  beforeEach(() => {
+    process.env.NEXT_PUBLIC_ENABLED_LOCALES = "en";
+    process.env.NEXT_PUBLIC_DEFAULT_LOCALE = "en";
+    const stubAdapter = makeAdapter();
+    GET = createSitemapHandler({ getContentAdapter: () => stubAdapter });
+  });
+
+  afterEach(() => {
+    delete process.env.NEXT_PUBLIC_ENABLED_LOCALES;
+    delete process.env.NEXT_PUBLIC_DEFAULT_LOCALE;
+    jest.resetAllMocks();
+  });
+
+  it("includes xmlns:xhtml namespace on <urlset>", async () => {
+    const response = await GET();
+    const text = await response.text();
+    expect(text).toContain('xmlns:xhtml="http://www.w3.org/1999/xhtml"');
+  });
+
+  it("each <url> has exactly one xhtml:link for en plus x-default (2 total)", async () => {
+    const response = await GET();
+    const text = await response.text();
+    const blocks = splitUrlBlocks(text);
+    expect(blocks.length).toBeGreaterThan(0);
+
+    for (const block of blocks) {
+      const links = extractXhtmlLinks(block);
+      const hreflangs = links.map(getHreflang);
+      expect(hreflangs).toContain("en");
+      expect(hreflangs).toContain("x-default");
+      expect(hreflangs).toHaveLength(2);
+    }
+  });
+
+  it("x-default href equals the en (bare-path) URL", async () => {
+    const response = await GET();
+    const text = await response.text();
+    const blocks = splitUrlBlocks(text);
+
+    for (const block of blocks) {
+      const links = extractXhtmlLinks(block);
+      const enLink = links.find((l) => getHreflang(l) === "en");
+      const xdefLink = links.find((l) => getHreflang(l) === "x-default");
+      expect(enLink).toBeTruthy();
+      expect(xdefLink).toBeTruthy();
+      expect(getHref(enLink!)).toEqual(getHref(xdefLink!));
+    }
+  });
+
+  it("default-locale URLs use bare path (no /en/ prefix)", async () => {
+    const response = await GET();
+    const text = await response.text();
+    const blocks = splitUrlBlocks(text);
+
+    for (const block of blocks) {
+      const loc = getLoc(block);
+      expect(loc).not.toBeNull();
+      expect(loc).not.toContain("/en/");
+    }
+  });
+
+  it("lastmod is preserved from page.publishedAt", async () => {
+    const response = await GET();
+    const text = await response.text();
+    const blocks = splitUrlBlocks(text);
+
+    for (const block of blocks) {
+      const lastmod = getLastmod(block);
+      expect(lastmod).toEqual("2026-01-15");
+    }
+  });
+
+  it("returns status 200", async () => {
+    const response = await GET();
+    expect(response.status).toBe(200);
+  });
+
+  it("returns application/xml content-type (regression)", async () => {
+    const response = await GET();
+    expect(response.headers.get("content-type")).toMatch(/application\/xml/);
+  });
+
+  it("returns cache-control: public, max-age=3600 (regression)", async () => {
+    const response = await GET();
+    expect(response.headers.get("cache-control")).toContain("public");
+    expect(response.headers.get("cache-control")).toContain("max-age=3600");
+  });
+
+  it("XML is structurally well-formed — has opening and closing urlset", async () => {
+    const response = await GET();
+    const text = await response.text();
+    expect(text).toContain("<urlset");
+    expect(text).toContain("</urlset>");
+    expect(text.indexOf("<urlset")).toBeLessThan(text.indexOf("</urlset>"));
+  });
+});
+
+// ─── Multi-locale: locales: [en, es] ────────────────────────────────────────
+
+describe("GET /sitemap.xml — multi locale (en, es)", () => {
+  let GET: () => Promise<Response>;
+
+  beforeEach(() => {
+    process.env.NEXT_PUBLIC_ENABLED_LOCALES = "en,es";
+    process.env.NEXT_PUBLIC_DEFAULT_LOCALE = "en";
+    const stubAdapter = makeAdapter();
+    GET = createSitemapHandler({ getContentAdapter: () => stubAdapter });
+  });
+
+  afterEach(() => {
+    delete process.env.NEXT_PUBLIC_ENABLED_LOCALES;
+    delete process.env.NEXT_PUBLIC_DEFAULT_LOCALE;
+    jest.resetAllMocks();
+  });
+
+  it("emits one <url> per locale (2 entries for 1 content page × 2 locales)", async () => {
+    const response = await GET();
+    const text = await response.text();
+    const blocks = splitUrlBlocks(text);
+    // 1 content page × 2 locales = 2 <url> entries
+    expect(blocks).toHaveLength(2);
+  });
+
+  it("each <url> has xhtml:link for en, es, and x-default (3 total)", async () => {
+    const response = await GET();
+    const text = await response.text();
+    const blocks = splitUrlBlocks(text);
+
+    for (const block of blocks) {
+      const links = extractXhtmlLinks(block);
+      const hreflangs = links.map(getHreflang);
+      expect(hreflangs).toContain("en");
+      expect(hreflangs).toContain("es");
+      expect(hreflangs).toContain("x-default");
+      expect(hreflangs).toHaveLength(3);
+    }
+  });
+
+  it("en <url> loc uses bare path; es <url> loc uses /es/ prefix", async () => {
+    const response = await GET();
+    const text = await response.text();
+    const blocks = splitUrlBlocks(text);
+
+    const locs = blocks.map((b) => getLoc(b)).filter(Boolean) as string[];
+    const enLoc = locs.find((l) => !l.includes("/es/"));
+    const esLoc = locs.find((l) => l.includes("/es/"));
+    expect(enLoc).toBeTruthy();
+    expect(esLoc).toBeTruthy();
+    expect(enLoc).not.toContain("/en/");
+    expect(esLoc).toContain("/es/");
+  });
+
+  it("x-default href equals the en (default-locale) URL in every <url>", async () => {
+    const response = await GET();
+    const text = await response.text();
+    const blocks = splitUrlBlocks(text);
+
+    for (const block of blocks) {
+      const links = extractXhtmlLinks(block);
+      const xdefLink = links.find((l) => getHreflang(l) === "x-default");
+      const enLink = links.find((l) => getHreflang(l) === "en");
+      expect(xdefLink).toBeTruthy();
+      expect(enLink).toBeTruthy();
+      // x-default always points at the en (bare-path) URL
+      expect(getHref(xdefLink!)).toEqual(getHref(enLink!));
+    }
+  });
+
+  it("all xhtml:link alternates reference the same slug with locale-appropriate prefix", async () => {
+    const response = await GET();
+    const text = await response.text();
+    const blocks = splitUrlBlocks(text);
+
+    for (const block of blocks) {
+      const links = extractXhtmlLinks(block);
+      const enLink = links.find((l) => getHreflang(l) === "en");
+      const esLink = links.find((l) => getHreflang(l) === "es");
+      const enHref = enLink ? getHref(enLink) : null;
+      const esHref = esLink ? getHref(esLink) : null;
+      expect(enHref).toContain("hello-world");
+      expect(esHref).toContain("hello-world");
+    }
+  });
+
+  it("returns application/xml content-type (regression)", async () => {
+    const response = await GET();
+    expect(response.headers.get("content-type")).toMatch(/application\/xml/);
+  });
+
+  it("returns cache-control: public, max-age=3600 (regression)", async () => {
+    const response = await GET();
+    expect(response.headers.get("cache-control")).toContain("max-age=3600");
+  });
+});
+
+// ─── Phase 3 S3: lists scoped per locale ──────────────────────────────────────
+//
+// AC-i18n-08: `listPages(type, 'es')` does NOT fall back to default-locale.
+// In the sitemap context this means a page that exists only in `en/` produces
+// exactly one <url> entry (for en) — not two. The previous behavior (which
+// emitted N×locales URLs unconditionally) is replaced by per-locale
+// enumeration of what actually exists in each locale directory.
+
+describe("GET /sitemap.xml — Phase 3 S3 lists scoped per locale", () => {
+  let GET: () => Promise<Response>;
+
+  beforeEach(() => {
+    process.env.NEXT_PUBLIC_ENABLED_LOCALES = "en,es";
+    process.env.NEXT_PUBLIC_DEFAULT_LOCALE = "en";
+    // Adapter that returns the page only on the FIRST en call (predictable
+    // count) and empty arrays for every other call — including all es calls.
+    // This models S3's "lists scoped" contract: only en has content for this
+    // slug, so the sitemap emits exactly one en <url>.
+    let enFirstCallDone = false;
+    // eslint-disable-next-line no-restricted-syntax -- jest.fn() stubs are not assignable to ContentAdapter's generic return types; partial stub is intentional, tracked in #1073
+    const scopedAdapter = {
+      listPages: jest.fn().mockImplementation((_type: string, locale?: string) => {
+        if (locale === "en" && !enFirstCallDone) {
+          enFirstCallDone = true;
+          return Promise.resolve([MOCK_PAGE_WITH_DATE]);
+        }
+        return Promise.resolve([]);
+      }),
+      listDetail: jest.fn().mockResolvedValue([]),
+      getPageBySlug: jest.fn().mockResolvedValue(null),
+      getDetailBySlug: jest.fn().mockResolvedValue(null),
+      searchPages: jest.fn().mockResolvedValue([]),
+      extractStructuredData: jest.fn().mockResolvedValue(null),
+      createPage: jest.fn(),
+      updatePage: jest.fn(),
+      deletePage: jest.fn(),
+      getPageVersion: jest.fn(),
+    } as unknown as ContentAdapter;
+    GET = createSitemapHandler({ getContentAdapter: () => scopedAdapter });
+  });
+
+  afterEach(() => {
+    delete process.env.NEXT_PUBLIC_ENABLED_LOCALES;
+    delete process.env.NEXT_PUBLIC_DEFAULT_LOCALE;
+    jest.resetAllMocks();
+  });
+
+  it("emits only en <url> entries when es has no content for the slug", async () => {
+    const response = await GET();
+    const text = await response.text();
+    const blocks = splitUrlBlocks(text);
+    // 13 type calls × en returns page on first call only = 1 entry total.
+    // es returns empty for every type call → contributes nothing.
+    expect(blocks).toHaveLength(1);
+    const loc = getLoc(blocks[0]!);
+    expect(loc).toBeTruthy();
+    expect(loc).not.toContain("/es/");
+  });
+});
+
+// ─── lastmod fallback ────────────────────────────────────────────────────────
+
+describe("GET /sitemap.xml — lastmod fallback", () => {
+  let GET: () => Promise<Response>;
+
+  beforeEach(() => {
+    process.env.NEXT_PUBLIC_ENABLED_LOCALES = "en";
+    process.env.NEXT_PUBLIC_DEFAULT_LOCALE = "en";
+    const stubAdapter = makeAdapter([MOCK_PAGE_NO_DATE]);
+    GET = createSitemapHandler({ getContentAdapter: () => stubAdapter });
+  });
+
+  afterEach(() => {
+    delete process.env.NEXT_PUBLIC_ENABLED_LOCALES;
+    delete process.env.NEXT_PUBLIC_DEFAULT_LOCALE;
+    jest.resetAllMocks();
+  });
+
+  it("lastmod falls back to today's date (YYYY-MM-DD) when publishedAt absent", async () => {
+    const response = await GET();
+    const text = await response.text();
+    const blocks = splitUrlBlocks(text);
+    const today = new Date().toISOString().slice(0, 10);
+
+    for (const block of blocks) {
+      const lastmod = getLastmod(block);
+      expect(lastmod).toEqual(today);
+    }
+  });
+});