piral-cli 1.0.0-pre.2217 → 1.0.0

package/src/common/npm.test.ts

@@ -1,16 +1,12 @@
 import { resolve } from 'path';
+import { clients } from './clients';
 import {
   dissectPackageName,
-  installPackage,
-  detectNpm,
-  detectPnpm,
-  detectYarn,
+  installNpmPackage,
   isMonorepoPackageRef,
-  detectMonorepo,
-  bootstrapMonorepo,
-  installDependencies,
-  createPackage,
-  findTarball,
+  installNpmDependencies,
+  createNpmPackage,
+  findNpmTarball,
   findSpecificVersion,
   findLatestVersion,
   isLocalPackage,
@@ -25,26 +21,42 @@ import {
   getPackageVersion,
   isGitPackage,
   makeExternals,
+  findPackageRoot,
 } from './npm';
 
 jest.mock('child_process');
 
 jest.mock('../external', () => ({
+  ...jest.requireActual('../external'),
   rc() {},
-  logger: {
-    stopSpinner() {},
-    verbose() {},
-    info() {},
-    error() {},
-    log() {},
-    setOptions() {},
+  ora() {
+    return {
+      succeed(msg) {
+        console.warn(msg);
+      },
+      warn(msg) {
+        console.warn(msg);
+      },
+      info(msg) {
+        console.info(msg);
+      },
+      fail(msg) {
+        console.error(msg);
+      },
+    };
+  },
+  getModulePath(root, moduleName) {
+    return require.resolve(moduleName, {
+      paths: [root],
+    });
   },
 }));
 
 let specialCase = false;
+let shouldFind = true;
 let wrongCase = false;
-const jsonValueString = JSON.stringify({ dependencies: { npm: { extraneous: true } } });
-const jsonValueStringWrong = JSON.stringify({ dependencies: {} });
+const jsonValueString = JSON.stringify([{ name: 'npm' }]);
+const jsonValueStringWrong = JSON.stringify([]);
 
 jest.mock('./scripts', () => ({
   runCommand: (exe: string, args: Array<string>, cwd: string, output?: NodeJS.WritableStream) => {
@@ -56,31 +68,42 @@ jest.mock('./scripts', () => ({
 }));
 
 jest.mock('fs', () => ({
-  constants: {
-    F_OK: 1,
-  },
-  createReadStream() {
-    return undefined;
-  },
+  ...jest.requireActual('fs'),
   exists: (file: string, cb: (status: boolean) => void) =>
-    cb(!file.endsWith('package.json') && !(specialCase && (file.endsWith('lerna.json') || file.endsWith('yarn.lock')))),
+    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, data: string) => void) => {
+  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: () => '',
-  access: (path: string, mode: number, callback: (err: NodeJS.ErrnoException) => void) => {
-    if (path.includes('test')) {
-      return callback(undefined);
-    } else {
-      return callback(new Error('bla'));
-    }
-  },
 }));
 
-describe('NPM Module', () => {
+describe('npm Module', () => {
+  it('findPackageRoot correctly resolves the package root of parcel-bundler', () => {
+    const dir = process.cwd();
+    const version = findPackageRoot('webpack', dir);
+    expect(version).toBe(resolve(dir, 'node_modules', 'webpack', 'package.json'));
+  });
+
+  it('findPackageRoot returns undefined for invalid package', () => {
+    const dir = process.cwd();
+    const version = findPackageRoot('foo-bar-not-exist', dir);
+    expect(version).toBeUndefined();
+  });
+
   it('dissects a fully qualified name with latest correctly', async () => {
     wrongCase = false;
     const [name, version, hadVersion, type] = await dissectPackageName(process.cwd(), 'foo@latest');
@@ -171,57 +194,68 @@ describe('NPM Module', () => {
     expect(type).toBe('registry');
   });
 
-  it('installs a package using the NPM command line tool without a target', async () => {
+  it('installs a package using the npm command line tool without a target', async () => {
     wrongCase = false;
-    await installPackage('npm', 'foo', 'latest').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage('npm', 'foo', 'latest').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installPackage('npm', 'foo', 'latest').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage('npm', 'foo', 'latest').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
-  it('installs a package using the NPM command line tool without a version', async () => {
+  it('installs a package using the npm command line tool without a version', async () => {
     wrongCase = false;
-    await installPackage('npm', 'foo').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage('npm', 'foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installPackage('npm', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage('npm', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('installs a package using the Yarn command line tool without a version', async () => {
     wrongCase = false;
-    await installPackage('yarn', 'foo').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage('yarn', 'foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installPackage('yarn', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage('yarn', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('installs a package using the Pnpm command line tool without a version', async () => {
     wrongCase = false;
-    await installPackage('pnpm', 'foo').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage('pnpm', 'foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installPackage('pnpm', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage('pnpm', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
-  it('installs a package using the NPM command line tool with some flag', async () => {
+  it('installs a package using the npm command line tool with some flag', async () => {
     wrongCase = false;
-    await installPackage('npm', 'foo', '1.3', '.', '--a=b').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage('npm', 'foo', '1.3', '.', '--a=b').then((result) =>
+      expect(result).toEqual(jsonValueString),
+    );
     wrongCase = true;
-    await installPackage('npm', 'foo', '1.3', '.', '--a=b').then((result) =>
+    await installNpmPackage('npm', 'foo', '1.3', '.', '--a=b').then((result) =>
       expect(result).not.toEqual(jsonValueString),
     );
   });
 
   it('detectNpm finds package-lock.json', async () => {
-    await detectNpm('test').then((result) => expect(result).toBeTruthy());
-    await detectNpm('toast').then((result) => expect(result).toBeFalsy());
+    shouldFind = true;
+    await clients.npm.detectClient('test').then((result) => expect(result).toBeTruthy());
+    shouldFind = false;
+    await clients.npm.detectClient('toast').then((result) => expect(result).toBeFalsy());
+    shouldFind = true;
   });
 
-  it('detectPnpm finds nppm-lock.yaml', async () => {
-    await detectPnpm('test').then((result) => expect(result).toBeTruthy());
-    await detectPnpm('toast').then((result) => expect(result).toBeFalsy());
+  it('detectPnpm finds pnpm-lock.yaml', async () => {
+    shouldFind = true;
+    await clients.pnpm.detectClient('test').then((result) => expect(result).toBeTruthy());
+    shouldFind = false;
+    await clients.pnpm.detectClient('toast').then((result) => expect(result).toBeFalsy());
+    shouldFind = true;
   });
 
   it('detectYarn finds yarn.lock', async () => {
-    await detectYarn('test').then((result) => expect(result).toBeTruthy());
+    shouldFind = true;
+    await clients.yarn.detectClient('test').then((result) => expect(result).toBeTruthy());
+    shouldFind = false;
     specialCase = true;
-    await detectYarn('toast').then((result) => expect(result).toBeFalsy());
+    await clients.yarn.detectClient('toast').then((result) => expect(result).toBeFalsy());
+    shouldFind = true;
     specialCase = false;
   });
 
@@ -232,59 +266,46 @@ describe('NPM Module', () => {
     await isMonorepoPackageRef('npm', './').then((result) => expect(result).toBeFalsy());
   });
 
-  it('verifies whether lerna config path is valid', async () => {
-    wrongCase = false;
-    await detectMonorepo('./').then((result) => {
-      expect(result).toBe('lerna');
-    });
-    wrongCase = true;
-    specialCase = true;
-    await detectMonorepo('./').then((result) => {
-      expect(result).toBe('none');
-    });
-    specialCase = false;
-  });
-
   it('verifies whether lerna bootstrap ran', async () => {
     wrongCase = false;
-    await bootstrapMonorepo().then((result) => expect(result).toEqual(jsonValueString));
+    await clients.lerna.installDependencies().then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await bootstrapMonorepo().then((result) => expect(result).not.toEqual(jsonValueString));
+    await clients.lerna.installDependencies().then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('install dependencies with npm client', async () => {
     wrongCase = false;
-    await installDependencies('npm').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmDependencies('npm').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installDependencies('npm').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmDependencies('npm').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('install dependencies with pnpm client', async () => {
     wrongCase = false;
-    await installDependencies('pnpm').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmDependencies('pnpm').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installDependencies('pnpm').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmDependencies('pnpm').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('install dependencies with yarn client', async () => {
     wrongCase = false;
-    await installDependencies('yarn').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmDependencies('yarn').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installDependencies('yarn').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmDependencies('yarn').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('create npm package', async () => {
     wrongCase = false;
-    await createPackage().then((result) => expect(result).toEqual(jsonValueString));
+    await createNpmPackage().then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await createPackage().then((result) => expect(result).not.toEqual(jsonValueString));
+    await createNpmPackage().then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('find npm tarball', async () => {
     wrongCase = false;
-    await findTarball('foo').then((result) => expect(result).toEqual(jsonValueString));
+    await findNpmTarball('foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await findTarball('foo').then((result) => expect(result).not.toEqual(jsonValueString));
+    await findNpmTarball('foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('find latest version', async () => {
@@ -301,23 +322,67 @@ describe('NPM Module', () => {
     await findSpecificVersion('foo', '1.0.0').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
-  it('check if package is local', () => {
-    let result = isLocalPackage('./', 'file://foo.tgz');
+  it('check if package from full file is local', () => {
+    const result = isLocalPackage('./', 'file://foo.tgz');
     expect(result).toBeTruthy();
-    result = isLocalPackage('./', './');
+  });
+
+  it('check if package from current dir is local', () => {
+    const result = isLocalPackage('./', './');
     expect(result).toBeTruthy();
-    result = isLocalPackage('./', 'foo.tgz');
+  });
+
+  it('check if package from file is local', () => {
+    const result = isLocalPackage('./', 'foo.tgz');
     expect(result).toBeTruthy();
-    result = isLocalPackage('./', null);
+  });
+
+  it('check if package from nothing is not local', () => {
+    const result = isLocalPackage('./', '');
+    expect(result).toBeFalsy();
+  });
+
+  it('check if package from tilde version is not local', () => {
+    const result = isLocalPackage('./', '~12.2.2');
+    expect(result).toBeFalsy();
+  });
+
+  it('check if package from caret version is not local', () => {
+    const result = isLocalPackage('./', '^12.2.2');
+    expect(result).toBeFalsy();
+  });
+
+  it('check if package from star version is not local', () => {
+    const result = isLocalPackage('./', '*');
+    expect(result).toBeFalsy();
+  });
+
+  it('check if package from greater than is not local', () => {
+    const result = isLocalPackage('./', '>=1.0.0');
     expect(result).toBeFalsy();
   });
 
+  it('check if package from home dir is local', () => {
+    const result = isLocalPackage('./', '~/foo/bar');
+    expect(result).toBeTruthy();
+  });
+
+  it('check if package from zero is not local', () => {
+    const result = isLocalPackage('./', '.0');
+    expect(result).toBeFalsy();
+  });
+
+  it('check if package from absolute dir is local', () => {
+    const result = isLocalPackage('./', '/0');
+    expect(result).toBeTruthy();
+  });
+
   it('check if package is coming from git', () => {
     let result = isGitPackage('https://.foo.git');
     expect(result).toBeTruthy();
     result = isGitPackage('git+');
     expect(result).toBeTruthy();
-    result = isGitPackage(null);
+    result = isGitPackage('');
     expect(result).toBeFalsy();
   });
 
@@ -337,35 +402,36 @@ describe('NPM Module', () => {
   });
 
   it('verify whether package is linked', () => {
-    let result = isLinkedPackage('foo', 'registry', false);
+    const target = process.cwd();
+    let result = isLinkedPackage('foo', 'registry', false, target);
     expect(result).toBeFalsy();
-    result = isLinkedPackage('foo', 'file', false);
+    result = isLinkedPackage('foo', 'file', false, target);
     expect(result).toBeFalsy();
-    result = isLinkedPackage('foo', 'git', false);
+    result = isLinkedPackage('foo', 'git', false, target);
     expect(result).toBeFalsy();
   });
 
   it('combine package refernce', () => {
     let result = combinePackageRef('foo', '1.0.0', 'registry');
     expect(result).toBe('foo@1.0.0');
-    result = combinePackageRef('foo', null, 'registry');
+    result = combinePackageRef('foo', '', 'registry');
     expect(result).toBe('foo@latest');
-    result = combinePackageRef('foo', null, 'file');
+    result = combinePackageRef('foo', '', 'file');
     expect(result).toBe('foo');
-    result = combinePackageRef('foo', null, 'git');
+    result = combinePackageRef('foo', '', 'git');
     expect(result).toBe('foo');
   });
 
-  it('retrieve package name', () => {
+  it('retrieve package name', async () => {
     let result = getPackageName('./', 'foo', 'file');
     expect(result).toBeInstanceOf(Promise);
-    result.then((message) => expect(message).toBeUndefined());
+    await result.then((message) => expect(message).toBeUndefined());
     result = getPackageName('./', 'foo', 'git');
     expect(result).toBeInstanceOf(Promise);
-    result.then((message) => expect(message).toBeUndefined());
+    await result.then((message) => expect(message).toBeUndefined());
     result = getPackageName('./', 'foo', 'registry');
     expect(result).toBeInstanceOf(Promise);
-    result.then((name) => expect(name).toEqual('foo'));
+    await result.then((name) => expect(name).toEqual('foo'));
   });
 
   it('gets path to file package', () => {
@@ -383,113 +449,68 @@ describe('NPM Module', () => {
     expect(result).toEqual('1.0.0');
     result = getPackageVersion(false, 'foo', '1.0.0', 'registry', './');
     expect(result).toBeFalsy();
-    result = getPackageVersion(true, './foo.tgz', null, 'file', './');
+    result = getPackageVersion(true, './foo.tgz', '', 'file', './');
     expect(result).toEqual('file:foo.tgz');
-    result = getPackageVersion(true, 'git+https://.foo.git', null, 'git', null);
+    result = getPackageVersion(true, 'git+https://.foo.git', '', 'git', '');
     expect(result).toEqual('git+https://.foo.git');
   });
 
-  it('gets path to git package', () => {
-    const result = getCurrentPackageDetails('./', './foo.tgz', null, 'file://foo.tgz', './');
-    result.then(([path, version]) => {
+  it('gets path to git package', async () => {
+    const result = getCurrentPackageDetails('./', './foo.tgz', '', 'file://foo.tgz', './');
+    await result.then(([path, version]) => {
       expect(path).not.toBeUndefined();
     });
-    const result2 = getCurrentPackageDetails('./', './foo.tgz', null, 'git+https://.foo.git', './');
-    result2.then(([path, version]) => {
+    const result2 = getCurrentPackageDetails('./', './foo.tgz', '', 'git+https://.foo.git', './');
+    await result2.then(([path, version]) => {
       expect(path).not.toBeUndefined();
     });
     const result3 = getCurrentPackageDetails('./', './foo.tgz', '1.0.0', 'latest', './');
-    result3.then(([path, version]) => {
+    await result3.then(([path, version]) => {
       expect(path).toEqual('./foo.tgz@latest');
       expect(version).toEqual('latest');
     });
   });
 
-  it('makeExternals without externals returns coreExternals', () => {
-    const externals = makeExternals();
-    expect(externals).toEqual([
-      '@dbeining/react-atom',
-      '@libre/atom',
-      'history',
-      'react',
-      'react-dom',
-      'react-router',
-      'react-router-dom',
-      'tslib',
-      'path-to-regexp',
-    ]);
+  it('makeExternals without externals returns coreExternals', async () => {
+    const externals = await makeExternals(process.cwd(), { piral: '*' }, []);
+    expect(externals).toEqual(['react', 'react-dom', 'react-router', 'react-router-dom', 'tslib']);
   });
 
-  it('makeExternals with no externals returns coreExternals', () => {
-    const externals = makeExternals([]);
-    expect(externals).toEqual([
-      '@dbeining/react-atom',
-      '@libre/atom',
-      'history',
-      'react',
-      'react-dom',
-      'react-router',
-      'react-router-dom',
-      'tslib',
-      'path-to-regexp',
-    ]);
+  it('makeExternals with no externals returns coreExternals', async () => {
+    const externals = await makeExternals(process.cwd(), { piral: '*' }, []);
+    expect(externals).toEqual(['react', 'react-dom', 'react-router', 'react-router-dom', 'tslib']);
   });
 
-  it('makeExternals with exclude coreExternals returns empty set', () => {
-    const externals = makeExternals(['!*']);
+  it('makeExternals with exclude coreExternals returns empty set', async () => {
+    const externals = await makeExternals(process.cwd(), { piral: '*' }, ['!*']);
     expect(externals).toEqual([]);
   });
 
-  it('makeExternals with externals concats coreExternals', () => {
-    const externals = makeExternals(['foo', 'bar']);
+  it('makeExternals with externals concats coreExternals', async () => {
+    const externals = await makeExternals(process.cwd(), { piral: '*' }, ['foo', 'bar']);
     expect(externals).toEqual([
       'foo',
       'bar',
-      '@dbeining/react-atom',
-      '@libre/atom',
-      'history',
       'react',
       'react-dom',
       'react-router',
       'react-router-dom',
       'tslib',
-      'path-to-regexp',
     ]);
   });
 
-  it('makeExternals with external duplicate only reflects coreExternals', () => {
-    const externals = makeExternals(['react', 'foo']);
-    expect(externals).toEqual([
-      'react',
-      'foo',
-      '@dbeining/react-atom',
-      '@libre/atom',
-      'history',
-      'react-dom',
-      'react-router',
-      'react-router-dom',
-      'tslib',
-      'path-to-regexp',
-    ]);
+  it('makeExternals with external duplicate only reflects coreExternals', async () => {
+    const externals = await makeExternals(process.cwd(), { piral: '*' }, ['react', 'foo']);
+    expect(externals).toEqual(['react', 'foo', 'react-dom', 'react-router', 'react-router-dom', 'tslib']);
   });
 
-  it('makeExternals with explicit include and exclude', () => {
-    const externals = makeExternals(['react', 'react-calendar', '!history']);
-    expect(externals).toEqual([
-      'react',
-      'react-calendar',
-      '@dbeining/react-atom',
-      '@libre/atom',
-      'react-dom',
-      'react-router',
-      'react-router-dom',
-      'tslib',
-      'path-to-regexp',
-    ]);
+  it('makeExternals with explicit include and exclude', async () => {
+    const externals = await makeExternals(process.cwd(), { piral: '*' }, ['react', 'react-calendar', '!tslib']);
+    expect(externals).toEqual(['react', 'react-calendar', 'react-dom', 'react-router', 'react-router-dom']);
   });
 
-  it('makeExternals with all exclude and explicit include', () => {
-    const externals = makeExternals(['react', 'react-router-dom', '!*']);
+  it('makeExternals with all exclude and explicit include', async () => {
+    const externals = await makeExternals(process.cwd(), { piral: '*' }, ['react', 'react-router-dom', '!*']);
     expect(externals).toEqual(['react', 'react-router-dom']);
   });
 });