test: migrate the minimal project e2e test

Author: dianjuar

packages/ngx-deploy-npm-e2e/src/ngx-deploy-npm.spec.ts

@@ -0,0 +1,11 @@
+import { setup } from './utils';
+
+describe('ngx-deploy-npm', () => {
+  it('should be installed', async () => {
+    const { tearDown, executeCommand } = await setup([]);
+
+    expect(() => executeCommand('npm ls ngx-deploy-npm')).not.toThrow();
+
+    return tearDown();
+  }, 120000);
+});

packages/ngx-deploy-npm-e2e/src/package-installation.spec.ts

@@ -0,0 +1,21 @@
+import { uniq } from '@nx/plugin/testing';
+import { setup } from './utils';
+
+describe('Minimal Project', () => {
+  it('should publish the lib', async () => {
+    const { processedLibs, tearDown, executeCommand } = await setup([
+      { name: uniq('minimal-lib'), generator: 'minimal' },
+    ]);
+    const [uniqLibName] = processedLibs;
+
+    executeCommand(
+      `npx nx deploy ${uniqLibName.name} --tag e2e --registry=http://localhost:4873`
+    );
+
+    expect(() => {
+      executeCommand(`npm view ${uniqLibName.npmPackageName}@e2e`);
+    }).not.toThrow();
+
+    return tearDown();
+  }, 120000);
+});

packages/ngx-deploy-npm-e2e/src/publish-minimal-lib.spec.ts

@@ -0,0 +1,221 @@
+import * as fs from 'fs';
+import { dirname, join } from 'path';
+import { execSync } from 'child_process';
+
+import { ProjectConfiguration } from '@nx/devkit';
+import { readJson } from '@nx/plugin/testing';
+
+import { currentNxVersion } from './get-nx-current-version';
+import { InstallGeneratorOptions } from 'bikecoders/ngx-deploy-npm';
+import {
+  generateLib,
+  initNgxDeployNPMProject,
+  installDependencies,
+  installNgxDeployNPMProject,
+} from '.';
+
+const mockDomian = '@mock-domain';
+
+const executeCommandFactory =
+  (projectDirectory: string) => (command: string) => {
+    let output: string;
+
+    try {
+      output = execSync(command, {
+        stdio: 'inherit',
+        cwd: projectDirectory,
+        encoding: 'utf-8',
+        env: process.env,
+      });
+    } catch (error) {
+      console.error(`Error executing command: ${command}`);
+      if (error instanceof Error && 'stderr' in error) {
+        console.error(error.stderr);
+      }
+      throw error;
+    }
+
+    return output;
+  };
+
+export const setup = async (
+  libs: {
+    name: string;
+    generator: 'minimal' | string;
+    installOptions?: Omit<
+      Partial<InstallGeneratorOptions>,
+      'distFolderPath' | 'project'
+    >;
+    skipInstall?: boolean;
+    extraOptions?: string;
+    distFolderPath?: string;
+  }[]
+) => {
+  const projectDirectory = await createTestProject();
+  const executeCommand = executeCommandFactory(projectDirectory);
+
+  initNgxDeployNPMProject(executeCommand);
+
+  // Install dependencies only once
+  const generators = new Set(
+    libs
+      .map(({ generator }) => generator)
+      .filter(generator => generator !== 'minimal')
+  );
+  generators.forEach(dependency => {
+    installDependencies(executeCommand, dependency);
+  });
+
+  // Init libs
+  await Promise.all(
+    libs.map(async ({ name, generator, extraOptions = '' }) => {
+      if (generator === 'minimal') {
+        await createMinimalLib(projectDirectory, name);
+      } else {
+        generateLib({
+          nxPlugin: generator,
+          executeCommand,
+          libName: name,
+          extraOptions: `--directory="libs/${name}" ${extraOptions}`,
+        });
+      }
+    })
+  );
+
+  // Install ngx-deploy-npm
+  libs
+    .filter(({ skipInstall }) => !!skipInstall === false)
+    .forEach(({ name, installOptions, generator }) => {
+      const optionGenerator = <T>(
+        optionaName: keyof InstallGeneratorOptions,
+        value?: T
+      ) => (value ? `--${optionaName}="${value}"` : '');
+
+      const installOptionsParsed = Object.entries(installOptions ?? {})
+        .map(([key, value]) =>
+          optionGenerator(key as keyof InstallGeneratorOptions, value)
+        )
+        .join(' ');
+
+      const distFolderPath =
+        generator === 'minimal'
+          ? getMinimalLibRoot(projectDirectory, name).libRoot
+          : `dist/libs/${name}`;
+
+      installNgxDeployNPMProject(
+        executeCommand,
+        `--project="${name}" --dist-folder-path="${distFolderPath}" ${installOptionsParsed}`
+      );
+    });
+
+  const processedLibs: {
+    name: string;
+    workspace: ProjectConfiguration;
+    npmPackageName: string;
+  }[] = libs.map(({ name }) => ({
+    name: name,
+    workspace: readJson(`${projectDirectory}/packages/${name}/project.json`),
+    npmPackageName: `${mockDomian}/${name}`,
+  }));
+
+  return {
+    processedLibs,
+    projectDirectory,
+    tearDown: async () => {
+      await fs.promises.rm(projectDirectory, {
+        recursive: true,
+        force: true,
+      });
+
+      return Promise.resolve();
+    },
+    executeCommand,
+  };
+};
+
+function getMinimalLibRoot(projectDirectory: string, libName: string) {
+  const libRoot = `packages/${libName}`;
+  const libRootAbsolutePath = join(projectDirectory, libRoot);
+
+  return { libRoot, libRootAbsolutePath };
+}
+
+async function createMinimalLib(projectDirectory: string, libName: string) {
+  // Create Lib
+  const { libRoot, libRootAbsolutePath } = getMinimalLibRoot(
+    projectDirectory,
+    libName
+  );
+
+  // Create the lib folder
+  await fs.promises.mkdir(libRootAbsolutePath, {
+    recursive: true,
+  });
+
+  const createProjectJsonPromise = fs.promises.writeFile(
+    join(libRootAbsolutePath, 'project.json'),
+    generateProjectJSON(libName, libRoot),
+    'utf8'
+  );
+  const createPackageJsonPromise = fs.promises.writeFile(
+    join(libRootAbsolutePath, 'package.json'),
+    generatePackageJSON(libName),
+    'utf8'
+  );
+  const createUniqueFilePromise = fs.promises.writeFile(
+    join(libRootAbsolutePath, 'hello-world.js'),
+    "console.log('Hello World!');",
+    'utf8'
+  );
+  await Promise.all([
+    createProjectJsonPromise,
+    createPackageJsonPromise,
+    createUniqueFilePromise,
+  ]);
+
+  return { libRoot };
+
+  function generateProjectJSON(projectName: string, libRoot: string): string {
+    const content = {
+      name: projectName,
+      $schema: '../../node_modules/nx/schemas/project-schema.json',
+      projectType: 'library',
+      sourceRoot: libRoot,
+    };
+
+    return JSON.stringify(content, null, 2);
+  }
+
+  function generatePackageJSON(projectName: string): string {
+    const content = {
+      name: `${mockDomian}/${projectName}`,
+      description: 'Minimal LIb',
+      version: '1.0.0',
+    };
+
+    return JSON.stringify(content, null, 2);
+  }
+}
+
+/**
+ * Creates a test project with create-nx-workspace and installs the plugin
+ * @returns The directory where the test project was created
+ */
+async function createTestProject() {
+  const projectName = 'test-project';
+  const projectDirectory = join(process.cwd(), 'tmp', projectName);
+
+  // Ensure projectDirectory is empty
+  await fs.promises.rm(projectDirectory, {
+    recursive: true,
+    force: true,
+  });
+  await fs.promises.mkdir(dirname(projectDirectory), {
+    recursive: true,
+  });
+
+  const command = `npx --yes create-nx-workspace@${currentNxVersion} ${projectName} --preset npm --nxCloud=skip --no-interactive`;
+  executeCommandFactory(dirname(projectDirectory))(command);
+
+  return projectDirectory;
+}

packages/ngx-deploy-npm-e2e/src/utils/basic-setup.ts

@@ -0,0 +1,24 @@
+type Options = {
+  nxPlugin: string;
+  libName: string;
+  executeCommand: (command: string) => void;
+  extraOptions?: string;
+  generator?: string;
+  setPublishableOption?: boolean;
+};
+
+export function generateLib({
+  nxPlugin,
+  libName,
+  executeCommand,
+  extraOptions,
+  generator = 'lib',
+  setPublishableOption = true,
+}: Options) {
+  const publishableOption = setPublishableOption ? '--publishable' : '';
+  const extraOptionsNormalized = extraOptions ? extraOptions : '';
+
+  executeCommand(
+    `npx nx generate ${nxPlugin}:${generator} --name ${libName} ${publishableOption} --importPath ${libName} ${extraOptionsNormalized}`
+  );
+}

packages/ngx-deploy-npm-e2e/src/utils/generate-lib.ts

@@ -0,0 +1,3 @@
+import packageJson from '../../../../package.json'; // This import style requires "esModuleInterop", see "side notes"
+
+export const currentNxVersion = packageJson.devDependencies['@nx/workspace'];

packages/ngx-deploy-npm-e2e/src/utils/get-nx-current-version.ts

@@ -0,0 +1,5 @@
+export * from './generate-lib';
+export * from './install-deps';
+export * from './utils-ngx-deploy-npm';
+export * from './get-nx-current-version';
+export * from './basic-setup';

packages/ngx-deploy-npm-e2e/src/utils/index.ts

@@ -0,0 +1,11 @@
+import { currentNxVersion } from './get-nx-current-version';
+
+export function installDependencies(
+  executeCommand: (command: string) => string,
+  nxPlugin: string
+) {
+  const packageToInstall = `${nxPlugin}@${currentNxVersion}`;
+
+  executeCommand(`npm add -D ${packageToInstall}`);
+  executeCommand(`npx nx g ${nxPlugin}:init`);
+}

packages/ngx-deploy-npm-e2e/src/utils/install-deps.ts

@@ -0,0 +1,13 @@
+export function initNgxDeployNPMProject(
+  executeCommand: (command: string) => void
+) {
+  executeCommand(`npm install ngx-deploy-npm@e2e`);
+}
+
+// TODO bring all the complexity generating the options to this function
+export function installNgxDeployNPMProject(
+  executeCommand: (command: string) => void,
+  options = ''
+) {
+  executeCommand(`npx nx generate ngx-deploy-npm:install ${options}`);
+}