@hubspot/cli 8.0.10-experimental.7 → 8.0.11-experimental.0

package/lib/__tests__/cliUpgradeUtils.test.js

@@ -0,0 +1,131 @@
+import updateNotifier from 'update-notifier';
+import { isCliGloballyInstalled, canCliBeAutoUpgraded, getLatestCliVersion, getCliUpgradeInfo, installCliVersion, } from '../cliUpgradeUtils.js';
+import { isGloballyInstalled, getLatestPackageVersion, executeInstall, isInstalledGloballyWithNPM, } from '../npm/npmCli.js';
+import { pkg } from '../jsonLoader.js';
+vi.mock('../npm/npmCli');
+vi.mock('update-notifier');
+vi.mock('../jsonLoader.js', () => ({
+    pkg: {
+        name: '@hubspot/cli',
+        version: '7.11.2',
+    },
+}));
+const mockedIsGloballyInstalled = vi.mocked(isGloballyInstalled);
+const mockedGetLatestPackageVersion = vi.mocked(getLatestPackageVersion);
+const mockedExecuteInstall = vi.mocked(executeInstall);
+const mockedUpdateNotifier = vi.mocked(updateNotifier);
+const mockedIsInstalledGloballyWithNPM = vi.mocked(isInstalledGloballyWithNPM);
+describe('lib/cliUpgradeUtils', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('isCliGloballyInstalled()', () => {
+        it('should return true when hs is globally installed', async () => {
+            mockedIsGloballyInstalled.mockResolvedValueOnce(true);
+            const result = await isCliGloballyInstalled();
+            expect(result).toBe(true);
+            expect(mockedIsGloballyInstalled).toHaveBeenCalledTimes(1);
+            expect(mockedIsGloballyInstalled).toHaveBeenCalledWith('hs');
+        });
+        it('should return false when hs is not globally installed', async () => {
+            mockedIsGloballyInstalled.mockResolvedValueOnce(false);
+            const result = await isCliGloballyInstalled();
+            expect(result).toBe(false);
+            expect(mockedIsGloballyInstalled).toHaveBeenCalledTimes(1);
+            expect(mockedIsGloballyInstalled).toHaveBeenCalledWith('hs');
+        });
+    });
+    describe('canCliBeAutoUpgraded()', () => {
+        it('should return true when package is installed globally via npm', async () => {
+            mockedIsInstalledGloballyWithNPM.mockResolvedValueOnce(true);
+            const result = await canCliBeAutoUpgraded();
+            expect(result).toBe(true);
+            expect(mockedIsInstalledGloballyWithNPM).toHaveBeenCalledTimes(1);
+            expect(mockedIsInstalledGloballyWithNPM).toHaveBeenCalledWith(pkg.name);
+        });
+        it('should return false when package is not installed globally via npm', async () => {
+            mockedIsInstalledGloballyWithNPM.mockResolvedValueOnce(false);
+            const result = await canCliBeAutoUpgraded();
+            expect(result).toBe(false);
+            expect(mockedIsInstalledGloballyWithNPM).toHaveBeenCalledTimes(1);
+            expect(mockedIsInstalledGloballyWithNPM).toHaveBeenCalledWith(pkg.name);
+        });
+    });
+    describe('getLatestCliVersion()', () => {
+        it('should return the latest CLI version', async () => {
+            const latest = '7.12.0';
+            const next = '7.12.0-beta.1';
+            mockedGetLatestPackageVersion.mockResolvedValueOnce({ latest, next });
+            const result = await getLatestCliVersion();
+            expect(result).toEqual({ latest, next });
+            expect(mockedGetLatestPackageVersion).toHaveBeenCalledTimes(1);
+            expect(mockedGetLatestPackageVersion).toHaveBeenCalledWith(pkg.name);
+        });
+        it('should throw errors from getLatestPackageVersion', async () => {
+            const errorMessage = 'Failed to get version';
+            mockedGetLatestPackageVersion.mockRejectedValueOnce(new Error(errorMessage));
+            await expect(getLatestCliVersion()).rejects.toThrow(errorMessage);
+            expect(mockedGetLatestPackageVersion).toHaveBeenCalledWith(pkg.name);
+        });
+    });
+    describe('getCliUpgradeInfo()', () => {
+        it('should return upgrade info when update is available', () => {
+            const mockNotifier = {
+                update: {
+                    current: '7.11.2',
+                    latest: '7.12.0',
+                    type: 'minor',
+                },
+            };
+            mockedUpdateNotifier.mockReturnValue(mockNotifier);
+            const result = getCliUpgradeInfo();
+            expect(result).toMatchObject({
+                current: '7.11.2',
+                latest: '7.12.0',
+                type: 'minor',
+            });
+            expect(mockedUpdateNotifier).toHaveBeenCalledWith({
+                pkg,
+                distTag: 'latest',
+                shouldNotifyInNpmScript: true,
+            });
+        });
+        it('should return cached info on subsequent calls', () => {
+            const mockNotifier = {
+                update: {
+                    current: '7.11.2',
+                    latest: '7.12.0',
+                    type: 'minor',
+                },
+            };
+            mockedUpdateNotifier.mockReturnValue(mockNotifier);
+            const firstCall = getCliUpgradeInfo();
+            const secondCall = getCliUpgradeInfo();
+            expect(firstCall).toEqual(secondCall);
+            expect(firstCall.current).toBe('7.11.2');
+            expect(firstCall.latest).toBe('7.12.0');
+            expect(firstCall.type).toBe('minor');
+        });
+    });
+    describe('installCliVersion()', () => {
+        it('should install latest version by default', async () => {
+            mockedExecuteInstall.mockResolvedValueOnce(undefined);
+            await installCliVersion();
+            expect(mockedExecuteInstall).toHaveBeenCalledTimes(1);
+            expect(mockedExecuteInstall).toHaveBeenCalledWith([`${pkg.name}@latest`], '-g');
+        });
+        it('should install a specific version when provided', async () => {
+            const version = '7.12.0';
+            mockedExecuteInstall.mockResolvedValueOnce(undefined);
+            await installCliVersion(version);
+            expect(mockedExecuteInstall).toHaveBeenCalledTimes(1);
+            expect(mockedExecuteInstall).toHaveBeenCalledWith([`${pkg.name}@${version}`], '-g');
+        });
+        it('should throw errors from executeInstall', async () => {
+            const errorMessage = 'Installation failed';
+            mockedExecuteInstall.mockRejectedValueOnce(new Error(errorMessage));
+            await expect(installCliVersion()).rejects.toThrow(errorMessage);
+            expect(mockedExecuteInstall).toHaveBeenCalledWith([`${pkg.name}@latest`], '-g');
+        });
+    });
+});

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

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

package/lib/__tests__/commandSuggestion.test.js

@@ -0,0 +1,121 @@
+import yargs from 'yargs';
+import { addCommandSuggestions, commandSuggestionMappings, } from '../commandSuggestion.js';
+import { uiLogger } from '../ui/logger.js';
+import { uiCommandReference } from '../ui/index.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+vi.mock('../ui/logger.js');
+vi.mock('../ui/index.js');
+const commandSpy = vi
+    .spyOn(yargs, 'command')
+    .mockReturnValue(yargs);
+describe('lib/commandSuggestion', () => {
+    const uiLoggerErrorMock = uiLogger.error;
+    const uiCommandReferenceMock = uiCommandReference;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        commandSpy.mockClear();
+        uiCommandReferenceMock.mockImplementation((command) => `\`${command}\``);
+    });
+    describe('addCommandSuggestions', () => {
+        it('adds all command suggestions to yargs instance', () => {
+            addCommandSuggestions(yargs);
+            expect(commandSpy).toHaveBeenCalledTimes(Object.keys(commandSuggestionMappings).length);
+        });
+        it('registers each mapping from commandSuggestionMappings', () => {
+            addCommandSuggestions(yargs);
+            Object.entries(commandSuggestionMappings).forEach(([oldCommand]) => {
+                expect(commandSpy).toHaveBeenCalledWith(expect.objectContaining({
+                    command: oldCommand,
+                }));
+            });
+        });
+        it('returns the yargs instance', () => {
+            const yargsInstance = yargs;
+            const result = addCommandSuggestions(yargsInstance);
+            expect(result).toBe(yargsInstance);
+        });
+        it('creates command modules with handler that logs error and exits', () => {
+            vi.spyOn(process, 'exit').mockImplementation(() => {
+                throw new Error(`process.exit called with ${EXIT_CODES.ERROR}`);
+            });
+            addCommandSuggestions(yargs);
+            // Get the first registered command module
+            const firstCall = commandSpy.mock.calls[0];
+            const commandModule = firstCall[0];
+            const firstMapping = Object.entries(commandSuggestionMappings)[0];
+            const [, newCommand] = firstMapping;
+            // Verify the command module structure
+            expect(commandModule).toHaveProperty('command');
+            expect(commandModule).toHaveProperty('handler');
+            expect(commandModule).toHaveProperty('builder');
+            // Invoke the handler to verify behavior
+            expect(() => {
+                commandModule.handler({});
+            }).toThrow('process.exit called');
+            expect(uiCommandReferenceMock).toHaveBeenCalledWith(newCommand);
+            expect(uiLoggerErrorMock).toHaveBeenCalledWith(`Did you mean \`${newCommand}\`?`);
+            expect(process.exit).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            vi.restoreAllMocks();
+        });
+        it('creates command modules with builder that sets strict mode to false', async () => {
+            const yargsInstance = yargs;
+            const commandSpyForTest = vi
+                .spyOn(yargsInstance, 'command')
+                .mockReturnValue(yargsInstance);
+            addCommandSuggestions(yargsInstance);
+            // Get a command module and verify it has a builder
+            const firstCall = commandSpyForTest.mock.calls[0];
+            const commandModule = firstCall[0];
+            expect(commandModule).toHaveProperty('builder');
+            expect(typeof commandModule.builder).toBe('function');
+            // Create a mock yargs builder with strict method
+            const mockYargsBuilder = {
+                strict: vi.fn().mockReturnThis(),
+                help: vi.fn().mockReturnThis(),
+                version: vi.fn().mockReturnThis(),
+            };
+            await commandModule.builder(mockYargsBuilder);
+            expect(mockYargsBuilder.strict).toHaveBeenCalledWith(false);
+            commandSpyForTest.mockRestore();
+        });
+        it('handles commands with multiple words', () => {
+            vi.spyOn(process, 'exit').mockImplementation(() => {
+                throw new Error(`process.exit called with ${EXIT_CODES.ERROR}`);
+            });
+            // Find a multi-word command
+            const multiWordCommand = Object.entries(commandSuggestionMappings).find(([oldCommand]) => oldCommand.includes(' '));
+            expect(multiWordCommand).toBeDefined();
+            if (multiWordCommand) {
+                const [oldCommand, newCommand] = multiWordCommand;
+                const yargsInstance = yargs;
+                const commandSpyForTest = vi
+                    .spyOn(yargsInstance, 'command')
+                    .mockReturnValue(yargsInstance);
+                addCommandSuggestions(yargsInstance);
+                // Find the call for this multi-word command
+                const call = commandSpyForTest.mock.calls.find(call => call[0]
+                    .command === oldCommand);
+                expect(call).toBeDefined();
+                const commandModule = call[0];
+                expect(commandModule).toHaveProperty('handler');
+                // Invoke handler to verify it works with multi-word commands
+                expect(() => {
+                    commandModule.handler({});
+                }).toThrow('process.exit called');
+                expect(uiCommandReferenceMock).toHaveBeenCalledWith(newCommand);
+                expect(uiLoggerErrorMock).toHaveBeenCalledWith(`Did you mean \`${newCommand}\`?`);
+                commandSpyForTest.mockRestore();
+            }
+            vi.restoreAllMocks();
+        });
+    });
+    describe('commandSuggestionMappings', () => {
+        it('all mappings point to valid new commands', () => {
+            Object.entries(commandSuggestionMappings).forEach(([, newCommand]) => {
+                expect(newCommand).toMatch(/^hs /);
+                expect(typeof newCommand).toBe('string');
+                expect(newCommand.length).toBeGreaterThan(0);
+            });
+        });
+    });
+});

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

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

package/lib/__tests__/commonOpts.test.js

@@ -0,0 +1,80 @@
+import { CMS_PUBLISH_MODE, DEFAULT_CMS_PUBLISH_MODE, } from '@hubspot/local-dev-lib/constants/files';
+import { getConfig, getConfigAccountById } from '@hubspot/local-dev-lib/config';
+import { getCmsPublishMode } from '../commonOpts.js';
+const mockedGetConfigAccountById = getConfigAccountById;
+const mockedGetConfig = getConfig;
+function buildArguments(args) {
+    return {
+        _: [],
+        $0: '',
+        ...args,
+    };
+}
+vi.mock('@hubspot/local-dev-lib/config');
+describe('lib/commonOpts', () => {
+    describe('getCmsPublishMode()', () => {
+        const accounts = {
+            PROD: 123,
+            DEV: 456,
+        };
+        const devAccountConfig = {
+            accountId: accounts.DEV,
+            name: 'DEV',
+            defaultCmsPublishMode: CMS_PUBLISH_MODE.draft,
+        };
+        const prodAccountConfig = {
+            accountId: accounts.PROD,
+            name: 'PROD',
+        };
+        const config = {
+            defaultAccount: 'DEV',
+            accounts: [devAccountConfig, prodAccountConfig],
+        };
+        const configWithDefaultCmsPublishMode = {
+            ...config,
+            defaultCmsPublishMode: CMS_PUBLISH_MODE.draft,
+        };
+        afterEach(() => {
+            vi.resetAllMocks();
+        });
+        describe('cms publish mode option precedence', () => {
+            describe('1. --cmsPublishMode', () => {
+                it('should return the cms publish mode specified by the command option if present.', () => {
+                    mockedGetConfig.mockReturnValue(configWithDefaultCmsPublishMode);
+                    mockedGetConfigAccountById.mockReturnValue(devAccountConfig);
+                    expect(getCmsPublishMode(buildArguments({
+                        cmsPublishMode: CMS_PUBLISH_MODE.draft,
+                    }))).toBe(CMS_PUBLISH_MODE.draft);
+                    expect(getCmsPublishMode(buildArguments({
+                        cmsPublishMode: CMS_PUBLISH_MODE.publish,
+                    }))).toBe(CMS_PUBLISH_MODE.publish);
+                });
+            });
+            describe('2. hubspot.config.yml -> config.accounts[x].defaultCmsPublishMode', () => {
+                it('should return the defaultCmsPublishMode specified by the account specific config if present.', () => {
+                    mockedGetConfig.mockReturnValue(configWithDefaultCmsPublishMode);
+                    mockedGetConfigAccountById.mockReturnValue(devAccountConfig);
+                    expect(getCmsPublishMode(buildArguments({
+                        account: accounts.DEV,
+                    }))).toBe(CMS_PUBLISH_MODE.draft);
+                });
+            });
+            describe('3. hubspot.config.yml -> config.defaultCmsPublishMode', () => {
+                it('should return the defaultCmsPublishMode specified by the config if present.', () => {
+                    mockedGetConfig.mockReturnValue(configWithDefaultCmsPublishMode);
+                    mockedGetConfigAccountById.mockReturnValue(prodAccountConfig);
+                    expect(getCmsPublishMode(buildArguments({
+                        account: accounts.PROD,
+                    }))).toBe(CMS_PUBLISH_MODE.draft);
+                });
+            });
+            describe('4. DEFAULT_CMS_PUBLISH_MODE', () => {
+                it('should return the defaultCmsPubishMode specified by the config if present.', () => {
+                    expect(getCmsPublishMode(buildArguments({
+                        account: 'xxxxx',
+                    }))).toBe(DEFAULT_CMS_PUBLISH_MODE);
+                });
+            });
+        });
+    });
+});

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

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