create-ailk 0.1.0

package/templates/apps/web/__tests__/knowledge-events-routes.test.tsx

@@ -0,0 +1,580 @@
+/**
+ * Phase 2 Content 5.1 tests: CaseStudy + Course + Event list + detail routes.
+ * Covers MDX rendering, JSON-LD dispatch, notFound() on unknown slug,
+ * and generateStaticParams enumeration.
+ *
+ * getMdxSource is injected via optional props on each page component.
+ * getMdxSlugs is mocked (it is called by generateStaticParams, a non-component
+ * function that cannot accept DI props per Next.js conventions; this mock is
+ * the narrowest possible scope for that function).
+ */
+
+import { render, screen } from "@testing-library/react";
+
+jest.mock("next-mdx-remote/rsc", () => ({
+  __esModule: true,
+  MDXRemote: ({ source }: { source: string }): React.ReactElement => (
+    <div data-testid="mdx-rendered">{source}</div>
+  ),
+}));
+
+jest.mock("next/navigation", () => ({
+  __esModule: true,
+  notFound: jest.fn(() => {
+    throw new Error("NEXT_NOT_FOUND");
+  }),
+}));
+
+// case-studies/[slug]/page.tsx, events/[slug]/page.tsx, and courses/[slug]/page.tsx
+// all import getMdxSlugs from @working-theory/page-renderer after migration (#1271, #1272, #1273).
+// Only getMdxSlugs is overridden here to avoid breaking the actual renderPage logic.
+
+jest.mock("@working-theory/page-renderer", () => {
+  const actual = jest.requireActual(
+    "@working-theory/page-renderer",
+  ) as Record<string, unknown>;
+  return { ...actual, getMdxSlugs: jest.fn() };
+});
+
+import * as React from "react";
+
+import { getMdxSlugs as getPageRendererMdxSlugs } from "@working-theory/page-renderer";
+import { notFound } from "next/navigation";
+
+import CaseStudiesPage from "../app/[locale]/case-studies/page";
+import CaseStudySlugPage, {
+  generateStaticParams as caseStudyStaticParams,
+} from "../app/[locale]/case-studies/[slug]/page";
+import CoursesPage from "../app/[locale]/courses/page";
+import CourseSlugPage, {
+  generateStaticParams as courseStaticParams,
+} from "../app/[locale]/courses/[slug]/page";
+import EventsPage from "../app/[locale]/events/page";
+import EventSlugPage, {
+  generateStaticParams as eventStaticParams,
+} from "../app/[locale]/events/[slug]/page";
+
+import type { getMdxSource } from "@working-theory/page-renderer";
+
+type GetMdxSource = typeof getMdxSource;
+
+const mockPageRendererGetMdxSlugs = getPageRendererMdxSlugs as jest.MockedFunction<
+  typeof getPageRendererMdxSlugs
+>;
+const mockNotFound = notFound as jest.MockedFunction<typeof notFound>;
+
+async function renderAsync(
+  element: Promise<React.ReactElement> | React.ReactElement,
+): Promise<void> {
+  const resolved = await element;
+  render(resolved);
+}
+
+describe("apps/web — Phase 2 Content 5.1: CaseStudy + Course + Event routes", () => {
+  beforeEach(() => {
+    mockPageRendererGetMdxSlugs.mockReset();
+    mockNotFound.mockClear();
+  });
+
+  // ── /case-studies (list) ──────────────────────────────────────────────────
+
+  describe("/case-studies", () => {
+    describe("with CaseStudiesList MDX present", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue({
+          frontmatter: {
+            type: "CaseStudiesList",
+            slug: "case-studies",
+            title: "Case Studies",
+            description: "Real-world accounts of teams using AI Launch Kit.",
+          },
+          body: "# Case Studies\n\nBody.",
+        });
+
+      beforeEach(() => stubGetMdxSource.mockClear());
+
+      it("renders the h1 from MDX frontmatter", async () => {
+        await renderAsync(
+          CaseStudiesPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+          "Case Studies",
+        );
+      });
+
+      it("emits a JSON-LD script tag with @type CollectionPage", async () => {
+        await renderAsync(
+          CaseStudiesPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        const script = screen.getByTestId("json-ld");
+        expect(script.getAttribute("type")).toBe("application/ld+json");
+        const parsed = JSON.parse(script.innerHTML) as { "@type": string };
+        expect(parsed["@type"]).toBe("CollectionPage");
+      });
+
+      it("calls getMdxSource with CaseStudiesList type and locale", async () => {
+        await renderAsync(
+          CaseStudiesPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(stubGetMdxSource).toHaveBeenCalledWith(
+          "CaseStudiesList",
+          "case-studies",
+          "en",
+        );
+      });
+    });
+
+    describe("with no CaseStudiesList MDX (empty state)", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue(null);
+
+      it("renders the fallback sentinel without crashing", async () => {
+        await renderAsync(
+          CaseStudiesPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByTestId("section-empty-state")).toBeInTheDocument();
+      });
+    });
+  });
+
+  // ── /case-studies/[slug] (detail) ─────────────────────────────────────────
+
+  describe("/case-studies/[slug]", () => {
+    describe("with CaseStudy MDX present", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue({
+          frontmatter: {
+            type: "CaseStudy",
+            slug: "ailk-aeo-rollout",
+            title: "AEO Rollout at AI Launch Kit",
+            description: "How the team implemented AEO.",
+          },
+          body: "# AEO Rollout\n\nBody.",
+        });
+
+      beforeEach(() => stubGetMdxSource.mockClear());
+
+      it("renders the h1 from MDX frontmatter", async () => {
+        await renderAsync(
+          CaseStudySlugPage({
+            params: Promise.resolve({ locale: "en", slug: "ailk-aeo-rollout" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+          "AEO Rollout at AI Launch Kit",
+        );
+      });
+
+      it("emits a JSON-LD script tag with @type Article (CaseStudy pageType)", async () => {
+        await renderAsync(
+          CaseStudySlugPage({
+            params: Promise.resolve({ locale: "en", slug: "ailk-aeo-rollout" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        const script = screen.getByTestId("json-ld");
+        const outer = JSON.parse(script.innerHTML) as { "@type": string; "@graph": Array<{ "@type": string; mainEntity: { "@type": string } }> };
+        expect(outer["@type"]).toBeUndefined();
+        const primary = outer["@graph"][0]!;
+        expect(primary["@type"]).toBe("WebPage");
+        expect(primary.mainEntity["@type"]).toBe("Article");
+      });
+    });
+
+    describe("with no CaseStudy MDX (unknown slug)", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue(null);
+
+      it("calls notFound() for an unknown slug", async () => {
+        await expect(
+          CaseStudySlugPage({
+            params: Promise.resolve({ locale: "en", slug: "unknown-slug" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        ).rejects.toThrow("NEXT_NOT_FOUND");
+        expect(mockNotFound).toHaveBeenCalled();
+      });
+    });
+  });
+
+  // ── /courses (list) ───────────────────────────────────────────────────────
+
+  describe("/courses", () => {
+    describe("with CoursesList MDX present", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue({
+          frontmatter: {
+            type: "CoursesList",
+            slug: "courses",
+            title: "Courses",
+            description: "Structured learning paths for teams adopting AILK.",
+          },
+          body: "# Courses\n\nBody.",
+        });
+
+      beforeEach(() => stubGetMdxSource.mockClear());
+
+      it("renders the h1 from MDX frontmatter", async () => {
+        await renderAsync(
+          CoursesPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+          "Courses",
+        );
+      });
+
+      it("emits a JSON-LD script tag with @type CollectionPage", async () => {
+        await renderAsync(
+          CoursesPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        const script = screen.getByTestId("json-ld");
+        const parsed = JSON.parse(script.innerHTML) as { "@type": string };
+        expect(parsed["@type"]).toBe("CollectionPage");
+      });
+
+      it("calls getMdxSource with CoursesList type and locale", async () => {
+        await renderAsync(
+          CoursesPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(stubGetMdxSource).toHaveBeenCalledWith(
+          "CoursesList",
+          "courses",
+          "en",
+        );
+      });
+    });
+
+    describe("with no CoursesList MDX (empty state)", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue(null);
+
+      it("renders the fallback sentinel without crashing", async () => {
+        await renderAsync(
+          CoursesPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByTestId("section-empty-state")).toBeInTheDocument();
+      });
+    });
+  });
+
+  // ── /courses/[slug] (detail) ──────────────────────────────────────────────
+
+  describe("/courses/[slug]", () => {
+    describe("with Course MDX present", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue({
+          frontmatter: {
+            type: "Course",
+            slug: "aeo-fundamentals",
+            title: "AEO Fundamentals",
+            description: "A practical course covering Layer 1 rules.",
+          },
+          body: "# AEO Fundamentals\n\nBody.",
+        });
+
+      beforeEach(() => stubGetMdxSource.mockClear());
+
+      it("renders the h1 from MDX frontmatter", async () => {
+        await renderAsync(
+          CourseSlugPage({
+            params: Promise.resolve({ locale: "en", slug: "aeo-fundamentals" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+          "AEO Fundamentals",
+        );
+      });
+
+      it("emits a JSON-LD script tag with @type WebPage and mainEntity Course", async () => {
+        await renderAsync(
+          CourseSlugPage({
+            params: Promise.resolve({ locale: "en", slug: "aeo-fundamentals" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        const script = screen.getByTestId("json-ld");
+        const outer = JSON.parse(script.innerHTML) as { "@type": string; "@graph": Array<{ "@type": string; mainEntity: { "@type": string } }> };
+        expect(outer["@type"]).toBeUndefined();
+        const primary = outer["@graph"][0]!;
+        expect(primary["@type"]).toBe("WebPage");
+        expect(primary.mainEntity["@type"]).toBe("Course");
+      });
+    });
+
+    describe("with no Course MDX (unknown slug)", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue(null);
+
+      it("calls notFound() for an unknown slug", async () => {
+        await expect(
+          CourseSlugPage({
+            params: Promise.resolve({ locale: "en", slug: "unknown-slug" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        ).rejects.toThrow("NEXT_NOT_FOUND");
+        expect(mockNotFound).toHaveBeenCalled();
+      });
+    });
+  });
+
+  // ── /events (list) ────────────────────────────────────────────────────────
+
+  describe("/events", () => {
+    describe("with EventsList MDX present", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue({
+          frontmatter: {
+            type: "EventsList",
+            slug: "events",
+            title: "Events",
+            description: "Live sessions and office hours from the AILK team.",
+          },
+          body: "# Events\n\nBody.",
+        });
+
+      beforeEach(() => stubGetMdxSource.mockClear());
+
+      it("renders the h1 from MDX frontmatter", async () => {
+        await renderAsync(
+          EventsPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+          "Events",
+        );
+      });
+
+      it("emits a JSON-LD script tag with @type CollectionPage", async () => {
+        await renderAsync(
+          EventsPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        const script = screen.getByTestId("json-ld");
+        const parsed = JSON.parse(script.innerHTML) as { "@type": string };
+        expect(parsed["@type"]).toBe("CollectionPage");
+      });
+
+      it("calls getMdxSource with EventsList type and locale", async () => {
+        await renderAsync(
+          EventsPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(stubGetMdxSource).toHaveBeenCalledWith(
+          "EventsList",
+          "events",
+          "en",
+        );
+      });
+    });
+
+    describe("with no EventsList MDX (empty state)", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue(null);
+
+      it("renders the fallback sentinel without crashing", async () => {
+        await renderAsync(
+          EventsPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByTestId("section-empty-state")).toBeInTheDocument();
+      });
+    });
+  });
+
+  // ── /events/[slug] (detail) ───────────────────────────────────────────────
+
+  describe("/events/[slug]", () => {
+    describe("with Event MDX present", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue({
+          frontmatter: {
+            type: "Event",
+            slug: "ailk-launch-day-2026",
+            title: "AI Launch Kit Launch Day 2026",
+            description: "The public launch of AI Launch Kit.",
+          },
+          body: "# Launch Day\n\nBody.",
+        });
+
+      beforeEach(() => stubGetMdxSource.mockClear());
+
+      it("renders the h1 from MDX frontmatter", async () => {
+        await renderAsync(
+          EventSlugPage({
+            params: Promise.resolve({
+              locale: "en",
+              slug: "ailk-launch-day-2026",
+            }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+          "AI Launch Kit Launch Day 2026",
+        );
+      });
+
+      it("emits a JSON-LD script tag with @type WebPage and mainEntity Event", async () => {
+        await renderAsync(
+          EventSlugPage({
+            params: Promise.resolve({
+              locale: "en",
+              slug: "ailk-launch-day-2026",
+            }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        const script = screen.getByTestId("json-ld");
+        const outer = JSON.parse(script.innerHTML) as { "@type": string; "@graph": Array<{ "@type": string; mainEntity: { "@type": string } }> };
+        expect(outer["@type"]).toBeUndefined();
+        const primary = outer["@graph"][0]!;
+        expect(primary["@type"]).toBe("WebPage");
+        expect(primary.mainEntity["@type"]).toBe("Event");
+      });
+    });
+
+    describe("with no Event MDX (unknown slug)", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue(null);
+
+      it("calls notFound() for an unknown slug", async () => {
+        await expect(
+          EventSlugPage({
+            params: Promise.resolve({ locale: "en", slug: "unknown-slug" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        ).rejects.toThrow("NEXT_NOT_FOUND");
+        expect(mockNotFound).toHaveBeenCalled();
+      });
+    });
+  });
+
+  // ── generateStaticParams ──────────────────────────────────────────────────
+  //
+  // generateStaticParams has a fixed Next.js function signature and cannot
+  // accept DI props. getMdxSlugs is mocked at the module level (see top of
+  // file) to cover this code path — the narrowest possible scope.
+
+  describe("generateStaticParams", () => {
+    describe("caseStudyStaticParams", () => {
+      // case-studies/[slug]/page.tsx was migrated to @working-theory/page-renderer (#1271);
+      // getMdxSlugs now comes from that package, not src/lib/content.
+      it("returns a slug for each seeded case study", async () => {
+        mockPageRendererGetMdxSlugs.mockResolvedValue([
+          "ailk-aeo-rollout",
+          "schema-builder-migration",
+        ]);
+        const params = await caseStudyStaticParams({
+          params: { locale: "en" },
+        });
+        expect(params).toEqual([
+          { slug: "ailk-aeo-rollout" },
+          { slug: "schema-builder-migration" },
+        ]);
+        expect(mockPageRendererGetMdxSlugs).toHaveBeenCalledWith(
+          "CaseStudy",
+          "en",
+        );
+      });
+
+      it("returns an empty array when no case studies are seeded", async () => {
+        mockPageRendererGetMdxSlugs.mockResolvedValue([]);
+        const params = await caseStudyStaticParams({
+          params: { locale: "en" },
+        });
+        expect(params).toEqual([]);
+      });
+    });
+
+    describe("courseStaticParams", () => {
+      // courses/[slug]/page.tsx was migrated to @working-theory/page-renderer (#1272);
+      // getMdxSlugs now comes from that package, not src/lib/content.
+      it("returns a slug for each seeded course", async () => {
+        mockPageRendererGetMdxSlugs.mockResolvedValue([
+          "aeo-fundamentals",
+          "schema-builder-workshop",
+        ]);
+        const params = await courseStaticParams({ params: { locale: "en" } });
+        expect(params).toEqual([
+          { slug: "aeo-fundamentals" },
+          { slug: "schema-builder-workshop" },
+        ]);
+        expect(mockPageRendererGetMdxSlugs).toHaveBeenCalledWith("Course", "en");
+      });
+
+      it("returns an empty array when no courses are seeded", async () => {
+        mockPageRendererGetMdxSlugs.mockResolvedValue([]);
+        const params = await courseStaticParams({ params: { locale: "en" } });
+        expect(params).toEqual([]);
+      });
+    });
+
+    describe("eventStaticParams", () => {
+      it("returns a slug for each seeded event", async () => {
+        // events/[slug]/page.tsx migrated to @working-theory/page-renderer (#1273) — use renderer mock.
+        mockPageRendererGetMdxSlugs.mockResolvedValue([
+          "ailk-launch-day-2026",
+          "aeo-office-hours-may-2026",
+        ]);
+        const params = await eventStaticParams({ params: { locale: "en" } });
+        expect(params).toEqual([
+          { slug: "ailk-launch-day-2026" },
+          { slug: "aeo-office-hours-may-2026" },
+        ]);
+        expect(mockPageRendererGetMdxSlugs).toHaveBeenCalledWith("Event", "en");
+      });
+
+      it("returns an empty array when no events are seeded", async () => {
+        // events/[slug]/page.tsx migrated to @working-theory/page-renderer (#1273) — use renderer mock.
+        mockPageRendererGetMdxSlugs.mockResolvedValue([]);
+        const params = await eventStaticParams({ params: { locale: "en" } });
+        expect(params).toEqual([]);
+      });
+    });
+  });
+});

package/templates/apps/web/__tests__/layout-stealth.test.ts

@@ -0,0 +1,39 @@
+// Tests that the stealth-metadata helper returns the right robots field
+// based on the STEALTH env var (#884). Extracted into its own module so it
+// can be tested without pulling in layout.tsx's component-level imports.
+
+import { getStealthRobots } from "@working-theory/web-i18n";
+
+describe("getStealthRobots (#884)", () => {
+  const originalStealth = process.env.STEALTH;
+
+  afterEach(() => {
+    if (originalStealth === undefined) {
+      delete process.env.STEALTH;
+    } else {
+      process.env.STEALTH = originalStealth;
+    }
+  });
+
+  it("returns { robots: { index: false, follow: false } } when STEALTH=true", () => {
+    process.env.STEALTH = "true";
+    expect(getStealthRobots()).toEqual({
+      robots: { index: false, follow: false },
+    });
+  });
+
+  it("returns an empty object when STEALTH is unset", () => {
+    delete process.env.STEALTH;
+    expect(getStealthRobots()).toEqual({});
+  });
+
+  it("returns an empty object when STEALTH is 'false'", () => {
+    process.env.STEALTH = "false";
+    expect(getStealthRobots()).toEqual({});
+  });
+
+  it("returns an empty object for any non-'true' STEALTH value", () => {
+    process.env.STEALTH = "yes";
+    expect(getStealthRobots()).toEqual({});
+  });
+});