@ohos-ports/parcel-package-manager 2.16.4-beta.0

package/test/NodePackageManager.test.js

@@ -0,0 +1,387 @@
+// @flow strict-local
+
+import {MemoryFS, NodeFS, OverlayFS} from '@parcel/fs';
+import assert from 'assert';
+import invariant from 'assert';
+import path from 'path';
+import sinon from 'sinon';
+import ThrowableDiagnostic from '@parcel/diagnostic';
+import {loadConfig} from '@parcel/utils';
+import WorkerFarm from '@parcel/workers';
+import {MockPackageInstaller, NodePackageManager} from '../src';
+
+const FIXTURES_DIR = path.join(__dirname, 'fixtures');
+
+function normalize(res) {
+  return {
+    ...res,
+    invalidateOnFileCreate:
+      res?.invalidateOnFileCreate?.sort((a, b) => {
+        let ax =
+          a.filePath ??
+          a.glob ??
+          (a.aboveFilePath != null && a.fileName != null
+            ? a.aboveFilePath + a.fileName
+            : '');
+        let bx =
+          b.filePath ??
+          b.glob ??
+          (b.aboveFilePath != null && b.fileName != null
+            ? b.aboveFilePath + b.fileName
+            : '');
+        return ax < bx ? -1 : 1;
+      }) ?? [],
+  };
+}
+
+function check(resolved, expected) {
+  assert.deepEqual(normalize(resolved), normalize(expected));
+}
+
+describe('NodePackageManager', function () {
+  let fs;
+  let packageManager;
+  let packageInstaller;
+  let workerFarm;
+
+  // These can sometimes take a lil while
+  this.timeout(20000);
+
+  beforeEach(() => {
+    workerFarm = new WorkerFarm({
+      workerPath: require.resolve('@parcel/core/src/worker.js'),
+    });
+    fs = new OverlayFS(new MemoryFS(workerFarm), new NodeFS());
+    packageInstaller = new MockPackageInstaller();
+    packageManager = new NodePackageManager(fs, '/', packageInstaller);
+  });
+
+  afterEach(async () => {
+    loadConfig.clear();
+    await workerFarm.end();
+  });
+
+  it('resolves packages that exist', async () => {
+    check(
+      await packageManager.resolve(
+        'foo',
+        path.join(FIXTURES_DIR, 'has-foo/index.js'),
+      ),
+      {
+        pkg: {
+          version: '1.1.0',
+        },
+        resolved: path.join(FIXTURES_DIR, 'has-foo/node_modules/foo/index.js'),
+        type: 1,
+        invalidateOnFileChange: new Set([
+          path.join(FIXTURES_DIR, 'has-foo/package.json'),
+          path.join(FIXTURES_DIR, 'has-foo/node_modules/foo/package.json'),
+        ]),
+        invalidateOnFileCreate: [
+          {
+            filePath: path.join(
+              FIXTURES_DIR,
+              'has-foo/node_modules/foo/index.ts',
+            ),
+          },
+          {
+            filePath: path.join(
+              FIXTURES_DIR,
+              'has-foo/node_modules/foo/index.tsx',
+            ),
+          },
+          {
+            fileName: 'node_modules/foo',
+            aboveFilePath: path.join(FIXTURES_DIR, 'has-foo'),
+          },
+          {
+            fileName: 'tsconfig.json',
+            aboveFilePath: path.join(FIXTURES_DIR, 'has-foo'),
+          },
+        ],
+      },
+    );
+  });
+
+  it('requires packages that exist', async () => {
+    assert.deepEqual(
+      await packageManager.require(
+        'foo',
+        path.join(FIXTURES_DIR, 'has-foo/index.js'),
+      ),
+      'foobar',
+    );
+  });
+
+  it("autoinstalls packages that don't exist", async () => {
+    packageInstaller.register('a', fs, path.join(FIXTURES_DIR, 'packages/a'));
+
+    check(
+      await packageManager.resolve(
+        'a',
+        path.join(FIXTURES_DIR, 'has-foo/index.js'),
+        {shouldAutoInstall: true},
+      ),
+      {
+        pkg: {
+          name: 'a',
+        },
+        resolved: path.join(FIXTURES_DIR, 'has-foo/node_modules/a/index.js'),
+        type: 1,
+        invalidateOnFileChange: new Set([
+          path.join(FIXTURES_DIR, 'has-foo/package.json'),
+          path.join(FIXTURES_DIR, 'has-foo/node_modules/a/package.json'),
+        ]),
+        invalidateOnFileCreate: [
+          {
+            filePath: path.join(
+              FIXTURES_DIR,
+              'has-foo/node_modules/a/index.ts',
+            ),
+          },
+          {
+            filePath: path.join(
+              FIXTURES_DIR,
+              'has-foo/node_modules/a/index.tsx',
+            ),
+          },
+          {
+            fileName: 'node_modules/a',
+            aboveFilePath: path.join(FIXTURES_DIR, 'has-foo'),
+          },
+          {
+            fileName: 'tsconfig.json',
+            aboveFilePath: path.join(FIXTURES_DIR, 'has-foo'),
+          },
+        ],
+      },
+    );
+  });
+
+  it('does not autoinstall packages that are already listed in package.json', async () => {
+    packageInstaller.register('a', fs, path.join(FIXTURES_DIR, 'packages/a'));
+
+    // $FlowFixMe assert.rejects is Node 10+
+    await assert.rejects(
+      () =>
+        packageManager.resolve(
+          'a',
+          path.join(FIXTURES_DIR, 'has-a-not-yet-installed/index.js'),
+          {shouldAutoInstall: true},
+        ),
+      err => {
+        invariant(err instanceof ThrowableDiagnostic);
+        assert(err.message.includes('Run your package manager'));
+        return true;
+      },
+    );
+  });
+
+  it('does not autoinstall peer dependencies that are already listed in package.json', async () => {
+    packageInstaller.register(
+      'peers',
+      fs,
+      path.join(FIXTURES_DIR, 'packages/peers'),
+    );
+
+    let spy = sinon.spy(packageInstaller, 'install');
+    await packageManager.resolve(
+      'peers',
+      path.join(FIXTURES_DIR, 'has-foo/index.js'),
+      {shouldAutoInstall: true},
+    );
+    assert.deepEqual(spy.args, [
+      [
+        {
+          cwd: path.join(FIXTURES_DIR, 'has-foo'),
+          packagePath: path.join(FIXTURES_DIR, 'has-foo/package.json'),
+          fs,
+          saveDev: true,
+          modules: [{name: 'peers', range: undefined}],
+        },
+      ],
+    ]);
+  });
+
+  it('autoinstalls peer dependencies that are not listed in package.json', async () => {
+    packageInstaller.register(
+      'foo',
+      fs,
+      path.join(FIXTURES_DIR, 'packages/foo-2.0'),
+    );
+    packageInstaller.register(
+      'peers',
+      fs,
+      path.join(FIXTURES_DIR, 'packages/peers-2.0'),
+    );
+
+    let spy = sinon.spy(packageInstaller, 'install');
+    await packageManager.resolve(
+      'peers',
+      path.join(FIXTURES_DIR, 'empty/index.js'),
+      {shouldAutoInstall: true},
+    );
+    assert.deepEqual(spy.args, [
+      [
+        {
+          cwd: path.join(FIXTURES_DIR, 'empty'),
+          packagePath: path.join(FIXTURES_DIR, 'empty/package.json'),
+          fs,
+          saveDev: true,
+          modules: [{name: 'peers', range: undefined}],
+        },
+      ],
+      [
+        {
+          cwd: path.join(FIXTURES_DIR, 'empty'),
+          packagePath: path.join(FIXTURES_DIR, 'empty/package.json'),
+          fs,
+          saveDev: true,
+          modules: [{name: 'foo', range: '^2.0.0'}],
+        },
+      ],
+    ]);
+  });
+
+  describe('range mismatch', () => {
+    it("cannot autoinstall if there's a local requirement", async () => {
+      packageManager.invalidate(
+        'foo',
+        path.join(FIXTURES_DIR, 'has-foo/index.js'),
+      );
+
+      // $FlowFixMe assert.rejects is Node 10+
+      await assert.rejects(
+        () =>
+          packageManager.resolve(
+            'foo',
+            path.join(FIXTURES_DIR, 'has-foo/index.js'),
+            {
+              range: '^2.0.0',
+            },
+          ),
+        err => {
+          invariant(err instanceof ThrowableDiagnostic);
+          assert.equal(
+            err.message,
+            'Could not find module "foo" satisfying ^2.0.0.',
+          );
+          return true;
+        },
+      );
+    });
+
+    it("can autoinstall into local package if there isn't a local requirement", async () => {
+      packageInstaller.register(
+        'foo',
+        fs,
+        path.join(FIXTURES_DIR, 'packages/foo-2.0'),
+      );
+
+      let spy = sinon.spy(packageInstaller, 'install');
+      check(
+        await packageManager.resolve(
+          'foo',
+          path.join(FIXTURES_DIR, 'has-foo/subpackage/index.js'),
+          {
+            range: '^2.0.0',
+            shouldAutoInstall: true,
+          },
+        ),
+        {
+          pkg: {
+            name: 'foo',
+            version: '2.0.0',
+          },
+          resolved: path.join(
+            FIXTURES_DIR,
+            'has-foo/subpackage/node_modules/foo/index.js',
+          ),
+          type: 1,
+          invalidateOnFileChange: new Set([
+            path.join(FIXTURES_DIR, 'has-foo/subpackage/package.json'),
+            path.join(
+              FIXTURES_DIR,
+              'has-foo/subpackage/node_modules/foo/package.json',
+            ),
+          ]),
+          invalidateOnFileCreate: [
+            {
+              filePath: path.join(
+                FIXTURES_DIR,
+                'has-foo/subpackage/node_modules/foo/index.ts',
+              ),
+            },
+            {
+              filePath: path.join(
+                FIXTURES_DIR,
+                'has-foo/subpackage/node_modules/foo/index.tsx',
+              ),
+            },
+            {
+              fileName: 'node_modules/foo',
+              aboveFilePath: path.join(FIXTURES_DIR, 'has-foo/subpackage'),
+            },
+            {
+              fileName: 'tsconfig.json',
+              aboveFilePath: path.join(FIXTURES_DIR, 'has-foo/subpackage'),
+            },
+          ],
+        },
+      );
+
+      assert.deepEqual(spy.args, [
+        [
+          {
+            cwd: path.join(FIXTURES_DIR, 'has-foo/subpackage'),
+            packagePath: path.join(
+              FIXTURES_DIR,
+              'has-foo/subpackage/package.json',
+            ),
+            fs,
+            saveDev: true,
+            modules: [{name: 'foo', range: '^2.0.0'}],
+          },
+        ],
+      ]);
+    });
+
+    it("cannot autoinstall peer dependencies if there's an incompatible local requirement", async () => {
+      packageManager.invalidate(
+        'peers',
+        path.join(FIXTURES_DIR, 'has-foo/index.js'),
+      );
+      packageInstaller.register(
+        'foo',
+        fs,
+        path.join(FIXTURES_DIR, 'packages/foo-2.0'),
+      );
+      packageInstaller.register(
+        'peers',
+        fs,
+        path.join(FIXTURES_DIR, 'packages/peers-2.0'),
+      );
+
+      // $FlowFixMe assert.rejects is Node 10+
+      await assert.rejects(
+        () =>
+          packageManager.resolve(
+            'peers',
+            path.join(FIXTURES_DIR, 'has-foo/index.js'),
+            {
+              range: '^2.0.0',
+              shouldAutoInstall: true,
+            },
+          ),
+        err => {
+          assert(err instanceof ThrowableDiagnostic);
+          assert.equal(
+            err.message,
+            'Could not install the peer dependency "foo" for "peers", installed version 1.1.0 is incompatible with ^2.0.0',
+          );
+          return true;
+        },
+      );
+    });
+  });
+});

package/test/fixtures/empty/package.json

@@ -0,0 +1 @@
+{}

package/test/fixtures/has-a-not-yet-installed/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "a": "1.1.0"
+  }
+}

package/test/fixtures/has-foo/node_modules/foo/index.js

@@ -0,0 +1 @@
+module.exports = 'foobar';

package/test/fixtures/has-foo/node_modules/foo/package.json

@@ -0,0 +1,3 @@
+{
+  "version": "1.1.0"
+}

package/test/fixtures/has-foo/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "foo": "1.1.0"
+  }
+}

package/test/fixtures/has-foo/subpackage/package.json

@@ -0,0 +1 @@
+{}

package/test/fixtures/packages/a/index.js

@@ -0,0 +1 @@
+module.exports = 'a';

package/test/fixtures/packages/a/package.json

@@ -0,0 +1,3 @@
+{
+  "name": "a"
+}

package/test/fixtures/packages/foo-2.0/index.js

@@ -0,0 +1 @@
+module.exports = 'foo';

package/test/fixtures/packages/foo-2.0/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "foo",
+  "version": "2.0.0"
+}

package/test/fixtures/packages/peers/index.js

@@ -0,0 +1 @@
+module.exports = 'foo';

package/test/fixtures/packages/peers/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "peers",
+  "version": "1.0.0",
+  "peerDependencies": {
+    "foo": "^1.0.0"
+  }
+}

package/test/fixtures/packages/peers-2.0/index.js

@@ -0,0 +1 @@
+module.exports = 'foo';

package/test/fixtures/packages/peers-2.0/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "peers",
+  "version": "2.0.0",
+  "peerDependencies": {
+    "foo": "^2.0.0"
+  }
+}

package/test/getCurrentPackageManager.test.js

@@ -0,0 +1,28 @@
+// @flow
+import assert from 'assert';
+import getCurrentPackageManager from '../src/getCurrentPackageManager';
+
+describe('getCurrentPackageManager', () => {
+  it('yarn', () => {
+    const npm_config_user_agent = 'yarn/1.22.21 npm/? node/v21.1.0 darwin x64';
+    const currentPackageManager = getCurrentPackageManager(
+      npm_config_user_agent,
+    );
+    assert(currentPackageManager?.name, 'yarn');
+  });
+  it('npm', () => {
+    const npm_config_user_agent =
+      'npm/10.2.0 node/v21.1.0 darwin x64 workspaces/true';
+    const currentPackageManager = getCurrentPackageManager(
+      npm_config_user_agent,
+    );
+    assert(currentPackageManager?.name, 'npm');
+  });
+  it('pnpm', () => {
+    const npm_config_user_agent = 'pnpm/8.14.2 npm/? node/v18.17.1 darwin x64';
+    const currentPackageManager = getCurrentPackageManager(
+      npm_config_user_agent,
+    );
+    assert(currentPackageManager?.name, 'pnpm');
+  });
+});

package/test/validateModuleSpecifiers.test.js

@@ -0,0 +1,38 @@
+// @flow
+import assert from 'assert';
+
+import validateModuleSpecifier from '../src/validateModuleSpecifier';
+
+describe('Validate Module Specifiers', () => {
+  it('Validate Module Specifiers', () => {
+    let modules = [
+      '@parcel/transformer-posthtml/package.json',
+      '@some-org/package@v1.0.0',
+      '@org/some-package@v1.0.0-alpha.1',
+      'something.js/something/index.js',
+      '@some.org/something.js/index.js',
+      'lodash/something/index.js',
+    ];
+
+    assert.deepEqual(
+      modules.map(module => validateModuleSpecifier(module)),
+      [
+        '@parcel/transformer-posthtml',
+        '@some-org/package@v1.0.0',
+        '@org/some-package@v1.0.0-alpha.1',
+        'something.js',
+        '@some.org/something.js',
+        'lodash',
+      ],
+    );
+  });
+
+  it('Return empty on invalid modules', () => {
+    let modules = ['./somewhere.js', './hello/world.js', '~/hello/world.js'];
+
+    assert.deepEqual(
+      modules.map(module => validateModuleSpecifier(module)),
+      ['', '', ''],
+    );
+  });
+});