@redocly/cli 1.10.6 → 1.12.0

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

@@ -10,12 +10,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const push_status_1 = require("../push-status");
-const miscellaneous_1 = require("../../../utils/miscellaneous");
 const remotes = {
     getPush: jest.fn(),
     getRemotesList: jest.fn(),
 };
-jest.mock('../../../utils/miscellaneous');
 jest.mock('colorette', () => ({
     green: (str) => str,
     yellow: (str) => str,
@@ -27,22 +25,49 @@ jest.mock('colorette', () => ({
 jest.mock('../../api', () => (Object.assign(Object.assign({}, jest.requireActual('../../api')), { ReuniteApiClient: jest.fn().mockImplementation(function (...args) {
         this.remotes = remotes;
     }) })));
+jest.mock('@redocly/openapi-core', () => ({
+    pause: jest.requireActual('@redocly/openapi-core').pause,
+}));
 describe('handlePushStatus()', () => {
     const mockConfig = { apis: {} };
+    const commitStub = {
+        message: 'test-commit-message',
+        branchName: 'test-branch-name',
+        sha: null,
+        url: null,
+        createdAt: null,
+        namespaceId: null,
+        repositoryId: null,
+        author: {
+            name: 'test-author-name',
+            email: 'test-author-email',
+            image: null,
+        },
+        statuses: [],
+    };
     const pushResponseStub = {
+        id: 'test-push-id',
+        remoteId: 'test-remote-id',
+        replace: false,
+        scoutJobId: null,
+        uploadedFiles: [],
+        commit: commitStub,
+        remote: { commits: [] },
+        isOutdated: false,
+        isMainBranch: false,
         hasChanges: true,
         status: {
             preview: {
                 scorecard: [],
                 deploy: {
-                    url: 'https://test-url',
+                    url: 'https://preview-test-url',
                     status: 'success',
                 },
             },
             production: {
                 scorecard: [],
                 deploy: {
-                    url: 'https://test-url',
+                    url: 'https://production-test-url',
                     status: 'success',
                 },
             },
@@ -56,16 +81,16 @@ describe('handlePushStatus()', () => {
         jest.clearAllMocks();
     });
     it('should throw error if organization not provided', () => __awaiter(void 0, void 0, void 0, function* () {
-        yield (0, push_status_1.handlePushStatus)({
+        yield expect((0, push_status_1.handlePushStatus)({
             domain: 'test-domain',
             organization: '',
             project: 'test-project',
             pushId: 'test-push-id',
-            'max-execution-time': 1000,
-        }, mockConfig);
-        expect(miscellaneous_1.exitWithError).toHaveBeenCalledWith("No organization provided, please use --organization option or specify the 'organization' field in the config file.");
+        }, mockConfig)).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 return success push status for preview-build', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('should print success push status for preview-build', () => __awaiter(void 0, void 0, void 0, function* () {
         process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
         remotes.getPush.mockResolvedValueOnce(pushResponseStub);
         yield (0, push_status_1.handlePushStatus)({
@@ -73,12 +98,11 @@ describe('handlePushStatus()', () => {
             organization: 'test-org',
             project: 'test-project',
             pushId: 'test-push-id',
-            'max-execution-time': 1000,
         }, mockConfig);
         expect(process.stdout.write).toHaveBeenCalledTimes(1);
-        expect(process.stdout.write).toHaveBeenCalledWith('🚀 Preview deploy success.\nPreview URL: https://test-url\n');
+        expect(process.stdout.write).toHaveBeenCalledWith('🚀 Preview deploy success.\nPreview URL: https://preview-test-url\n');
     }));
-    it('should return 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', () => __awaiter(void 0, void 0, void 0, function* () {
         process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
         remotes.getPush.mockResolvedValue(Object.assign(Object.assign({}, pushResponseStub), { isMainBranch: true }));
         yield (0, push_status_1.handlePushStatus)({
@@ -86,38 +110,39 @@ describe('handlePushStatus()', () => {
             organization: 'test-org',
             project: 'test-project',
             pushId: 'test-push-id',
-            'max-execution-time': 1000,
         }, mockConfig);
         expect(process.stdout.write).toHaveBeenCalledTimes(2);
-        expect(process.stdout.write).toHaveBeenCalledWith('🚀 Preview deploy success.\nPreview URL: https://test-url\n');
-        expect(process.stdout.write).toHaveBeenCalledWith('🚀 Production deploy success.\nProduction URL: https://test-url\n');
+        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 return failed push status for preview build', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('should print failed push status for preview build', () => __awaiter(void 0, void 0, void 0, function* () {
         process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
         remotes.getPush.mockResolvedValue({
             isOutdated: false,
             hasChanges: true,
             status: {
-                preview: { deploy: { status: 'failed', url: 'https://test-url' }, scorecard: [] },
+                preview: { deploy: { status: 'failed', url: 'https://preview-test-url' }, scorecard: [] },
             },
         });
-        yield (0, push_status_1.handlePushStatus)({
+        yield expect((0, push_status_1.handlePushStatus)({
             domain: 'test-domain',
             organization: 'test-org',
             project: 'test-project',
             pushId: 'test-push-id',
-            'max-execution-time': 1000,
-        }, mockConfig);
-        expect(miscellaneous_1.exitWithError).toHaveBeenCalledWith('❌ Preview deploy fail.\nPreview URL: https://test-url');
+        }, mockConfig)).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 return 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', () => __awaiter(void 0, void 0, void 0, function* () {
         process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
         remotes.getPush.mockResolvedValue({
             isOutdated: false,
             hasChanges: true,
             status: {
                 preview: {
-                    deploy: { status: 'success', url: 'https://test-url' },
+                    deploy: { status: 'success', url: 'https://preview-test-url' },
                     scorecard: [
                         {
                             name: 'test-name',
@@ -134,21 +159,24 @@ describe('handlePushStatus()', () => {
             organization: 'test-org',
             project: 'test-project',
             pushId: 'test-push-id',
-            'max-execution-time': 1000,
         }, mockConfig);
         expect(process.stdout.write).toHaveBeenCalledTimes(4);
-        expect(process.stdout.write).toHaveBeenCalledWith('🚀 Preview deploy success.\nPreview URL: https://test-url\n');
+        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 display message if there is no changes', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('should print message if there is no changes', () => __awaiter(void 0, void 0, void 0, function* () {
         process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
         remotes.getPush.mockResolvedValueOnce({
             isOutdated: false,
             hasChanges: false,
             status: {
-                preview: { deploy: { status: 'skipped', url: 'https://test-url' }, scorecard: [] },
+                preview: { deploy: { status: 'skipped', url: 'https://preview-test-url' }, scorecard: [] },
+                production: {
+                    deploy: { status: 'skipped', url: null },
+                    scorecard: [],
+                },
             },
         });
         yield (0, push_status_1.handlePushStatus)({
@@ -157,8 +185,289 @@ describe('handlePushStatus()', () => {
             project: 'test-project',
             pushId: 'test-push-id',
             wait: true,
-            'max-execution-time': 1000,
         }, mockConfig);
-        expect(process.stderr.write).toHaveBeenCalledWith('Files not uploaded. Reason: no changes.\n');
+        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)({
+                domain: 'test-domain',
+                organization: 'test-org',
+                project: 'test-project',
+                pushId: 'test-push-id',
+            }, mockConfig);
+            expect(result).toEqual({
+                preview: {
+                    deploy: {
+                        status: 'success',
+                        url: 'https://preview-test-url',
+                    },
+                    scorecard: [],
+                },
+                production: null,
+                commit: commitStub,
+            });
+        }));
+        it('should return preview and production 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: true }));
+            const result = yield (0, push_status_1.handlePushStatus)({
+                domain: 'test-domain',
+                organization: 'test-org',
+                project: 'test-project',
+                pushId: 'test-push-id',
+            }, mockConfig);
+            expect(result).toEqual({
+                preview: {
+                    deploy: {
+                        status: 'success',
+                        url: 'https://preview-test-url',
+                    },
+                    scorecard: [],
+                },
+                production: {
+                    deploy: {
+                        status: 'success',
+                        url: 'https://production-test-url',
+                    },
+                    scorecard: [],
+                },
+                commit: commitStub,
+            });
+        }));
+    });
+    describe('"wait" option', () => {
+        it('should wait for preview "success" deployment status', () => __awaiter(void 0, void 0, void 0, function* () {
+            process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, pushResponseStub), { status: {
+                    preview: {
+                        deploy: { status: 'pending', url: 'https://preview-test-url' },
+                        scorecard: [],
+                    },
+                } }));
+            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, pushResponseStub), { status: {
+                    preview: {
+                        deploy: { status: 'running', url: 'https://preview-test-url' },
+                        scorecard: [],
+                    },
+                } }));
+            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, 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);
+            expect(result).toEqual({
+                preview: {
+                    deploy: {
+                        status: 'success',
+                        url: 'https://preview-test-url',
+                    },
+                    scorecard: [],
+                },
+                production: null,
+                commit: commitStub,
+            });
+        }));
+        it('should wait for production "success" status after preview "success" status', () => __awaiter(void 0, void 0, void 0, function* () {
+            process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, pushResponseStub), { isMainBranch: true, status: {
+                    preview: {
+                        deploy: { status: 'success', url: 'https://preview-test-url' },
+                        scorecard: [],
+                    },
+                    production: {
+                        deploy: { status: 'pending', url: 'https://production-test-url' },
+                        scorecard: [],
+                    },
+                } }));
+            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, pushResponseStub), { isMainBranch: true, status: {
+                    preview: {
+                        deploy: { status: 'success', url: 'https://preview-test-url' },
+                        scorecard: [],
+                    },
+                    production: {
+                        deploy: { status: 'running', url: 'https://production-test-url' },
+                        scorecard: [],
+                    },
+                } }));
+            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, pushResponseStub), { isMainBranch: true, status: {
+                    preview: {
+                        deploy: { status: 'success', url: 'https://preview-test-url' },
+                        scorecard: [],
+                    },
+                    production: {
+                        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);
+            expect(result).toEqual({
+                preview: {
+                    deploy: { status: 'success', url: 'https://preview-test-url' },
+                    scorecard: [],
+                },
+                production: {
+                    deploy: { status: 'success', url: 'https://production-test-url' },
+                    scorecard: [],
+                },
+                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* () {
+            process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, 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(`
+        "❌ 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* () {
+            process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, 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({
+                preview: {
+                    deploy: { status: 'failed', url: 'https://preview-test-url' },
+                    scorecard: [],
+                },
+                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* () {
+            process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, pushResponseStub), { status: {
+                    preview: {
+                        deploy: { status: 'pending', url: 'https://preview-test-url' },
+                        scorecard: [],
+                    },
+                } }));
+            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, pushResponseStub), { status: {
+                    preview: {
+                        deploy: { status: 'running', url: 'https://preview-test-url' },
+                        scorecard: [],
+                    },
+                } }));
+            remotes.getPush.mockResolvedValueOnce(Object.assign(Object.assign({}, 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);
+            expect(onRetrySpy).toBeCalledTimes(2);
+            // first retry
+            expect(onRetrySpy).toHaveBeenNthCalledWith(1, {
+                preview: {
+                    deploy: {
+                        status: 'pending',
+                        url: 'https://preview-test-url',
+                    },
+                    scorecard: [],
+                },
+                production: null,
+                commit: commitStub,
+            });
+            // second retry
+            expect(onRetrySpy).toHaveBeenNthCalledWith(2, {
+                preview: {
+                    deploy: {
+                        status: 'running',
+                        url: 'https://preview-test-url',
+                    },
+                    scorecard: [],
+                },
+                production: null,
+                commit: commitStub,
+            });
+            // final result
+            expect(result).toEqual({
+                preview: {
+                    deploy: {
+                        status: 'success',
+                        url: 'https://preview-test-url',
+                    },
+                    scorecard: [],
+                },
+                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* () {
+            process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+            // Stuck deployment simulation
+            remotes.getPush.mockResolvedValue(Object.assign(Object.assign({}, 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(`
+        "✗ Failed to get push status. Reason: Timeout exceeded
+        "
+      `);
+        }));
+    });
 });

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

@@ -32,8 +32,8 @@ describe('handlePush()', () => {
     let fsReaddirSyncSpy;
     beforeEach(() => {
         remotes.getDefaultBranch.mockResolvedValueOnce('test-default-branch');
-        remotes.upsert.mockResolvedValueOnce({ id: 'test-remote-id' });
-        remotes.push.mockResolvedValueOnce({ branchName: 'uploaded-to-branch' });
+        remotes.upsert.mockResolvedValueOnce({ id: 'test-remote-id', mountPath: 'test-mount-path' });
+        remotes.push.mockResolvedValueOnce({ branchName: 'uploaded-to-branch', id: 'test-id' });
         jest.spyOn(fs, 'createReadStream').mockReturnValue('stream');
         pathResolveSpy = jest.spyOn(path, 'resolve');
         pathRelativeSpy = jest.spyOn(path, 'relative');
@@ -104,6 +104,36 @@ describe('handlePush()', () => {
             },
         ]);
     }));
+    it('should return push id', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockConfig = { apis: {} };
+        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+        fsStatSyncSpy.mockReturnValueOnce({
+            isDirectory() {
+                return false;
+            },
+        });
+        pathResolveSpy.mockImplementationOnce((p) => p);
+        pathRelativeSpy.mockImplementationOnce((_, p) => p);
+        pathDirnameSpy.mockImplementation((_) => '.');
+        const result = yield (0, push_1.handlePush)({
+            domain: 'test-domain',
+            'mount-path': 'test-mount-path',
+            organization: 'test-org',
+            project: 'test-project',
+            branch: 'test-branch',
+            namespace: 'test-namespace',
+            repository: 'test-repository',
+            'commit-sha': 'test-commit-sha',
+            'commit-url': 'test-commit-url',
+            'default-branch': 'test-branch',
+            'created-at': 'test-created-at',
+            author: 'TestAuthor <test-author@mail.com>',
+            message: 'Test message',
+            files: ['test-file'],
+            'max-execution-time': 10,
+        }, mockConfig);
+        expect(result).toEqual({ pushId: 'test-id' });
+    }));
     it('should collect files from directory and preserve file structure', () => __awaiter(void 0, void 0, void 0, function* () {
         const mockConfig = { apis: {} };
         process.env.REDOCLY_AUTHORIZATION = 'test-api-key';

package/lib/cms/commands/__tests__/utils.test.d.ts

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

package/lib/cms/commands/__tests__/utils.test.js

@@ -0,0 +1,60 @@
+"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 utils_1 = require("../utils");
+jest.mock('@redocly/openapi-core', () => ({
+    pause: jest.requireActual('@redocly/openapi-core').pause,
+}));
+describe('retryUntilConditionMet()', () => {
+    it('should retry until condition meet and return result', () => __awaiter(void 0, void 0, void 0, function* () {
+        const operation = jest
+            .fn()
+            .mockResolvedValueOnce({ status: 'pending' })
+            .mockResolvedValueOnce({ status: 'pending' })
+            .mockResolvedValueOnce({ status: 'done' });
+        const data = yield (0, utils_1.retryUntilConditionMet)({
+            operation,
+            condition: (result) => (result === null || result === void 0 ? void 0 : result.status) === 'done',
+            retryIntervalMs: 100,
+            retryTimeoutMs: 1000,
+        });
+        expect(data).toEqual({ status: 'done' });
+    }));
+    it('should throw error if condition not meet for desired timeout', () => __awaiter(void 0, void 0, void 0, function* () {
+        const operation = jest.fn().mockResolvedValue({ status: 'pending' });
+        yield expect((0, utils_1.retryUntilConditionMet)({
+            operation,
+            condition: (result) => (result === null || result === void 0 ? void 0 : result.status) === 'done',
+            retryIntervalMs: 100,
+            retryTimeoutMs: 1000,
+        })).rejects.toThrow('Timeout exceeded');
+    }));
+    it('should call "onConditionNotMet" and "onRetry" callbacks', () => __awaiter(void 0, void 0, void 0, function* () {
+        const operation = jest
+            .fn()
+            .mockResolvedValueOnce({ status: 'pending' })
+            .mockResolvedValueOnce({ status: 'pending' })
+            .mockResolvedValueOnce({ status: 'done' });
+        const onConditionNotMet = jest.fn();
+        const onRetry = jest.fn();
+        const data = yield (0, utils_1.retryUntilConditionMet)({
+            operation,
+            condition: (result) => (result === null || result === void 0 ? void 0 : result.status) === 'done',
+            retryIntervalMs: 100,
+            retryTimeoutMs: 1000,
+            onConditionNotMet,
+            onRetry,
+        });
+        expect(data).toEqual({ status: 'done' });
+        expect(onConditionNotMet).toHaveBeenCalledTimes(2);
+        expect(onRetry).toHaveBeenCalledTimes(2);
+    }));
+});

package/lib/cms/commands/push-status.d.ts

@@ -1,12 +1,22 @@
-import { Config } from '@redocly/openapi-core';
+import type { Config, OutputFormat } from '@redocly/openapi-core';
+import type { DeploymentStatusResponse, PushResponse } from '../api/types';
 export type PushStatusOptions = {
     organization: string;
     project: string;
     pushId: string;
     domain?: string;
     config?: string;
-    format?: 'stylish' | 'json';
+    format?: Extract<OutputFormat, 'stylish'>;
     wait?: boolean;
-    'max-execution-time': number;
+    'max-execution-time'?: number;
+    'retry-interval'?: number;
+    'start-time'?: number;
+    'continue-on-deploy-failures'?: boolean;
+    onRetry?: (lasSummary: PushStatusSummary) => void;
 };
-export declare function handlePushStatus(argv: PushStatusOptions, config: Config): Promise<void>;
+export interface PushStatusSummary {
+    preview: DeploymentStatusResponse;
+    production: DeploymentStatusResponse | null;
+    commit: PushResponse['commit'];
+}
+export declare function handlePushStatus(argv: PushStatusOptions, config: Config): Promise<PushStatusSummary | undefined>;