chore: update-tests

update to make tests more robust for package-generator

Author: ryanbas21

tools/create-package/src/generators/create-package-generator.spec.ts

@@ -0,0 +1,214 @@
+import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing';
+import { Tree, installPackagesTask, formatFiles } from '@nx/devkit';
+import { createPackageGeneratorGenerator } from './create-package-generator';
+import { CreatePackageGeneratorGeneratorSchema } from './schema';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+// Mock installPackagesTask and formatFiles
+vi.mock('@nx/devkit', async () => {
+  const actual = await vi.importActual('@nx/devkit');
+  return {
+    ...actual,
+    installPackagesTask: vi.fn(),
+    formatFiles: vi.fn(),
+  };
+});
+
+describe('create-package-generator generator', () => {
+  let tree: Tree;
+  let options: CreatePackageGeneratorGeneratorSchema = { name: 'test' };
+
+  beforeEach(() => {
+    tree = createTreeWithEmptyWorkspace();
+    vi.clearAllMocks();
+  });
+
+  const getJson = (path: string) => {
+    const contents = tree.read(path) ?? new Buffer('');
+    const value = Buffer.from(contents).toString();
+
+    return JSON.parse(value);
+  };
+
+  it('should run successfully', async () => {
+    options = {
+      name: 'test-package',
+      packageScope: 'test',
+      description: 'I have written some code',
+      sideEffects: false,
+      outputDir: './dist',
+      moduleType: 'module',
+    };
+    const returnedFn = await createPackageGeneratorGenerator(tree, options);
+
+    expect(tree.exists('packages/test-package/package.json')).toBeTruthy();
+
+    const packageJson = getJson('packages/test-package/package.json');
+
+    expect(packageJson.name).toBe('@test/test-package');
+    expect(packageJson.sideEffects).toBe(false);
+    expect(packageJson.type).toBe('module');
+    expect(packageJson.description).toBe('I have written some code');
+    expect(packageJson.module).toBe('./dist/index.js');
+    expect(packageJson.exports).toEqual({
+      '.': './dist/index.js',
+      './package.json': './package.json',
+    });
+    expect(packageJson.dependencies).toEqual({});
+    expect(packageJson.devDependencies).toEqual({});
+    expect(packageJson.version).toBe('0.0.0');
+    expect(packageJson.private).toBe(true);
+    expect(packageJson.main).toBe('./dist/index.js');
+
+    expect(tree.exists('packages/test-package/src/index.ts')).toBe(true);
+    expect(tree.exists('packages/test-package/src/lib/index.ts')).toBe(true);
+    expect(tree.exists('packages/test-package/LICENSE')).toBe(true);
+
+    expect(typeof returnedFn).toBe('function');
+
+    returnedFn();
+    expect(installPackagesTask).toHaveBeenCalledTimes(1);
+    expect(installPackagesTask).toHaveBeenCalledWith(tree, true);
+  });
+
+  it('should have defaults that work', async () => {
+    options = {
+      name: 'test-package',
+    };
+    const installer = await createPackageGeneratorGenerator(tree, options);
+
+    expect(tree.exists('packages/test-package/package.json')).toBeTruthy();
+
+    const packageJson = getJson('packages/test-package/package.json');
+
+    expect(packageJson.name).toBe('@forgerock/test-package');
+    expect(packageJson.sideEffects).toBe(false);
+    expect(packageJson.type).toBe('module');
+    expect(packageJson.description).toBe('');
+    expect(packageJson.module).toBe('./dist/index.js');
+    expect(packageJson.exports).toEqual({
+      '.': './dist/index.js',
+      './package.json': './package.json',
+    });
+    expect(packageJson.dependencies).toEqual({});
+    expect(packageJson.devDependencies).toEqual({});
+    expect(packageJson.version).toBe('0.0.0');
+    expect(packageJson.private).toBe(true);
+    expect(packageJson.main).toBe('./dist/index.js');
+
+    expect(tree.exists('packages/test-package/src/index.ts')).toBe(true);
+    expect(tree.exists('packages/test-package/src/lib/index.ts')).toBe(true);
+    expect(tree.exists('packages/test-package/LICENSE')).toBe(true);
+
+    installer();
+    expect(installPackagesTask).toHaveBeenCalledWith(tree, true);
+  });
+
+  describe('installer function', () => {
+    it('should handle installation errors', async () => {
+      vi.mocked(installPackagesTask).mockImplementationOnce(() => {
+        throw new Error('Installation failed');
+      });
+
+      const installer = await createPackageGeneratorGenerator(tree, { name: 'test-package' });
+      expect(() => installer()).toThrow('Installation failed');
+    });
+
+    it('should handle multiple installations', async () => {
+      const installer = await createPackageGeneratorGenerator(tree, { name: 'test-package' });
+
+      installer();
+      installer();
+
+      expect(installPackagesTask).toHaveBeenCalledTimes(2);
+      expect(installPackagesTask).toHaveBeenNthCalledWith(1, tree, true);
+      expect(installPackagesTask).toHaveBeenNthCalledWith(2, tree, true);
+    });
+  });
+
+  describe('file content validation', () => {
+    it('should generate correct index.ts content', async () => {
+      await createPackageGeneratorGenerator(tree, { name: 'test-package' });
+
+      const indexContent = tree.read('packages/test-package/src/index.ts')?.toString();
+      expect(indexContent).toContain('import testPackage from "./lib/index.ts"');
+    });
+
+    it('should generate correct lib/index.ts content', async () => {
+      await createPackageGeneratorGenerator(tree, { name: 'test-package' });
+
+      const libContent = tree.read('packages/test-package/src/lib/index.ts')?.toString();
+      expect(libContent).toBeDefined();
+      expect(libContent).not.toBe('');
+    });
+
+    it('should include correct license content', async () => {
+      await createPackageGeneratorGenerator(tree, { name: 'test-package' });
+
+      const licenseContent = tree.read('packages/test-package/LICENSE')?.toString();
+      expect(licenseContent).toBeDefined();
+      expect(licenseContent).toContain('MIT License');
+    });
+  });
+
+  describe('package.json edge cases', () => {
+    it('should sanitize package names properly', async () => {
+      await createPackageGeneratorGenerator(tree, {
+        name: 'test-package-with-special',
+        packageScope: 'test-scope',
+      });
+
+      const packageJson = getJson('packages/test-package-with-special/package.json');
+      expect(packageJson.name).toBe('@test-scope/test-package-with-special');
+    });
+
+    it('should handle very long descriptions', async () => {
+      const longDescription = 'a'.repeat(1000);
+      await createPackageGeneratorGenerator(tree, {
+        name: 'test-package-long-desc',
+        description: longDescription,
+      });
+
+      const packageJson = getJson('packages/test-package-long-desc/package.json');
+      expect(packageJson.description).toBe(longDescription);
+    });
+  });
+
+  describe('file formatting', () => {
+    it('should call formatFiles after generating files', async () => {
+      await createPackageGeneratorGenerator(tree, { name: 'test-package' });
+      expect(formatFiles).toHaveBeenCalledTimes(1);
+      expect(formatFiles).toHaveBeenCalledWith(tree);
+    });
+
+    it('should still create files if formatFiles fails', async () => {
+      vi.mocked(formatFiles).mockRejectedValueOnce(new Error('Format failed'));
+
+      await expect(createPackageGeneratorGenerator(tree, { name: 'test-package' })).rejects.toThrow(
+        'Format failed',
+      );
+
+      expect(tree.exists('packages/test-package/package.json')).toBe(true);
+    });
+  });
+
+  it('should error if no name is passed', async () => {
+    const options = {};
+    // @ts-expect-error options is purposefully invalid
+    await expect(createPackageGeneratorGenerator(tree, options)).rejects.toThrowError(
+      'Invalid name provided. Please provide a name',
+    );
+  });
+
+  it('should error when no moduleType is provided or its invalid', async () => {
+    const options = {
+      name: 'test-package',
+      moduleType: 'invalid moduleType',
+    };
+
+    // @ts-expect-error options is purposefully invalid
+    await expect(createPackageGeneratorGenerator(tree, options)).rejects.toThrowError(
+      'Invalid moduleType provided. Please provide a valid moduleType',
+    );
+  });
+});

tools/create-package/src/generators/create-package-generator.test.ts

@@ -10,13 +10,13 @@
   "sideEffects": <%= sideEffects %>,
   "exports": {
     ".": "./dist/index.js",
-    "./package.json": "./package.json",
+    "./package.json": "./package.json"
   },
   "files": ["<%= outputDir %>"],
   "dependencies": {},
   "devDependencies": {},
   "scripts": {
-    "build": "tsc --project ./tsconfig.lib.json ",
+    "build": "nx exec -- vite build",
     "lint": "nx exec -- eslint **/*.ts --fix",
     "test": "vitest",
     "test:watch": "vitest --watch",

tools/create-package/src/generators/files/package.json.template

@@ -1,26 +1,67 @@
 import { defineConfig } from 'vite';
+import dts from 'vite-plugin-dts';
+import * as path from 'path';
+import * as pkg from './package.json';
+import { codecovVitePlugin } from '@codecov/vite-plugin';
 
-export default defineConfig(() => ({
-  cacheDir: '../../node_modules/.vite/<%= name %>',
+export default defineConfig({
+  root: __dirname,
+  cacheDir: '../../node_modules/.vite/packages/<%= name %>',
+
+  plugins: [
+    dts({
+      rollupTypes: false,
+      insertTypesEntry: false,
+      entryRoot: 'src',
+      tsconfigPath: path.join(__dirname, 'tsconfig.lib.json'),
+    }),
+    /**
+     * This is specifically for tracking bundle sizes
+     * and will only run in CI when the CODECOV_TOKEN
+     * is available
+     **/
+    codecovVitePlugin({
+      enableBundleAnalysis: process.env['CODECOV_TOKEN'] !== undefined,
+      bundleName: '<%= name %>',
+      uploadToken: process.env['CODECOV_TOKEN'],
+    }),
+  ],
+  build: {
+    outDir: './dist',
+    target: ['esnext', 'es2020'],
+    rollupOptions: {
+      output: {
+        // This is the directory your library will be compiled to.
+        dir: '<%= outputDir %>',
+        preserveModules: true,
+        preserveModulesRoot: 'src',
+      },
+      external: Array.from(Object.keys(pkg.dependencies) || []).concat([
+        './src/lib/mock-data',
+        '@reduxjs/toolkit/query',
+      ]),
+    },
+    lib: {
+      entry: 'src/index.ts',
+      name: '<%= name %>',
+      formats: ['es'],
+    },
+    reportCompressedSize: true,
+    commonjsOptions: { transformMixedEsModules: true },
+  },
   test: {
-    reporters: ['default'],
+    cache: {
+      dir: '../../node_modules/.vitest',
+    },
     globals: true,
-    passWithNoTests: true,
-    watch: !process.env['CI'],
+    environment: 'jsdom',
+    include: ['src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
     coverage: {
-      enabled: Boolean(process.env['CI']),
       reporter: ['text', 'json', 'html'],
+      enabled: Boolean(process.env['CI']),
       reportsDirectory: './coverage',
       provider: 'v8',
     },
-    deps: {
-      optimizer: {
-        web: {
-          include: ['vitest-canvas-mock'],
-        },
-      },
-    },
-    environment: 'jsdom',
-    include: ['src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
   },
-}));
+});