test(e2e): modernize plugin e2e harness and dist publish flow

.codex/environments/environment.toml

@@ -0,0 +1,6 @@
+# THIS IS AUTOGENERATED. DO NOT EDIT MANUALLY
+version = 1
+name = "nx-forge"
+
+[setup]
+script = "npm i"

e2e/nx-forge-e2e/project.json

@@ -7,10 +7,9 @@
     "e2e": {
       "executor": "@nx/jest:jest",
       "options": {
-        "jestConfig": "e2e/nx-forge-e2e/jest.config.js",
-        "runInBand": true
+        "jestConfig": "e2e/nx-forge-e2e/jest.config.js"
       },
-      "dependsOn": ["nx-forge:build"]
+      "dependsOn": ["^build"]
     }
   },
   "tags": [],

e2e/nx-forge-e2e/src/application.generator.spec.ts

@@ -0,0 +1,78 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { generateForgeApp } from './utils/generate-forge-app';
+import { runNxCommandAsync } from './utils/async-commands';
+import { cleanupTestProject, createTestProject } from './utils/test-project';
+
+describe('Forge application generator', () => {
+  let projectDirectory: string;
+
+  beforeAll(() => {
+    projectDirectory = createTestProject();
+  });
+
+  afterAll(async () => {
+    try {
+      if (projectDirectory) {
+        await runNxCommandAsync('reset', { cwd: projectDirectory });
+      }
+    } finally {
+      cleanupTestProject(projectDirectory);
+    }
+  });
+
+  it('should generate a Forge app', async () => {
+    const appName = await generateForgeApp({
+      cwd: projectDirectory,
+      directory: 'apps',
+      options: '--bundler=webpack',
+    });
+    expect(
+      existsSync(join(projectDirectory, 'apps', appName, 'manifest.yml'))
+    ).toBe(true);
+    expect(
+      existsSync(join(projectDirectory, 'apps', appName, 'webpack.config.js'))
+    ).toBe(true);
+    expect(
+      existsSync(join(projectDirectory, 'apps', appName, 'src', 'index.ts'))
+    ).toBe(true);
+  });
+
+  describe('--directory', () => {
+    it('should generate a Forge app in the specified directory', async () => {
+      const subdir = 'subdir';
+      const appName = await generateForgeApp({
+        cwd: projectDirectory,
+        directory: subdir,
+        options: `--bundler=webpack`,
+      });
+
+      expect(
+        existsSync(join(projectDirectory, subdir, appName, 'manifest.yml'))
+      ).toBe(true);
+      expect(
+        existsSync(join(projectDirectory, subdir, appName, 'webpack.config.js'))
+      ).toBe(true);
+      expect(
+        existsSync(join(projectDirectory, subdir, appName, 'src', 'index.ts'))
+      ).toBe(true);
+    });
+  });
+
+  describe('--tags', () => {
+    it('should generate a Forge app with tags added to the project', async () => {
+      const appName = await generateForgeApp({
+        cwd: projectDirectory,
+        directory: 'apps',
+        options: `--tags e2etag,e2ePackage`,
+      });
+      const project = JSON.parse(
+        readFileSync(
+          join(projectDirectory, 'apps', appName, 'project.json'),
+          'utf8'
+        )
+      );
+      expect(project.tags).toEqual(['e2etag', 'e2ePackage']);
+    });
+  });
+});

e2e/nx-forge-e2e/src/basic-setup.spec.ts

@@ -0,0 +1,183 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { GraphQLClient } from 'graphql-request';
+import { generateForgeApp } from './utils/generate-forge-app';
+import {
+  Credentials,
+  ForgeInstallationContext,
+  getCredentials,
+  getDeveloperSpaceId,
+  getForgeInstallationContext,
+} from './utils/config';
+import { createClient, deleteApp } from './utils/atlassian-graphql-client';
+import {
+  runCommandAsync,
+  runForgeCommandAsync,
+  runNxCommandAsync,
+} from './utils/async-commands';
+import {
+  cleanupTestProject,
+  createTestProject,
+} from './utils/test-project';
+import stripAnsi = require('strip-ansi');
+
+describe('Forge lifecycle', () => {
+  // initialize before all tests
+  let projectDirectory: string;
+  let developerCredentials: Credentials;
+  let apiClient: GraphQLClient;
+  let installationContext: ForgeInstallationContext;
+  let developerSpaceId: string;
+
+  beforeAll(async () => {
+    projectDirectory = createTestProject();
+    developerCredentials = getCredentials();
+    apiClient = createClient(developerCredentials);
+    installationContext = getForgeInstallationContext();
+    developerSpaceId = getDeveloperSpaceId();
+
+    // Initialize the Forge CLI, otherwise commands may fail due to expected interactive input
+    await runCommandAsync(`npx forge settings set usage-analytics false`, {
+      cwd: projectDirectory,
+      silenceError: true,
+    });
+  });
+
+  afterAll(async () => {
+    try {
+      if (projectDirectory) {
+        await runNxCommandAsync('reset', { cwd: projectDirectory });
+      }
+    } finally {
+      cleanupTestProject(projectDirectory);
+    }
+  });
+
+  it('should generate, build, package, register, deploy and install a Forge app', async () => {
+    const appName = await generateForgeApp({
+      cwd: projectDirectory,
+      directory: 'apps',
+    });
+
+    // Build
+
+    const nxBuildResult = await runNxCommandAsync(`run ${appName}:build`, {
+      cwd: projectDirectory,
+      silenceError: true,
+    });
+    expect(nxBuildResult.stderr).toEqual('');
+    expect(stripAnsi(nxBuildResult.stdout)).toContain(
+      'Successfully ran target build for project'
+    );
+
+    // Package
+
+    const nxPackageResult = await runNxCommandAsync(`run ${appName}:package`, {
+      cwd: projectDirectory,
+    });
+    expect(nxPackageResult.stderr).toEqual('');
+    expect(stripAnsi(nxPackageResult.stdout)).toEqual(
+      expect.stringContaining('Successfully ran target package for project')
+    );
+
+    // Register
+
+    const unregisteredOutputManifestContent = readFileSync(
+      join(projectDirectory, 'dist', 'apps', appName, 'manifest.yml'),
+      'utf8'
+    );
+    expect(unregisteredOutputManifestContent).toContain(
+      'ari:cloud:ecosystem::app/to-be-generated'
+    );
+
+    const nxRegisterResult = await runNxCommandAsync(
+      `run ${appName}:register --accept-terms --developer-space-id ${developerSpaceId}`,
+      {
+        cwd: projectDirectory,
+        silenceError: true,
+      }
+    );
+    expect(nxRegisterResult.stderr).toEqual('');
+    expect(stripAnsi(nxRegisterResult.stdout)).toContain(
+      'Forge app registered'
+    );
+
+    // ari:cloud:ecosystem::app/<uuid>
+    const registeredAppIdRegex =
+      /ari:cloud:ecosystem::app\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/;
+
+    const registeredOutputManifestContent = readFileSync(
+      join(projectDirectory, 'dist', 'apps', appName, 'manifest.yml'),
+      'utf8'
+    );
+    const [registeredAppId] =
+      registeredOutputManifestContent.match(registeredAppIdRegex) ?? [];
+    expect(registeredAppId).not.toBeNull();
+    expect(registeredAppId).toBeDefined();
+    expect(registeredAppId).not.toEqual('');
+
+    const projectManifestContent = readFileSync(
+      join(projectDirectory, 'apps', appName, 'manifest.yml'),
+      'utf8'
+    );
+    expect(projectManifestContent).toContain(registeredAppId);
+
+    try {
+      // Deploy
+
+      // Run with `--no-verfiy` because the generated blank app template causes linting errors
+      const nxDeployResult = await runNxCommandAsync(
+        `run ${appName}:deploy --no-verify`,
+        {
+          cwd: projectDirectory,
+          silenceError: true,
+        }
+      );
+      expect(nxDeployResult.stderr).toEqual('');
+      expect(stripAnsi(nxDeployResult.stdout)).toContain('Forge app deployed');
+
+      // Install using Forge CLI
+
+      const installResult = await runForgeCommandAsync(
+        `install --product=${installationContext.product} --site=${installationContext.siteUrl} --environment ${installationContext.environment} --non-interactive`,
+        {
+          cwd: join(projectDirectory, 'dist', 'apps', appName),
+          silenceError: true,
+        }
+      );
+      expect(installResult.stderr).toEqual('');
+      expect(stripAnsi(installResult.stdout)).toMatch(/Install.*complete/);
+    } finally {
+      if (registeredAppId) {
+        try {
+          await runForgeCommandAsync(
+            `uninstall --product=${installationContext.product} --site=${installationContext.siteUrl} --environment ${installationContext.environment} --non-interactive`,
+            {
+              cwd: join(projectDirectory, 'dist', 'apps', appName),
+              silenceError: true,
+            }
+          );
+        } catch (error) {
+          console.warn(
+            `Failed to uninstall Forge app ${registeredAppId}`,
+            error
+          );
+        }
+
+        try {
+          const result = await deleteApp(registeredAppId)(apiClient);
+          if (!result.success) {
+            console.warn(
+              `Failed to delete registered app ${registeredAppId}: ${result.errors}`
+            );
+          }
+        } catch (error) {
+          console.warn(
+            `Failed to delete registered app ${registeredAppId}`,
+            error
+          );
+        }
+      }
+    }
+  });
+});

e2e/nx-forge-e2e/tests/utils/async-commands.ts → e2e/nx-forge-e2e/src/utils/async-commands.ts

@@ -1,9 +1,5 @@
 import { exec } from 'child_process';
-import {
-  detectPackageManager,
-  getPackageManagerCommand,
-} from '@nx/devkit';
-import { tmpProjPath } from '@nx/plugin/testing';
+import { detectPackageManager, getPackageManagerCommand } from '@nx/devkit';
 
 const getCommandEnv = (env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv => {
   const commandEnv = { ...process.env, ...env };
@@ -17,7 +13,7 @@ const getCommandEnv = (env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv => {
 };
 
 /**
- * Runs the given command asynchronously inside the e2e directory (if cwd is not provided).
+ * Runs the given command asynchronously inside the provided working directory.
  *
  * This is a local re-implementation of the helper from `@nx/plugin/testing`
  * so the e2e suite can control the child process environment.
@@ -32,15 +28,13 @@ const getCommandEnv = (env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv => {
  */
 export const runCommandAsync = (
   command: string,
-  opts: { silenceError?: boolean; env?: NodeJS.ProcessEnv; cwd?: string } = {
-    silenceError: false,
-  }
+  opts: { cwd: string; silenceError?: boolean; env?: NodeJS.ProcessEnv }
 ): Promise<{ stdout: string; stderr: string }> => {
   return new Promise((resolve, reject) => {
     exec(
       command,
       {
-        cwd: opts.cwd ?? tmpProjPath(),
+        cwd: opts.cwd,
         env: getCommandEnv(opts.env),
         windowsHide: true,
       },
@@ -55,7 +49,7 @@ export const runCommandAsync = (
 };
 
 /**
- * Runs an Nx command asynchronously inside the e2e directory.
+ * Runs an Nx command asynchronously inside the provided working directory.
  *
  * This mirrors `runNxCommandAsync` from `@nx/plugin/testing`, but delegates to
  * the local `runCommandAsync` above so the same NO_COLOR cleanup is applied to
@@ -65,21 +59,17 @@ export const runCommandAsync = (
  */
 export const runNxCommandAsync = (
   command: string,
-  opts: { silenceError?: boolean; env?: NodeJS.ProcessEnv; cwd?: string } = {
-    silenceError: false,
-  }
+  opts: { cwd: string; silenceError?: boolean; env?: NodeJS.ProcessEnv }
 ): Promise<{ stdout: string; stderr: string }> => {
-  const cwd = opts.cwd ?? tmpProjPath();
-  const pmc = getPackageManagerCommand(detectPackageManager(cwd));
+  const pmc = getPackageManagerCommand(detectPackageManager(opts.cwd));
 
   return runCommandAsync(`${pmc.exec} nx ${command}`, {
     ...opts,
-    cwd,
   });
 };
 
 /**
- * Runs the given Forge CLI command asynchronously inside the e2e directory (if cwd is not provided).
+ * Runs the given Forge CLI command asynchronously inside the provided working directory.
  *
  * Note that this implementation is only meant to be used in testing code. It is using `exec`
  * to run the Forge CLI command. `exec` returns `stdout` and `stderr` as strings which is convenient
@@ -93,16 +83,14 @@ export const runNxCommandAsync = (
  */
 export const runForgeCommandAsync = (
   command: string,
-  opts: { silenceError?: boolean; env?: NodeJS.ProcessEnv; cwd?: string } = {
-    silenceError: false,
-  }
+  opts: { cwd: string; silenceError?: boolean; env?: NodeJS.ProcessEnv }
 ): Promise<{ stdout: string; stderr: string }> => {
   const pmc = getPackageManagerCommand();
   return new Promise((resolve, reject) => {
     exec(
       `${pmc.exec} forge ${command}`,
       {
-        cwd: opts.cwd ?? tmpProjPath(),
+        cwd: opts.cwd,
         env: getCommandEnv(opts.env),
       },
       (err, stdout, stderr) => {