@redocly/cli 0.0.0-snapshot.1737554067

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

@@ -0,0 +1,563 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const push_status_1 = require("../push-status");
+const remotes = {
+    getPush: jest.fn(),
+    getRemotesList: jest.fn(),
+};
+jest.mock('colorette', () => ({
+    green: (str) => str,
+    yellow: (str) => str,
+    red: (str) => str,
+    gray: (str) => str,
+    magenta: (str) => str,
+    cyan: (str) => str,
+}));
+jest.mock('../../api', () => ({
+    ...jest.requireActual('../../api'),
+    ReuniteApi: jest.fn().mockImplementation(function (...args) {
+        this.remotes = remotes;
+        this.reportSunsetWarnings = jest.fn();
+    }),
+}));
+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://preview-test-url',
+                    status: 'success',
+                },
+            },
+            production: {
+                scorecard: [],
+                deploy: {
+                    url: 'https://production-test-url',
+                    status: 'success',
+                },
+            },
+        },
+    };
+    beforeEach(() => {
+        jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    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', async () => {
+        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+        remotes.getPush.mockResolvedValueOnce(pushResponseStub);
+        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', async () => {
+        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+        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', async () => {
+        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+        remotes.getPush.mockResolvedValue({
+            isOutdated: false,
+            hasChanges: true,
+            status: {
+                preview: { deploy: { status: 'failed', url: 'https://preview-test-url' }, scorecard: [] },
+            },
+        });
+        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', async () => {
+        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+        remotes.getPush.mockResolvedValue({
+            isOutdated: false,
+            hasChanges: true,
+            status: {
+                preview: {
+                    deploy: { status: 'success', url: 'https://preview-test-url' },
+                    scorecard: [
+                        {
+                            name: 'test-name',
+                            status: 'success',
+                            description: 'test-description',
+                            url: 'test-url',
+                        },
+                    ],
+                },
+            },
+        });
+        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', async () => {
+        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+        remotes.getPush.mockResolvedValueOnce({
+            isOutdated: false,
+            hasChanges: false,
+            status: {
+                preview: { deploy: { status: 'skipped', url: 'https://preview-test-url' }, scorecard: [] },
+                production: {
+                    deploy: { status: 'skipped', url: null },
+                    scorecard: [],
+                },
+            },
+        });
+        await (0, push_status_1.handlePushStatus)({
+            argv: {
+                domain: 'test-domain',
+                organization: 'test-org',
+                project: 'test-project',
+                pushId: 'test-push-id',
+                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: {
+                        status: 'success',
+                        url: 'https://preview-test-url',
+                    },
+                    scorecard: [],
+                },
+                production: null,
+                commit: commitStub,
+            });
+        });
+        it('should return preview and production deployment info', async () => {
+            process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+            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: {
+                        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', async () => {
+            process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+            remotes.getPush.mockResolvedValueOnce({
+                ...pushResponseStub,
+                status: {
+                    preview: {
+                        deploy: { status: 'pending', url: 'https://preview-test-url' },
+                        scorecard: [],
+                    },
+                },
+            });
+            remotes.getPush.mockResolvedValueOnce({
+                ...pushResponseStub,
+                status: {
+                    preview: {
+                        deploy: { status: 'running', url: 'https://preview-test-url' },
+                        scorecard: [],
+                    },
+                },
+            });
+            remotes.getPush.mockResolvedValueOnce({
+                ...pushResponseStub,
+                status: {
+                    preview: {
+                        deploy: { status: 'success', url: 'https://preview-test-url' },
+                        scorecard: [],
+                    },
+                },
+            });
+            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',
+                    },
+                    scorecard: [],
+                },
+                production: null,
+                commit: commitStub,
+            });
+        });
+        it('should wait for production "success" status after preview "success" status', async () => {
+            process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+            remotes.getPush.mockResolvedValueOnce({
+                ...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({
+                ...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({
+                ...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 = 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' },
+                    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', async () => {
+            process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+            remotes.getPush.mockResolvedValueOnce({
+                ...pushResponseStub,
+                status: {
+                    preview: {
+                        deploy: { status: 'failed', url: 'https://preview-test-url' },
+                        scorecard: [],
+                    },
+                },
+            });
+            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', async () => {
+            process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+            remotes.getPush.mockResolvedValueOnce({
+                ...pushResponseStub,
+                status: {
+                    preview: {
+                        deploy: { status: 'failed', url: 'https://preview-test-url' },
+                        scorecard: [],
+                    },
+                },
+            });
+            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: [],
+                },
+                production: null,
+                commit: commitStub,
+            });
+        });
+    });
+    describe('"onRetry" callback', () => {
+        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({
+                ...pushResponseStub,
+                status: {
+                    preview: {
+                        deploy: { status: 'pending', url: 'https://preview-test-url' },
+                        scorecard: [],
+                    },
+                },
+            });
+            remotes.getPush.mockResolvedValueOnce({
+                ...pushResponseStub,
+                status: {
+                    preview: {
+                        deploy: { status: 'running', url: 'https://preview-test-url' },
+                        scorecard: [],
+                    },
+                },
+            });
+            remotes.getPush.mockResolvedValueOnce({
+                ...pushResponseStub,
+                status: {
+                    preview: {
+                        deploy: { status: 'success', url: 'https://preview-test-url' },
+                        scorecard: [],
+                    },
+                },
+            });
+            const onRetrySpy = jest.fn();
+            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, {
+                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', async () => {
+            process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+            // Stuck deployment simulation
+            remotes.getPush.mockResolvedValue({
+                ...pushResponseStub,
+                status: {
+                    preview: {
+                        deploy: { status: 'pending', url: 'https://preview-test-url' },
+                        scorecard: [],
+                    },
+                },
+            });
+            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.
+        "
+      `);
+        });
+    });
+});

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

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