@specific.dev/spectest 0.78.0 → 0.79.1

package/src/components/expo.test.ts

@@ -0,0 +1,227 @@
+// What `expo()` builds from a real app directory: which package manager it
+// installs with, which Node it builds on, and the order of the Dockerfile
+// steps. The order is what makes a source edit cheap, so it is the part a
+// test has to hold: an install that moves below the source COPY runs again
+// on every edit, and nothing about the environment looks wrong when it does.
+
+import { afterEach, afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { expo, nodeMajorFromRange } from "./expo.js";
+import type { ServiceConfig } from "../index.js";
+
+let root = "";
+const prevWorkspace = process.env.SPECTEST_WORKSPACE;
+
+beforeAll(() => {
+  root = mkdtempSync(join(tmpdir(), "expo-app-"));
+  process.env.SPECTEST_WORKSPACE = root;
+});
+afterEach(() => rmSync(root, { recursive: true, force: true }));
+afterAll(() => {
+  if (prevWorkspace === undefined) delete process.env.SPECTEST_WORKSPACE;
+  else process.env.SPECTEST_WORKSPACE = prevWorkspace;
+  rmSync(root, { recursive: true, force: true });
+});
+
+/** Write an app into the workspace. `files` is path → content. */
+function app(files: Record<string, string>, dir = "."): void {
+  for (const [rel, content] of Object.entries(files)) {
+    const abs = join(root, dir, rel);
+    mkdirSync(join(abs, ".."), { recursive: true });
+    writeFileSync(abs, content);
+  }
+}
+
+const pkg = (extra: Record<string, unknown> = {}): string =>
+  JSON.stringify({ name: "app", dependencies: { expo: "51.0.0" }, ...extra });
+
+/** The generated Dockerfile of a service. */
+function dockerfile(svc: ServiceConfig): string {
+  const image = svc.image as { content?: string };
+  if (image.content === undefined) throw new Error("service does not build a generated Dockerfile");
+  return image.content;
+}
+
+/** Line index of the first line that holds `needle`. */
+function lineOf(text: string, needle: string): number {
+  const i = text.split("\n").findIndex((l) => l.includes(needle));
+  if (i < 0) throw new Error(`no line with ${needle} in:\n${text}`);
+  return i;
+}
+
+describe("expo() Dockerfile caching", () => {
+  test("installs from the manifests before it copies the source", () => {
+    app({ "package.json": pkg(), "package-lock.json": "{}", "App.js": "x" });
+    const df = dockerfile(expo());
+
+    // The manifests, the install, then everything else. An edit to App.js
+    // invalidates only the last two steps.
+    expect(lineOf(df, "COPY package.json package-lock.json ./")).toBeLessThan(lineOf(df, "npm ci"));
+    expect(lineOf(df, "npm ci")).toBeLessThan(lineOf(df, "COPY . ."));
+    expect(lineOf(df, "COPY . .")).toBeLessThan(lineOf(df, "expo export"));
+  });
+
+  test("keeps the package store and the Metro cache across builds", () => {
+    app({ "package.json": pkg(), "package-lock.json": "{}" });
+    const df = dockerfile(expo());
+
+    expect(df).toContain("RUN --mount=type=cache,target=/root/.npm,sharing=locked npm ci");
+    expect(df).toContain("--mount=type=cache,target=/tmp/metro-cache");
+  });
+
+  test("bakes EXPO_PUBLIC_* after the source, so an edit to one only exports again", () => {
+    app({ "package.json": pkg(), "package-lock.json": "{}" });
+    const df = dockerfile(expo({ env: { EXPO_PUBLIC_API: "https://api.test", OTHER: "no" } }));
+
+    expect(lineOf(df, "npm ci")).toBeLessThan(lineOf(df, "ENV EXPO_PUBLIC_API"));
+    expect(lineOf(df, "ENV EXPO_PUBLIC_API")).toBeLessThan(lineOf(df, "expo export"));
+    // Only the public ones are baked; the rest are container env.
+    expect(df).not.toContain("OTHER");
+  });
+
+  test("copies patches, because the install applies them", () => {
+    app({
+      "package.json": pkg(),
+      "package-lock.json": "{}",
+      "patches/expo+51.0.0.patch": "diff",
+    });
+    expect(dockerfile(expo())).toContain("COPY package.json package-lock.json patches ./");
+  });
+
+  test("holds the host's node_modules and the old export out of the context", () => {
+    app({ "package.json": pkg() });
+    const image = expo().image as { context?: string; exclude?: readonly string[] };
+    expect(image.context).toBe(".");
+    expect(image.exclude).toContain("node_modules");
+    expect(image.exclude).toContain("dist");
+  });
+});
+
+describe("expo() package manager", () => {
+  test("npm installs from the lockfile, and without one it resolves", () => {
+    app({ "package.json": pkg(), "package-lock.json": "{}" });
+    expect(dockerfile(expo())).toContain("npm ci");
+
+    rmSync(join(root, "package-lock.json"));
+    expect(dockerfile(expo())).toContain("npm install");
+  });
+
+  test("pnpm comes from its lockfile, with Corepack and its own store", () => {
+    app({ "package.json": pkg(), "pnpm-lock.yaml": "lockfileVersion: 9" });
+    const df = dockerfile(expo());
+
+    expect(df).toContain("RUN corepack enable pnpm");
+    expect(df).toContain("pnpm install --store-dir /pnpm-store --frozen-lockfile");
+    expect(df).toContain("pnpm exec expo export");
+  });
+
+  test("yarn 1 uses the image's own yarn; yarn 2+ is a Corepack release", () => {
+    app({ "package.json": pkg(), "yarn.lock": "" });
+    const classic = dockerfile(expo());
+    expect(classic).toContain("yarn install --cache-folder /yarn-cache --frozen-lockfile");
+    expect(classic).not.toContain("corepack");
+
+    app({ "package.json": pkg({ packageManager: "yarn@4.5.0" }), ".yarnrc.yml": "nodeLinker: node-modules" });
+    const berry = dockerfile(expo());
+    expect(berry).toContain("corepack enable yarn");
+    expect(berry).toContain("yarn install --immutable");
+    expect(berry).toContain("ENV YARN_ENABLE_GLOBAL_CACHE=1");
+  });
+
+  test("bun is installed into the Node image", () => {
+    app({ "package.json": pkg(), "bun.lock": "" });
+    const df = dockerfile(expo());
+    expect(df).toContain("RUN npm install -g bun");
+    expect(df).toContain("bun install --frozen-lockfile");
+    expect(df).toContain("bunx expo export");
+  });
+
+  test("the packageManager field wins over a stray lockfile", () => {
+    app({ "package.json": pkg({ packageManager: "pnpm@9.1.0" }), "package-lock.json": "{}" });
+    expect(dockerfile(expo())).toContain("pnpm install");
+  });
+
+  test("the option wins over both", () => {
+    app({ "package.json": pkg(), "package-lock.json": "{}" });
+    expect(dockerfile(expo({ packageManager: "yarn" }))).toContain("yarn install");
+  });
+});
+
+describe("expo() Node version", () => {
+  test("takes the version the app declares", () => {
+    app({ "package.json": pkg({ engines: { node: ">=22" } }) });
+    expect(dockerfile(expo())).toContain("FROM node:22-bookworm-slim");
+
+    app({ "package.json": pkg(), ".nvmrc": "v20.11.1\n" });
+    expect(dockerfile(expo())).toContain("FROM node:20-bookworm-slim");
+  });
+
+  test("builds on 22 when the app declares nothing readable", () => {
+    app({ "package.json": pkg(), ".nvmrc": "lts/iron\n" });
+    expect(dockerfile(expo())).toContain("FROM node:22-bookworm-slim");
+  });
+
+  test("the option wins", () => {
+    app({ "package.json": pkg({ engines: { node: ">=22" } }) });
+    expect(dockerfile(expo({ nodeVersion: "20-alpine" }))).toContain("FROM node:20-alpine");
+  });
+
+  test("a range names what to build on, not what to avoid", () => {
+    // An upper bound says which version must NOT run, so it is not a choice.
+    expect(nodeMajorFromRange(">=18 <21")).toBe(18);
+    expect(nodeMajorFromRange("18 || 20 || 22")).toBe(22);
+    expect(nodeMajorFromRange("^20.9.0")).toBe(20);
+    // One version is one token — its first number is the major.
+    expect(nodeMajorFromRange("18.20.4")).toBe(18);
+    expect(nodeMajorFromRange("22.x")).toBe(22);
+    expect(nodeMajorFromRange("lts/*")).toBeNull();
+  });
+});
+
+describe("expo() with your own Dockerfile", () => {
+  test("builds the repo file from the app dir, and serves the documented path", () => {
+    app({ "package.json": pkg(), "Dockerfile": "FROM node:22\n" }, "mobile");
+    const svc = expo({ appDir: "mobile", dockerfile: "mobile/Dockerfile" });
+
+    expect(svc.image).toEqual({ type: "dockerfile", path: "mobile/Dockerfile", context: "mobile" });
+    expect(svc.command).toContain("/app/dist");
+  });
+
+  test("staticDir says where that build wrote the export", () => {
+    app({ "package.json": pkg(), "Dockerfile": "FROM nginx\n" });
+    const svc = expo({ dockerfile: "Dockerfile", staticDir: "/srv/web" });
+    expect(svc.command).toBe("node /spectest-expo-serve.mjs /srv/web 8081");
+  });
+
+  test("refuses a staticDir that depends on the image's WORKDIR", () => {
+    app({ "package.json": pkg(), "Dockerfile": "FROM nginx\n" });
+    expect(() => expo({ dockerfile: "Dockerfile", staticDir: "web" })).toThrow(/absolute path/);
+  });
+
+  test("refuses the options that describe the generated Dockerfile", () => {
+    app({ "package.json": pkg(), "Dockerfile": "FROM node:22\n" });
+    expect(() => expo({ dockerfile: "Dockerfile", nodeVersion: "22-alpine" })).toThrow(/nodeVersion/);
+    expect(() => expo({ dockerfile: "Dockerfile", env: { EXPO_PUBLIC_API: "x" } })).toThrow(/EXPO_PUBLIC/);
+    // `env` that Expo does not inline is the container's, and stays allowed.
+    expect(expo({ dockerfile: "Dockerfile", env: { API: "x" } }).env).toEqual({ API: "x" });
+  });
+
+  test("the static server stops on an image with no export in it", () => {
+    app({ "package.json": pkg() });
+    const server = expo().files!.find((f) => f.path.endsWith(".mjs"))!.content;
+    expect(server).toContain("holds no index.html");
+    expect(server).toContain("process.exit(1)");
+  });
+});
+
+describe("expo() app directory", () => {
+  test("names the directory when there is no app in it", () => {
+    app({ "package.json": pkg() });
+    expect(() => expo({ appDir: "mobile" })).toThrow(/appDir "mobile" is not in the project/);
+    app({ "readme.md": "x" }, "mobile");
+    expect(() => expo({ appDir: "mobile" })).toThrow(/no package.json in mobile/);
+  });
+});