@hubspot/cli 7.7.21-experimental.0 → 7.7.21-experimental.1

package/lib/projects/__tests__/LocalDevProcess.test.js

@@ -1,26 +1,31 @@
-import path from 'path';
-import { translateForLocalDev } from '@hubspot/project-parsing-lib';
-import { handleProjectUpload } from '../upload.js';
-import { getProjectConfig } from '../config.js';
-import LocalDevProcess from '../localDev/LocalDevProcess.js';
-import LocalDevLogger from '../localDev/LocalDevLogger.js';
-import DevServerManagerV2 from '../localDev/DevServerManagerV2.js';
-import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
-import { vi } from 'vitest';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
+const upload_1 = require("../upload");
+const config_1 = require("../config");
+const LocalDevProcess_1 = __importDefault(require("../localDev/LocalDevProcess"));
+const LocalDevLogger_1 = __importDefault(require("../localDev/LocalDevLogger"));
+const DevServerManagerV2_1 = __importDefault(require("../localDev/DevServerManagerV2"));
+const environments_1 = require("@hubspot/local-dev-lib/constants/environments");
+const vitest_1 = require("vitest");
 // Mock @hubspot/ui-extensions-dev-server
-vi.mock('@hubspot/ui-extensions-dev-server', () => ({
+vitest_1.vi.mock('@hubspot/ui-extensions-dev-server', () => ({
     DevModeUnifiedInterface: {
-        setup: vi.fn().mockResolvedValue(undefined),
-        start: vi.fn().mockResolvedValue(undefined),
-        fileChange: vi.fn().mockResolvedValue(undefined),
-        cleanup: vi.fn().mockResolvedValue(undefined),
+        setup: vitest_1.vi.fn().mockResolvedValue(undefined),
+        start: vitest_1.vi.fn().mockResolvedValue(undefined),
+        fileChange: vitest_1.vi.fn().mockResolvedValue(undefined),
+        cleanup: vitest_1.vi.fn().mockResolvedValue(undefined),
     },
 }));
-vi.mock('@hubspot/project-parsing-lib');
-vi.mock('../upload');
-vi.mock('../config');
-vi.mock('../localDev/LocalDevLogger');
-vi.mock('../localDev/DevServerManagerV2');
+vitest_1.vi.mock('@hubspot/project-parsing-lib');
+vitest_1.vi.mock('../upload');
+vitest_1.vi.mock('../config');
+vitest_1.vi.mock('../localDev/LocalDevLogger');
+vitest_1.vi.mock('../localDev/DevServerManagerV2');
 // Tests for LocalDevProcess and LocalDevState
 describe('LocalDevProcess', () => {
     let mockLocalDevLogger;
@@ -74,51 +79,51 @@ describe('LocalDevProcess', () => {
         projectId: 789,
         isGithubLinked: false,
         initialProjectNodes: {},
-        env: ENVIRONMENTS.PROD,
+        env: environments_1.ENVIRONMENTS.PROD,
         deployedBuild: mockBuild,
         projectName: 'test-project',
     };
     beforeEach(() => {
-        vi.clearAllMocks();
+        vitest_1.vi.clearAllMocks();
         mockLocalDevLogger = {
-            resetSpinnies: vi.fn(),
-            devServerSetupError: vi.fn(),
-            devServerStartError: vi.fn(),
-            devServerCleanupError: vi.fn(),
-            missingComponentsWarning: vi.fn(),
-            noDeployedBuild: vi.fn(),
-            startupMessage: vi.fn(),
-            monitorConsoleOutput: vi.fn(),
-            cleanupStart: vi.fn(),
-            cleanupError: vi.fn(),
-            cleanupSuccess: vi.fn(),
-            uploadInitiated: vi.fn(),
-            projectConfigMismatch: vi.fn(),
-            uploadError: vi.fn(),
-            uploadSuccess: vi.fn(),
-            clearUploadWarnings: vi.fn(),
-            fileChangeError: vi.fn(),
-            uploadWarning: vi.fn(),
+            resetSpinnies: vitest_1.vi.fn(),
+            devServerSetupError: vitest_1.vi.fn(),
+            devServerStartError: vitest_1.vi.fn(),
+            devServerCleanupError: vitest_1.vi.fn(),
+            missingComponentsWarning: vitest_1.vi.fn(),
+            noDeployedBuild: vitest_1.vi.fn(),
+            startupMessage: vitest_1.vi.fn(),
+            monitorConsoleOutput: vitest_1.vi.fn(),
+            cleanupStart: vitest_1.vi.fn(),
+            cleanupError: vitest_1.vi.fn(),
+            cleanupSuccess: vitest_1.vi.fn(),
+            uploadInitiated: vitest_1.vi.fn(),
+            projectConfigMismatch: vitest_1.vi.fn(),
+            uploadError: vitest_1.vi.fn(),
+            uploadSuccess: vitest_1.vi.fn(),
+            clearUploadWarnings: vitest_1.vi.fn(),
+            fileChangeError: vitest_1.vi.fn(),
+            uploadWarning: vitest_1.vi.fn(),
         };
         mockDevServerManager = {
-            setup: vi.fn().mockResolvedValue(undefined),
-            start: vi.fn().mockResolvedValue(undefined),
-            cleanup: vi.fn().mockResolvedValue(undefined),
-            fileChange: vi.fn().mockResolvedValue(undefined),
+            setup: vitest_1.vi.fn().mockResolvedValue(undefined),
+            start: vitest_1.vi.fn().mockResolvedValue(undefined),
+            cleanup: vitest_1.vi.fn().mockResolvedValue(undefined),
+            fileChange: vitest_1.vi.fn().mockResolvedValue(undefined),
         };
         // Mock constructors
-        LocalDevLogger.mockImplementation(() => mockLocalDevLogger);
-        DevServerManagerV2.mockImplementation(() => mockDevServerManager);
+        LocalDevLogger_1.default.mockImplementation(() => mockLocalDevLogger);
+        DevServerManagerV2_1.default.mockImplementation(() => mockDevServerManager);
         // Create process instance
-        process = new LocalDevProcess(mockOptions);
+        process = new LocalDevProcess_1.default(mockOptions);
         // Mock process.exit
-        vi.spyOn(global.process, 'exit').mockImplementation((code) => {
+        vitest_1.vi.spyOn(global.process, 'exit').mockImplementation((code) => {
             throw new Error(`Process.exit called with code ${code}`);
         });
     });
     describe('start()', () => {
         it('should exit if no deployed build exists', async () => {
-            const processWithoutBuild = new LocalDevProcess({
+            const processWithoutBuild = new LocalDevProcess_1.default({
                 ...mockOptions,
                 deployedBuild: undefined,
             });
@@ -151,7 +156,7 @@ describe('LocalDevProcess', () => {
                 config: {},
                 files: [],
             };
-            const processWithNode = new LocalDevProcess({
+            const processWithNode = new LocalDevProcess_1.default({
                 ...mockOptions,
                 initialProjectNodes: {
                     component3: mockNode,
@@ -182,13 +187,13 @@ describe('LocalDevProcess', () => {
     describe('updateProjectNodes()', () => {
         it('should update project nodes with translated representation', async () => {
             const mockNodes = { node1: { uid: 'node1' } };
-            translateForLocalDev.mockResolvedValue({
+            project_parsing_lib_1.translateForLocalDev.mockResolvedValue({
                 intermediateNodesIndexedByUid: mockNodes,
             });
             // @ts-expect-error testing private method
             await process.updateProjectNodes();
-            expect(translateForLocalDev).toHaveBeenCalledWith({
-                projectSourceDir: path.join(mockOptions.projectDir, mockOptions.projectConfig.srcDir),
+            expect(project_parsing_lib_1.translateForLocalDev).toHaveBeenCalledWith({
+                projectSourceDir: path_1.default.join(mockOptions.projectDir, mockOptions.projectConfig.srcDir),
                 platformVersion: mockOptions.projectConfig.platformVersion,
                 accountId: mockOptions.targetProjectAccountId,
             }, { projectNodesAtLastUpload: {} });
@@ -197,18 +202,18 @@ describe('LocalDevProcess', () => {
     });
     describe('uploadProject()', () => {
         it('should not upload if project config is invalid', async () => {
-            getProjectConfig.mockResolvedValue({
+            config_1.getProjectConfig.mockResolvedValue({
                 projectConfig: null,
             });
             await process.uploadProject();
             expect(mockLocalDevLogger.projectConfigMismatch).toHaveBeenCalled();
-            expect(handleProjectUpload).not.toHaveBeenCalled();
+            expect(upload_1.handleProjectUpload).not.toHaveBeenCalled();
         });
         it('should handle upload error', async () => {
-            getProjectConfig.mockResolvedValue({
+            config_1.getProjectConfig.mockResolvedValue({
                 projectConfig: mockOptions.projectConfig,
             });
-            handleProjectUpload.mockResolvedValue({
+            upload_1.handleProjectUpload.mockResolvedValue({
                 uploadError: new Error('Upload failed'),
             });
             const success = await process.uploadProject();
@@ -217,10 +222,10 @@ describe('LocalDevProcess', () => {
         });
         it('should handle successful upload', async () => {
             await process.handleConfigFileChange();
-            getProjectConfig.mockResolvedValue({
+            config_1.getProjectConfig.mockResolvedValue({
                 projectConfig: mockOptions.projectConfig,
             });
-            handleProjectUpload.mockResolvedValue({
+            upload_1.handleProjectUpload.mockResolvedValue({
                 uploadError: null,
             });
             const success = await process.uploadProject();
@@ -233,19 +238,19 @@ describe('LocalDevProcess', () => {
             const initialProjectNodes = { existingNode: { uid: 'existingNode' } };
             // @ts-expect-error accessing private property for testing
             process.state._projectNodesAtLastUpload = initialProjectNodes;
-            getProjectConfig.mockResolvedValue({
+            config_1.getProjectConfig.mockResolvedValue({
                 projectConfig: mockOptions.projectConfig,
             });
-            handleProjectUpload.mockResolvedValue({
+            upload_1.handleProjectUpload.mockResolvedValue({
                 uploadError: null,
             });
-            translateForLocalDev.mockResolvedValue({
+            project_parsing_lib_1.translateForLocalDev.mockResolvedValue({
                 intermediateNodesIndexedByUid: mockNodes,
             });
             const success = await process.uploadProject();
             // Verify translateForLocalDev was called without projectNodesAtLastUpload option
-            expect(translateForLocalDev).toHaveBeenCalledWith({
-                projectSourceDir: path.join(mockOptions.projectDir, mockOptions.projectConfig.srcDir),
+            expect(project_parsing_lib_1.translateForLocalDev).toHaveBeenCalledWith({
+                projectSourceDir: path_1.default.join(mockOptions.projectDir, mockOptions.projectConfig.srcDir),
                 platformVersion: mockOptions.projectConfig.platformVersion,
                 accountId: mockOptions.targetProjectAccountId,
             }, { projectNodesAtLastUpload: undefined });
@@ -276,14 +281,14 @@ describe('LocalDevProcess', () => {
     });
     describe('handleConfigFileChange()', () => {
         beforeEach(() => {
-            translateForLocalDev.mockResolvedValue({
+            project_parsing_lib_1.translateForLocalDev.mockResolvedValue({
                 intermediateNodesIndexedByUid: {},
             });
         });
         it('should update project nodes and show upload warning', async () => {
             await process.handleConfigFileChange();
-            expect(translateForLocalDev).toHaveBeenCalledWith({
-                projectSourceDir: path.join(mockOptions.projectDir, mockOptions.projectConfig.srcDir),
+            expect(project_parsing_lib_1.translateForLocalDev).toHaveBeenCalledWith({
+                projectSourceDir: path_1.default.join(mockOptions.projectDir, mockOptions.projectConfig.srcDir),
                 platformVersion: mockOptions.projectConfig.platformVersion,
                 accountId: mockOptions.targetProjectAccountId,
             }, { projectNodesAtLastUpload: {} });
@@ -292,7 +297,7 @@ describe('LocalDevProcess', () => {
     });
     describe('addStateListener()', () => {
         it('should add state listener', () => {
-            const listener = vi.fn();
+            const listener = vitest_1.vi.fn();
             const key = 'projectNodes';
             process.addStateListener(key, listener);
             // @ts-expect-error
@@ -300,7 +305,7 @@ describe('LocalDevProcess', () => {
             expect(listener).toHaveBeenCalled();
         });
         it('should call listener immediately when callOnInit is true', () => {
-            const listener = vi.fn();
+            const listener = vitest_1.vi.fn();
             const key = 'projectNodes';
             process.addStateListener(key, listener, true);
             expect(listener).toHaveBeenCalledWith(process.projectNodes);

package/lib/projects/__tests__/LocalDevWebsocketServer.test.js

@@ -1,9 +1,14 @@
-import { WebSocketServer } from 'ws';
-import { isPortManagerServerRunning, requestPorts, } from '@hubspot/local-dev-lib/portManager';
-import { logger } from '@hubspot/local-dev-lib/logger';
-import { LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES, LOCAL_DEV_SERVER_MESSAGE_TYPES, } from '../../constants.js';
-import LocalDevWebsocketServer from '../localDev/LocalDevWebsocketServer.js';
-import { lib } from '../../../lang/en.js';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ws_1 = require("ws");
+const portManager_1 = require("@hubspot/local-dev-lib/portManager");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const constants_1 = require("../../constants");
+const LocalDevWebsocketServer_1 = __importDefault(require("../localDev/LocalDevWebsocketServer"));
+const en_1 = require("../../../lang/en");
 vi.mock('ws');
 vi.mock('@hubspot/local-dev-lib/portManager');
 vi.mock('@hubspot/local-dev-lib/logger');
@@ -33,28 +38,28 @@ describe('LocalDevWebsocketServer', () => {
             sendDevServerMessage: vi.fn(),
         };
         // Mock WebSocketServer constructor
-        WebSocketServer.mockImplementation(() => mockWebSocketServer);
+        ws_1.WebSocketServer.mockImplementation(() => mockWebSocketServer);
         // Create server instance
-        server = new LocalDevWebsocketServer(mockLocalDevProcess, true);
+        server = new LocalDevWebsocketServer_1.default(mockLocalDevProcess, true);
     });
     describe('start()', () => {
         it('should throw error if port manager is not running', async () => {
-            isPortManagerServerRunning.mockResolvedValue(false);
+            portManager_1.isPortManagerServerRunning.mockResolvedValue(false);
             await expect(server.start()).rejects.toThrow();
         });
         it('should start websocket server successfully', async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
+            portManager_1.isPortManagerServerRunning.mockResolvedValue(true);
+            portManager_1.requestPorts.mockResolvedValue({
                 'local-dev-ui-websocket-server': 1234,
             });
             await server.start();
-            expect(WebSocketServer).toHaveBeenCalledWith({ port: 1234 });
+            expect(ws_1.WebSocketServer).toHaveBeenCalledWith({ port: 1234 });
             expect(mockWebSocketServer.on).toHaveBeenCalledWith('connection', expect.any(Function));
-            expect(logger.log).toHaveBeenCalled();
+            expect(logger_1.logger.log).toHaveBeenCalled();
         });
         it('should accept connection from valid origin', async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
+            portManager_1.isPortManagerServerRunning.mockResolvedValue(true);
+            portManager_1.requestPorts.mockResolvedValue({
                 'local-dev-ui-websocket-server': 1234,
             });
             await server.start();
@@ -69,8 +74,8 @@ describe('LocalDevWebsocketServer', () => {
             expect(mockWebSocket.close).not.toHaveBeenCalled();
         });
         it('should reject connection from invalid origin', async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
+            portManager_1.isPortManagerServerRunning.mockResolvedValue(true);
+            portManager_1.requestPorts.mockResolvedValue({
                 'local-dev-ui-websocket-server': 1234,
             });
             await server.start();
@@ -80,13 +85,13 @@ describe('LocalDevWebsocketServer', () => {
             connectionCallback(mockWebSocket, {
                 headers: { origin: 'https://malicious-site.com' },
             });
-            expect(mockWebSocket.close).toHaveBeenCalledWith(1008, lib.LocalDevWebsocketServer.errors.originNotAllowed('https://malicious-site.com'));
+            expect(mockWebSocket.close).toHaveBeenCalledWith(1008, en_1.lib.LocalDevWebsocketServer.errors.originNotAllowed('https://malicious-site.com'));
             expect(mockWebSocket.on).not.toHaveBeenCalled();
             expect(mockLocalDevProcess.addStateListener).not.toHaveBeenCalled();
         });
         it('should reject connection with no origin header', async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
+            portManager_1.isPortManagerServerRunning.mockResolvedValue(true);
+            portManager_1.requestPorts.mockResolvedValue({
                 'local-dev-ui-websocket-server': 1234,
             });
             await server.start();
@@ -96,13 +101,13 @@ describe('LocalDevWebsocketServer', () => {
             connectionCallback(mockWebSocket, {
                 headers: {},
             });
-            expect(mockWebSocket.close).toHaveBeenCalledWith(1008, lib.LocalDevWebsocketServer.errors.originNotAllowed());
+            expect(mockWebSocket.close).toHaveBeenCalledWith(1008, en_1.lib.LocalDevWebsocketServer.errors.originNotAllowed());
             expect(mockWebSocket.on).not.toHaveBeenCalled();
             expect(mockLocalDevProcess.addStateListener).not.toHaveBeenCalled();
         });
         it('should send WEBSOCKET_SERVER_CONNECTED message when valid connection is established', async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
+            portManager_1.isPortManagerServerRunning.mockResolvedValue(true);
+            portManager_1.requestPorts.mockResolvedValue({
                 'local-dev-ui-websocket-server': 1234,
             });
             await server.start();
@@ -112,13 +117,13 @@ describe('LocalDevWebsocketServer', () => {
             connectionCallback(mockWebSocket, {
                 headers: { origin: 'https://app.hubspot.com' },
             });
-            expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledWith(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
+            expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledWith(constants_1.LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
         });
     });
     describe('message handling', () => {
         beforeEach(async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
+            portManager_1.isPortManagerServerRunning.mockResolvedValue(true);
+            portManager_1.requestPorts.mockResolvedValue({
                 'local-dev-ui-websocket-server': 1234,
             });
             await server.start();
@@ -130,7 +135,7 @@ describe('LocalDevWebsocketServer', () => {
         it('should handle UPLOAD message type', () => {
             const messageCallback = mockWebSocket.on.mock.calls[0][1];
             const message = {
-                type: LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.UPLOAD,
+                type: constants_1.LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.UPLOAD,
             };
             messageCallback(JSON.stringify(message));
             expect(mockLocalDevProcess.uploadProject).toHaveBeenCalled();
@@ -139,7 +144,7 @@ describe('LocalDevWebsocketServer', () => {
             const messageCallback = mockWebSocket.on.mock.calls[0][1];
             const message = {};
             messageCallback(JSON.stringify(message));
-            expect(logger.error).toHaveBeenCalled();
+            expect(logger_1.logger.error).toHaveBeenCalled();
         });
         it('should log error for unknown message type', () => {
             const messageCallback = mockWebSocket.on.mock.calls[0][1];
@@ -147,19 +152,19 @@ describe('LocalDevWebsocketServer', () => {
                 type: 'UNKNOWN_TYPE',
             };
             messageCallback(JSON.stringify(message));
-            expect(logger.error).toHaveBeenCalled();
+            expect(logger_1.logger.error).toHaveBeenCalled();
         });
         it('should log error for invalid JSON', () => {
             const messageCallback = mockWebSocket.on.mock.calls[0][1];
             const invalidJson = 'invalid json';
             messageCallback(invalidJson);
-            expect(logger.error).toHaveBeenCalled();
+            expect(logger_1.logger.error).toHaveBeenCalled();
         });
     });
     describe('shutdown()', () => {
         it('should close the websocket server', async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
+            portManager_1.isPortManagerServerRunning.mockResolvedValue(true);
+            portManager_1.requestPorts.mockResolvedValue({
                 'local-dev-ui-websocket-server': 1234,
             });
             await server.start();

package/lib/projects/__tests__/ProjectLogsManager.test.js

@@ -1,7 +1,9 @@
-import { ProjectLogsManager } from '../ProjectLogsManager.js';
-import { getProjectConfig } from '../config.js';
-import { ensureProjectExists } from '../ensureProjectExists.js';
-import { fetchProjectComponentsMetadata } from '@hubspot/local-dev-lib/api/projects';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ProjectLogsManager_1 = require("../ProjectLogsManager");
+const config_1 = require("../config");
+const ensureProjectExists_1 = require("../ensureProjectExists");
+const projects_1 = require("@hubspot/local-dev-lib/api/projects");
 const SUBCOMPONENT_TYPES = {
     APP_ID: 'APP_ID',
     PACKAGE_LOCK_FILE: 'PACKAGE_LOCK_FILE',
@@ -55,10 +57,10 @@ describe('lib/projects/ProjectLogsManager', () => {
         },
     ];
     beforeEach(() => {
-        ProjectLogsManager.reset();
-        getProjectConfig.mockResolvedValue(projectConfig);
-        ensureProjectExists.mockResolvedValue(projectDetails);
-        fetchProjectComponentsMetadata.mockResolvedValue({
+        ProjectLogsManager_1.ProjectLogsManager.reset();
+        config_1.getProjectConfig.mockResolvedValue(projectConfig);
+        ensureProjectExists_1.ensureProjectExists.mockResolvedValue(projectDetails);
+        projects_1.fetchProjectComponentsMetadata.mockResolvedValue({
             data: {
                 topLevelComponentMetadata: [
                     {
@@ -83,59 +85,59 @@ describe('lib/projects/ProjectLogsManager', () => {
     });
     describe('init', () => {
         it('should load the project config', async () => {
-            await ProjectLogsManager.init(accountId);
-            expect(getProjectConfig).toHaveBeenCalledTimes(1);
+            await ProjectLogsManager_1.ProjectLogsManager.init(accountId);
+            expect(config_1.getProjectConfig).toHaveBeenCalledTimes(1);
         });
         it('should throw an error if there is a problem with the config', async () => {
-            getProjectConfig.mockResolvedValue({});
-            await expect(async () => ProjectLogsManager.init(accountId)).rejects.toThrow('No project detected. Run this command again from a project directory.');
-            expect(getProjectConfig).toHaveBeenCalledTimes(1);
+            config_1.getProjectConfig.mockResolvedValue({});
+            await expect(async () => ProjectLogsManager_1.ProjectLogsManager.init(accountId)).rejects.toThrow('No project detected. Run this command again from a project directory.');
+            expect(config_1.getProjectConfig).toHaveBeenCalledTimes(1);
         });
         it('should ensure the project exists', async () => {
-            await ProjectLogsManager.init(accountId);
-            expect(ensureProjectExists).toHaveBeenCalledTimes(1);
-            expect(ensureProjectExists).toHaveBeenCalledWith(accountId, projectName, {
+            await ProjectLogsManager_1.ProjectLogsManager.init(accountId);
+            expect(ensureProjectExists_1.ensureProjectExists).toHaveBeenCalledTimes(1);
+            expect(ensureProjectExists_1.ensureProjectExists).toHaveBeenCalledWith(accountId, projectName, {
                 allowCreate: false,
             });
         });
         it('should throw an error if there is data missing from the project details', async () => {
-            ensureProjectExists.mockResolvedValue({});
-            await expect(async () => ProjectLogsManager.init(accountId)).rejects.toThrow(/There was an error fetching project details/);
+            ensureProjectExists_1.ensureProjectExists.mockResolvedValue({});
+            await expect(async () => ProjectLogsManager_1.ProjectLogsManager.init(accountId)).rejects.toThrow(/There was an error fetching project details/);
         });
         it('should set all of the expected fields correctly', async () => {
-            await ProjectLogsManager.init(accountId);
-            expect(ProjectLogsManager.projectId).toEqual(projectId);
-            expect(ProjectLogsManager.projectName).toEqual(projectName);
-            expect(ProjectLogsManager.accountId).toEqual(accountId);
-            expect(ProjectLogsManager.functions).toEqual(functions);
+            await ProjectLogsManager_1.ProjectLogsManager.init(accountId);
+            expect(ProjectLogsManager_1.ProjectLogsManager.projectId).toEqual(projectId);
+            expect(ProjectLogsManager_1.ProjectLogsManager.projectName).toEqual(projectName);
+            expect(ProjectLogsManager_1.ProjectLogsManager.accountId).toEqual(accountId);
+            expect(ProjectLogsManager_1.ProjectLogsManager.functions).toEqual(functions);
         });
     });
     describe('fetchFunctionDetails', () => {
         it('should throw an error if the projectId is null when the method is called', async () => {
-            await expect(async () => ProjectLogsManager.fetchFunctionDetails()).rejects.toThrow('No project detected. Run this command again from a project directory.');
+            await expect(async () => ProjectLogsManager_1.ProjectLogsManager.fetchFunctionDetails()).rejects.toThrow('No project detected. Run this command again from a project directory.');
         });
         it('should fetch the component metadata', async () => {
-            ProjectLogsManager.projectId = projectId;
-            ProjectLogsManager.accountId = accountId;
-            await ProjectLogsManager.fetchFunctionDetails();
-            expect(fetchProjectComponentsMetadata).toHaveBeenCalledTimes(1);
-            expect(fetchProjectComponentsMetadata).toHaveBeenCalledWith(accountId, projectId);
+            ProjectLogsManager_1.ProjectLogsManager.projectId = projectId;
+            ProjectLogsManager_1.ProjectLogsManager.accountId = accountId;
+            await ProjectLogsManager_1.ProjectLogsManager.fetchFunctionDetails();
+            expect(projects_1.fetchProjectComponentsMetadata).toHaveBeenCalledTimes(1);
+            expect(projects_1.fetchProjectComponentsMetadata).toHaveBeenCalledWith(accountId, projectId);
         });
         it('should set the functions correctly', async () => {
-            ProjectLogsManager.projectId = projectId;
-            ProjectLogsManager.accountId = accountId;
-            await ProjectLogsManager.fetchFunctionDetails();
-            expect(ProjectLogsManager.functions).toEqual(functions);
+            ProjectLogsManager_1.ProjectLogsManager.projectId = projectId;
+            ProjectLogsManager_1.ProjectLogsManager.accountId = accountId;
+            await ProjectLogsManager_1.ProjectLogsManager.fetchFunctionDetails();
+            expect(ProjectLogsManager_1.ProjectLogsManager.functions).toEqual(functions);
         });
     });
     describe('getFunctionNames', () => {
         it('should return an empty array if functions is empty', async () => {
-            ProjectLogsManager.functions = [];
-            expect(ProjectLogsManager.getFunctionNames()).toEqual([]);
+            ProjectLogsManager_1.ProjectLogsManager.functions = [];
+            expect(ProjectLogsManager_1.ProjectLogsManager.getFunctionNames()).toEqual([]);
         });
         it('should return an array of the componentNames', async () => {
-            ProjectLogsManager.functions = functions;
-            expect(ProjectLogsManager.getFunctionNames()).toEqual([
+            ProjectLogsManager_1.ProjectLogsManager.functions = functions;
+            expect(ProjectLogsManager_1.ProjectLogsManager.getFunctionNames()).toEqual([
                 'function1',
                 'function2',
             ]);
@@ -143,13 +145,13 @@ describe('lib/projects/ProjectLogsManager', () => {
     });
     describe('setFunction', () => {
         it('should throw an error when functions is empty', async () => {
-            ProjectLogsManager.functions = [];
-            expect(() => ProjectLogsManager.setFunction('foo')).toThrow(`There aren't any functions in this project`);
+            ProjectLogsManager_1.ProjectLogsManager.functions = [];
+            expect(() => ProjectLogsManager_1.ProjectLogsManager.setFunction('foo')).toThrow(`There aren't any functions in this project`);
         });
         it('should throw an error when the provided function is invalid', async () => {
-            ProjectLogsManager.functions = functions;
+            ProjectLogsManager_1.ProjectLogsManager.functions = functions;
             const badName = 'foo';
-            expect(() => ProjectLogsManager.setFunction(badName)).toThrow(`No function with name "${badName}"`);
+            expect(() => ProjectLogsManager_1.ProjectLogsManager.setFunction(badName)).toThrow(`No function with name "${badName}"`);
         });
         it('should set the data correctly for public functions', async () => {
             const functionToChoose = {
@@ -163,27 +165,27 @@ describe('lib/projects/ProjectLogsManager', () => {
                     endpoint: { path: 'yooooooo', methods: ['GET'] },
                 },
             };
-            ProjectLogsManager.functions = [functionToChoose];
-            ProjectLogsManager.setFunction('function1');
-            expect(ProjectLogsManager.functionName).toEqual('function1');
-            expect(ProjectLogsManager.endpointName).toEqual('yooooooo');
-            expect(ProjectLogsManager.selectedFunction).toEqual(functionToChoose);
-            expect(ProjectLogsManager.isPublicFunction).toEqual(true);
+            ProjectLogsManager_1.ProjectLogsManager.functions = [functionToChoose];
+            ProjectLogsManager_1.ProjectLogsManager.setFunction('function1');
+            expect(ProjectLogsManager_1.ProjectLogsManager.functionName).toEqual('function1');
+            expect(ProjectLogsManager_1.ProjectLogsManager.endpointName).toEqual('yooooooo');
+            expect(ProjectLogsManager_1.ProjectLogsManager.selectedFunction).toEqual(functionToChoose);
+            expect(ProjectLogsManager_1.ProjectLogsManager.isPublicFunction).toEqual(true);
         });
         it('should set the data correctly for public functions', async () => {
-            ProjectLogsManager.functions = functions;
-            ProjectLogsManager.setFunction('function1');
-            expect(ProjectLogsManager.selectedFunction).toEqual(function1);
-            expect(ProjectLogsManager.functionName).toEqual('function1');
-            expect(ProjectLogsManager.isPublicFunction).toEqual(false);
+            ProjectLogsManager_1.ProjectLogsManager.functions = functions;
+            ProjectLogsManager_1.ProjectLogsManager.setFunction('function1');
+            expect(ProjectLogsManager_1.ProjectLogsManager.selectedFunction).toEqual(function1);
+            expect(ProjectLogsManager_1.ProjectLogsManager.functionName).toEqual('function1');
+            expect(ProjectLogsManager_1.ProjectLogsManager.isPublicFunction).toEqual(false);
         });
     });
     describe('reset', () => {
         it('should reset all the values', async () => {
-            ProjectLogsManager.projectName = 'value';
-            expect(ProjectLogsManager.projectName).toBeDefined();
-            ProjectLogsManager.reset();
-            expect(ProjectLogsManager.projectName).toBeUndefined();
+            ProjectLogsManager_1.ProjectLogsManager.projectName = 'value';
+            expect(ProjectLogsManager_1.ProjectLogsManager.projectName).toBeDefined();
+            ProjectLogsManager_1.ProjectLogsManager.reset();
+            expect(ProjectLogsManager_1.ProjectLogsManager.projectName).toBeUndefined();
         });
     });
 });

package/lib/projects/__tests__/buildAndDeploy.test.js

@@ -1,23 +1,25 @@
-import { useV3Api } from '../buildAndDeploy.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const buildAndDeploy_1 = require("../buildAndDeploy");
 describe('buildAndDeploy', () => {
     describe('useV3Api', () => {
         it('returns true if platform version is UNSTABLE', () => {
-            expect(useV3Api('UNSTABLE')).toBe(true);
+            expect((0, buildAndDeploy_1.useV3Api)('UNSTABLE')).toBe(true);
         });
         it('returns true if platform version is equal to the minimum', () => {
-            expect(useV3Api('2025.2')).toBe(true);
+            expect((0, buildAndDeploy_1.useV3Api)('2025.2')).toBe(true);
         });
         it('returns true if platform version is greater than the minimum', () => {
-            expect(useV3Api('2026.2')).toBe(true);
+            expect((0, buildAndDeploy_1.useV3Api)('2026.2')).toBe(true);
         });
         it('returns false if platform version is less than the minimum', () => {
-            expect(useV3Api('2025.0')).toBe(false);
+            expect((0, buildAndDeploy_1.useV3Api)('2025.0')).toBe(false);
         });
         it('returns false if platform version is invalid', () => {
-            expect(useV3Api(null)).toBe(false);
+            expect((0, buildAndDeploy_1.useV3Api)(null)).toBe(false);
         });
         it('returns false for an invalid platform version', () => {
-            expect(useV3Api('notplaformversion')).toBe(false);
+            expect((0, buildAndDeploy_1.useV3Api)('notplaformversion')).toBe(false);
         });
     });
 });