@hubspot/cli 8.1.0 → 8.1.2-experimental.0

package/lib/errorHandlers/__tests__/index.test.js

@@ -1,278 +0,0 @@
-import { logError, debugError, ApiErrorContext, isErrorWithMessageOrReason, getErrorMessage, } from '../index.js';
-import { uiLogger } from '../../ui/logger.js';
-import { isHubSpotHttpError, isValidationError, } from '@hubspot/local-dev-lib/errors/index';
-import { getConfig } from '@hubspot/local-dev-lib/config';
-import { shouldSuppressError } from '../suppressError.js';
-import { isProjectValidationError } from '../../errors/ProjectValidationError.js';
-import { lib } from '../../../lang/en.js';
-vi.mock('../../ui/logger.js');
-vi.mock('@hubspot/local-dev-lib/errors/index');
-vi.mock('@hubspot/local-dev-lib/config');
-vi.mock('../suppressError.js');
-vi.mock('../../errors/ProjectValidationError.js');
-describe('lib/errorHandlers/index', () => {
-    const uiLoggerErrorMock = uiLogger.error;
-    const uiLoggerDebugMock = uiLogger.debug;
-    const isHubSpotHttpErrorMock = isHubSpotHttpError;
-    const isValidationErrorMock = isValidationError;
-    const getConfigMock = getConfig;
-    const shouldSuppressErrorMock = shouldSuppressError;
-    const isProjectValidationErrorMock = isProjectValidationError;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        isHubSpotHttpErrorMock.mockReturnValue(false);
-        isValidationErrorMock.mockReturnValue(false);
-        shouldSuppressErrorMock.mockReturnValue(false);
-        isProjectValidationErrorMock.mockReturnValue(false);
-        getConfigMock.mockReturnValue({});
-    });
-    describe('logError', () => {
-        it('logs ProjectValidationError message and returns early', () => {
-            const error = {
-                message: 'Project validation failed',
-                name: 'ProjectValidationError',
-            };
-            isProjectValidationErrorMock.mockReturnValue(true);
-            logError(error);
-            expect(uiLoggerErrorMock).toHaveBeenCalledWith('Project validation failed');
-            expect(uiLoggerErrorMock).toHaveBeenCalledTimes(1);
-        });
-        it('returns early when error should be suppressed', () => {
-            const error = new Error('Suppressed error');
-            shouldSuppressErrorMock.mockReturnValue(true);
-            logError(error);
-            expect(shouldSuppressErrorMock).toHaveBeenCalled();
-            expect(uiLoggerErrorMock).not.toHaveBeenCalled();
-        });
-        it('logs validation errors for HubSpotHttpError with validation errors', () => {
-            const mockError = {
-                formattedValidationErrors: vi
-                    .fn()
-                    .mockReturnValue('Formatted validation errors'),
-                updateContext: vi.fn(),
-                context: {},
-            };
-            isHubSpotHttpErrorMock.mockReturnValue(true);
-            isValidationErrorMock.mockReturnValue(true);
-            logError(mockError);
-            expect(mockError.formattedValidationErrors).toHaveBeenCalled();
-            expect(uiLoggerErrorMock).toHaveBeenCalledWith('Formatted validation errors');
-        });
-        it('logs error message for errors with message property', () => {
-            const error = new Error('Something went wrong');
-            logError(error);
-            expect(uiLoggerErrorMock).toHaveBeenCalledWith('Something went wrong');
-        });
-        it('logs error with both message and reason', () => {
-            const error = { message: 'Error message', reason: 'Error reason' };
-            logError(error);
-            expect(uiLoggerErrorMock).toHaveBeenCalledWith('Error message Error reason');
-        });
-        it('logs unknown error message for errors without message or reason', () => {
-            const error = { foo: 'bar' };
-            logError(error);
-            expect(uiLoggerErrorMock).toHaveBeenCalledWith(lib.errorHandlers.index.unknownErrorOccurred);
-        });
-        it('calls updateContext on HubSpotHttpError', () => {
-            const mockError = {
-                updateContext: vi.fn(),
-                context: {},
-                message: 'test',
-            };
-            isHubSpotHttpErrorMock.mockReturnValue(true);
-            logError(mockError);
-            expect(mockError.updateContext).toHaveBeenCalled();
-        });
-        describe('timeout error handling', () => {
-            it('shows config timeout message for direct ETIMEDOUT error matching default timeout', () => {
-                const mockError = {
-                    code: 'ETIMEDOUT',
-                    timeout: 15000,
-                    updateContext: vi.fn(),
-                    context: {},
-                    message: 'Timeout',
-                };
-                isHubSpotHttpErrorMock.mockReturnValue(true);
-                getConfigMock.mockReturnValue({ httpTimeout: 15000 });
-                logError(mockError);
-                expect(uiLoggerErrorMock).toHaveBeenCalledTimes(2);
-                expect(uiLoggerErrorMock).toHaveBeenNthCalledWith(1, 'Timeout');
-                expect(uiLoggerErrorMock).toHaveBeenNthCalledWith(2, lib.errorHandlers.index.configTimeoutErrorOccurred(15000, 'hs config set'));
-            });
-            it('shows generic timeout message for direct ETIMEDOUT error with custom timeout', () => {
-                const mockError = {
-                    code: 'ETIMEDOUT',
-                    timeout: 30000,
-                    updateContext: vi.fn(),
-                    context: {},
-                    message: 'Timeout',
-                };
-                isHubSpotHttpErrorMock.mockReturnValue(true);
-                getConfigMock.mockReturnValue({ httpTimeout: 15000 });
-                logError(mockError);
-                expect(uiLoggerErrorMock).toHaveBeenCalledTimes(2);
-                expect(uiLoggerErrorMock).toHaveBeenNthCalledWith(2, lib.errorHandlers.index.genericTimeoutErrorOccurred);
-            });
-            it('detects timeout error wrapped in error.cause', () => {
-                const causeError = {
-                    code: 'ETIMEDOUT',
-                    timeout: 15000,
-                    name: 'HubSpotHttpError',
-                };
-                const wrapperError = new Error('Assets unavailable');
-                Object.defineProperty(wrapperError, 'cause', {
-                    value: causeError,
-                    writable: true,
-                });
-                isHubSpotHttpErrorMock.mockImplementation(err => {
-                    return err === causeError;
-                });
-                getConfigMock.mockReturnValue({ httpTimeout: 15000 });
-                logError(wrapperError);
-                expect(uiLoggerErrorMock).toHaveBeenCalledWith('Assets unavailable');
-                expect(uiLoggerErrorMock).toHaveBeenCalledWith(lib.errorHandlers.index.configTimeoutErrorOccurred(15000, 'hs config set'));
-            });
-            it('shows generic timeout message for wrapped timeout with different timeout value', () => {
-                const causeError = {
-                    code: 'ETIMEDOUT',
-                    timeout: 60000,
-                    name: 'HubSpotHttpError',
-                };
-                const wrapperError = new Error('Assets unavailable');
-                Object.defineProperty(wrapperError, 'cause', {
-                    value: causeError,
-                    writable: true,
-                });
-                isHubSpotHttpErrorMock.mockImplementation(err => {
-                    return err === causeError;
-                });
-                getConfigMock.mockReturnValue({ httpTimeout: 15000 });
-                logError(wrapperError);
-                expect(uiLoggerErrorMock).toHaveBeenCalledTimes(2);
-                expect(uiLoggerErrorMock).toHaveBeenNthCalledWith(2, lib.errorHandlers.index.genericTimeoutErrorOccurred);
-            });
-            it('does not show timeout message for non-timeout errors', () => {
-                const error = new Error('Regular error');
-                logError(error);
-                expect(uiLoggerErrorMock).toHaveBeenCalledTimes(1);
-                expect(uiLoggerErrorMock).toHaveBeenCalledWith('Regular error');
-            });
-        });
-    });
-    describe('debugError', () => {
-        it('logs HubSpotHttpError using toString', () => {
-            const mockError = {
-                toString: vi.fn().mockReturnValue('HubSpotHttpError details'),
-            };
-            isHubSpotHttpErrorMock.mockReturnValue(true);
-            debugError(mockError);
-            expect(uiLoggerDebugMock).toHaveBeenCalledWith('HubSpotHttpError details');
-        });
-        it('logs regular error using lib.errorHandlers.index.errorOccurred', () => {
-            const error = new Error('Regular error');
-            debugError(error);
-            expect(uiLoggerDebugMock).toHaveBeenCalledWith(lib.errorHandlers.index.errorOccurred('Error: Regular error'));
-        });
-        it('logs error.cause when it is a HubSpotHttpError', () => {
-            const causeError = {
-                toString: vi.fn().mockReturnValue('Cause error details'),
-            };
-            const error = new Error('Wrapper error');
-            Object.defineProperty(error, 'cause', {
-                value: causeError,
-                writable: true,
-            });
-            isHubSpotHttpErrorMock.mockImplementation(err => {
-                return err === causeError;
-            });
-            debugError(error);
-            expect(causeError.toString).toHaveBeenCalled();
-            expect(uiLoggerDebugMock).toHaveBeenCalledWith('Cause error details');
-        });
-        it('logs error.cause using lib.errorHandlers.index.errorCause when not a HubSpotHttpError', () => {
-            const causeError = { customField: 'value' };
-            const error = new Error('Wrapper error');
-            Object.defineProperty(error, 'cause', {
-                value: causeError,
-                writable: true,
-            });
-            debugError(error);
-            expect(uiLoggerDebugMock).toHaveBeenCalledWith(expect.stringMatching(/^Cause:/));
-        });
-        it('logs context using lib.errorHandlers.index.errorContext when provided', () => {
-            const error = new Error('Error');
-            const context = new ApiErrorContext({
-                accountId: 123,
-                request: '/api/test',
-            });
-            debugError(error, context);
-            expect(uiLoggerDebugMock).toHaveBeenCalledWith(expect.stringMatching(/^Context:/));
-        });
-    });
-    describe('ApiErrorContext', () => {
-        it('creates context with all properties', () => {
-            const context = new ApiErrorContext({
-                accountId: 123,
-                request: '/api/test',
-                payload: '{"data": "value"}',
-                projectName: 'my-project',
-            });
-            expect(context.accountId).toBe(123);
-            expect(context.request).toBe('/api/test');
-            expect(context.payload).toBe('{"data": "value"}');
-            expect(context.projectName).toBe('my-project');
-        });
-        it('creates context with default values', () => {
-            const context = new ApiErrorContext();
-            expect(context.accountId).toBeUndefined();
-            expect(context.request).toBe('');
-            expect(context.payload).toBe('');
-            expect(context.projectName).toBe('');
-        });
-        it('creates context with partial properties', () => {
-            const context = new ApiErrorContext({
-                accountId: 456,
-            });
-            expect(context.accountId).toBe(456);
-            expect(context.request).toBe('');
-            expect(context.payload).toBe('');
-            expect(context.projectName).toBe('');
-        });
-    });
-    describe('isErrorWithMessageOrReason', () => {
-        it('returns true for object with message property', () => {
-            expect(isErrorWithMessageOrReason({ message: 'test' })).toBe(true);
-        });
-        it('returns true for object with reason property', () => {
-            expect(isErrorWithMessageOrReason({ reason: 'test' })).toBe(true);
-        });
-        it('returns true for object with both message and reason', () => {
-            expect(isErrorWithMessageOrReason({ message: 'msg', reason: 'rsn' })).toBe(true);
-        });
-        it('returns true for Error instances', () => {
-            expect(isErrorWithMessageOrReason(new Error('test'))).toBe(true);
-        });
-        it('returns false for null', () => {
-            expect(isErrorWithMessageOrReason(null)).toBe(false);
-        });
-        it('returns false for undefined', () => {
-            expect(isErrorWithMessageOrReason(undefined)).toBe(false);
-        });
-        it('returns false for primitive values', () => {
-            expect(isErrorWithMessageOrReason('string')).toBe(false);
-            expect(isErrorWithMessageOrReason(123)).toBe(false);
-            expect(isErrorWithMessageOrReason(true)).toBe(false);
-        });
-        it('returns false for object without message or reason', () => {
-            expect(isErrorWithMessageOrReason({ foo: 'bar' })).toBe(false);
-        });
-        it('returns false for empty object', () => {
-            expect(isErrorWithMessageOrReason({})).toBe(false);
-        });
-    });
-    describe('getErrorMessage', () => {
-        it('returns message from Error instance', () => {
-            expect(getErrorMessage(new Error('Error message'))).toBe('Error message');
-        });
-    });
-});

package/lib/mcp/__tests__/setup.test.d.ts

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

package/lib/mcp/__tests__/setup.test.js

@@ -1,194 +0,0 @@
-import { execAsync } from '../../../mcp-server/utils/command.js';
-import { setupCodex, setupGemini, supportedTools } from '../setup.js';
-import SpinniesManager from '../../ui/SpinniesManager.js';
-import { logError } from '../../errorHandlers/index.js';
-import { commands } from '../../../lang/en.js';
-// Mock dependencies
-vi.mock('../../../mcp-server/utils/command.js');
-vi.mock('../../ui/SpinniesManager.js');
-vi.mock('../../errorHandlers/index.js');
-vi.mock('../../../lang/en.js', () => ({
-    commands: {
-        mcp: {
-            setup: {
-                codex: 'Codex CLI',
-                claudeCode: 'Claude Code',
-                cursor: 'Cursor',
-                gemini: 'Gemini CLI',
-                vsCode: 'VS Code',
-                windsurf: 'Windsurf',
-                success: vi.fn(targets => `Success message for ${targets.join(', ')}`),
-                spinners: {
-                    configuringCodex: 'Configuring Codex...',
-                    configuredCodex: 'Configured Codex',
-                    codexNotFound: 'Codex command not found - skipping configuration',
-                    codexInstallFailed: 'Failed to configure Codex',
-                    configuringGemini: 'Configuring Gemini CLI...',
-                    configuredGemini: 'Configured Gemini CLI',
-                    geminiNotFound: 'Gemini CLI not found - skipping configuration',
-                    geminiInstallFailed: 'Failed to configure Gemini CLI',
-                },
-            },
-        },
-    },
-}));
-const mockedExecAsync = vi.mocked(execAsync);
-const mockedSpinniesManager = vi.mocked(SpinniesManager);
-const mockedLogError = vi.mocked(logError);
-describe('lib/mcp/setup', () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-    });
-    describe('supportedTools', () => {
-        it('should include Codex in the supported tools list', () => {
-            const codexTool = supportedTools.find(tool => tool.value === 'codex');
-            expect(codexTool).toBeDefined();
-            expect(codexTool?.name).toBe(commands.mcp.setup.codex);
-            expect(codexTool?.value).toBe('codex');
-        });
-        it('should have Codex as the first tool in the list', () => {
-            expect(supportedTools[0].value).toBe('codex');
-        });
-        it('should contain all expected tools', () => {
-            const toolValues = supportedTools.map(tool => tool.value);
-            expect(toolValues).toContain('codex');
-            expect(toolValues).toContain('claude');
-            expect(toolValues).toContain('cursor');
-            expect(toolValues).toContain('gemini');
-            expect(toolValues).toContain('vscode');
-            expect(toolValues).toContain('windsurf');
-        });
-        it('should include Gemini in the supported tools list', () => {
-            const geminiTool = supportedTools.find(tool => tool.value === 'gemini');
-            expect(geminiTool).toBeDefined();
-            expect(geminiTool?.name).toBe(commands.mcp.setup.gemini);
-            expect(geminiTool?.value).toBe('gemini');
-        });
-    });
-    describe('setupCodex', () => {
-        const mockMcpCommand = {
-            command: 'test-command',
-            args: ['--arg1', '--arg2'],
-        };
-        it('should successfully configure Codex when command is available', async () => {
-            mockedExecAsync.mockResolvedValueOnce({
-                stdout: 'codex version 1.0.0',
-                stderr: '',
-            }); // version check
-            mockedExecAsync.mockResolvedValueOnce({ stdout: '', stderr: '' }); // mcp add command
-            const result = await setupCodex(mockMcpCommand);
-            expect(result).toBe(true);
-            expect(mockedSpinniesManager.add).toHaveBeenCalledWith('codexSpinner', {
-                text: commands.mcp.setup.spinners.configuringCodex,
-            });
-            expect(mockedExecAsync).toHaveBeenCalledWith('codex --version');
-            expect(mockedExecAsync).toHaveBeenCalledWith('codex mcp add "HubSpotDev" -- test-command --arg1 --arg2 --ai-agent codex');
-            expect(mockedSpinniesManager.succeed).toHaveBeenCalledWith('codexSpinner', {
-                text: commands.mcp.setup.spinners.configuredCodex,
-            });
-        });
-        it('should use default mcp command when none provided', async () => {
-            mockedExecAsync.mockResolvedValueOnce({
-                stdout: 'codex version 1.0.0',
-                stderr: '',
-            }); // version check
-            mockedExecAsync.mockResolvedValueOnce({ stdout: '', stderr: '' }); // mcp add command
-            const result = await setupCodex();
-            expect(result).toBe(true);
-            expect(mockedExecAsync).toHaveBeenCalledWith('codex mcp add "HubSpotDev" -- hs mcp start --ai-agent codex');
-        });
-        it('should handle codex command not found', async () => {
-            const error = new Error('Command not found: codex');
-            mockedExecAsync.mockRejectedValueOnce(error);
-            const result = await setupCodex(mockMcpCommand);
-            expect(result).toBe(false);
-            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('codexSpinner', {
-                text: commands.mcp.setup.spinners.codexNotFound,
-            });
-        });
-        it('should handle codex installation failure', async () => {
-            const error = new Error('Some other error');
-            mockedExecAsync.mockResolvedValueOnce({
-                stdout: 'codex version 1.0.0',
-                stderr: '',
-            }); // version check passes
-            mockedExecAsync.mockRejectedValueOnce(error); // mcp add fails
-            const result = await setupCodex(mockMcpCommand);
-            expect(result).toBe(false);
-            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('codexSpinner', {
-                text: commands.mcp.setup.spinners.codexInstallFailed,
-            });
-            expect(mockedLogError).toHaveBeenCalledWith(error);
-        });
-        it('should handle unexpected errors during spinner setup', async () => {
-            const error = new Error('Unexpected error');
-            mockedSpinniesManager.add.mockImplementationOnce(() => {
-                throw error;
-            });
-            const result = await setupCodex(mockMcpCommand);
-            expect(result).toBe(false);
-            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('codexSpinner', {
-                text: commands.mcp.setup.spinners.codexInstallFailed,
-            });
-            expect(mockedLogError).toHaveBeenCalledWith(error);
-        });
-    });
-    describe('setupGemini', () => {
-        const mockMcpCommand = {
-            command: 'test-command',
-            args: ['--arg1', '--arg2'],
-        };
-        it('should successfully configure Gemini CLI when command is available', async () => {
-            mockedExecAsync.mockResolvedValueOnce({
-                stdout: 'gemini version 1.0.0',
-                stderr: '',
-            });
-            mockedExecAsync.mockResolvedValueOnce({ stdout: '', stderr: '' });
-            const result = await setupGemini(mockMcpCommand);
-            expect(result).toBe(true);
-            expect(mockedSpinniesManager.add).toHaveBeenCalledWith('geminiSpinner', {
-                text: commands.mcp.setup.spinners.configuringGemini,
-            });
-            expect(mockedExecAsync).toHaveBeenCalledWith('gemini --version');
-            expect(mockedExecAsync).toHaveBeenCalledWith('gemini mcp add -s user "HubSpotDev" test-command --arg1 --arg2 --ai-agent gemini');
-            expect(mockedSpinniesManager.succeed).toHaveBeenCalledWith('geminiSpinner', {
-                text: commands.mcp.setup.spinners.configuredGemini,
-            });
-        });
-        it('should use default mcp command when none provided', async () => {
-            mockedExecAsync.mockResolvedValueOnce({
-                stdout: 'gemini version 1.0.0',
-                stderr: '',
-            });
-            mockedExecAsync.mockResolvedValueOnce({ stdout: '', stderr: '' });
-            const result = await setupGemini();
-            expect(result).toBe(true);
-            expect(mockedExecAsync).toHaveBeenCalledWith('gemini mcp add -s user "HubSpotDev" hs mcp start --ai-agent gemini');
-        });
-        it('should handle gemini command not found', async () => {
-            const error = new Error('Command not found: gemini');
-            mockedExecAsync.mockRejectedValueOnce(error);
-            const result = await setupGemini(mockMcpCommand);
-            expect(result).toBe(false);
-            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('geminiSpinner', {
-                text: commands.mcp.setup.spinners.geminiNotFound,
-            });
-        });
-        it('should handle gemini installation failure', async () => {
-            const error = new Error('Some other error');
-            mockedExecAsync.mockResolvedValueOnce({
-                stdout: 'gemini version 1.0.0',
-                stderr: '',
-            });
-            mockedExecAsync.mockRejectedValueOnce(error);
-            const result = await setupGemini(mockMcpCommand);
-            expect(result).toBe(false);
-            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('geminiSpinner', {
-                text: commands.mcp.setup.spinners.geminiInstallFailed,
-            });
-            expect(mockedLogError).toHaveBeenCalledWith(error);
-        });
-    });
-    // Note: addMcpServerToConfig integration tests would require mocking many dependencies
-    // and complex setup. The setupCodex function tests above cover the new functionality.
-});

package/lib/middleware/__tests__/commandTargetingUtils.test.d.ts

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

package/lib/middleware/__tests__/commandTargetingUtils.test.js

@@ -1,99 +0,0 @@
-import * as cliConfig from '@hubspot/local-dev-lib/config';
-import { isTargetedCommand, shouldLoadConfigForCommand, shouldRunAccountValidationForCommand, shouldRunConfigValidationForCommand, } from '../commandTargetingUtils.js';
-vi.mock('@hubspot/local-dev-lib/config');
-const globalConfigFileExistsSpy = vi.spyOn(cliConfig, 'globalConfigFileExists');
-const targetCommandMap = {
-    init: true,
-    account: {
-        use: true,
-    },
-    project: {
-        deploy: true,
-    },
-};
-describe('lib/middleware/commandTargetingUtils', () => {
-    describe('isTargetedCommand()', () => {
-        it('should return true for a direct target command', () => {
-            const result = isTargetedCommand(['init'], targetCommandMap);
-            expect(result).toBe(true);
-        });
-        it('should return false for a command with a subcommand', () => {
-            const result = isTargetedCommand(['account'], targetCommandMap);
-            expect(result).toBe(false);
-        });
-        it('should return true for a nested target command', () => {
-            const result = isTargetedCommand(['project', 'deploy'], targetCommandMap);
-            expect(result).toBe(true);
-        });
-        it('should return false for a non-existent command', () => {
-            const result = isTargetedCommand(['nonexistent'], targetCommandMap);
-            expect(result).toBe(false);
-        });
-        it('should return false for a non-targeted command', () => {
-            const result = isTargetedCommand(['auth'], targetCommandMap);
-            expect(result).toBe(false);
-        });
-        it('should return false for a command with a targeted subcommand', () => {
-            const result = isTargetedCommand(['project'], targetCommandMap);
-            expect(result).toBe(false);
-        });
-        it('should return false for a non-existent subcommand', () => {
-            const result = isTargetedCommand(['auth', 'nonexistent'], targetCommandMap);
-            expect(result).toBe(false);
-        });
-        it('should return false for an empty command array', () => {
-            const result = isTargetedCommand([], targetCommandMap);
-            expect(result).toBe(false);
-        });
-    });
-    describe('shouldLoadConfigForCommand()', () => {
-        it('should return true for a command that requires a config file', () => {
-            const result = shouldLoadConfigForCommand(['account', 'use']);
-            expect(result).toBe(true);
-        });
-        it('should return false for a command that does not require a config file', () => {
-            const result = shouldLoadConfigForCommand(['init']);
-            expect(result).toBe(false);
-        });
-        it('should return false when the user is trying to migrate the global config', () => {
-            globalConfigFileExistsSpy.mockReturnValue(false);
-            const result = shouldLoadConfigForCommand(['config', 'migrate']);
-            expect(result).toBe(false);
-        });
-        it('should return true when the global config file does exist', () => {
-            globalConfigFileExistsSpy.mockReturnValue(true);
-            const result = shouldLoadConfigForCommand(['account', 'use']);
-            expect(result).toBe(true);
-        });
-    });
-    describe('shouldRunAccountValidationForCommand()', () => {
-        it('should return true for a command that requires a config file', () => {
-            const result = shouldRunAccountValidationForCommand([
-                'project',
-                'upload',
-            ]);
-            expect(result).toBe(true);
-        });
-        it('should return false for a command that does not require account validation', () => {
-            const result1 = shouldRunAccountValidationForCommand(['init']);
-            const result2 = shouldRunAccountValidationForCommand(['auth']);
-            const result3 = shouldRunAccountValidationForCommand([
-                'accounts',
-                'list',
-            ]);
-            expect(result1).toBe(false);
-            expect(result2).toBe(false);
-            expect(result3).toBe(false);
-        });
-    });
-    describe('shouldRunConfigValidationForCommand()', () => {
-        it('should return true for a command that requires a config file', () => {
-            const result = shouldRunConfigValidationForCommand(['account', 'use']);
-            expect(result).toBe(true);
-        });
-        it('should return false for a command that does not require config validation', () => {
-            const result = shouldRunConfigValidationForCommand(['init']);
-            expect(result).toBe(false);
-        });
-    });
-});

package/lib/middleware/__tests__/configMiddleware.test.d.ts

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