@servicetitan/startup 33.1.1 → 34.0.0

package/src/cli/commands/__tests__/mfe-package-publish.test.ts

@@ -8,15 +8,20 @@ import {
     npmPackageSet,
     npmPublish,
     npmTagVersion,
+    npmView,
     runCommand,
 } from '../../utils';
 import { MFEPackagePublish } from '../mfe-package-publish';
+import { ROLLBACK_TAG_SUFFIX } from '../utils';
 
 jest.mock('fs', () => fs);
+jest.mock('yargs', () => jest.fn());
+jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
+
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
     isWebComponent: jest.fn(),
-    log: { info: jest.fn(), warning: jest.fn() },
+    log: { info: jest.fn(), warning: jest.fn(), error: jest.fn() },
 }));
 jest.mock('../../utils', () => ({
     ...jest.requireActual('../../utils'),
@@ -26,17 +31,22 @@ jest.mock('../../utils', () => ({
     npmPackageSet: jest.fn(),
     npmPublish: jest.fn(),
     npmTagVersion: jest.fn(),
+    npmView: jest.fn(),
     runCommand: jest.fn(),
 }));
 
 describe(`[startup] ${MFEPackagePublish.name}`, () => {
     const defaultRegistry = 'https://verdaccio.servicetitan.com';
     const branch = 'master';
+    const tag = 'prod';
+    const rollbackTag = `${tag}${ROLLBACK_TAG_SUFFIX}`;
+    const previousVersion = 'bar';
     const commitHash = '6c461f1a';
     const packageName = '@servicetitan/foo';
     let args: ConstructorParameters<typeof MFEPackagePublish>[0];
 
-    const defaultPackageVersion = () => `0.0.0-${branch}.${commitHash}`;
+    const buildPackageVersion = (branchOverride?: string) =>
+        `0.0.0-${branchOverride ?? branch}.${commitHash}`;
 
     beforeEach(() => {
         args = {};
@@ -45,6 +55,13 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
         jest.mocked(gitGetBranch).mockReturnValue(branch);
         jest.mocked(gitGetCommitHash).mockReturnValue(commitHash);
         jest.mocked(npmGetPackageVersions).mockReturnValue([]);
+        jest.mocked(npmPublish).mockResolvedValue(undefined);
+        jest.mocked(npmTagVersion).mockResolvedValue(undefined);
+        jest.mocked(npmView).mockReturnValue({
+            'name': packageName,
+            'version': previousVersion,
+            'dist-tags': { [tag]: previousVersion },
+        });
         vol.fromNestedJSON({
             'package.json': JSON.stringify({ name: packageName, files: [] }),
             'tsconfig.json': JSON.stringify({
@@ -78,7 +95,7 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
     test('sets package version', async () => {
         await subject();
 
-        expect(npmPackageSet).toHaveBeenCalledWith('version', defaultPackageVersion());
+        expect(npmPackageSet).toHaveBeenCalledWith('version', buildPackageVersion());
     });
 
     test('sets package registry', async () => {
@@ -92,17 +109,7 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
 
         const metadata = JSON.parse(fs.readFileSync('dist/metadata.json', 'utf8').toString());
 
-        expect(metadata.version).toBe(defaultPackageVersion());
-    });
-
-    describe('with "registry" argument', () => {
-        beforeEach(() => (args.registry = 'https://foo'));
-
-        test('sets package registry to specified value', async () => {
-            await subject();
-
-            expect(npmPackageSet).toHaveBeenCalledWith('publishConfig.registry', args.registry);
-        });
+        expect(metadata.version).toBe(buildPackageVersion());
     });
 
     test('publishes package and logs message', async () => {
@@ -110,7 +117,7 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
 
         expect(npmPublish).toHaveBeenCalled();
         expect(log.info).toHaveBeenCalledWith(
-            expect.stringContaining(`published ${packageName} version ${defaultPackageVersion()}`)
+            expect.stringContaining(`Publishing ${packageName} version ${buildPackageVersion()}`)
         );
     });
 
@@ -118,39 +125,31 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
         await subject();
 
         expect(runCommand).toHaveBeenCalledWith(
-            `npx startup upload-sourcemaps --releaseVersion=${defaultPackageVersion()}`
+            `npx startup upload-sourcemaps --releaseVersion=${buildPackageVersion()}`
         );
     });
 
-    function itDoesNotUploadSourcemaps() {
-        test('does not upload sourcemaps', async () => {
-            await subject();
+    test('gets current tagged versions before publishing', async () => {
+        await subject();
 
-            expect(runCommand).not.toHaveBeenCalledWith(
-                expect.stringContaining('upload-sourcemaps')
-            );
+        expect(npmView).toHaveBeenCalledWith({
+            packageName,
+            registry: defaultRegistry,
         });
-    }
-
-    describe('with "uploadSourcemaps: false"', () => {
-        beforeEach(() => (args.uploadSourcemaps = false));
-
-        itDoesNotUploadSourcemaps();
     });
 
-    describe('when branch configuration includes "uploadSourcemaps: false"', () => {
-        beforeEach(() =>
-            vol.fromJSON({
-                'package.json': JSON.stringify({
-                    name: packageName,
-                    cli: {
-                        'web-component': { branches: { [branch]: { uploadSourcemaps: false } } },
-                    },
-                }),
-            })
-        );
+    test(`tags previous version with {tag}${ROLLBACK_TAG_SUFFIX}`, async () => {
+        await subject();
+        expect(npmTagVersion).toHaveBeenCalledWith({
+            packageName,
+            packageVersion: previousVersion,
+            registry: defaultRegistry,
+            tag: rollbackTag,
+        });
 
-        itDoesNotUploadSourcemaps();
+        expect(log.info).toHaveBeenCalledWith(
+            `Tagging previous version ${previousVersion} with tag "${rollbackTag}"`
+        );
     });
 
     Object.entries({ dev: ['dev', 'develop'], next: ['next'], prod: ['master'] }).forEach(
@@ -167,34 +166,25 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
         }
     );
 
-    describe('with "tag" argument', () => {
-        beforeEach(() => (args.tag = 'foo'));
+    describe('with "registry" argument', () => {
+        beforeEach(() => (args.registry = 'https://foo'));
 
-        test('uses specified tag', async () => {
+        test('sets package registry to specified value', async () => {
             await subject();
 
-            expect(npmPublish).toHaveBeenCalledWith(expect.objectContaining({ tag: args.tag }));
+            expect(npmPackageSet).toHaveBeenCalledWith('publishConfig.registry', args.registry);
         });
     });
 
-    describe('when branch configuration includes "publishTag"', () => {
-        const branchConfig: WebComponentBranchConfigs = { publishTag: 'foo' };
+    describe('with "tag" argument', () => {
+        const tag = 'foo';
 
-        beforeEach(() =>
-            vol.fromJSON({
-                'package.json': JSON.stringify({
-                    name: packageName,
-                    cli: { 'web-component': { branches: { [branch]: branchConfig } } },
-                }),
-            })
-        );
+        beforeEach(() => (args.tag = tag));
 
-        test('uses configured "publishTag"', async () => {
+        test('uses specified tag', async () => {
             await subject();
 
-            expect(npmPublish).toHaveBeenCalledWith(
-                expect.objectContaining({ tag: branchConfig.publishTag })
-            );
+            expect(npmPublish).toHaveBeenCalledWith(expect.objectContaining({ tag: args.tag }));
         });
     });
 
@@ -225,21 +215,201 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
             );
         });
 
-        test('logs message', async () => {
+        test('logs messages', async () => {
             await subject();
 
             expect(log.info).toHaveBeenCalledWith(
                 expect.stringContaining(
-                    `(dry-run) published ${packageName} version ${defaultPackageVersion()}`
+                    `(dry-run) Publishing ${packageName} version ${buildPackageVersion()}`
                 )
             );
+            expect(log.info).toHaveBeenCalledWith(
+                `(dry-run) Tagging previous version ${previousVersion} with tag "${rollbackTag}"`
+            );
+        });
+
+        test('does not tag previous version', async () => {
+            await subject();
+
+            expect(npmTagVersion).not.toHaveBeenCalled();
         });
 
         test('uploads sourcemaps with "--dry" option', async () => {
             await subject();
 
             expect(runCommand).toHaveBeenCalledWith(
-                `npx startup upload-sourcemaps --dry --releaseVersion=${defaultPackageVersion()}`
+                `npx startup upload-sourcemaps --dry --releaseVersion=${buildPackageVersion()}`
+            );
+        });
+    });
+
+    function itDoesNotUploadSourcemaps() {
+        test('does not upload sourcemaps', async () => {
+            await subject();
+
+            expect(runCommand).not.toHaveBeenCalledWith(
+                expect.stringContaining('upload-sourcemaps')
+            );
+        });
+    }
+
+    describe('with "uploadSourcemaps: false"', () => {
+        beforeEach(() => (args.uploadSourcemaps = false));
+
+        itDoesNotUploadSourcemaps();
+    });
+
+    describe('when branch configuration includes "uploadSourcemaps: false"', () => {
+        beforeEach(() =>
+            vol.fromJSON({
+                'package.json': JSON.stringify({
+                    name: packageName,
+                    cli: {
+                        'web-component': { branches: { [branch]: { uploadSourcemaps: false } } },
+                    },
+                }),
+            })
+        );
+
+        itDoesNotUploadSourcemaps();
+    });
+
+    describe('with "trackHistory: false"', () => {
+        beforeEach(() => {
+            args.trackHistory = false;
+        });
+
+        test('skips tagging rollback and logs', async () => {
+            await subject();
+
+            expect(npmTagVersion).not.toHaveBeenCalled();
+            expect(log.info).toHaveBeenCalledWith(
+                'Track history is turned off, skipping rollback tag'
+            );
+        });
+    });
+
+    describe('when no previous version exists', () => {
+        beforeEach(() => {
+            jest.mocked(npmView).mockReturnValue({
+                'name': packageName,
+                'version': previousVersion,
+                'dist-tags': {},
+            });
+        });
+
+        test('skips tagging rollback and logs', async () => {
+            await subject();
+
+            expect(npmTagVersion).not.toHaveBeenCalled();
+            expect(log.info).toHaveBeenCalledWith(
+                `No previous version published with tag "${tag}", skipping rollback tag`
+            );
+        });
+    });
+
+    describe('when previous version equals current version', () => {
+        beforeEach(() => {
+            args.build = 'same-version';
+            jest.mocked(npmView).mockReturnValue({
+                'name': packageName,
+                'version': `0.0.0-${args.build}`,
+                'dist-tags': { [tag]: `0.0.0-${args.build}` },
+            });
+        });
+
+        test('skips tagging rollback and logs', async () => {
+            await subject();
+
+            expect(npmTagVersion).not.toHaveBeenCalled();
+            expect(log.info).not.toHaveBeenCalledWith(
+                expect.stringContaining('Tagging previous version')
+            );
+            expect(log.info).toHaveBeenCalledWith(
+                `Version "0.0.0-${args.build}" is already tagged "${tag}", skipping rollback tag`
+            );
+        });
+    });
+
+    describe('when tagging rollback fails', () => {
+        const error = new Error('Failed to apply rollback tag');
+
+        beforeEach(() => {
+            jest.mocked(npmTagVersion).mockRejectedValue(error);
+        });
+
+        test('throws error and skips publishing', async () => {
+            jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn()); // suppress error output
+            await expect(subject).rejects.toThrow(error);
+
+            expect(npmPublish).not.toHaveBeenCalled();
+            expect(runCommand).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('when publish fails after rollback tag is applied', () => {
+        const currentTaggedVersion = 'current-v2.0.0';
+        const rollbackTaggedVersion = 'original-rollback-v1.0.0';
+        const error = new Error('Publish failed');
+
+        beforeEach(() => {
+            jest.mocked(npmView).mockReturnValueOnce({
+                'name': packageName,
+                'version': 'some-version',
+                'dist-tags': {
+                    [tag]: currentTaggedVersion,
+                    [rollbackTag]: rollbackTaggedVersion,
+                },
+            });
+
+            jest.mocked(npmPublish).mockRejectedValue(error);
+        });
+
+        test('restores rollback tag to the version it started on', async () => {
+            jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn()); // suppress error output
+
+            await expect(subject).rejects.toThrow(error.message);
+
+            expect(npmTagVersion).toHaveBeenNthCalledWith(
+                1,
+                expect.objectContaining({
+                    packageName,
+                    packageVersion: currentTaggedVersion,
+                    tag: rollbackTag,
+                })
+            );
+            expect(npmTagVersion).toHaveBeenNthCalledWith(
+                2,
+                expect.objectContaining({
+                    packageName,
+                    packageVersion: rollbackTaggedVersion,
+                    tag: rollbackTag,
+                })
+            );
+            expect(log.error).toHaveBeenCalledWith(`Failed to publish package ${packageName}`);
+            expect(log.info).toHaveBeenCalledWith(
+                `Restoring rollback tag ${rollbackTag} back to version ${rollbackTaggedVersion}`
+            );
+        });
+    });
+
+    describe('when branch configuration includes "publishTag"', () => {
+        const branchConfig: WebComponentBranchConfigs = { publishTag: 'foo' };
+
+        beforeEach(() =>
+            vol.fromJSON({
+                'package.json': JSON.stringify({
+                    name: packageName,
+                    cli: { 'web-component': { branches: { [branch]: branchConfig } } },
+                }),
+            })
+        );
+
+        test('uses configured "publishTag"', async () => {
+            await subject();
+
+            expect(npmPublish).toHaveBeenCalledWith(
+                expect.objectContaining({ tag: branchConfig.publishTag })
             );
         });
     });
@@ -283,56 +453,113 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
         });
     }
 
+    function itTagsPublishedVersion(tag?: string) {
+        test(`tags published version`, async () => {
+            await subject();
+
+            expect(npmTagVersion).toHaveBeenCalledWith({
+                packageName,
+                packageVersion: buildPackageVersion(),
+                registry: defaultRegistry,
+                tag,
+            });
+            expect(log.info).toHaveBeenCalledWith(
+                `Tagging version ${buildPackageVersion()} with tag "${tag}"`
+            );
+        });
+    }
+
     describe('when version is already published', () => {
         beforeEach(() =>
-            jest.mocked(npmGetPackageVersions).mockReturnValue([defaultPackageVersion()])
+            jest.mocked(npmGetPackageVersions).mockReturnValue([buildPackageVersion()])
         );
 
         itLogsMessageAndSkipsPublishing(/is already published/);
 
-        describe('with "tag" argument', () => {
-            beforeEach(() => (args.tag = 'foo'));
+        itTagsPublishedVersion(tag);
 
-            test('tags the published version in default registry', async () => {
-                await subject();
+        describe('when tagging published version fails', () => {
+            const error = new Error('Tagging failed');
 
-                expect(npmTagVersion).toHaveBeenCalledWith({
-                    packageName,
-                    packageVersion: defaultPackageVersion(),
-                    registry: defaultRegistry,
-                    tag: args.tag,
-                });
-                expect(log.info).toHaveBeenCalledWith(
-                    expect.stringMatching(`adding tag "${args.tag}"`)
-                );
+            beforeEach(() => {
+                jest.mocked(npmTagVersion).mockResolvedValueOnce(undefined); // rollback tag
+                jest.mocked(npmTagVersion).mockRejectedValueOnce(error); // tag published
+                jest.mocked(npmTagVersion).mockResolvedValue(undefined); // restore rollback
             });
 
-            describe('with "registry" argument', () => {
-                beforeEach(() => (args.registry = 'https://foo'));
+            test('logs error', async () => {
+                jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn()); // suppress error output
+                await expect(subject).rejects.toThrow(error);
 
-                test('tags the published version in specified registry', async () => {
-                    await subject();
+                expect(log.error).toHaveBeenCalledWith(`Failed to publish package ${packageName}`);
+            });
 
-                    expect(npmTagVersion).toHaveBeenCalledWith({
-                        packageName,
-                        packageVersion: defaultPackageVersion(),
-                        registry: args.registry,
-                        tag: args.tag,
+            describe('when there is an existing version with rollback tag', () => {
+                const rollbackVersion = 'rollback-version';
+
+                beforeEach(() => {
+                    jest.mocked(npmView).mockReturnValueOnce({
+                        'name': packageName,
+                        'version': previousVersion,
+                        'dist-tags': {
+                            [tag]: previousVersion,
+                            [rollbackTag]: rollbackVersion,
+                        },
                     });
                 });
+
+                test('restores rollback tag', async () => {
+                    jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn()); // suppress error output
+                    await expect(subject).rejects.toThrow(error);
+
+                    expect(npmTagVersion).toHaveBeenCalledWith(
+                        expect.objectContaining({
+                            packageVersion: rollbackVersion,
+                            tag: rollbackTag,
+                        })
+                    );
+                });
             });
+        });
 
-            describe('when performing dry-run', () => {
-                beforeEach(() => (args.dry = true));
+        describe('with "tag" argument', () => {
+            const tag = 'foo';
 
-                test('does not tag published version', async () => {
-                    await subject();
+            beforeEach(() => (args.tag = tag));
 
-                    expect(npmTagVersion).not.toHaveBeenCalled();
-                    expect(log.info).toHaveBeenCalledWith(
-                        expect.stringMatching(/\(dry-run\) adding tag/)
-                    );
+            itTagsPublishedVersion(tag);
+        });
+
+        describe('with "registry" argument', () => {
+            const registry = 'https://foo';
+
+            beforeEach(() => (args.registry = registry));
+
+            test('uses specified registry', async () => {
+                await subject();
+
+                expect(npmTagVersion).toHaveBeenCalledWith({
+                    packageName,
+                    packageVersion: buildPackageVersion(),
+                    registry,
+                    tag,
                 });
+                expect(log.info).toHaveBeenCalledWith(
+                    `Tagging version ${buildPackageVersion()} with tag "${tag}"`
+                );
+            });
+        });
+
+        describe('with "dry" argument', () => {
+            beforeEach(() => (args.dry = true));
+
+            test('logs message and does not tag version', async () => {
+                await subject();
+
+                expect(npmTagVersion).not.toHaveBeenCalled();
+                expect(log.info).toHaveBeenCalledWith(
+                    `(dry-run) Tagging version ${buildPackageVersion()} with tag "${tag}"`
+                );
             });
         });
     });
@@ -346,7 +573,9 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
     });
 
     describe('with unrecognized branch', () => {
-        beforeEach(() => jest.mocked(gitGetBranch).mockReturnValue('foo'));
+        const branch = 'foo';
+
+        beforeEach(() => jest.mocked(gitGetBranch).mockReturnValue(branch));
 
         itLogsMessageAndSkipsPublishing(/branch is not configured for publishing/);