@redocly/cli 1.18.0 → 1.19.0

package/lib/cms/commands/__tests__/push-status.test.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const push_status_1 = require("../push-status");
 const remotes = {
@@ -22,9 +13,12 @@ jest.mock('colorette', () => ({
     magenta: (str) => str,
     cyan: (str) => str,
 }));
-jest.mock('../../api', () => (Object.assign(Object.assign({}, jest.requireActual('../../api')), { ReuniteApiClient: jest.fn().mockImplementation(function (...args) {
+jest.mock('../../api', () => ({
+    ...jest.requireActual('../../api'),
+    ReuniteApiClient: jest.fn().mockImplementation(function (...args) {
         this.remotes = remotes;
-    }) })));
+    }),
+}));
 jest.mock('@redocly/openapi-core', () => ({
     pause: jest.requireActual('@redocly/openapi-core').pause,
 }));
@@ -80,42 +74,54 @@ describe('handlePushStatus()', () => {
     afterEach(() => {
         jest.clearAllMocks();
     });
-    it('should throw error if organization not provided', () => __awaiter(void 0, void 0, void 0, function* () {
-        yield expect((0, push_status_1.handlePushStatus)({
-            domain: 'test-domain',
-            organization: '',
-            project: 'test-project',
-            pushId: 'test-push-id',
-        }, mockConfig)).rejects.toThrowErrorMatchingInlineSnapshot(`"No organization provided, please use --organization option or specify the 'organization' field in the config file."`);
+    it('should throw error if organization not provided', async () => {
+        await expect((0, push_status_1.handlePushStatus)({
+            argv: {
+                domain: 'test-domain',
+                organization: '',
+                project: 'test-project',
+                pushId: 'test-push-id',
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        })).rejects.toThrowErrorMatchingInlineSnapshot(`"No organization provided, please use --organization option or specify the 'organization' field in the config file."`);
         expect(process.stderr.write).toHaveBeenCalledWith(`No organization provided, please use --organization option or specify the 'organization' field in the config file.` +
             '\n\n');
-    }));
-    it('should print success push status for preview-build', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('should print success push status for preview-build', async () => {
         process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
         remotes.getPush.mockResolvedValueOnce(pushResponseStub);
-        yield (0, push_status_1.handlePushStatus)({
-            domain: 'test-domain',
-            organization: 'test-org',
-            project: 'test-project',
-            pushId: 'test-push-id',
-        }, mockConfig);
+        await (0, push_status_1.handlePushStatus)({
+            argv: {
+                domain: 'test-domain',
+                organization: 'test-org',
+                project: 'test-project',
+                pushId: 'test-push-id',
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
         expect(process.stdout.write).toHaveBeenCalledTimes(1);
         expect(process.stdout.write).toHaveBeenCalledWith('🚀 Preview deploy success.\nPreview URL: https://preview-test-url\n');
-    }));
-    it('should print success push status for preview and production builds', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('should print success push status for preview and production builds', async () => {
         process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-        remotes.getPush.mockResolvedValue(Object.assign(Object.assign({}, pushResponseStub), { isMainBranch: true }));
-        yield (0, push_status_1.handlePushStatus)({
-            domain: 'test-domain',
-            organization: 'test-org',
-            project: 'test-project',
-            pushId: 'test-push-id',
-        }, mockConfig);
+        remotes.getPush.mockResolvedValue({ ...pushResponseStub, isMainBranch: true });
+        await (0, push_status_1.handlePushStatus)({
+            argv: {
+                domain: 'test-domain',
+                organization: 'test-org',
+                project: 'test-project',
+                pushId: 'test-push-id',
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
         expect(process.stdout.write).toHaveBeenCalledTimes(2);
         expect(process.stdout.write).toHaveBeenCalledWith('🚀 Preview deploy success.\nPreview URL: https://preview-test-url\n');
         expect(process.stdout.write).toHaveBeenCalledWith('🚀 Production deploy success.\nProduction URL: https://production-test-url\n');
-    }));
-    it('should print failed push status for preview build', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('should print failed push status for preview build', async () => {
         process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
         remotes.getPush.mockResolvedValue({
             isOutdated: false,
@@ -124,18 +130,22 @@ describe('handlePushStatus()', () => {
                 preview: { deploy: { status: 'failed', url: 'https://preview-test-url' }, scorecard: [] },
             },
         });
-        yield expect((0, push_status_1.handlePushStatus)({
-            domain: 'test-domain',
-            organization: 'test-org',
-            project: 'test-project',
-            pushId: 'test-push-id',
-        }, mockConfig)).rejects.toThrowErrorMatchingInlineSnapshot(`
+        await expect((0, push_status_1.handlePushStatus)({
+            argv: {
+                domain: 'test-domain',
+                organization: 'test-org',
+                project: 'test-project',
+                pushId: 'test-push-id',
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        })).rejects.toThrowErrorMatchingInlineSnapshot(`
       "❌ Preview deploy fail.
       Preview URL: https://preview-test-url"
     `);
         expect(process.stderr.write).toHaveBeenCalledWith('❌ Preview deploy fail.\nPreview URL: https://preview-test-url' + '\n\n');
-    }));
-    it('should print success push status for preview build and print scorecards', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('should print success push status for preview build and print scorecards', async () => {
         process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
         remotes.getPush.mockResolvedValue({
             isOutdated: false,
@@ -154,19 +164,23 @@ describe('handlePushStatus()', () => {
                 },
             },
         });
-        yield (0, push_status_1.handlePushStatus)({
-            domain: 'test-domain',
-            organization: 'test-org',
-            project: 'test-project',
-            pushId: 'test-push-id',
-        }, mockConfig);
+        await (0, push_status_1.handlePushStatus)({
+            argv: {
+                domain: 'test-domain',
+                organization: 'test-org',
+                project: 'test-project',
+                pushId: 'test-push-id',
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
         expect(process.stdout.write).toHaveBeenCalledTimes(4);
         expect(process.stdout.write).toHaveBeenCalledWith('🚀 Preview deploy success.\nPreview URL: https://preview-test-url\n');
         expect(process.stdout.write).toHaveBeenCalledWith('\nScorecard:');
         expect(process.stdout.write).toHaveBeenCalledWith('\n    Name: test-name\n    Status: success\n    URL: test-url\n    Description: test-description\n');
         expect(process.stdout.write).toHaveBeenCalledWith('\n');
-    }));
-    it('should print message if there is no changes', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('should print message if there is no changes', async () => {
         process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
         remotes.getPush.mockResolvedValueOnce({
             isOutdated: false,
@@ -179,25 +193,33 @@ describe('handlePushStatus()', () => {
                 },
             },
         });
-        yield (0, push_status_1.handlePushStatus)({
-            domain: 'test-domain',
-            organization: 'test-org',
-            project: 'test-project',
-            pushId: 'test-push-id',
-            wait: true,
-        }, mockConfig);
-        expect(process.stderr.write).toHaveBeenCalledWith('Files not added to your project. Reason: no changes.\n');
-    }));
-    describe('return value', () => {
-        it('should return preview deployment info', () => __awaiter(void 0, void 0, void 0, function* () {
-            process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-            remotes.getPush.mockResolvedValue(Object.assign(Object.assign({}, pushResponseStub), { isMainBranch: false }));
-            const result = yield (0, push_status_1.handlePushStatus)({
+        await (0, push_status_1.handlePushStatus)({
+            argv: {
                 domain: 'test-domain',
                 organization: 'test-org',
                 project: 'test-project',
                 pushId: 'test-push-id',
-            }, mockConfig);
+                wait: true,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
+        expect(process.stderr.write).toHaveBeenCalledWith('Files not added to your project. Reason: no changes.\n');
+    });
+    describe('return value', () => {
+        it('should return preview deployment info', async () => {
+            process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+            remotes.getPush.mockResolvedValue({ ...pushResponseStub, isMainBranch: false });
+            const result = await (0, push_status_1.handlePushStatus)({
+                argv: {
+                    domain: 'test-domain',
+                    organization: 'test-org',
+                    project: 'test-project',
+                    pushId: 'test-push-id',
+                },
+                config: mockConfig,
+                version: 'cli-version',
+            });
             expect(result).toEqual({
                 preview: {
                     deploy: {
@@ -209,16 +231,20 @@ describe('handlePushStatus()', () => {
                 production: null,
                 commit: commitStub,
             });
-        }));
-        it('should return preview and production deployment info', () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        it('should return preview and production deployment info', async () => {
             process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-            remotes.getPush.mockResolvedValue(Object.assign(Object.assign({}, pushResponseStub), { isMainBranch: true }));
-            const result = yield (0, push_status_1.handlePushStatus)({
-                domain: 'test-domain',
-                organization: 'test-org',
-                project: 'test-project',
-                pushId: 'test-push-id',
-            }, mockConfig);
+            remotes.getPush.mockResolvedValue({ ...pushResponseStub, isMainBranch: true });
+            const result = await (0, push_status_1.handlePushStatus)({
+                argv: {
+                    domain: 'test-domain',
+                    organization: 'test-org',
+                    project: 'test-project',
+                    pushId: 'test-push-id',
+                },
+                config: mockConfig,
+                version: 'cli-version',
+            });
             expect(result).toEqual({
                 preview: {
                     deploy: {
@@ -236,37 +262,50 @@ describe('handlePushStatus()', () => {
                 },
                 commit: commitStub,
             });
-        }));
+        });
     });
     describe('"wait" option', () => {
-        it('should wait for preview "success" deployment status', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should wait for preview "success" deployment status', async () => {
             process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, pushResponseStub), { status: {
+            remotes.getPush.mockResolvedValueOnce({
+                ...pushResponseStub,
+                status: {
                     preview: {
                         deploy: { status: 'pending', url: 'https://preview-test-url' },
                         scorecard: [],
                     },
-                } }));
-            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, pushResponseStub), { status: {
+                },
+            });
+            remotes.getPush.mockResolvedValueOnce({
+                ...pushResponseStub,
+                status: {
                     preview: {
                         deploy: { status: 'running', url: 'https://preview-test-url' },
                         scorecard: [],
                     },
-                } }));
-            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, pushResponseStub), { status: {
+                },
+            });
+            remotes.getPush.mockResolvedValueOnce({
+                ...pushResponseStub,
+                status: {
                     preview: {
                         deploy: { status: 'success', url: 'https://preview-test-url' },
                         scorecard: [],
                     },
-                } }));
-            const result = yield (0, push_status_1.handlePushStatus)({
-                domain: 'test-domain',
-                organization: 'test-org',
-                project: 'test-project',
-                pushId: 'test-push-id',
-                'retry-interval': 0.5,
-                wait: true,
-            }, mockConfig);
+                },
+            });
+            const result = await (0, push_status_1.handlePushStatus)({
+                argv: {
+                    domain: 'test-domain',
+                    organization: 'test-org',
+                    project: 'test-project',
+                    pushId: 'test-push-id',
+                    'retry-interval': 0.5, // 500 ms
+                    wait: true,
+                },
+                config: mockConfig,
+                version: 'cli-version',
+            });
             expect(result).toEqual({
                 preview: {
                     deploy: {
@@ -278,10 +317,13 @@ describe('handlePushStatus()', () => {
                 production: null,
                 commit: commitStub,
             });
-        }));
-        it('should wait for production "success" status after preview "success" status', () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        it('should wait for production "success" status after preview "success" status', async () => {
             process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, pushResponseStub), { isMainBranch: true, status: {
+            remotes.getPush.mockResolvedValueOnce({
+                ...pushResponseStub,
+                isMainBranch: true,
+                status: {
                     preview: {
                         deploy: { status: 'success', url: 'https://preview-test-url' },
                         scorecard: [],
@@ -290,8 +332,12 @@ describe('handlePushStatus()', () => {
                         deploy: { status: 'pending', url: 'https://production-test-url' },
                         scorecard: [],
                     },
-                } }));
-            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, pushResponseStub), { isMainBranch: true, status: {
+                },
+            });
+            remotes.getPush.mockResolvedValueOnce({
+                ...pushResponseStub,
+                isMainBranch: true,
+                status: {
                     preview: {
                         deploy: { status: 'success', url: 'https://preview-test-url' },
                         scorecard: [],
@@ -300,8 +346,12 @@ describe('handlePushStatus()', () => {
                         deploy: { status: 'running', url: 'https://production-test-url' },
                         scorecard: [],
                     },
-                } }));
-            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, pushResponseStub), { isMainBranch: true, status: {
+                },
+            });
+            remotes.getPush.mockResolvedValueOnce({
+                ...pushResponseStub,
+                isMainBranch: true,
+                status: {
                     preview: {
                         deploy: { status: 'success', url: 'https://preview-test-url' },
                         scorecard: [],
@@ -310,15 +360,20 @@ describe('handlePushStatus()', () => {
                         deploy: { status: 'success', url: 'https://production-test-url' },
                         scorecard: [],
                     },
-                } }));
-            const result = yield (0, push_status_1.handlePushStatus)({
-                domain: 'test-domain',
-                organization: 'test-org',
-                project: 'test-project',
-                pushId: 'test-push-id',
-                'retry-interval': 0.5,
-                wait: true,
-            }, mockConfig);
+                },
+            });
+            const result = await (0, push_status_1.handlePushStatus)({
+                argv: {
+                    domain: 'test-domain',
+                    organization: 'test-org',
+                    project: 'test-project',
+                    pushId: 'test-push-id',
+                    'retry-interval': 0.5, // 500 ms
+                    wait: true,
+                },
+                config: mockConfig,
+                version: 'cli-version',
+            });
             expect(result).toEqual({
                 preview: {
                     deploy: { status: 'success', url: 'https://preview-test-url' },
@@ -330,43 +385,57 @@ describe('handlePushStatus()', () => {
                 },
                 commit: commitStub,
             });
-        }));
+        });
     });
     describe('"continue-on-deploy-failures" option', () => {
-        it('should throw error if option value is false', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should throw error if option value is false', async () => {
             process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, pushResponseStub), { status: {
+            remotes.getPush.mockResolvedValueOnce({
+                ...pushResponseStub,
+                status: {
                     preview: {
                         deploy: { status: 'failed', url: 'https://preview-test-url' },
                         scorecard: [],
                     },
-                } }));
-            yield expect((0, push_status_1.handlePushStatus)({
-                domain: 'test-domain',
-                organization: 'test-org',
-                project: 'test-project',
-                pushId: 'test-push-id',
-                'continue-on-deploy-failures': false,
-            }, mockConfig)).rejects.toThrowErrorMatchingInlineSnapshot(`
+                },
+            });
+            await expect((0, push_status_1.handlePushStatus)({
+                argv: {
+                    domain: 'test-domain',
+                    organization: 'test-org',
+                    project: 'test-project',
+                    pushId: 'test-push-id',
+                    'continue-on-deploy-failures': false,
+                },
+                config: mockConfig,
+                version: 'cli-version',
+            })).rejects.toThrowErrorMatchingInlineSnapshot(`
         "❌ Preview deploy fail.
         Preview URL: https://preview-test-url"
       `);
-        }));
-        it('should not throw error if option value is true', () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        it('should not throw error if option value is true', async () => {
             process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, pushResponseStub), { status: {
+            remotes.getPush.mockResolvedValueOnce({
+                ...pushResponseStub,
+                status: {
                     preview: {
                         deploy: { status: 'failed', url: 'https://preview-test-url' },
                         scorecard: [],
                     },
-                } }));
-            yield expect((0, push_status_1.handlePushStatus)({
-                domain: 'test-domain',
-                organization: 'test-org',
-                project: 'test-project',
-                pushId: 'test-push-id',
-                'continue-on-deploy-failures': true,
-            }, mockConfig)).resolves.toStrictEqual({
+                },
+            });
+            await expect((0, push_status_1.handlePushStatus)({
+                argv: {
+                    domain: 'test-domain',
+                    organization: 'test-org',
+                    project: 'test-project',
+                    pushId: 'test-push-id',
+                    'continue-on-deploy-failures': true,
+                },
+                config: mockConfig,
+                version: 'cli-version',
+            })).resolves.toStrictEqual({
                 preview: {
                     deploy: { status: 'failed', url: 'https://preview-test-url' },
                     scorecard: [],
@@ -374,39 +443,52 @@ describe('handlePushStatus()', () => {
                 production: null,
                 commit: commitStub,
             });
-        }));
+        });
     });
     describe('"onRetry" callback', () => {
-        it('should be called when command retries request to API in wait mode for preview deploy', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should be called when command retries request to API in wait mode for preview deploy', async () => {
             process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, pushResponseStub), { status: {
+            remotes.getPush.mockResolvedValueOnce({
+                ...pushResponseStub,
+                status: {
                     preview: {
                         deploy: { status: 'pending', url: 'https://preview-test-url' },
                         scorecard: [],
                     },
-                } }));
-            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, pushResponseStub), { status: {
+                },
+            });
+            remotes.getPush.mockResolvedValueOnce({
+                ...pushResponseStub,
+                status: {
                     preview: {
                         deploy: { status: 'running', url: 'https://preview-test-url' },
                         scorecard: [],
                     },
-                } }));
-            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, pushResponseStub), { status: {
+                },
+            });
+            remotes.getPush.mockResolvedValueOnce({
+                ...pushResponseStub,
+                status: {
                     preview: {
                         deploy: { status: 'success', url: 'https://preview-test-url' },
                         scorecard: [],
                     },
-                } }));
+                },
+            });
             const onRetrySpy = jest.fn();
-            const result = yield (0, push_status_1.handlePushStatus)({
-                domain: 'test-domain',
-                organization: 'test-org',
-                project: 'test-project',
-                pushId: 'test-push-id',
-                wait: true,
-                'retry-interval': 0.5,
-                onRetry: onRetrySpy,
-            }, mockConfig);
+            const result = await (0, push_status_1.handlePushStatus)({
+                argv: {
+                    domain: 'test-domain',
+                    organization: 'test-org',
+                    project: 'test-project',
+                    pushId: 'test-push-id',
+                    wait: true,
+                    'retry-interval': 0.5, // 500 ms
+                    onRetry: onRetrySpy,
+                },
+                config: mockConfig,
+                version: 'cli-version',
+            });
             expect(onRetrySpy).toBeCalledTimes(2);
             // first retry
             expect(onRetrySpy).toHaveBeenNthCalledWith(1, {
@@ -444,30 +526,37 @@ describe('handlePushStatus()', () => {
                 production: null,
                 commit: commitStub,
             });
-        }));
+        });
     });
     describe('"max-execution-time" option', () => {
-        it('should throw error in case "max-execution-time" was exceeded', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should throw error in case "max-execution-time" was exceeded', async () => {
             process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
             // Stuck deployment simulation
-            remotes.getPush.mockResolvedValue(Object.assign(Object.assign({}, pushResponseStub), { status: {
+            remotes.getPush.mockResolvedValue({
+                ...pushResponseStub,
+                status: {
                     preview: {
                         deploy: { status: 'pending', url: 'https://preview-test-url' },
                         scorecard: [],
                     },
-                } }));
-            yield expect((0, push_status_1.handlePushStatus)({
-                domain: 'test-domain',
-                organization: 'test-org',
-                project: 'test-project',
-                pushId: 'test-push-id',
-                'retry-interval': 2,
-                'max-execution-time': 1,
-                wait: true,
-            }, mockConfig)).rejects.toThrowErrorMatchingInlineSnapshot(`
+                },
+            });
+            await expect((0, push_status_1.handlePushStatus)({
+                argv: {
+                    domain: 'test-domain',
+                    organization: 'test-org',
+                    project: 'test-project',
+                    pushId: 'test-push-id',
+                    'retry-interval': 2, // seconds
+                    'max-execution-time': 1, // seconds
+                    wait: true,
+                },
+                config: mockConfig,
+                version: 'cli-version',
+            })).rejects.toThrowErrorMatchingInlineSnapshot(`
         "✗ Failed to get push status. Reason: Timeout exceeded
         "
       `);
-        }));
+        });
     });
 });