@codingame/monaco-vscode-api 1.83.15 → 1.85.0-next.0

package/vscode/src/vs/workbench/contrib/testing/common/testProfileService.js

@@ -1,3 +1,174 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { isDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { StoredValue } from './storedValue.js';
+import { testRunProfileBitsetList } from './testTypes.js';
+import { TestId } from './testId.js';
+import { TestingContextKeys } from './testingContextKeys.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 const ITestProfileService = ( createDecorator('testProfileService'));
-export { ITestProfileService };
+const canUseProfileWithTest = (profile, test) => profile.controllerId === test.controllerId && (TestId.isRoot(test.item.extId) || !profile.tag || test.item.tags.includes(profile.tag));
+const sorter = (a, b) => {
+    if (a.isDefault !== b.isDefault) {
+        return a.isDefault ? -1 : 1;
+    }
+    return a.label.localeCompare(b.label);
+};
+const capabilityContextKeys = (capabilities) => [
+    [TestingContextKeys.hasRunnableTests.key, ((capabilities & 2) ) !== 0],
+    [TestingContextKeys.hasDebuggableTests.key, ((capabilities & 4) ) !== 0],
+    [TestingContextKeys.hasCoverableTests.key, ((capabilities & 8) ) !== 0],
+];
+let TestProfileService = class TestProfileService extends Disposable {
+    constructor(contextKeyService, storageService) {
+        super();
+        this.changeEmitter = this._register(( new Emitter()));
+        this.controllerProfiles = ( new Map());
+        this.onDidChange = this.changeEmitter.event;
+        this.preferredDefaults = this._register(( new StoredValue({
+            key: 'testingPreferredProfiles',
+            scope: 1 ,
+            target: 1 ,
+        }, storageService)));
+        this.capabilitiesContexts = {
+            [2 ]: TestingContextKeys.hasRunnableTests.bindTo(contextKeyService),
+            [4 ]: TestingContextKeys.hasDebuggableTests.bindTo(contextKeyService),
+            [8 ]: TestingContextKeys.hasCoverableTests.bindTo(contextKeyService),
+            [16 ]: TestingContextKeys.hasNonDefaultProfile.bindTo(contextKeyService),
+            [32 ]: TestingContextKeys.hasConfigurableProfile.bindTo(contextKeyService),
+            [64 ]: TestingContextKeys.supportsContinuousRun.bindTo(contextKeyService),
+        };
+        this.refreshContextKeys();
+    }
+    addProfile(controller, profile) {
+        let record = this.controllerProfiles.get(profile.controllerId);
+        if (record) {
+            record.profiles.push(profile);
+            record.profiles.sort(sorter);
+        }
+        else {
+            record = {
+                profiles: [profile],
+                controller,
+            };
+            this.controllerProfiles.set(profile.controllerId, record);
+        }
+        this.refreshContextKeys();
+        this.changeEmitter.fire();
+    }
+    updateProfile(controllerId, profileId, update) {
+        const ctrl = this.controllerProfiles.get(controllerId);
+        if (!ctrl) {
+            return;
+        }
+        const profile = ctrl.profiles.find(c => c.controllerId === controllerId && c.profileId === profileId);
+        if (!profile) {
+            return;
+        }
+        Object.assign(profile, update);
+        ctrl.profiles.sort(sorter);
+        this.changeEmitter.fire();
+    }
+    configure(controllerId, profileId) {
+        this.controllerProfiles.get(controllerId)?.controller.configureRunProfile(profileId);
+    }
+    removeProfile(controllerId, profileId) {
+        const ctrl = this.controllerProfiles.get(controllerId);
+        if (!ctrl) {
+            return;
+        }
+        if (!profileId) {
+            this.controllerProfiles.delete(controllerId);
+            this.changeEmitter.fire();
+            return;
+        }
+        const index = ctrl.profiles.findIndex(c => c.profileId === profileId);
+        if (index === -1) {
+            return;
+        }
+        ctrl.profiles.splice(index, 1);
+        this.refreshContextKeys();
+        this.changeEmitter.fire();
+    }
+    capabilitiesForTest(test) {
+        const ctrl = this.controllerProfiles.get(test.controllerId);
+        if (!ctrl) {
+            return 0;
+        }
+        let capabilities = 0;
+        for (const profile of ctrl.profiles) {
+            if (!profile.tag || test.item.tags.includes(profile.tag)) {
+                capabilities |= capabilities & profile.group ? 16  : profile.group;
+            }
+        }
+        return capabilities;
+    }
+    all() {
+        return ( this.controllerProfiles.values());
+    }
+    getControllerProfiles(profileId) {
+        return this.controllerProfiles.get(profileId)?.profiles ?? [];
+    }
+    getGroupDefaultProfiles(group) {
+        const preferred = this.preferredDefaults.get();
+        if (!preferred) {
+            return this.getBaseDefaults(group);
+        }
+        const profiles = preferred[group]
+            ?.map(p => this.controllerProfiles.get(p.controllerId)?.profiles.find(c => c.profileId === p.profileId && c.group === group))
+            .filter(isDefined);
+        return profiles?.length ? profiles : this.getBaseDefaults(group);
+    }
+    setGroupDefaultProfiles(group, profiles) {
+        const next = {
+            ...this.preferredDefaults.get(),
+            [group]: ( profiles.map(c => ({ profileId: c.profileId, controllerId: c.controllerId }))),
+        };
+        if (group === 2  || group === 4 ) {
+            const otherGroup = group === 2  ? 4  : 2 ;
+            const previousDefaults = next[otherGroup] || [];
+            let newDefaults = previousDefaults.slice();
+            for (const [ctrlId, { profiles: ctrlProfiles }] of this.controllerProfiles) {
+                const labels = ( new Set(( profiles.filter(p => p.controllerId === ctrlId).map(p => p.label))));
+                const nextByLabels = ctrlProfiles.filter(p => ( labels.has(p.label)) && p.group === otherGroup);
+                if (nextByLabels.length) {
+                    newDefaults = newDefaults.filter(p => p.controllerId !== ctrlId);
+                    newDefaults.push(...( nextByLabels.map(p => ({ profileId: p.profileId, controllerId: p.controllerId }))));
+                }
+            }
+            next[otherGroup] = newDefaults;
+        }
+        this.preferredDefaults.store(next);
+        this.changeEmitter.fire();
+    }
+    getBaseDefaults(group) {
+        const defaults = [];
+        for (const { profiles } of ( this.controllerProfiles.values())) {
+            const profile = profiles.find(c => c.group === group);
+            if (profile) {
+                defaults.push(profile);
+            }
+        }
+        return defaults;
+    }
+    refreshContextKeys() {
+        let allCapabilities = 0;
+        for (const { profiles } of ( this.controllerProfiles.values())) {
+            for (const profile of profiles) {
+                allCapabilities |= allCapabilities & profile.group ? 16  : profile.group;
+                allCapabilities |= profile.supportsContinuousRun ? 64  : 0;
+            }
+        }
+        for (const group of testRunProfileBitsetList) {
+            this.capabilitiesContexts[group].set((allCapabilities & group) !== 0);
+        }
+    }
+};
+TestProfileService = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IStorageService))
+], TestProfileService));
+export { ITestProfileService, TestProfileService, canUseProfileWithTest, capabilityContextKeys };

package/vscode/src/vs/workbench/contrib/testing/common/testResult.js

@@ -0,0 +1,384 @@
+import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Lazy } from 'monaco-editor/esm/vs/base/common/lazy.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { observableValue } from 'monaco-editor/esm/vs/base/common/observable.js';
+import { language } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { removeAnsiEscapeCodes } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { refreshComputedState } from './getComputedState.js';
+import { TestId } from './testId.js';
+import { makeEmptyCounts, terminalStatePriorities, maxPriority, statesInOrder } from './testingStates.js';
+import { TestResultItem, getMarkId } from './testTypes.js';
+const emptyRawOutput = {
+    buffers: [],
+    length: 0,
+    onDidWriteData: Event.None,
+    endPromise: Promise.resolve(),
+    getRange: () => VSBuffer.alloc(0),
+    getRangeIter: () => [],
+};
+class TaskRawOutput {
+    constructor() {
+        this.writeDataEmitter = ( new Emitter());
+        this.endDeferred = ( new DeferredPromise());
+        this.offset = 0;
+        this.onDidWriteData = this.writeDataEmitter.event;
+        this.endPromise = this.endDeferred.p;
+        this.buffers = [];
+    }
+    get length() {
+        return this.offset;
+    }
+    getRange(start, length) {
+        const buf = VSBuffer.alloc(length);
+        let bufLastWrite = 0;
+        for (const chunk of this.getRangeIter(start, length)) {
+            buf.buffer.set(chunk.buffer, bufLastWrite);
+            bufLastWrite += chunk.byteLength;
+        }
+        return bufLastWrite < length ? buf.slice(0, bufLastWrite) : buf;
+    }
+    *getRangeIter(start, length) {
+        let soFar = 0;
+        let internalLastRead = 0;
+        for (const b of this.buffers) {
+            if (internalLastRead + b.byteLength <= start) {
+                internalLastRead += b.byteLength;
+                continue;
+            }
+            const bstart = Math.max(0, start - internalLastRead);
+            const bend = Math.min(b.byteLength, bstart + length - soFar);
+            yield b.slice(bstart, bend);
+            soFar += bend - bstart;
+            internalLastRead += b.byteLength;
+            if (soFar === length) {
+                break;
+            }
+        }
+    }
+    append(data, marker) {
+        const offset = this.offset;
+        let length = data.byteLength;
+        if (marker === undefined) {
+            this.push(data);
+            return { offset, length };
+        }
+        const start = VSBuffer.fromString(getMarkCode(marker, true));
+        const end = VSBuffer.fromString(getMarkCode(marker, false));
+        length += start.byteLength + end.byteLength;
+        this.push(start);
+        let trimLen = data.byteLength;
+        for (; trimLen > 0; trimLen--) {
+            const last = data.buffer[trimLen - 1];
+            if (last !== 13  && last !== 10 ) {
+                break;
+            }
+        }
+        this.push(data.slice(0, trimLen));
+        this.push(end);
+        this.push(data.slice(trimLen));
+        return { offset, length };
+    }
+    push(data) {
+        if (data.byteLength === 0) {
+            return;
+        }
+        this.buffers.push(data);
+        this.writeDataEmitter.fire(data);
+        this.offset += data.byteLength;
+    }
+    end() {
+        this.endDeferred.complete();
+    }
+}
+const resultItemParents = function* (results, item) {
+    for (const id of TestId.fromString(item.item.extId).idsToRoot()) {
+        yield results.getStateById(( id.toString()));
+    }
+};
+const maxCountPriority = (counts) => {
+    for (const state of statesInOrder) {
+        if (counts[state] > 0) {
+            return state;
+        }
+    }
+    return 0 ;
+};
+const getMarkCode = (marker, start) => `\x1b]633;SetMark;Id=${getMarkId(marker, start)};Hidden\x07`;
+const itemToNode = (controllerId, item, parent) => ({
+    controllerId,
+    expand: 0 ,
+    item: { ...item },
+    children: [],
+    tasks: [],
+    ownComputedState: 0 ,
+    computedState: 0 ,
+});
+class LiveTestResult extends Disposable {
+    get completedAt() {
+        return this._completedAt;
+    }
+    get tests() {
+        return ( this.testById.values());
+    }
+    constructor(id, persist, request) {
+        super();
+        this.id = id;
+        this.persist = persist;
+        this.request = request;
+        this.completeEmitter = this._register(( new Emitter()));
+        this.newTaskEmitter = this._register(( new Emitter()));
+        this.endTaskEmitter = this._register(( new Emitter()));
+        this.changeEmitter = this._register(( new Emitter()));
+        this.testById = ( new Map());
+        this.testMarkerCounter = 0;
+        this.startedAt = Date.now();
+        this.onChange = this.changeEmitter.event;
+        this.onComplete = this.completeEmitter.event;
+        this.onNewTask = this.newTaskEmitter.event;
+        this.onEndTask = this.endTaskEmitter.event;
+        this.tasks = [];
+        this.name = ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testResult',
+            'runFinished',
+            'Test run at {0}',
+            ( new Date()).toLocaleString(language)
+        ));
+        this.counts = makeEmptyCounts();
+        this.computedStateAccessor = {
+            getOwnState: i => i.ownComputedState,
+            getCurrentComputedState: i => i.computedState,
+            setComputedState: (i, s) => i.computedState = s,
+            getChildren: i => i.children,
+            getParents: i => {
+                const { testById: testByExtId } = this;
+                return (function* () {
+                    const parentId = TestId.fromString(i.item.extId).parentId;
+                    if (parentId) {
+                        for (const id of parentId.idsToRoot()) {
+                            yield testByExtId.get(( id.toString()));
+                        }
+                    }
+                })();
+            },
+        };
+        this.doSerialize = ( new Lazy(() => ({
+            id: this.id,
+            completedAt: this.completedAt,
+            tasks: ( this.tasks.map(t => ({ id: t.id, name: t.name }))),
+            name: this.name,
+            request: this.request,
+            items: ( [...( this.testById.values())].map(TestResultItem.serializeWithoutMessages)),
+        })));
+        this.doSerializeWithMessages = ( new Lazy(() => ({
+            id: this.id,
+            completedAt: this.completedAt,
+            tasks: ( this.tasks.map(t => ({ id: t.id, name: t.name }))),
+            name: this.name,
+            request: this.request,
+            items: ( [...( this.testById.values())].map(TestResultItem.serialize)),
+        })));
+    }
+    getStateById(extTestId) {
+        return this.testById.get(extTestId);
+    }
+    appendOutput(output, taskId, location, testId) {
+        const preview = output.byteLength > 100 ? ( output.slice(0, 100).toString()) + '…' : ( output.toString());
+        let marker;
+        if (testId || location) {
+            marker = this.testMarkerCounter++;
+        }
+        const index = this.mustGetTaskIndex(taskId);
+        const task = this.tasks[index];
+        const { offset, length } = task.output.append(output, marker);
+        const message = {
+            location,
+            message: removeAnsiEscapeCodes(preview),
+            offset,
+            length,
+            marker,
+            type: 1 ,
+        };
+        const test = testId && this.testById.get(testId);
+        if (test) {
+            test.tasks[index].messages.push(message);
+            this.changeEmitter.fire({ item: test, result: this, reason: 2 , message });
+        }
+        else {
+            task.otherMessages.push(message);
+        }
+    }
+    addTask(task) {
+        this.tasks.push({ ...task, coverage: observableValue(this, undefined), otherMessages: [], output: ( new TaskRawOutput()) });
+        for (const test of this.tests) {
+            test.tasks.push({ duration: undefined, messages: [], state: 0  });
+        }
+        this.newTaskEmitter.fire(this.tasks.length - 1);
+    }
+    addTestChainToRun(controllerId, chain) {
+        let parent = this.testById.get(chain[0].extId);
+        if (!parent) {
+            parent = this.addTestToRun(controllerId, chain[0], null);
+        }
+        for (let i = 1; i < chain.length; i++) {
+            parent = this.addTestToRun(controllerId, chain[i], parent.item.extId);
+        }
+        return undefined;
+    }
+    updateState(testId, taskId, state, duration) {
+        const entry = this.testById.get(testId);
+        if (!entry) {
+            return;
+        }
+        const index = this.mustGetTaskIndex(taskId);
+        const oldTerminalStatePrio = terminalStatePriorities[entry.tasks[index].state];
+        const newTerminalStatePrio = terminalStatePriorities[state];
+        if (oldTerminalStatePrio !== undefined &&
+            (newTerminalStatePrio === undefined || newTerminalStatePrio < oldTerminalStatePrio)) {
+            return;
+        }
+        this.fireUpdateAndRefresh(entry, index, state, duration);
+    }
+    appendMessage(testId, taskId, message) {
+        const entry = this.testById.get(testId);
+        if (!entry) {
+            return;
+        }
+        entry.tasks[this.mustGetTaskIndex(taskId)].messages.push(message);
+        this.changeEmitter.fire({ item: entry, result: this, reason: 2 , message });
+    }
+    markTaskComplete(taskId) {
+        const index = this.mustGetTaskIndex(taskId);
+        const task = this.tasks[index];
+        task.running = false;
+        task.output.end();
+        this.setAllToState(0 , taskId, t => t.state === 1  || t.state === 2 );
+        this.endTaskEmitter.fire(index);
+    }
+    markComplete() {
+        if (this._completedAt !== undefined) {
+            throw new Error('cannot complete a test result multiple times');
+        }
+        for (const task of this.tasks) {
+            if (task.running) {
+                this.markTaskComplete(task.id);
+            }
+        }
+        this._completedAt = Date.now();
+        this.completeEmitter.fire();
+    }
+    markRetired(testIds) {
+        for (const [id, test] of this.testById) {
+            if (!test.retired && (!testIds || testIds.hasKeyOrParent(TestId.fromString(id).path))) {
+                test.retired = true;
+                this.changeEmitter.fire({ reason: 0 , item: test, result: this });
+            }
+        }
+    }
+    toJSON() {
+        return this.completedAt && this.persist ? this.doSerialize.value : undefined;
+    }
+    toJSONWithMessages() {
+        return this.completedAt && this.persist ? this.doSerializeWithMessages.value : undefined;
+    }
+    setAllToState(state, taskId, when) {
+        const index = this.mustGetTaskIndex(taskId);
+        for (const test of ( this.testById.values())) {
+            if (when(test.tasks[index], test)) {
+                this.fireUpdateAndRefresh(test, index, state);
+            }
+        }
+    }
+    fireUpdateAndRefresh(entry, taskIndex, newState, newOwnDuration) {
+        const previousOwnComputed = entry.ownComputedState;
+        const previousOwnDuration = entry.ownDuration;
+        const changeEvent = {
+            item: entry,
+            result: this,
+            reason: 1 ,
+            previousState: previousOwnComputed,
+            previousOwnDuration: previousOwnDuration,
+        };
+        entry.tasks[taskIndex].state = newState;
+        if (newOwnDuration !== undefined) {
+            entry.tasks[taskIndex].duration = newOwnDuration;
+            entry.ownDuration = Math.max(entry.ownDuration || 0, newOwnDuration);
+        }
+        const newOwnComputed = maxPriority(...( entry.tasks.map(t => t.state)));
+        if (newOwnComputed === previousOwnComputed) {
+            if (newOwnDuration !== previousOwnDuration) {
+                this.changeEmitter.fire(changeEvent);
+            }
+            return;
+        }
+        entry.ownComputedState = newOwnComputed;
+        this.counts[previousOwnComputed]--;
+        this.counts[newOwnComputed]++;
+        refreshComputedState(this.computedStateAccessor, entry).forEach(t => this.changeEmitter.fire(t === entry ? changeEvent : {
+            item: t,
+            result: this,
+            reason: 0 ,
+        }));
+    }
+    addTestToRun(controllerId, item, parent) {
+        const node = itemToNode(controllerId, item);
+        this.testById.set(item.extId, node);
+        this.counts[0 ]++;
+        if (parent) {
+            this.testById.get(parent)?.children.push(node);
+        }
+        if (this.tasks.length) {
+            for (let i = 0; i < this.tasks.length; i++) {
+                node.tasks.push({ duration: undefined, messages: [], state: 0  });
+            }
+        }
+        return node;
+    }
+    mustGetTaskIndex(taskId) {
+        const index = this.tasks.findIndex(t => t.id === taskId);
+        if (index === -1) {
+            throw new Error(`Unknown task ${taskId} in updateState`);
+        }
+        return index;
+    }
+}
+class HydratedTestResult {
+    get tests() {
+        return ( this.testById.values());
+    }
+    constructor(serialized, persist = true) {
+        this.serialized = serialized;
+        this.persist = persist;
+        this.counts = makeEmptyCounts();
+        this.testById = ( new Map());
+        this.id = serialized.id;
+        this.completedAt = serialized.completedAt;
+        this.tasks = ( serialized.tasks.map((task, i) => ({
+            id: task.id,
+            name: task.name,
+            running: false,
+            coverage: observableValue(this, undefined),
+            output: emptyRawOutput,
+            otherMessages: []
+        })));
+        this.name = serialized.name;
+        this.request = serialized.request;
+        for (const item of serialized.items) {
+            const de = TestResultItem.deserialize(item);
+            this.counts[de.ownComputedState]++;
+            this.testById.set(item.item.extId, de);
+        }
+    }
+    getStateById(extTestId) {
+        return this.testById.get(extTestId);
+    }
+    toJSON() {
+        return this.persist ? this.serialized : undefined;
+    }
+    toJSONWithMessages() {
+        return this.toJSON();
+    }
+}
+export { HydratedTestResult, LiveTestResult, TaskRawOutput, maxCountPriority, resultItemParents };