@codingame/monaco-vscode-testing-service-override 3.2.3 → 4.1.0

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

@@ -1,296 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { groupBy } from 'vscode/vscode/vs/base/common/arrays';
-import { CancellationToken, CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
-import { Disposable, DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { IWorkspaceTrustRequestService } from 'vscode/vscode/vs/platform/workspace/common/workspaceTrust';
-import { MainThreadTestCollection } from './mainThreadTestCollection.js';
-import { MutableObservableValue } from 'vscode/vscode/vs/workbench/contrib/testing/common/observableValue';
-import { StoredValue } from 'vscode/vscode/vs/workbench/contrib/testing/common/storedValue';
-import { TestExclusions } from './testExclusions.js';
-import { TestId } from 'vscode/vscode/vs/workbench/contrib/testing/common/testId';
-import { TestingContextKeys } from 'vscode/vscode/vs/workbench/contrib/testing/common/testingContextKeys';
-import { canUseProfileWithTest, ITestProfileService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testProfileService';
-import { ITestResultService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testResultService';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { getTestingConfiguration } from './configuration.js';
-import { isDefined } from 'vscode/vscode/vs/base/common/types';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
-
-let TestService = class TestService extends Disposable {
-    constructor(contextKeyService, instantiationService, uriIdentityService, storage, editorService, testProfiles, notificationService, configurationService, testResults, workspaceTrustRequestService) {
-        super();
-        this.uriIdentityService = uriIdentityService;
-        this.storage = storage;
-        this.editorService = editorService;
-        this.testProfiles = testProfiles;
-        this.notificationService = notificationService;
-        this.configurationService = configurationService;
-        this.testResults = testResults;
-        this.workspaceTrustRequestService = workspaceTrustRequestService;
-        this.testControllers = ( new Map());
-        this.cancelExtensionTestRunEmitter = ( new Emitter());
-        this.willProcessDiffEmitter = ( new Emitter());
-        this.didProcessDiffEmitter = ( new Emitter());
-        this.testRefreshCancellations = ( new Set());
-        this.uiRunningTests = ( new Map());
-        this.onWillProcessDiff = this.willProcessDiffEmitter.event;
-        this.onDidProcessDiff = this.didProcessDiffEmitter.event;
-        this.onDidCancelTestRun = this.cancelExtensionTestRunEmitter.event;
-        this.collection = ( new MainThreadTestCollection(this.uriIdentityService, this.expandTest.bind(this)));
-        this.showInlineOutput = MutableObservableValue.stored(this._register(( new StoredValue({
-            key: 'inlineTestOutputVisible',
-            scope: 1 ,
-            target: 0
-        }, this.storage))), true);
-        this.excluded = instantiationService.createInstance(TestExclusions);
-        this.providerCount = TestingContextKeys.providerCount.bindTo(contextKeyService);
-        this.canRefreshTests = TestingContextKeys.canRefreshTests.bindTo(contextKeyService);
-        this.isRefreshingTests = TestingContextKeys.isRefreshingTests.bindTo(contextKeyService);
-        this.activeEditorHasTests = TestingContextKeys.activeEditorHasTests.bindTo(contextKeyService);
-        this._register(editorService.onDidActiveEditorChange(() => this.updateEditorContextKeys()));
-    }
-    async expandTest(id, levels) {
-        await this.testControllers.get(TestId.fromString(id).controllerId)?.expandTest(id, levels);
-    }
-    cancelTestRun(runId) {
-        this.cancelExtensionTestRunEmitter.fire({ runId });
-        if (runId === undefined) {
-            for (const runCts of ( this.uiRunningTests.values())) {
-                runCts.cancel();
-            }
-        }
-        else {
-            this.uiRunningTests.get(runId)?.cancel();
-        }
-    }
-    async runTests(req, token = CancellationToken.None) {
-        const resolved = {
-            targets: [],
-            exclude: req.exclude?.map(t => t.item.extId),
-            continuous: req.continuous,
-        };
-        for (const profile of this.testProfiles.getGroupDefaultProfiles(req.group)) {
-            const testIds = ( req.tests.filter(t => canUseProfileWithTest(profile, t)).map(t => t.item.extId));
-            if (testIds.length) {
-                resolved.targets.push({
-                    testIds: testIds,
-                    profileGroup: profile.group,
-                    profileId: profile.profileId,
-                    controllerId: profile.controllerId,
-                });
-            }
-        }
-        if (resolved.targets.length === 0) {
-            for (const byController of groupBy(req.tests, (a, b) => a.controllerId === b.controllerId ? 0 : 1)) {
-                const profiles = this.testProfiles.getControllerProfiles(byController[0].controllerId);
-                const withControllers = ( byController.map(test => ({
-                    profile: profiles.find(p => p.group === req.group && canUseProfileWithTest(p, test)),
-                    test,
-                })));
-                for (const byProfile of groupBy(withControllers, (a, b) => a.profile === b.profile ? 0 : 1)) {
-                    const profile = byProfile[0].profile;
-                    if (profile) {
-                        resolved.targets.push({
-                            testIds: ( byProfile.map(t => t.test.item.extId)),
-                            profileGroup: req.group,
-                            profileId: profile.profileId,
-                            controllerId: profile.controllerId,
-                        });
-                    }
-                }
-            }
-        }
-        return this.runResolvedTests(resolved, token);
-    }
-    async startContinuousRun(req, token) {
-        if (!req.exclude) {
-            req.exclude = [...this.excluded.all];
-        }
-        const trust = await this.workspaceTrustRequestService.requestWorkspaceTrust({
-            message: ( localizeWithPath(
-                'vs/workbench/contrib/testing/common/testServiceImpl',
-                'testTrust',
-                "Running tests may execute code in your workspace."
-            )),
-        });
-        if (!trust) {
-            return;
-        }
-        const byController = groupBy(req.targets, (a, b) => a.controllerId.localeCompare(b.controllerId));
-        const requests = ( byController.map(
-            group => this.testControllers.get(group[0].controllerId)?.startContinuousRun(( group.map(controlReq => ({
-                excludeExtIds: req.exclude.filter(t => !controlReq.testIds.includes(t)),
-                profileId: controlReq.profileId,
-                controllerId: controlReq.controllerId,
-                testIds: controlReq.testIds,
-            }))), token).then(result => {
-                const errs = ( result.map(r => r.error)).filter(isDefined);
-                if (errs.length) {
-                    this.notificationService.error(( localizeWithPath(
-                        'vs/workbench/contrib/testing/common/testServiceImpl',
-                        'testError',
-                        'An error occurred attempting to run tests: {0}',
-                        errs.join(' ')
-                    )));
-                }
-            })
-        ));
-        await Promise.all(requests);
-    }
-    async runResolvedTests(req, token = CancellationToken.None) {
-        if (!req.exclude) {
-            req.exclude = [...this.excluded.all];
-        }
-        const result = this.testResults.createLiveResult(req);
-        const trust = await this.workspaceTrustRequestService.requestWorkspaceTrust({
-            message: ( localizeWithPath(
-                'vs/workbench/contrib/testing/common/testServiceImpl',
-                'testTrust',
-                "Running tests may execute code in your workspace."
-            )),
-        });
-        if (!trust) {
-            result.markComplete();
-            return result;
-        }
-        try {
-            const cancelSource = ( new CancellationTokenSource(token));
-            this.uiRunningTests.set(result.id, cancelSource);
-            const byController = groupBy(req.targets, (a, b) => a.controllerId.localeCompare(b.controllerId));
-            const requests = ( byController.map(
-                group => this.testControllers.get(group[0].controllerId)?.runTests(( group.map(controlReq => ({
-                    runId: result.id,
-                    excludeExtIds: req.exclude.filter(t => !controlReq.testIds.includes(t)),
-                    profileId: controlReq.profileId,
-                    controllerId: controlReq.controllerId,
-                    testIds: controlReq.testIds,
-                }))), cancelSource.token).then(result => {
-                    const errs = ( result.map(r => r.error)).filter(isDefined);
-                    if (errs.length) {
-                        this.notificationService.error(( localizeWithPath(
-                            'vs/workbench/contrib/testing/common/testServiceImpl',
-                            'testError',
-                            'An error occurred attempting to run tests: {0}',
-                            errs.join(' ')
-                        )));
-                    }
-                })
-            ));
-            await this.saveAllBeforeTest(req);
-            await Promise.all(requests);
-            return result;
-        }
-        finally {
-            this.uiRunningTests.delete(result.id);
-            result.markComplete();
-        }
-    }
-    publishDiff(_controllerId, diff) {
-        this.willProcessDiffEmitter.fire(diff);
-        this.collection.apply(diff);
-        this.updateEditorContextKeys();
-        this.didProcessDiffEmitter.fire(diff);
-    }
-    getTestController(id) {
-        return this.testControllers.get(id);
-    }
-    async syncTests() {
-        const cts = ( new CancellationTokenSource());
-        try {
-            await Promise.all(( [...( this.testControllers.values())].map(c => c.syncTests(cts.token))));
-        }
-        finally {
-            cts.dispose(true);
-        }
-    }
-    async refreshTests(controllerId) {
-        const cts = ( new CancellationTokenSource());
-        this.testRefreshCancellations.add(cts);
-        this.isRefreshingTests.set(true);
-        try {
-            if (controllerId) {
-                await this.testControllers.get(controllerId)?.refreshTests(cts.token);
-            }
-            else {
-                await Promise.all(( [...( this.testControllers.values())].map(c => c.refreshTests(cts.token))));
-            }
-        }
-        finally {
-            this.testRefreshCancellations.delete(cts);
-            this.isRefreshingTests.set(this.testRefreshCancellations.size > 0);
-            cts.dispose(true);
-        }
-    }
-    cancelRefreshTests() {
-        for (const cts of this.testRefreshCancellations) {
-            cts.cancel();
-        }
-        this.testRefreshCancellations.clear();
-        this.isRefreshingTests.set(false);
-    }
-    registerTestController(id, controller) {
-        this.testControllers.set(id, controller);
-        this.providerCount.set(this.testControllers.size);
-        this.updateCanRefresh();
-        const disposable = ( new DisposableStore());
-        disposable.add(toDisposable(() => {
-            const diff = [];
-            for (const root of this.collection.rootItems) {
-                if (root.controllerId === id) {
-                    diff.push({ op: 3 , itemId: root.item.extId });
-                }
-            }
-            this.publishDiff(id, diff);
-            if (this.testControllers.delete(id)) {
-                this.providerCount.set(this.testControllers.size);
-                this.updateCanRefresh();
-            }
-        }));
-        disposable.add(controller.canRefresh.onDidChange(this.updateCanRefresh, this));
-        return disposable;
-    }
-    updateEditorContextKeys() {
-        const uri = this.editorService.activeEditor?.resource;
-        if (uri) {
-            this.activeEditorHasTests.set(!Iterable.isEmpty(this.collection.getNodeByUrl(uri)));
-        }
-        else {
-            this.activeEditorHasTests.set(false);
-        }
-    }
-    async saveAllBeforeTest(req, configurationService = this.configurationService, editorService = this.editorService) {
-        if (req.isUiTriggered === false) {
-            return;
-        }
-        const saveBeforeTest = getTestingConfiguration(this.configurationService, "testing.saveBeforeTest" );
-        if (saveBeforeTest) {
-            await editorService.saveAll();
-        }
-        return;
-    }
-    updateCanRefresh() {
-        this.canRefreshTests.set(( Iterable.some(( this.testControllers.values()), t => t.canRefresh.value)));
-    }
-};
-TestService = ( __decorate([
-    ( __param(0, IContextKeyService)),
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IUriIdentityService)),
-    ( __param(3, IStorageService)),
-    ( __param(4, IEditorService)),
-    ( __param(5, ITestProfileService)),
-    ( __param(6, INotificationService)),
-    ( __param(7, IConfigurationService)),
-    ( __param(8, ITestResultService)),
-    ( __param(9, IWorkspaceTrustRequestService))
-], TestService));
-
-export { TestService };

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

@@ -1,125 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
-import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { removeAnsiEscapeCodes } from 'vscode/vscode/vs/base/common/strings';
-import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
-import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
-import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { ITestResultService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testResultService';
-import { TEST_DATA_SCHEME, parseTestUri } from './testingUri.js';
-
-let TestingContentProvider = class TestingContentProvider {
-    constructor(textModelResolverService, languageService, modelService, resultService) {
-        this.languageService = languageService;
-        this.modelService = modelService;
-        this.resultService = resultService;
-        textModelResolverService.registerTextModelContentProvider(TEST_DATA_SCHEME, this);
-    }
-    async provideTextContent(resource) {
-        const existing = this.modelService.getModel(resource);
-        if (existing && !existing.isDisposed()) {
-            return existing;
-        }
-        const parsed = parseTestUri(resource);
-        if (!parsed) {
-            return null;
-        }
-        const result = this.resultService.getResult(parsed.resultId);
-        if (!result) {
-            return null;
-        }
-        if (parsed.type === 0 ) {
-            const task = result.tasks[parsed.taskIndex];
-            const model = this.modelService.createModel('', null, resource, false);
-            const append = (text) => model.applyEdits([{
-                    range: { startColumn: 1, endColumn: 1, startLineNumber: Infinity, endLineNumber: Infinity },
-                    text,
-                }]);
-            const init = ( VSBuffer.concat(task.output.buffers, task.output.length).toString());
-            append(removeAnsiEscapeCodes(init));
-            let hadContent = init.length > 0;
-            const dispose = ( new DisposableStore());
-            dispose.add(task.output.onDidWriteData(d => {
-                hadContent ||= d.byteLength > 0;
-                append(removeAnsiEscapeCodes(( d.toString())));
-            }));
-            task.output.endPromise.then(() => {
-                if (dispose.isDisposed) {
-                    return;
-                }
-                if (!hadContent) {
-                    append(( localizeWithPath(
-                        'vs/workbench/contrib/testing/common/testingContentProvider',
-                        'runNoOutout',
-                        'The test run did not record any output.'
-                    )));
-                    dispose.dispose();
-                }
-            });
-            model.onWillDispose(() => dispose.dispose());
-            return model;
-        }
-        const test = result?.getStateById(parsed.testExtId);
-        if (!test) {
-            return null;
-        }
-        let text;
-        let language = null;
-        switch (parsed.type) {
-            case 3 : {
-                const message = test.tasks[parsed.taskIndex].messages[parsed.messageIndex];
-                if (message?.type === 0 ) {
-                    text = message.actual;
-                }
-                break;
-            }
-            case 1 : {
-                text = '';
-                const output = result.tasks[parsed.taskIndex].output;
-                for (const message of test.tasks[parsed.taskIndex].messages) {
-                    if (message.type === 1 ) {
-                        text += removeAnsiEscapeCodes(( output.getRange(message.offset, message.length).toString()));
-                    }
-                }
-                break;
-            }
-            case 4 : {
-                const message = test.tasks[parsed.taskIndex].messages[parsed.messageIndex];
-                if (message?.type === 0 ) {
-                    text = message.expected;
-                }
-                break;
-            }
-            case 2 : {
-                const message = test.tasks[parsed.taskIndex].messages[parsed.messageIndex];
-                if (!message) {
-                    break;
-                }
-                if (message.type === 1 ) {
-                    const content = result.tasks[parsed.taskIndex].output.getRange(message.offset, message.length);
-                    text = removeAnsiEscapeCodes(( content.toString()));
-                }
-                else if (typeof message.message === 'string') {
-                    text = message.message;
-                }
-                else {
-                    text = message.message.value;
-                    language = this.languageService.createById('markdown');
-                }
-            }
-        }
-        if (text === undefined) {
-            return null;
-        }
-        return this.modelService.createModel(text, language, resource, false);
-    }
-};
-TestingContentProvider = ( __decorate([
-    ( __param(0, ITextModelService)),
-    ( __param(1, ILanguageService)),
-    ( __param(2, IModelService)),
-    ( __param(3, ITestResultService))
-], TestingContentProvider));
-
-export { TestingContentProvider };

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

@@ -1,67 +0,0 @@
-import { assertNever } from 'vscode/vscode/vs/base/common/assert';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-
-const TEST_DATA_SCHEME = 'vscode-test-data';
-const parseTestUri = (uri) => {
-    const type = uri.authority;
-    const [resultId, ...request] = uri.path.slice(1).split('/');
-    if (request[0] === "message" ) {
-        const taskIndex = Number(request[1]);
-        const testExtId = uri.query;
-        const index = Number(request[2]);
-        const part = request[3];
-        if (type === "results" ) {
-            switch (part) {
-                case "TestFailureMessage" :
-                    return { resultId, taskIndex, testExtId, messageIndex: index, type: 2  };
-                case "ActualOutput" :
-                    return { resultId, taskIndex, testExtId, messageIndex: index, type: 3  };
-                case "ExpectedOutput" :
-                    return { resultId, taskIndex, testExtId, messageIndex: index, type: 4  };
-            }
-        }
-    }
-    if (request[0] === "output" ) {
-        const testExtId = uri.query;
-        const taskIndex = Number(request[1]);
-        return testExtId
-            ? { resultId, taskIndex, testExtId, type: 1  }
-            : { resultId, taskIndex, type: 0  };
-    }
-    return undefined;
-};
-const buildTestUri = (parsed) => {
-    const uriParts = {
-        scheme: TEST_DATA_SCHEME,
-        authority: "results"
-    };
-    if (parsed.type === 0 ) {
-        return ( URI.from({
-            ...uriParts,
-            path: ['', parsed.resultId, "output" , parsed.taskIndex].join('/'),
-        }));
-    }
-    const msgRef = (resultId, ...remaining) => ( URI.from({
-        ...uriParts,
-        query: parsed.testExtId,
-        path: ['', resultId, "message" , ...remaining].join('/'),
-    }));
-    switch (parsed.type) {
-        case 3 :
-            return msgRef(parsed.resultId, parsed.taskIndex, parsed.messageIndex, "ActualOutput" );
-        case 4 :
-            return msgRef(parsed.resultId, parsed.taskIndex, parsed.messageIndex, "ExpectedOutput" );
-        case 2 :
-            return msgRef(parsed.resultId, parsed.taskIndex, parsed.messageIndex, "TestFailureMessage" );
-        case 1 :
-            return ( URI.from({
-                ...uriParts,
-                query: parsed.testExtId,
-                path: ['', parsed.resultId, "output" , parsed.taskIndex].join('/'),
-            }));
-        default:
-            assertNever(parsed, 'Invalid test uri');
-    }
-};
-
-export { TEST_DATA_SCHEME, buildTestUri, parseTestUri };