@theia/test 1.43.0

package/src/browser/view/test-view-frontend-module.ts

@@ -0,0 +1,132 @@
+// *****************************************************************************
+// Copyright (C) 2023 STMicroelectronics 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 '../../../src/browser/style/index.css';
+
+import { interfaces, ContainerModule, Container } from '@theia/core/shared/inversify';
+import {
+    bindViewContribution, FrontendApplicationContribution,
+    WidgetFactory, ViewContainer,
+    WidgetManager, createTreeContainer
+} from '@theia/core/lib/browser';
+import { TestTree, TestTreeWidget } from './test-tree-widget';
+import { TestViewContribution, TEST_VIEW_CONTAINER_ID, TEST_VIEW_CONTAINER_TITLE_OPTIONS, TEST_VIEW_CONTEXT_MENU } from './test-view-contribution';
+import { TestService, TestContribution, DefaultTestService } from '../test-service';
+import { bindContributionProvider } from '@theia/core';
+import { TabBarToolbarContribution } from '@theia/core/lib/browser/shell/tab-bar-toolbar';
+import { TestExecutionStateManager } from './test-execution-state-manager';
+import { TestResultWidget } from './test-result-widget';
+import { TestOutputWidget } from './test-output-widget';
+import { TestOutputViewContribution } from './test-output-view-contribution';
+import { TestOutputUIModel } from './test-output-ui-model';
+import { TestRunTree, TestRunTreeWidget } from './test-run-widget';
+import { TestResultViewContribution } from './test-result-view-contribution';
+import { TEST_RUNS_CONTEXT_MENU, TestRunViewContribution } from './test-run-view-contribution';
+
+export default new ContainerModule(bind => {
+
+    bindContributionProvider(bind, TestContribution);
+    bind(TestService).to(DefaultTestService).inSingletonScope();
+
+    bind(WidgetFactory).toDynamicValue(({ container }) => ({
+        id: TestOutputWidget.ID,
+        createWidget: () => container.get<TestOutputWidget>(TestOutputWidget)
+    })).inSingletonScope();
+
+    bind(TestOutputWidget).toSelf();
+
+    bind(WidgetFactory).toDynamicValue(({ container }) => ({
+        id: TestResultWidget.ID,
+        createWidget: () => container.get<TestResultWidget>(TestResultWidget)
+    })).inSingletonScope();
+
+    bind(TestResultWidget).toSelf();
+
+    bind(TestTreeWidget).toDynamicValue(({ container }) => {
+        const child = createTestTreeContainer(container);
+        return child.get(TestTreeWidget);
+    });
+    bind(WidgetFactory).toDynamicValue(({ container }) => ({
+        id: TestTreeWidget.ID,
+        createWidget: () => container.get<TestTreeWidget>(TestTreeWidget)
+    })).inSingletonScope();
+
+    bind(TestRunTreeWidget).toDynamicValue(({ container }) => {
+        const child = createTestRunContainer(container);
+        return child.get(TestRunTreeWidget);
+    });
+    bind(WidgetFactory).toDynamicValue(({ container }) => ({
+        id: TestRunTreeWidget.ID,
+        createWidget: () => container.get<TestRunTreeWidget>(TestRunTreeWidget)
+    })).inSingletonScope();
+
+    bind(WidgetFactory).toDynamicValue(({ container }) => ({
+        id: TEST_VIEW_CONTAINER_ID,
+        createWidget: async () => {
+            const viewContainer = container.get<ViewContainer.Factory>(ViewContainer.Factory)({
+                id: TEST_VIEW_CONTAINER_ID,
+                progressLocationId: 'test'
+            });
+            viewContainer.setTitleOptions(TEST_VIEW_CONTAINER_TITLE_OPTIONS);
+            let widget = await container.get(WidgetManager).getOrCreateWidget(TestTreeWidget.ID);
+            viewContainer.addWidget(widget, {
+                canHide: false,
+                initiallyCollapsed: false
+            });
+            widget = await container.get(WidgetManager).getOrCreateWidget(TestRunTreeWidget.ID);
+            viewContainer.addWidget(widget, {
+                canHide: true,
+                initiallyCollapsed: false,
+            }); return viewContainer;
+        }
+    })).inSingletonScope();
+
+    bindViewContribution(bind, TestViewContribution);
+    bindViewContribution(bind, TestRunViewContribution);
+    bindViewContribution(bind, TestResultViewContribution);
+    bindViewContribution(bind, TestOutputViewContribution);
+    bind(FrontendApplicationContribution).toService(TestViewContribution);
+    bind(TabBarToolbarContribution).toService(TestViewContribution);
+    bind(TabBarToolbarContribution).toService(TestRunViewContribution);
+    bind(TestExecutionStateManager).toSelf().inSingletonScope();
+    bind(TestOutputUIModel).toSelf().inSingletonScope();
+
+});
+
+export function createTestTreeContainer(parent: interfaces.Container): Container {
+    return createTreeContainer(parent, {
+        tree: TestTree,
+        props: {
+            virtualized: false,
+            search: true,
+            contextMenuPath: TEST_VIEW_CONTEXT_MENU
+        },
+        widget: TestTreeWidget,
+    });
+}
+
+export function createTestRunContainer(parent: interfaces.Container): Container {
+    return createTreeContainer(parent, {
+        tree: TestRunTree,
+        props: {
+            virtualized: false,
+            search: true,
+            multiSelect: false,
+            contextMenuPath: TEST_RUNS_CONTEXT_MENU
+        },
+        widget: TestRunTreeWidget
+    });
+}

package/src/common/collections.ts

@@ -0,0 +1,223 @@
+// *****************************************************************************
+// Copyright (C) 2022 STMicroelectronics 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 { Event } from '@theia/core';
+import { CollectionDelta, TreeDeltaBuilder } from './tree-delta';
+import { Emitter } from '@theia/core/shared/vscode-languageserver-protocol';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function observableProperty(observationFunction: string): (target: any, property: string) => any {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (target: any, property: string): any => {
+        Reflect.defineProperty(target, property, {
+            // @ts-ignore
+            get(): unknown { return this['_' + property]; },
+            set(v: unknown): void {
+                // @ts-ignore
+                this[observationFunction](property, v);
+                // @ts-ignore
+                this['_' + property] = v;
+            }
+        });
+    };
+}
+
+export class ChangeBatcher {
+    private handle: NodeJS.Timeout | undefined;
+    private startTime: number | undefined;
+    constructor(private emitBatch: () => void, readonly timeoutMs: number) {
+    }
+
+    changeOccurred(): void {
+        if (!this.startTime) {
+            this.startTime = Date.now();
+            this.handle = setTimeout(() => {
+                this.flush();
+            }, this.timeoutMs);
+        } else {
+            if (Date.now() - this.startTime > this.timeoutMs) {
+                this.flush();
+            }
+        }
+    }
+    flush(): void {
+        if (this.handle) {
+            clearTimeout(this.handle);
+            this.handle = undefined;
+        }
+        this.startTime = undefined;
+        this.emitBatch();
+    }
+}
+
+export class SimpleObservableCollection<V> {
+    private _values: V[] = [];
+
+    constructor(private equals: (left: V, right: V) => boolean = (left, right) => left === right) {
+    }
+
+    add(value: V): boolean {
+        if (!this._values.find(v => this.equals(v, value))) {
+            this._values.push(value);
+            this.onChangeEmitter.fire({ added: [value] });
+            return true;
+        }
+        return false;
+    }
+
+    remove(value: V): boolean {
+        const index = this._values.findIndex(v => this.equals(v, value));
+        if (index >= 0) {
+            this._values.splice(index, 1);
+            this.onChangeEmitter.fire({ removed: [value] });
+            return true;
+        }
+        return false;
+    }
+
+    private onChangeEmitter = new Emitter<CollectionDelta<V, V>>();
+    onChanged: Event<CollectionDelta<V, V>> = this.onChangeEmitter.event;
+    get values(): readonly V[] {
+        return this._values;
+    }
+
+    clear(): void {
+        const copy = this._values;
+        this._values = [];
+        this.onChangeEmitter.fire({ removed: copy });
+    }
+}
+
+abstract class AbstractIndexedCollection<K, T> {
+    private keys: Map<K, T> = new Map();
+    private _values: T[] | undefined;
+
+    abstract add(item: T): T | undefined;
+
+    get values(): readonly T[] {
+        if (!this._values) {
+            this._values = [...this.keys.values()];
+        }
+        return this._values;
+    }
+
+    get size(): number {
+        return this.keys.size;
+    }
+
+    has(key: K): boolean {
+        return this.keys.has(key);
+    }
+
+    get(key: K): T | undefined {
+        return this.keys.get(key);
+    }
+
+    protected doAdd(key: K, value: T): T | undefined {
+        const previous = this.keys.get(key);
+        if (previous !== undefined) {
+            return previous;
+        } else {
+            this.keys.set(key, value);
+            this._values = undefined;
+            return undefined;
+        }
+    }
+
+    remove(key: K): T | undefined {
+        const previous = this.keys.get(key);
+        if (previous !== undefined) {
+            this.keys.delete(key);
+            this._values = undefined;
+            return previous;
+        }
+        return undefined;
+    }
+}
+
+export class TreeCollection<K, T, P> extends AbstractIndexedCollection<K, T> implements Iterable<[K, T]> {
+
+    constructor(protected readonly owner: T | P,
+        protected readonly pathOf: (v: T) => K[],
+        protected readonly deltaBuilder: (v: T | undefined) => TreeDeltaBuilder<K, T> | undefined) {
+        super();
+    }
+
+    add(item: T): T | undefined {
+        const path = this.pathOf(item);
+        const previous = this.doAdd(path[path.length - 1], item);
+        const deltaBuilder = this.deltaBuilder(item);
+        if (deltaBuilder) {
+            if (previous) {
+                deltaBuilder.reportChanged(path, item);
+            } else {
+                deltaBuilder.reportAdded(path, item);
+            }
+        }
+        return previous;
+    }
+
+    override remove(key: K): T | undefined {
+        const toRemove = this.get(key);
+        if (toRemove) {
+            const deltaBuilder = this.deltaBuilder(toRemove);
+            const path = this.pathOf(toRemove);
+            super.remove(key);
+            if (deltaBuilder) {
+                deltaBuilder.reportRemoved(path);
+            }
+        }
+        return toRemove;
+    }
+
+    entries(): Iterator<[K, T], unknown, undefined> {
+        return this[Symbol.iterator]();
+    }
+
+    [Symbol.iterator](): Iterator<[K, T], unknown, undefined> {
+        const iter = this.values.entries();
+        const that = this;
+        return {
+            next(..._args): IteratorResult<[K, T]> {
+                const res = iter.next();
+                if (res.done) {
+                    return { done: true, value: res.value };
+                } else {
+                    const path = that.pathOf(res.value[1]);
+                    const result: [K, T] = [path[path.length - 1], res.value[1]];
+                    return {
+                        done: false,
+                        value: result
+                    };
+                }
+            }
+        };
+
+    }
+}
+export function groupBy<K, T>(items: Iterable<T>, keyOf: (item: T) => K): Map<K, T[]> {
+    const result = new Map<K, T[]>();
+    for (const item of items) {
+        const key = keyOf(item);
+        let values = result.get(key);
+        if (!values) {
+            values = [];
+            result.set(key, values);
+        }
+        values.push(item);
+    }
+    return result;
+}

package/src/common/tree-delta.spec.ts

@@ -0,0 +1,166 @@
+// *****************************************************************************
+// Copyright (C) 2022 STMicroelectronics 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 { DeltaKind, TreeDelta, TreeDeltaBuilderImpl } from './tree-delta';
+import * as chai from 'chai';
+
+const expect = chai.expect;
+
+interface TestType {
+    id: string;
+    prop: number;
+}
+
+describe('TreeDeltaBuilder tests', () => {
+
+    it('should split paths', () => {
+        const builder = new TreeDeltaBuilderImpl<string, TestType>();
+
+        builder.reportAdded(['a', 'b', 'c'], {
+            id: 'c',
+            prop: 17
+        });
+
+        builder.reportRemoved(['a', 'b', 'd', 'e']);
+
+        const expected: TreeDelta<string, TestType> = {
+            path: ['a', 'b'],
+            type: DeltaKind.NONE,
+            childDeltas: [
+                {
+                    path: ['d', 'e'],
+                    type: DeltaKind.REMOVED,
+                },
+                {
+                    type: DeltaKind.ADDED,
+                    path: ['c'],
+                    value: { id: 'c', prop: 17 },
+                },
+            ]
+        };
+
+        expect(builder.currentDelta).deep.equal([
+            expected
+        ]);
+    });
+
+    it('should merge add/remove child', () => {
+        const builder = new TreeDeltaBuilderImpl<string, TestType>();
+
+        builder.reportAdded(['a', 'b', 'c'], {
+            id: 'c',
+            prop: 17
+        });
+
+        builder.reportRemoved(['a', 'b', 'c', 'd']);
+
+        expect(builder.currentDelta).deep.equal([{
+            path: ['a', 'b', 'c'],
+            type: DeltaKind.ADDED,
+            value: { id: 'c', prop: 17 },
+        }]);
+    });
+
+    it('should merge change', () => {
+        const builder = new TreeDeltaBuilderImpl<string, TestType>();
+
+        builder.reportChanged(['a', 'b', 'c'], { id: 'c', prop: 17 });
+        builder.reportChanged(['a', 'b', 'c'], { prop: 18 });
+        builder.reportChanged(['a', 'b', 'c'], { prop: 19 });
+
+        expect(builder.currentDelta).deep.equal([
+            {
+                type: DeltaKind.CHANGED,
+                path: ['a', 'b', 'c'],
+                value: { id: 'c', prop: 19 },
+            }
+        ]);
+    });
+
+    it('should merge add/change', () => {
+        const builder = new TreeDeltaBuilderImpl<string, TestType>();
+
+        const obj = {
+            id: 'c',
+            prop: 17
+        };
+
+        builder.reportAdded(['a', 'b', 'c'], obj);
+
+        obj.prop = 18;
+
+        builder.reportChanged(['a', 'b', 'c'], { prop: 18 });
+
+        expect(builder.currentDelta).deep.equal([
+            {
+                type: DeltaKind.ADDED,
+                path: ['a', 'b', 'c'],
+                value: { id: 'c', prop: 18 },
+            }
+        ]);
+    });
+
+    it('should handle adds/delete', () => {
+        const builder = new TreeDeltaBuilderImpl<string, TestType>();
+        builder.reportAdded(['a', 'b'], { id: 'c', prop: 14 });
+        builder.reportRemoved(['a', 'b']);
+        expect(builder.currentDelta).deep.equal([]);
+        builder.reportAdded(['a', 'b'], { id: 'c', prop: 20 });
+        expect(builder.currentDelta).deep.equal([{
+            path: ['a', 'b'],
+            type: DeltaKind.ADDED,
+            value: { id: 'c', prop: 20 }
+        }]);
+    });
+
+    it('should handle delete/add', () => {
+        const builder = new TreeDeltaBuilderImpl<string, TestType>();
+        builder.reportRemoved(['a', 'b']);
+        builder.reportAdded(['a', 'b'], { id: 'c', prop: 14 });
+        expect(builder.currentDelta).deep.equal([{
+            path: ['a', 'b'],
+            type: DeltaKind.CHANGED,
+            value: { id: 'c', prop: 14 }
+        }]);
+        builder.reportRemoved(['a', 'b']);
+        expect(builder.currentDelta).deep.equal([{
+            path: ['a', 'b'],
+            type: DeltaKind.REMOVED,
+        }]);
+    });
+
+    it('should handle changed below changed', () => {
+        const builder = new TreeDeltaBuilderImpl<string, TestType>();
+        builder.reportChanged(['a', 'b', 'c', 'e'], { id: 'e', prop: 14 });
+        builder.reportChanged(['a', 'b', 'c', 'd'], { id: 'd', prop: 23 });
+        builder.reportChanged(['a', 'b', 'c'], { id: 'c', prop: 27 });
+        expect(builder.currentDelta).deep.equal([{
+            path: ['a', 'b', 'c'],
+            type: DeltaKind.CHANGED,
+            value: { id: 'c', prop: 27 },
+            childDeltas: [
+                {
+                    path: ['d'],
+                    type: DeltaKind.CHANGED,
+                    value: { id: 'd', prop: 23 }
+                }, {
+                    path: ['e'],
+                    type: DeltaKind.CHANGED,
+                    value: { id: 'e', prop: 14 }
+                }]
+        }]);
+    });
+
+});