@redocly/cli 1.11.0 → 1.12.1

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @redocly/cli
 
+## 1.12.1
+
+### Patch Changes
+
+- Updated @redocly/openapi-core to v1.12.1.
+
+## 1.12.0
+
+### Minor Changes
+
+- Added return values for the `push` and `push-status` commands.
+
+### Patch Changes
+
+- Fixed handling of wildcards on Windows ([#1521](https://github.com/Redocly/redocly-cli/issues/1521)).
+- Updated @redocly/openapi-core to v1.12.0.
+
 ## 1.11.0
 
 ### Minor Changes

package/lib/__tests__/utils.test.js

@@ -348,13 +348,13 @@ describe('handleErrors', () => {
         jest.clearAllMocks();
     });
     it('should handle ResolveError', () => {
-        const resolveError = new openapi_core_1.ResolveError(new Error('File not found'));
+        const resolveError = new openapi_core_1.ResolveError(new Error('File not found.'));
         expect(() => (0, miscellaneous_1.handleError)(resolveError, ref)).toThrowError(miscellaneous_1.HandledError);
         expect(redColoretteMocks).toHaveBeenCalledTimes(1);
         expect(process.stderr.write).toHaveBeenCalledWith(`Failed to resolve API description at openapi/test.yaml:\n\n  - File not found.\n\n`);
     });
     it('should handle YamlParseError', () => {
-        const yamlParseError = new openapi_core_1.YamlParseError(new Error('Invalid yaml'), {});
+        const yamlParseError = new openapi_core_1.YamlParseError(new Error('Invalid yaml.'), {});
         expect(() => (0, miscellaneous_1.handleError)(yamlParseError, ref)).toThrowError(miscellaneous_1.HandledError);
         expect(redColoretteMocks).toHaveBeenCalledTimes(1);
         expect(process.stderr.write).toHaveBeenCalledWith(`Failed to parse API description at openapi/test.yaml:\n\n  - Invalid yaml.\n\n`);
@@ -372,7 +372,7 @@ describe('handleErrors', () => {
         expect(process.stderr.write).toHaveBeenCalledWith('Syntax error: Unexpected identifier test stack\n\n');
     });
     it('should throw unknown error', () => {
-        const testError = new Error('Test error');
+        const testError = new Error('Test error.');
         expect(() => (0, miscellaneous_1.handleError)(testError, ref)).toThrowError(miscellaneous_1.HandledError);
         expect(process.stderr.write).toHaveBeenCalledWith(`Something went wrong when processing openapi/test.yaml:\n\n  - Test error.\n\n`);
     });

package/lib/cms/api/types.d.ts

@@ -44,32 +44,44 @@ export type Remote = {
 export type PushResponse = {
     id: string;
     remoteId: string;
+    isMainBranch: boolean;
+    isOutdated: boolean;
+    hasChanges: boolean;
+    replace: boolean;
+    scoutJobId: string | null;
+    uploadedFiles: Array<{
+        path: string;
+        mimeType: string;
+    }>;
     commit: {
-        message: string;
         branchName: string;
-        sha: string | null;
-        url: string | null;
+        message: string;
         createdAt: string | null;
-        namespace: string | null;
-        repository: string | null;
+        namespaceId: string | null;
+        repositoryId: string | null;
+        url: string | null;
+        sha: string | null;
         author: {
             name: string;
             email: string;
             image: string | null;
         };
+        statuses: Array<{
+            name: string;
+            description: string;
+            status: 'pending' | 'running' | 'success' | 'failed';
+            url: string | null;
+        }>;
     };
     remote: {
         commits: {
-            branchName: string;
             sha: string;
+            branchName: string;
         }[];
     };
-    hasChanges: boolean;
-    isOutdated: boolean;
-    isMainBranch: boolean;
     status: PushStatusResponse;
 };
-type DeploymentStatusResponse = {
+export type DeploymentStatusResponse = {
     deploy: {
         url: string | null;
         status: DeploymentStatus;
@@ -88,4 +100,3 @@ export type ScorecardItem = {
 };
 export type PushStatusBase = 'pending' | 'success' | 'running' | 'failed';
 export type DeploymentStatus = 'skipped' | PushStatusBase;
-export {};

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 {};