@hubspot/cli 7.7.19-experimental.2 → 7.7.20-experimental.0

package/lib/__tests__/projectProfiles.test.js

@@ -0,0 +1,134 @@
+"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 en_1 = require("../../lang/en");
+const ui_1 = require("../ui");
+const logger_1 = require("../ui/logger");
+const exitCodes_1 = require("../enums/exitCodes");
+const projectProfiles_1 = require("../projectProfiles");
+// Mock dependencies
+vi.mock('@hubspot/project-parsing-lib');
+vi.mock('../ui');
+vi.mock('../ui/logger');
+vi.mock('../../lang/en');
+// Mock process.exit
+const mockExit = vi.spyOn(process, 'exit').mockImplementation(code => {
+    throw new Error(`Process.exit called with code ${code}`);
+});
+const mockedLoadHsProfileFile = project_parsing_lib_1.loadHsProfileFile;
+const mockedGetHsProfileFilename = project_parsing_lib_1.getHsProfileFilename;
+const mockedGetAllHsProfiles = project_parsing_lib_1.getAllHsProfiles;
+const mockedUiBetaTag = ui_1.uiBetaTag;
+const mockedUiLine = ui_1.uiLine;
+const mockedUiLogger = logger_1.uiLogger;
+describe('lib/projectProfiles', () => {
+    describe('logProfileHeader()', () => {
+        it('should log profile header with correct format', () => {
+            const profileName = 'test-profile';
+            const filename = 'test-profile.hsprofile';
+            mockedGetHsProfileFilename.mockReturnValue(filename);
+            (0, projectProfiles_1.logProfileHeader)(profileName);
+            expect(mockedUiLine).toHaveBeenCalled();
+            expect(mockedUiBetaTag).toHaveBeenCalledWith(en_1.lib.projectProfiles.logs.usingProfile(filename));
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('');
+        });
+    });
+    describe('logProfileFooter()', () => {
+        const mockProfile = {
+            accountId: 123,
+            variables: {
+                key1: 'value1',
+                key2: 'value2',
+            },
+        };
+        it('should log profile footer with account ID', () => {
+            (0, projectProfiles_1.logProfileFooter)(mockProfile);
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(en_1.lib.projectProfiles.logs.profileTargetAccount(mockProfile.accountId));
+            expect(mockedUiLine).toHaveBeenCalled();
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('');
+        });
+        it('should log variables when includeVariables is true', () => {
+            (0, projectProfiles_1.logProfileFooter)(mockProfile, true);
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(en_1.lib.projectProfiles.logs.profileTargetAccount(mockProfile.accountId));
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('');
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(en_1.lib.projectProfiles.logs.profileVariables);
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('  key1: value1');
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('  key2: value2');
+            expect(mockedUiLine).toHaveBeenCalled();
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('');
+        });
+    });
+    describe('loadProfile()', () => {
+        const mockProjectConfig = {
+            srcDir: 'src',
+            name: 'test-project',
+            platformVersion: '1.0.0',
+        };
+        const mockProjectDir = '/test/project';
+        const mockProfileName = 'test-profile';
+        const mockProfile = {
+            accountId: 123,
+        };
+        it('should return undefined when project config is missing', () => {
+            const result = (0, projectProfiles_1.loadProfile)(null, mockProjectDir, mockProfileName);
+            expect(result).toBeUndefined();
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(en_1.lib.projectProfiles.loadProfile.errors.noProjectConfig);
+        });
+        it('should return undefined when profile is not found', () => {
+            mockedLoadHsProfileFile.mockReturnValue(null);
+            const filename = 'test-profile.hsprofile';
+            mockedGetHsProfileFilename.mockReturnValue(filename);
+            const result = (0, projectProfiles_1.loadProfile)(mockProjectConfig, mockProjectDir, mockProfileName);
+            expect(result).toBeUndefined();
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(en_1.lib.projectProfiles.loadProfile.errors.profileNotFound(filename));
+        });
+        it('should return undefined when profile has no account ID', () => {
+            mockedLoadHsProfileFile.mockReturnValue({});
+            const filename = 'test-profile.hsprofile';
+            mockedGetHsProfileFilename.mockReturnValue(filename);
+            const result = (0, projectProfiles_1.loadProfile)(mockProjectConfig, mockProjectDir, mockProfileName);
+            expect(result).toBeUndefined();
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(en_1.lib.projectProfiles.loadProfile.errors.missingAccountId(filename));
+        });
+        it('should return undefined when profile loading fails', () => {
+            mockedLoadHsProfileFile.mockImplementation(() => {
+                throw new Error('Load failed');
+            });
+            const filename = 'test-profile.hsprofile';
+            mockedGetHsProfileFilename.mockReturnValue(filename);
+            const result = (0, projectProfiles_1.loadProfile)(mockProjectConfig, mockProjectDir, mockProfileName);
+            expect(result).toBeUndefined();
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(en_1.lib.projectProfiles.loadProfile.errors.failedToLoadProfile(filename));
+        });
+        it('should return profile when loading succeeds', () => {
+            mockedLoadHsProfileFile.mockReturnValue(mockProfile);
+            const result = (0, projectProfiles_1.loadProfile)(mockProjectConfig, mockProjectDir, mockProfileName);
+            expect(result).toEqual(mockProfile);
+            expect(mockedLoadHsProfileFile).toHaveBeenCalledWith(path_1.default.join(mockProjectDir, mockProjectConfig.srcDir), mockProfileName);
+        });
+    });
+    describe('exitIfUsingProfiles()', () => {
+        const mockProjectConfig = {
+            srcDir: 'src',
+            name: 'test-project',
+            platformVersion: '1.0.0',
+        };
+        const mockProjectDir = '/test/project';
+        it('should not exit when no profiles exist', async () => {
+            mockedGetAllHsProfiles.mockResolvedValue([]);
+            await (0, projectProfiles_1.exitIfUsingProfiles)(mockProjectConfig, mockProjectDir);
+            expect(mockedUiLogger.error).not.toHaveBeenCalled();
+            expect(mockExit).not.toHaveBeenCalled();
+        });
+        it('should exit with error when profiles exist', async () => {
+            mockedGetAllHsProfiles.mockResolvedValue(['profile1', 'profile2']);
+            await expect((0, projectProfiles_1.exitIfUsingProfiles)(mockProjectConfig, mockProjectDir)).rejects.toThrow(`Process.exit called with code ${exitCodes_1.EXIT_CODES.ERROR}`);
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(en_1.lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
+            expect(mockExit).toHaveBeenCalledWith(exitCodes_1.EXIT_CODES.ERROR);
+        });
+    });
+});

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

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

package/lib/__tests__/sandboxSync.test.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const sandboxSync_1 = require("@hubspot/local-dev-lib/api/sandboxSync");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const config_2 = require("@hubspot/local-dev-lib/constants/config");
+const testUtils_1 = require("../testUtils");
+const sandboxes_1 = require("../sandboxes");
+const sandboxSync_2 = require("../sandboxSync");
+const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('@hubspot/local-dev-lib/api/sandboxSync');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../sandboxes');
+vi.mock('../ui/SpinniesManager');
+const mockedLogger = logger_1.logger;
+const mockedInitiateSync = sandboxSync_1.initiateSync;
+const mockedGetAccountId = config_1.getAccountId;
+const mockedGetAvailableSyncTypes = sandboxes_1.getAvailableSyncTypes;
+const mockedSpinniesInit = SpinniesManager_1.default.init;
+const mockedSpinniesAdd = SpinniesManager_1.default.add;
+const mockedSpinniesSucceed = SpinniesManager_1.default.succeed;
+const mockedSpinniesFail = SpinniesManager_1.default.fail;
+describe('lib/sandboxSync', () => {
+    const mockEnv = 'qa';
+    const mockParentAccount = {
+        name: 'Parent Account',
+        portalId: 123,
+        accountType: config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+        env: mockEnv,
+    };
+    const mockChildAccount = {
+        name: 'Child Account',
+        portalId: 456,
+        accountType: config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+        env: mockEnv,
+    };
+    const mockSyncTasks = [{ type: 'mock-sync-type' }];
+    beforeEach(() => {
+        mockedGetAccountId
+            .mockReturnValueOnce(mockChildAccount.portalId)
+            .mockReturnValueOnce(mockParentAccount.portalId);
+        mockedGetAvailableSyncTypes.mockResolvedValue(mockSyncTasks);
+    });
+    describe('syncSandbox()', () => {
+        it('successfully syncs a sandbox with provided sync tasks', async () => {
+            mockedInitiateSync.mockResolvedValue({ status: 'SUCCESS' });
+            await (0, sandboxSync_2.syncSandbox)(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks);
+            expect(mockedSpinniesInit).toHaveBeenCalled();
+            expect(mockedSpinniesAdd).toHaveBeenCalled();
+            expect(mockedInitiateSync).toHaveBeenCalledWith(mockParentAccount.portalId, mockChildAccount.portalId, mockSyncTasks, mockChildAccount.portalId);
+            expect(mockedSpinniesSucceed).toHaveBeenCalled();
+        });
+        it('fetches sync types when no tasks are provided', async () => {
+            mockedInitiateSync.mockResolvedValue({ status: 'SUCCESS' });
+            await (0, sandboxSync_2.syncSandbox)(mockChildAccount, mockParentAccount, mockEnv, []);
+            expect(mockedGetAvailableSyncTypes).toHaveBeenCalledWith(mockParentAccount, mockChildAccount);
+            expect(mockedGetAvailableSyncTypes).toHaveBeenCalledWith(mockParentAccount, mockChildAccount);
+            expect(mockedInitiateSync).toHaveBeenCalled();
+        });
+        it('throws error when account IDs are missing', async () => {
+            mockedGetAccountId.mockReset();
+            mockedGetAccountId.mockReturnValue(null);
+            const errorRegex = new RegExp(`Couldn't sync ${mockChildAccount.portalId} because your account has been removed from`);
+            await expect((0, sandboxSync_2.syncSandbox)(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toThrow(errorRegex);
+        });
+        it('handles sync in progress error', async () => {
+            const error = (0, testUtils_1.mockHubSpotHttpError)('', {
+                status: 429,
+                data: {
+                    category: 'RATE_LIMITS',
+                    subCategory: 'sandboxes-sync-api.SYNC_IN_PROGRESS',
+                },
+            });
+            mockedInitiateSync.mockRejectedValue(error);
+            await expect((0, sandboxSync_2.syncSandbox)(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            expect(mockedSpinniesFail).toHaveBeenCalled();
+            expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Couldn't run the sync because there's another sync in progress/));
+        });
+        it('handles invalid user error', async () => {
+            const error = (0, testUtils_1.mockHubSpotHttpError)('', {
+                status: 403,
+                data: {
+                    category: 'BANNED',
+                    subCategory: 'sandboxes-sync-api.SYNC_NOT_ALLOWED_INVALID_USER',
+                },
+            });
+            mockedInitiateSync.mockRejectedValue(error);
+            await expect((0, sandboxSync_2.syncSandbox)(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            expect(mockedSpinniesFail).toHaveBeenCalled();
+            expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/because your account has been removed from/));
+        });
+        it('handles not super admin error', async () => {
+            const error = (0, testUtils_1.mockHubSpotHttpError)('', {
+                status: 403,
+                data: {
+                    category: 'BANNED',
+                    subCategory: 'sandboxes-sync-api.SYNC_NOT_ALLOWED_INVALID_USERID',
+                },
+            });
+            mockedInitiateSync.mockRejectedValue(error);
+            await expect((0, sandboxSync_2.syncSandbox)(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            expect(mockedSpinniesFail).toHaveBeenCalled();
+            expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Couldn't run the sync because you are not a super admin in/));
+        });
+        it('handles sandbox not found error', async () => {
+            const error = (0, testUtils_1.mockHubSpotHttpError)('', {
+                status: 404,
+                data: {
+                    category: 'OBJECT_NOT_FOUND',
+                    subCategory: 'SandboxErrors.SANDBOX_NOT_FOUND',
+                },
+            });
+            mockedInitiateSync.mockRejectedValue(error);
+            await expect((0, sandboxSync_2.syncSandbox)(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            expect(mockedSpinniesFail).toHaveBeenCalled();
+            expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/may have been deleted through the UI/));
+        });
+        it('displays slim info message when specified', async () => {
+            mockedInitiateSync.mockResolvedValue({ status: 'SUCCESS' });
+            await (0, sandboxSync_2.syncSandbox)(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks, true);
+            expect(mockedLogger.info).not.toHaveBeenCalled();
+            expect(mockedSpinniesSucceed).toHaveBeenCalledWith('sandboxSync', expect.objectContaining({
+                text: expect.stringMatching(/Initiated sync of object definitions from production to /),
+            }));
+        });
+    });
+});

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

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

package/lib/__tests__/sandboxes.test.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const sandboxHubs_1 = require("@hubspot/local-dev-lib/api/sandboxHubs");
+const sandboxSync_1 = require("@hubspot/local-dev-lib/api/sandboxSync");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const config_2 = require("@hubspot/local-dev-lib/constants/config");
+const testUtils_1 = require("../testUtils");
+const sandboxes_1 = require("../sandboxes");
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('@hubspot/local-dev-lib/api/sandboxHubs');
+vi.mock('@hubspot/local-dev-lib/api/sandboxSync');
+vi.mock('@hubspot/local-dev-lib/config');
+const mockedGetAccountId = config_1.getAccountId;
+const mockedGetSandboxUsageLimits = sandboxHubs_1.getSandboxUsageLimits;
+const mockedFetchTypes = sandboxSync_1.fetchTypes;
+const mockedGetConfigAccounts = config_1.getConfigAccounts;
+const mockedLogger = logger_1.logger;
+describe('lib/sandboxes', () => {
+    describe('getSandboxTypeAsString()', () => {
+        it('returns "development" for development sandbox type', () => {
+            expect((0, sandboxes_1.getSandboxTypeAsString)(config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe('development');
+        });
+        it('returns "standard" for standard sandbox type', () => {
+            expect((0, sandboxes_1.getSandboxTypeAsString)(config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX)).toBe('standard');
+        });
+        it('returns "standard" for undefined input', () => {
+            expect((0, sandboxes_1.getSandboxTypeAsString)(undefined)).toBe('standard');
+        });
+    });
+    describe('getHasSandboxesByType()', () => {
+        const mockParentAccount = {
+            name: 'Parent Account',
+            portalId: 123,
+            authType: undefined,
+            accountType: config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+            env: 'qa',
+        };
+        it('returns true when sandbox of specified type exists', () => {
+            mockedGetAccountId.mockReturnValue(mockParentAccount.portalId);
+            mockedGetConfigAccounts.mockReturnValue([
+                mockParentAccount,
+                {
+                    ...mockParentAccount,
+                    parentAccountId: 123,
+                    accountType: config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+                },
+            ]);
+            expect((0, sandboxes_1.getHasSandboxesByType)(mockParentAccount, config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(true);
+        });
+        it('returns false when no sandbox of specified type exists', () => {
+            mockedGetConfigAccounts.mockReturnValue([mockParentAccount]);
+            expect((0, sandboxes_1.getHasSandboxesByType)(mockParentAccount, config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(false);
+        });
+    });
+    describe('getAvailableSyncTypes()', () => {
+        const mockParentAccount = {
+            name: 'Parent Account',
+            portalId: 123,
+            env: 'qa',
+        };
+        const mockChildAccount = {
+            ...mockParentAccount,
+            portalId: 456,
+        };
+        it('returns available sync types when fetch is successful', async () => {
+            const mockSyncTypes = [{ name: 'type1' }, { name: 'type2' }];
+            mockedGetAccountId
+                .mockReturnValue(mockParentAccount.portalId)
+                .mockReturnValue(mockChildAccount.portalId);
+            mockedFetchTypes.mockResolvedValue({
+                data: { results: mockSyncTypes },
+            });
+            const result = await (0, sandboxes_1.getAvailableSyncTypes)(mockParentAccount, mockChildAccount);
+            expect(result).toEqual([{ type: 'type1' }, { type: 'type2' }]);
+        });
+        it('throws error when sync types fetch fails', async () => {
+            mockedFetchTypes.mockResolvedValue({ data: { results: null } });
+            await expect((0, sandboxes_1.getAvailableSyncTypes)(mockParentAccount, mockChildAccount)).rejects.toThrow(/Unable to fetch available sandbox sync types/);
+        });
+    });
+    describe('validateSandboxUsageLimits()', () => {
+        const mockAccount = {
+            name: 'Test Account',
+            portalId: 123,
+            authType: undefined,
+            env: 'qa',
+        };
+        it('validates successfully when limits are not reached', async () => {
+            mockedGetAccountId.mockReturnValue(mockAccount.portalId);
+            mockedGetSandboxUsageLimits.mockResolvedValue({
+                data: {
+                    usage: { DEVELOPER: { available: 1, limit: 3 } },
+                },
+            });
+            await expect((0, sandboxes_1.validateSandboxUsageLimits)(mockAccount, config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'qa')).resolves.not.toThrow();
+        });
+        it('throws error when development sandbox limit is reached', async () => {
+            mockedGetAccountId.mockReturnValue(mockAccount.portalId);
+            mockedGetConfigAccounts.mockReturnValue([]);
+            mockedGetSandboxUsageLimits.mockResolvedValue({
+                data: {
+                    usage: { DEVELOPER: { available: 0, limit: 1 } },
+                },
+            });
+            await expect((0, sandboxes_1.validateSandboxUsageLimits)(mockAccount, config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'qa')).rejects.toThrow(/reached the limit of 1 development sandbox/);
+        });
+    });
+    describe('handleSandboxCreateError()', () => {
+        const mockEnv = 'qa';
+        const mockName = 'Test Sandbox';
+        const mockAccountId = 123;
+        it('handles missing scope error', () => {
+            const error = (0, testUtils_1.mockHubSpotHttpError)('missing scopes error', {
+                status: 403,
+                data: {
+                    message: 'Missing scopes error',
+                    category: 'MISSING_SCOPES',
+                },
+            });
+            expect(() => (0, sandboxes_1.handleSandboxCreateError)(error, mockEnv, mockName, mockAccountId)).toThrow(error);
+            expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/The personal access key you provided doesn't include sandbox permissions/));
+            expect(mockedLogger.info).toHaveBeenCalledWith(expect.stringMatching(/To update CLI permissions for/));
+        });
+        it('handles user access not allowed error', () => {
+            const error = (0, testUtils_1.mockHubSpotHttpError)('user access not allowed error', {
+                status: 403,
+                data: {
+                    category: 'BANNED',
+                    subCategory: 'SandboxErrors.USER_ACCESS_NOT_ALLOWED',
+                },
+            });
+            expect(() => (0, sandboxes_1.handleSandboxCreateError)(error, mockEnv, mockName, mockAccountId)).toThrow(error);
+            expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/your permission set doesn't allow you to create the sandbox/));
+        });
+        it('handles 403 gating error', () => {
+            const error = (0, testUtils_1.mockHubSpotHttpError)('403 gating error', {
+                status: 403,
+                data: {
+                    category: 'BANNED',
+                    subCategory: 'SandboxErrors.DEVELOPMENT_SANDBOX_ACCESS_NOT_ALLOWED',
+                },
+            });
+            expect(() => (0, sandboxes_1.handleSandboxCreateError)(error, mockEnv, mockName, mockAccountId)).toThrow(error);
+            expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/does not have access to development sandboxes/));
+        });
+    });
+});

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

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

package/lib/__tests__/serverlessLogs.test.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mock_stdin_1 = __importDefault(require("mock-stdin"));
+const serverlessFunctionLogs_1 = require("../ui/serverlessFunctionLogs");
+const serverlessLogs_1 = require("../serverlessLogs");
+vi.mock('../ui/serverlessFunctionLogs');
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('../ui/SpinniesManager', () => ({
+    default: {
+        init: vi.fn(),
+        add: vi.fn(),
+        remove: vi.fn(),
+        succeed: vi.fn(),
+        fail: vi.fn(),
+        stopAll: vi.fn(),
+    },
+}));
+vi.useFakeTimers();
+const ACCOUNT_ID = 123;
+describe('lib/serverlessLogs', () => {
+    describe('tailLogs()', () => {
+        let stdinMock;
+        beforeEach(() => {
+            // @ts-ignore - we don't need to mock the entire process object
+            vi.spyOn(process, 'exit').mockImplementation(() => { });
+            stdinMock = mock_stdin_1.default.stdin();
+        });
+        afterEach(() => {
+            vi.clearAllTimers();
+            stdinMock.restore();
+        });
+        it('calls tailCall() to get the next results', async () => {
+            const compact = false;
+            const fetchLatest = vi.fn(() => {
+                return Promise.resolve({
+                    data: {
+                        id: '1234',
+                        executionTime: 510,
+                        log: 'Log message',
+                        error: { message: '', type: '', stackTrace: [] },
+                        status: 'SUCCESS',
+                        createdAt: 1620232011451,
+                        memory: '70/128 MB',
+                        duration: '53.40 ms',
+                    },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {},
+                });
+            });
+            const tailCall = vi.fn(() => {
+                return Promise.resolve({
+                    data: {
+                        results: [],
+                        paging: {
+                            next: {
+                                after: 'somehash',
+                            },
+                        },
+                    },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {},
+                });
+            });
+            // @ts-ignore - headers is not used in the actual function and does not need to be mocked
+            await (0, serverlessLogs_1.tailLogs)(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            vi.runOnlyPendingTimers();
+            expect(fetchLatest).toHaveBeenCalled();
+            expect(tailCall).toHaveBeenCalledTimes(2);
+        });
+        it('outputs results', async () => {
+            const compact = false;
+            const fetchLatest = vi.fn(() => {
+                return Promise.resolve({
+                    data: {
+                        id: '1234',
+                        executionTime: 510,
+                        log: 'Log message',
+                        error: { message: '', type: '', stackTrace: [], statusCode: null },
+                        status: 'SUCCESS',
+                        createdAt: 1620232011451,
+                        memory: '70/128 MB',
+                        duration: '53.40 ms',
+                    },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {},
+                });
+            });
+            const latestLogResponse = {
+                results: [
+                    {
+                        id: '456',
+                        executionTime: 510,
+                        log: 'Message 1',
+                        error: null,
+                        status: 'SUCCESS',
+                        createdAt: 1620232011451,
+                        memory: '70/128 MB',
+                        duration: '53.40 ms',
+                    },
+                    {
+                        id: '457',
+                        executionTime: 510,
+                        log: 'Message 2',
+                        error: null,
+                        status: 'SUCCESS',
+                        createdAt: 1620232011451,
+                        memory: '70/128 MB',
+                        duration: '53.40 ms',
+                    },
+                ],
+                paging: {
+                    next: {
+                        after: 'somehash',
+                    },
+                },
+            };
+            const tailCall = vi.fn(() => Promise.resolve({ data: latestLogResponse }));
+            // @ts-ignore - headers is not used in the actual function and does not need to be mocked
+            await (0, serverlessLogs_1.tailLogs)(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            vi.runOnlyPendingTimers();
+            expect(serverlessFunctionLogs_1.outputLogs).toHaveBeenCalledWith(latestLogResponse, expect.objectContaining({ compact }));
+            expect(tailCall).toHaveBeenCalledTimes(2);
+        });
+        it('handles no logs', async () => {
+            const compact = false;
+            const fetchLatest = vi.fn(() => {
+                return Promise.reject({
+                    message: '',
+                    type: '',
+                    stackTrace: [],
+                    statusCode: 404,
+                });
+            });
+            const tailCall = vi.fn(() => Promise.reject({
+                message: '',
+                type: '',
+                stackTrace: [],
+                statusCode: 404,
+            }));
+            await (0, serverlessLogs_1.tailLogs)(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            vi.runOnlyPendingTimers();
+            expect(tailCall).toHaveBeenCalledTimes(2);
+        });
+    });
+});

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

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