create-ailk 0.1.0

package/templates/apps/web/__tests__/routes/blog-route.test.tsx

@@ -0,0 +1,191 @@
+/**
+ * Route handler tests: GET /blog (catch-all)
+ *
+ * Validates the empty-state contract: with `content/blog/` empty, the index
+ * renders the BLOG_EMPTY_SENTINEL placeholder. Also validates the populated
+ * branch and the detail-route branch. The Fumadocs source is injected via
+ * the optional `blogSource` prop instead of mocked at the module level,
+ * so these tests don't depend on the on-disk content tree or lib/source.
+ */
+import { render, screen } from "@testing-library/react";
+
+jest.mock("next/navigation", () => ({
+  __esModule: true,
+  notFound: jest.fn(() => {
+    throw new Error("NEXT_NOT_FOUND");
+  }),
+}));
+
+import * as React from "react";
+
+import BlogRoute, {
+  BLOG_EMPTY_SENTINEL,
+} from "../../app/[locale]/blog/[[...slug]]/page";
+
+/** Minimal blog-source stub matching the BlogSource interface. */
+function makeStubBlogSource(overrides: {
+  pages?: Array<{ url: string; data: unknown }>;
+  page?: { data: unknown } | undefined;
+}) {
+  return {
+    getPages: jest.fn().mockReturnValue(overrides.pages ?? []),
+    getPage: jest.fn().mockReturnValue(overrides.page),
+  };
+}
+
+async function renderAsync(
+  element: Promise<React.ReactElement>,
+): Promise<void> {
+  const resolved = await element;
+  render(resolved);
+}
+
+describe("apps/web — /blog catch-all route", () => {
+  describe("index route (no slug) — empty content/blog/", () => {
+    it("renders the empty-state placeholder with the known sentinel", async () => {
+      const stubSource = makeStubBlogSource({ pages: [] });
+      await renderAsync(BlogRoute({ params: Promise.resolve({ locale: "en" }), blogSource: stubSource }));
+      const placeholder = screen.getByTestId("blog-empty-placeholder");
+      expect(placeholder.getAttribute("data-sentinel")).toBe(
+        BLOG_EMPTY_SENTINEL,
+      );
+    });
+
+    it("renders the Blog heading", async () => {
+      const stubSource = makeStubBlogSource({ pages: [] });
+      await renderAsync(BlogRoute({ params: Promise.resolve({ locale: "en" }), blogSource: stubSource }));
+      const heading = screen.getByRole("heading", { level: 1 });
+      expect(heading).toHaveTextContent("Blog");
+    });
+
+    it("emits a Blog JSON-LD <script> alongside the placeholder", async () => {
+      const stubSource = makeStubBlogSource({ pages: [] });
+      await renderAsync(BlogRoute({ params: Promise.resolve({ locale: "en" }), blogSource: stubSource }));
+      const script = screen.getByTestId("json-ld");
+      const parsed = JSON.parse(script.innerHTML) as Record<string, unknown>;
+      expect(parsed["@context"]).toBe("https://schema.org");
+      expect(parsed["@type"]).toBe("Blog");
+    });
+  });
+
+  describe("index route (no slug) — populated content/blog/", () => {
+    const stubPages = [
+      {
+        url: "/blog/launching",
+        data: {
+          title: "Launching AILK",
+          description: "First post.",
+          date: "2026-05-06",
+          image: "/img/launching.png",
+          author: { name: "The AILK Team" },
+          tags: ["Announcements", "AX"],
+        },
+      },
+      {
+        url: "/blog/second",
+        data: {
+          title: "Second Post",
+          description: "Another post.",
+        },
+      },
+    ];
+
+    it("renders the BlogList section (no bare placeholder list)", async () => {
+      const stubSource = makeStubBlogSource({ pages: stubPages });
+      await renderAsync(BlogRoute({ params: Promise.resolve({ locale: "en" }), blogSource: stubSource }));
+      expect(screen.getByTestId("blog-list")).toBeInTheDocument();
+    });
+
+    it("renders one linked title per post with the /blog/ prefix re-applied", async () => {
+      const stubSource = makeStubBlogSource({ pages: stubPages });
+      await renderAsync(BlogRoute({ params: Promise.resolve({ locale: "en" }), blogSource: stubSource }));
+      const links = screen.getAllByRole("link");
+      expect(links).toHaveLength(2);
+      const first = links[0];
+      if (!first) throw new Error("expected at least one link");
+      expect(first).toHaveTextContent("Launching AILK");
+      expect(first.getAttribute("href")).toBe("/blog/launching");
+    });
+
+    it("maps author and tags onto the rendered post preview", async () => {
+      const stubSource = makeStubBlogSource({ pages: stubPages });
+      await renderAsync(BlogRoute({ params: Promise.resolve({ locale: "en" }), blogSource: stubSource }));
+      expect(screen.getByText("The AILK Team")).toBeInTheDocument();
+      expect(screen.getByText("Announcements")).toBeInTheDocument();
+      expect(screen.getByText("AX")).toBeInTheDocument();
+    });
+
+    it("does not render the empty-state placeholder", async () => {
+      const stubSource = makeStubBlogSource({ pages: stubPages });
+      await renderAsync(BlogRoute({ params: Promise.resolve({ locale: "en" }), blogSource: stubSource }));
+      expect(screen.queryByTestId("blog-empty-placeholder")).toBeNull();
+    });
+  });
+
+  describe("detail route (slug provided)", () => {
+    it("renders the BlogPost section and emits a BlogPosting JSON-LD <script>", async () => {
+      const stubSource = makeStubBlogSource({
+        page: {
+          data: {
+            title: "Hello, World",
+            description: "First post.",
+            date: "2026-05-01",
+          },
+        },
+      });
+
+      await renderAsync(
+        BlogRoute({ params: Promise.resolve({ locale: "en", slug: ["hello-world"] }), blogSource: stubSource }),
+      );
+      expect(screen.getByTestId("blog-post")).toBeInTheDocument();
+      const heading = screen.getByRole("heading", { level: 1 });
+      expect(heading).toHaveTextContent("Hello, World");
+
+      const script = screen.getByTestId("json-ld");
+      const parsed = JSON.parse(script.innerHTML) as Record<string, unknown>;
+      expect(parsed["@context"]).toBe("https://schema.org");
+      expect(parsed["@type"]).toBe("WebPage");
+      const mainEntity = parsed.mainEntity as Record<string, unknown>;
+      expect(mainEntity["@type"]).toBe("BlogPosting");
+      expect(mainEntity.headline).toBe("Hello, World");
+      expect(parsed.datePublished).toBe("2026-05-01");
+    });
+
+    it("renders the compiled MDX body through the section's children slot", async () => {
+      const Body = () => <p data-testid="mdx-body">Compiled MDX paragraph.</p>;
+      const stubSource = makeStubBlogSource({
+        page: {
+          data: {
+            title: "Hello, World",
+            description: "First post.",
+            date: "2026-05-01",
+            author: { name: "The AILK Team" },
+            tags: ["Engineering"],
+            body: Body,
+            toc: [{ title: "Intro", url: "#intro", depth: 2 }],
+          },
+        },
+      });
+
+      await renderAsync(
+        BlogRoute({ params: Promise.resolve({ locale: "en", slug: ["hello-world"] }), blogSource: stubSource }),
+      );
+      expect(screen.getByTestId("mdx-body")).toHaveTextContent(
+        "Compiled MDX paragraph.",
+      );
+      expect(screen.getByText("The AILK Team")).toBeInTheDocument();
+      expect(screen.getByText("Engineering")).toBeInTheDocument();
+      expect(screen.getByTestId("blog-post-toc")).toBeInTheDocument();
+    });
+
+    it("calls notFound() when the slug does not resolve", async () => {
+      const stubSource = makeStubBlogSource({ page: undefined });
+
+      await expect(
+        renderAsync(
+          BlogRoute({ params: Promise.resolve({ locale: "en", slug: ["missing"] }), blogSource: stubSource }),
+        ),
+      ).rejects.toThrow("NEXT_NOT_FOUND");
+    });
+  });
+});

package/templates/apps/web/__tests__/routes/llms-txt.test.ts

@@ -0,0 +1,123 @@
+/**
+ * @jest-environment node
+ */
+
+/**
+ * Route handler tests: GET /llms.txt
+ *
+ * Validates: 200 status, text/plain Content-Type, non-empty body listing
+ * content seeds. Both the MDX adapter and blog pages are injected via
+ * createLlmsHandler rather than mocked at the module level.
+ */
+
+import { createLlmsHandler } from "../../app/llms.txt/route";
+import type { ContentAdapter } from "@working-theory/content-adapters";
+
+function makeStubAdapter(): ContentAdapter {
+  // 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().mockResolvedValue([
+      {
+        type: "HomePage",
+        slug: "home",
+        title: "Home",
+        description: "AX-first OSS template for shipping software.",
+      },
+    ]),
+    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;
+}
+
+const stubBlogPages = [
+  {
+    url: "/blog",
+    data: {
+      title: "Blog",
+      description: "Writing on AEO and AX-first software.",
+    },
+  },
+  {
+    url: "/blog/launching-ailk",
+    data: {
+      title: "Launching AI Launch Kit",
+      description: "How we built and shipped AILK.",
+    },
+  },
+];
+
+describe("GET /llms.txt", () => {
+  let GET: () => Promise<Response>;
+
+  beforeEach(() => {
+    const stubAdapter = makeStubAdapter();
+    GET = createLlmsHandler({
+      getContentAdapter: () => stubAdapter,
+      getBlogPages: () => stubBlogPages,
+    });
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it("returns 200", async () => {
+    const response = await GET();
+    expect(response.status).toBe(200);
+  });
+
+  it("returns text/plain content-type", async () => {
+    const response = await GET();
+    expect(response.headers.get("content-type")).toMatch(/text\/plain/);
+  });
+
+  it("body contains content titles", async () => {
+    const response = await GET();
+    const text = await response.text();
+    expect(text).toContain("Home");
+  });
+
+  it("body is non-empty", async () => {
+    const response = await GET();
+    const text = await response.text();
+    expect(text.trim().length).toBeGreaterThan(0);
+  });
+
+  it("body contains blog index entry", async () => {
+    const response = await GET();
+    const text = await response.text();
+    const lines = text.split("\n");
+    const titleIdx = lines.findIndex((l) => l.includes("Title: Blog"));
+    expect(titleIdx).toBeGreaterThan(-1);
+    const urlLine = lines.slice(titleIdx).find((l) => l.startsWith("  URL:"));
+    expect(urlLine).toMatch(/\/blog/);
+  });
+
+  it("body contains migrated post entry", async () => {
+    const response = await GET();
+    const text = await response.text();
+    const lines = text.split("\n");
+    const titleIdx = lines.findIndex((l) =>
+      l.includes("Title: Launching AI Launch Kit"),
+    );
+    expect(titleIdx).toBeGreaterThan(-1);
+    const urlLine = lines.slice(titleIdx).find((l) => l.startsWith("  URL:"));
+    expect(urlLine).toMatch(/\/blog\/launching-ailk/);
+  });
+
+  it("blog entries appear after section-catalog entries", async () => {
+    const response = await GET();
+    const text = await response.text();
+    const homeIdx = text.indexOf("Title: Home");
+    const blogIdx = text.indexOf("Title: Blog");
+    expect(homeIdx).toBeGreaterThan(-1);
+    expect(blogIdx).toBeGreaterThan(homeIdx);
+  });
+});

package/templates/apps/web/__tests__/routes/robots-txt.test.ts

@@ -0,0 +1,52 @@
+/**
+ * @jest-environment node
+ */
+
+/**
+ * Route handler tests: GET /robots.txt
+ *
+ * Validates: 200 status, text/plain Content-Type, sensible defaults, and
+ * optional AILK_ROBOTS_DISALLOW env-var override.
+ */
+
+describe("GET /robots.txt", () => {
+  afterEach(() => {
+    delete process.env["AILK_ROBOTS_DISALLOW"];
+    jest.resetModules();
+  });
+
+  it("returns 200", async () => {
+    const { GET } = await import("../../app/robots.txt/route");
+    const response = await GET();
+    expect(response.status).toBe(200);
+  });
+
+  it("returns text/plain content-type", async () => {
+    const { GET } = await import("../../app/robots.txt/route");
+    const response = await GET();
+    expect(response.headers.get("content-type")).toMatch(/text\/plain/);
+  });
+
+  it("body contains User-agent directive", async () => {
+    const { GET } = await import("../../app/robots.txt/route");
+    const response = await GET();
+    const text = await response.text();
+    expect(text).toContain("User-agent:");
+  });
+
+  it("body contains Sitemap directive by default", async () => {
+    const { GET } = await import("../../app/robots.txt/route");
+    const response = await GET();
+    const text = await response.text();
+    expect(text).toContain("Sitemap:");
+  });
+
+  it("honours AILK_ROBOTS_DISALLOW env var", async () => {
+    process.env["AILK_ROBOTS_DISALLOW"] = "/private/";
+    jest.resetModules();
+    const { GET } = await import("../../app/robots.txt/route");
+    const response = await GET();
+    const text = await response.text();
+    expect(text).toContain("Disallow: /private/");
+  });
+});

package/templates/apps/web/__tests__/routes/sitemap-xml.test.ts

@@ -0,0 +1,78 @@
+/**
+ * @jest-environment node
+ */
+
+/**
+ * Route handler tests: GET /sitemap.xml
+ *
+ * Validates: 200 status, application/xml Content-Type, body contains <urlset>
+ * and covers content seeds. MDX adapter is injected via createSitemapHandler
+ * rather than mocked at the module level.
+ */
+
+import { createSitemapHandler } from "../../app/sitemap.xml/route";
+import type { ContentAdapter } from "@working-theory/content-adapters";
+
+function makeStubAdapter(): ContentAdapter {
+  // 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().mockResolvedValue([
+      {
+        type: "BlogPosting",
+        slug: "launching-ailk",
+        title: "Launching AI Launch Kit",
+        description: "A short note on why we built.",
+      },
+    ]),
+    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;
+}
+
+describe("GET /sitemap.xml", () => {
+  let GET: () => Promise<Response>;
+
+  beforeEach(() => {
+    process.env.NEXT_PUBLIC_ENABLED_LOCALES = "en";
+    process.env.NEXT_PUBLIC_DEFAULT_LOCALE = "en";
+    const stubAdapter = makeStubAdapter();
+    GET = createSitemapHandler({ getContentAdapter: () => stubAdapter });
+  });
+
+  afterEach(() => {
+    delete process.env.NEXT_PUBLIC_ENABLED_LOCALES;
+    delete process.env.NEXT_PUBLIC_DEFAULT_LOCALE;
+    jest.resetAllMocks();
+  });
+
+  it("returns 200", async () => {
+    const response = await GET();
+    expect(response.status).toBe(200);
+  });
+
+  it("returns application/xml content-type", async () => {
+    const response = await GET();
+    expect(response.headers.get("content-type")).toMatch(/application\/xml/);
+  });
+
+  it("body is a valid XML sitemap with <urlset>", async () => {
+    const response = await GET();
+    const text = await response.text();
+    expect(text).toContain("<urlset");
+    expect(text).toContain("</urlset>");
+  });
+
+  it("body contains <url> entries for content seeds", async () => {
+    const response = await GET();
+    const text = await response.text();
+    expect(text).toContain("<url>");
+    expect(text).toContain("<loc>");
+  });
+});

package/templates/apps/web/__tests__/routes/well-known-mcp.test.ts

@@ -0,0 +1,203 @@
+/**
+ * @jest-environment node
+ */
+
+/**
+ * Route handler + builder tests: GET /.well-known/mcp.json
+ *
+ * Covers (issue #209 initial, #300 rename + extensions):
+ *   - GET returns 200 + JSON with schemaVersion, name, description,
+ *     mcpEndpoint, tools, transport, ailk
+ *   - tools array enumerates all tools by name (derived from catalog, not
+ *     hardcoded — tolerant of catalog growth when #299 adds ailkScaffold)
+ *   - Each tool entry has name, description, inputSchema, outputSchema
+ *   - CORS headers present on GET and OPTIONS responses
+ *   - schemaVersion is '1'
+ *   - cache-control matches the /.well-known/ai-plugin.json precedent
+ *   - buildMcpManifest is a pure function (no I/O)
+ */
+
+import { getMcpToolCatalog } from "@working-theory/metadata";
+import { buildMcpManifest } from "../../app/.well-known/mcp.json/build-manifest";
+
+describe("buildMcpManifest", () => {
+  it("returns an object with required top-level fields", () => {
+    const manifest = buildMcpManifest({
+      baseUrl: "https://example.com",
+      ailkVersion: "0.1.0",
+    });
+    expect(manifest).toHaveProperty("schemaVersion", "1");
+    expect(manifest).toHaveProperty("name");
+    expect(manifest).toHaveProperty("description");
+    expect(manifest).toHaveProperty("mcpEndpoint");
+    expect(manifest).toHaveProperty("tools");
+    expect(manifest).toHaveProperty("transport");
+    expect(manifest).toHaveProperty("ailk");
+  });
+
+  it("name and description are non-empty strings", () => {
+    const manifest = buildMcpManifest({
+      baseUrl: "https://example.com",
+      ailkVersion: "0.1.0",
+    });
+    expect(typeof manifest.name).toBe("string");
+    expect(manifest.name.length).toBeGreaterThan(0);
+    expect(typeof manifest.description).toBe("string");
+    expect(manifest.description.length).toBeGreaterThan(0);
+  });
+
+  it("mcpEndpoint is built from the baseUrl", () => {
+    const manifest = buildMcpManifest({
+      baseUrl: "https://example.com",
+      ailkVersion: "0.1.0",
+    });
+    expect(manifest.mcpEndpoint).toContain("https://example.com");
+  });
+
+  it("transport block has type 'http' and a version string", () => {
+    const manifest = buildMcpManifest({
+      baseUrl: "https://example.com",
+      ailkVersion: "0.1.0",
+    });
+    expect(manifest.transport).toHaveProperty("type", "http");
+    expect(typeof manifest.transport.version).toBe("string");
+    expect(manifest.transport.version.length).toBeGreaterThan(0);
+  });
+
+  it("ailk block carries the version", () => {
+    const manifest = buildMcpManifest({
+      baseUrl: "https://example.com",
+      ailkVersion: "0.42.0",
+    });
+    expect(manifest.ailk).toEqual({ version: "0.42.0" });
+  });
+
+  it("tools array is consistent with the catalog (name-for-name match)", () => {
+    const catalog = getMcpToolCatalog();
+    const manifest = buildMcpManifest({
+      baseUrl: "https://example.com",
+      ailkVersion: "0.1.0",
+    });
+    const manifestNames = manifest.tools.map((t) => t.name).sort();
+    const catalogNames = catalog.map((t) => t.name).sort();
+    expect(manifestNames).toEqual(catalogNames);
+  });
+
+  it("every tool entry has name, description, inputSchema, outputSchema", () => {
+    const manifest = buildMcpManifest({
+      baseUrl: "https://example.com",
+      ailkVersion: "0.1.0",
+    });
+    for (const tool of manifest.tools) {
+      expect(typeof tool.name).toBe("string");
+      expect(tool.name.length).toBeGreaterThan(0);
+      expect(typeof tool.description).toBe("string");
+      expect(tool.description.length).toBeGreaterThan(0);
+      expect(tool.inputSchema).toBeDefined();
+      expect(typeof tool.inputSchema).toBe("object");
+      expect(tool.outputSchema).toBeDefined();
+      expect(typeof tool.outputSchema).toBe("object");
+    }
+  });
+});
+
+describe("GET /.well-known/mcp.json", () => {
+  it("returns 200", async () => {
+    const { GET } = await import("../../app/.well-known/mcp.json/route");
+    const response = await GET();
+    expect(response.status).toBe(200);
+  });
+
+  it("returns application/json content-type", async () => {
+    const { GET } = await import("../../app/.well-known/mcp.json/route");
+    const response = await GET();
+    expect(response.headers.get("content-type")).toMatch(/application\/json/);
+  });
+
+  it("body has required top-level fields", async () => {
+    const { GET } = await import("../../app/.well-known/mcp.json/route");
+    const response = await GET();
+    const body = await response.json();
+    expect(body).toHaveProperty("schemaVersion", "1");
+    expect(body).toHaveProperty("name");
+    expect(body).toHaveProperty("description");
+    expect(body).toHaveProperty("mcpEndpoint");
+    expect(body).toHaveProperty("tools");
+    expect(body).toHaveProperty("transport");
+    expect(body).toHaveProperty("ailk");
+  });
+
+  it("transport block has type 'http' and a version string", async () => {
+    const { GET } = await import("../../app/.well-known/mcp.json/route");
+    const response = await GET();
+    const body = await response.json();
+    expect(body.transport).toHaveProperty("type", "http");
+    expect(typeof body.transport.version).toBe("string");
+    expect(body.transport.version.length).toBeGreaterThan(0);
+  });
+
+  it("tools array is consistent with the catalog (name-for-name match)", async () => {
+    const catalog = getMcpToolCatalog();
+    const { GET } = await import("../../app/.well-known/mcp.json/route");
+    const response = await GET();
+    const body = await response.json();
+    const manifestNames = (body.tools as Array<{ name: string }>)
+      .map((t) => t.name)
+      .sort();
+    const catalogNames = catalog.map((t) => t.name).sort();
+    expect(manifestNames).toEqual(catalogNames);
+  });
+
+  it("each tool entry has name, description, inputSchema, outputSchema", async () => {
+    const { GET } = await import("../../app/.well-known/mcp.json/route");
+    const response = await GET();
+    const body = await response.json();
+    for (const tool of body.tools as Array<Record<string, unknown>>) {
+      expect(typeof tool["name"]).toBe("string");
+      expect(typeof tool["description"]).toBe("string");
+      expect(tool["inputSchema"]).toBeDefined();
+      expect(typeof tool["inputSchema"]).toBe("object");
+      expect(tool["outputSchema"]).toBeDefined();
+      expect(typeof tool["outputSchema"]).toBe("object");
+    }
+  });
+
+  it("CORS: Access-Control-Allow-Origin is *", async () => {
+    const { GET } = await import("../../app/.well-known/mcp.json/route");
+    const response = await GET();
+    expect(response.headers.get("access-control-allow-origin")).toBe("*");
+  });
+
+  it("CORS: Access-Control-Allow-Methods includes GET", async () => {
+    const { GET } = await import("../../app/.well-known/mcp.json/route");
+    const response = await GET();
+    const methods = response.headers.get("access-control-allow-methods") ?? "";
+    expect(methods).toContain("GET");
+  });
+
+  it("cache-control matches the /.well-known/ai-plugin.json precedent", async () => {
+    const { GET: getMcp } = await import(
+      "../../app/.well-known/mcp.json/route"
+    );
+    const { GET: getAiPlugin } = await import(
+      "../../app/.well-known/ai-plugin.json/route"
+    );
+    const mcpRes = await getMcp();
+    const aiPluginRes = getAiPlugin();
+    expect(mcpRes.headers.get("cache-control")).toBe(
+      aiPluginRes.headers.get("cache-control"),
+    );
+  });
+});
+
+describe("OPTIONS /.well-known/mcp.json", () => {
+  it("returns 204 with CORS headers", async () => {
+    const { OPTIONS } = await import("../../app/.well-known/mcp.json/route");
+    const response = await OPTIONS();
+    expect(response.status).toBe(204);
+    expect(response.headers.get("access-control-allow-origin")).toBe("*");
+    expect(response.headers.get("access-control-allow-methods")).toContain(
+      "GET",
+    );
+  });
+});