// *****************************************************************************
// Copyright (C) 2018 Ericsson and others.
//
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License v. 2.0 which is available at
// http://www.eclipse.org/legal/epl-2.0.
//
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License v. 2.0 are satisfied: GNU General Public License, version 2
// with the GNU Classpath Exception which is available at
// https://www.gnu.org/software/classpath/license.html.
//
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
// *****************************************************************************

/* eslint-disable @typescript-eslint/no-explicit-any */

import { enableJSDOM } from '../test/jsdom.js';

let disableJSDOM = enableJSDOM();

import * as assert from 'assert';
import { Container } from 'inversify';
import { PreferenceChange, PreferenceChanges, PreferenceProvider, PreferenceScope, PreferenceService, PreferenceServiceImpl } from '../../common/preferences/index.js';
import { PreferenceSchema, PreferenceSchemaService } from '../../common/preferences/preference-schema.js';
import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider.js';
import { bindMockPreferenceProviders, MockPreferenceProvider } from './test/index.js';
import { PreferenceChangeEvent, createPreferenceProxy } from '../../common/preferences/preference-proxy.js';
import { bindPreferenceService } from '../frontend-application-bindings.js';
import { ILogger } from '../../common/logger.js';
import { MockLogger } from '../../common/test/mock-logger.js';
import { expect } from 'chai';

disableJSDOM();

process.on('unhandledRejection', (reason, promise) => {
    console.error(reason);
    throw reason;
});

let testContainer: Container;

function createTestContainer(): Container {
    const result = new Container();
    bindPreferenceService(result.bind.bind(result));
    bindMockPreferenceProviders(result.bind.bind(result), result.unbind.bind(result));
    result.bind(ILogger).to(MockLogger);
    return result;
}

describe('Preference Service', () => {
    let prefService: PreferenceServiceImpl;
    let prefSchema: PreferenceSchemaService;

    before(() => {
        disableJSDOM = enableJSDOM();
        FrontendApplicationConfigProvider.set({});
    });

    after(() => {
        disableJSDOM();
    });

    beforeEach(async () => {
        testContainer = createTestContainer();
        prefSchema = testContainer.get(PreferenceSchemaService);
        prefService = testContainer.get<PreferenceService>(PreferenceService) as PreferenceServiceImpl;
        getProvider(PreferenceScope.User).markReady();
        getProvider(PreferenceScope.Workspace).markReady();
        getProvider(PreferenceScope.Folder).markReady();
        console.log('before ready');
        try {
            await prefService.ready;
        } catch (e) {
            console.error(e);
        }
        console.log('done');
    });

    afterEach(() => {
    });

    function getProvider(scope: PreferenceScope): MockPreferenceProvider {
        return testContainer.getNamed(PreferenceProvider, scope) as MockPreferenceProvider;
    }

    it('should return the preference from the more specific scope (user > workspace)', () => {
        prefSchema.addSchema({
            scope: PreferenceScope.Folder,
            properties: {
                'test.number': {
                    type: 'number',
                }
            }
        });
        const userProvider = getProvider(PreferenceScope.User);
        const workspaceProvider = getProvider(PreferenceScope.Workspace);
        const folderProvider = getProvider(PreferenceScope.Folder);
        userProvider.setPreference('test.number', 1);
        expect(prefService.get('test.number')).equals(1);
        workspaceProvider.setPreference('test.number', 0);
        expect(prefService.get('test.number')).equals(0);
        folderProvider.setPreference('test.number', 2);
        expect(prefService.get('test.number')).equals(2);

        // remove property on lower scope
        folderProvider.setPreference('test.number', undefined);
        expect(prefService.get('test.number')).equals(0);
    });

    it('should throw a TypeError if the preference (reference object) is modified', () => {
        prefSchema.addSchema({
            scope: PreferenceScope.Folder,
            properties: {
                'test.immutable': {
                    type: 'array',
                    items: {
                        type: 'string'
                    },
                }
            }
        });
        const userProvider = getProvider(PreferenceScope.User);
        userProvider.setPreference('test.immutable', [
            'test', 'test', 'test'
        ]);
        const immutablePref: string[] | undefined = prefService.get('test.immutable');
        expect(immutablePref).to.not.be.undefined;
        if (immutablePref !== undefined) {
            expect(() => immutablePref.push('fails')).to.throw(TypeError);
        }
    });

    it('should still report the more specific preference even though the less specific one changed', () => {
        prefSchema.addSchema({
            scope: PreferenceScope.Folder,
            properties: {
                'test.number': {
                    type: 'number',
                }
            }
        });
        const userProvider = getProvider(PreferenceScope.User);
        const workspaceProvider = getProvider(PreferenceScope.Workspace);
        userProvider.setPreference('test.number', 1);
        workspaceProvider.setPreference('test.number', 0);
        expect(prefService.get('test.number')).equals(0);

        userProvider.setPreference('test.number', 4);
        expect(prefService.get('test.number')).equals(0);
    });

    it('should not fire events if preference schema is unset in the same tick ', async () => {
        const events: PreferenceChange[] = [];
        prefService.onPreferenceChanged(event => events.push(event));
        prefSchema.registerOverrideIdentifier('go');

        const toUnset = prefSchema.addSchema({
            scope: PreferenceScope.User,
            properties: {
                'editor.insertSpaces': {
                    type: 'boolean',
                    default: true,
                    overridable: true
                }
            }
        });

        prefSchema.registerOverride('editor.insertSpaces', 'go', false);
        assert.deepStrictEqual([], events.map(e => e.preferenceName), 'events after set in the same tick');
        assert.strictEqual(prefService.get('editor.insertSpaces'), true, 'get before');
        assert.strictEqual(prefService.get('editor.insertSpaces', { override: 'go' }), false, 'get before overridden');

        toUnset.dispose();

        assert.deepStrictEqual([], events.map(e => e.preferenceName), 'events after unset in the same tick');
        assert.strictEqual(prefService.get('editor.insertSpaces'), undefined, 'get after'); // removing the schema does not removes the default value
        assert.strictEqual(prefService.get('editor.insertSpaces', { override: 'go' }), false, 'get after overridden'); // but not the override

        assert.deepStrictEqual([], events.map(e => e.preferenceName), 'events in next tick');
    });

    it('should fire events if preference schema is unset in another tick', async () => {
        prefSchema.registerOverrideIdentifier('go');

        let pending = new Promise<PreferenceChanges>(resolve => prefService.onPreferencesChanged(resolve));
        const toUnset = prefSchema.addSchema({
            scope: PreferenceScope.User,
            properties: {
                'editor.insertSpaces': {
                    type: 'boolean',
                    default: true,
                    overridable: true
                }
            }
        });
        prefSchema.registerOverride('editor.insertSpaces', 'go', false);
        let changes = await pending;

        assert.deepStrictEqual([
            { preferenceName: 'editor.insertSpaces', affectedOverrides: [] },
            { preferenceName: 'editor.insertSpaces', affectedOverrides: ['go'] },
        ], changes.map((change: PreferenceChange) => ({
            preferenceName: change.preferenceName,
            affectedOverrides: change.affectedOverrides
        })), 'events before');
        assert.strictEqual(prefService.get('editor.insertSpaces'), true, 'get before');
        assert.strictEqual(prefService.get('editor.insertSpaces', { override: 'go' }), false, 'get before overridden');

        pending = new Promise<PreferenceChanges>(resolve => prefService.onPreferencesChanged(resolve));
        toUnset.dispose();
        changes = await pending;

        assert.deepStrictEqual([
            { preferenceName: 'editor.insertSpaces', affectedOverrides: [] },
            { preferenceName: 'editor.insertSpaces', affectedOverrides: ['go'] },
        ], changes.map((change: PreferenceChange) => ({
            preferenceName: change.preferenceName,
            affectedOverrides: change.affectedOverrides
        })), 'events after');
        assert.strictEqual(prefService.get('editor.insertSpaces'), undefined, 'get after');
        assert.strictEqual(prefService.get('editor.insertSpaces', { override: 'go' }), false, 'get after overridden');
    });

    async function prepareServices(options?: { schema: PreferenceSchema }): Promise<{
        preferences: PreferenceServiceImpl;
        schema: PreferenceSchemaService;
    }> {
        const waitForEvent = new Promise<PreferenceChange>(resolve => {
            prefService.onPreferenceChanged(event => resolve(event));
        });
        prefSchema.addSchema(options && options.schema || {
            scope: PreferenceScope.User,
            properties: {
                'editor.tabSize': {
                    type: 'number',
                    default: 4,
                    description: '',
                    overridable: true,
                }
            }
        });

        await waitForEvent;

        return { preferences: prefService, schema: prefSchema };
    }

    describe('PreferenceService.updateValues()', () => {
        const TAB_SIZE = 'editor.tabSize';
        const DUMMY_URI = 'dummy_uri';
        async function generateAndCheckValues(
            preferences: PreferenceService,
            globalValue: number | undefined,
            workspaceValue: number | undefined,
            workspaceFolderValue: number | undefined
        ): Promise<void> {
            await preferences.set(TAB_SIZE, globalValue, PreferenceScope.User);
            await preferences.set(TAB_SIZE, workspaceValue, PreferenceScope.Workspace);
            await preferences.set(TAB_SIZE, workspaceFolderValue, PreferenceScope.Folder, DUMMY_URI);
            const expectedValue = workspaceFolderValue ?? workspaceValue ?? globalValue ?? 4;
            checkValues(preferences, globalValue, workspaceValue, workspaceFolderValue, expectedValue);
        }

        function checkValues(
            preferences: PreferenceService,
            globalValue: number | undefined,
            workspaceValue: number | undefined,
            workspaceFolderValue: number | undefined,
            value: number = 4,
        ): void {
            const expected = {
                preferenceName: 'editor.tabSize',
                defaultValue: 4,
                globalValue,
                workspaceValue,
                workspaceFolderValue,
                sessionValue: undefined,
                value,
            };
            const inspection = preferences.inspect(TAB_SIZE, DUMMY_URI);
            assert.deepStrictEqual(inspection, expected);
        }

        it('should modify the narrowest scope.', async () => {
            const { preferences } = await prepareServices();

            await generateAndCheckValues(preferences, 1, 2, 3);
            await preferences.updateValue(TAB_SIZE, 8, DUMMY_URI);
            checkValues(preferences, 1, 2, 8, 8);

            await generateAndCheckValues(preferences, 1, 2, undefined);
            await preferences.updateValue(TAB_SIZE, 8, DUMMY_URI);
            checkValues(preferences, 1, 8, undefined, 8);

            await generateAndCheckValues(preferences, 1, undefined, undefined);
            await preferences.updateValue(TAB_SIZE, 8, DUMMY_URI);
            checkValues(preferences, 8, undefined, undefined, 8);
        });

        it('defaults to user scope.', async () => {
            const { preferences } = await prepareServices();
            checkValues(preferences, undefined, undefined, undefined);
            await preferences.updateValue(TAB_SIZE, 8, DUMMY_URI);
            checkValues(preferences, 8, undefined, undefined, 8);
        });

        it('clears all settings when input is undefined.', async () => {
            const { preferences } = await prepareServices();

            await generateAndCheckValues(preferences, 1, 2, 3);
            await preferences.updateValue(TAB_SIZE, undefined, DUMMY_URI);
            checkValues(preferences, undefined, undefined, undefined);
        });

        it('deletes user setting if user is only defined scope and target is default value', async () => {
            const { preferences } = await prepareServices();

            await generateAndCheckValues(preferences, 8, undefined, undefined);
            await preferences.updateValue(TAB_SIZE, 4, DUMMY_URI);
            checkValues(preferences, undefined, undefined, undefined);
        });

        it('does not delete setting in lower scopes, even if target is default', async () => {
            const { preferences } = await prepareServices();

            await generateAndCheckValues(preferences, undefined, 2, undefined);
            await preferences.updateValue(TAB_SIZE, 4, DUMMY_URI);
            checkValues(preferences, undefined, 4, undefined);
        });
    });

    describe('get overloads', () => {

        function setupSchema(): void {
            prefSchema.addSchema({
                scope: PreferenceScope.Folder,
                properties: {
                    'test.string': { type: 'string' },
                    'test.number': { type: 'number' },
                    'test.boolean': { type: 'boolean' },
                    'test.array': { type: 'array', items: { type: 'string' } }
                }
            });
        }

        it('returns the string default when no value is stored', () => {
            setupSchema();
            const value: string = prefService.get('test.string', 'default');
            expect(value).to.equal('default');
        });

        it('returns the stored string value over the default', () => {
            setupSchema();
            getProvider(PreferenceScope.User).setPreference('test.string', 'stored');
            const value: string = prefService.get('test.string', 'default');
            expect(value).to.equal('stored');
        });

        it('returns the number default when no value is stored', () => {
            setupSchema();
            const value: number = prefService.get('test.number', 42);
            expect(value).to.equal(42);
        });

        it('returns the stored number value over the default', () => {
            setupSchema();
            getProvider(PreferenceScope.User).setPreference('test.number', 7);
            const value: number = prefService.get('test.number', 42);
            expect(value).to.equal(7);
        });

        it('returns the boolean default when no value is stored', () => {
            setupSchema();
            const value: boolean = prefService.get('test.boolean', true);
            expect(value).to.equal(true);
        });

        it('returns the stored boolean value over the default', () => {
            setupSchema();
            getProvider(PreferenceScope.User).setPreference('test.boolean', false);
            const value: boolean = prefService.get('test.boolean', true);
            expect(value).to.equal(false);
        });

        it('returns the array default when no value is stored', () => {
            setupSchema();
            const value: string[] = prefService.get<string[]>('test.array', ['a', 'b']);
            expect(value).to.deep.equal(['a', 'b']);
        });

        it('returns the stored array value over the default', () => {
            setupSchema();
            getProvider(PreferenceScope.User).setPreference('test.array', ['x', 'y']);
            const value: string[] = prefService.get<string[]>('test.array', []);
            expect(value).to.deep.equal(['x', 'y']);
        });

        it('still supports the options form alongside the new overloads', () => {
            setupSchema();
            expect(prefService.get('test.string', { fallback: 'opts' })).to.equal('opts');
            expect(prefService.get('test.number', { fallback: 5 })).to.equal(5);
            expect(prefService.get('test.boolean', { fallback: false })).to.equal(false);
            expect(prefService.get<string[]>('test.array', { fallback: ['c'] })).to.deep.equal(['c']);
            expect(prefService.get('test.string')).to.be.undefined;
        });
    });

    describe('overridden preferences', () => {

        it('get #0', async () => {
            const { preferences } = await prepareServices();

            preferences.set('editor.tabSize', 2, PreferenceScope.User, undefined, 'json');

            expect(preferences.get('editor.tabSize')).to.equal(4);
            expect(preferences.get('editor.tabSize', { override: 'json' })).to.equal(2);
        });

        it('get #1', async () => {
            const { preferences, schema } = await prepareServices();
            schema.registerOverrideIdentifier('json');

            expect(preferences.get('editor.tabSize')).to.equal(4);
            expect(preferences.get('editor.tabSize', { override: 'json' })).to.equal(4);

            preferences.set('editor.tabSize', 2, PreferenceScope.User, undefined, 'json');

            expect(preferences.get('editor.tabSize')).to.equal(4);
            expect(preferences.get('editor.tabSize', { override: 'json' })).to.equal(2);
        });

        it('get #2', async () => {
            const { preferences, schema } = await prepareServices();
            schema.registerOverrideIdentifier('json');

            expect(preferences.get('editor.tabSize')).to.equal(4);
            expect(preferences.get('editor.tabSize', { override: 'json' })).to.equal(4);

            preferences.set('editor.tabSize', 2, PreferenceScope.User);

            expect(preferences.get('editor.tabSize')).to.equal(2);
            expect(preferences.get('editor.tabSize', { override: 'json' })).to.equal(2);
        });

        it('has', async () => {
            const { preferences, schema } = await prepareServices();

            expect(preferences.has('editor.tabSize')).to.be.true;
            expect(preferences.has('editor.tabSize', undefined, 'json')).to.be.false;

            schema.registerOverrideIdentifier('json');

            expect(preferences.has('editor.tabSize')).to.be.true;
            expect(preferences.has('editor.tabSize', undefined, 'json')).to.be.true;
        });

        it('inspect #0', async () => {
            const { preferences, schema } = await prepareServices();

            const expected = {
                preferenceName: 'editor.tabSize',
                defaultValue: 4,
                globalValue: undefined,
                workspaceValue: undefined,
                workspaceFolderValue: undefined,
                sessionValue: undefined,
                value: 4,
            };
            assert.deepStrictEqual(expected, preferences.inspect('editor.tabSize'));
            assert.ok(!preferences.has('editor.tabSize', undefined, 'json'));

            schema.registerOverrideIdentifier('json');

            assert.deepStrictEqual(expected, preferences.inspect('editor.tabSize'));
            assert.deepStrictEqual(expected, preferences.inspect('editor.tabSize', undefined, 'json'));
        });

        it('inspect #1', async () => {
            const { preferences, schema } = await prepareServices();

            const expected = {
                preferenceName: 'editor.tabSize',
                defaultValue: 4,
                globalValue: 2,
                workspaceValue: undefined,
                workspaceFolderValue: undefined,
                sessionValue: undefined,
                value: 2
            };
            preferences.set('editor.tabSize', 2, PreferenceScope.User);

            assert.deepStrictEqual(expected, preferences.inspect('editor.tabSize'), 'before override');
            assert.ok(!preferences.has('editor.tabSize', undefined, 'json'));

            schema.registerOverrideIdentifier('json');

            assert.deepStrictEqual(expected, preferences.inspect('editor.tabSize'), 'after override');
            assert.deepStrictEqual(expected, preferences.inspect('editor.tabSize', undefined, 'json'), 'after override with json identifier');
        });

        it('inspect #2', async () => {
            const { preferences, schema } = await prepareServices();

            const expected = {
                preferenceName: 'editor.tabSize',
                defaultValue: 4,
                globalValue: undefined,
                workspaceValue: undefined,
                workspaceFolderValue: undefined,
                sessionValue: undefined,
                value: 4
            };
            assert.deepStrictEqual(expected, preferences.inspect('editor.tabSize'));
            assert.ok(!preferences.has('editor.tabSize', undefined, 'json'));

            schema.registerOverrideIdentifier('json');
            preferences.set('editor.tabSize', 2, PreferenceScope.User, undefined, 'json');

            assert.deepStrictEqual(expected, preferences.inspect('editor.tabSize'));
            assert.deepStrictEqual({
                ...expected,
                globalValue: 2,
                value: 2,
            }, preferences.inspect('editor.tabSize', undefined, 'json'));
        });

        it('onPreferenceChanged #0', async () => {
            const { preferences, schema } = await prepareServices();

            const events: PreferenceChange[] = [];
            preferences.onPreferenceChanged(event => events.push(event));

            schema.registerOverrideIdentifier('json');
            await preferences.set('editor.tabSize', 2, PreferenceScope.User, undefined, 'json');
            await preferences.set('editor.tabSize', 3, PreferenceScope.User);

            assert.deepStrictEqual([
                'editor.tabSize',
                'editor.tabSize'
            ], events.map(e => e.preferenceName));
        });

        it('onPreferenceChanged #1', async () => {
            const { preferences, schema } = await prepareServices();

            const events: PreferenceChange[] = [];
            preferences.onPreferenceChanged(event => events.push(event));

            schema.registerOverrideIdentifier('json');
            await preferences.set('editor.tabSize', 2, PreferenceScope.User);

            assert.deepStrictEqual([
                { preferenceName: 'editor.tabSize', affectedOverrides: ['json'] },
            ], events.map(e => ({ preferenceName: e.preferenceName, affectedOverrides: e.affectedOverrides })));
            assert.strictEqual(events[0].affects(undefined, 'json'), true);
        });

        it('onPreferenceChanged: base change of overridable pref does not affect overrides with their own value', async () => {
            const { preferences, schema } = await prepareServices();

            schema.registerOverrideIdentifier('json');
            schema.registerOverrideIdentifier('javascript');
            await preferences.set('editor.tabSize', 2, PreferenceScope.User, undefined, 'json');

            const events: PreferenceChange[] = [];
            preferences.onPreferenceChanged(event => events.push(event));
            await preferences.set('editor.tabSize', 3, PreferenceScope.User);

            assert.deepStrictEqual(['javascript'], events[0].affectedOverrides);
            assert.strictEqual(events[0].affects(undefined, 'json'), false);
            assert.strictEqual(events[0].affects(undefined, 'javascript'), true);
        });

        it('onPreferenceChanged: base change of non-overridable pref affects all registered overrides', async () => {
            const { preferences, schema } = await prepareServices({
                schema: {
                    scope: PreferenceScope.User,
                    properties: {
                        'my.nonOverridable': {
                            type: 'number',
                            default: 1
                        }
                    }
                }
            });

            schema.registerOverrideIdentifier('json');
            schema.registerOverrideIdentifier('javascript');

            const events: PreferenceChange[] = [];
            preferences.onPreferenceChanged(event => events.push(event));
            await preferences.set('my.nonOverridable', 2, PreferenceScope.User);

            assert.deepStrictEqual(['json', 'javascript'], [...events[0].affectedOverrides]);
            assert.strictEqual(events[0].affects(undefined, 'json'), true);
            assert.strictEqual(events[0].affects(undefined, 'javascript'), true);
        });

        it('onPreferenceChanged #2', async function (): Promise<void> {
            const { preferences, schema } = await prepareServices();

            schema.registerOverrideIdentifier('json');
            schema.registerOverrideIdentifier('javascript');
            preferences.set('editor.tabSize', 2, PreferenceScope.User, undefined, 'json');
            await preferences.set('editor.tabSize', 3, PreferenceScope.User);

            const events: PreferenceChangeEvent<{ [key: string]: any }>[] = [];
            const proxy = createPreferenceProxy<{ [key: string]: any }>(preferences, schema.getJSONSchema(PreferenceScope.Folder), { overrideIdentifier: 'json' });
            proxy.onPreferenceChanged(event => events.push(event));

            await preferences.set('editor.tabSize', 4, PreferenceScope.User, undefined, 'javascript');

            assert.deepStrictEqual([], events.map(e => e.preferenceName), 'changes not relevant to json override should be ignored');
        });

        it('onPreferenceChanged #3', async () => {
            const { preferences, schema } = await prepareServices();

            schema.registerOverrideIdentifier('json');
            preferences.set('editor.tabSize', 2, PreferenceScope.User, undefined, 'json');
            await preferences.set('editor.tabSize', 3, PreferenceScope.User);

            const events: PreferenceChange[] = [];
            preferences.onPreferenceChanged(event => events.push(event));

            await preferences.set('editor.tabSize', undefined, PreferenceScope.User, undefined, 'json');

            assert.deepStrictEqual(['editor.tabSize'], events.map(e => e.preferenceName));
        });

        it('defaultOverrides [go].editor.formatOnSave', async () => {
            const { preferences, schema } = await prepareServices({
                schema: {
                    scope: PreferenceScope.Folder,
                    properties: {
                        'editor.insertSpaces': {
                            type: 'boolean',
                            default: true,
                            overridable: true
                        },
                        'editor.formatOnSave': {
                            type: 'boolean',
                            default: false,
                            overridable: true
                        }
                    }
                }
            });

            assert.strictEqual(true, preferences.get('editor.insertSpaces'));
            assert.strictEqual(undefined, preferences.get('editor.insertSpaces', { override: 'go' }));
            assert.strictEqual(false, preferences.get('editor.formatOnSave'));
            assert.strictEqual(undefined, preferences.get('editor.formatOnSave', { override: 'go' }));

            schema.registerOverrideIdentifier('go');
            prefSchema.registerOverride('editor.insertSpaces', 'go', false);
            prefSchema.registerOverride('editor.formatOnSave', 'go', true);

            assert.strictEqual(true, preferences.get('editor.insertSpaces'));
            assert.strictEqual(false, preferences.get('editor.insertSpaces', { override: 'go' }));
            assert.strictEqual(false, preferences.get('editor.formatOnSave'));
            assert.strictEqual(true, preferences.get('editor.formatOnSave', { override: 'go' }));
        });
    });

    describe('session-scope overrides', () => {
        function getSessionProvider(): PreferenceProvider {
            return testContainer.getNamed<PreferenceProvider>(PreferenceProvider, PreferenceScope.Session);
        }

        beforeEach(() => {
            prefSchema.addSchema({
                scope: PreferenceScope.Folder,
                properties: {
                    'test.session': { type: 'number' }
                }
            });
        });

        it('takes precedence over the user scope', async () => {
            getProvider(PreferenceScope.User).setPreference('test.session', 1);
            await prefService.set('test.session', 99, PreferenceScope.Session);
            expect(prefService.get('test.session')).equals(99);
        });

        it('is dropped when the same key is written to a persistent scope', async () => {
            const sessionProvider = getSessionProvider();
            getProvider(PreferenceScope.User).setPreference('test.session', 1);
            await prefService.set('test.session', 99, PreferenceScope.Session);
            expect(prefService.get('test.session')).equals(99);

            // An explicit user edit must win over the session override and clear it.
            await prefService.set('test.session', 2, PreferenceScope.User);
            expect(sessionProvider.get('test.session')).to.equal(undefined);
            expect(prefService.get('test.session')).equals(2);
        });

        it('is reported via inspect().sessionValue', async () => {
            await prefService.set('test.session', 42, PreferenceScope.Session);
            expect(prefService.inspect('test.session')?.sessionValue).equals(42);
        });

        it('emits a Session-scope change event when evicted by a persistent write', async () => {
            // Status bar listeners rely on this: an eviction must surface as an
            // onPreferenceChanged event whose `scope` is Session, otherwise the
            // status bar would never clear after the override is dropped.
            await prefService.set('test.session', 99, PreferenceScope.Session);

            const sessionScopeEvents: PreferenceScope[] = [];
            const listener = prefService.onPreferenceChanged(e => {
                if (e.preferenceName === 'test.session') {
                    sessionScopeEvents.push(e.scope);
                }
            });
            try {
                await prefService.set('test.session', 2, PreferenceScope.User);
            } finally {
                listener.dispose();
            }

            expect(sessionScopeEvents).to.include(PreferenceScope.Session);
        });

        it('is left alone when writing to the Session scope itself', async () => {
            const sessionProvider = getSessionProvider();
            await prefService.set('test.session', 7, PreferenceScope.Session);
            expect(sessionProvider.get('test.session')).to.equal(7);
            // A second write to Session must not trigger eviction of itself.
            await prefService.set('test.session', 8, PreferenceScope.Session);
            expect(sessionProvider.get('test.session')).to.equal(8);
        });
    });

});
