@hubspot/cli 7.7.19-experimental.3 → 7.7.21-experimental.0

package/lib/__tests__/projectProfiles.test.js

@@ -0,0 +1,129 @@
+import path from 'path';
+import { loadHsProfileFile, getHsProfileFilename, getAllHsProfiles, } from '@hubspot/project-parsing-lib';
+import { lib } from '../../lang/en.js';
+import { uiBetaTag, uiLine } from '../ui/index.js';
+import { uiLogger } from '../ui/logger.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+import { logProfileHeader, logProfileFooter, loadProfile, exitIfUsingProfiles, } from '../projectProfiles.js';
+// 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 = loadHsProfileFile;
+const mockedGetHsProfileFilename = getHsProfileFilename;
+const mockedGetAllHsProfiles = getAllHsProfiles;
+const mockedUiBetaTag = uiBetaTag;
+const mockedUiLine = uiLine;
+const mockedUiLogger = 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);
+            logProfileHeader(profileName);
+            expect(mockedUiLine).toHaveBeenCalled();
+            expect(mockedUiBetaTag).toHaveBeenCalledWith(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', () => {
+            logProfileFooter(mockProfile);
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(lib.projectProfiles.logs.profileTargetAccount(mockProfile.accountId));
+            expect(mockedUiLine).toHaveBeenCalled();
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('');
+        });
+        it('should log variables when includeVariables is true', () => {
+            logProfileFooter(mockProfile, true);
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(lib.projectProfiles.logs.profileTargetAccount(mockProfile.accountId));
+            expect(mockedUiLogger.log).toHaveBeenCalledWith('');
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(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 = loadProfile(null, mockProjectDir, mockProfileName);
+            expect(result).toBeUndefined();
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(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 = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
+            expect(result).toBeUndefined();
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(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 = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
+            expect(result).toBeUndefined();
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(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 = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
+            expect(result).toBeUndefined();
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(filename));
+        });
+        it('should return profile when loading succeeds', () => {
+            mockedLoadHsProfileFile.mockReturnValue(mockProfile);
+            const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
+            expect(result).toEqual(mockProfile);
+            expect(mockedLoadHsProfileFile).toHaveBeenCalledWith(path.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 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(exitIfUsingProfiles(mockProjectConfig, mockProjectDir)).rejects.toThrow(`Process.exit called with code ${EXIT_CODES.ERROR}`);
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
+            expect(mockExit).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+    });
+});

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

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

package/lib/__tests__/sandboxSync.test.js

@@ -0,0 +1,126 @@
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { initiateSync } from '@hubspot/local-dev-lib/api/sandboxSync';
+import { getAccountId } from '@hubspot/local-dev-lib/config';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { mockHubSpotHttpError } from '../testUtils.js';
+import { getAvailableSyncTypes } from '../sandboxes.js';
+import { syncSandbox } from '../sandboxSync.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+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;
+const mockedInitiateSync = initiateSync;
+const mockedGetAccountId = getAccountId;
+const mockedGetAvailableSyncTypes = getAvailableSyncTypes;
+const mockedSpinniesInit = SpinniesManager.init;
+const mockedSpinniesAdd = SpinniesManager.add;
+const mockedSpinniesSucceed = SpinniesManager.succeed;
+const mockedSpinniesFail = SpinniesManager.fail;
+describe('lib/sandboxSync', () => {
+    const mockEnv = 'qa';
+    const mockParentAccount = {
+        name: 'Parent Account',
+        portalId: 123,
+        accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+        env: mockEnv,
+    };
+    const mockChildAccount = {
+        name: 'Child Account',
+        portalId: 456,
+        accountType: 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 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 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(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toThrow(errorRegex);
+        });
+        it('handles sync in progress error', async () => {
+            const error = mockHubSpotHttpError('', {
+                status: 429,
+                data: {
+                    category: 'RATE_LIMITS',
+                    subCategory: 'sandboxes-sync-api.SYNC_IN_PROGRESS',
+                },
+            });
+            mockedInitiateSync.mockRejectedValue(error);
+            await expect(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 = mockHubSpotHttpError('', {
+                status: 403,
+                data: {
+                    category: 'BANNED',
+                    subCategory: 'sandboxes-sync-api.SYNC_NOT_ALLOWED_INVALID_USER',
+                },
+            });
+            mockedInitiateSync.mockRejectedValue(error);
+            await expect(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 = mockHubSpotHttpError('', {
+                status: 403,
+                data: {
+                    category: 'BANNED',
+                    subCategory: 'sandboxes-sync-api.SYNC_NOT_ALLOWED_INVALID_USERID',
+                },
+            });
+            mockedInitiateSync.mockRejectedValue(error);
+            await expect(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 = mockHubSpotHttpError('', {
+                status: 404,
+                data: {
+                    category: 'OBJECT_NOT_FOUND',
+                    subCategory: 'SandboxErrors.SANDBOX_NOT_FOUND',
+                },
+            });
+            mockedInitiateSync.mockRejectedValue(error);
+            await expect(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 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,146 @@
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
+import { fetchTypes } from '@hubspot/local-dev-lib/api/sandboxSync';
+import { getAccountId, getConfigAccounts } from '@hubspot/local-dev-lib/config';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { mockHubSpotHttpError } from '../testUtils.js';
+import { getSandboxTypeAsString, getHasSandboxesByType, getAvailableSyncTypes, validateSandboxUsageLimits, handleSandboxCreateError, } from '../sandboxes.js';
+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 = getAccountId;
+const mockedGetSandboxUsageLimits = getSandboxUsageLimits;
+const mockedFetchTypes = fetchTypes;
+const mockedGetConfigAccounts = getConfigAccounts;
+const mockedLogger = logger;
+describe('lib/sandboxes', () => {
+    describe('getSandboxTypeAsString()', () => {
+        it('returns "development" for development sandbox type', () => {
+            expect(getSandboxTypeAsString(HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe('development');
+        });
+        it('returns "standard" for standard sandbox type', () => {
+            expect(getSandboxTypeAsString(HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX)).toBe('standard');
+        });
+        it('returns "standard" for undefined input', () => {
+            expect(getSandboxTypeAsString(undefined)).toBe('standard');
+        });
+    });
+    describe('getHasSandboxesByType()', () => {
+        const mockParentAccount = {
+            name: 'Parent Account',
+            portalId: 123,
+            authType: undefined,
+            accountType: 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: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+                },
+            ]);
+            expect(getHasSandboxesByType(mockParentAccount, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(true);
+        });
+        it('returns false when no sandbox of specified type exists', () => {
+            mockedGetConfigAccounts.mockReturnValue([mockParentAccount]);
+            expect(getHasSandboxesByType(mockParentAccount, 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 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(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(validateSandboxUsageLimits(mockAccount, 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(validateSandboxUsageLimits(mockAccount, 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 = mockHubSpotHttpError('missing scopes error', {
+                status: 403,
+                data: {
+                    message: 'Missing scopes error',
+                    category: 'MISSING_SCOPES',
+                },
+            });
+            expect(() => 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 = mockHubSpotHttpError('user access not allowed error', {
+                status: 403,
+                data: {
+                    category: 'BANNED',
+                    subCategory: 'SandboxErrors.USER_ACCESS_NOT_ALLOWED',
+                },
+            });
+            expect(() => 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 = mockHubSpotHttpError('403 gating error', {
+                status: 403,
+                data: {
+                    category: 'BANNED',
+                    subCategory: 'SandboxErrors.DEVELOPMENT_SANDBOX_ACCESS_NOT_ALLOWED',
+                },
+            });
+            expect(() => 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,149 @@
+import mockStdIn from 'mock-stdin';
+import { outputLogs } from '../ui/serverlessFunctionLogs.js';
+import { tailLogs } from '../serverlessLogs.js';
+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 = mockStdIn.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 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 tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            vi.runOnlyPendingTimers();
+            expect(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 tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            vi.runOnlyPendingTimers();
+            expect(tailCall).toHaveBeenCalledTimes(2);
+        });
+    });
+});

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

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