@theia/plugin-ext 1.42.0 → 1.43.0

package/src/plugin/test-item.ts

@@ -0,0 +1,174 @@
+// *****************************************************************************
+// Copyright (C) 2023 Mathieu Bussieres 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
+// *****************************************************************************
+
+import type * as theia from '@theia/plugin';
+
+import { TreeCollection, observableProperty } from '@theia/test/lib/common/collections';
+import { TreeDeltaBuilder } from '@theia/test/lib/common/tree-delta';
+import { TestControllerImpl } from './tests';
+
+export class TestTagImpl {
+    constructor(readonly id: string) { }
+}
+
+export class TestItemImpl implements theia.TestItem {
+    constructor(readonly id: string, readonly uri: theia.Uri | undefined, label: string) {
+        this.label = label;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    protected notifyPropertyChange(property: keyof TestItemImpl, value: any): void {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const val: any = {};
+        val[property] = value;
+        if (this.path) {
+            this.deltaBuilder?.reportChanged(this.path, val);
+        }
+    }
+
+    _deltaBuilder: TreeDeltaBuilder<string, TestItemImpl> | undefined;
+    get deltaBuilder(): TreeDeltaBuilder<string, TestItemImpl> | undefined {
+        if (this._deltaBuilder) {
+            return this._deltaBuilder;
+        } else if (this.parent) {
+            this._deltaBuilder = this.parent._deltaBuilder;
+            return this._deltaBuilder;
+        } else {
+            return undefined;
+        }
+    }
+
+    _path: string[] | undefined;
+
+    get path(): string[] {
+        if (this._path) {
+            return this._path;
+        } else if (this.parent && this.parent.path) {
+            this._path = [...this.parent.path, this.id];
+            return this._path;
+        } else {
+            return [this.id];
+        }
+    };
+
+    private _parent?: TestItemImpl | TestControllerImpl;
+    get realParent(): TestItemImpl | TestControllerImpl | undefined {
+        return this._parent;
+    }
+
+    set realParent(v: TestItemImpl | TestControllerImpl | undefined) {
+        this.iterate(item => {
+            item._path = undefined;
+            return true;
+        });
+        this._parent = v;
+    }
+
+    get parent(): TestItemImpl | undefined {
+        const p = this.realParent;
+        if (p instanceof TestControllerImpl) {
+            return undefined;
+        }
+        return p;
+    }
+
+    protected iterate(toDo: (v: TestItemImpl) => boolean): boolean {
+        if (toDo(this)) {
+            for (const tuple of this.children) {
+                const child: TestItemImpl = tuple[1] as TestItemImpl;
+                if (!child.iterate(toDo)) {
+                    return false;
+                }
+            }
+            return true;
+        } else {
+            return false;
+        }
+    }
+    children: TestItemCollection = new TestItemCollection(this, (v: TestItemImpl) => v.path, (v: TestItemImpl) => v.deltaBuilder);
+    @observableProperty('notifyPropertyChange')
+    tags: readonly theia.TestTag[] = [];
+
+    @observableProperty('notifyPropertyChange')
+    canResolveChildren: boolean = false;
+    @observableProperty('notifyPropertyChange')
+    busy: boolean = false;
+    @observableProperty('notifyPropertyChange')
+    label: string = '';
+    @observableProperty('notifyPropertyChange')
+    description?: string | undefined;
+    @observableProperty('notifyPropertyChange')
+    sortText?: string | undefined;
+    @observableProperty('notifyPropertyChange')
+    range: theia.Range | undefined;
+    @observableProperty('notifyPropertyChange')
+    error: string | theia.MarkdownString | undefined;
+}
+
+export class TestItemCollection implements theia.TestItemCollection {
+
+    constructor(private owner: TestItemImpl | TestControllerImpl,
+        protected readonly pathOf: (v: TestItemImpl) => string[],
+        protected readonly deltaBuilder: (v: TestItemImpl | TestControllerImpl | undefined) => TreeDeltaBuilder<string, TestItemImpl> | undefined) {
+        this.values = new TreeCollection<string, TestItemImpl, TestItemImpl | TestControllerImpl>(owner, pathOf, deltaBuilder);
+    }
+
+    private readonly values: TreeCollection<string, TestItemImpl, TestItemImpl | TestControllerImpl>;
+
+    get size(): number {
+        return this.values.size;
+    }
+    replace(items: readonly theia.TestItem[]): void {
+        const toRemove = this.values.values.map(item => item.id);
+        items.forEach(item => this.add(item));
+        toRemove.forEach(key => this.delete(key));
+    }
+
+    forEach(callback: (item: theia.TestItem, collection: theia.TestItemCollection) => unknown, thisArg?: unknown): void {
+        this.values.values.forEach(item => callback(item, this), thisArg);
+    }
+    add(item: theia.TestItem): void {
+        if (!(item instanceof TestItemImpl)) {
+            throw new Error('Not an instance of TestItem');
+        }
+        item.realParent = this.owner;
+        item._deltaBuilder = this.deltaBuilder(this.owner);
+        this.values.add(item);
+    }
+    delete(itemId: string): void {
+        this.values.remove(itemId);
+    }
+    get(itemId: string): theia.TestItem | undefined {
+        return this.values.get(itemId);
+    }
+
+    [Symbol.iterator](): Iterator<[id: string, testItem: theia.TestItem], unknown, undefined> {
+        return this.values.entries();
+    }
+
+    find(path: string[]): theia.TestItem | undefined {
+        let currentCollection: theia.TestItemCollection = this;
+        let item;
+        for (let i = 0; i < path.length; i++) {
+            item = currentCollection.get(path[i]);
+            if (!item) {
+                return undefined;
+            }
+            currentCollection = item.children;
+        }
+        return item;
+    }
+}

package/src/plugin/tests.ts

@@ -0,0 +1,482 @@
+// *****************************************************************************
+// Copyright (C) 2023 Mathieu Bussieres 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
+// *****************************************************************************
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation and others. All rights reserved.
+ *  Licensed under the MIT License. See https://github.com/Microsoft/vscode/blob/master/LICENSE.txt for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// some code copied and modified from https://github.com/microsoft/vscode/blob/1.72.2/src/vs/workbench/api/common/extHostTesting.ts
+
+// /* eslint-disable */
+
+/* tslint:disable:typedef */
+
+import * as theia from '@theia/plugin';
+import { CancellationToken, CancellationTokenSource } from '@theia/core/lib/common/cancellation';
+import { Disposable, DisposableCollection, Emitter, Event } from '@theia/core';
+import { hash } from '@theia/core/lib/common/hash';
+
+import { isDefined } from '@theia/core/lib/common/types';
+import { TestingExt, PLUGIN_RPC_CONTEXT, TestingMain } from '../common/plugin-api-rpc';
+import { CommandRegistryImpl } from './command-registry';
+import { RPCProtocol } from '../common/rpc-protocol';
+import { v4 as uuidv4 } from 'uuid';
+import * as Convert from './type-converters';
+import { TestItemImpl, TestItemCollection } from './test-item';
+import { AccumulatingTreeDeltaEmitter, TreeDelta } from '@theia/test/lib/common/tree-delta';
+import {
+    TestItemDTO, TestOutputDTO, TestExecutionState, TestRunProfileDTO,
+    TestRunProfileKind, TestRunRequestDTO, TestStateChangeDTO, TestItemReference
+} from '../common/test-types';
+import { ChangeBatcher, observableProperty } from '@theia/test/lib/common/collections';
+import { TestRunRequest } from './types-impl';
+
+type RefreshHandler = (token: theia.CancellationToken) => void | theia.Thenable<void>;
+type ResolveHandler = (item: theia.TestItem | undefined) => theia.Thenable<void> | void;
+
+export class TestControllerImpl implements theia.TestController {
+    protected readonly _profiles = new Map<number, TestRunProfile>();
+    private activeRuns = new Map<theia.TestRunRequest, TestRun>();
+    private deltaBuilder: AccumulatingTreeDeltaEmitter<string, TestItemImpl>;
+    private _refreshHandler?: RefreshHandler;
+    private _resolveHandler?: ResolveHandler;
+
+    constructor(
+        private onDispose: () => void,
+        protected readonly proxy: TestingMain,
+        readonly id: string,
+        private _label: string) {
+
+        this.proxy.$registerTestController(id, _label);
+
+        this.deltaBuilder = new AccumulatingTreeDeltaEmitter<string, TestItemImpl>(200);
+        this.deltaBuilder.onDidFlush(delta => {
+            // console.debug('flushing delta'); // logging levels don't work in plugin host: https://github.com/eclipse-theia/theia/issues/12234
+            const mapped = this.mapDeltas(delta);
+            // console.debug(JSON.stringify(mapped, undefined, 3));
+            this.proxy.$notifyDelta(id, mapped);
+        });
+
+        this.items = new TestItemCollection(this, item => item.path, () => this.deltaBuilder);
+    }
+    mapDeltas(deltas: TreeDelta<string, TestItemImpl>[]): TreeDelta<string, TestItemDTO>[] {
+        return deltas.map(delta => this.mapDelta(delta));
+    }
+
+    mapDelta(delta: TreeDelta<string, TestItemImpl>): TreeDelta<string, TestItemDTO> {
+        return {
+            path: delta.path,
+            type: delta.type,
+            value: delta.value ? Convert.TestItem.fromPartial(delta.value) : undefined,
+            childDeltas: delta.childDeltas?.map(d => this.mapDelta(d))
+        };
+    }
+
+    readonly items: TestItemCollection;
+
+    get label(): string {
+        return this._label;
+    }
+    set label(value: string) {
+        this._label = value;
+        this.proxy.$updateController(this.id, { label: value });
+    }
+    get refreshHandler(): RefreshHandler | undefined {
+        return this._refreshHandler;
+    }
+    set refreshHandler(value: RefreshHandler | undefined) {
+        this._refreshHandler = value;
+        this.proxy.$updateController(this.id, { canRefresh: !!value });
+    }
+
+    get resolveHandler(): ResolveHandler | undefined {
+        return this._resolveHandler;
+    }
+
+    set resolveHandler(handler: ResolveHandler | undefined) {
+        this._resolveHandler = handler;
+        this.proxy.$updateController(this.id, { canResolve: !!handler });
+    }
+
+    getProfile(id: string) {
+        return this._profiles.get(Number.parseInt(id));
+    }
+
+    createRunProfile(label: string, kind: TestRunProfileKind, runHandler: (request: theia.TestRunRequest, token: CancellationToken) => Thenable<void> | void,
+        isDefault?: boolean, tag?: theia.TestTag, supportsContinuousRun?: boolean): theia.TestRunProfile {
+        // Derive the profile ID from a hash so that the same profile will tend
+        // to have the same hashes, allowing re-run requests to work across reloads.
+        let profileId = hash(label);
+        while (this._profiles.has(profileId)) {
+            profileId++;
+        }
+
+        const profile = new TestRunProfile(this.proxy, this.id, profileId.toString(), label, kind, runHandler, isDefault, tag);
+        this._profiles.set(profileId, profile);
+        return profile;
+    }
+    createTestItem(id: string, label: string, uri?: theia.Uri): theia.TestItem {
+        return new TestItemImpl(id, uri, label);
+    }
+
+    createTestRun(request: theia.TestRunRequest, name?: string, persist: boolean = true): theia.TestRun {
+        return this.testRunStarted(request, name || '', persist, true);
+    }
+
+    dispose() {
+        this.proxy.$unregisterTestController(this.id);
+        this.onDispose();
+    }
+
+    protected testRunStarted(request: theia.TestRunRequest, name: string, persist: boolean, isRunning: boolean): TestRun {
+        const existing = this.activeRuns.get(request);
+        if (existing) {
+            return existing;
+        }
+
+        const run = new TestRun(this, this.proxy, name, persist, isRunning);
+        const endListener = run.onWillFlush(() => {
+            // make sure we notify the front end of test item changes before test run state is sent
+            this.deltaBuilder.flush();
+        });
+        run.onDidEnd(() => {
+            endListener.dispose();
+            this.activeRuns.delete(request);
+        });
+        this.activeRuns.set(request, run);
+        return run;
+    }
+
+    runTestsForUI(profileId: string, name: string, includedTests: string[][], excludedTests: string[][]): void {
+        const profile = this.getProfile(profileId);
+        if (!profile) {
+            console.error(`No test run profile found for controller ${this.id} with id ${profileId} `);
+            return;
+        }
+
+        const includeTests = includedTests
+            .map(testId => this.items.find(testId))
+            .filter(isDefined);
+
+        if (includeTests.length === 0) {
+            return;
+        }
+        function isPrefix(left: string[], right: string[]) {
+            if (left.length > right.length) {
+                return false;
+            }
+
+            for (let i = 0; i < left.length; i++) {
+                if (left[i] !== right[i]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        const excludeTests = excludedTests
+            .filter(path => includedTests.some(
+                includedPath => isPrefix(path, includedPath)
+            ))
+            .map(path => this.items.find(path))
+            .filter(isDefined);
+
+        const request = new TestRunRequest(
+            includeTests, excludeTests, profile, false // don't support continuous run yet
+        );
+
+        const run = this.testRunStarted(request, name, false, false);
+        profile.runHandler(request, run.token);
+    }
+
+    cancelRun(runId?: string): void {
+        if (runId === undefined) {
+            this.activeRuns.forEach(run => run.cancel());
+        } else {
+            const run = [...this.activeRuns.values()].find(r => r.id === runId);
+            if (!run) {
+                throw new Error(`TestController ${this.id} cannot cancel non - existing run ${runId} `);
+            }
+            run.cancel();
+        }
+    }
+
+    invalidateTestResults(items?: theia.TestItem | readonly theia.TestItem[] | undefined): void {
+        // do nothing for the moment, since we don't have a UI to "mark as outdated and deprioritized in the editor's UI."
+    }
+}
+
+function checkTestInstance(item: theia.TestItem): TestItemImpl;
+function checkTestInstance(item?: theia.TestItem): TestItemImpl | undefined;
+function checkTestInstance(item?: theia.TestItem): TestItemImpl | undefined {
+    if (item instanceof TestItemImpl) {
+        if (!item.path) {
+            throw new Error('Test item not added to a collection');
+        }
+        return <TestItemImpl>item;
+    } else if (item) {
+        throw new Error('Not a TestItem instance');
+    }
+    return undefined;
+}
+
+class TestRun implements theia.TestRun {
+    private onDidEndEmitter = new Emitter<void>();
+    onDidEnd: Event<void> = this.onDidEndEmitter.event;
+    private onWillFlushEmitter = new Emitter<void>();
+    onWillFlush: Event<void> = this.onWillFlushEmitter.event;
+
+    readonly id: string;
+    private testStateDeltas = new Map<theia.TestItem, TestStateChangeDTO>();
+    private testOutputDeltas: TestOutputDTO[] = [];
+    private changeBatcher = new ChangeBatcher(() => {
+        this.emitChange();
+    }, 200);
+    private ended: boolean;
+    private tokenSource: CancellationTokenSource;
+    readonly token: CancellationToken;
+
+    constructor(
+        private readonly controller: TestControllerImpl,
+        private readonly proxy: TestingMain,
+        readonly name: string,
+        readonly isPersisted: boolean,
+        isRunning: boolean) {
+        this.id = uuidv4();
+
+        this.tokenSource = new CancellationTokenSource();
+        this.token = this.tokenSource.token;
+
+        this.proxy.$notifyTestRunCreated(this.controller.id, { id: this.id, name: this.name, isRunning });
+    }
+    enqueued(test: theia.TestItem): void {
+        this.updateTestState(test, { itemPath: checkTestInstance(test).path, state: TestExecutionState.Queued });
+    }
+
+    started(test: theia.TestItem): void {
+        this.updateTestState(test, { itemPath: checkTestInstance(test).path, state: TestExecutionState.Running });
+    }
+    skipped(test: theia.TestItem): void {
+        this.updateTestState(test, { itemPath: checkTestInstance(test).path, state: TestExecutionState.Skipped });
+    }
+    failed(test: theia.TestItem, message: theia.TestMessage | readonly theia.TestMessage[], duration?: number | undefined): void {
+        this.updateTestState(test, { itemPath: checkTestInstance(test).path, state: TestExecutionState.Failed, messages: Convert.TestMessage.from(message), duration });
+    }
+    errored(test: theia.TestItem, message: theia.TestMessage | readonly theia.TestMessage[], duration?: number | undefined): void {
+        this.updateTestState(test, { itemPath: checkTestInstance(test).path, state: TestExecutionState.Errored, messages: Convert.TestMessage.from(message), duration });
+    }
+    passed(test: theia.TestItem, duration?: number | undefined): void {
+        this.updateTestState(test, { itemPath: checkTestInstance(test).path, state: TestExecutionState.Passed, duration });
+    }
+    appendOutput(output: string, location?: theia.Location | undefined, test?: theia.TestItem | undefined): void {
+        this.testOutputDeltas.push({ output, location: Convert.fromLocation(location), itemPath: checkTestInstance(test)?.path });
+        this.changeBatcher.changeOccurred();
+    }
+
+    end(): void {
+        this.ended = true;
+        this.proxy.$notifyTestRunEnded(this.controller.id, this.id);
+    }
+
+    private checkNotEnded(test: theia.TestItem): boolean {
+        if (this.ended) {
+            console.warn(`Setting the state of test "${test.id}" is a no - op after the run ends.`);
+            return false;
+        }
+        return true;
+    }
+
+    private updateTestState<T extends TestStateChangeDTO>(item: theia.TestItem, state: T) {
+        if (this.checkNotEnded(item)) {
+            this.testStateDeltas.set(item, state);
+            this.changeBatcher.changeOccurred();
+        }
+    }
+
+    emitChange() {
+        this.onWillFlushEmitter.fire();
+        this.proxy.$notifyTestStateChanged(this.controller.id, this.id, [...this.testStateDeltas.values()], this.testOutputDeltas);
+        this.testOutputDeltas = [];
+        this.testStateDeltas = new Map();
+    }
+
+    cancel() {
+        this.tokenSource.cancel();
+    }
+}
+
+export class TestingExtImpl implements TestingExt {
+    private readonly controllersById = new Map<string, TestControllerImpl>();
+    private readonly proxy: TestingMain;
+
+    constructor(
+        rpc: RPCProtocol,
+        commands: CommandRegistryImpl
+    ) {
+        this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.TESTING_MAIN);
+
+        commands.registerArgumentProcessor({
+            processArgument: arg => {
+                if (TestItemReference.is(arg)) {
+                    return this.toTestItem(arg);
+                } else if (Array.isArray(arg)) {
+                    return arg.map(param => TestItemReference.is(param) ? this.toTestItem(param) : param);
+                } else {
+                    return arg;
+                }
+            }
+        });
+
+    }
+
+    toTestItem(ref: TestItemReference): theia.TestItem {
+        const result = this.withController(ref.controllerId).items.find(ref.testPath);
+        if (!result) {
+            throw new Error(`Test item for controller ${ref.controllerId} not found: ${ref.testPath}`);
+        }
+        return result;
+    }
+
+    protected withController(controllerId: string): TestControllerImpl {
+        const controller = this.controllersById.get(controllerId);
+        if (!controller) {
+            throw new Error(`No test controller found with id "${controllerId}"`);
+        }
+        return controller;
+    }
+
+    $onResolveChildren(controllerId: string, path: string[]): void {
+        const controller = this.withController(controllerId);
+        if (controller.resolveHandler) {
+            const item = controller.items.find(path);
+            if (item?.canResolveChildren) { // the item and resolve handler might have been been changed, but not sent to the front end
+                controller.resolveHandler?.(item);
+            }
+        }
+    }
+
+    /**
+     * Implements theia.test.registerTestProvider
+     */
+    createTestController(controllerId: string, label: string): theia.TestController {
+        if (this.controllersById.has(controllerId)) {
+            throw new Error(`Attempt to insert a duplicate controller with ID "${controllerId}"`);
+        }
+
+        const disposable = new DisposableCollection();
+
+        const controller = new TestControllerImpl(() => disposable.dispose(), this.proxy, controllerId, label);
+
+        this.controllersById.set(controllerId, controller);
+        disposable.push(Disposable.create(() => this.controllersById.delete(controllerId)));
+
+        return controller;
+    }
+
+    /** @inheritdoc */
+    $onConfigureRunProfile(controllerId: string, profileId: string): void {
+        this.controllersById.get(controllerId)?.getProfile(profileId)?.configureHandler?.();
+    }
+
+    /** @inheritdoc */
+    async $refreshTests(controllerId: string, token: CancellationToken): Promise<void> {
+        await this.withController(controllerId).refreshHandler?.(token);
+    }
+
+    /**
+     * Runs tests with the given set of IDs. Allows for test from multiple
+     * providers to be run.
+     * @override
+     */
+    $onRunControllerTests(reqs: TestRunRequestDTO[]): void {
+        reqs.map(req => this.runTestsForUI(req));
+    }
+
+    runTestsForUI(req: TestRunRequestDTO): void {
+        this.withController(req.controllerId).runTestsForUI(req.profileId, req.name, req.includedTests, req.excludedTests);
+    }
+
+    /**
+     * Cancels an ongoing test run.
+     */
+    $onCancelTestRun(controllerId: string, runId: string): void {
+        this.withController(controllerId).cancelRun(runId);
+    }
+}
+
+export class TestRunProfile implements theia.TestRunProfile {
+    private readonly proxy: TestingMain;
+    supportsContinuousRun: boolean = false;
+
+    constructor(
+        proxy: TestingMain,
+        readonly controllerId: string,
+        readonly profileId: string,
+        label: string,
+        readonly kind: theia.TestRunProfileKind,
+        public runHandler: (request: theia.TestRunRequest, token: theia.CancellationToken) => Thenable<void> | void,
+        isDefault = false,
+        tag: theia.TestTag | undefined = undefined,
+    ) {
+        this.proxy = proxy;
+        this.label = label;
+        this.tag = tag;
+        this.label = label;
+        this.isDefault = isDefault;
+
+        this.proxy.$notifyTestRunProfileCreated(controllerId, {
+            id: profileId,
+            kind: kind,
+            tag: tag ? tag.toString() : '',
+            label: label,
+            isDefault: isDefault,
+            canConfigure: false,
+        });
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    protected notifyPropertyChange(property: keyof TestRunProfileDTO, value: any): void {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const val: any = {};
+        val[property] = value;
+        this.proxy.$updateTestRunProfile(this.controllerId, this.profileId, val);
+    }
+
+    @observableProperty('notifyPropertyChange')
+    label: string;
+
+    @observableProperty('notifyPropertyChange')
+    isDefault: boolean;
+
+    @observableProperty('notifyTagChange')
+    tag: theia.TestTag | undefined;
+
+    protected notifyTagChange(_property: keyof TestRunProfileDTO, value?: theia.TestTag): void {
+        this.proxy.$updateTestRunProfile(this.controllerId, this.profileId, { tag: value ? value.toString() : '' });
+    }
+
+    @observableProperty('notifyConfigureHandlerChange')
+    configureHandler: () => void | undefined;
+
+    protected notifyConfigureHandlerChange(_property: keyof TestRunProfileDTO, value?: () => void): void {
+        this.proxy.$updateTestRunProfile(this.controllerId, this.profileId, { canConfigure: !!value });
+    }
+
+    dispose(): void {
+    }
+
+}

package/src/plugin/tree/tree-views.ts

@@ -34,6 +34,7 @@ import { PluginIconPath } from '../plugin-icon-path';
 import { URI } from '@theia/core/shared/vscode-uri';
 import { UriComponents } from '@theia/core/lib/common/uri';
 import { isObject } from '@theia/core';
+import { coalesce } from '../../common/arrays';
 
 export class TreeViewsExtImpl implements TreeViewsExt {
     private proxy: TreeViewsMain;
@@ -407,7 +408,7 @@ class TreeViewExtImpl<T> implements Disposable {
         // ask data provider for children for cached element
         const result = await this.options.treeDataProvider.getChildren(parent);
         if (result) {
-            const treeItemPromises = result.map(async value => {
+            const treeItemPromises = coalesce(result).map(async value => {
 
                 // Ask data provider for a tree item for the value
                 // Data provider must return theia.TreeItem