@theia/test 1.43.0

package/src/browser/view/test-execution-state-manager.ts

@@ -0,0 +1,147 @@
+// *****************************************************************************
+// 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 { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { TestController, TestExecutionState, TestItem, TestRun, TestService } from '../test-service';
+
+/**
+ * This class manages the state of "internal" nodes in the test tree
+ */
+@injectable()
+export class TestExecutionStateManager {
+    @inject(TestService)
+    protected readonly testService: TestService;
+
+    private executionStates = new Map<TestRun, TestExecutionStateMap>();
+
+    @postConstruct()
+    init(): void {
+        this.testService.getControllers().forEach(controller => this.addController(controller));
+        this.testService.onControllersChanged(controllerDelta => {
+            controllerDelta.added?.forEach(controller => this.addController(controller));
+        });
+    }
+    addController(controller: TestController): void {
+        controller.testRuns.forEach(run => this.addRun(run));
+        controller.onRunsChanged(runDelta => {
+            runDelta.added?.forEach(run => this.addRun(run));
+            runDelta.removed?.forEach(run => {
+                this.executionStates.delete(run);
+            });
+        });
+    }
+    addRun(run: TestRun): void {
+        this.executionStates.set(run, new TestExecutionStateMap);
+        run.onDidChangeTestState(updates => {
+            updates.forEach(update => {
+                this.updateState(run, update.test, update.oldState?.state, update.newState?.state);
+            });
+        });
+    }
+
+    protected updateState(run: TestRun, item: TestItem, oldState: TestExecutionState | undefined, newState: TestExecutionState | undefined): void {
+        const map = this.executionStates.get(run)!;
+        map.reportState(item, oldState, newState);
+    }
+
+    getComputedState(run: TestRun, item: TestItem): TestExecutionState | undefined {
+        return this.executionStates.get(run)?.getComputedState(item);
+    }
+}
+
+class TestExecutionStateMap {
+    reportState(item: TestItem, oldState: TestExecutionState | undefined, newState: TestExecutionState | undefined): void {
+        if (oldState !== newState) {
+            if (item.parent) {
+                this.reportChildStateChanged(item.parent, oldState, newState);
+            }
+        }
+    }
+    reportChildStateChanged(parent: TestItem, oldState: TestExecutionState | undefined, newState: TestExecutionState | undefined): void {
+        if (oldState !== newState) {
+            const currentParentState = this.getComputedState(parent);
+            let counts = this.stateCounts.get(parent);
+            if (!counts) {
+                counts = [];
+                counts[TestExecutionState.Queued] = 0;
+                counts[TestExecutionState.Running] = 0;
+                counts[TestExecutionState.Passed] = 0;
+                counts[TestExecutionState.Failed] = 0;
+                counts[TestExecutionState.Skipped] = 0;
+                counts[TestExecutionState.Errored] = 0;
+                this.stateCounts.set(parent, counts);
+            }
+            if (oldState) {
+                counts[oldState]--;
+            }
+            if (newState) {
+                counts[newState]++;
+            }
+            const newParentState = this.getComputedState(parent);
+            if (parent.parent && currentParentState !== newParentState) {
+                this.reportChildStateChanged(parent.parent, currentParentState, newParentState!);
+            }
+        }
+    }
+
+    private stateCounts: Map<TestItem | TestController, number[]> = new Map();
+
+    updateState(item: TestItem, oldState: TestExecutionState | undefined, newState: TestExecutionState): void {
+        let parent = item.parent;
+        while (parent && 'parent' in parent) { // parent is a test item
+            let counts = this.stateCounts.get(parent);
+            if (!counts) {
+                counts = [];
+                counts[TestExecutionState.Queued] = 0;
+                counts[TestExecutionState.Running] = 0;
+                counts[TestExecutionState.Passed] = 0;
+                counts[TestExecutionState.Failed] = 0;
+                counts[TestExecutionState.Skipped] = 0;
+                counts[TestExecutionState.Errored] = 0;
+                this.stateCounts.set(parent, counts);
+            }
+            if (oldState) {
+                counts[oldState]--;
+            }
+            counts[newState]++;
+            parent = parent.parent;
+        }
+    }
+
+    getComputedState(item: TestItem): TestExecutionState | undefined {
+        const counts = this.stateCounts.get(item);
+        if (counts) {
+            if (counts[TestExecutionState.Errored] > 0) {
+                return TestExecutionState.Errored;
+            } else if (counts[TestExecutionState.Failed] > 0) {
+                return TestExecutionState.Failed;
+            } else if (counts[TestExecutionState.Running] > 0) {
+                return TestExecutionState.Running;
+            } else if (counts[TestExecutionState.Queued] > 0) {
+                return TestExecutionState.Queued;
+            } else if (counts[TestExecutionState.Passed] > 0) {
+                return TestExecutionState.Passed;
+            } else if (counts[TestExecutionState.Skipped] > 0) {
+                return TestExecutionState.Skipped;
+            } else {
+                return undefined;
+            }
+        } else {
+            return undefined;
+        }
+    }
+}
+

package/src/browser/view/test-output-ui-model.ts

@@ -0,0 +1,148 @@
+// *****************************************************************************
+// 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 { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { TestController, TestOutputItem, TestRun, TestService, TestState, TestStateChangedEvent } from '../test-service';
+import { Disposable, Emitter, Event } from '@theia/core';
+
+export interface ActiveRunEvent {
+    controller: TestController;
+    activeRun: TestRun | undefined
+}
+
+export interface TestOutputSource {
+    readonly output: readonly TestOutputItem[];
+    onDidAddTestOutput: Event<TestOutputItem[]>;
+}
+
+export interface ActiveTestStateChangedEvent {
+    controller: TestController;
+    testRun: TestRun;
+    statedDelta: TestStateChangedEvent[];
+}
+
+interface ActiveTestRunInfo {
+    run: TestRun;
+    toDispose: Disposable;
+}
+
+@injectable()
+export class TestOutputUIModel {
+    @inject(TestService) protected testService: TestService;
+
+    protected readonly activeRuns = new Map<string, ActiveTestRunInfo>();
+    protected readonly controllerListeners = new Map<string, Disposable>();
+    private _selectedOutputSource: TestOutputSource | undefined;
+    private _selectedTestState: TestState | undefined;
+
+    @postConstruct()
+    init(): void {
+        this.testService.getControllers().forEach(controller => this.addController(controller));
+        this.testService.onControllersChanged(deltas => {
+            deltas.added?.forEach(controller => this.addController(controller));
+            deltas.removed?.forEach(controller => this.removeController(controller));
+        });
+    }
+
+    protected removeController(id: string): void {
+        this.controllerListeners.get(id)?.dispose();
+        if (this.activeRuns.has(id)) {
+            this.activeRuns.delete(id);
+        }
+    }
+
+    protected addController(controller: TestController): void {
+        this.controllerListeners.set(controller.id, controller.onRunsChanged(delta => {
+            if (delta.added) {
+                const currentRun = controller.testRuns[controller.testRuns.length - 1];
+                if (currentRun) {
+                    this.setActiveTestRun(currentRun);
+                }
+            } else {
+                delta.removed?.forEach(run => {
+                    if (run === this.getActiveTestRun(controller)) {
+                        const currentRun = controller.testRuns[controller.testRuns.length - 1];
+                        this.doSetActiveRun(controller, currentRun);
+                    }
+                });
+            }
+        }));
+    }
+
+    getActiveTestRun(controller: TestController): TestRun | undefined {
+        return this.activeRuns.get(controller.id)?.run;
+    }
+
+    protected readonly onDidChangeActiveTestRunEmitter = new Emitter<ActiveRunEvent>();
+    onDidChangeActiveTestRun: Event<ActiveRunEvent> = this.onDidChangeActiveTestRunEmitter.event;
+
+    setActiveTestRun(run: TestRun): void {
+        this.doSetActiveRun(run.controller, run);
+    }
+
+    doSetActiveRun(controller: TestController, run: TestRun | undefined): void {
+        const old = this.activeRuns.get(controller.id);
+        if (old !== run) {
+            if (old) {
+                old.toDispose.dispose();
+            }
+            if (run) {
+                const toDispose = run.onDidChangeTestState(e => {
+                    this.onDidChangeActiveTestStateEmitter.fire({
+                        controller,
+                        testRun: run,
+                        statedDelta: e
+                    });
+                });
+                this.activeRuns.set(controller.id, { run, toDispose });
+            } else {
+                this.activeRuns.delete(controller.id);
+            }
+            this.onDidChangeActiveTestRunEmitter.fire({ activeRun: run, controller: controller });
+        }
+    }
+
+    private onDidChangeActiveTestStateEmitter: Emitter<ActiveTestStateChangedEvent> = new Emitter();
+    onDidChangeActiveTestState: Event<ActiveTestStateChangedEvent> = this.onDidChangeActiveTestStateEmitter.event;
+
+    get selectedOutputSource(): TestOutputSource | undefined {
+        return this._selectedOutputSource;
+    }
+
+    set selectedOutputSource(element: TestOutputSource | undefined) {
+        if (element !== this._selectedOutputSource) {
+            this._selectedOutputSource = element;
+            this.onDidChangeSelectedOutputSourceEmitter.fire(element);
+        }
+    }
+
+    protected readonly onDidChangeSelectedOutputSourceEmitter = new Emitter<TestOutputSource | undefined>();
+    readonly onDidChangeSelectedOutputSource: Event<TestOutputSource | undefined> = this.onDidChangeSelectedOutputSourceEmitter.event;
+
+    get selectedTestState(): TestState | undefined {
+        return this._selectedTestState;
+    }
+
+    set selectedTestState(element: TestState | undefined) {
+        if (element !== this._selectedTestState) {
+            this._selectedTestState = element;
+            this.onDidChangeSelectedTestStateEmitter.fire(element);
+        }
+    }
+
+    protected readonly onDidChangeSelectedTestStateEmitter = new Emitter<TestState | undefined>();
+    readonly onDidChangeSelectedTestState: Event<TestState | undefined> = this.onDidChangeSelectedTestStateEmitter.event;
+}

package/src/browser/view/test-output-view-contribution.ts

@@ -0,0 +1,34 @@
+// *****************************************************************************
+// 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 { AbstractViewContribution } from '@theia/core/lib/browser';
+import { TestOutputWidget } from './test-output-widget';
+import { injectable } from '@theia/core/shared/inversify';
+import { nls } from '@theia/core';
+
+@injectable()
+export class TestOutputViewContribution extends AbstractViewContribution<TestOutputWidget> {
+    constructor() {
+        super({
+            widgetId: TestOutputWidget.ID,
+            widgetName: nls.localizeByDefault('Test Output'),
+            defaultWidgetOptions: {
+                area: 'bottom'
+            }
+        });
+
+    }
+}

package/src/browser/view/test-output-widget.ts

@@ -0,0 +1,148 @@
+// *****************************************************************************
+// 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 { RendererType, Terminal } from 'xterm';
+import { FitAddon } from 'xterm-addon-fit';
+
+import { BaseWidget, Message, Widget, codicon, isFirefox } from '@theia/core/lib/browser';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { Disposable, DisposableCollection } from '@theia/core';
+import { DEFAULT_TERMINAL_RENDERER_TYPE, TerminalPreferences, TerminalRendererType, isTerminalRendererType } from '@theia/terminal/lib/browser/terminal-preferences';
+import { TerminalThemeService } from '@theia/terminal/lib/browser/terminal-theme-service';
+import { TestOutputSource, TestOutputUIModel } from './test-output-ui-model';
+import debounce = require('p-debounce');
+
+@injectable()
+export class TestOutputWidget extends BaseWidget {
+    @inject(TerminalPreferences) protected readonly preferences: TerminalPreferences;
+    @inject(TerminalThemeService) protected readonly themeService: TerminalThemeService;
+    @inject(TestOutputUIModel) protected readonly uiModel: TestOutputUIModel;
+
+    static ID = 'test-output-view';
+
+    protected term: Terminal;
+    protected disposeOnSetInput = new DisposableCollection();
+    protected fitAddon: FitAddon;
+
+    constructor() {
+        super();
+
+        this.id = TestOutputWidget.ID;
+        this.title.label = 'Test Output';
+        this.title.caption = 'Test Output';
+        this.title.iconClass = codicon('symbol-keyword');
+        this.title.closable = true;
+    }
+
+    @postConstruct()
+    init(): void {
+        this.term = new Terminal({
+            disableStdin: true,
+            cursorStyle: 'bar',
+            fontFamily: this.preferences['terminal.integrated.fontFamily'],
+            fontSize: this.preferences['terminal.integrated.fontSize'],
+            fontWeight: this.preferences['terminal.integrated.fontWeight'],
+            fontWeightBold: this.preferences['terminal.integrated.fontWeightBold'],
+            drawBoldTextInBrightColors: this.preferences['terminal.integrated.drawBoldTextInBrightColors'],
+            letterSpacing: this.preferences['terminal.integrated.letterSpacing'],
+            lineHeight: this.preferences['terminal.integrated.lineHeight'],
+            scrollback: this.preferences['terminal.integrated.scrollback'],
+            fastScrollSensitivity: this.preferences['terminal.integrated.fastScrollSensitivity'],
+            rendererType: this.getTerminalRendererType(this.preferences['terminal.integrated.rendererType']),
+            theme: this.themeService.theme
+        });
+
+        this.fitAddon = new FitAddon();
+        this.term.loadAddon(this.fitAddon);
+        this.setInput(this.uiModel.selectedOutputSource);
+        this.uiModel.onDidChangeSelectedOutputSource(source => this.setInput(source));
+
+        this.toDispose.push(Disposable.create(() =>
+            this.term.dispose()
+        ));
+    }
+
+    setInput(selectedOutputSource: TestOutputSource | undefined): void {
+        this.disposeOnSetInput.dispose();
+        this.disposeOnSetInput = new DisposableCollection();
+        this.term.clear();
+        if (selectedOutputSource) {
+            selectedOutputSource.output.forEach(item => this.term.writeln(item.output));
+            this.disposeOnSetInput.push(selectedOutputSource.onDidAddTestOutput(items => {
+                items.forEach(item => this.term.writeln(item.output));
+            }));
+            this.term.scrollToBottom();
+        }
+    }
+
+    protected override onAfterAttach(msg: Message): void {
+        super.onAfterAttach(msg);
+        this.term.open(this.node);
+
+        if (isFirefox) {
+            // monkey patching intersection observer handling for secondary window support
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const renderService: any = (this.term as any)._core._renderService;
+            const originalFunc: (entry: IntersectionObserverEntry) => void = renderService._onIntersectionChange.bind(renderService);
+            const replacement = function (entry: IntersectionObserverEntry): void {
+                if (entry.target.ownerDocument !== document) {
+                    // in Firefox, the intersection observer always reports the widget as non-intersecting if the dom element
+                    // is in a different document from when the IntersectionObserver started observing. Since we know
+                    // that the widget is always "visible" when in a secondary window, so we mark the entry as "intersecting"
+                    const patchedEvent: IntersectionObserverEntry = {
+                        ...entry,
+                        isIntersecting: true,
+                    };
+                    originalFunc(patchedEvent);
+                } else {
+                    originalFunc(entry);
+                }
+            };
+
+            renderService._onIntersectionChange = replacement;
+        }
+
+        if (isFirefox) {
+            // The software scrollbars don't work with xterm.js, so we disable the scrollbar if we are on firefox.
+            if (this.term.element) {
+                (this.term.element.children.item(0) as HTMLElement).style.overflow = 'hidden';
+            }
+        }
+    }
+
+    private getTerminalRendererType(terminalRendererType?: string | TerminalRendererType): RendererType {
+        if (terminalRendererType && isTerminalRendererType(terminalRendererType)) {
+            return terminalRendererType;
+        }
+        return DEFAULT_TERMINAL_RENDERER_TYPE;
+    }
+
+    protected override onResize(msg: Widget.ResizeMessage): void {
+        super.onResize(msg);
+        this.resizeTerminal();
+    }
+
+    protected resizeTerminal = debounce(() => this.doResizeTerminal(), 50);
+
+    protected doResizeTerminal(): void {
+        if (this.isDisposed) {
+            return;
+        }
+        const geo = this.fitAddon.proposeDimensions();
+        const cols = geo.cols;
+        const rows = geo.rows - 1; // subtract one row for margin
+        this.term.resize(cols, rows);
+    }
+}

package/src/browser/view/test-result-view-contribution.ts

@@ -0,0 +1,34 @@
+// *****************************************************************************
+// 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 { AbstractViewContribution } from '@theia/core/lib/browser';
+import { injectable } from '@theia/core/shared/inversify';
+import { TestResultWidget } from './test-result-widget';
+import { nls } from '@theia/core';
+
+@injectable()
+export class TestResultViewContribution extends AbstractViewContribution<TestResultWidget> {
+    constructor() {
+        super({
+            widgetId: TestResultWidget.ID,
+            widgetName: nls.localizeByDefault('Test Results'),
+            defaultWidgetOptions: {
+                area: 'bottom'
+            }
+        });
+
+    }
+}

package/src/browser/view/test-result-widget.ts

@@ -0,0 +1,92 @@
+// *****************************************************************************
+// 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 { BaseWidget, Message, codicon } from '@theia/core/lib/browser';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { TestOutputUIModel } from './test-output-ui-model';
+import { DisposableCollection, nls } from '@theia/core';
+import { TestFailure, TestMessage } from '../test-service';
+import { MarkdownRenderer } from '@theia/core/lib/browser/markdown-rendering/markdown-renderer';
+import { MarkdownString } from '@theia/core/lib/common/markdown-rendering';
+
+@injectable()
+export class TestResultWidget extends BaseWidget {
+
+    static readonly ID = 'test-result-widget';
+
+    @inject(TestOutputUIModel) uiModel: TestOutputUIModel;
+    @inject(MarkdownRenderer) markdownRenderer: MarkdownRenderer;
+
+    protected toDisposeOnRender = new DisposableCollection();
+    protected input: TestMessage[] = [];
+    protected content: HTMLDivElement;
+
+    constructor() {
+        super();
+        this.id = TestResultWidget.ID;
+        this.title.label = nls.localizeByDefault('Test Results');
+        this.title.caption = nls.localizeByDefault('Test Results');
+        this.title.iconClass = codicon('checklist');
+        this.title.closable = true;
+        this.scrollOptions = {
+            minScrollbarLength: 35,
+        };
+    }
+
+    @postConstruct()
+    init(): void {
+        this.uiModel.onDidChangeSelectedTestState(e => {
+            if (TestFailure.is(e)) {
+                this.setInput(e.messages);
+            }
+        });
+    }
+
+    protected override onAfterAttach(msg: Message): void {
+        super.onAfterAttach(msg);
+        this.content = this.node.ownerDocument.createElement('div');
+        this.node.append(this.content);
+    }
+
+    setInput(messages: TestMessage[]): void {
+        this.input = messages;
+        this.update();
+    }
+
+    protected override onUpdateRequest(msg: Message): void {
+        this.render();
+        super.onUpdateRequest(msg);
+    }
+
+    render(): void {
+        this.toDisposeOnRender.dispose();
+        this.toDisposeOnRender = new DisposableCollection();
+        this.content.innerHTML = '';
+        this.input.forEach(message => {
+            if (MarkdownString.is(message.message)) {
+                const line = this.markdownRenderer.render(message.message);
+                this.content.append(line.element);
+                this.toDisposeOnRender.push(line);
+            } else {
+                this.content.append(this.node.ownerDocument.createTextNode(message.message));
+            }
+        });
+    }
+
+    override dispose(): void {
+        this.toDisposeOnRender.dispose();
+    }
+}