@hubspot/cli 7.7.19-experimental.2 → 7.7.20-experimental.0

package/lib/__tests__/usageTracking.test.js

@@ -0,0 +1,171 @@
+"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);
+            // Allow setImmediate to execute
+            await new Promise(resolve => setImmediate(resolve));
+            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);
+            // Allow setImmediate to execute
+            await new Promise(resolve => setImmediate(resolve));
+            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.mockRejectedValue(error);
+            await (0, usageTracking_1.trackCommandUsage)(mockCommand);
+            // Allow setImmediate to execute
+            await new Promise(resolve => setImmediate(resolve));
+            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,
+            }));
+        });
+        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,
+            }));
+        });
+    });
+    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);
+            // Allow setImmediate to execute
+            await new Promise(resolve => setImmediate(resolve));
+            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' }));
+        });
+        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' }));
+        });
+        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' }));
+        });
+    });
+});

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 {};

package/lib/__tests__/yargsUtils.test.js

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const yargsUtils_1 = require("../yargsUtils");
+const commonOpts = __importStar(require("../commonOpts"));
+vi.mock('../commonOpts');
+const argvWithFlag = ['hs', 'command', '--test'];
+const argvWithoutFlag = ['hs', 'command'];
+describe('lib/yargsUtils', () => {
+    describe('hasFlag()', () => {
+        it('should return true if the flag is present', () => {
+            const flag = (0, yargsUtils_1.hasFlag)('test', argvWithFlag);
+            expect(flag).toBe(true);
+        });
+        it('should return false if argv is an empty array', () => {
+            const flag = (0, yargsUtils_1.hasFlag)('test', []);
+            expect(flag).toBe(false);
+        });
+        it('should return false if the flag is not present', () => {
+            const flag = (0, yargsUtils_1.hasFlag)('test', argvWithoutFlag);
+            expect(flag).toBe(false);
+        });
+    });
+    describe('makeYargsBuilder()', () => {
+        it('should add specified options', async () => {
+            const builder = (0, yargsUtils_1.makeYargsBuilder)(yargs => yargs, 'command', 'describe', {
+                useAccountOptions: true,
+                useConfigOptions: true,
+                useEnvironmentOptions: true,
+                useTestingOptions: true,
+                useGlobalOptions: true,
+            });
+            await builder({});
+            expect(commonOpts.addGlobalOptions).toHaveBeenCalled();
+            expect(commonOpts.addAccountOptions).toHaveBeenCalled();
+            expect(commonOpts.addConfigOptions).toHaveBeenCalled();
+            expect(commonOpts.addUseEnvironmentOptions).toHaveBeenCalled();
+            expect(commonOpts.addTestingOptions).toHaveBeenCalled();
+            expect(commonOpts.addCustomHelpOutput).toHaveBeenCalled();
+        });
+    });
+});

package/lib/app/__tests__/migrate.test.d.ts

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