@hubspot/cli 7.6.0-beta.3 → 7.6.0-beta.5

package/lib/__tests__/sandboxes.test.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const sandboxHubs_1 = require("@hubspot/local-dev-lib/api/sandboxHubs");
+const sandboxSync_1 = require("@hubspot/local-dev-lib/api/sandboxSync");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const config_2 = require("@hubspot/local-dev-lib/constants/config");
+const testUtils_1 = require("../testUtils");
+const sandboxes_1 = require("../sandboxes");
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('@hubspot/local-dev-lib/api/sandboxHubs');
+vi.mock('@hubspot/local-dev-lib/api/sandboxSync');
+vi.mock('@hubspot/local-dev-lib/config');
+const mockedGetAccountId = config_1.getAccountId;
+const mockedGetSandboxUsageLimits = sandboxHubs_1.getSandboxUsageLimits;
+const mockedFetchTypes = sandboxSync_1.fetchTypes;
+const mockedGetConfigAccounts = config_1.getConfigAccounts;
+const mockedLogger = logger_1.logger;
+describe('lib/sandboxes', () => {
+    describe('getSandboxTypeAsString()', () => {
+        it('returns "development" for development sandbox type', () => {
+            expect((0, sandboxes_1.getSandboxTypeAsString)(config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe('development');
+        });
+        it('returns "standard" for standard sandbox type', () => {
+            expect((0, sandboxes_1.getSandboxTypeAsString)(config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX)).toBe('standard');
+        });
+        it('returns "standard" for undefined input', () => {
+            expect((0, sandboxes_1.getSandboxTypeAsString)(undefined)).toBe('standard');
+        });
+    });
+    describe('getHasSandboxesByType()', () => {
+        const mockParentAccount = {
+            name: 'Parent Account',
+            portalId: 123,
+            authType: undefined,
+            accountType: config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+            env: 'qa',
+        };
+        it('returns true when sandbox of specified type exists', () => {
+            mockedGetAccountId.mockReturnValue(mockParentAccount.portalId);
+            mockedGetConfigAccounts.mockReturnValue([
+                mockParentAccount,
+                {
+                    ...mockParentAccount,
+                    parentAccountId: 123,
+                    accountType: config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+                },
+            ]);
+            expect((0, sandboxes_1.getHasSandboxesByType)(mockParentAccount, config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(true);
+        });
+        it('returns false when no sandbox of specified type exists', () => {
+            mockedGetConfigAccounts.mockReturnValue([mockParentAccount]);
+            expect((0, sandboxes_1.getHasSandboxesByType)(mockParentAccount, config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(false);
+        });
+    });
+    describe('getAvailableSyncTypes()', () => {
+        const mockParentAccount = {
+            name: 'Parent Account',
+            portalId: 123,
+            env: 'qa',
+        };
+        const mockChildAccount = {
+            ...mockParentAccount,
+            portalId: 456,
+        };
+        it('returns available sync types when fetch is successful', async () => {
+            const mockSyncTypes = [{ name: 'type1' }, { name: 'type2' }];
+            mockedGetAccountId
+                .mockReturnValue(mockParentAccount.portalId)
+                .mockReturnValue(mockChildAccount.portalId);
+            mockedFetchTypes.mockResolvedValue({
+                data: { results: mockSyncTypes },
+            });
+            const result = await (0, sandboxes_1.getAvailableSyncTypes)(mockParentAccount, mockChildAccount);
+            expect(result).toEqual([{ type: 'type1' }, { type: 'type2' }]);
+        });
+        it('throws error when sync types fetch fails', async () => {
+            mockedFetchTypes.mockResolvedValue({ data: { results: null } });
+            await expect((0, sandboxes_1.getAvailableSyncTypes)(mockParentAccount, mockChildAccount)).rejects.toThrow(/Unable to fetch available sandbox sync types/);
+        });
+    });
+    describe('validateSandboxUsageLimits()', () => {
+        const mockAccount = {
+            name: 'Test Account',
+            portalId: 123,
+            authType: undefined,
+            env: 'qa',
+        };
+        it('validates successfully when limits are not reached', async () => {
+            mockedGetAccountId.mockReturnValue(mockAccount.portalId);
+            mockedGetSandboxUsageLimits.mockResolvedValue({
+                data: {
+                    usage: { DEVELOPER: { available: 1, limit: 3 } },
+                },
+            });
+            await expect((0, sandboxes_1.validateSandboxUsageLimits)(mockAccount, config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'qa')).resolves.not.toThrow();
+        });
+        it('throws error when development sandbox limit is reached', async () => {
+            mockedGetAccountId.mockReturnValue(mockAccount.portalId);
+            mockedGetConfigAccounts.mockReturnValue([]);
+            mockedGetSandboxUsageLimits.mockResolvedValue({
+                data: {
+                    usage: { DEVELOPER: { available: 0, limit: 1 } },
+                },
+            });
+            await expect((0, sandboxes_1.validateSandboxUsageLimits)(mockAccount, config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'qa')).rejects.toThrow(/reached the limit of 1 development sandbox/);
+        });
+    });
+    describe('handleSandboxCreateError()', () => {
+        const mockEnv = 'qa';
+        const mockName = 'Test Sandbox';
+        const mockAccountId = 123;
+        it('handles missing scope error', () => {
+            const error = (0, testUtils_1.mockHubSpotHttpError)('missing scopes error', {
+                status: 403,
+                data: {
+                    message: 'Missing scopes error',
+                    category: 'MISSING_SCOPES',
+                },
+            });
+            expect(() => (0, sandboxes_1.handleSandboxCreateError)(error, mockEnv, mockName, mockAccountId)).toThrow(error);
+            expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/The personal access key you provided doesn't include sandbox permissions/));
+            expect(mockedLogger.info).toHaveBeenCalledWith(expect.stringMatching(/To update CLI permissions for/));
+        });
+        it('handles user access not allowed error', () => {
+            const error = (0, testUtils_1.mockHubSpotHttpError)('user access not allowed error', {
+                status: 403,
+                data: {
+                    category: 'BANNED',
+                    subCategory: 'SandboxErrors.USER_ACCESS_NOT_ALLOWED',
+                },
+            });
+            expect(() => (0, sandboxes_1.handleSandboxCreateError)(error, mockEnv, mockName, mockAccountId)).toThrow(error);
+            expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/your permission set doesn't allow you to create the sandbox/));
+        });
+        it('handles 403 gating error', () => {
+            const error = (0, testUtils_1.mockHubSpotHttpError)('403 gating error', {
+                status: 403,
+                data: {
+                    category: 'BANNED',
+                    subCategory: 'SandboxErrors.DEVELOPMENT_SANDBOX_ACCESS_NOT_ALLOWED',
+                },
+            });
+            expect(() => (0, sandboxes_1.handleSandboxCreateError)(error, mockEnv, mockName, mockAccountId)).toThrow(error);
+            expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/does not have access to development sandboxes/));
+        });
+    });
+});

package/lib/__tests__/serverlessLogs.test.d.ts

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

package/lib/__tests__/serverlessLogs.test.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mock_stdin_1 = __importDefault(require("mock-stdin"));
+const serverlessFunctionLogs_1 = require("../ui/serverlessFunctionLogs");
+const serverlessLogs_1 = require("../serverlessLogs");
+vi.mock('../ui/serverlessFunctionLogs');
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('../ui/SpinniesManager', () => ({
+    default: {
+        init: vi.fn(),
+        add: vi.fn(),
+        remove: vi.fn(),
+        succeed: vi.fn(),
+        fail: vi.fn(),
+        stopAll: vi.fn(),
+    },
+}));
+vi.useFakeTimers();
+const ACCOUNT_ID = 123;
+describe('lib/serverlessLogs', () => {
+    describe('tailLogs()', () => {
+        let stdinMock;
+        beforeEach(() => {
+            // @ts-ignore - we don't need to mock the entire process object
+            vi.spyOn(process, 'exit').mockImplementation(() => { });
+            stdinMock = mock_stdin_1.default.stdin();
+        });
+        afterEach(() => {
+            vi.clearAllTimers();
+            stdinMock.restore();
+        });
+        it('calls tailCall() to get the next results', async () => {
+            const compact = false;
+            const fetchLatest = vi.fn(() => {
+                return Promise.resolve({
+                    data: {
+                        id: '1234',
+                        executionTime: 510,
+                        log: 'Log message',
+                        error: { message: '', type: '', stackTrace: [] },
+                        status: 'SUCCESS',
+                        createdAt: 1620232011451,
+                        memory: '70/128 MB',
+                        duration: '53.40 ms',
+                    },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {},
+                });
+            });
+            const tailCall = vi.fn(() => {
+                return Promise.resolve({
+                    data: {
+                        results: [],
+                        paging: {
+                            next: {
+                                after: 'somehash',
+                            },
+                        },
+                    },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {},
+                });
+            });
+            // @ts-ignore - headers is not used in the actual function and does not need to be mocked
+            await (0, serverlessLogs_1.tailLogs)(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            vi.runOnlyPendingTimers();
+            expect(fetchLatest).toHaveBeenCalled();
+            expect(tailCall).toHaveBeenCalledTimes(2);
+        });
+        it('outputs results', async () => {
+            const compact = false;
+            const fetchLatest = vi.fn(() => {
+                return Promise.resolve({
+                    data: {
+                        id: '1234',
+                        executionTime: 510,
+                        log: 'Log message',
+                        error: { message: '', type: '', stackTrace: [], statusCode: null },
+                        status: 'SUCCESS',
+                        createdAt: 1620232011451,
+                        memory: '70/128 MB',
+                        duration: '53.40 ms',
+                    },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {},
+                });
+            });
+            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 = vi.fn(() => Promise.resolve({ data: latestLogResponse }));
+            // @ts-ignore - headers is not used in the actual function and does not need to be mocked
+            await (0, serverlessLogs_1.tailLogs)(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            vi.runOnlyPendingTimers();
+            expect(serverlessFunctionLogs_1.outputLogs).toHaveBeenCalledWith(latestLogResponse, expect.objectContaining({ compact }));
+            expect(tailCall).toHaveBeenCalledTimes(2);
+        });
+        it('handles no logs', async () => {
+            const compact = false;
+            const fetchLatest = vi.fn(() => {
+                return Promise.reject({
+                    message: '',
+                    type: '',
+                    stackTrace: [],
+                    statusCode: 404,
+                });
+            });
+            const tailCall = vi.fn(() => Promise.reject({
+                message: '',
+                type: '',
+                stackTrace: [],
+                statusCode: 404,
+            }));
+            await (0, serverlessLogs_1.tailLogs)(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            vi.runOnlyPendingTimers();
+            expect(tailCall).toHaveBeenCalledTimes(2);
+        });
+    });
+});

package/lib/__tests__/usageTracking.test.d.ts

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

package/lib/__tests__/usageTracking.test.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const trackUsage_1 = require("@hubspot/local-dev-lib/trackUsage");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const auth_1 = require("@hubspot/local-dev-lib/constants/auth");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const usageTracking_1 = require("../usageTracking");
+const package_json_1 = require("../../package.json");
+vi.mock('@hubspot/local-dev-lib/trackUsage');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/logger');
+const mockedTrackUsage = trackUsage_1.trackUsage;
+const mockedIsTrackingAllowed = config_1.isTrackingAllowed;
+const mockedGetAccountConfig = config_1.getAccountConfig;
+const mockedLogger = logger_1.logger;
+describe('lib/usageTracking', () => {
+    const mockPlatform = 'darwin';
+    const mockNodeVersion = 'v16.14.0';
+    beforeEach(() => {
+        mockedIsTrackingAllowed.mockReturnValue(true);
+        Object.defineProperty(process, 'platform', { value: mockPlatform });
+        Object.defineProperty(process, 'version', { value: mockNodeVersion });
+    });
+    describe('trackCommandUsage()', () => {
+        const mockCommand = 'test-command';
+        const mockAccountId = 123;
+        it('should not track when tracking is disabled', async () => {
+            mockedIsTrackingAllowed.mockReturnValue(false);
+            await (0, usageTracking_1.trackCommandUsage)(mockCommand);
+            expect(mockedTrackUsage).not.toHaveBeenCalled();
+        });
+        it('should track command usage with default auth type', async () => {
+            await (0, usageTracking_1.trackCommandUsage)(mockCommand, {}, mockAccountId);
+            expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
+                action: 'cli-command',
+                command: mockCommand,
+                os: 'macos',
+                nodeVersion: mockNodeVersion,
+                nodeMajorVersion: 'v16',
+                version: package_json_1.version,
+                authType: auth_1.API_KEY_AUTH_METHOD.value,
+            }), mockAccountId);
+        });
+        it('should track command usage with custom auth type', async () => {
+            mockedGetAccountConfig.mockReturnValue({ authType: 'oauth2' });
+            await (0, usageTracking_1.trackCommandUsage)(mockCommand, {}, mockAccountId);
+            expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
+                authType: 'oauth2',
+            }), mockAccountId);
+        });
+        it('should handle tracking errors gracefully', async () => {
+            const error = new Error('Tracking failed');
+            mockedTrackUsage.mockImplementationOnce(() => {
+                throw error;
+            });
+            await (0, usageTracking_1.trackCommandUsage)(mockCommand);
+            expect(mockedLogger.debug).toHaveBeenCalledWith(expect.stringContaining(error.message));
+        });
+    });
+    describe('trackHelpUsage()', () => {
+        const mockCommand = 'help-command';
+        it('should not track when tracking is disabled', async () => {
+            mockedIsTrackingAllowed.mockReturnValue(false);
+            await (0, usageTracking_1.trackHelpUsage)(mockCommand);
+            expect(mockedTrackUsage).not.toHaveBeenCalled();
+        });
+        it('should track help usage with command', async () => {
+            await (0, usageTracking_1.trackHelpUsage)(mockCommand);
+            expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
+                action: 'cli-help',
+                command: mockCommand,
+                os: 'macos',
+                nodeVersion: mockNodeVersion,
+                nodeMajorVersion: 'v16',
+                version: package_json_1.version,
+            }), undefined);
+        });
+        it('should track main help usage without command', async () => {
+            await (0, usageTracking_1.trackHelpUsage)('');
+            expect(mockedLogger.debug).toHaveBeenCalledWith(expect.stringContaining('main command'));
+        });
+    });
+    describe('trackConvertFieldsUsage()', () => {
+        const mockCommand = 'convert-fields-command';
+        it('should not track when tracking is disabled', async () => {
+            mockedIsTrackingAllowed.mockReturnValue(false);
+            await (0, usageTracking_1.trackConvertFieldsUsage)(mockCommand);
+            expect(mockedTrackUsage).not.toHaveBeenCalled();
+        });
+        it('should track convert fields usage', async () => {
+            await (0, usageTracking_1.trackConvertFieldsUsage)(mockCommand);
+            expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
+                action: 'cli-process-fields',
+                command: mockCommand,
+                os: 'macos',
+                nodeVersion: mockNodeVersion,
+                nodeMajorVersion: 'v16',
+                version: package_json_1.version,
+            }), undefined);
+        });
+    });
+    describe('trackAuthAction()', () => {
+        const mockCommand = 'auth-command';
+        const mockAuthType = 'oauth2';
+        const mockStep = 'init';
+        const mockAccountId = 123;
+        it('should not track when tracking is disabled', async () => {
+            mockedIsTrackingAllowed.mockReturnValue(false);
+            await (0, usageTracking_1.trackAuthAction)(mockCommand, mockAuthType, mockStep, mockAccountId);
+            expect(mockedTrackUsage).not.toHaveBeenCalled();
+        });
+        it('should track auth action', async () => {
+            await (0, usageTracking_1.trackAuthAction)(mockCommand, mockAuthType, mockStep, mockAccountId);
+            expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
+                action: 'cli-auth',
+                command: mockCommand,
+                authType: mockAuthType,
+                step: mockStep,
+                os: 'macos',
+                nodeVersion: mockNodeVersion,
+                nodeMajorVersion: 'v16',
+                version: package_json_1.version,
+            }), mockAccountId);
+        });
+    });
+    describe('trackCommandMetadataUsage()', () => {
+        const mockCommand = 'metadata-command';
+        const mockMeta = { assetType: 'test-asset' };
+        const mockAccountId = 123;
+        it('should not track when tracking is disabled', async () => {
+            mockedIsTrackingAllowed.mockReturnValue(false);
+            await (0, usageTracking_1.trackCommandMetadataUsage)(mockCommand, mockMeta, mockAccountId);
+            expect(mockedTrackUsage).not.toHaveBeenCalled();
+        });
+        it('should track command metadata usage', async () => {
+            await (0, usageTracking_1.trackCommandMetadataUsage)(mockCommand, mockMeta, mockAccountId);
+            expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
+                action: 'cli-command-metadata',
+                command: mockCommand,
+                assetType: 'test-asset',
+                os: 'macos',
+                nodeVersion: mockNodeVersion,
+                nodeMajorVersion: 'v16',
+                version: package_json_1.version,
+            }), mockAccountId);
+        });
+    });
+    describe('Platform detection', () => {
+        it('should return "macos" for darwin platform', async () => {
+            Object.defineProperty(process, 'platform', { value: 'darwin' });
+            await (0, usageTracking_1.trackHelpUsage)('test');
+            expect(mockedTrackUsage).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.objectContaining({ os: 'macos' }), undefined);
+        });
+        it('should return "windows" for win32 platform', async () => {
+            Object.defineProperty(process, 'platform', { value: 'win32' });
+            await (0, usageTracking_1.trackHelpUsage)('test');
+            expect(mockedTrackUsage).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.objectContaining({ os: 'windows' }), undefined);
+        });
+        it('should return platform name for other platforms', async () => {
+            Object.defineProperty(process, 'platform', { value: 'linux' });
+            await (0, usageTracking_1.trackHelpUsage)('test');
+            expect(mockedTrackUsage).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.objectContaining({ os: 'linux' }), undefined);
+        });
+    });
+});

package/lib/__tests__/validation.test.d.ts

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

package/lib/__tests__/validation.test.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("@hubspot/local-dev-lib/config");
+const oauth_1 = require("@hubspot/local-dev-lib/oauth");
+const personalAccessKey_1 = require("@hubspot/local-dev-lib/personalAccessKey");
+const validation_1 = require("../validation");
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('@hubspot/local-dev-lib/oauth');
+vi.mock('@hubspot/local-dev-lib/personalAccessKey');
+vi.mock('../commonOpts');
+const yargsOption = (option) => ({
+    $0: '',
+    _: [''],
+    ...option,
+});
+describe('lib/validation', () => {
+    const getAccountIdMock = config_1.getAccountId;
+    const getAccountConfigMock = config_1.getAccountConfig;
+    const getOauthManagerMock = oauth_1.getOauthManager;
+    const accessTokenForPersonalAccessKeyMock = personalAccessKey_1.accessTokenForPersonalAccessKey;
+    describe('validateAccount', () => {
+        it('returns false if an account is missing', async () => {
+            getAccountIdMock.mockReturnValueOnce(null);
+            expect(await (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(false);
+        });
+        it('returns false if an account config is missing', async () => {
+            getAccountIdMock.mockReturnValueOnce('123');
+            getAccountConfigMock.mockReturnValueOnce(undefined);
+            expect(await (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(false);
+        });
+        it('returns false for oauth2 authType if auth is missing', async () => {
+            getAccountIdMock.mockReturnValueOnce('123');
+            getAccountConfigMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'oauth2',
+            });
+            expect(await (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(false);
+        });
+        it('returns false if OAuth is missing configuration', async () => {
+            getAccountIdMock.mockReturnValueOnce('123');
+            getAccountConfigMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'oauth2',
+                auth: {
+                    clientId: 'foo',
+                },
+            });
+            expect(await (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(false);
+        });
+        it('returns false if an access token was not retrieved', async () => {
+            getAccountIdMock.mockReturnValueOnce('123');
+            getOauthManagerMock.mockReturnValueOnce({
+                accessToken() {
+                    return null;
+                },
+            });
+            getAccountConfigMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'oauth2',
+                auth: {
+                    clientId: 'foo',
+                    clientSecret: 'abc',
+                    tokenInfo: {
+                        refreshToken: 'def',
+                    },
+                },
+            });
+            expect(await (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(false);
+        });
+        it('returns false if an getting an access token throws', async () => {
+            getAccountIdMock.mockReturnValueOnce('123');
+            getOauthManagerMock.mockReturnValueOnce({
+                accessToken() {
+                    throw new Error('It failed');
+                },
+            });
+            getAccountConfigMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'oauth2',
+                auth: {
+                    clientId: 'foo',
+                    clientSecret: 'abc',
+                    tokenInfo: {
+                        refreshToken: 'def',
+                    },
+                },
+            });
+            expect(await (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(false);
+        });
+        it('returns true if OAuth is configured and an access token is received', async () => {
+            getAccountIdMock.mockReturnValueOnce('123');
+            getOauthManagerMock.mockReturnValueOnce({
+                accessToken() {
+                    return 'yep';
+                },
+            });
+            getAccountConfigMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'oauth2',
+                auth: {
+                    clientId: 'foo',
+                    clientSecret: 'abc',
+                    tokenInfo: {
+                        refreshToken: 'def',
+                    },
+                },
+            });
+            expect(await (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(true);
+        });
+        it('returns false if "personalaccesskey" configured and getting an access token throws', async () => {
+            getAccountIdMock.mockReturnValueOnce('123');
+            accessTokenForPersonalAccessKeyMock.mockImplementationOnce(() => {
+                throw new Error('It failed');
+            });
+            getAccountConfigMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'personalaccesskey',
+                personalAccessKey: 'foo',
+            });
+            expect(await (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(false);
+        });
+        it('returns true if "personalaccesskey" configured and an access token is received', async () => {
+            getAccountIdMock.mockReturnValueOnce('123');
+            accessTokenForPersonalAccessKeyMock.mockImplementationOnce(() => {
+                return 'secret-stuff';
+            });
+            getAccountConfigMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'personalaccesskey',
+                personalAccessKey: 'foo',
+            });
+            expect(await (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(true);
+        });
+        it('returns true if apiKey is configured and present', async () => {
+            getAccountIdMock.mockReturnValueOnce('123');
+            getAccountConfigMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'apikey',
+                apiKey: 'my-secret-key',
+            });
+            expect(await (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(true);
+        });
+    });
+});

package/lib/__tests__/yargsUtils.test.d.ts

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