@hubspot/cli 8.0.11-experimental.0 → 8.0.11-experimental.2

package/lib/__tests__/oauth.test.js

@@ -1,109 +0,0 @@
-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

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

package/lib/__tests__/parsing.test.js

@@ -1,34 +0,0 @@
-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

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

package/lib/__tests__/polling.test.js

@@ -1,76 +0,0 @@
-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

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

package/lib/__tests__/process.test.js

@@ -1,89 +0,0 @@
-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

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

package/lib/__tests__/sandboxes.test.js

@@ -1,128 +0,0 @@
-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

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

package/lib/__tests__/serverlessLogs.test.js

@@ -1,163 +0,0 @@
-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

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