/**
 * @license
 * Copyright 2026 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */
import { describe, it, expect, vi } from 'vitest';
import { enableFeature, disableFeature, } from './featureToggleUtils.js';
import { SettingScope, } from '../config/settings.js';
function createMockLoadedSettings(opts) {
    const scopes = {
        [SettingScope.User]: {
            settings: opts.userSettings ?? {},
            path: opts.userPath ?? '/home/user/.gemini/settings.json',
        },
        [SettingScope.Workspace]: {
            settings: opts.workspaceSettings ?? {},
            path: opts.workspacePath ?? '/project/.gemini/settings.json',
        },
    };
    const mockSettings = {
        forScope: vi.fn((scope) => scopes[scope]),
        setValue: vi.fn(),
    };
    return mockSettings;
}
function createMockStrategy(overrides) {
    return {
        needsEnabling: vi.fn(overrides?.needsEnabling ?? (() => false)),
        enable: vi.fn(),
        isExplicitlyDisabled: vi.fn(overrides?.isExplicitlyDisabled ?? (() => false)),
        disable: vi.fn(),
    };
}
describe('featureToggleUtils', () => {
    describe('enableFeature', () => {
        it('should return no-op when the feature is already enabled in all scopes', () => {
            const settings = createMockLoadedSettings({});
            const strategy = createMockStrategy({
                needsEnabling: () => false,
            });
            const result = enableFeature(settings, 'my-feature', strategy);
            expect(result.status).toBe('no-op');
            expect(result.action).toBe('enable');
            expect(result.featureName).toBe('my-feature');
            expect(result.modifiedScopes).toHaveLength(0);
            expect(result.alreadyInStateScopes).toHaveLength(2);
            expect(strategy.enable).not.toHaveBeenCalled();
        });
        it('should enable the feature when disabled in one scope', () => {
            const settings = createMockLoadedSettings({});
            const strategy = createMockStrategy({
                needsEnabling: (_s, scope) => scope === SettingScope.Workspace,
            });
            const result = enableFeature(settings, 'my-feature', strategy);
            expect(result.status).toBe('success');
            expect(result.action).toBe('enable');
            expect(result.modifiedScopes).toHaveLength(1);
            expect(result.modifiedScopes[0].scope).toBe(SettingScope.Workspace);
            expect(result.alreadyInStateScopes).toHaveLength(1);
            expect(result.alreadyInStateScopes[0].scope).toBe(SettingScope.User);
            expect(strategy.enable).toHaveBeenCalledTimes(1);
        });
        it('should enable the feature when disabled in both scopes', () => {
            const settings = createMockLoadedSettings({});
            const strategy = createMockStrategy({
                needsEnabling: () => true,
            });
            const result = enableFeature(settings, 'my-feature', strategy);
            expect(result.status).toBe('success');
            expect(result.action).toBe('enable');
            expect(result.modifiedScopes).toHaveLength(2);
            expect(result.alreadyInStateScopes).toHaveLength(0);
            expect(strategy.enable).toHaveBeenCalledTimes(2);
        });
        it('should include correct scope paths in the result', () => {
            const settings = createMockLoadedSettings({
                userPath: '/custom/user/path',
                workspacePath: '/custom/workspace/path',
            });
            const strategy = createMockStrategy({
                needsEnabling: () => true,
            });
            const result = enableFeature(settings, 'my-feature', strategy);
            const paths = result.modifiedScopes.map((s) => s.path);
            expect(paths).toContain('/custom/workspace/path');
            expect(paths).toContain('/custom/user/path');
        });
    });
    describe('disableFeature', () => {
        it('should return no-op when the feature is already disabled in the target scope', () => {
            const settings = createMockLoadedSettings({});
            const strategy = createMockStrategy({
                isExplicitlyDisabled: () => true,
            });
            const result = disableFeature(settings, 'my-feature', SettingScope.User, strategy);
            expect(result.status).toBe('no-op');
            expect(result.action).toBe('disable');
            expect(result.featureName).toBe('my-feature');
            expect(result.modifiedScopes).toHaveLength(0);
            expect(result.alreadyInStateScopes).toHaveLength(1);
            expect(strategy.disable).not.toHaveBeenCalled();
        });
        it('should disable the feature when it is enabled', () => {
            const settings = createMockLoadedSettings({});
            const strategy = createMockStrategy({
                isExplicitlyDisabled: () => false,
            });
            const result = disableFeature(settings, 'my-feature', SettingScope.User, strategy);
            expect(result.status).toBe('success');
            expect(result.action).toBe('disable');
            expect(result.modifiedScopes).toHaveLength(1);
            expect(result.modifiedScopes[0].scope).toBe(SettingScope.User);
            expect(strategy.disable).toHaveBeenCalledOnce();
        });
        it('should return error for an invalid  scope', () => {
            const settings = createMockLoadedSettings({});
            const strategy = createMockStrategy();
            const result = disableFeature(settings, 'my-feature', SettingScope.Session, strategy);
            expect(result.status).toBe('error');
            expect(result.action).toBe('disable');
            expect(result.error).toContain('Invalid settings scope');
            expect(strategy.disable).not.toHaveBeenCalled();
        });
    });
});
//# sourceMappingURL=featureToggleUtils.test.js.map