Add option packToPath to pack packages instead of publishing (#1076)

Author: ecraig12345

change/beachball-55d9e364-8092-44cb-b48b-1c8adf681703.json

@@ -0,0 +1,7 @@
+{
+  "type": "minor",
+  "comment": "Add option packToPath to pack packages instead of publishing",
+  "packageName": "beachball",
+  "email": "elcraig@microsoft.com",
+  "dependentChangeType": "patch"
+}

src/__e2e__/publishGit.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, beforeAll, beforeEach, afterEach, jest } from '@jest/globals';
+import { describe, expect, it, beforeEach, afterEach } from '@jest/globals';
 import fs from 'fs-extra';
 import { defaultRemoteBranchName } from '../__fixtures__/gitDefaults';
 import { generateChangeFiles, getChangeFiles } from '../__fixtures__/changeFiles';
@@ -38,10 +38,6 @@ describe('publish command (git)', () => {
     };
   }
 
-  beforeAll(() => {
-    jest.setTimeout(30000);
-  });
-
   beforeEach(() => {
     repositoryFactory = new RepositoryFactory('single');
   });

src/__e2e__/publishRegistry.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it, afterEach, jest } from '@jest/globals';
+import fs from 'fs';
 import { defaultRemoteBranchName } from '../__fixtures__/gitDefaults';
 import { generateChangeFiles } from '../__fixtures__/changeFiles';
 import { initMockLogs } from '../__fixtures__/mockLogs';
@@ -9,6 +10,7 @@ import { publish } from '../commands/publish';
 import { getDefaultOptions } from '../options/getDefaultOptions';
 import type { BeachballOptions } from '../types/BeachballOptions';
 import { initNpmMock } from '../__fixtures__/mockNpm';
+import { removeTempDir, tmpdir } from '../__fixtures__/tmpdir';
 
 // Spawning actual npm to run commands against a fake registry is extremely slow, so mock it for
 // this test (packagePublish covers the more complete npm registry scenario).
@@ -22,11 +24,12 @@ describe('publish command (registry)', () => {
 
   let repositoryFactory: RepositoryFactory | undefined;
   let repo: Repository | undefined;
+  let packToPath: string | undefined;
 
   // show error logs for these tests
   const logs = initMockLogs({ alsoLog: ['error'] });
 
-  function getOptions(): BeachballOptions {
+  function getOptions(options?: Partial<BeachballOptions>): BeachballOptions {
     return {
       ...getDefaultOptions(),
       branch: defaultRemoteBranchName,
@@ -41,13 +44,16 @@ describe('publish command (registry)', () => {
       tag: 'latest',
       yes: true,
       access: 'public',
+      ...options,
     };
   }
 
   afterEach(() => {
     repositoryFactory?.cleanUp();
     repositoryFactory = undefined;
     repo = undefined;
+    packToPath && removeTempDir(packToPath);
+    packToPath = undefined;
   });
 
   it('publishes single package', async () => {
@@ -66,6 +72,21 @@ describe('publish command (registry)', () => {
     expect(publishedPackage.versions).toHaveLength(1);
   });
 
+  it('packs single package', async () => {
+    repositoryFactory = new RepositoryFactory('single');
+    repo = repositoryFactory.cloneRepository();
+    packToPath = tmpdir({ prefix: 'beachball-pack-' });
+
+    const options = getOptions({ packToPath });
+    generateChangeFiles(['foo'], options);
+    repo.push();
+
+    await publish(options);
+
+    expect(fs.readdirSync(packToPath)).toEqual(['1-foo-1.1.0.tgz']);
+    await npmShow('foo', { shouldFail: true });
+  });
+
   it('publishes in monorepo with mixed public and private packages', async () => {
     repositoryFactory = new RepositoryFactory({
       folders: {
@@ -115,6 +136,34 @@ describe('publish command (registry)', () => {
     expect(showBar['dist-tags'].latest).toEqual('1.1.0');
   });
 
+  it('packs many packages', async () => {
+    const packageNames = Array.from({ length: 11 }, (_, i) => `pkg-${i + 1}`);
+    repositoryFactory = new RepositoryFactory({
+      folders: {
+        packages: Object.fromEntries(
+          packageNames.map((name, i) => [
+            name,
+            // Each package depends on the next one, so they must be published in reverse alphabetical order
+            { version: '1.0.0', dependencies: { [packageNames[i + 1] || 'other']: '^1.0.0' } },
+          ])
+        ),
+      },
+    });
+    repo = repositoryFactory.cloneRepository();
+    packToPath = tmpdir({ prefix: 'beachball-pack-' });
+
+    const options = getOptions({ packToPath, groupChanges: true });
+    generateChangeFiles(packageNames, options);
+    repo.push();
+
+    await publish(options);
+
+    expect(fs.readdirSync(packToPath).sort()).toEqual(
+      [...packageNames].reverse().map((name, i) => `${String(i + 1).padStart(2, '0')}-${name}-1.1.0.tgz`)
+    );
+    await npmShow('pkg-1', { shouldFail: true });
+  });
+
   it('succeeds even with a non-existent package listed in a change file', async () => {
     repositoryFactory = new RepositoryFactory({
       folders: {

src/__fixtures__/mockNpm.test.ts

@@ -6,7 +6,14 @@ import { afterAll, afterEach, beforeAll, describe, expect, it, jest } from '@jes
 import fs from 'fs-extra';
 import { type NpmResult, npm } from '../packageManager/npm';
 import type { PackageJson } from '../types/PackageInfo';
-import { initNpmMock, _makeRegistryData, _mockNpmPublish, _mockNpmShow, type MockNpmResult } from './mockNpm';
+import {
+  initNpmMock,
+  _makeRegistryData,
+  _mockNpmPack,
+  _mockNpmPublish,
+  _mockNpmShow,
+  type MockNpmResult,
+} from './mockNpm';
 
 jest.mock('fs-extra');
 jest.mock('../packageManager/npm');
@@ -277,6 +284,69 @@ describe('_mockNpmPublish', () => {
   });
 });
 
+describe('_mockNpmPack', () => {
+  let packageJson: PackageJson | undefined;
+  let writtenFiles: (fs.PathLike | number)[] = [];
+
+  beforeAll(() => {
+    (fs.readJsonSync as jest.MockedFunction<typeof fs.readJsonSync>).mockImplementation(() => {
+      if (!packageJson) throw new Error('packageJson not set');
+      return packageJson;
+    });
+    (fs.writeFileSync as jest.MockedFunction<typeof fs.writeFileSync>).mockImplementation(filePath => {
+      writtenFiles.push(String(filePath).replace(/\\/g, '/'));
+    });
+  });
+
+  afterEach(() => {
+    packageJson = undefined;
+    writtenFiles = [];
+  });
+
+  afterAll(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('throws if cwd is not specified', async () => {
+    await expect(() => _mockNpmPack({}, [], { cwd: undefined })).rejects.toThrow('cwd is required for mock npm pack');
+  });
+
+  it('errors if reading package.json fails', async () => {
+    // this error is from the fs.readJsonSync mock, but it's the same code path as if reading the file fails
+    await expect(() => _mockNpmPack({}, [], { cwd: 'fake' })).rejects.toThrow('packageJson not set');
+  });
+
+  it('packs unscoped package', async () => {
+    const registryData = {};
+    packageJson = { name: 'foo', version: '1.0.0' };
+    const result = await _mockNpmPack(registryData, [], { cwd: 'fake' });
+    expect(result).toEqual({
+      success: true,
+      failed: false,
+      all: 'foo-1.0.0.tgz',
+      stdout: 'foo-1.0.0.tgz',
+      stderr: '',
+    });
+    expect(writtenFiles).toEqual(['fake/foo-1.0.0.tgz']);
+    expect(registryData).toEqual({});
+  });
+
+  it('packs scoped package', async () => {
+    const registryData = {};
+    packageJson = { name: '@foo/bar', version: '2.0.0' };
+    const result = await _mockNpmPack(registryData, [], { cwd: 'fake' });
+    expect(result).toEqual({
+      success: true,
+      failed: false,
+      all: 'foo-bar-2.0.0.tgz',
+      stdout: 'foo-bar-2.0.0.tgz',
+      stderr: '',
+    });
+    expect(writtenFiles).toEqual(['fake/foo-bar-2.0.0.tgz']);
+    expect(registryData).toEqual({});
+  });
+});
+
 describe('mockNpm', () => {
   const npmMock = initNpmMock();
   let packageJson: PackageJson | undefined;
@@ -334,7 +404,7 @@ describe('mockNpm', () => {
   });
 
   it('throws on unsupported command', async () => {
-    await expect(() => npm(['pack'], { cwd: undefined })).rejects.toThrow('Command not supported by mock npm: pack');
+    await expect(() => npm(['foo'], { cwd: undefined })).rejects.toThrow('Command not supported by mock npm: foo');
   });
 
   it('respects mocked command', async () => {

src/__fixtures__/mockNpm.ts

@@ -81,6 +81,7 @@ export function initNpmMock(): NpmMock {
   const defaultMocks: Record<string, MockNpmCommand> = {
     show: _mockNpmShow,
     publish: _mockNpmPublish,
+    pack: _mockNpmPack,
   };
   let overrideMocks: Record<string, MockNpmCommand> = {};
   let registryData: MockNpmRegistry = {};
@@ -233,3 +234,29 @@ function mockPublishPackage(registryData: MockNpmRegistry, packageJson: PackageJ
 
   return `[fake] published ${name}@${version} with tag ${tag}`;
 }
+
+/**
+ * Return a .tgz filename following npm's naming scheme.
+ */
+export function getMockNpmPackName(packageJson: PackageJson) {
+  const { name, version } = packageJson;
+  // Note this may be less name sanitization than npm does, but it doesn't matter for tests.
+  const safeName = name.startsWith('@') ? name.slice(1).replace('/', '-') : name;
+  return `${safeName}-${version}.tgz`;
+}
+
+export const _mockNpmPack: MockNpmCommand = async (registryData, args, opts) => {
+  if (!opts?.cwd) {
+    throw new Error('cwd is required for mock npm pack');
+  }
+
+  // Read package.json from cwd to find the package name and version.
+  // (If this fails, let the exception propagate for easier debugging.)
+  const packageJson = fs.readJsonSync(path.join(opts.cwd, 'package.json')) as PackageJson;
+
+  // Create a fake ".tgz" file with npm's naming scheme (contents don't matter).
+  const packFileName = getMockNpmPackName(packageJson);
+  fs.writeFileSync(path.join(opts.cwd, packFileName), 'fake package contents');
+
+  return { stdout: packFileName, stderr: '', all: packFileName, success: true, failed: false };
+};