ember.nvp 0.5.0 → 0.7.0

package/test/ember.nvp/library-src-fixtures.ts

@@ -0,0 +1,81 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+import type { Project } from "ember.nvp";
+
+/**
+ * The library base generates an empty `src/`; tests that build or test a
+ * library write this example source (a class component, a template-only
+ * component, and a plain module) into the generated project first.
+ */
+export const librarySource = {
+  typescript: {
+    "src/index.ts": `export { Badge, type BadgeSignature } from "./components/badge.gts";
+export { default as Greeting, type GreetingSignature } from "./components/greeting.gts";
+export { add } from "./utils/math.ts";
+`,
+    "src/components/greeting.gts": `import Component from "@glimmer/component";
+
+export interface GreetingSignature {
+  Element: HTMLParagraphElement;
+  Args: {
+    name: string;
+  };
+}
+
+export default class Greeting extends Component<GreetingSignature> {
+  <template>
+    <p ...attributes>Hello, {{@name}}!</p>
+  </template>
+}
+`,
+    "src/components/badge.gts": `import type { TOC } from "@ember/component/template-only";
+
+export interface BadgeSignature {
+  Element: HTMLSpanElement;
+  Blocks: {
+    default: [];
+  };
+}
+
+export const Badge: TOC<BadgeSignature> = <template>
+  <span class="badge" ...attributes>{{yield}}</span>
+</template>;
+`,
+    "src/utils/math.ts": `export function add(a: number, b: number): number {
+  return a + b;
+}
+`,
+  },
+  javascript: {
+    "src/index.js": `export { Badge } from "./components/badge.gjs";
+export { default as Greeting } from "./components/greeting.gjs";
+export { add } from "./utils/math.js";
+`,
+    "src/components/greeting.gjs": `import Component from "@glimmer/component";
+
+export default class Greeting extends Component {
+  <template>
+    <p ...attributes>Hello, {{@name}}!</p>
+  </template>
+}
+`,
+    "src/components/badge.gjs": `export const Badge = <template>
+  <span class="badge" ...attributes>{{yield}}</span>
+</template>;
+`,
+    "src/utils/math.js": `export function add(a, b) {
+  return a + b;
+}
+`,
+  },
+};
+
+export async function writeLibrarySource(project: Project, flavor: keyof typeof librarySource) {
+  for (let [filePath, contents] of Object.entries(librarySource[flavor])) {
+    let target = join(project.directory, filePath);
+
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, contents);
+  }
+}

package/test/ember.nvp/permutations/app-1.test.ts

@@ -0,0 +1,3 @@
+import { testPermutations } from "./shared.ts";
+
+testPermutations("minimal-app", { index: 0, total: 2 });

package/test/ember.nvp/permutations/app-2.test.ts

@@ -0,0 +1,3 @@
+import { testPermutations } from "./shared.ts";
+
+testPermutations("minimal-app", { index: 1, total: 2 });

package/test/ember.nvp/permutations/library-1.test.ts

@@ -0,0 +1,3 @@
+import { testPermutations } from "./shared.ts";
+
+testPermutations("minimal-library", { index: 0, total: 2 });

package/test/ember.nvp/permutations/library-2.test.ts

@@ -0,0 +1,3 @@
+import { testPermutations } from "./shared.ts";
+
+testPermutations("minimal-library", { index: 1, total: 2 });

package/test/ember.nvp/permutations/shared.ts

@@ -0,0 +1,239 @@
+import { beforeAll, describe, it, expect, afterAll } from "vitest";
+import { generate, permutate, bases, layers, reapply } from "#test-helpers";
+import { TODO } from "#layers";
+
+import { rm } from "node:fs/promises";
+
+import type { Project } from "ember.nvp";
+import type { ProjectType } from "#types";
+
+const baseline = "<baseline>";
+
+const RE_APPLY_ONLY = new Set<string>([
+  // "typescript"
+  // "renovate",
+  // "github-actions",
+]);
+const INITIAL_ONLY = new Set<string>([
+  // baseline,
+  // "eslint-bundled-nvp",
+  // "typescript"
+]);
+
+/**
+ * Layers that don't yet generate a working setup for a project type.
+ * Every layer is *supposed* to support every base eventually -- shrink
+ * these as layers learn.
+ */
+const NOT_YET_SUPPORTED: Record<ProjectType, Set<string>> = {
+  // publish checks: apps aren't published
+  app: new Set(["publint", "are-the-types-wrong"]),
+  // libraries have no Application to wire inspector support into
+  library: new Set(["inspector-support"]),
+};
+
+const eachBase = bases.map((base) => {
+  const type: ProjectType = base === "minimal-app" ? "app" : "library";
+
+  const applicableLayers = layers.filter((layer) => !NOT_YET_SUPPORTED[type].has(layer.name));
+
+  const permutations = permutate(applicableLayers.map((layer) => layer.name));
+  permutations.push([baseline]);
+
+  const eachPermutation = permutations
+    .filter((permutation) => {
+      if (INITIAL_ONLY.size > 0 && !permutation.some((x) => INITIAL_ONLY.has(x))) {
+        return;
+      }
+
+      // Not implemented yet
+      if (permutation.some((x) => TODO.has(x))) {
+        return;
+      }
+
+      return true;
+    })
+    .map((permutation) => ({ permutation, name: permutation.join(", ") }));
+
+  return { name: base, type, applicableLayers, eachPermutation };
+});
+
+/**
+ * The permutation matrix grows exponentially with the layer count, so
+ * each base runs from its own test file(s) -- CI runs them as separate,
+ * parallel jobs. A base whose matrix outgrows one job's budget runs from
+ * several files, each taking a deterministic 1-of-N slice.
+ *
+ * @param base which base's permutations this file runs
+ * @param slice which 1-of-N slice of the permutations this file runs
+ */
+export function testPermutations(
+  base: (typeof bases)[number],
+  slice: { index: number; total: number } = { index: 0, total: 1 },
+) {
+  const {
+    type,
+    applicableLayers,
+    eachPermutation: allPermutations,
+  } = eachBase.find((b) => b.name === base)!;
+
+  const eachPermutation = allPermutations.filter((_, i) => i % slice.total === slice.index);
+
+  describe(base, () => {
+    describe.each(eachPermutation)("layers: $name", ({ permutation }) => {
+      let project: Project;
+      let layerNames = permutation.filter((x) => x !== baseline);
+      let startingLayers = layers.filter((layer) => layerNames.includes(layer.name));
+
+      beforeAll(async () => {
+        project = await generate({
+          type,
+          layers: layerNames,
+        });
+      });
+
+      afterAll(async () => {
+        if (process.env.CI) {
+          return;
+        }
+
+        if (project?.directory) {
+          await rm(project.directory, {
+            recursive: true,
+            force: true,
+            maxRetries: 3,
+            retryDelay: 100,
+          });
+        }
+      });
+
+      it("successfully setup the layers", async () => {
+        if (startingLayers.length === 0) {
+          // TODO: test baseline stuff more?
+          expect(true, "No layers to verify").toBe(true);
+        }
+
+        for (let layer of startingLayers) {
+          expect(layer.isSetup, `has isSetup for ${layer.name}`).toBeInstanceOf(Function);
+
+          let result = await layer.isSetup(project);
+
+          expect(result, `${layer.name} is setup`).toBe(true);
+        }
+      });
+
+      /**
+       * Are these valuable? no one would invoke the layers like this
+       */
+      // describe.skip("(re)applying", () => {
+      //   for (let layer of layers) {
+      //     if (RE_APPLY_ONLY.size > 0 && !RE_APPLY_ONLY.has(layer.name)) {
+      //       continue;
+      //     }
+
+      //     if (TODO.has(layer.name)) {
+      //       continue;
+      //     }
+
+      //     describe(layer.name, () => {
+      //       let expected = startingLayers.find((l) => l.name === layer.name);
+
+      //       beforeAll(async () => {
+      //         await layer.run(project);
+      //       });
+
+      //       if (expected) {
+      //         it("is applied", async () => {
+      //           expect(layer.isSetup, `has isSetup for ${layer.name}`).toBeInstanceOf(Function);
+
+      //           let result = await layer.isSetup(project, true);
+
+      //           if (typeof result === "object") {
+      //             expect(result.reasons, `${layer.name} is setup`).deep.equal([]);
+      //             expect(result.isSetup, `${layer.name} is setup`).toBe(true);
+      //             return;
+      //           }
+
+      //           expect(result, `${layer.name} is setup`).toBe(true);
+
+      //           return;
+      //         });
+      //       } else {
+      //         it("is not applied", async () => {
+      //           expect(layer.isSetup, `has isSetup for ${layer.name}`).toBeInstanceOf(Function);
+
+      //           let result = await layer.isSetup(project, true);
+
+      //           if (typeof result === "object") {
+      //             expect(result.isSetup, `${layer.name} is not setup`).toBe(false);
+      //             hardExpect(result.reasons.length, `${layer.name} is not setup`).toBeGreaterThan(0);
+      //             return;
+      //           }
+
+      //           expect(result, `${layer.name} is not setup`).toBe(false);
+      //         });
+      //       }
+      //     });
+      //   }
+      // });
+
+      /**
+       * Simulates running the CLI again with different options selected
+       * on the same project
+       */
+      describe("apply anew", () => {
+        let newLayers = applicableLayers
+          .filter((layer) => {
+            if (RE_APPLY_ONLY.size > 0 && !RE_APPLY_ONLY.has(layer.name)) {
+              return false;
+            }
+
+            if (TODO.has(layer.name)) {
+              return false;
+            }
+
+            return true;
+          })
+          .map((layer) => ({ name: layer.name, layer }));
+
+        describe.each(newLayers)("$name", ({ layer }) => {
+          beforeAll(async () => {
+            // Simulate running the CLI again, adding one more option while
+            // keeping the previously-selected layers.
+            await reapply(project, [...new Set([...layerNames, layer.name])]);
+          });
+
+          it.for(startingLayers)("starting layers still present: $name", async (layer) => {
+            expect(layer.isSetup, `has isSetup for ${layer.name}`).toBeInstanceOf(Function);
+
+            let result = await layer.isSetup(project, true);
+
+            if (typeof result === "object") {
+              expect(result.reasons, `${layer.name} is setup`).deep.equal([]);
+              expect(result.isSetup, `${layer.name} is setup`).toBe(true);
+              return;
+            }
+
+            expect(result, `${layer.name} is setup`).toBe(true);
+          });
+
+          it("is applied", async () => {
+            expect(layer.isSetup, `has isSetup for ${layer.name}`).toBeInstanceOf(Function);
+
+            let result = await layer.isSetup(project, true);
+
+            if (typeof result === "object") {
+              expect(result.reasons, `${layer.name} is setup`).deep.equal([]);
+              expect(result.isSetup, `${layer.name} is setup`).toBe(true);
+              return;
+            }
+
+            expect(result, `${layer.name} is setup`).toBe(true);
+
+            return;
+          });
+        });
+      });
+    });
+  });
+}

package/test/ember.nvp/rewrite-imports.test.ts

@@ -0,0 +1,235 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+
+import { rewriteImportsToMatchFiles } from "#utils/rewrite-imports.js";
+
+/**
+ * Generation renames files (e.g. type removal turns .ts into .js), so
+ * import specifiers are checked against the emitted project tree:
+ * whatever file actually exists on disk wins.
+ */
+describe("rewriteImportsToMatchFiles", () => {
+  const dirs: string[] = [];
+
+  afterEach(async () => {
+    for (const dir of dirs.splice(0)) {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  /**
+   * Lays out an emitted-project fixture on disk (the way generation
+   * stages real files) and returns its root.
+   */
+  async function makeProject(files: Record<string, string>) {
+    const dir = await mkdtemp(join(tmpdir(), "rewrite-imports-test-"));
+    dirs.push(dir);
+
+    for (const [path, contents] of Object.entries(files)) {
+      await mkdir(join(dir, dirname(path)), { recursive: true });
+      await writeFile(join(dir, path), contents);
+    }
+
+    return dir;
+  }
+
+  const manifest = JSON.stringify({
+    name: "fixture",
+    imports: {
+      "#app/*": "./app/*",
+      "#config": "./app/config.js",
+    },
+  });
+
+  it("rewrites a specifier whose file was renamed", async () => {
+    const project = await makeProject({
+      "package.json": manifest,
+      "app/app.js": "",
+      "app/config.js": "",
+    });
+
+    const result = rewriteImportsToMatchFiles(
+      [`import Application from "#app/app.ts";`, `import config from "#config";`].join("\n"),
+      join(project, "tests/test-helper.js"),
+    );
+
+    expect(result).toMatchInlineSnapshot(`
+      "import Application from "#app/app.js";
+      import config from "#config";"
+    `);
+  });
+
+  it("leaves a specifier alone when its file exists as written", async () => {
+    const project = await makeProject({
+      "package.json": manifest,
+      "app/helpers/x.ts": "",
+    });
+
+    const result = rewriteImportsToMatchFiles(
+      `import x from "./helpers/x.ts";`,
+      join(project, "app/consumer.ts"),
+    );
+
+    expect(result).toMatchInlineSnapshot(`"import x from "./helpers/x.ts";"`);
+  });
+
+  it("adds the on-disk extension to extensionless local imports", async () => {
+    const project = await makeProject({
+      "package.json": manifest,
+      "app/helpers/x.js": "",
+      "app/app.ts": "",
+    });
+
+    const result = rewriteImportsToMatchFiles(
+      [`import x from "./helpers/x";`, `import Application from "#app/app";`].join("\n"),
+      join(project, "app/consumer.js"),
+    );
+
+    expect(result).toMatchInlineSnapshot(`
+      "import x from "./helpers/x.js";
+      import Application from "#app/app.ts";"
+    `);
+  });
+
+  it("keeps an extensionless specifier whose fully-specified form would not map", async () => {
+    const project = await makeProject({
+      "package.json": manifest,
+      "app/config.js": "",
+    });
+
+    // `#config` maps to "./app/config.js" -- the extension lives in the
+    // `imports` target, so "#config.js" would not resolve
+    const result = rewriteImportsToMatchFiles(
+      `import config from "#config";`,
+      join(project, "app/consumer.js"),
+    );
+
+    expect(result).toMatchInlineSnapshot(`"import config from "#config";"`);
+  });
+
+  it("rewrites relative, re-export, and dynamic import() specifiers", async () => {
+    const project = await makeProject({
+      "package.json": manifest,
+      "app/thing.js": "",
+      "shared/other.js": "",
+      "app/lazy.js": "",
+    });
+
+    const result = rewriteImportsToMatchFiles(
+      [
+        `export { thing } from "./thing.ts";`,
+        `export * from "../shared/other.ts";`,
+        `export async function load() {`,
+        `  return await import("./lazy.ts");`,
+        `}`,
+      ].join("\n"),
+      join(project, "app/consumer.js"),
+    );
+
+    expect(result).toMatchInlineSnapshot(`
+      "export { thing } from "./thing.js";
+      export * from "../shared/other.js";
+      export async function load() {
+        return await import("./lazy.js");
+      }"
+    `);
+  });
+
+  it("leaves a specifier alone when no file matches at all", async () => {
+    const project = await makeProject({
+      "package.json": manifest,
+    });
+
+    const result = rewriteImportsToMatchFiles(
+      `import missing from "./does-not-exist.ts";`,
+      join(project, "app/consumer.js"),
+    );
+
+    expect(result).toMatchInlineSnapshot(`"import missing from "./does-not-exist.ts";"`);
+  });
+
+  it("leaves package specifiers and non-import strings alone", async () => {
+    const project = await makeProject({
+      "package.json": manifest,
+      "app/looks-like-a-file.js": "",
+    });
+
+    const result = rewriteImportsToMatchFiles(
+      [`import lib from "some-lib/file.ts";`, `const notAnImport = "./looks-like-a-file.ts";`].join(
+        "\n",
+      ),
+      join(project, "app/consumer.js"),
+    );
+
+    expect(result).toMatchInlineSnapshot(`
+      "import lib from "some-lib/file.ts";
+      const notAnImport = "./looks-like-a-file.ts";"
+    `);
+  });
+
+  it("rewrites imports in gjs files while preserving the template", async () => {
+    const project = await makeProject({
+      "package.json": manifest,
+      "app/components/button.gjs": "",
+    });
+
+    const result = rewriteImportsToMatchFiles(
+      [
+        `import Component from "@glimmer/component";`,
+        `import Button from "./button.gts";`,
+        ``,
+        `export default class Foo extends Component {`,
+        `  <template>`,
+        `    <Button />`,
+        `  </template>`,
+        `}`,
+      ].join("\n"),
+      join(project, "app/components/foo.gjs"),
+    );
+
+    expect(result).toMatchInlineSnapshot(`
+      "import Component from "@glimmer/component";
+      import Button from "./button.gjs";
+      export default class Foo extends Component {
+        <template><Button /></template>
+      }"
+    `);
+  });
+
+  it("keeps comments in files whose imports are rewritten", async () => {
+    const project = await makeProject({
+      "package.json": manifest,
+      "app/app.js": "",
+    });
+
+    const result = rewriteImportsToMatchFiles(
+      [
+        `// top comment`,
+        `import Application from "#app/app.ts";`,
+        ``,
+        `/**`,
+        ` * doc comment for start`,
+        ` */`,
+        `export function start() {`,
+        `  // inner comment`,
+        `  Application.create();`,
+        `}`,
+      ].join("\n"),
+      join(project, "tests/test-helper.js"),
+    );
+
+    expect(result).toMatchInlineSnapshot(`
+      "// top comment
+      import Application from "#app/app.js";
+      /**
+       * doc comment for start
+       */
+      export function start() {
+        // inner comment
+        Application.create();
+      }"
+    `);
+  });
+});