@redocly/cli 1.10.6 → 1.12.0

package/src/cms/commands/__tests__/push-status.test.ts

@@ -1,14 +1,11 @@
 import { handlePushStatus } from '../push-status';
 import { PushResponse } from '../../api/types';
-import { exitWithError } from '../../../utils/miscellaneous';
 
 const remotes = {
   getPush: jest.fn(),
   getRemotesList: jest.fn(),
 };
 
-jest.mock('../../../utils/miscellaneous');
-
 jest.mock('colorette', () => ({
   green: (str: string) => str,
   yellow: (str: string) => str,
@@ -25,28 +22,57 @@ jest.mock('../../api', () => ({
   }),
 }));
 
+jest.mock('@redocly/openapi-core', () => ({
+  pause: jest.requireActual('@redocly/openapi-core').pause,
+}));
+
 describe('handlePushStatus()', () => {
   const mockConfig = { apis: {} } as any;
 
-  const pushResponseStub = {
+  const commitStub: PushResponse['commit'] = {
+    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: PushResponse = {
+    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',
         },
       },
     },
-  } as unknown as PushResponse;
+  };
 
   beforeEach(() => {
     jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
@@ -58,23 +84,27 @@ describe('handlePushStatus()', () => {
   });
 
   it('should throw error if organization not provided', async () => {
-    await handlePushStatus(
-      {
-        domain: 'test-domain',
-        organization: '',
-        project: 'test-project',
-        pushId: 'test-push-id',
-        'max-execution-time': 1000,
-      },
-      mockConfig
+    await expect(
+      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."`
     );
 
-    expect(exitWithError).toHaveBeenCalledWith(
-      "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', async () => {
+  it('should print success push status for preview-build', async () => {
     process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
     remotes.getPush.mockResolvedValueOnce(pushResponseStub);
 
@@ -84,17 +114,16 @@ 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'
+      '🚀 Preview deploy success.\nPreview URL: https://preview-test-url\n'
     );
   });
 
-  it('should return success push status for preview and production builds', async () => {
+  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 });
 
@@ -104,46 +133,50 @@ 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'
+      '🚀 Preview deploy success.\nPreview URL: https://preview-test-url\n'
     );
     expect(process.stdout.write).toHaveBeenCalledWith(
-      '🚀 Production deploy success.\nProduction URL: https://test-url\n'
+      '🚀 Production deploy success.\nProduction URL: https://production-test-url\n'
     );
   });
 
-  it('should return failed push status for preview build', async () => {
+  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://test-url' }, scorecard: [] },
+        preview: { deploy: { status: 'failed', url: 'https://preview-test-url' }, scorecard: [] },
       },
     });
 
-    await handlePushStatus(
-      {
-        domain: 'test-domain',
-        organization: 'test-org',
-        project: 'test-project',
-        pushId: 'test-push-id',
-        'max-execution-time': 1000,
-      },
-      mockConfig
-    );
-    expect(exitWithError).toHaveBeenCalledWith(
-      '❌ Preview deploy fail.\nPreview URL: https://test-url'
+    await expect(
+      handlePushStatus(
+        {
+          domain: 'test-domain',
+          organization: 'test-org',
+          project: 'test-project',
+          pushId: 'test-push-id',
+        },
+        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', async () => {
+  it('should print success push status for preview build and print scorecards', async () => {
     process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
 
     remotes.getPush.mockResolvedValue({
@@ -151,7 +184,7 @@ describe('handlePushStatus()', () => {
       hasChanges: true,
       status: {
         preview: {
-          deploy: { status: 'success', url: 'https://test-url' },
+          deploy: { status: 'success', url: 'https://preview-test-url' },
           scorecard: [
             {
               name: 'test-name',
@@ -170,13 +203,12 @@ 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'
+      '🚀 Preview deploy success.\nPreview URL: https://preview-test-url\n'
     );
     expect(process.stdout.write).toHaveBeenCalledWith('\nScorecard:');
     expect(process.stdout.write).toHaveBeenCalledWith(
@@ -185,14 +217,18 @@ describe('handlePushStatus()', () => {
     expect(process.stdout.write).toHaveBeenCalledWith('\n');
   });
 
-  it('should display message if there is no changes', async () => {
+  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://test-url' }, scorecard: [] },
+        preview: { deploy: { status: 'skipped', url: 'https://preview-test-url' }, scorecard: [] },
+        production: {
+          deploy: { status: 'skipped', url: null },
+          scorecard: [],
+        },
       },
     });
 
@@ -203,10 +239,400 @@ 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', async () => {
+      process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+      remotes.getPush.mockResolvedValue({ ...pushResponseStub, isMainBranch: false });
+
+      const result = await 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', async () => {
+      process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+      remotes.getPush.mockResolvedValue({ ...pushResponseStub, isMainBranch: true });
+
+      const result = await 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', 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 handlePushStatus(
+        {
+          domain: 'test-domain',
+          organization: 'test-org',
+          project: 'test-project',
+          pushId: 'test-push-id',
+          'retry-interval': 0.5, // 500 ms
+          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', 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 handlePushStatus(
+        {
+          domain: 'test-domain',
+          organization: 'test-org',
+          project: 'test-project',
+          pushId: 'test-push-id',
+          'retry-interval': 0.5, // 500 ms
+          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', 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(
+        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', 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(
+        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', 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 handlePushStatus(
+        {
+          domain: 'test-domain',
+          organization: 'test-org',
+          project: 'test-project',
+          pushId: 'test-push-id',
+          wait: true,
+          'retry-interval': 0.5, // 500 ms
+          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', 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(
+        handlePushStatus(
+          {
+            domain: 'test-domain',
+            organization: 'test-org',
+            project: 'test-project',
+            pushId: 'test-push-id',
+            'retry-interval': 2, // seconds
+            'max-execution-time': 1, // seconds
+            wait: true,
+          },
+          mockConfig
+        )
+      ).rejects.toThrowErrorMatchingInlineSnapshot(`
+        "✗ Failed to get push status. Reason: Timeout exceeded
+        "
+      `);
+    });
   });
 });

package/src/cms/commands/__tests__/push.test.ts

@@ -29,8 +29,8 @@ describe('handlePush()', () => {
 
   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' as any);
 
@@ -118,6 +118,44 @@ describe('handlePush()', () => {
     );
   });
 
+  it('should return push id', async () => {
+    const mockConfig = { apis: {} } as any;
+    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+
+    fsStatSyncSpy.mockReturnValueOnce({
+      isDirectory() {
+        return false;
+      },
+    } as any);
+
+    pathResolveSpy.mockImplementationOnce((p) => p);
+    pathRelativeSpy.mockImplementationOnce((_, p) => p);
+    pathDirnameSpy.mockImplementation((_: string) => '.');
+
+    const result = await 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', async () => {
     const mockConfig = { apis: {} } as any;
     process.env.REDOCLY_AUTHORIZATION = 'test-api-key';