ember.nvp 0.5.0 → 0.7.0

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

@@ -0,0 +1,179 @@
+import { describe, it, expect } from "vitest";
+
+import { hasInspectorSupport, wireInspectorSupport } from "#utils/inspector-support.js";
+
+/**
+ * The Application definition is found structurally, so every shape an app
+ * author may have refactored their app file into gets wired the same way
+ * the freshly generated shape does.
+ */
+describe("wireInspectorSupport", () => {
+  it("wires the generated shape (export default class extends Application)", () => {
+    const code = [
+      `import Application from "ember-strict-application-resolver";`,
+      ``,
+      `export default class App extends Application {`,
+      `  modules = {`,
+      `    ...import.meta.glob("./router.*", { eager: true }),`,
+      `  };`,
+      `}`,
+    ].join("\n");
+
+    expect(wireInspectorSupport(code, "app/app.ts")).toMatchInlineSnapshot(`
+      "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 }) };
+        inspector = setupInspector(this);
+      }"
+    `);
+  });
+
+  it("wires a named class exported in a separate statement", () => {
+    const code = [
+      `import Application from "ember-strict-application-resolver";`,
+      ``,
+      `class App extends Application {`,
+      `  modules = {};`,
+      `}`,
+      ``,
+      `export default App;`,
+    ].join("\n");
+
+    expect(wireInspectorSupport(code, "app/app.js")).toMatchInlineSnapshot(`
+      "import Application from "ember-strict-application-resolver";
+      import setupInspector from "@embroider/legacy-inspector-support/ember-source-4.12";
+      class App extends Application {
+        modules = {  };
+        inspector = setupInspector(this);
+      }
+      export default App"
+    `);
+  });
+
+  it("wires an anonymous default-exported class", () => {
+    const code = [
+      `import Application from "ember-strict-application-resolver";`,
+      ``,
+      `export default class extends Application {}`,
+    ].join("\n");
+
+    expect(wireInspectorSupport(code, "app/app.js")).toMatchInlineSnapshot(`
+      "import Application from "ember-strict-application-resolver";
+      import setupInspector from "@embroider/legacy-inspector-support/ember-source-4.12";
+      export default class extends Application {
+        inspector = setupInspector(this);
+      }"
+    `);
+  });
+
+  it("wires a class expression assigned to a variable", () => {
+    const code = [
+      `import Application from "ember-strict-application-resolver";`,
+      ``,
+      `const App = class extends Application {`,
+      `  modules = {};`,
+      `};`,
+      ``,
+      `export default App;`,
+    ].join("\n");
+
+    expect(wireInspectorSupport(code, "app/app.js")).toMatchInlineSnapshot(`
+      "import Application from "ember-strict-application-resolver";
+      import setupInspector from "@embroider/legacy-inspector-support/ember-source-4.12";
+      const App = class extends Application {
+        modules = {  };
+        inspector = setupInspector(this);
+      };
+      export default App"
+    `);
+  });
+
+  it("wires a class extending @ember/application under a renamed import", () => {
+    const code = [
+      `import Base from "@ember/application";`,
+      ``,
+      `export default class App extends Base {}`,
+    ].join("\n");
+
+    expect(wireInspectorSupport(code, "app/app.ts")).toMatchInlineSnapshot(`
+      "import Base from "@ember/application";
+      import setupInspector from "@embroider/legacy-inspector-support/ember-source-4.12";
+      export default class App extends Base {
+        inspector = setupInspector(this);
+      }"
+    `);
+  });
+
+  it("adds only the missing member when the import is already present", () => {
+    const code = [
+      `import wireUp from "@embroider/legacy-inspector-support/ember-source-4.12";`,
+      `import Application from "ember-strict-application-resolver";`,
+      ``,
+      `export default class App extends Application {}`,
+    ].join("\n");
+
+    expect(wireInspectorSupport(code, "app/app.ts")).toMatchInlineSnapshot(`
+      "import wireUp from "@embroider/legacy-inspector-support/ember-source-4.12";
+      import Application from "ember-strict-application-resolver";
+      export default class App extends Application {
+        inspector = wireUp(this);
+      }"
+    `);
+  });
+
+  it("is idempotent", () => {
+    const code = [
+      `import Application from "ember-strict-application-resolver";`,
+      ``,
+      `export default class App extends Application {`,
+      `  modules = {};`,
+      `}`,
+    ].join("\n");
+
+    const once = wireInspectorSupport(code, "app/app.ts");
+    const twice = wireInspectorSupport(once, "app/app.ts");
+
+    expect(twice).toBe(once);
+  });
+
+  it("leaves a module without an Application definition alone", () => {
+    const code = [`export function noApplicationHere() {}`, ``].join("\n");
+
+    expect(wireInspectorSupport(code, "app/app.js")).toBe(code);
+  });
+
+  it("leaves a class that does not extend an Application import alone", () => {
+    const code = [
+      `import Component from "@glimmer/component";`,
+      ``,
+      `export default class App extends Component {}`,
+    ].join("\n");
+
+    expect(wireInspectorSupport(code, "app/app.ts")).toBe(code);
+  });
+});
+
+describe("hasInspectorSupport", () => {
+  it("is false before wiring and true after", () => {
+    const code = [
+      `import Application from "ember-strict-application-resolver";`,
+      ``,
+      `export default class App extends Application {}`,
+    ].join("\n");
+
+    expect(hasInspectorSupport(code, "app/app.ts")).toBe(false);
+    expect(hasInspectorSupport(wireInspectorSupport(code, "app/app.ts"), "app/app.ts")).toBe(true);
+  });
+
+  it("is false when only the import is present", () => {
+    const code = [
+      `import setupInspector from "@embroider/legacy-inspector-support/ember-source-4.12";`,
+      `import Application from "ember-strict-application-resolver";`,
+      ``,
+      `export default class App extends Application {}`,
+    ].join("\n");
+
+    expect(hasInspectorSupport(code, "app/app.ts")).toBe(false);
+  });
+});

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,103 @@
+import { describe, it, beforeAll, afterAll, expect } from "vitest";
+import { generate } 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, 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 () => {
+      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, 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 () => {
+      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]");
+    });
+  });
+});