@quantum-ai/gemini-cli 0.45.8 → 0.45.10

package/dist/test-utils/async.js

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { act } from 'react';
+import { vi } from 'vitest';
+// The waitFor from vitest doesn't properly wrap in act(), so we have to
+// implement our own like the one in @testing-library/react
+// or @testing-library/react-native
+// The version of waitFor from vitest is still fine to use if you aren't waiting
+// for React state updates.
+export async function waitFor(assertion, { timeout = 2000, interval = 50 } = {}) {
+    const startTime = Date.now();
+    while (true) {
+        try {
+            await assertion();
+            return;
+        }
+        catch (error) {
+            if (Date.now() - startTime > timeout) {
+                throw error;
+            }
+            await act(async () => {
+                if (vi.isFakeTimers()) {
+                    await vi.advanceTimersByTimeAsync(interval);
+                }
+                else {
+                    await new Promise((resolve) => setTimeout(resolve, interval));
+                }
+            });
+        }
+    }
+}

package/dist/test-utils/createExtension.js

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { EXTENSIONS_CONFIG_FILENAME, INSTALL_METADATA_FILENAME, } from '../config/extensions/variables.js';
+export function createExtension({ extensionsDir = 'extensions-dir', name = 'my-extension', version = '1.0.0', addContextFile = false, contextFileName = undefined, mcpServers = {}, installMetadata = undefined, settings = undefined, themes = undefined, } = {}) {
+    const extDir = path.join(extensionsDir, name);
+    fs.mkdirSync(extDir, { recursive: true });
+    fs.writeFileSync(path.join(extDir, EXTENSIONS_CONFIG_FILENAME), JSON.stringify({
+        name,
+        version,
+        contextFileName,
+        mcpServers,
+        settings,
+        themes,
+    }));
+    if (addContextFile) {
+        fs.writeFileSync(path.join(extDir, 'GEMINI.md'), 'context');
+    }
+    if (contextFileName) {
+        fs.writeFileSync(path.join(extDir, contextFileName), 'context');
+    }
+    if (installMetadata) {
+        fs.writeFileSync(path.join(extDir, INSTALL_METADATA_FILENAME), JSON.stringify(installMetadata));
+    }
+    return extDir;
+}

package/dist/test-utils/customMatchers.js

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/// <reference types="vitest/globals" />
+import { expect } from 'vitest';
+import path from 'node:path';
+import stripAnsi from 'strip-ansi';
+// RegExp to detect invalid characters: backspace, and ANSI escape codes
+// eslint-disable-next-line no-control-regex
+const invalidCharsRegex = /[\b\x1b]/;
+const callCountByTest = new Map();
+export async function toMatchSvgSnapshot(renderInstance, options) {
+    const currentTestName = expect.getState().currentTestName;
+    if (!currentTestName) {
+        throw new Error('toMatchSvgSnapshot must be called within a test');
+    }
+    const testPath = expect.getState().testPath;
+    if (!testPath) {
+        throw new Error('toMatchSvgSnapshot requires testPath');
+    }
+    let textContent;
+    if (renderInstance.lastFrameRaw) {
+        textContent = renderInstance.lastFrameRaw({
+            allowEmpty: options?.allowEmpty,
+        });
+    }
+    else if (renderInstance.lastFrame) {
+        textContent = renderInstance.lastFrame({ allowEmpty: options?.allowEmpty });
+    }
+    else {
+        throw new Error('toMatchSvgSnapshot requires a renderInstance with either lastFrameRaw or lastFrame');
+    }
+    const svgContent = renderInstance.generateSvg();
+    const sanitize = (name) => name.replace(/[^a-zA-Z0-9_-]/g, '-').replace(/-+/g, '-');
+    const testId = testPath + ':' + currentTestName;
+    let count = callCountByTest.get(testId) ?? 0;
+    count++;
+    callCountByTest.set(testId, count);
+    const snapshotName = options?.name ??
+        (count > 1 ? `${currentTestName}-${count}` : currentTestName);
+    const svgFileName = sanitize(path.basename(testPath).replace(/\.test\.tsx?$/, '')) +
+        '-' +
+        sanitize(snapshotName) +
+        '.snap.svg';
+    const svgDir = path.join(path.dirname(testPath), '__snapshots__');
+    const svgFilePath = path.join(svgDir, svgFileName);
+    // Assert the text matches standard snapshot, stripping ANSI for stability
+    expect(stripAnsi(textContent)).toMatchSnapshot();
+    // Assert the SVG matches the file snapshot
+    await expect(svgContent).toMatchFileSnapshot(svgFilePath);
+    return { pass: true, message: () => '' };
+}
+function toHaveOnlyValidCharacters(buffer) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const { isNot } = this;
+    let pass = true;
+    const invalidLines = [];
+    for (let i = 0; i < buffer.lines.length; i++) {
+        const line = buffer.lines[i];
+        if (line.includes('\n')) {
+            pass = false;
+            invalidLines.push({ line: i, content: line });
+            break; // Fail fast on newlines
+        }
+        if (invalidCharsRegex.test(line)) {
+            pass = false;
+            invalidLines.push({ line: i, content: line });
+        }
+    }
+    return {
+        pass,
+        message: () => `Expected buffer ${isNot ? 'not ' : ''}to have only valid characters, but found invalid characters in lines:\n${invalidLines
+            .map((l) => `  [${l.line}]: "${l.content}"`) /* This line was changed */
+            .join('\n')}`,
+        actual: buffer.lines,
+        expected: 'Lines with no line breaks, backspaces, or escape codes.',
+    };
+}
+expect.extend({
+    toHaveOnlyValidCharacters,
+    toMatchSvgSnapshot,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+});

package/dist/test-utils/mockCommandContext.js

@@ -0,0 +1,102 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { vi } from 'vitest';
+import { mergeSettings } from '../config/settings.js';
+/**
+ * Creates a deep, fully-typed mock of the CommandContext for use in tests.
+ * All functions are pre-mocked with `vi.fn()`.
+ *
+ * @param overrides - A deep partial object to override any default mock values.
+ * @returns A complete, mocked CommandContext object.
+ */
+export const createMockCommandContext = (overrides = {}) => {
+    const defaultMergedSettings = mergeSettings({}, {}, {}, {}, true);
+    const defaultMocks = {
+        invocation: {
+            raw: '',
+            name: '',
+            args: '',
+        },
+        services: {
+            agentContext: null,
+            settings: {
+                merged: defaultMergedSettings,
+                setValue: vi.fn(),
+                forScope: vi.fn().mockReturnValue({ settings: {} }),
+            },
+            git: undefined,
+            logger: {
+                log: vi.fn(),
+                logMessage: vi.fn(),
+                saveCheckpoint: vi.fn(),
+                loadCheckpoint: vi.fn().mockResolvedValue([]),
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }, // Cast because Logger is a class.
+        },
+        ui: {
+            addItem: vi.fn(),
+            clear: vi.fn(),
+            setDebugMessage: vi.fn(),
+            pendingItem: null,
+            setPendingItem: vi.fn(),
+            loadHistory: vi.fn(),
+            toggleCorgiMode: vi.fn(),
+            toggleShortcutsHelp: vi.fn(),
+            toggleVimEnabled: vi.fn(),
+            reloadCommands: vi.fn(),
+            openAgentConfigDialog: vi.fn(),
+            closeAgentConfigDialog: vi.fn(),
+            extensionsUpdateState: new Map(),
+            setExtensionsUpdateState: vi.fn(),
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        },
+        session: {
+            sessionShellAllowlist: new Set(),
+            stats: {
+                sessionStartTime: new Date(),
+                lastPromptTokenCount: 0,
+                metrics: {
+                    models: {},
+                    tools: {
+                        totalCalls: 0,
+                        totalSuccess: 0,
+                        totalFail: 0,
+                        totalDurationMs: 0,
+                        totalDecisions: { accept: 0, reject: 0, modify: 0 },
+                        byName: {},
+                    },
+                },
+            },
+        },
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const merge = (target, source) => {
+        const output = { ...target };
+        for (const key in source) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+                const sourceValue = source[key];
+                const targetValue = output[key];
+                if (
+                // We only want to recursively merge plain objects
+                Object.prototype.toString.call(sourceValue) === '[object Object]' &&
+                    Object.prototype.toString.call(targetValue) === '[object Object]') {
+                    output[key] = merge(targetValue, sourceValue);
+                }
+                else {
+                    // If not, we do a direct assignment. This preserves Date objects and others.
+                    output[key] = sourceValue;
+                }
+            }
+        }
+        return output;
+    };
+    const merged = merge(defaultMocks, overrides);
+    const isCommandContext = (val) => typeof val === 'object' && val !== null;
+    if (isCommandContext(merged)) {
+        return merged;
+    }
+    throw new Error('Unreachable');
+};

package/dist/test-utils/mockConfig.js

@@ -0,0 +1,202 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { vi } from 'vitest';
+import { NoopSandboxManager } from '@google/gemini-cli-core';
+import { createTestMergedSettings, } from '../config/settings.js';
+/**
+ * Creates a mocked Config object with default values and allows overrides.
+ */
+export const createMockConfig = (overrides = {}) => ({
+    getSandbox: vi.fn(() => undefined),
+    getQuestion: vi.fn(() => ''),
+    isInteractive: vi.fn(() => false),
+    isInitialized: vi.fn(() => true),
+    setTerminalBackground: vi.fn(),
+    storage: {
+        getProjectTempDir: vi.fn().mockReturnValue('/tmp/gemini-test'),
+        initialize: vi.fn().mockResolvedValue(undefined),
+    },
+    getDebugMode: vi.fn(() => false),
+    getProjectRoot: vi.fn(() => '/'),
+    refreshAuth: vi.fn().mockResolvedValue(undefined),
+    getRemoteAdminSettings: vi.fn(() => undefined),
+    initialize: vi.fn().mockResolvedValue(undefined),
+    getPolicyEngine: vi.fn(() => ({})),
+    getMessageBus: vi.fn(() => ({ subscribe: vi.fn() })),
+    getHookSystem: vi.fn(() => ({
+        fireSessionEndEvent: vi.fn().mockResolvedValue(undefined),
+        fireSessionStartEvent: vi.fn().mockResolvedValue(undefined),
+    })),
+    isAutoMemoryEnabled: vi.fn(() => false),
+    getListExtensions: vi.fn(() => false),
+    getExtensions: vi.fn(() => []),
+    getListSessions: vi.fn(() => false),
+    getDeleteSession: vi.fn(() => undefined),
+    setSessionId: vi.fn(),
+    resetNewSessionState: vi.fn(),
+    getSessionId: vi.fn().mockReturnValue('mock-session-id'),
+    getWorktreeSettings: vi.fn(() => undefined),
+    getContentGeneratorConfig: vi.fn(() => ({ authType: 'google' })),
+    getAcpMode: vi.fn(() => false),
+    isBrowserLaunchSuppressed: vi.fn(() => false),
+    setRemoteAdminSettings: vi.fn(),
+    isYoloModeDisabled: vi.fn(() => false),
+    isPlanEnabled: vi.fn(() => false),
+    getPlanModeRoutingEnabled: vi.fn().mockResolvedValue(true),
+    getApprovedPlanPath: vi.fn(() => undefined),
+    getCoreTools: vi.fn(() => []),
+    getAllowedTools: vi.fn(() => []),
+    getApprovalMode: vi.fn(() => 'default'),
+    getFileFilteringRespectGitIgnore: vi.fn(() => true),
+    getOutputFormat: vi.fn(() => 'text'),
+    getUsageStatisticsEnabled: vi.fn(() => true),
+    getScreenReader: vi.fn(() => false),
+    getGeminiMdFileCount: vi.fn(() => 0),
+    getDeferredCommand: vi.fn(() => undefined),
+    getFileSystemService: vi.fn(() => ({})),
+    clientVersion: '1.0.0',
+    getModel: vi.fn().mockReturnValue('gemini-pro'),
+    getWorkingDir: vi.fn().mockReturnValue('/mock/cwd'),
+    getToolRegistry: vi.fn().mockReturnValue({
+        getTools: vi.fn().mockReturnValue([]),
+        getAllTools: vi.fn().mockReturnValue([]),
+    }),
+    getAgentRegistry: vi.fn().mockReturnValue({}),
+    getPromptRegistry: vi.fn().mockReturnValue({}),
+    getResourceRegistry: vi.fn().mockReturnValue({}),
+    getSkillManager: vi.fn().mockReturnValue({
+        isAdminEnabled: vi.fn().mockReturnValue(false),
+    }),
+    getFileService: vi.fn().mockReturnValue({}),
+    getGitService: vi.fn().mockResolvedValue({}),
+    getUserMemory: vi.fn().mockReturnValue(''),
+    getSystemInstructionMemory: vi.fn().mockReturnValue(''),
+    getSessionMemory: vi.fn().mockReturnValue(''),
+    getGeminiMdFilePaths: vi.fn().mockReturnValue([]),
+    getShowMemoryUsage: vi.fn().mockReturnValue(false),
+    getAccessibility: vi.fn().mockReturnValue({}),
+    getTelemetryEnabled: vi.fn().mockReturnValue(false),
+    getTelemetryLogPromptsEnabled: vi.fn().mockReturnValue(false),
+    getTelemetryTracesEnabled: vi.fn().mockReturnValue(false),
+    getTelemetryOtlpEndpoint: vi.fn().mockReturnValue(''),
+    getTelemetryOtlpProtocol: vi.fn().mockReturnValue('grpc'),
+    getTelemetryTarget: vi.fn().mockReturnValue(''),
+    getTelemetryOutfile: vi.fn().mockReturnValue(undefined),
+    getTelemetryUseCollector: vi.fn().mockReturnValue(false),
+    getTelemetryUseCliAuth: vi.fn().mockReturnValue(false),
+    getGeminiClient: vi.fn().mockReturnValue({
+        isInitialized: vi.fn().mockReturnValue(true),
+    }),
+    updateSystemInstructionIfInitialized: vi.fn().mockResolvedValue(undefined),
+    getModelRouterService: vi.fn().mockReturnValue({}),
+    getModelAvailabilityService: vi.fn().mockReturnValue({}),
+    getEnableRecursiveFileSearch: vi.fn().mockReturnValue(true),
+    getFileFilteringEnableFuzzySearch: vi.fn().mockReturnValue(true),
+    getFileFilteringRespectGeminiIgnore: vi.fn().mockReturnValue(true),
+    getFileFilteringOptions: vi.fn().mockReturnValue({}),
+    getCustomExcludes: vi.fn().mockReturnValue([]),
+    getCheckpointingEnabled: vi.fn().mockReturnValue(false),
+    getProxy: vi.fn().mockReturnValue(undefined),
+    getBugCommand: vi.fn().mockReturnValue(undefined),
+    getExtensionManagement: vi.fn().mockReturnValue(true),
+    getExtensionLoader: vi.fn().mockReturnValue({}),
+    getEnabledExtensions: vi.fn().mockReturnValue([]),
+    getEnableExtensionReloading: vi.fn().mockReturnValue(false),
+    getDisableLLMCorrection: vi.fn().mockReturnValue(false),
+    getNoBrowser: vi.fn().mockReturnValue(false),
+    getAgentsSettings: vi.fn().mockReturnValue({}),
+    getSummarizeToolOutputConfig: vi.fn().mockReturnValue(undefined),
+    getIdeMode: vi.fn().mockReturnValue(false),
+    getFolderTrust: vi.fn().mockReturnValue(true),
+    isTrustedFolder: vi.fn().mockReturnValue(true),
+    getCompressionThreshold: vi.fn().mockResolvedValue(undefined),
+    getUserCaching: vi.fn().mockResolvedValue(false),
+    getNumericalRoutingEnabled: vi.fn().mockResolvedValue(false),
+    getClassifierThreshold: vi.fn().mockResolvedValue(undefined),
+    getBannerTextNoCapacityIssues: vi.fn().mockResolvedValue(''),
+    getBannerTextCapacityIssues: vi.fn().mockResolvedValue(''),
+    isInteractiveShellEnabled: vi.fn().mockReturnValue(false),
+    getDisableAlwaysAllow: vi.fn().mockReturnValue(false),
+    isSkillsSupportEnabled: vi.fn().mockReturnValue(false),
+    reloadSkills: vi.fn().mockResolvedValue(undefined),
+    reloadAgents: vi.fn().mockResolvedValue(undefined),
+    getUseRipgrep: vi.fn().mockReturnValue(false),
+    getEnableInteractiveShell: vi.fn().mockReturnValue(false),
+    getSkipNextSpeakerCheck: vi.fn().mockReturnValue(false),
+    getRetryFetchErrors: vi.fn().mockReturnValue(true),
+    getEnableShellOutputEfficiency: vi.fn().mockReturnValue(true),
+    getShellToolInactivityTimeout: vi.fn().mockReturnValue(300000),
+    getRequestTimeoutMs: vi.fn().mockReturnValue(undefined),
+    getShellExecutionConfig: vi.fn().mockReturnValue({
+        sandboxManager: new NoopSandboxManager(),
+        sanitizationConfig: {
+            allowedEnvironmentVariables: [],
+            blockedEnvironmentVariables: [],
+            enableEnvironmentVariableRedaction: false,
+        },
+    }),
+    setShellExecutionConfig: vi.fn(),
+    getEnableToolOutputTruncation: vi.fn().mockReturnValue(true),
+    getTruncateToolOutputThreshold: vi.fn().mockReturnValue(1000),
+    getTruncateToolOutputLines: vi.fn().mockReturnValue(100),
+    getNextCompressionTruncationId: vi.fn().mockReturnValue(1),
+    getUseWriteTodos: vi.fn().mockReturnValue(false),
+    getFileExclusions: vi.fn().mockReturnValue({}),
+    getEnableHooks: vi.fn().mockReturnValue(true),
+    getEnableHooksUI: vi.fn().mockReturnValue(true),
+    getMcpClientManager: vi.fn().mockReturnValue({
+        getMcpInstructions: vi.fn().mockReturnValue(''),
+        getMcpServers: vi.fn().mockReturnValue({}),
+        getLastError: vi.fn().mockReturnValue(undefined),
+    }),
+    setUserInteractedWithMcp: vi.fn(),
+    emitMcpDiagnostic: vi.fn(),
+    getEnableEventDrivenScheduler: vi.fn().mockReturnValue(false),
+    getAdminSkillsEnabled: vi.fn().mockReturnValue(false),
+    getDisabledSkills: vi.fn().mockReturnValue([]),
+    getExperimentalGemma: vi.fn().mockReturnValue(false),
+    getMemoryBoundaryMarkers: vi.fn().mockReturnValue(['.git']),
+    getTerminalBackground: vi.fn().mockReturnValue(undefined),
+    getEmbeddingModel: vi.fn().mockReturnValue('embedding-model'),
+    getQuotaErrorOccurred: vi.fn().mockReturnValue(false),
+    getMaxSessionTurns: vi.fn().mockReturnValue(100),
+    getExcludeTools: vi.fn().mockReturnValue(new Set()),
+    getAllowedMcpServers: vi.fn().mockReturnValue([]),
+    getBlockedMcpServers: vi.fn().mockReturnValue([]),
+    getExperiments: vi.fn().mockReturnValue(undefined),
+    getHasAccessToPreviewModel: vi.fn().mockReturnValue(false),
+    validatePathAccess: vi.fn().mockReturnValue(null),
+    getUseAlternateBuffer: vi.fn().mockReturnValue(false),
+    getUseTerminalBuffer: vi.fn().mockReturnValue(false),
+    getUseRenderProcess: vi.fn().mockReturnValue(false),
+    ...overrides,
+});
+/**
+ * Creates a mocked LoadedSettings object for tests.
+ */
+export function createMockSettings(overrides = {}) {
+    const merged = createTestMergedSettings(overrides['merged'] || {});
+    return {
+        system: { settings: {} },
+        systemDefaults: { settings: {} },
+        user: { settings: {} },
+        workspace: { settings: {} },
+        errors: [],
+        subscribe: vi.fn().mockReturnValue(() => { }),
+        getSnapshot: vi.fn().mockReturnValue({
+            system: { settings: {} },
+            systemDefaults: { settings: {} },
+            user: { settings: {} },
+            workspace: { settings: {} },
+            isTrusted: true,
+            errors: [],
+            merged,
+        }),
+        setValue: vi.fn(),
+        ...overrides,
+        merged,
+    };
+}

package/dist/test-utils/mockDebugLogger.js

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { vi } from 'vitest';
+import stripAnsi from 'strip-ansi';
+import { format } from 'node:util';
+export function createMockDebugLogger(options = {}) {
+    const emitConsoleLog = vi.fn();
+    const debugLogger = {
+        log: vi.fn((message, ...args) => {
+            let formatted = typeof message === 'string' ? format(message, ...args) : message;
+            if (options.stripAnsi && typeof formatted === 'string') {
+                formatted = stripAnsi(formatted);
+            }
+            emitConsoleLog('log', formatted);
+        }),
+        error: vi.fn((message, ...args) => {
+            let formatted = typeof message === 'string' ? format(message, ...args) : message;
+            if (options.stripAnsi && typeof formatted === 'string') {
+                formatted = stripAnsi(formatted);
+            }
+            emitConsoleLog('error', formatted);
+        }),
+        warn: vi.fn((message, ...args) => {
+            let formatted = typeof message === 'string' ? format(message, ...args) : message;
+            if (options.stripAnsi && typeof formatted === 'string') {
+                formatted = stripAnsi(formatted);
+            }
+            emitConsoleLog('warn', formatted);
+        }),
+        debug: vi.fn(),
+        info: vi.fn(),
+    };
+    return { emitConsoleLog, debugLogger };
+}
+/**
+ * A helper specifically designed for `vi.mock('@google/gemini-cli-core', ...)` to easily
+ * mock both `debugLogger` and `coreEvents.emitConsoleLog`.
+ *
+ * Example:
+ * ```typescript
+ * vi.mock('@google/gemini-cli-core', async (importOriginal) => {
+ *   const { mockCoreDebugLogger } = await import('../../test-utils/mockDebugLogger.js');
+ *   return mockCoreDebugLogger(
+ *     await importOriginal<typeof import('@google/gemini-cli-core')>(),
+ *     { stripAnsi: true }
+ *   );
+ * });
+ * ```
+ */
+export function mockCoreDebugLogger(actual, options) {
+    const { emitConsoleLog, debugLogger } = createMockDebugLogger(options);
+    return {
+        ...actual,
+        coreEvents: {
+            // eslint-disable-next-line no-restricted-syntax
+            ...(typeof actual['coreEvents'] === 'object' &&
+                actual['coreEvents'] !== null
+                ? actual['coreEvents']
+                : {}),
+            emitConsoleLog,
+        },
+        debugLogger,
+    };
+}

package/dist/test-utils/mockSpinner.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { vi } from 'vitest';
+export function mockInkSpinner() {
+    vi.mock('ink-spinner', async () => {
+        const { Text } = await import('ink');
+        const cliSpinners = (await import('cli-spinners')).default;
+        return {
+            default: function MockSpinner({ type = 'dots' }) {
+                const spinner = cliSpinners[type];
+                const frame = spinner ? spinner.frames[0] : '⠋';
+                return _jsx(Text, { children: frame });
+            },
+        };
+    });
+}

package/dist/test-utils/persistentStateFake.js

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { vi } from 'vitest';
+/**
+ * A fake implementation of PersistentState for testing.
+ * It keeps state in memory and provides spies for get and set.
+ */
+export class FakePersistentState {
+    data = {};
+    get = vi.fn().mockImplementation((key) => this.data[key]);
+    set = vi.fn().mockImplementation((key, value) => {
+        this.data[key] = value;
+    });
+    /**
+     * Helper to reset the fake state between tests.
+     */
+    reset() {
+        this.data = {};
+        this.get.mockClear();
+        this.set.mockClear();
+    }
+    /**
+     * Helper to clear mock call history without wiping data.
+     */
+    mockClear() {
+        this.get.mockClear();
+        this.set.mockClear();
+    }
+    /**
+     * Helper to set initial data for the fake.
+     */
+    setData(data) {
+        this.data = { ...data };
+    }
+}