piral-cli 1.3.3-beta.6190 → 1.3.3-beta.6201

package/src/common/npm.test.ts

@@ -1,5 +1,6 @@
+import { describe, it, expect, vitest } from 'vitest';
 import { resolve } from 'path';
-import { clients } from './clients';
+import { clients } from '../npm-clients';
 import {
   dissectPackageName,
   installNpmPackage,
@@ -24,10 +25,10 @@ import {
   findPackageRoot,
 } from './npm';
 
-jest.mock('child_process');
+vitest.mock('child_process');
 
-jest.mock('../external', () => ({
-  ...jest.requireActual('../external'),
+vitest.mock('../external', async () => ({
+  ...((await vitest.importActual('../external')) as any),
   rc() {},
   ora() {
     return {
@@ -58,7 +59,7 @@ let wrongCase = false;
 const jsonValueString = JSON.stringify([{ name: 'npm' }]);
 const jsonValueStringWrong = JSON.stringify([]);
 
-jest.mock('./scripts', () => ({
+vitest.mock('./scripts', () => ({
   runCommand: (exe: string, args: Array<string>, cwd: string, output?: NodeJS.WritableStream) => {
     return new Promise<void>((resolve) => {
       output?.write(wrongCase ? jsonValueStringWrong : jsonValueString, () => {});
@@ -67,29 +68,34 @@ jest.mock('./scripts', () => ({
   },
 }));
 
-jest.mock('fs', () => ({
-  ...jest.requireActual('fs'),
-  exists: (file: string, cb: (status: boolean) => void) =>
-    cb(
-      shouldFind &&
-        !file.endsWith('package.json') &&
-        !(specialCase && (file.endsWith('lerna.json') || file.endsWith('yarn.lock'))),
-    ),
-  existsSync: (file: string) => {
-    return true;
-  },
-  readFile: (file: string, type: string, callback: (err: NodeJS.ErrnoException | undefined, data: string) => void) => {
-    const fs = jest.requireActual('fs');
-
-    if (fs.existsSync(file)) {
-      return fs.readFile(file, type, callback);
-    }
-
-    return callback(undefined, '');
-  },
-  realpathSync: () => ({}),
-  readFileSync: () => '',
-}));
+vitest.mock('fs', async () => {
+  const fs = (await vitest.importActual('fs')) as any;
+  return {
+    ...fs,
+    exists: (file: string, cb: (status: boolean) => void) =>
+      cb(
+        shouldFind &&
+          !file.endsWith('package.json') &&
+          !(specialCase && (file.endsWith('lerna.json') || file.endsWith('yarn.lock'))),
+      ),
+    existsSync: (file: string) => {
+      return true;
+    },
+    readFile: (
+      file: string,
+      type: string,
+      callback: (err: NodeJS.ErrnoException | undefined, data: string) => void,
+    ) => {
+      if (fs.existsSync(file)) {
+        return fs.readFile(file, type, callback);
+      }
+
+      return callback(undefined, '');
+    },
+    realpathSync: () => ({}),
+    readFileSync: () => '',
+  };
+});
 
 describe('npm Module', () => {
   it('findPackageRoot correctly resolves the package root of parcel-bundler', () => {
@@ -488,15 +494,7 @@ describe('npm Module', () => {
 
   it('makeExternals with externals concats coreExternals', async () => {
     const externals = await makeExternals(process.cwd(), { piral: '*' }, ['foo', 'bar']);
-    expect(externals).toEqual([
-      'foo',
-      'bar',
-      'react',
-      'react-dom',
-      'react-router',
-      'react-router-dom',
-      'tslib',
-    ]);
+    expect(externals).toEqual(['foo', 'bar', 'react', 'react-dom', 'react-router', 'react-router-dom', 'tslib']);
   });
 
   it('makeExternals with external duplicate only reflects coreExternals', async () => {

package/src/common/npm.ts

@@ -1,11 +1,11 @@
 import { resolve, relative, dirname } from 'path';
 import { createReadStream, existsSync } from 'fs';
 import { log, fail } from './log';
-import { clients, detectClients, isWrapperClient } from './clients';
 import { config } from './config';
 import { legacyCoreExternals, frameworkLibs, defaultRegistry, packageJson } from './constants';
 import { inspectPackage } from './inspect';
 import { readJson, checkExists } from './io';
+import { clients, detectClients, isWrapperClient } from '../npm-clients';
 import { clientTypeKeys } from '../helpers';
 import { getModulePath } from '../external';
 import { PackageType, NpmClientType } from '../types';

package/src/common/pack.test.ts

@@ -1,20 +1,21 @@
+import { describe, it, expect, vitest } from 'vitest';
 import { createPiletPackage } from './pack';
 import { resolve } from 'path';
 
 let json: any = {};
 
-jest.mock('./io', () => ({
-  readJson: jest.fn(() => json),
-  removeDirectory: jest.fn(() => Promise.resolve()),
-  checkIsDirectory: jest.fn(() => false),
-  makeTempDir: jest.fn(() => Promise.resolve('')),
-  copy: jest.fn(() => Promise.resolve()),
-  checkExists: jest.fn(() => Promise.resolve(true)),
-  createDirectory: jest.fn(() => Promise.resolve()),
+vitest.mock('./io', () => ({
+  readJson: vitest.fn(() => json),
+  removeDirectory: vitest.fn(() => Promise.resolve()),
+  checkIsDirectory: vitest.fn(() => false),
+  makeTempDir: vitest.fn(() => Promise.resolve('')),
+  copy: vitest.fn(() => Promise.resolve()),
+  checkExists: vitest.fn(() => Promise.resolve(true)),
+  createDirectory: vitest.fn(() => Promise.resolve()),
 }));
 
-jest.mock('./archive', () => ({
-  createTgz: jest.fn(() => Promise.resolve()),
+vitest.mock('./archive', () => ({
+  createTgz: vitest.fn(() => Promise.resolve()),
 }));
 
 describe('Pack Module', () => {

package/src/common/package.test.ts

@@ -1,115 +1,154 @@
+import { describe, it, expect } from 'vitest';
 import { findPackageVersion, getPiralPackage, getPiletsInfo, retrievePiletData } from './package';
 import { cliVersion } from './info';
 
-describe('CLI package module', () => {
-  jest.setTimeout(15000);
-
-  it('findPackageVersion finds the current package version', async () => {
-    const version = await findPackageVersion(process.cwd(), 'sample-piral');
-    expect(version).toBe(cliVersion);
-  });
+const testOptions = {
+  timeout: 10000,
+};
 
-  it('findPackageVersion falls back to latest', async () => {
-    const version = await findPackageVersion(process.cwd(), 'foo-bar-not-exists');
-    expect(version).toBe('latest');
-  });
+describe('CLI package module', () => {
+  it(
+    'findPackageVersion finds the current package version',
+    async () => {
+      const version = await findPackageVersion(process.cwd(), 'sample-piral');
+      expect(version).toBe(cliVersion);
+    },
+    testOptions,
+  );
 
-  it('getPiletsInfo returns pilets information about provided piralInfo', () => {
-    const emptyPiletsInfo = {
-      files: [],
-      template: 'default',
-      scripts: {},
-      validators: {},
-      devDependencies: {},
-      preScaffold: '',
-      postScaffold: '',
-      packageOverrides: {},
-      preUpgrade: '',
-      postUpgrade: '',
-    };
-    let result = getPiletsInfo({});
-    expect(result).toStrictEqual(emptyPiletsInfo);
+  it(
+    'findPackageVersion falls back to latest',
+    async () => {
+      const version = await findPackageVersion(process.cwd(), 'foo-bar-not-exists');
+      expect(version).toBe('latest');
+    },
+    testOptions,
+  );
 
-    const piralInfo = {
-      pilets: {
-        files: ['foo.tgz', 'foo2.tgz'],
+  it(
+    'getPiletsInfo returns pilets information about provided piralInfo',
+    () => {
+      const emptyPiletsInfo = {
+        files: [],
         template: 'default',
         scripts: {},
         validators: {},
         devDependencies: {},
         preScaffold: '',
-        packageOverrides: {},
         postScaffold: '',
+        packageOverrides: {},
         preUpgrade: '',
         postUpgrade: '',
-      },
-    };
-    result = getPiletsInfo(piralInfo);
-    expect(result).toStrictEqual(piralInfo.pilets);
-  });
+      };
+      let result = getPiletsInfo({});
+      expect(result).toStrictEqual(emptyPiletsInfo);
+
+      const piralInfo = {
+        pilets: {
+          files: ['foo.tgz', 'foo2.tgz'],
+          template: 'default',
+          scripts: {},
+          validators: {},
+          devDependencies: {},
+          preScaffold: '',
+          packageOverrides: {},
+          postScaffold: '',
+          preUpgrade: '',
+          postUpgrade: '',
+        },
+      };
+      result = getPiletsInfo(piralInfo);
+      expect(result).toStrictEqual(piralInfo.pilets);
+    },
+    testOptions,
+  );
 
-  it('getPiralPackage returns piral package with webpack in latest version',async () => {
-    const result = await getPiralPackage(
-      'app',
-      { language: 'ts', packageName: 'piral-base', reactRouterVersion: 5, reactVersion: 17 },
-      '10.0.0',
-      'webpack',
-    );
-    expect(result.devDependencies['piral-cli-webpack']).toEqual('latest');
-  });
+  it(
+    'getPiralPackage returns piral package with webpack in latest version',
+    async () => {
+      const result = await getPiralPackage(
+        'app',
+        { language: 'ts', packageName: 'piral-base', reactRouterVersion: 5, reactVersion: 17 },
+        '10.0.0',
+        'webpack',
+      );
+      expect(result.devDependencies['piral-cli-webpack']).toEqual('latest');
+    },
+    testOptions,
+  );
 
-  it('getPiralPackage returns piral package with webpack in beta version',async () => {
-    const result = await getPiralPackage(
-      'app',
-      { language: 'ts', packageName: 'piral-base', reactRouterVersion: 5, reactVersion: 17 },
-      '0.15.0-beta.1',
-      'webpack',
-    );
-    expect(result.devDependencies['piral-cli-webpack']).toEqual('next');
-  });
+  it(
+    'getPiralPackage returns piral package with webpack in beta version',
+    async () => {
+      const result = await getPiralPackage(
+        'app',
+        { language: 'ts', packageName: 'piral-base', reactRouterVersion: 5, reactVersion: 17 },
+        '0.15.0-beta.1',
+        'webpack',
+      );
+      expect(result.devDependencies['piral-cli-webpack']).toEqual('next');
+    },
+    testOptions,
+  );
 
-  it('getPiralPackage returns piral package with webpack in alpha version',async () => {
-    const result = await getPiralPackage(
-      'app',
-      { language: 'ts', packageName: 'piral-base', reactRouterVersion: 5, reactVersion: 17 },
-      '0.15.0-alpha.1',
-      'webpack',
-    );
-    expect(result.devDependencies['piral-cli-webpack']).toEqual('canary');
-  });
+  it(
+    'getPiralPackage returns piral package with webpack in alpha version',
+    async () => {
+      const result = await getPiralPackage(
+        'app',
+        { language: 'ts', packageName: 'piral-base', reactRouterVersion: 5, reactVersion: 17 },
+        '0.15.0-alpha.1',
+        'webpack',
+      );
+      expect(result.devDependencies['piral-cli-webpack']).toEqual('canary');
+    },
+    testOptions,
+  );
 
-  it('getPiralPackage returns piral package with webpack in existing version',async () => {
-    const result = await getPiralPackage(
-      'app',
-      { language: 'ts', packageName: 'piral-base', reactRouterVersion: 5, reactVersion: 17 },
-      '0.14.0',
-      'webpack',
-    );
-    expect(result.devDependencies['piral-cli-webpack']).toEqual('0.14.0');
-  });
+  it(
+    'getPiralPackage returns piral package with webpack in existing version',
+    async () => {
+      const result = await getPiralPackage(
+        'app',
+        { language: 'ts', packageName: 'piral-base', reactRouterVersion: 5, reactVersion: 17 },
+        '0.14.0',
+        'webpack',
+      );
+      expect(result.devDependencies['piral-cli-webpack']).toEqual('0.14.0');
+    },
+    testOptions,
+  );
 
-  it('getPiralPackage returns piral package without bundler',async () => {
-    const result = await getPiralPackage(
-      'app',
-      { language: 'ts', packageName: 'piral-base', reactRouterVersion: 5, reactVersion: 17 },
-      '1.0.0',
-    );
-    expect(result.devDependencies).not.toContain('piral-cli-webpack');
-  });
+  it(
+    'getPiralPackage returns piral package without bundler',
+    async () => {
+      const result = await getPiralPackage(
+        'app',
+        { language: 'ts', packageName: 'piral-base', reactRouterVersion: 5, reactVersion: 17 },
+        '1.0.0',
+      );
+      expect(result.devDependencies['piral-cli-webpack']).toBeUndefined();
+    },
+    testOptions,
+  );
 
-  it('retrievePiletData error cases', async () => {
-    await retrievePiletData('foo', '').catch((err) =>
-      expect(err).toStrictEqual(Error('[0012] No Piral instances have been provided.')),
-    );
+  it(
+    'retrievePiletData error cases',
+    async () => {
+      await retrievePiletData('foo', '').catch((err) =>
+        expect(err).toStrictEqual(Error('[0012] No Piral instances have been provided.')),
+      );
 
-    await retrievePiletData('foo', 'bar').catch((err) =>
-      expect(err).toStrictEqual(Error('[0010] The defined Piral instance ("bar") could not be found.')),
-    );
+      await retrievePiletData('foo', 'bar').catch((err) =>
+        expect(err).toStrictEqual(Error('[0010] The defined Piral instance ("bar") could not be found.')),
+      );
 
-    await retrievePiletData('/foo', 'sample-piral').catch((err) =>
-      expect(err).toStrictEqual(
-        Error('[0075] Cannot find the "package.json". You need a valid package.json for your pilet.'),
-      ),
-    );
-  });
+      await retrievePiletData('/foo', 'sample-piral').catch((err) =>
+        expect(err).toStrictEqual(
+          Error('[0075] Cannot find the "package.json". You need a valid package.json for your pilet.'),
+        ),
+      );
+    },
+    testOptions,
+  );
 });

package/src/common/parallel.test.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect } from 'vitest';
 import { concurrentWorkers } from './parallel';
 
 describe('Concurrent Workers', () => {

package/src/common/patches.test.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect } from 'vitest';
 import { getPatch, installPatch } from './patches';
 
 const patchName = 'foo';

package/src/common/port.test.ts

@@ -1,9 +1,10 @@
+import { describe, it, expect, vitest } from 'vitest';
 import { getFreePort } from './port';
 
 const defaultPort = 12345;
 const error = Error('RangeError: Port should be >= 0 and < 65536.');
 
-jest.mock('../external', () => ({
+vitest.mock('../external', () => ({
   ora() {
     return {};
   },

package/src/common/rules.test.ts

@@ -1,8 +1,9 @@
+import { describe, it, expect, vitest } from 'vitest';
 import { ruleSummary, runRules } from './rules';
 import { chalk } from '../external';
 
 const rule = {
-  run: jest.fn(),
+  run: vitest.fn(),
   name: 'test',
 };
 
@@ -13,11 +14,11 @@ describe('Rules Module', () => {
     };
     expect(runException).toThrow(Error('[0080] Validation failed. Found 1 error(s).'));
 
-    let consoleSpy = jest.spyOn(process.stderr, 'write');
+    let consoleSpy = vitest.spyOn(process.stderr, 'write');
     ruleSummary([], []);
     expect(consoleSpy).toHaveBeenLastCalledWith(`${chalk.green('✔')} Validation successful. No errors or warnings.\n`);
 
-    jest.clearAllMocks();
+    vitest.clearAllMocks();
     ruleSummary([], ['Warning!']);
     expect(consoleSpy).toHaveBeenCalled();
   });

package/src/common/url.test.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect } from 'vitest';
 import { normalizePublicUrl } from './url';
 
 describe('Url Module', () => {

package/src/common/utils.test.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect } from 'vitest';
 import { onlyUnique, onlyUniqueFiles } from './utils';
 
 describe('only unique', () => {

package/src/common/version.test.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect } from 'vitest';
 import { satisfies, validate } from './version';
 
 describe('semver check module', () => {

package/src/external/index.test.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect } from 'vitest';
 import * as externals from '../external';
 
 describe('Externals module', () => {

package/src/helpers.test.ts

@@ -1,3 +1,4 @@
+import { describe, it, expect } from 'vitest';
 import { keyOfForceOverwrite, valueOfForceOverwrite } from './helpers';
 import { ForceOverwrite } from './common/enums';
 

package/src/injectors/pilet-injector.test.ts

@@ -1,6 +1,7 @@
+import PiletInjector from './pilet-injector';
+import { describe, it, expect } from 'vitest';
 import { EventEmitter } from 'events';
 import { KrasRequest } from 'kras';
-import PiletInjector from './pilet-injector';
 
 const optionsMock = {
   pilets: [],
@@ -96,14 +97,14 @@ describe('Piral-CLI pilet injector', () => {
 
     const core = new EventEmitter();
     const injector = new PiletInjector(optionsMock, configMock, core);
-    const request: KrasRequest = {
+    const request = {
       content: 'someFakeContent',
       headers: {},
       method: 'PUT',
       query: {},
       target: optionsMock.api,
       url: 'localhost:1234',
-    };
+    } as KrasRequest;
 
     // Act
     const res = await injector.handle(request);
@@ -125,14 +126,14 @@ describe('Piral-CLI pilet injector', () => {
     };
     const core = new EventEmitter();
     const injector = new PiletInjector(optionsMock, configMock, core);
-    const request: KrasRequest = {
+    const request = {
       content: 'someFakeContent',
       headers: {},
       method: 'PUT',
       query: {},
       target: '',
       url: 'localhost:1234',
-    };
+    } as KrasRequest;
 
     // Act
     const res = injector.handle(request);

package/src/injectors/piral-injector.test.ts

@@ -1,4 +1,5 @@
 import PiralInjector from './piral-injector';
+import { describe, it, expect } from 'vitest';
 import { KrasRequest, KrasResult } from 'kras';
 import { EventEmitter } from 'events';
 
@@ -39,7 +40,7 @@ describe('Piral-CLI piral injector', () => {
       active: true,
       headers: {},
     };
-    const injector = new PiralInjector(config, undefined, new EventEmitter());
+    const injector = new PiralInjector(config, undefined as any, new EventEmitter());
     expect(injector.active).toBeTruthy();
   });
 
@@ -51,7 +52,7 @@ describe('Piral-CLI piral injector', () => {
       active: true,
       headers: {},
     };
-    const injector = new PiralInjector(config, undefined, new EventEmitter());
+    const injector = new PiralInjector(config, undefined as any, new EventEmitter());
 
     // Act
     injector.active = false;
@@ -71,7 +72,7 @@ describe('Piral-CLI piral injector', () => {
       active: true,
       headers: {},
     };
-    const injector = new PiralInjector(config, undefined, new EventEmitter());
+    const injector = new PiralInjector(config, undefined as any, new EventEmitter());
 
     // Act
     const res = injector.sendResponse('some/nice/invalid/path', 'sometarget.file', 'someDir', 'localhost:1234');
@@ -88,15 +89,15 @@ describe('Piral-CLI piral injector', () => {
       active: true,
       headers: {},
     };
-    const injector = new PiralInjector(config, undefined, new EventEmitter());
-    const request: KrasRequest = {
+    const injector = new PiralInjector(config, undefined as any, new EventEmitter());
+    const request = {
       content: 'someFakeContent',
       headers: {},
       method: 'PUT',
       query: {},
       target: '',
       url: 'localhost:1234',
-    };
+    } as KrasRequest;
 
     // Act
     const res = await (injector.handle(request) as Promise<KrasResult>);

package/src/{common/clients → npm-clients}/bun.ts

@@ -1,8 +1,8 @@
 import { resolve } from 'path';
-import { log } from '../log';
-import { findFile } from '../io';
-import { runCommand } from '../scripts';
-import { MemoryStream } from '../MemoryStream';
+import { log } from '../common/log';
+import { findFile } from '../common/io';
+import { runCommand } from '../common/scripts';
+import { MemoryStream } from '../common/MemoryStream';
 
 // Helpers:
 
@@ -68,7 +68,7 @@ export async function isProject(root: string, packageRef: string) {
   return false;
 }
 
-// Functions to exclusively use from yarn client:
+// Functions to exclusively use from Bun client:
 
 export async function listProjects(target: string) {
   const ms = new MemoryStream();

package/src/{common/clients → npm-clients}/index.ts

@@ -1,5 +1,5 @@
 import { dirname, resolve } from 'path';
-import { findFile } from '../io';
+import { findFile } from '../common/io';
 
 import * as lerna from './lerna';
 import * as npm from './npm';

package/src/{common/clients → npm-clients}/lerna.ts

@@ -1,8 +1,8 @@
 import { resolve } from 'path';
-import { log } from '../log';
-import { findFile, readJson, writeJson } from '../io';
-import { runCommand } from '../scripts';
-import { MemoryStream } from '../MemoryStream';
+import { log } from '../common/log';
+import { findFile, readJson, writeJson } from '../common/io';
+import { runCommand } from '../common/scripts';
+import { MemoryStream } from '../common/MemoryStream';
 
 // Helpers:
 

package/src/{common/clients → npm-clients}/npm.ts

@@ -1,8 +1,8 @@
 import { resolve } from 'path';
-import { log } from '../log';
-import { findFile } from '../io';
-import { runCommand } from '../scripts';
-import { MemoryStream } from '../MemoryStream';
+import { log } from '../common/log';
+import { findFile } from '../common/io';
+import { runCommand } from '../common/scripts';
+import { MemoryStream } from '../common/MemoryStream';
 
 // Helpers:
 

package/src/{common/clients → npm-clients}/pnp.ts

@@ -1,8 +1,8 @@
 import { resolve } from 'path';
-import { log } from '../log';
-import { findFile } from '../io';
-import { runCommand } from '../scripts';
-import { MemoryStream } from '../MemoryStream';
+import { log } from '../common/log';
+import { findFile } from '../common/io';
+import { runCommand } from '../common/scripts';
+import { MemoryStream } from '../common/MemoryStream';
 
 // Helpers: