@hubspot/cli 6.2.0 → 6.2.2-beta.0

package/lib/__tests__/serverlessLogs.test.js

@@ -1,162 +0,0 @@
-const mockStdIn = require('mock-stdin');
-const { outputLogs } = require('../ui/serverlessFunctionLogs');
-const { tailLogs } = require('../serverlessLogs');
-
-jest.mock('../ui/serverlessFunctionLogs');
-jest.mock('@hubspot/local-dev-lib/logger');
-
-jest.useFakeTimers();
-
-const ACCOUNT_ID = 123;
-
-describe('@hubspot/cli/lib/serverlessLogs', () => {
-  describe('tailLogs()', () => {
-    let stdinMock;
-    let spinnies;
-
-    beforeEach(() => {
-      jest.spyOn(process, 'exit').mockImplementation(() => {});
-      stdinMock = mockStdIn.stdin();
-      spinnies = {
-        succeed: jest.fn(),
-        fail: jest.fn(),
-        stopAll: jest.fn(),
-      };
-    });
-
-    afterEach(() => {
-      jest.clearAllTimers();
-      stdinMock.restore();
-    });
-
-    it('calls tailCall() to get the next results', async () => {
-      const compact = false;
-      const fetchLatest = jest.fn(() => {
-        return Promise.resolve({
-          id: '1234',
-          executionTime: 510,
-          log: 'Log message',
-          error: null,
-          status: 'SUCCESS',
-          createdAt: 1620232011451,
-          memory: '70/128 MB',
-          duration: '53.40 ms',
-        });
-      });
-      const tailCall = jest.fn(() => {
-        return Promise.resolve({
-          results: [],
-          paging: {
-            next: {
-              after: 'somehash',
-            },
-          },
-        });
-      });
-
-      await tailLogs({
-        accountId: ACCOUNT_ID,
-        compact,
-        spinnies,
-        fetchLatest,
-        tailCall,
-      });
-      jest.runOnlyPendingTimers();
-
-      expect(fetchLatest).toHaveBeenCalled();
-      expect(tailCall).toHaveBeenCalledTimes(2);
-    });
-    it('outputs results', async () => {
-      const compact = false;
-
-      const fetchLatest = jest.fn(() => {
-        return Promise.resolve({
-          data: {
-            id: '1234',
-            executionTime: 510,
-            log: 'Log message',
-            error: null,
-            status: 'SUCCESS',
-            createdAt: 1620232011451,
-            memory: '70/128 MB',
-            duration: '53.40 ms',
-          },
-        });
-      });
-      const latestLogResponse = {
-        results: [
-          {
-            id: '456',
-            executionTime: 510,
-            log: 'Message 1',
-            error: null,
-            status: 'SUCCESS',
-            createdAt: 1620232011451,
-            memory: '70/128 MB',
-            duration: '53.40 ms',
-          },
-          {
-            id: '457',
-            executionTime: 510,
-            log: 'Message 2',
-            error: null,
-            status: 'SUCCESS',
-            createdAt: 1620232011451,
-            memory: '70/128 MB',
-            duration: '53.40 ms',
-          },
-        ],
-        paging: {
-          next: {
-            after: 'somehash',
-          },
-        },
-      };
-      const tailCall = jest.fn(() =>
-        Promise.resolve({ data: latestLogResponse })
-      );
-
-      await tailLogs({
-        accountId: ACCOUNT_ID,
-        compact,
-        spinnies,
-        fetchLatest,
-        tailCall,
-      });
-      jest.runOnlyPendingTimers();
-      expect(outputLogs).toHaveBeenCalledWith(
-        latestLogResponse,
-        expect.objectContaining({ compact })
-      );
-      expect(tailCall).toHaveBeenCalledTimes(2);
-    });
-    it('handles no logs', async () => {
-      const compact = false;
-
-      const fetchLatest = jest.fn(() => {
-        return Promise.reject(
-          new Error({
-            statusCode: 404,
-          })
-        );
-      });
-      const tailCall = jest.fn(() =>
-        Promise.reject(
-          new Error({
-            statusCode: 404,
-          })
-        )
-      );
-
-      await tailLogs({
-        accountId: ACCOUNT_ID,
-        compact,
-        spinnies,
-        fetchLatest,
-        tailCall,
-      });
-      jest.runOnlyPendingTimers();
-      expect(tailCall).toHaveBeenCalledTimes(2);
-    });
-  });
-});

package/lib/__tests__/validation.test.js

@@ -1,140 +0,0 @@
-const { getAccountConfig } = require('@hubspot/local-dev-lib/config');
-const { getOauthManager } = require('@hubspot/local-dev-lib/oauth');
-const {
-  accessTokenForPersonalAccessKey,
-} = require('@hubspot/local-dev-lib/personalAccessKey');
-
-const { getAccountId } = require('../commonOpts');
-const { validateAccount } = require('../validation');
-
-jest.mock('@hubspot/local-dev-lib/config');
-jest.mock('@hubspot/local-dev-lib/logger');
-jest.mock('@hubspot/local-dev-lib/oauth');
-jest.mock('@hubspot/local-dev-lib/personalAccessKey');
-jest.mock('../commonOpts');
-
-describe('validation', () => {
-  describe('validateAccount', () => {
-    it('returns false if an account is missing', async () => {
-      getAccountId.mockReturnValueOnce(null);
-      expect(await validateAccount({ account: 123 })).toBe(false);
-    });
-    it('returns false if an account config is missing', async () => {
-      getAccountId.mockReturnValueOnce(123);
-      getAccountConfig.mockReturnValueOnce(undefined);
-      expect(await validateAccount({ account: 123 })).toBe(false);
-    });
-    it('returns false for oauth2 authType if auth is missing', async () => {
-      getAccountId.mockReturnValueOnce(123);
-      getAccountConfig.mockReturnValueOnce({
-        accountId: 123,
-        authType: 'oauth2',
-      });
-      expect(await validateAccount({ account: 123 })).toBe(false);
-    });
-    it('returns false if OAuth is missing configuration', async () => {
-      getAccountId.mockReturnValueOnce(123);
-      getAccountConfig.mockReturnValueOnce({
-        accountId: 123,
-        authType: 'oauth2',
-        auth: {
-          clientId: 'foo',
-        },
-      });
-      expect(await validateAccount({ account: 123 })).toBe(false);
-    });
-    it('returns false if an access token was not retrieved', async () => {
-      getAccountId.mockReturnValueOnce(123);
-      getOauthManager.mockReturnValueOnce({
-        accessToken() {
-          return null;
-        },
-      });
-      getAccountConfig.mockReturnValueOnce({
-        accountId: 123,
-        authType: 'oauth2',
-        auth: {
-          clientId: 'foo',
-          clientSecret: 'abc',
-          tokenInfo: {
-            refreshToken: 'def',
-          },
-        },
-      });
-      expect(await validateAccount({ account: 123 })).toBe(false);
-    });
-    it('returns false if an getting an access token throws', async () => {
-      getAccountId.mockReturnValueOnce(123);
-      getOauthManager.mockReturnValueOnce({
-        accessToken() {
-          throw new Error('It failed');
-        },
-      });
-      getAccountConfig.mockReturnValueOnce({
-        accountId: 123,
-        authType: 'oauth2',
-        auth: {
-          clientId: 'foo',
-          clientSecret: 'abc',
-          tokenInfo: {
-            refreshToken: 'def',
-          },
-        },
-      });
-      expect(await validateAccount({ account: 123 })).toBe(false);
-    });
-    it('returns true if OAuth is configured and an access token is received', async () => {
-      getAccountId.mockReturnValueOnce(123);
-      getOauthManager.mockReturnValueOnce({
-        accessToken() {
-          return 'yep';
-        },
-      });
-      getAccountConfig.mockReturnValueOnce({
-        accountId: 123,
-        authType: 'oauth2',
-        auth: {
-          clientId: 'foo',
-          clientSecret: 'abc',
-          tokenInfo: {
-            refreshToken: 'def',
-          },
-        },
-      });
-      expect(await validateAccount({ account: 123 })).toBe(true);
-    });
-    it('returns false if "personalaccesskey" configured and getting an access token throws', async () => {
-      getAccountId.mockReturnValueOnce(123);
-      accessTokenForPersonalAccessKey.mockImplementationOnce(() => {
-        throw new Error('It failed');
-      });
-      getAccountConfig.mockReturnValueOnce({
-        accountId: 123,
-        authType: 'personalaccesskey',
-        personalAccessKey: 'foo',
-      });
-      expect(await validateAccount({ account: 123 })).toBe(false);
-    });
-    it('returns true if "personalaccesskey" configured and an access token is received', async () => {
-      getAccountId.mockReturnValueOnce(123);
-      accessTokenForPersonalAccessKey.mockImplementationOnce(() => {
-        return 'secret-stuff';
-      });
-      getAccountConfig.mockReturnValueOnce({
-        accountId: 123,
-        authType: 'personalaccesskey',
-        personalAccessKey: 'foo',
-      });
-      expect(await validateAccount({ account: 123 })).toBe(true);
-    });
-    it('returns true if apiKey is configured and present', async () => {
-      getAccountId.mockReturnValueOnce(123);
-      getAccountConfig.mockReturnValueOnce({
-        accountId: 123,
-        authType: 'apikey',
-        apiKey: 'my-secret-key',
-      });
-      expect(await validateAccount({ account: 123 })).toBe(true);
-    });
-  });
-});

package/lib/getFunctionArrays.js

@@ -1,18 +0,0 @@
-const moment = require('moment');
-
-const getFunctionArrays = resp => {
-  return resp.objects.map(func => {
-    const { route, method, created, updated, secretNames } = func;
-    return [
-      route,
-      method,
-      secretNames.join(', '),
-      moment(created).format(),
-      moment(updated).format(),
-    ];
-  });
-};
-
-module.exports = {
-  getFunctionArrays,
-};

package/lib/prompts/__tests__/projectsLogsPrompt.test.js

@@ -1,46 +0,0 @@
-const { projectLogsPrompt } = require('../projectsLogsPrompt');
-
-jest.mock('../promptUtils');
-const { promptUser } = require('../promptUtils');
-const chalk = require('chalk');
-
-describe('prompts/projectsLogsPrompt', () => {
-  it('should return undefined functionName when functionChoices is nullable', async () => {
-    const actual = await projectLogsPrompt({ functionChoices: null });
-    expect(actual).toEqual({});
-    expect(promptUser).not.toHaveBeenCalled();
-  });
-
-  it('should return the functionName without prompting when there is only one functionChoice', async () => {
-    const functionChoice = 'this-is-the-only-function';
-    const { functionName } = await projectLogsPrompt({
-      functionChoices: [functionChoice],
-    });
-    expect(functionName).toEqual(functionChoice);
-    expect(promptUser).not.toHaveBeenCalled();
-  });
-
-  it('should prompt the user if there is more than one choice', async () => {
-    const functionChoices = ['choice 1', 'choice 2'];
-    const projectName = 'my cool project';
-    await projectLogsPrompt({
-      functionChoices,
-      projectName,
-    });
-
-    expect(promptUser).toHaveBeenCalledTimes(1);
-    expect(promptUser).toHaveBeenLastCalledWith(
-      expect.arrayContaining([
-        expect.objectContaining({
-          name: 'functionName',
-          type: 'list',
-          message: `[--function] Select function in ${chalk.bold(
-            projectName
-          )} project`,
-          when: expect.any(Function),
-          choices: functionChoices,
-        }),
-      ])
-    );
-  });
-});