@redocly/cli 1.11.0 → 1.12.1

package/src/cms/api/types.ts

@@ -48,33 +48,42 @@ 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;
@@ -96,6 +105,4 @@ export type ScorecardItem = {
 
 export type PushStatusBase = 'pending' | 'success' | 'running' | 'failed';
 
-// export type BuildStatus = PushStatusBase | 'NOT_STARTED' | 'QUEUED';
-
 export type DeploymentStatus = 'skipped' | PushStatusBase;

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
+        "
+      `);
+    });
   });
 });