create-ailk 0.1.0 → 0.2.0

package/templates/apps/web/__tests__/i18n/translations.test.ts

@@ -1,191 +0,0 @@
-/**
- * @jest-environment node
- */
-// i18n S2 — Translation API tests (#949)
-//
-// Tests that:
-// 1. messages/en.json has the required namespace structure (consent + common)
-// 2. All leaf values are non-empty strings
-// 3. The i18n.ts module exports a function (getRequestConfig wrapper)
-// 4. The catalog loads correctly for the 'en' locale via the i18n loader
-// 5. Missing locale catalog falls back to English (no catalog for 'es')
-
-// next-intl/server relies on the Next.js request context and cannot be called
-// directly in jest. We test i18n.ts's internal loader logic by mocking the
-// server context and verifying the messages returned.
-
-// Mock next-intl/server so getRequestConfig is a passthrough that calls our fn.
-jest.mock("next-intl/server", () => ({
-  getRequestConfig: (fn: unknown) => fn,
-}));
-
-import messages from "../../messages/en.json";
-
-describe("message catalog — en.json structure", () => {
-  it("has top-level 'consent' namespace", () => {
-    expect(messages).toHaveProperty("consent");
-    expect(typeof messages.consent).toBe("object");
-  });
-
-  it("has top-level 'common' namespace", () => {
-    expect(messages).toHaveProperty("common");
-    expect(typeof messages.common).toBe("object");
-  });
-
-  it("consent namespace contains required keys for S3 ConsentBanner", () => {
-    const { consent } = messages;
-    expect(consent).toHaveProperty("title");
-    expect(consent).toHaveProperty("body");
-    expect(consent).toHaveProperty("acceptLabel");
-    expect(consent).toHaveProperty("rejectLabel");
-    expect(consent).toHaveProperty("policyLinkLabel");
-  });
-
-  it("common namespace contains siteTitle key", () => {
-    const { common } = messages;
-    expect(common).toHaveProperty("siteTitle");
-  });
-
-  it("all leaf values are non-empty strings", () => {
-    // Walk the object tree asserting every leaf is a non-empty string.
-    // JSON.parse produces unknown, so we use a typed entry helper.
-    const parsed: unknown = JSON.parse(JSON.stringify(messages));
-    function assertLeafStrings(obj: unknown, path = ""): void {
-      if (typeof obj !== "object" || obj === null) {
-        expect(typeof obj).toBe("string");
-        expect((obj as string).length).toBeGreaterThan(0);
-        return;
-      }
-      for (const [key, value] of Object.entries(
-        obj as Record<string, unknown>,
-      )) {
-        assertLeafStrings(value, path ? `${path}.${key}` : key);
-      }
-    }
-    assertLeafStrings(parsed);
-  });
-});
-
-describe("i18n.ts — getRequestConfig loader", () => {
-  it("module default export is a function (the getRequestConfig callback)", async () => {
-    const i18nModule = await import("../../i18n/request");
-    expect(typeof i18nModule.default).toBe("function");
-  });
-
-  it("loader returns messages object for 'en' locale", async () => {
-    const i18nModule = await import("../../i18n/request");
-    const loader = i18nModule.default as (args: {
-      requestLocale: Promise<string>;
-    }) => Promise<{ locale: string; messages: typeof messages }>;
-
-    const result = await loader({
-      requestLocale: Promise.resolve("en"),
-    });
-
-    expect(result).toHaveProperty("locale", "en");
-    expect(result).toHaveProperty("messages");
-    expect(result.messages).toHaveProperty("consent");
-    expect(result.messages).toHaveProperty("common");
-  });
-
-  it("loader falls back to English messages for unknown locale 'es'", async () => {
-    const i18nModule = await import("../../i18n/request");
-    const loader = i18nModule.default as (args: {
-      requestLocale: Promise<string>;
-    }) => Promise<{ locale: string; messages: Record<string, unknown> }>;
-
-    // 'es' has no messages/es.json — should return en.json contents
-    const result = await loader({
-      requestLocale: Promise.resolve("es"),
-    });
-
-    expect(result).toHaveProperty("locale", "es");
-    expect(result).toHaveProperty("messages");
-    expect(result.messages).toHaveProperty("consent");
-    expect(result.messages).toHaveProperty("common");
-  });
-});
-
-describe("TypeScript type safety — compile-time key checking", () => {
-  it("messages structure satisfies the declared IntlMessages shape at runtime", () => {
-    // The TypeScript contract is declared in types/messages.d.ts.
-    // A deliberately mis-typed key (e.g. t('consnt.title')) is caught by
-    // tsc --noEmit — verified manually per AC checklist.
-    // Here we assert the runtime structure is internally consistent.
-    type ExpectedMessages = {
-      consent: {
-        title: string;
-        body: string;
-        acceptLabel: string;
-        rejectLabel: string;
-        policyLinkLabel: string;
-      };
-      common: {
-        siteTitle: string;
-      };
-    };
-
-    const typed = messages as ExpectedMessages;
-    expect(typed.consent.title.length).toBeGreaterThan(0);
-    expect(typed.consent.acceptLabel.length).toBeGreaterThan(0);
-    expect(typed.consent.rejectLabel.length).toBeGreaterThan(0);
-    expect(typed.common.siteTitle.length).toBeGreaterThan(0);
-  });
-});
-
-describe("i18n/request.ts — outer catch fallback (lines 31-32)", () => {
-  // Tests the outer catch block of i18n/request.ts: when import('../messages/en.json')
-  // on line 27 (inner fallback) rejects, the outer catch on lines 30-32 fires
-  // and attempts its own import of en.json.
-  //
-  // We cover the branch by isolating i18n/request.ts under jest.isolateModules and
-  // injecting a module-registry mock that makes the second en.json import
-  // (line 27) throw, so execution falls into the outer catch (line 31).
-
-  it("outer catch returns English messages when inner fallback import throws", async () => {
-    let result: { locale: string; messages: Record<string, unknown> } | undefined;
-
-    // Track how many times en.json is imported so we can make the second one
-    // fail (simulating the line-27 inner fallback rejection) while the third
-    // (line-31 outer catch) succeeds.
-    let enImportCount = 0;
-
-    await jest.isolateModulesAsync(async () => {
-      // Mock next-intl/server in the isolated scope.
-      jest.mock("next-intl/server", () => ({
-        getRequestConfig: (fn: unknown) => fn,
-      }));
-
-      // Mock the messages directory so we can control what each import returns.
-      // eslint-disable-next-line no-restricted-syntax -- test-seam mock required; controls dynamic import resolution in i18n.ts outer-catch coverage; tracked in #507
-      jest.mock("../../messages/en.json", () => {
-          enImportCount++;
-          if (enImportCount === 1) {
-            // First call — from line 27 (inner fallback after locale miss) —
-            // throw to force execution into the outer catch on line 31.
-            throw new Error("simulated en.json load failure");
-          }
-          // Second call — from line 31 (outer catch) — return real content.
-          // i18n.ts does `fallback.default ?? fallback`, so put content at top level.
-          return { consent: { title: "t", body: "b", acceptLabel: "a", rejectLabel: "r", policyLinkLabel: "p" }, common: { siteTitle: "s" } };
-        },
-        { virtual: true },
-      );
-
-      const i18nMod = await import("../../i18n/request");
-      const loader = i18nMod.default as (args: {
-        requestLocale: Promise<string>;
-      }) => Promise<{ locale: string; messages: Record<string, unknown> }>;
-
-      // Use locale "es" (no catalog) → locale import → null → line 27 runs →
-      // throws (mocked) → outer catch fires → line 31 runs → returns stub.
-      result = await loader({
-        requestLocale: Promise.resolve("es"),
-      });
-    });
-
-    expect(result).toBeDefined();
-    expect(result!.messages).toHaveProperty("consent");
-    expect(result!.messages).toHaveProperty("common");
-  });
-});

package/templates/apps/web/__tests__/json-ld.test.ts

@@ -1,98 +0,0 @@
-/**
- * Tests for pack-aware pageToJsonLd and getPackOnce.
- *
- * U3 contract:
- *   - pageToJsonLd is async; calls getPackOnce() then buildJsonLdWithPack(page, pack).
- *   - Empty-pack passthrough: output is byte-identical to the pre-U3 synchronous
- *     buildJsonLd(page) call when the pack has no patches for the page type.
- *   - With-pack: output reflects the pack's builder patch for the page type.
- *   - getPackOnce memoizes getCurrentPack — called at most once per module load.
- *
- * @working-theory/schema-pack-registry is globally mocked in setup.ts (prevents the
- * jose/license chain from loading in the JSDOM test environment). Individual
- * tests configure `getCurrentPack` and `applyPack` return values as needed.
- */
-
-import type { Pack } from "@working-theory/schema-pack-registry";
-import { getCurrentPack, applyPack } from "@working-theory/schema-pack-registry";
-import { buildJsonLd } from "@working-theory/schema";
-import { pageToJsonLd } from "@working-theory/page-renderer";
-import type { ContentPage } from "@working-theory/content-adapters";
-
-const mockGetCurrentPack = getCurrentPack as jest.MockedFunction<
-  typeof getCurrentPack
->;
-const mockApplyPack = applyPack as jest.MockedFunction<typeof applyPack>;
-
-const emptyPack: Pack = {
-  version: "2026.01.01",
-  schemaApiVersion: 1,
-  publishedAt: "2026-01-01T00:00:00.000Z",
-  patches: {},
-  registryDeltas: [],
-  signature: "built-in",
-};
-
-const homePageContent: ContentPage = {
-  type: "HomePage",
-  slug: "home",
-  title: "Example",
-  description: "An example site.",
-};
-
-describe("pageToJsonLd — pack-aware async", () => {
-  beforeEach(() => {
-    mockGetCurrentPack.mockReset();
-    mockApplyPack.mockReset();
-    // Default: applyPack is a passthrough (no patches applied).
-    mockApplyPack.mockImplementation(
-      (_name: string, output: Record<string, unknown>) => ({
-        result: output,
-        fellBack: false,
-      }),
-    );
-  });
-
-  it("is async (returns a Promise)", async () => {
-    mockGetCurrentPack.mockResolvedValue(emptyPack);
-    const result = pageToJsonLd(homePageContent, "en");
-    expect(result).toBeInstanceOf(Promise);
-    await result;
-  });
-
-  it("empty-pack: output byte-identical to buildJsonLd(page) with matching locale", async () => {
-    mockGetCurrentPack.mockResolvedValue(emptyPack);
-    const result = await pageToJsonLd(homePageContent, "en");
-    const input = {
-      type: homePageContent.type,
-      slug: homePageContent.slug,
-      title: homePageContent.title,
-      description: homePageContent.description,
-      locale: "en",
-    } as Parameters<typeof buildJsonLd>[0];
-    const baseline = buildJsonLd(input);
-    expect(JSON.stringify(result)).toBe(JSON.stringify(baseline));
-  });
-
-  it("with-pack: applyPack is called and its result is returned", async () => {
-    mockGetCurrentPack.mockResolvedValue(emptyPack);
-    // Simulate applyPack injecting a custom field.
-    mockApplyPack.mockImplementation(
-      (_name: string, output: Record<string, unknown>) => ({
-        result: { ...output, customField: "pack-injected" },
-        fellBack: false,
-      }),
-    );
-    const result = await pageToJsonLd(homePageContent, "en");
-    expect(result).toHaveProperty("customField", "pack-injected");
-  });
-
-  it("getCurrentPack is memoized — called at most once per module load", async () => {
-    mockGetCurrentPack.mockResolvedValue(emptyPack);
-    await pageToJsonLd(homePageContent, "en");
-    const callCount = mockGetCurrentPack.mock.calls.length;
-    await pageToJsonLd(homePageContent, "en");
-    // Second call must not invoke getCurrentPack again — memoized.
-    expect(mockGetCurrentPack.mock.calls.length).toBe(callCount);
-  });
-});