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

package/lib/__tests__/oauth.test.js

@@ -0,0 +1,109 @@
+import express from 'express';
+import open from 'open';
+import { OAuth2Manager } from '@hubspot/local-dev-lib/models/OAuth2Manager';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
+import { addOauthToAccountConfig } from '@hubspot/local-dev-lib/oauth';
+import { uiLogger } from '../ui/logger.js';
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
+import { DEFAULT_OAUTH_SCOPES } from '@hubspot/local-dev-lib/constants/auth';
+import { authenticateWithOauth } from '../oauth.js';
+vi.mock('express');
+vi.mock('open');
+vi.mock('@hubspot/local-dev-lib/models/OAuth2Manager');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/oauth');
+const mockedExpress = express;
+const mockedOAuth2Manager = OAuth2Manager;
+const mockedGetConfigAccountById = getConfigAccountById;
+describe('lib/oauth', () => {
+    const mockExpressReq = {
+        query: { code: 'test-auth-code' },
+    };
+    const mockExpressResp = { send: vi.fn() };
+    const mockAccountConfig = {
+        name: 'test-account',
+        accountId: 123,
+        authType: 'oauth2',
+        env: ENVIRONMENTS.PROD,
+        auth: {
+            clientId: 'test-client-id',
+            clientSecret: 'test-client-secret',
+            scopes: ['test-scope'],
+        },
+    };
+    beforeEach(() => {
+        mockedExpress.mockReturnValue({
+            get: vi.fn().mockImplementation((path, callback) => {
+                if (path === '/oauth-callback') {
+                    callback(mockExpressReq, mockExpressResp);
+                }
+            }),
+            listen: vi.fn().mockReturnValue({ close: vi.fn() }),
+        });
+    });
+    describe('authenticateWithOauth()', () => {
+        it('should setup OAuth and authenticate successfully', async () => {
+            // Mock successful OAuth flow
+            const mockOAuth2Manager = {
+                account: mockAccountConfig,
+                exchangeForTokens: vi.fn().mockResolvedValue({}),
+            };
+            mockedOAuth2Manager.mockImplementation(() => mockOAuth2Manager);
+            mockedGetConfigAccountById.mockReturnValue({
+                env: ENVIRONMENTS.PROD,
+            });
+            await authenticateWithOauth(mockAccountConfig);
+            // Verify OAuth2Manager was initialized correctly
+            expect(mockedOAuth2Manager).toHaveBeenCalledWith({
+                ...mockAccountConfig,
+                env: ENVIRONMENTS.PROD,
+            });
+            // Verify logger was called
+            expect(uiLogger.log).toHaveBeenCalledWith('Authorizing');
+            // Verify OAuth tokens were added to config
+            expect(addOauthToAccountConfig).toHaveBeenCalledWith(mockOAuth2Manager);
+        });
+        it('should handle missing clientId', async () => {
+            const invalidConfig = {
+                ...mockAccountConfig,
+                auth: {
+                    ...mockAccountConfig.auth,
+                    clientId: undefined,
+                },
+            };
+            mockedOAuth2Manager.mockImplementation(() => ({
+                account: invalidConfig,
+            }));
+            // @ts-expect-error Testing invalid config
+            await expect(authenticateWithOauth(invalidConfig)).rejects.toThrow();
+        });
+        it('should use default scopes when none provided', async () => {
+            const configWithoutScopes = {
+                ...mockAccountConfig,
+                auth: {
+                    ...mockAccountConfig.auth,
+                    scopes: [],
+                },
+            };
+            const mockOAuth2Manager = {
+                account: configWithoutScopes,
+                exchangeForTokens: vi.fn().mockResolvedValue({}),
+            };
+            mockedOAuth2Manager.mockImplementation(() => mockOAuth2Manager);
+            await authenticateWithOauth(configWithoutScopes);
+            // Verify default scopes were used
+            expect(open).toHaveBeenCalledWith(expect.stringContaining(encodeURIComponent(DEFAULT_OAUTH_SCOPES.join(' '))), expect.anything());
+        });
+        it('should handle OAuth exchange failure', async () => {
+            const mockOAuth2Manager = {
+                account: mockAccountConfig,
+                exchangeForTokens: vi
+                    .fn()
+                    .mockRejectedValue(new Error('Exchange failed')),
+            };
+            mockedOAuth2Manager.mockImplementation(() => mockOAuth2Manager);
+            await authenticateWithOauth(mockAccountConfig);
+            expect(mockExpressResp.send).toHaveBeenCalledWith(expect.stringContaining('Authorization failed'));
+        });
+    });
+});

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

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

package/lib/__tests__/parsing.test.js

@@ -0,0 +1,34 @@
+import { parseStringToNumber } from '../parsing.js';
+describe('lib/parsing', () => {
+    describe('parseStringToNumber', () => {
+        it('should parse valid integer strings', () => {
+            expect(parseStringToNumber('123')).toBe(123);
+            expect(parseStringToNumber('0')).toBe(0);
+            expect(parseStringToNumber('-456')).toBe(-456);
+            expect(parseStringToNumber('999')).toBe(999);
+        });
+        it('should parse strings with leading zeros', () => {
+            expect(parseStringToNumber('007')).toBe(7);
+            expect(parseStringToNumber('0123')).toBe(123);
+        });
+        it('should throw error for strings with leading whitespace', () => {
+            expect(() => parseStringToNumber('  42')).toThrow('Unable to parse string to number');
+            expect(() => parseStringToNumber('\t123')).toThrow('Unable to parse string to number');
+        });
+        it('should throw error for invalid number strings', () => {
+            expect(() => parseStringToNumber('abc')).toThrow('Unable to parse string to number');
+            expect(() => parseStringToNumber('')).toThrow('Unable to parse string to number');
+            expect(() => parseStringToNumber('NaN')).toThrow('Unable to parse string to number');
+        });
+        it('should throw error for strings with non-numeric characters', () => {
+            expect(() => parseStringToNumber('123abc')).toThrow('Unable to parse string to number');
+            expect(() => parseStringToNumber('456def')).toThrow('Unable to parse string to number');
+            expect(() => parseStringToNumber('12.34')).toThrow('Unable to parse string to number');
+        });
+        it('should throw error for strings with mixed content', () => {
+            expect(() => parseStringToNumber('123 456')).toThrow('Unable to parse string to number');
+            expect(() => parseStringToNumber('1,234')).toThrow('Unable to parse string to number');
+            expect(() => parseStringToNumber('1.23e4')).toThrow('Unable to parse string to number');
+        });
+    });
+});

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

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

package/lib/__tests__/polling.test.js

@@ -0,0 +1,76 @@
+import { poll, DEFAULT_POLLING_STATES } from '../polling.js';
+import { DEFAULT_POLLING_DELAY } from '../constants.js';
+// Helper to create a mock polling callback
+const createMockCallback = (responses) => {
+    let callCount = 0;
+    return vi.fn(() => {
+        const response = responses[callCount];
+        callCount++;
+        return Promise.resolve({ data: response });
+    });
+};
+describe('lib/polling', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    describe('poll()', () => {
+        it('should resolve when status is SUCCESS', async () => {
+            const mockCallback = createMockCallback([
+                { status: DEFAULT_POLLING_STATES.STARTED },
+                { status: DEFAULT_POLLING_STATES.SUCCESS },
+            ]);
+            const pollPromise = poll(mockCallback);
+            // Fast-forward through two polling intervals
+            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY * 2);
+            const result = await pollPromise;
+            expect(result.status).toBe(DEFAULT_POLLING_STATES.SUCCESS);
+            expect(mockCallback).toHaveBeenCalledTimes(2);
+        });
+        it('should reject when status is ERROR', async () => {
+            const mockCallback = createMockCallback([
+                { status: DEFAULT_POLLING_STATES.STARTED },
+                { status: DEFAULT_POLLING_STATES.ERROR },
+            ]);
+            const pollPromise = poll(mockCallback);
+            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY * 2);
+            await expect(pollPromise).rejects.toEqual({
+                status: DEFAULT_POLLING_STATES.ERROR,
+            });
+            expect(mockCallback).toHaveBeenCalledTimes(2);
+        });
+        it('should reject when status is FAILURE', async () => {
+            const mockCallback = createMockCallback([
+                { status: DEFAULT_POLLING_STATES.STARTED },
+                { status: DEFAULT_POLLING_STATES.FAILURE },
+            ]);
+            const pollPromise = poll(mockCallback);
+            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY * 2);
+            await expect(pollPromise).rejects.toEqual({
+                status: DEFAULT_POLLING_STATES.FAILURE,
+            });
+        });
+        it('should reject when status is REVERTED', async () => {
+            const mockCallback = createMockCallback([
+                { status: DEFAULT_POLLING_STATES.STARTED },
+                { status: DEFAULT_POLLING_STATES.REVERTED },
+            ]);
+            const pollPromise = poll(mockCallback);
+            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY * 2);
+            await expect(pollPromise).rejects.toEqual({
+                status: DEFAULT_POLLING_STATES.REVERTED,
+            });
+        });
+        it('should reject when callback throws an error', async () => {
+            const mockCallback = vi
+                .fn()
+                .mockRejectedValue(new Error('Network error'));
+            const pollPromise = poll(mockCallback);
+            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY);
+            await expect(pollPromise).rejects.toThrow('Network error');
+            expect(mockCallback).toHaveBeenCalledTimes(1);
+        });
+    });
+});

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

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

package/lib/__tests__/process.test.js

@@ -0,0 +1,89 @@
+import readline from 'readline';
+import { uiLogger } from '../ui/logger.js';
+import { setLogLevel, LOG_LEVEL } from '@hubspot/local-dev-lib/logger';
+import { handleExit, handleKeypress, TERMINATION_SIGNALS } from '../process.js';
+vi.mock('readline');
+vi.mock('@hubspot/local-dev-lib/logger', async () => {
+    const logger = await vi.importActual('@hubspot/local-dev-lib/logger');
+    return { ...logger, setLogLevel: vi.fn() };
+});
+const mockedReadline = readline;
+const mockedUiLogger = uiLogger;
+const mockedSetLogLevel = setLogLevel;
+const processRemoveListenerSpy = vi.spyOn(process, 'removeAllListeners');
+const processOnSpy = vi.spyOn(process, 'on');
+describe('lib/process', () => {
+    describe('handleExit()', () => {
+        const mockCallback = vi.fn();
+        it('should set up listeners for all termination signals', () => {
+            handleExit(mockCallback);
+            TERMINATION_SIGNALS.forEach(signal => {
+                expect(processRemoveListenerSpy).toHaveBeenCalledWith(signal);
+                expect(processOnSpy).toHaveBeenCalledWith(signal, expect.any(Function));
+            });
+        });
+        it('should handle SIGHUP signal correctly', async () => {
+            handleExit(mockCallback);
+            // Get the callback function passed to process.on for SIGHUP
+            const sighupCallback = processOnSpy.mock.calls.find(call => call[0] === 'SIGHUP')?.[1];
+            expect(sighupCallback).toBeDefined();
+            sighupCallback();
+            expect(mockedSetLogLevel).toHaveBeenCalledWith(LOG_LEVEL.NONE);
+            expect(mockCallback).toHaveBeenCalledWith({ isSIGHUP: true });
+            expect(mockedUiLogger.debug).toHaveBeenCalledWith(expect.stringContaining('SIGHUP'));
+        });
+        it('should handle non-SIGHUP signals correctly', async () => {
+            handleExit(mockCallback);
+            // Get the callback function passed to process.on for SIGINT
+            const sigintCallback = processOnSpy.mock.calls.find(call => call[0] === 'SIGINT')?.[1];
+            expect(sigintCallback).toBeDefined();
+            sigintCallback();
+            expect(mockedSetLogLevel).not.toHaveBeenCalled();
+            expect(mockCallback).toHaveBeenCalledWith({ isSIGHUP: false });
+            expect(mockedUiLogger.debug).toHaveBeenCalledWith(expect.stringContaining('SIGINT'));
+        });
+        it('should prevent duplicate exit handling', async () => {
+            handleExit(mockCallback);
+            // Get the callback function passed to process.on for SIGINT
+            const sigintCallback = processOnSpy.mock.calls.find(call => call[0] === 'SIGINT')?.[1];
+            expect(sigintCallback).toBeDefined();
+            sigintCallback();
+            sigintCallback(); // Second call should be ignored
+            expect(mockCallback).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('handleKeypress()', () => {
+        const mockCallback = vi.fn();
+        it('should set up keypress handling correctly', () => {
+            // Mock process.stdin
+            Object.defineProperty(process, 'stdin', {
+                value: {
+                    isTTY: true,
+                    setRawMode: vi.fn(),
+                    on: vi.fn(),
+                    removeAllListeners: vi.fn(),
+                },
+            });
+            mockedReadline.createInterface.mockReturnValue({});
+            mockedReadline.emitKeypressEvents.mockImplementation(() => { });
+            handleKeypress(mockCallback);
+            expect(mockedReadline.createInterface).toHaveBeenCalledWith(process.stdin, process.stdout);
+            expect(mockedReadline.emitKeypressEvents).toHaveBeenCalledWith(process.stdin);
+            expect(process.stdin.setRawMode).toHaveBeenCalledWith(true);
+            expect(process.stdin.removeAllListeners).toHaveBeenCalledWith('keypress');
+            expect(process.stdin.on).toHaveBeenCalledWith('keypress', expect.any(Function));
+        });
+        it('should not set raw mode when stdin is not TTY', () => {
+            // Mock process.stdin as non-TTY
+            Object.defineProperty(process, 'stdin', {
+                value: {
+                    isTTY: false,
+                    on: vi.fn(),
+                    removeAllListeners: vi.fn(),
+                },
+            });
+            handleKeypress(mockCallback);
+            expect(process.stdin.setRawMode).toBeUndefined();
+        });
+    });
+});

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

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

package/lib/__tests__/sandboxes.test.js

@@ -0,0 +1,128 @@
+import { uiLogger } from '../ui/logger.js';
+import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
+import { getAllConfigAccounts, getConfigAccountIfExists, } 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, validateSandboxUsageLimits, handleSandboxCreateError, } from '../sandboxes.js';
+import { isMissingScopeError, isSpecifiedError, } from '@hubspot/local-dev-lib/errors/index';
+vi.mock('@hubspot/local-dev-lib/api/sandboxHubs');
+vi.mock('@hubspot/local-dev-lib/api/sandboxSync');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/errors/index');
+const mockedGetConfigAccountIfExists = getConfigAccountIfExists;
+const mockedGetSandboxUsageLimits = getSandboxUsageLimits;
+const mockedGetAllConfigAccounts = getAllConfigAccounts;
+const mockedUiLogger = uiLogger;
+const mockedIsMissingScopeError = isMissingScopeError;
+const mockedIsSpecifiedError = isSpecifiedError;
+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',
+            accountId: 123,
+            accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+            env: 'qa',
+        };
+        it('returns true when sandbox of specified type exists', () => {
+            mockedGetConfigAccountIfExists.mockReturnValue(mockParentAccount);
+            mockedGetAllConfigAccounts.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', () => {
+            mockedGetAllConfigAccounts.mockReturnValue([mockParentAccount]);
+            expect(getHasSandboxesByType(mockParentAccount, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(false);
+        });
+    });
+    describe('validateSandboxUsageLimits()', () => {
+        const mockAccount = {
+            name: 'Test Account',
+            accountId: 123,
+            env: 'qa',
+        };
+        it('validates successfully when limits are not reached', async () => {
+            mockedGetConfigAccountIfExists.mockReturnValue(mockAccount.accountId);
+            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 () => {
+            mockedGetConfigAccountIfExists.mockReturnValue(mockAccount.accountId);
+            mockedGetAllConfigAccounts.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 developer sandboxes/);
+        });
+    });
+    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',
+                },
+            });
+            // Mock the error checking function to return true for missing scope error
+            mockedIsMissingScopeError.mockReturnValue(true);
+            mockedIsSpecifiedError.mockReturnValue(false);
+            expect(() => handleSandboxCreateError(error, mockEnv, mockName, mockAccountId)).toThrow(error);
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/The personal access key you provided doesn't include sandbox permissions/));
+            expect(mockedUiLogger.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',
+                },
+            });
+            // Mock the error checking function to return true for this error type
+            mockedIsMissingScopeError.mockReturnValue(false);
+            mockedIsSpecifiedError.mockReturnValue(true);
+            expect(() => handleSandboxCreateError(error, mockEnv, mockName, mockAccountId)).toThrow(error);
+            expect(mockedUiLogger.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',
+                },
+            });
+            // Mock the error checking function to return true for this error type
+            mockedIsMissingScopeError.mockReturnValue(false);
+            mockedIsSpecifiedError.mockReturnValue(true);
+            expect(() => handleSandboxCreateError(error, mockEnv, mockName, mockAccountId)).toThrow(error);
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Couldn't create.*because your account has been removed from.*or your permission set doesn't allow you to create/));
+        });
+    });
+});

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

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

package/lib/__tests__/serverlessLogs.test.js

@@ -0,0 +1,163 @@
+import { outputLogs } from '../ui/serverlessFunctionLogs.js';
+import { tailLogs } from '../serverlessLogs.js';
+import { handleKeypress } from '../process.js';
+vi.mock('../ui/serverlessFunctionLogs');
+vi.mock('../ui/SpinniesManager', () => ({
+    default: {
+        init: vi.fn(),
+        add: vi.fn(),
+        remove: vi.fn(),
+        succeed: vi.fn(),
+        fail: vi.fn(),
+        stopAll: vi.fn(),
+    },
+}));
+vi.mock('../process');
+vi.useFakeTimers();
+const ACCOUNT_ID = 123;
+function terminateTailLogs() {
+    const keypressCallback = vi.mocked(handleKeypress).mock.calls[0][0];
+    keypressCallback({ name: 'q' });
+}
+describe('lib/serverlessLogs', () => {
+    describe('tailLogs()', () => {
+        afterEach(() => {
+            vi.clearAllTimers();
+            vi.clearAllMocks();
+        });
+        it('calls tailCall() to get the next results', async () => {
+            const compact = false;
+            const fetchLatest = vi.fn(() => 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: {},
+                // eslint-disable-next-line
+                config: { headers: {} },
+            }));
+            const tailCall = vi.fn(() => Promise.resolve({
+                data: {
+                    results: [],
+                    paging: {
+                        next: {
+                            after: 'somehash',
+                        },
+                    },
+                },
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                // eslint-disable-next-line
+                config: { headers: {} },
+            }));
+            // @ts-ignore - headers is not used in the actual function and does not need to be mocked
+            const tailPromise = tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            await vi.advanceTimersByTimeAsync(0);
+            expect(fetchLatest).toHaveBeenCalled();
+            expect(tailCall).toHaveBeenCalledTimes(1);
+            await vi.advanceTimersByTimeAsync(5000);
+            expect(tailCall).toHaveBeenCalledTimes(2);
+            terminateTailLogs();
+            await tailPromise;
+        });
+        it('outputs results', async () => {
+            const compact = false;
+            const fetchLatest = vi.fn(() => 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: {},
+                // eslint-disable-next-line
+                config: { headers: {} },
+            }));
+            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,
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                // eslint-disable-next-line
+                config: { headers: {} },
+            }));
+            // @ts-ignore - headers is not used in the actual function and does not need to be mocked
+            const tailPromise = tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            await vi.advanceTimersByTimeAsync(0);
+            expect(outputLogs).toHaveBeenCalledWith(latestLogResponse, expect.objectContaining({ compact }));
+            expect(tailCall).toHaveBeenCalledTimes(1);
+            await vi.advanceTimersByTimeAsync(5000);
+            expect(tailCall).toHaveBeenCalledTimes(2);
+            terminateTailLogs();
+            await tailPromise;
+        });
+        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);
+            expect(tailCall).toHaveBeenCalledTimes(1);
+        });
+    });
+});

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

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