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

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

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

@@ -0,0 +1,153 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import yargs from 'yargs';
+import * as configLib from '@hubspot/local-dev-lib/config';
+import * as defaultAccountOverrideLib from '@hubspot/local-dev-lib/config/defaultAccountOverride';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import * as commonOpts from '../../../lib/commonOpts.js';
+import * as usageTrackingLib from '../../../lib/usageTracking.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import accountListCommand from '../list.js';
+vi.mock('../../../lib/commonOpts');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/config/defaultAccountOverride');
+vi.mock('../../../lib/ui/index.js');
+vi.mock('../../../lib/ui/table.js');
+const getConfigFilePathSpy = vi.spyOn(configLib, 'getConfigFilePath');
+const getAllConfigAccountsSpy = vi.spyOn(configLib, 'getAllConfigAccounts');
+const getConfigDefaultAccountIfExistsSpy = vi.spyOn(configLib, 'getConfigDefaultAccountIfExists');
+const getDefaultAccountOverrideFilePathSpy = vi.spyOn(defaultAccountOverrideLib, 'getDefaultAccountOverrideFilePath');
+const trackCommandUsageSpy = vi.spyOn(usageTrackingLib, 'trackCommandUsage');
+const exampleSpy = vi
+    .spyOn(yargs, 'example')
+    .mockReturnValue(yargs);
+describe('commands/account/list', () => {
+    const yargsMock = yargs;
+    beforeEach(() => {
+        getConfigFilePathSpy.mockReturnValue('/test/.hscli.config.yaml');
+        getAllConfigAccountsSpy.mockReturnValue([]);
+        getConfigDefaultAccountIfExistsSpy.mockReturnValue(undefined);
+        getDefaultAccountOverrideFilePathSpy.mockReturnValue(null);
+        trackCommandUsageSpy.mockImplementation(async () => { });
+    });
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(accountListCommand.command).toEqual(['list', 'ls']);
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(accountListCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            accountListCommand.builder(yargsMock);
+            expect(exampleSpy).toHaveBeenCalledTimes(1);
+            expect(commonOpts.addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(commonOpts.addConfigOptions).toHaveBeenCalledWith(yargsMock);
+        });
+    });
+    describe('handler', () => {
+        let args;
+        beforeEach(() => {
+            args = {
+                derivedAccountId: 123456,
+                d: false,
+                debug: false,
+                _: [],
+                $0: '',
+            };
+        });
+        it('should track command usage', async () => {
+            await accountListCommand.handler(args);
+            expect(trackCommandUsageSpy).toHaveBeenCalledWith('accounts-list', undefined, 123456);
+        });
+        it('should display accounts list when no default account', async () => {
+            const accounts = [
+                {
+                    accountId: 111111,
+                    name: 'Test Account 1',
+                    authType: 'personalaccesskey',
+                    accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
+                },
+                {
+                    accountId: 222222,
+                    name: 'Test Account 2',
+                    authType: 'oauth2',
+                    accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
+                },
+            ];
+            getAllConfigAccountsSpy.mockReturnValue(accounts);
+            await accountListCommand.handler(args);
+            expect(getAllConfigAccountsSpy).toHaveBeenCalled();
+            expect(uiLogger.log).toHaveBeenCalledWith(expect.stringContaining('Accounts'));
+        });
+        it('should display default account when present', async () => {
+            getConfigDefaultAccountIfExistsSpy.mockReturnValue({
+                accountId: 123456,
+                name: 'Default Account',
+            });
+            await accountListCommand.handler(args);
+            expect(getConfigDefaultAccountIfExistsSpy).toHaveBeenCalled();
+            expect(uiLogger.log).toHaveBeenCalled();
+        });
+        it('should display config file path when default account present', async () => {
+            getConfigDefaultAccountIfExistsSpy.mockReturnValue({
+                accountId: 123456,
+            });
+            await accountListCommand.handler(args);
+            expect(getConfigFilePathSpy).toHaveBeenCalled();
+            expect(uiLogger.log).toHaveBeenCalled();
+        });
+        it('should display override file path when present', async () => {
+            getConfigDefaultAccountIfExistsSpy.mockReturnValue({
+                accountId: 123456,
+            });
+            getDefaultAccountOverrideFilePathSpy.mockReturnValue('/test/override.yaml');
+            await accountListCommand.handler(args);
+            expect(getDefaultAccountOverrideFilePathSpy).toHaveBeenCalled();
+            expect(uiLogger.log).toHaveBeenCalled();
+        });
+        it('should group sandbox accounts under parent', async () => {
+            const accounts = [
+                {
+                    accountId: 111111,
+                    name: 'Parent Account',
+                    authType: 'personalaccesskey',
+                    accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
+                },
+                {
+                    accountId: 222222,
+                    name: 'Sandbox Account',
+                    authType: 'personalaccesskey',
+                    accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+                    parentAccountId: 111111,
+                },
+            ];
+            getAllConfigAccountsSpy.mockReturnValue(accounts);
+            await accountListCommand.handler(args);
+            expect(getAllConfigAccountsSpy).toHaveBeenCalled();
+            expect(uiLogger.log).toHaveBeenCalled();
+        });
+        it('should display app developer accounts', async () => {
+            const accounts = [
+                {
+                    accountId: 333333,
+                    name: 'App Developer Account',
+                    authType: 'personalaccesskey',
+                    accountType: HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER,
+                },
+            ];
+            getAllConfigAccountsSpy.mockReturnValue(accounts);
+            await accountListCommand.handler(args);
+            expect(getAllConfigAccountsSpy).toHaveBeenCalled();
+            expect(uiLogger.log).toHaveBeenCalled();
+        });
+        it('should handle empty accounts list', async () => {
+            getAllConfigAccountsSpy.mockReturnValue([]);
+            await accountListCommand.handler(args);
+            expect(getAllConfigAccountsSpy).toHaveBeenCalled();
+            expect(uiLogger.log).toHaveBeenCalled();
+        });
+    });
+});

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

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

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

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

package/commands/account/__tests__/removeOverride.d.ts

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

package/commands/account/__tests__/removeOverride.js

@@ -0,0 +1,25 @@
+import yargs from 'yargs';
+import accountRemoveOverrideCommand from '../removeOverride.js';
+vi.mock('yargs');
+const optionsSpy = vi
+    .spyOn(yargs, 'options')
+    .mockReturnValue(yargs);
+describe('commands/account/removeOverride', () => {
+    const yargsMock = yargs;
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(accountRemoveOverrideCommand.command).toEqual('remove-override');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(accountRemoveOverrideCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            accountRemoveOverrideCommand.builder(yargsMock);
+            expect(optionsSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,82 @@
+import yargs from 'yargs';
+import { addConfigOptions, addAccountOptions, } from '../../../lib/commonOpts.js';
+import accountRenameCommand from '../rename.js';
+import * as config from '@hubspot/local-dev-lib/config';
+import { logError } from '../../../lib/errorHandlers/index.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import * as usageTracking from '../../../lib/usageTracking.js';
+vi.mock('../../../lib/commonOpts');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../../lib/errorHandlers/index.js');
+const positionalSpy = vi
+    .spyOn(yargs, 'positional')
+    .mockReturnValue(yargs);
+const exampleSpy = vi
+    .spyOn(yargs, 'example')
+    .mockReturnValue(yargs);
+const renameAccountSpy = vi.spyOn(config, 'renameConfigAccount');
+const processExitSpy = vi.spyOn(process, 'exit');
+const trackCommandUsageSpy = vi.spyOn(usageTracking, 'trackCommandUsage');
+describe('commands/account/rename', () => {
+    const yargsMock = yargs;
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(accountRenameCommand.command).toEqual('rename <account-name> <new-name>');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(accountRenameCommand.describe).toBeDefined();
+        });
+    });
+    describe('handler', () => {
+        let args;
+        beforeEach(() => {
+            renameAccountSpy.mockReturnValue(undefined);
+            processExitSpy.mockImplementation(() => {
+                throw new Error('process.exit called');
+            });
+            args = {
+                accountName: 'myExistingAccountName',
+                newName: 'myNewAccountName',
+            };
+        });
+        it('should rename the account', async () => {
+            await expect(accountRenameCommand.handler(args)).rejects.toThrow('process.exit called');
+            expect(trackCommandUsageSpy).toHaveBeenCalledWith('accounts-rename', undefined, undefined);
+            expect(renameAccountSpy).toHaveBeenCalledWith('myExistingAccountName', 'my-new-account-name');
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+        it('should handle errors when renameAccount throws', async () => {
+            const error = new Error('Failed to rename account');
+            renameAccountSpy.mockImplementation(() => {
+                throw error;
+            });
+            await expect(accountRenameCommand.handler(args)).rejects.toThrow('process.exit called');
+            expect(trackCommandUsageSpy).toHaveBeenCalledWith('accounts-rename', undefined, undefined);
+            expect(renameAccountSpy).toHaveBeenCalledWith('myExistingAccountName', 'my-new-account-name');
+            expect(logError).toHaveBeenCalledTimes(1);
+            expect(logError).toHaveBeenCalledWith(error);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            accountRenameCommand.builder(yargsMock);
+            expect(exampleSpy).toHaveBeenCalledTimes(1);
+            expect(positionalSpy).toHaveBeenCalledTimes(2);
+            expect(positionalSpy).toHaveBeenCalledWith('account-name', {
+                describe: expect.any(String),
+                type: 'string',
+            });
+            expect(positionalSpy).toHaveBeenCalledWith('new-name', {
+                describe: expect.any(String),
+                type: 'string',
+            });
+            expect(addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledWith(yargsMock);
+            expect(addAccountOptions).toHaveBeenCalledTimes(1);
+            expect(addAccountOptions).toHaveBeenCalledWith(yargsMock);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,170 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import yargs from 'yargs';
+import * as configLib from '@hubspot/local-dev-lib/config';
+import * as defaultAccountOverrideLib from '@hubspot/local-dev-lib/config/defaultAccountOverride';
+import * as usageTrackingLib from '../../../lib/usageTracking.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/config/defaultAccountOverride');
+vi.mock('../../../lib/prompts/accountsPrompt.js');
+// Import after mocks
+import * as accountsPromptLib from '../../../lib/prompts/accountsPrompt.js';
+import accountUseCommand from '../use.js';
+const getConfigFilePathSpy = vi.spyOn(configLib, 'getConfigFilePath');
+const getConfigAccountIfExistsSpy = vi.spyOn(configLib, 'getConfigAccountIfExists');
+const getConfigAccountByNameSpy = vi.spyOn(configLib, 'getConfigAccountByName');
+const getConfigAccountByIdSpy = vi.spyOn(configLib, 'getConfigAccountById');
+const getAllConfigAccountsSpy = vi.spyOn(configLib, 'getAllConfigAccounts');
+const setConfigAccountAsDefaultSpy = vi.spyOn(configLib, 'setConfigAccountAsDefault');
+const getDefaultAccountOverrideAccountIdSpy = vi.spyOn(defaultAccountOverrideLib, 'getDefaultAccountOverrideAccountId');
+const getDefaultAccountOverrideFilePathSpy = vi.spyOn(defaultAccountOverrideLib, 'getDefaultAccountOverrideFilePath');
+const selectAccountFromConfigSpy = vi.spyOn(accountsPromptLib, 'selectAccountFromConfig');
+const trackCommandUsageSpy = vi.spyOn(usageTrackingLib, 'trackCommandUsage');
+const positionalSpy = vi
+    .spyOn(yargs, 'positional')
+    .mockReturnValue(yargs);
+const exampleSpy = vi
+    .spyOn(yargs, 'example')
+    .mockReturnValue(yargs);
+describe('commands/account/use', () => {
+    const yargsMock = yargs;
+    beforeEach(() => {
+        getConfigFilePathSpy.mockReturnValue('/test/.hscli.config.yaml');
+        getAllConfigAccountsSpy.mockReturnValue([]);
+        getDefaultAccountOverrideAccountIdSpy.mockReturnValue(null);
+        getDefaultAccountOverrideFilePathSpy.mockReturnValue(null);
+        trackCommandUsageSpy.mockImplementation(async () => { });
+        setConfigAccountAsDefaultSpy.mockImplementation(() => { });
+    });
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(accountUseCommand.command).toEqual('use [account]');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(accountUseCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            accountUseCommand.builder(yargsMock);
+            expect(exampleSpy).toHaveBeenCalledTimes(1);
+            expect(positionalSpy).toHaveBeenCalledTimes(1);
+            expect(positionalSpy).toHaveBeenCalledWith('account', {
+                describe: expect.any(String),
+                type: 'string',
+            });
+        });
+    });
+    describe('handler', () => {
+        let args;
+        beforeEach(() => {
+            args = {
+                derivedAccountId: 0,
+                d: false,
+                debug: false,
+                _: [],
+                $0: '',
+            };
+        });
+        describe('with account ID', () => {
+            it('should set account by ID', async () => {
+                args.account = '123456';
+                const account = {
+                    accountId: 123456,
+                    name: 'Test Account',
+                };
+                getConfigAccountIfExistsSpy.mockReturnValue(account);
+                getConfigAccountByIdSpy.mockReturnValue(account);
+                await accountUseCommand.handler(args);
+                expect(getConfigAccountByIdSpy).toHaveBeenCalledWith(123456);
+                expect(setConfigAccountAsDefaultSpy).toHaveBeenCalledWith('123456');
+                expect(uiLogger.success).toHaveBeenCalled();
+            });
+            it('should track command usage', async () => {
+                args.account = '123456';
+                const account = {
+                    accountId: 123456,
+                    name: 'Test Account',
+                };
+                getConfigAccountIfExistsSpy.mockReturnValue(account);
+                getConfigAccountByIdSpy.mockReturnValue(account);
+                await accountUseCommand.handler(args);
+                expect(trackCommandUsageSpy).toHaveBeenCalledWith('accounts-use', undefined, 123456);
+            });
+        });
+        describe('with account name', () => {
+            it('should set account by name', async () => {
+                args.account = 'MyAccount';
+                const account = {
+                    accountId: 123456,
+                    name: 'MyAccount',
+                };
+                getConfigAccountIfExistsSpy.mockReturnValue(account);
+                getConfigAccountByNameSpy.mockReturnValue(account);
+                await accountUseCommand.handler(args);
+                expect(getConfigAccountByNameSpy).toHaveBeenCalledWith('MyAccount');
+                expect(setConfigAccountAsDefaultSpy).toHaveBeenCalledWith('MyAccount');
+                expect(uiLogger.success).toHaveBeenCalled();
+            });
+        });
+        describe('account not found', () => {
+            it('should prompt when account not found', async () => {
+                args.account = 'InvalidAccount';
+                const account = {
+                    accountId: 999999,
+                    name: 'Selected Account',
+                };
+                getConfigAccountIfExistsSpy.mockReturnValue(undefined);
+                selectAccountFromConfigSpy.mockResolvedValue(999999);
+                getConfigAccountByIdSpy.mockReturnValue(account);
+                await accountUseCommand.handler(args);
+                expect(uiLogger.error).toHaveBeenCalled();
+                expect(selectAccountFromConfigSpy).toHaveBeenCalled();
+                expect(setConfigAccountAsDefaultSpy).toHaveBeenCalledWith('999999');
+            });
+        });
+        describe('without account argument', () => {
+            it('should prompt for account selection', async () => {
+                const account = {
+                    accountId: 888888,
+                    name: 'Prompted Account',
+                };
+                selectAccountFromConfigSpy.mockResolvedValue(888888);
+                getConfigAccountByIdSpy.mockReturnValue(account);
+                await accountUseCommand.handler(args);
+                expect(selectAccountFromConfigSpy).toHaveBeenCalled();
+                expect(setConfigAccountAsDefaultSpy).toHaveBeenCalledWith('888888');
+            });
+        });
+        describe('account override', () => {
+            it('should warn when account override is present', async () => {
+                args.account = '123456';
+                const account = {
+                    accountId: 123456,
+                    name: 'Test Account',
+                };
+                getConfigAccountIfExistsSpy.mockReturnValue(account);
+                getConfigAccountByIdSpy.mockReturnValue(account);
+                getDefaultAccountOverrideAccountIdSpy.mockReturnValue(777777);
+                getDefaultAccountOverrideFilePathSpy.mockReturnValue('/test/override.yaml');
+                getAllConfigAccountsSpy.mockReturnValue([account]);
+                await accountUseCommand.handler(args);
+                expect(getDefaultAccountOverrideAccountIdSpy).toHaveBeenCalled();
+                expect(uiLogger.warn).toHaveBeenCalled();
+            });
+            it('should not warn when no account override', async () => {
+                args.account = '123456';
+                const account = {
+                    accountId: 123456,
+                    name: 'Test Account',
+                };
+                getConfigAccountIfExistsSpy.mockReturnValue(account);
+                getConfigAccountByIdSpy.mockReturnValue(account);
+                await accountUseCommand.handler(args);
+                expect(uiLogger.warn).not.toHaveBeenCalled();
+            });
+        });
+    });
+});

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

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

package/commands/app/__tests__/migrate.test.js

@@ -0,0 +1,111 @@
+import yargs from 'yargs';
+import { PLATFORM_VERSIONS } from '@hubspot/local-dev-lib/constants/projects';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
+import { migrateApp } from '../../../lib/app/migrate.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import migrateCommand from '../migrate.js';
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../../lib/app/migrate');
+vi.mock('../../../lib/projects/config.js');
+const mockYargs = yargs;
+const mockedGetConfigAccountById = getConfigAccountById;
+const mockedmigrateApp = migrateApp;
+const mockedUiLogger = uiLogger;
+const optionsSpy = vi.spyOn(mockYargs, 'options');
+const exampleSpy = vi.spyOn(mockYargs, 'example');
+const exitSpy = vi
+    .spyOn(process, 'exit')
+    .mockImplementation(() => undefined);
+describe('commands/app/migrate', () => {
+    const mockAccountId = 123;
+    const mockAccountConfig = {
+        accountId: mockAccountId,
+        name: 'Test Account',
+        env: 'prod',
+        authType: 'personalaccesskey',
+        personalAccessKey: 'test-key',
+    };
+    beforeEach(() => {
+        mockedGetConfigAccountById.mockReturnValue(mockAccountConfig);
+        exitSpy.mockClear();
+    });
+    afterEach(() => {
+        exitSpy.mockClear();
+    });
+    describe('handler', () => {
+        it('should exit with error when no account config is found', async () => {
+            mockedGetConfigAccountById.mockReturnValue(null);
+            await migrateCommand.handler({
+                derivedAccountId: mockAccountId,
+            });
+            expect(mockedUiLogger.error).toHaveBeenCalled();
+            expect(exitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should call migrateApp for platform version 2025.2', async () => {
+            const options = {
+                derivedAccountId: mockAccountId,
+                platformVersion: PLATFORM_VERSIONS.v2025_2,
+            };
+            await migrateCommand.handler(options);
+            expect(mockedmigrateApp).toHaveBeenCalledWith(mockAccountId, options);
+            expect(exitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+        it('should call migrateApp when unstable is true', async () => {
+            const options = {
+                derivedAccountId: mockAccountId,
+                unstable: true,
+            };
+            await migrateCommand.handler(options);
+            expect(mockedmigrateApp).toHaveBeenCalledWith(mockAccountId, options);
+            expect(exitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+        it('should handle errors during migration', async () => {
+            const mockError = new Error('Migration failed');
+            mockedmigrateApp.mockRejectedValue(mockError);
+            await migrateCommand.handler({
+                derivedAccountId: mockAccountId,
+                platformVersion: PLATFORM_VERSIONS.v2025_2,
+            });
+            expect(mockedUiLogger.error).toHaveBeenCalled();
+            expect(exitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+    });
+    describe('builder', () => {
+        it('should add required options', async () => {
+            await migrateCommand.builder(mockYargs);
+            expect(optionsSpy).toHaveBeenCalledWith(expect.objectContaining({
+                name: expect.objectContaining({
+                    type: 'string',
+                    describe: expect.any(String),
+                }),
+                dest: expect.objectContaining({
+                    type: 'string',
+                    describe: expect.any(String),
+                }),
+                'app-id': expect.objectContaining({
+                    type: 'number',
+                    describe: expect.any(String),
+                }),
+                'platform-version': expect.objectContaining({
+                    type: 'string',
+                    default: '2026.03',
+                }),
+            }));
+        });
+        it('should set default platform version to 2025.2', async () => {
+            await migrateCommand.builder(mockYargs);
+            expect(optionsSpy).toHaveBeenCalledWith(expect.objectContaining({
+                'platform-version': expect.objectContaining({
+                    default: '2026.03',
+                }),
+            }));
+        });
+        it('should add example command', async () => {
+            await migrateCommand.builder(mockYargs);
+            expect(exampleSpy).toHaveBeenCalledWith([
+                ['$0 app migrate', expect.any(String)],
+            ]);
+        });
+    });
+});

package/commands/app/secret/__tests__/add.test.d.ts

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