ember.nvp 0.6.0 → 1.0.0

package/test/ember.nvp/layer-inspector-support.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, afterAll, expect } from "vitest";
+import { generate, build, expectIsSetup, layers } from "#test-helpers";
+import { execa } from "execa";
+import { readFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+
+const inspectorSupport = layers.find((layer) => layer.name === "inspector-support");
+
+describe("layer: inspector-support", () => {
+  const dirs: string[] = [];
+
+  afterAll(async () => {
+    if (process.env.CI) return;
+
+    for (const dir of dirs) {
+      await rm(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    }
+  });
+
+  it("wires a TypeScript app, which still builds", async () => {
+    const project = await generate({ type: "app", layers: ["typescript", "inspector-support"] });
+    dirs.push(project.directory);
+
+    expect(inspectorSupport).toBeTruthy();
+    await expectIsSetup(project, inspectorSupport!);
+
+    const install = await execa("pnpm install", { cwd: project.directory, shell: true });
+    expect(install.exitCode).toBe(0);
+
+    const result = await build(project);
+    expect(result.exitCode).toBe(0);
+  });
+
+  it("wires a JavaScript app (no typescript layer), which still builds", async () => {
+    const project = await generate({ type: "app", layers: ["inspector-support"] });
+    dirs.push(project.directory);
+
+    expect(inspectorSupport).toBeTruthy();
+    await expectIsSetup(project, inspectorSupport!);
+
+    const appFile = await readFile(join(project.directory, "app/app.js"), "utf8");
+    expect(appFile).toMatchInlineSnapshot(`
+      "/**
+       * Looking for services that come from addons?
+       *
+       * See: https://github.com/embroider-build/embroider/issues/2659
+       *
+       * We currently don't support app-tree merging from libraries.
+       *
+       * For services, I highly recommend looking in to either of
+       * - https://github.com/chancancode/ember-polaris-service-
+       * - https://ember-primitives.pages.dev/6-utils/createService.md
+       *   - https://ember-primitives.pages.dev/6-utils/createAsyncService.md
+       */
+      import Application from 'ember-strict-application-resolver';
+      import setupInspector from "@embroider/legacy-inspector-support/ember-source-4.12";
+      export default class App extends Application {
+        modules = { ...import.meta.glob('./router.*', { eager: true }), ...import.meta.glob('./templates/**/*', { eager: true }), ...import.meta.glob('./services/**/*', { eager: true }) };
+        inspector = setupInspector(this);
+      }"
+    `);
+
+    const install = await execa("pnpm install", { cwd: project.directory, shell: true });
+    expect(install.exitCode).toBe(0);
+
+    const result = await build(project);
+    expect(result.exitCode).toBe(0);
+  });
+});

package/test/ember.nvp/layer-publish-checks.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, beforeAll, afterAll, expect } from "vitest";
+import { generate, pinYukuParser } from "#test-helpers";
+import { execa } from "execa";
+import { readFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+
+import type { Project } from "ember.nvp";
+
+/**
+ * publint and are-the-types-wrong run inside the library's own build
+ * (tsdown), so the real assertion is their report lines in `pnpm build`
+ * output.
+ */
+
+async function read(project: Project, filePath: string): Promise<string> {
+  return readFile(join(project.directory, filePath), "utf-8");
+}
+
+describe("layers: publint + are-the-types-wrong", () => {
+  const dirs: string[] = [];
+
+  afterAll(async () => {
+    if (process.env.CI) return;
+
+    for (const dir of dirs) {
+      await rm(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    }
+  });
+
+  describe("TypeScript library", () => {
+    let project: Project;
+
+    beforeAll(async () => {
+      project = await generate({
+        type: "library",
+        name: "my-lib",
+        layers: ["typescript", "publint", "are-the-types-wrong"],
+      });
+      dirs.push(project.directory);
+    });
+
+    it("wires both checks into the build", async () => {
+      expect(await read(project, "tsdown.config.js")).toMatchInlineSnapshot(`
+        "import { defineConfig } from "tsdown";
+        import { ember } from "@nullvoxpopuli/ember-rolldown";
+        export default defineConfig({ entry: ["./src/index.ts"], plugins: [ember()], attw: { profile: "esm-only" }, publint: true })"
+      `);
+    });
+
+    it("both checks run and pass in the build", async () => {
+      await pinYukuParser(project);
+
+      let install = await execa("pnpm install", { cwd: project.directory, shell: true });
+      expect(install.exitCode).toBe(0);
+
+      let build = await execa("pnpm build", {
+        cwd: project.directory,
+        shell: true,
+        all: true,
+        // assertions match the report lines as plain text
+        env: { FORCE_COLOR: "0" },
+      });
+      expect(build.exitCode).toBe(0);
+
+      expect(build.all).toContain("[publint] No issues found");
+      expect(build.all).toContain("[attw] No problems found");
+    });
+  });
+
+  describe("JavaScript library", () => {
+    let project: Project;
+
+    beforeAll(async () => {
+      project = await generate({
+        type: "library",
+        name: "my-lib",
+        layers: ["publint", "are-the-types-wrong"],
+      });
+      dirs.push(project.directory);
+    });
+
+    it("wires publint only (no declarations to check)", async () => {
+      expect(await read(project, "tsdown.config.js")).toMatchInlineSnapshot(`
+        "import { defineConfig } from "tsdown";
+        import { ember } from "@nullvoxpopuli/ember-rolldown";
+        export default defineConfig({ entry: ["./src/index.js"], dts: false, plugins: [ember()], publint: true })"
+      `);
+    });
+
+    it("publint runs and passes in the build", async () => {
+      await pinYukuParser(project);
+
+      let install = await execa("pnpm install", { cwd: project.directory, shell: true });
+      expect(install.exitCode).toBe(0);
+
+      let build = await execa("pnpm build", {
+        cwd: project.directory,
+        shell: true,
+        all: true,
+        // assertions match the report lines as plain text
+        env: { FORCE_COLOR: "0" },
+      });
+      expect(build.exitCode).toBe(0);
+
+      expect(build.all).toContain("[publint] No issues found");
+      expect(build.all).not.toContain("[attw]");
+    });
+  });
+});

package/test/ember.nvp/layer-qunit.test.ts

@@ -1,15 +1,141 @@
-import { describe, it, afterAll, expect } from "vitest";
-import { generate } from "#test-helpers";
-import { rimraf } from "rimraf";
+import { describe, it, beforeAll, afterAll, expect } from "vitest";
+import { generate, pinYukuParser } from "#test-helpers";
+import { writeLibrarySource } from "./library-src-fixtures.ts";
 import { execa } from "execa";
+import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join, relative, sep } from "node:path";
+
+import type { Project } from "ember.nvp";
+
+async function listFiles(directory: string): Promise<string[]> {
+  const entries = await readdir(directory, { withFileTypes: true, recursive: true });
+
+  return entries
+    .filter((entry) => entry.isFile())
+    .map((entry) => relative(directory, join(entry.parentPath, entry.name)))
+    .filter((path) => !path.split(sep).includes("node_modules"))
+    .filter((path) => !path.startsWith(`dist${sep}`))
+    .sort();
+}
+
+async function read(project: Project, filePath: string): Promise<string> {
+  return readFile(join(project.directory, filePath), "utf-8");
+}
+
+async function installAndTest(project: Project) {
+  await pinYukuParser(project);
+
+  let install = await execa("pnpm install", { cwd: project.directory, shell: true });
+  expect(install.exitCode).toBe(0);
+
+  let test = await execa("pnpm test", { cwd: project.directory, shell: true });
+  expect(test.exitCode).toBe(0);
+}
 
 /**
- * The replace-or-update question only matters when a project already exists
- * at the target path. These tests generate a project, assert the baseline
- * state, then regenerate over it the way the CLI does once the user has
- * answered the question, and assert the resulting project output is correct
- * for each answer.
+ * The layer ships testing infrastructure only; the tests exercising the
+ * base's example exports are generated here, in both flavors.
  */
+const exampleTests = {
+  typescript: {
+    "tests/rendering/greeting-test.gts": `import { render } from "@ember/test-helpers";
+import { module, test } from "qunit";
+import { setupRenderingTest } from "ember-qunit";
+
+import Greeting from "#src/components/greeting.gts";
+
+module("Rendering | Greeting", function (hooks) {
+  setupRenderingTest(hooks);
+
+  test("it renders", async function (assert) {
+    await render(<template><Greeting @name="Tomster" /></template>);
+
+    assert.dom("p").hasText("Hello, Tomster!");
+  });
+});
+`,
+    "tests/rendering/badge-test.gts": `import { render } from "@ember/test-helpers";
+import { module, test } from "qunit";
+import { setupRenderingTest } from "ember-qunit";
+
+import { Badge } from "#src/components/badge.gts";
+
+module("Rendering | Badge", function (hooks) {
+  setupRenderingTest(hooks);
+
+  test("it renders its content", async function (assert) {
+    await render(<template><Badge>New</Badge></template>);
+
+    assert.dom("span.badge").hasText("New");
+  });
+});
+`,
+    "tests/unit/math-test.ts": `import { module, test } from "qunit";
+
+import { add } from "#src/utils/math.ts";
+
+module("Unit | add", function () {
+  test("adds two numbers", function (assert) {
+    assert.strictEqual(add(1, 2), 3);
+  });
+});
+`,
+  },
+  javascript: {
+    "tests/rendering/greeting-test.gjs": `import { render } from "@ember/test-helpers";
+import { module, test } from "qunit";
+import { setupRenderingTest } from "ember-qunit";
+
+import Greeting from "#src/components/greeting.gjs";
+
+module("Rendering | Greeting", function (hooks) {
+  setupRenderingTest(hooks);
+
+  test("it renders", async function (assert) {
+    await render(<template><Greeting @name="Tomster" /></template>);
+
+    assert.dom("p").hasText("Hello, Tomster!");
+  });
+});
+`,
+    "tests/rendering/badge-test.gjs": `import { render } from "@ember/test-helpers";
+import { module, test } from "qunit";
+import { setupRenderingTest } from "ember-qunit";
+
+import { Badge } from "#src/components/badge.gjs";
+
+module("Rendering | Badge", function (hooks) {
+  setupRenderingTest(hooks);
+
+  test("it renders its content", async function (assert) {
+    await render(<template><Badge>New</Badge></template>);
+
+    assert.dom("span.badge").hasText("New");
+  });
+});
+`,
+    "tests/unit/math-test.js": `import { module, test } from "qunit";
+
+import { add } from "#src/utils/math.js";
+
+module("Unit | add", function () {
+  test("adds two numbers", function (assert) {
+    assert.strictEqual(add(1, 2), 3);
+  });
+});
+`,
+  },
+};
+
+async function writeExampleTests(project: Project, flavor: keyof typeof exampleTests) {
+  for (let [filePath, contents] of Object.entries(exampleTests[flavor])) {
+    let target = join(project.directory, filePath);
+
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, contents);
+  }
+}
+
 describe("layer: qunit", () => {
   const dirs: string[] = [];
 
@@ -17,18 +143,257 @@ describe("layer: qunit", () => {
     if (process.env.CI) return;
 
     for (const dir of dirs) {
-      await rimraf(dir, { maxRetries: 3, retryDelay: 100 });
+      await rm(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
     }
   });
 
-  it("it boots and run tests", async () => {
-    const project = await generate({ type: "app", layers: ["qunit"] });
-    dirs.push(project.directory);
+  describe("app", () => {
+    it("it boots and run tests", async () => {
+      const project = await generate({ type: "app", layers: ["qunit"] });
+      dirs.push(project.directory);
+
+      await installAndTest(project);
+    });
+  });
+
+  describe("library (TypeScript)", () => {
+    let project: Project;
+
+    beforeAll(async () => {
+      project = await generate({
+        type: "library",
+        name: "my-lib",
+        layers: ["qunit", "typescript"],
+      });
+      dirs.push(project.directory);
+    });
+
+    it("generates the expected files, without any index.html", async () => {
+      let files = await listFiles(project.directory);
+
+      expect(files.some((file) => file.endsWith("index.html"))).toBe(false);
+      expect(files).toMatchInlineSnapshot(`
+        [
+          ".gitignore",
+          "README.md",
+          "config/test/babel.config.js",
+          "config/test/testem.cjs",
+          "package.json",
+          "src/index.ts",
+          "tests/rendering/.gitkeep",
+          "tests/test-helper.ts",
+          "tests/unit/.gitkeep",
+          "tsconfig.json",
+          "tsdown.config.js",
+          "vite.config.mjs",
+        ]
+      `);
+    });
+
+    it("generates the test build config", async () => {
+      expect(await read(project, "vite.config.mjs")).toMatchInlineSnapshot(`
+        "import { defineConfig } from "vite";
+        import { ember } from "@nullvoxpopuli/ember-vite";
+
+        export default defineConfig({
+          plugins: [ember({ babel: { configFile: "./config/test/babel.config.js" } })],
+        });
+        "
+      `);
+      expect(await read(project, "config/test/babel.config.js")).toMatchInlineSnapshot(`
+        "import { buildMacros } from "@embroider/macros/babel";
+
+        const macros = buildMacros({
+          configure(config) {
+            if (process.env.EMBER_ENV === "test") {
+              config.enableRuntimeMode();
+            }
+          },
+        });
+
+        export default {
+          plugins: [
+            [
+              "@babel/plugin-transform-typescript",
+              {
+                allExtensions: true,
+                onlyRemoveTypeImports: true,
+                allowDeclareFields: true,
+              },
+            ],
+            [
+              "babel-plugin-ember-template-compilation",
+              {
+                transforms: [...macros.templateMacros],
+              },
+            ],
+            [
+              "module:decorator-transforms",
+              {
+                runtime: {
+                  import: import.meta.resolve("decorator-transforms/runtime-esm"),
+                },
+              },
+            ],
+            ...macros.babelMacros,
+          ],
+
+          generatorOpts: {
+            compact: false,
+          },
+        };
+        "
+      `);
+      expect(await read(project, "config/test/testem.cjs")).toMatchInlineSnapshot(`
+        ""use strict";
+
+        if (typeof module !== "undefined") {
+          module.exports = {
+            test_page: "tests/index.html?hidepassed",
+            cwd: "dist",
+            disable_watching: true,
+            launch_in_ci: ["Chrome"],
+            launch_in_dev: ["Chrome"],
+            browser_start_timeout: 120,
+            browser_args: {
+              Chrome: {
+                ci: [
+                  // --no-sandbox is needed when running Chrome inside a container
+                  process.env.CI ? "--no-sandbox" : null,
+                  "--headless",
+                  "--disable-dev-shm-usage",
+                  "--disable-software-rasterizer",
+                  "--mute-audio",
+                  "--remote-debugging-port=0",
+                  "--window-size=1440,900",
+                ].filter(Boolean),
+              },
+            },
+          };
+        }
+        "
+      `);
+    });
+
+    it("leaves the publish build config alone", async () => {
+      expect(await read(project, "tsdown.config.js")).toMatchInlineSnapshot(`
+        "import { defineConfig } from "tsdown";
+        import { ember } from "@nullvoxpopuli/ember-rolldown";
+
+        export default defineConfig({
+          entry: ["./src/index.ts"],
+          plugins: [ember()],
+        });
+        "
+      `);
+    });
+
+    it("installs, and tests generated against the library's exports pass", async () => {
+      await writeLibrarySource(project, "typescript");
+      await writeExampleTests(project, "typescript");
+      await installAndTest(project);
+    });
+
+    it("the publish build still ships precompileTemplate", async () => {
+      let build = await execa("pnpm build", { cwd: project.directory, shell: true });
+      expect(build.exitCode).toBe(0);
+
+      let output = await read(project, "dist/index.js");
+
+      expect(output).toContain("precompileTemplate");
+      expect(output).not.toContain("createTemplateFactory");
+    });
+  });
+
+  describe("library (JavaScript)", () => {
+    let project: Project;
+
+    beforeAll(async () => {
+      project = await generate({ type: "library", name: "my-lib", layers: ["qunit"] });
+      dirs.push(project.directory);
+    });
+
+    it("generates the expected files, without any index.html", async () => {
+      let files = await listFiles(project.directory);
+
+      expect(files.some((file) => file.endsWith("index.html"))).toBe(false);
+      expect(files).toMatchInlineSnapshot(`
+        [
+          ".gitignore",
+          "README.md",
+          "config/test/babel.config.js",
+          "config/test/testem.cjs",
+          "package.json",
+          "src/index.js",
+          "tests/rendering/.gitkeep",
+          "tests/test-helper.js",
+          "tests/unit/.gitkeep",
+          "tsdown.config.js",
+          "vite.config.mjs",
+        ]
+      `);
+    });
+
+    it("has no TypeScript leftovers in the test build config", async () => {
+      expect(await read(project, "config/test/babel.config.js")).toMatchInlineSnapshot(`
+        "import { buildMacros } from "@embroider/macros/babel";
+
+        const macros = buildMacros({
+          configure(config) {
+            if (process.env.EMBER_ENV === "test") {
+              config.enableRuntimeMode();
+            }
+          },
+        });
+
+        export default {
+          plugins: [[
+            "babel-plugin-ember-template-compilation",
+            {
+              transforms: [...macros.templateMacros],
+            },
+          ], [
+            "module:decorator-transforms",
+            {
+              runtime: {
+                import: import.meta.resolve("decorator-transforms/runtime-esm"),
+              },
+            },
+          ], ...macros.babelMacros],
+
+          generatorOpts: {
+            compact: false,
+          },
+        };
+        "
+      `);
+      expect(await read(project, "tsdown.config.js")).toMatchInlineSnapshot(`
+        "import { defineConfig } from "tsdown";
+        import { ember } from "@nullvoxpopuli/ember-rolldown";
+
+        export default defineConfig({
+          entry: ["./src/index.js"],
+          dts: false,
+          plugins: [ember()],
+        });
+        "
+      `);
+    });
+
+    it("installs, and tests generated against the library's exports pass", async () => {
+      await writeLibrarySource(project, "javascript");
+      await writeExampleTests(project, "javascript");
+      await installAndTest(project);
+    });
+
+    it("the publish build still ships precompileTemplate", async () => {
+      let build = await execa("pnpm build", { cwd: project.directory, shell: true });
+      expect(build.exitCode).toBe(0);
 
-    let install = await execa("pnpm install", { cwd: project.directory, shell: true });
-    expect(install.exitCode).toBe(0);
+      let output = await read(project, "dist/index.js");
 
-    let test = await execa("pnpm test", { cwd: project.directory, shell: true });
-    expect(test.exitCode).toBe(0);
+      expect(output).toContain("precompileTemplate");
+      expect(output).not.toContain("createTemplateFactory");
+    });
   });
 });