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

package/commands/__tests__/upgrade.test.js

@@ -0,0 +1,309 @@
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import yargs from 'yargs';
+import upgradeCommand from '../upgrade.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { canCliBeAutoUpgraded, getLatestCliVersion, installCliVersion, } from '../../lib/cliUpgradeUtils.js';
+import { confirmPrompt } from '../../lib/prompts/promptUtils.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { pkg } from '../../lib/jsonLoader.js';
+import SpinniesManager from '../../lib/ui/SpinniesManager.js';
+import { debugError } from '../../lib/errorHandlers/index.js';
+import { commands } from '../../lang/en.js';
+import { isConfigFlagEnabled } from '@hubspot/local-dev-lib/config';
+vi.mock('../../lib/usageTracking');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../lib/cliUpgradeUtils');
+vi.mock('../../lib/prompts/promptUtils');
+vi.mock('../../lib/ui/logger.js');
+vi.mock('../../lib/jsonLoader.js');
+vi.mock('../../lib/ui/SpinniesManager');
+vi.mock('../../lib/errorHandlers/index.js');
+const mockedTrackCommandUsage = vi.mocked(trackCommandUsage);
+const mockedCanCliBeAutoUpgraded = vi.mocked(canCliBeAutoUpgraded);
+const mockedGetLatestCliVersion = vi.mocked(getLatestCliVersion);
+const mockedInstallCliVersion = vi.mocked(installCliVersion);
+const mockedConfirmPrompt = vi.mocked(confirmPrompt);
+const mockedDebugError = vi.mocked(debugError);
+const mockedIsConfigFlagEnabled = vi.mocked(isConfigFlagEnabled);
+const optionSpy = vi
+    .spyOn(yargs, 'option')
+    .mockReturnValue(yargs);
+const positionalSpy = vi
+    .spyOn(yargs, 'positional')
+    .mockReturnValue(yargs);
+describe('commands/upgrade', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let processExitSpy;
+    const accountId = 123456;
+    const currentVersion = '7.11.2';
+    const latestVersion = '7.12.0';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // @ts-expect-error Doesn't match the actual signature because then the linter complains about unused variables
+        processExitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { });
+        vi.mocked(pkg).version = currentVersion;
+        vi.mocked(SpinniesManager.init).mockReturnValue(undefined);
+        vi.mocked(SpinniesManager.add).mockReturnValue(undefined);
+        vi.mocked(SpinniesManager.succeed).mockReturnValue(undefined);
+        vi.mocked(SpinniesManager.fail).mockReturnValue(undefined);
+        // Default mock for isConfigFlagEnabled - can be overridden in individual tests
+        mockedIsConfigFlagEnabled.mockReturnValue(false);
+        // Reset mock implementations to ensure clean state
+        mockedGetLatestCliVersion.mockReset();
+        mockedCanCliBeAutoUpgraded.mockReset();
+        mockedInstallCliVersion.mockReset();
+        mockedConfirmPrompt.mockReset();
+    });
+    describe('command', () => {
+        it('should have the proper command names', () => {
+            expect(upgradeCommand.command).toEqual([
+                'upgrade [version]',
+                'update [version]',
+            ]);
+        });
+    });
+    describe('describe', () => {
+        it('should have a description', () => {
+            expect(upgradeCommand.describe).toBeDefined();
+            expect(upgradeCommand.describe).toContain('Install');
+        });
+    });
+    describe('builder', () => {
+        it('should apply the correct options', async () => {
+            await upgradeCommand.builder(yargs);
+            expect(positionalSpy).toHaveBeenCalledWith('[version]', {
+                describe: commands.upgrade.options.version,
+                type: 'string',
+            });
+            expect(optionSpy).toHaveBeenCalledWith('force', {
+                alias: 'f',
+                describe: commands.upgrade.options.force,
+                type: 'boolean',
+                default: false,
+            });
+            expect(optionSpy).toHaveBeenCalledWith('beta', {
+                alias: 'next',
+                describe: commands.upgrade.options.beta,
+                type: 'boolean',
+                default: false,
+            });
+        });
+    });
+    describe('handler', () => {
+        it('should track the command usage', async () => {
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: '7.12.0-beta.1',
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(false);
+            await upgradeCommand.handler({
+                derivedAccountId: accountId,
+            });
+            expect(mockedTrackCommandUsage).toHaveBeenCalledTimes(1);
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('upgrade', {}, accountId);
+        });
+        it('should exit successfully when already on latest version', async () => {
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: currentVersion,
+                next: '7.11.2-beta.1',
+            });
+            await upgradeCommand.handler({});
+            expect(uiLogger.log).toHaveBeenCalledWith(commands.upgrade.alreadyLatest(currentVersion));
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+            expect(mockedInstallCliVersion).not.toHaveBeenCalled();
+        });
+        it('should exit successfully when already on requested version', async () => {
+            const requestedVersion = currentVersion;
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: '7.12.0-beta.1',
+            });
+            await upgradeCommand.handler({
+                version: requestedVersion,
+            });
+            expect(uiLogger.log).toHaveBeenCalledWith(commands.upgrade.alreadyOnVersion(currentVersion));
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+            expect(mockedInstallCliVersion).not.toHaveBeenCalled();
+        });
+        it('should show message when CLI is not globally installed', async () => {
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: '7.12.0-beta.1',
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(false);
+            await upgradeCommand.handler({});
+            expect(uiLogger.log).toHaveBeenCalledWith(commands.upgrade.autoUpgradeNotAvailable(latestVersion));
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+            expect(mockedInstallCliVersion).not.toHaveBeenCalled();
+        });
+        it('should cancel upgrade when user declines confirmation', async () => {
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: '7.12.0-beta.1',
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(true);
+            mockedConfirmPrompt.mockResolvedValueOnce(false);
+            await upgradeCommand.handler({});
+            expect(mockedConfirmPrompt).toHaveBeenCalledWith(commands.upgrade.confirmPrompt(currentVersion, latestVersion), { defaultAnswer: true });
+            expect(uiLogger.log).toHaveBeenCalledWith(commands.upgrade.cancelled);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+            expect(mockedInstallCliVersion).not.toHaveBeenCalled();
+        });
+        it('should upgrade successfully when user confirms', async () => {
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: '7.12.0-beta.1',
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(true);
+            mockedConfirmPrompt.mockResolvedValueOnce(true);
+            mockedInstallCliVersion.mockResolvedValueOnce(undefined);
+            await upgradeCommand.handler({});
+            expect(mockedConfirmPrompt).toHaveBeenCalled();
+            expect(SpinniesManager.add).toHaveBeenCalledWith('upgrade', {
+                text: commands.upgrade.installing(latestVersion),
+            });
+            expect(mockedInstallCliVersion).toHaveBeenCalledWith(latestVersion);
+            expect(SpinniesManager.succeed).toHaveBeenCalledWith('upgrade', {
+                text: commands.upgrade.success(latestVersion),
+            });
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+        it('should upgrade without confirmation when --force is used', async () => {
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: '7.12.0-beta.1',
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(true);
+            mockedInstallCliVersion.mockResolvedValueOnce(undefined);
+            await upgradeCommand.handler({
+                force: true,
+            });
+            expect(mockedConfirmPrompt).not.toHaveBeenCalled();
+            expect(mockedInstallCliVersion).toHaveBeenCalledWith(latestVersion);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+        it('should install specific version when provided', async () => {
+            const specificVersion = '7.10.0';
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: '7.12.0',
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(true);
+            mockedConfirmPrompt.mockResolvedValueOnce(true);
+            mockedInstallCliVersion.mockResolvedValueOnce(undefined);
+            await upgradeCommand.handler({
+                version: specificVersion,
+            });
+            expect(mockedInstallCliVersion).toHaveBeenCalledWith(specificVersion);
+            expect(SpinniesManager.add).toHaveBeenCalledWith('upgrade', {
+                text: commands.upgrade.installing(specificVersion),
+            });
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+        it('should handle installation errors', async () => {
+            const error = new Error('Installation failed');
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: '7.12.0-beta.1',
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(true);
+            mockedConfirmPrompt.mockResolvedValueOnce(true);
+            mockedInstallCliVersion.mockRejectedValueOnce(error);
+            await upgradeCommand.handler({});
+            expect(mockedDebugError).toHaveBeenCalledWith(error);
+            expect(SpinniesManager.fail).toHaveBeenCalledWith('upgrade', {
+                text: commands.upgrade.errors.installFailed,
+            });
+            expect(uiLogger.error).toHaveBeenCalledWith(commands.upgrade.errors.generic);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should install beta version when --beta flag is used', async () => {
+            const betaVersion = '7.13.0-beta.1';
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: betaVersion,
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(true);
+            mockedConfirmPrompt.mockResolvedValueOnce(true);
+            mockedInstallCliVersion.mockResolvedValueOnce(undefined);
+            await upgradeCommand.handler({
+                beta: true,
+            });
+            expect(mockedGetLatestCliVersion).toHaveBeenCalled();
+            expect(mockedInstallCliVersion).toHaveBeenCalledWith(betaVersion);
+            expect(SpinniesManager.add).toHaveBeenCalledWith('upgrade', {
+                text: commands.upgrade.installing(betaVersion),
+            });
+            expect(SpinniesManager.succeed).toHaveBeenCalledWith('upgrade', {
+                text: commands.upgrade.success(betaVersion),
+            });
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+        it('should error when beta is requested but next version is not available', async () => {
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: null,
+            });
+            mockedIsConfigFlagEnabled.mockReturnValue(false);
+            await upgradeCommand.handler({
+                beta: true,
+            });
+            expect(mockedGetLatestCliVersion).toHaveBeenCalled();
+            expect(uiLogger.error).toHaveBeenCalledWith(commands.upgrade.errors.unableToDetermineLatestVersion);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            expect(mockedInstallCliVersion).not.toHaveBeenCalled();
+            expect(mockedCanCliBeAutoUpgraded).not.toHaveBeenCalled();
+        });
+        it('should show already on latest beta version message', async () => {
+            const betaVersion = '7.12.0-beta.1';
+            vi.mocked(pkg).version = betaVersion;
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: betaVersion,
+            });
+            await upgradeCommand.handler({
+                beta: true,
+            });
+            expect(uiLogger.log).toHaveBeenCalledWith(commands.upgrade.alreadyLatest(betaVersion, true));
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+            expect(mockedInstallCliVersion).not.toHaveBeenCalled();
+        });
+        it('should not show auto-upgrade message when beta flag is used', async () => {
+            const betaVersion = '7.12.0-beta.1';
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: betaVersion,
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(true);
+            mockedConfirmPrompt.mockResolvedValueOnce(true);
+            mockedInstallCliVersion.mockResolvedValueOnce(undefined);
+            mockedIsConfigFlagEnabled.mockReturnValue(false);
+            await upgradeCommand.handler({
+                beta: true,
+            });
+            // Verify the auto-upgrade message was not logged
+            const logCalls = vi.mocked(uiLogger.log).mock.calls;
+            const autoUpgradeMessageCall = logCalls.find(call => call[0]?.includes('automatic updates'));
+            expect(autoUpgradeMessageCall).toBeUndefined();
+            // Should succeed even though auto-updates are disabled when beta is used
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+            expect(mockedInstallCliVersion).toHaveBeenCalledWith(betaVersion);
+        });
+        it('should upgrade to beta without confirmation when --force and --beta are used', async () => {
+            const betaVersion = '7.12.0-beta.1';
+            mockedGetLatestCliVersion.mockResolvedValueOnce({
+                latest: latestVersion,
+                next: betaVersion,
+            });
+            mockedCanCliBeAutoUpgraded.mockResolvedValueOnce(true);
+            mockedInstallCliVersion.mockResolvedValueOnce(undefined);
+            await upgradeCommand.handler({
+                force: true,
+                beta: true,
+            });
+            expect(mockedConfirmPrompt).not.toHaveBeenCalled();
+            expect(mockedInstallCliVersion).toHaveBeenCalledWith(betaVersion);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+    });
+});

package/commands/account/__tests__/auth.test.d.ts

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

package/commands/account/__tests__/auth.test.js

@@ -0,0 +1,206 @@
+import yargs from 'yargs';
+import * as configLib from '@hubspot/local-dev-lib/config';
+import * as personalAccessKeyLib from '@hubspot/local-dev-lib/personalAccessKey';
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
+import { addGlobalOptions, addTestingOptions, } from '../../../lib/commonOpts.js';
+import * as configMigrate from '../../../lib/configMigrate.js';
+import * as processLib from '../../../lib/process.js';
+import * as usageTrackingLib from '../../../lib/usageTracking.js';
+import * as personalAccessKeyPromptLib from '../../../lib/prompts/personalAccessKeyPrompt.js';
+import * as accountNamePromptLib from '../../../lib/prompts/accountNamePrompt.js';
+import * as setAsDefaultPromptLib from '../../../lib/prompts/setAsDefaultAccountPrompt.js';
+import * as parsingLib from '../../../lib/parsing.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import accountAuthCommand from '../auth.js';
+vi.mock('../../../lib/commonOpts');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/personalAccessKey');
+vi.mock('../../../lib/configMigrate.js');
+vi.mock('../../../lib/process.js');
+vi.mock('../../../lib/prompts/personalAccessKeyPrompt.js');
+vi.mock('../../../lib/prompts/accountNamePrompt.js');
+vi.mock('../../../lib/prompts/setAsDefaultAccountPrompt.js');
+vi.mock('../../../lib/parsing.js');
+vi.mock('../../../lib/ui/index.js');
+vi.mock('../../../lib/errorHandlers/index.js');
+const localConfigFileExistsSpy = vi.spyOn(configLib, 'localConfigFileExists');
+const globalConfigFileExistsSpy = vi.spyOn(configLib, 'globalConfigFileExists');
+const createEmptyConfigFileSpy = vi.spyOn(configLib, 'createEmptyConfigFile');
+const getAccessTokenSpy = vi.spyOn(personalAccessKeyLib, 'getAccessToken');
+const updateConfigWithAccessTokenSpy = vi.spyOn(personalAccessKeyLib, 'updateConfigWithAccessToken');
+const handleMergeSpy = vi.spyOn(configMigrate, 'handleMerge');
+const handleMigrationSpy = vi.spyOn(configMigrate, 'handleMigration');
+const handleExitSpy = vi.spyOn(processLib, 'handleExit');
+const trackCommandUsageSpy = vi.spyOn(usageTrackingLib, 'trackCommandUsage');
+const trackAuthActionSpy = vi.spyOn(usageTrackingLib, 'trackAuthAction');
+const personalAccessKeyPromptSpy = vi.spyOn(personalAccessKeyPromptLib, 'personalAccessKeyPrompt');
+const cliAccountNamePromptSpy = vi.spyOn(accountNamePromptLib, 'cliAccountNamePrompt');
+const setAsDefaultAccountPromptSpy = vi.spyOn(setAsDefaultPromptLib, 'setAsDefaultAccountPrompt');
+const parseStringToNumberSpy = vi.spyOn(parsingLib, 'parseStringToNumber');
+const processExitSpy = vi.spyOn(process, 'exit');
+describe('commands/account/auth', () => {
+    const yargsMock = yargs;
+    beforeEach(() => {
+        // @ts-expect-error Mock implementation
+        processExitSpy.mockImplementation(() => { });
+        localConfigFileExistsSpy.mockReturnValue(false);
+        globalConfigFileExistsSpy.mockReturnValue(true);
+        createEmptyConfigFileSpy.mockImplementation(() => { });
+        handleExitSpy.mockImplementation(async () => { });
+        trackCommandUsageSpy.mockImplementation(async () => { });
+        trackAuthActionSpy.mockResolvedValue(undefined);
+        personalAccessKeyPromptSpy.mockResolvedValue({
+            personalAccessKey: 'test-key',
+            env: 'prod',
+        });
+        getAccessTokenSpy.mockResolvedValue({
+            portalId: 456789,
+            accessToken: 'test-access-token',
+            expiresAt: '2025-01-01T00:00:00.000Z',
+            scopeGroups: ['content'],
+            encodedOAuthRefreshToken: 'encoded-token',
+            hubName: 'Test Hub',
+            accountType: 'STANDARD',
+        });
+        cliAccountNamePromptSpy.mockResolvedValue({ name: 'test-account' });
+        updateConfigWithAccessTokenSpy.mockResolvedValue({
+            accountId: 456789,
+            name: 'test-account',
+            authType: 'personalaccesskey',
+            env: 'prod',
+            auth: { tokenInfo: { accessToken: 'test-token' } },
+            personalAccessKey: 'test-key',
+        });
+        setAsDefaultAccountPromptSpy.mockResolvedValue(true);
+    });
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(accountAuthCommand.command).toEqual('auth');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(accountAuthCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            accountAuthCommand.builder(yargsMock);
+            expect(addTestingOptions).toHaveBeenCalledTimes(1);
+            expect(addTestingOptions).toHaveBeenCalledWith(yargsMock);
+            expect(addGlobalOptions).toHaveBeenCalledTimes(1);
+            expect(addGlobalOptions).toHaveBeenCalledWith(yargsMock);
+        });
+    });
+    describe('handler', () => {
+        let args;
+        beforeEach(() => {
+            args = {
+                derivedAccountId: 0,
+                d: false,
+                debug: false,
+                _: [],
+                $0: '',
+            };
+        });
+        it('should track command usage', async () => {
+            await accountAuthCommand.handler(args);
+            expect(trackCommandUsageSpy).toHaveBeenCalledWith('account-auth', {}, undefined);
+            expect(trackAuthActionSpy).toHaveBeenCalledWith('account-auth', 'personalaccesskey', 'started');
+        });
+        it('should not track when tracking is disabled', async () => {
+            args.disableTracking = true;
+            await accountAuthCommand.handler(args);
+            expect(trackCommandUsageSpy).not.toHaveBeenCalled();
+            expect(trackAuthActionSpy).not.toHaveBeenCalled();
+            expect(updateConfigWithAccessTokenSpy).toHaveBeenCalled();
+        });
+        it('should parse user provided account ID', async () => {
+            args.userProvidedAccount = '123456';
+            parseStringToNumberSpy.mockReturnValue(123456);
+            await accountAuthCommand.handler(args);
+            expect(parseStringToNumberSpy).toHaveBeenCalledWith('123456');
+            expect(trackCommandUsageSpy).toHaveBeenCalledWith('account-auth', {}, 123456);
+        });
+        it('should error on invalid account ID', async () => {
+            args.userProvidedAccount = 'invalid';
+            parseStringToNumberSpy.mockImplementation(() => {
+                throw new Error('Invalid');
+            });
+            await accountAuthCommand.handler(args);
+            expect(uiLogger.error).toHaveBeenCalledWith('--account must be a number.');
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should handle merge when both configs exist', async () => {
+            localConfigFileExistsSpy.mockReturnValue(true);
+            globalConfigFileExistsSpy.mockReturnValue(true);
+            handleMergeSpy.mockResolvedValue(true);
+            await accountAuthCommand.handler(args);
+            expect(handleMergeSpy).toHaveBeenCalled();
+        });
+        it('should exit if merge is not confirmed', async () => {
+            localConfigFileExistsSpy.mockReturnValue(true);
+            globalConfigFileExistsSpy.mockReturnValue(true);
+            handleMergeSpy.mockResolvedValue(false);
+            await accountAuthCommand.handler(args);
+            expect(uiLogger.log).toHaveBeenCalled();
+            expect(trackAuthActionSpy).toHaveBeenCalledWith('account-auth', 'personalaccesskey', 'error');
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should handle migration when only local config exists', async () => {
+            localConfigFileExistsSpy.mockReturnValue(true);
+            globalConfigFileExistsSpy.mockReturnValue(false);
+            handleMigrationSpy.mockResolvedValue(true);
+            await accountAuthCommand.handler(args);
+            expect(handleMigrationSpy).toHaveBeenCalled();
+        });
+        it('should create config file if it does not exist', async () => {
+            globalConfigFileExistsSpy.mockReturnValue(false);
+            await accountAuthCommand.handler(args);
+            expect(createEmptyConfigFileSpy).toHaveBeenCalledWith(true);
+        });
+        it('should prompt for personal access key', async () => {
+            await accountAuthCommand.handler(args);
+            expect(personalAccessKeyPromptSpy).toHaveBeenCalledWith({
+                env: ENVIRONMENTS.PROD,
+                account: undefined,
+            });
+        });
+        it('should use provided personal access key', async () => {
+            args.personalAccessKey = 'provided-key';
+            await accountAuthCommand.handler(args);
+            expect(personalAccessKeyPromptSpy).not.toHaveBeenCalled();
+            expect(getAccessTokenSpy).toHaveBeenCalledWith('provided-key', ENVIRONMENTS.PROD);
+        });
+        it('should use QA environment when qa flag is set', async () => {
+            args.qa = true;
+            await accountAuthCommand.handler(args);
+            expect(getAccessTokenSpy).toHaveBeenCalledWith('test-key', ENVIRONMENTS.QA);
+        });
+        it('should prompt for account name for new config', async () => {
+            globalConfigFileExistsSpy.mockReturnValue(false);
+            await accountAuthCommand.handler(args);
+            expect(cliAccountNamePromptSpy).toHaveBeenCalledWith('test-hub');
+        });
+        it('should not prompt for account name for existing config', async () => {
+            globalConfigFileExistsSpy.mockReturnValue(true);
+            await accountAuthCommand.handler(args);
+            expect(setAsDefaultAccountPromptSpy).toHaveBeenCalledWith('test-account');
+        });
+        it('should exit with error if config update fails', async () => {
+            getAccessTokenSpy.mockRejectedValue(new Error('Invalid key'));
+            await accountAuthCommand.handler(args);
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('Failed'));
+            expect(trackAuthActionSpy).toHaveBeenCalledWith('account-auth', 'personalaccesskey', 'error');
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should log success for new config', async () => {
+            globalConfigFileExistsSpy.mockReturnValue(false);
+            await accountAuthCommand.handler(args);
+            expect(uiLogger.success).toHaveBeenCalled();
+            expect(trackAuthActionSpy).toHaveBeenCalledWith('account-auth', 'personalaccesskey', 'complete', 456789);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+    });
+});

package/commands/account/__tests__/clean.test.d.ts

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

package/commands/account/__tests__/clean.test.js

@@ -0,0 +1,28 @@
+import yargs from 'yargs';
+import { addConfigOptions } from '../../../lib/commonOpts.js';
+import { addTestingOptions } from '../../../lib/commonOpts.js';
+import accountCleanCommand from '../clean.js';
+vi.mock('../../../lib/commonOpts');
+describe('commands/account/clean', () => {
+    const yargsMock = yargs;
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(accountCleanCommand.command).toEqual('clean');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(accountCleanCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            accountCleanCommand.builder(yargsMock);
+            expect(yargsMock.example).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledWith(yargsMock);
+            expect(addTestingOptions).toHaveBeenCalledTimes(1);
+            expect(addTestingOptions).toHaveBeenCalledWith(yargsMock);
+        });
+    });
+});

package/commands/account/__tests__/createOverride.test.d.ts

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

package/commands/account/__tests__/createOverride.test.js

@@ -0,0 +1,32 @@
+import yargs from 'yargs';
+import accountCreateOverrideCommand from '../createOverride.js';
+const positionalSpy = vi
+    .spyOn(yargs, 'positional')
+    .mockReturnValue(yargs);
+const exampleSpy = vi
+    .spyOn(yargs, 'example')
+    .mockReturnValue(yargs);
+describe('commands/account/createOverride', () => {
+    const yargsMock = yargs;
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(accountCreateOverrideCommand.command).toEqual('create-override [account]');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(accountCreateOverrideCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            accountCreateOverrideCommand.builder(yargsMock);
+            expect(exampleSpy).toHaveBeenCalledTimes(1);
+            expect(positionalSpy).toHaveBeenCalledTimes(1);
+            expect(positionalSpy).toHaveBeenCalledWith('account', {
+                describe: expect.any(String),
+                type: 'string',
+            });
+        });
+    });
+});

package/commands/account/__tests__/info.test.d.ts

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

package/commands/account/__tests__/info.test.js

@@ -0,0 +1,28 @@
+import yargs from 'yargs';
+import { addConfigOptions } from '../../../lib/commonOpts.js';
+import accountInfoCommand from '../info.js';
+vi.mock('../../../lib/commonOpts');
+const exampleSpy = vi
+    .spyOn(yargs, 'example')
+    .mockReturnValue(yargs);
+describe('commands/account/info', () => {
+    const yargsMock = yargs;
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(accountInfoCommand.command).toEqual('info [account]');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(accountInfoCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            accountInfoCommand.builder(yargsMock);
+            expect(exampleSpy).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledWith(yargsMock);
+        });
+    });
+});

package/commands/account/__tests__/list.test.d.ts

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