piral-cli 0.15.0-alpha.4098 → 0.15.0-alpha.4257

package/src/common/http.ts

@@ -1,17 +1,14 @@
 import { join } from 'path';
 import { Agent } from 'https';
 import { Stream } from 'stream';
-import { platform, tmpdir } from 'os';
+import { tmpdir } from 'os';
 import { createWriteStream } from 'fs';
 import { log } from './log';
+import { standardHeaders } from './info';
+import { getTokenInteractively } from './interactive';
 import { axios, FormData } from '../external';
 import { PiletPublishScheme } from '../types';
 
-const os = platform();
-const standardHeaders = {
-  'user-agent': `piral-cli/http.node-${os}`,
-};
-
 function getMessage(body: string | { message?: string }) {
   if (typeof body === 'string') {
     try {
@@ -74,6 +71,7 @@ export function postFile(
   customFields: Record<string, string> = {},
   customHeaders: Record<string, string> = {},
   ca?: Buffer,
+  interactive = false,
 ): Promise<PostFileResult> {
   const form = new FormData();
   const httpsAgent = ca ? new Agent({ ca }) : undefined;
@@ -124,6 +122,22 @@ export function postFile(
           // The request was made and the server responded with a status code
           // that falls out of the range of 2xx
           const { data, statusText, status } = error.response;
+
+          if (interactive && 'interactiveAuth' in data) {
+            const { interactiveAuth } = data;
+
+            if (typeof interactiveAuth === 'string') {
+              log(
+                'generalDebug_0003',
+                `Received status "${status}" from HTTP - trying interactive log in to "${interactiveAuth}".`,
+              );
+
+              return getTokenInteractively(interactiveAuth, httpsAgent).then(({ mode, token }) =>
+                postFile(target, mode, token, file, customFields, customHeaders, ca, false),
+              );
+            }
+          }
+
           const message = getMessage(data) || '';
           log('unsuccessfulHttpPost_0066', statusText, status, message);
           return {

package/src/common/importmap.ts

@@ -3,6 +3,7 @@ import { log, fail } from './log';
 import { satisfies, validate } from './version';
 import { computeHash } from './hash';
 import { getHash, readJson, findFile, checkExists, checkIsDirectory } from './io';
+import { tryResolvePackage } from './npm';
 import { SharedDependency } from '../types';
 
 interface Importmap {
@@ -12,17 +13,6 @@ interface Importmap {
 
 const shorthandsUrls = ['', '.', '...'];
 
-function tryResolve(baseDir: string, name: string) {
-  try {
-    return require.resolve(name, {
-      paths: [baseDir],
-    });
-  } catch (ex) {
-    log('generalDebug_0003', `Could not resolve the package "${name}" in "${baseDir}": ${ex}`);
-    return undefined;
-  }
-}
-
 function getDependencyDetails(depName: string): [assetName: string, identifier: string, versionSpec: string] {
   const sep = depName.indexOf('@', 1);
   const version = sep > 0 ? depName.substring(sep + 1) : '';
@@ -77,7 +67,7 @@ async function resolveImportmap(dir: string, importmap: Importmap) {
           type: 'remote',
         });
       } else if (url === identifier || shorthandsUrls.includes(url)) {
-        const entry = tryResolve(dir, identifier);
+        const entry = tryResolvePackage(identifier, dir);
 
         if (entry) {
           const packageJson = await findFile(dirname(entry), 'package.json');
@@ -111,7 +101,7 @@ async function resolveImportmap(dir: string, importmap: Importmap) {
             dependencies.push({
               id: `${identifier}@${version}`,
               requireId: `${identifier}@${requireVersion}`,
-              entry: isDirectory ? tryResolve(dir, entry) : entry,
+              entry: isDirectory ? tryResolvePackage(entry, dir) : entry,
               name: identifier,
               ref: `${assetName}.js`,
               type: 'local',
@@ -139,7 +129,7 @@ async function resolveImportmap(dir: string, importmap: Importmap) {
 
   if (Array.isArray(inheritedImports)) {
     for (const inheritedImport of inheritedImports) {
-      const packageJson = tryResolve(dir, `${inheritedImport}/package.json`);
+      const packageJson = tryResolvePackage(`${inheritedImport}/package.json`, dir);
 
       if (packageJson) {
         const packageDir = dirname(packageJson);

package/src/common/info.ts

@@ -1,6 +1,7 @@
-import { cpus } from 'os';
+import { cpus, platform } from 'os';
 
 const info = require('../../package.json');
+const os = platform();
 
 export function findCompatVersion(version: string) {
   // we only care about major and minor
@@ -15,9 +16,13 @@ export function findCompatVersion(version: string) {
 }
 
 export const nodeVersion = process.version.substring(1);
+export const cliName = info.name;
 export const cliVersion = info.version;
 export const compatVersion = findCompatVersion(cliVersion);
 export const repositoryUrl = info.repository.url;
 export const isWindows = process.platform === 'win32';
 export const pathSeparator = isWindows ? ';' : ':';
 export const cpuCount = cpus().length;
+export const standardHeaders = {
+  'user-agent': `piral-cli/http.node-${os}`,
+};

package/src/common/injectors.ts

@@ -1,25 +1,9 @@
 import chalk from 'chalk';
-import { KrasConfigurationInjectors } from 'kras';
+import { resolve } from 'path';
 import { liveIcon, settingsIcon } from './emoji';
 import { logInfo, log, logReset } from './log';
 import { Bundler } from '../types';
 
-export function reorderInjectors(injectorName: string, injectorConfig: any, injectors: KrasConfigurationInjectors) {
-  return {
-    script: injectors.script || {
-      active: true,
-    },
-    har: injectors.har || {
-      active: true,
-    },
-    json: injectors.json || {
-      active: true,
-    },
-    [injectorName]: injectorConfig,
-    ...injectors,
-  };
-}
-
 export function notifyServerOnline(bundlers: Array<Bundler>, path: string, api: string | false) {
   return (svc: any) => {
     log('generalDebug_0003', `The kras server for debugging is online!`);
@@ -30,3 +14,48 @@ export function notifyServerOnline(bundlers: Array<Bundler>, path: string, api:
     bundlers.forEach((bundler) => bundler.start());
   };
 }
+
+export function createInitialKrasConfig(
+  directory: string,
+  map: Record<string, string> = {},
+  sources: Array<string> = [],
+  feed: string | Array<string> = [],
+) {
+  return {
+    api: '/manage-mock-server',
+    directory,
+    map: {
+      '/': '',
+      ...map,
+    },
+    ssl: undefined,
+    sources,
+    injectorDirs: [resolve(__dirname, '../injectors')],
+    injectors: {
+      script: {
+        active: true,
+      },
+      har: {
+        active: true,
+        delay: false,
+      },
+      json: {
+        active: true,
+        randomize: true,
+      },
+      piral: {
+        active: true,
+        headers: {},
+      },
+      pilet: {
+        active: true,
+        meta: 'debug-meta.json',
+        headers: {},
+        feed,
+      },
+      proxy: {
+        active: true,
+      },
+    },
+  };
+}

package/src/common/inspect.ts

@@ -1,5 +1,6 @@
 import { dirname, basename } from 'path';
 import { unpackGzTar } from './archive';
+import { jju } from '../external';
 import { PackageData, PackageFiles } from '../types';
 
 const packageRoot = 'package/';
@@ -8,7 +9,7 @@ function getPackageJson(files: PackageFiles): PackageData {
   const fileName = `${packageRoot}package.json`;
   const fileContent = files[fileName];
   const content = fileContent.toString('utf8');
-  return JSON.parse(content);
+  return jju.parse(content);
 }
 
 function getPiletMainPath(data: PackageData, files: PackageFiles) {

package/src/common/interactive.test.ts

@@ -3,6 +3,9 @@ import { promptConfirm, promptSelect } from './interactive';
 const answer = 'Yes, really';
 
 jest.mock('../external', () => ({
+  rc(_, cfg) {
+    return cfg;
+  },
   inquirer: {
     prompt: (...any) => {
       return Promise.resolve({ q: answer });

package/src/common/interactive.ts

@@ -1,4 +1,8 @@
-import { inquirer } from '../external';
+import { Agent } from 'https';
+import { openBrowserAt } from './browser';
+import { standardHeaders } from './info';
+import { axios, inquirer } from '../external';
+import { PiletPublishScheme } from '../types';
 
 export function promptSelect(message: string, values: Array<string>, defaultValue: string): Promise<string> {
   const questions = [
@@ -24,3 +28,46 @@ export function promptConfirm(message: string, defaultValue: boolean): Promise<b
   ];
   return inquirer.prompt(questions).then((answers: any) => answers.q);
 }
+
+type TokenResult = Promise<{ mode: PiletPublishScheme; token: string }>;
+
+const tokenRetrievers: Record<string, TokenResult> = {};
+
+export function getTokenInteractively(url: string, httpsAgent: Agent): TokenResult {
+  if (!(url in tokenRetrievers)) {
+    tokenRetrievers[url] = axios.default
+      .post(
+        url,
+        {
+          clientId: 'piral-cli',
+          clientName: 'Piral CLI',
+          description: 'Authorize the Piral CLI temporarily to perform actions in your name.',
+        },
+        {
+          headers: {
+            ...standardHeaders,
+            'content-type': 'application/json',
+          },
+          httpsAgent,
+        },
+      )
+      .then((res) => {
+        const { loginUrl, callbackUrl, expires } = res.data;
+        console.log(`Use the URL below to complete the login. The link expires at ${new Date(expires)}.`);
+        console.log('===');
+        console.log(loginUrl);
+        console.log('===');
+
+        openBrowserAt(loginUrl);
+
+        return axios.default.get(callbackUrl).then(({ data }) => {
+          console.log('Logged in successfully.');
+          return {
+            ...data,
+          };
+        });
+      });
+  }
+
+  return tokenRetrievers[url];
+}

package/src/common/io.ts

@@ -239,7 +239,7 @@ export async function matchAnyPilet(baseDir: string, patterns: Array<string>) {
   const allPatterns = patterns.reduce<Array<AnyPattern>>((agg, curr) => {
     const patterns = [];
 
-    if (/[a-zA-Z0-9\-\*]+$/.test(curr) && !preferences.find((ext) => curr.endsWith(ext))) {
+    if (/[a-zA-Z0-9\-\*]$/.test(curr) && !preferences.find((ext) => curr.endsWith(ext))) {
       patterns.push(curr, `${curr}.{${exts}}`, `${curr}/${nameOfPackageJson}`);
     } else if (curr.endsWith('/')) {
       patterns.push(`${curr}index.{${exts}}`, `${curr}${nameOfPackageJson}`);

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,6 +21,7 @@ import {
   getPackageVersion,
   isGitPackage,
   makeExternals,
+  findPackageRoot,
 } from './npm';
 
 jest.mock('child_process');
@@ -42,9 +39,10 @@ jest.mock('../external', () => ({
 }));
 
 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,14 +54,15 @@ jest.mock('./scripts', () => ({
 }));
 
 jest.mock('fs', () => ({
-  constants: {
-    F_OK: 1,
-  },
   createReadStream() {
     return undefined;
   },
   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;
   },
@@ -72,16 +71,21 @@ jest.mock('fs', () => ({
   },
   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', () => {
+  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');
@@ -174,55 +178,66 @@ describe('npm Module', () => {
 
   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 () => {
     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 () => {
     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;
   });
 
@@ -233,59 +248,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 () => {
@@ -302,17 +304,61 @@ 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();
+  });
+
+  it('check if package from current dir is local', () => {
+    const result = isLocalPackage('./', './');
     expect(result).toBeTruthy();
-    result = isLocalPackage('./', './');
+  });
+
+  it('check if package from file is local', () => {
+    const result = isLocalPackage('./', 'foo.tgz');
     expect(result).toBeTruthy();
-    result = isLocalPackage('./', 'foo.tgz');
+  });
+
+  it('check if package from nothing is not local', () => {
+    const result = isLocalPackage('./', null);
+    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();
-    result = isLocalPackage('./', null);
+  });
+
+  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();
@@ -407,7 +453,7 @@ describe('npm Module', () => {
   });
 
   it('makeExternals without externals returns coreExternals', () => {
-    const externals = makeExternals({ piral: '*' });
+    const externals = makeExternals(process.cwd(), { piral: '*' });
     expect(externals).toEqual([
       'react',
       'react-dom',
@@ -422,7 +468,7 @@ describe('npm Module', () => {
   });
 
   it('makeExternals with no externals returns coreExternals', () => {
-    const externals = makeExternals({ piral: '*' }, []);
+    const externals = makeExternals(process.cwd(), { piral: '*' }, []);
     expect(externals).toEqual([
       'react',
       'react-dom',
@@ -437,12 +483,12 @@ describe('npm Module', () => {
   });
 
   it('makeExternals with exclude coreExternals returns empty set', () => {
-    const externals = makeExternals({ piral: '*' }, ['!*']);
+    const externals = makeExternals(process.cwd(), { piral: '*' }, ['!*']);
     expect(externals).toEqual([]);
   });
 
   it('makeExternals with externals concats coreExternals', () => {
-    const externals = makeExternals({ piral: '*' }, ['foo', 'bar']);
+    const externals = makeExternals(process.cwd(), { piral: '*' }, ['foo', 'bar']);
     expect(externals).toEqual([
       'foo',
       'bar',
@@ -459,7 +505,7 @@ describe('npm Module', () => {
   });
 
   it('makeExternals with external duplicate only reflects coreExternals', () => {
-    const externals = makeExternals({ piral: '*' }, ['react', 'foo']);
+    const externals = makeExternals(process.cwd(), { piral: '*' }, ['react', 'foo']);
     expect(externals).toEqual([
       'react',
       'foo',
@@ -475,7 +521,7 @@ describe('npm Module', () => {
   });
 
   it('makeExternals with explicit include and exclude', () => {
-    const externals = makeExternals({ piral: '*' }, ['react', 'react-calendar', '!history']);
+    const externals = makeExternals(process.cwd(), { piral: '*' }, ['react', 'react-calendar', '!history']);
     expect(externals).toEqual([
       'react',
       'react-calendar',
@@ -490,7 +536,7 @@ describe('npm Module', () => {
   });
 
   it('makeExternals with all exclude and explicit include', () => {
-    const externals = makeExternals({ piral: '*' }, ['react', 'react-router-dom', '!*']);
+    const externals = makeExternals(process.cwd(), { piral: '*' }, ['react', 'react-router-dom', '!*']);
     expect(externals).toEqual(['react', 'react-router-dom']);
   });
 });