@opensumi/ide-testing 2.21.13 → 2.22.0

package/src/common/getComputedState.ts

@@ -0,0 +1,136 @@
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Iterable } from '@opensumi/monaco-editor-core/esm/vs/base/common/iterator';
+
+import { TestResultState } from './testCollection';
+import { maxPriority, statePriority } from './testingStates';
+
+/**
+ * Accessor for nodes in get and refresh computed state.
+ */
+export interface IComputedStateAccessor<T> {
+  getOwnState(item: T): TestResultState | undefined;
+  getCurrentComputedState(item: T): TestResultState;
+  setComputedState(item: T, state: TestResultState): void;
+  getChildren(item: T): Iterable<T>;
+  getParents(item: T): Iterable<T>;
+}
+
+export interface IComputedStateAndDurationAccessor<T> extends IComputedStateAccessor<T> {
+  getOwnDuration(item: T): number | undefined;
+  getCurrentComputedDuration(item: T): number | undefined;
+  setComputedDuration(item: T, duration: number | undefined): void;
+}
+
+export const isDurationAccessor = <T>(
+  accessor: IComputedStateAccessor<T>,
+): accessor is IComputedStateAndDurationAccessor<T> => 'getOwnDuration' in accessor;
+
+/**
+ * Gets the computed state for the node.
+ * @param force whether to refresh the computed state for this node, even
+ * if it was previously set.
+ */
+
+export const getComputedState = <T>(accessor: IComputedStateAccessor<T>, node: T, force = false) => {
+  let computed = accessor.getCurrentComputedState(node);
+  if (computed === undefined || force) {
+    computed = accessor.getOwnState(node) ?? TestResultState.Unset;
+    for (const child of accessor.getChildren(node)) {
+      computed = maxPriority(computed, getComputedState(accessor, child));
+    }
+
+    accessor.setComputedState(node, computed);
+  }
+
+  return computed;
+};
+
+export const getComputedDuration = <T>(
+  accessor: IComputedStateAndDurationAccessor<T>,
+  node: T,
+  force = false,
+): number | undefined => {
+  let computed = accessor.getCurrentComputedDuration(node);
+  if (computed === undefined || force) {
+    const own = accessor.getOwnDuration(node);
+    if (own !== undefined) {
+      computed = own;
+    } else {
+      computed = undefined;
+      for (const child of accessor.getChildren(node)) {
+        const d = getComputedDuration(accessor, child);
+        if (d !== undefined) {
+          computed = (computed || 0) + d;
+        }
+      }
+    }
+
+    accessor.setComputedDuration(node, computed);
+  }
+
+  return computed;
+};
+
+/**
+ * Refreshes the computed state for the node and its parents. Any changes
+ * elements cause `addUpdated` to be called.
+ */
+export const refreshComputedState = <T>(
+  accessor: IComputedStateAccessor<T>,
+  node: T,
+  explicitNewComputedState?: TestResultState,
+) => {
+  const oldState = accessor.getCurrentComputedState(node);
+  const oldPriority = statePriority[oldState];
+  const newState = explicitNewComputedState ?? getComputedState(accessor, node, true);
+  const newPriority = statePriority[newState];
+  const toUpdate = new Set<T>();
+
+  if (newPriority !== oldPriority) {
+    accessor.setComputedState(node, newState);
+    toUpdate.add(node);
+
+    if (newPriority > oldPriority) {
+      // Update all parents to ensure they're at least this priority.
+      for (const parent of accessor.getParents(node)) {
+        const prev = accessor.getCurrentComputedState(parent);
+        if (prev !== undefined && statePriority[prev] >= newPriority) {
+          break;
+        }
+
+        accessor.setComputedState(parent, newState);
+        toUpdate.add(parent);
+      }
+    } else if (newPriority < oldPriority) {
+      // Re-render all parents of this node whose computed priority might have come from this node
+      for (const parent of accessor.getParents(node)) {
+        const prev = accessor.getCurrentComputedState(parent);
+        if (prev === undefined || statePriority[prev] > oldPriority) {
+          break;
+        }
+
+        accessor.setComputedState(parent, getComputedState(accessor, parent, true));
+        toUpdate.add(parent);
+      }
+    }
+  }
+
+  if (isDurationAccessor(accessor)) {
+    for (const parent of Iterable.concat(Iterable.single(node), accessor.getParents(node))) {
+      const oldDuration = accessor.getCurrentComputedDuration(parent);
+      const newDuration = getComputedDuration(accessor, parent, true);
+      if (oldDuration === newDuration) {
+        break;
+      }
+
+      accessor.setComputedDuration(parent, newDuration);
+      toUpdate.add(parent);
+    }
+  }
+
+  return toUpdate;
+};

package/src/common/index.ts

@@ -0,0 +1,55 @@
+import { Event, IDisposable, CancellationToken } from '@opensumi/ide-core-browser';
+
+import { ObservableValue } from './observableValue';
+import { ITestResult } from './test-result';
+import {
+  InternalTestItem,
+  MainThreadTestCollection,
+  ResolvedTestRunRequest,
+  RunTestForControllerRequest,
+  TestRunProfileBitset,
+  TestsDiff,
+} from './testCollection';
+
+export * from './testId';
+
+export interface ITestController {
+  readonly id: string;
+  readonly label: string;
+  readonly canRefresh: ObservableValue<boolean>;
+  configureRunProfile(profileId: number): void;
+  expandTest(testId: string, levels: number): Promise<void>;
+  refreshTests(token: CancellationToken): Promise<void>;
+  runTests(request: RunTestForControllerRequest, token: CancellationToken): Promise<void>;
+}
+
+export const TestServiceToken = Symbol('TestService');
+export const TestDecorationsToken = Symbol('TestDecorationsToken');
+export const TestPeekMessageToken = Symbol('TestPeekMessageToken');
+
+export interface ITestingPeekMessageService {
+  onDidReveal: Event<any>;
+}
+
+export interface ITestService {
+  readonly collection: MainThreadTestCollection;
+
+  registerTestController(id: string, testController: ITestController): IDisposable;
+  runTests(req: AmbiguousRunTestsRequest, token?: CancellationToken): Promise<ITestResult>;
+  publishDiff(controllerId: string, diff: TestsDiff): void;
+  runResolvedTests(req: ResolvedTestRunRequest, token?: CancellationToken): Promise<ITestResult>;
+  onDidProcessDiff: Event<TestsDiff>;
+  getTestController(controllerId: string): ITestController | undefined;
+  refreshTests(controllerId?: string): Promise<void>;
+}
+
+export interface AmbiguousRunTestsRequest {
+  /** Group to run */
+  group: TestRunProfileBitset;
+  /** Tests to run. Allowed to be from different controllers */
+  tests: readonly InternalTestItem[];
+  /** Tests to exclude. If not given, the current UI excluded tests are used */
+  exclude?: InternalTestItem[];
+  /** Whether this was triggered from an auto run. */
+  isAutoRun?: boolean;
+}

package/src/common/observableValue.ts

@@ -0,0 +1,27 @@
+import { Disposable, Emitter, Event } from '@opensumi/ide-core-common';
+
+export interface IObservableValue<T> {
+  onDidChange: Event<T>;
+  readonly value: T;
+}
+
+export class ObservableValue<T> extends Disposable implements IObservableValue<T> {
+  private readonly changeEmitter = this.registerDispose(new Emitter<T>());
+
+  public readonly onDidChange = this.changeEmitter.event;
+
+  public get value() {
+    return this._value;
+  }
+
+  public set value(v: T) {
+    if (v !== this._value) {
+      this._value = v;
+      this.changeEmitter.fire(v);
+    }
+  }
+
+  constructor(private _value: T) {
+    super();
+  }
+}

package/src/common/test-profile.ts

@@ -0,0 +1,25 @@
+import { ITestController, TestId } from '../index';
+
+import { InternalTestItem, ITestRunProfile, TestRunProfileBitset } from './testCollection';
+
+export const sorter = (a: ITestRunProfile, b: ITestRunProfile) => {
+  if (a.isDefault !== b.isDefault) {
+    return a.isDefault ? -1 : 1;
+  }
+
+  return a.label.localeCompare(b.label);
+};
+
+export const canUseProfileWithTest = (profile: ITestRunProfile, test: InternalTestItem) =>
+  profile.controllerId === test.controllerId &&
+  (TestId.isRoot(test.item.extId) || !profile.tag || test.item.tags.includes(profile.tag));
+
+export const TestProfileServiceToken = Symbol('TestProfileService');
+
+export interface ITestProfileService {
+  addProfile(controller: ITestController, profile: ITestRunProfile): void;
+  removeProfile(controllerId: string, profileId?: number): void;
+
+  getBaseDefaultsProfile(group: TestRunProfileBitset): ITestRunProfile[];
+  getControllerProfiles(controllerId: string): ITestRunProfile[];
+}

package/src/common/test-result.ts

@@ -0,0 +1,328 @@
+import { Emitter, formatLocalize, localize } from '@opensumi/ide-core-common';
+
+import { IComputedStateAccessor, refreshComputedState } from './getComputedState';
+import {
+  ExtensionRunTestsRequest,
+  IRichLocation,
+  ISerializedTestResults,
+  ITestItem,
+  ITestMessage,
+  ITestOutputMessage,
+  ITestRunTask,
+  ITestTaskState,
+  ResolvedTestRunRequest,
+  SerializedTestMessage,
+  TestItemExpandState,
+  TestResultItem,
+  TestResultState,
+} from './testCollection';
+import { maxPriority, statesInOrder } from './testingStates';
+
+export type TestStateCount = { [K in TestResultState]: number };
+
+export const makeEmptyCounts = () => {
+  const o: Partial<TestStateCount> = {};
+  for (const state of statesInOrder) {
+    o[state] = 0;
+  }
+
+  return o as TestStateCount;
+};
+export interface ITestRunTaskResults extends ITestRunTask {
+  readonly coverage: any | undefined;
+
+  readonly otherMessages: ITestOutputMessage[];
+}
+
+export const TestResultServiceToken = Symbol('TestResultService');
+
+export const enum TestResultItemChangeReason {
+  Retired,
+  ParentRetired,
+  ComputedStateChange,
+  OwnStateChange,
+}
+
+interface TestResultItemWithChildren extends TestResultItem {
+  children: TestResultItemWithChildren[];
+}
+
+const itemToNode = (controllerId: string, item: ITestItem, parent: string | null): TestResultItemWithChildren => ({
+  parent,
+  controllerId,
+  expand: TestItemExpandState.NotExpandable,
+  item: { ...item },
+  children: [],
+  tasks: [],
+  ownComputedState: TestResultState.Unset,
+  computedState: TestResultState.Unset,
+  retired: false,
+});
+
+export type TestResultItemChange = { item: TestResultItem; result: ITestResult } & (
+  | {
+      reason:
+        | TestResultItemChangeReason.Retired
+        | TestResultItemChangeReason.ParentRetired
+        | TestResultItemChangeReason.ComputedStateChange;
+    }
+  | { reason: TestResultItemChangeReason.OwnStateChange; previous: TestResultState }
+);
+
+export interface ITestResultService {
+  createTestResult(req: ResolvedTestRunRequest | ExtensionRunTestsRequest): ITestResult;
+  addTestResult(result: ITestResult): void;
+  getResult(resultId: string): ITestResult | undefined;
+  readonly results: ReadonlyArray<ITestResult>;
+}
+
+export const maxCountPriority = (counts: Readonly<TestStateCount>) => {
+  for (const state of statesInOrder) {
+    if (counts[state] > 0) {
+      return state;
+    }
+  }
+
+  return TestResultState.Unset;
+};
+
+export const resultItemParents = function* (results: ITestResult, item: TestResultItem) {
+  let i: TestResultItem | undefined = item;
+  while (i) {
+    yield i;
+    i = i.parent ? results.getStateById(i.parent) : undefined;
+  }
+};
+
+export interface ITestResult {
+  readonly counts: Readonly<TestStateCount>;
+
+  readonly id: string;
+
+  readonly completedAt: number | undefined;
+
+  readonly request: ResolvedTestRunRequest;
+
+  readonly name: string;
+
+  tests: IterableIterator<TestResultItem>;
+
+  tasks: ReadonlyArray<ITestRunTaskResults>;
+
+  getStateById(testExtId: string): TestResultItem | undefined;
+
+  getOutput(): Promise<string>;
+
+  toJSON(): ISerializedTestResults | undefined;
+
+  updateState(testId: string, taskId: string, state: TestResultState, duration?: number): void;
+
+  appendOutput(output: string, taskId: string, location?: IRichLocation, testId?: string): void;
+
+  addTestChainToRun(controllerId: string, chain: ReadonlyArray<ITestItem>): void;
+
+  addTask(task: ITestRunTask): void;
+
+  markTaskComplete(taskId: string): void;
+
+  markComplete(): void;
+}
+
+export class TestResultImpl implements ITestResult {
+  private readonly completeEmitter = new Emitter<void>();
+  private readonly changeEmitter = new Emitter<TestResultItemChange>();
+  private readonly testById = new Map<string, TestResultItemWithChildren>();
+
+  private _completedAt?: number;
+
+  public readonly name: string = formatLocalize('test.result.runFinished', new Date().toLocaleString());
+  public readonly tasks: ITestRunTaskResults[] = [];
+  public readonly onChange = this.changeEmitter.event;
+  public readonly onComplete = this.completeEmitter.event;
+  public readonly counts: { [K in TestResultState]: number } = makeEmptyCounts();
+
+  public get completedAt() {
+    return this._completedAt;
+  }
+
+  public get tests() {
+    return this.testById.values();
+  }
+
+  constructor(public readonly id: string, public readonly request: ResolvedTestRunRequest) {}
+
+  protected setAllToState(
+    state: TestResultState,
+    taskId: string,
+    when: (task: ITestTaskState, item: TestResultItem) => boolean,
+  ) {
+    const index = this.mustGetTaskIndex(taskId);
+    for (const test of this.testById.values()) {
+      if (when(test.tasks[index], test)) {
+        this.fireUpdateAndRefresh(test, index, state);
+      }
+    }
+  }
+
+  private readonly computedStateAccessor: IComputedStateAccessor<TestResultItemWithChildren> = {
+    getOwnState: (i) => i.ownComputedState,
+    getCurrentComputedState: (i) => i.computedState,
+    setComputedState: (i, s) => (i.computedState = s),
+    getChildren: (i) => i.children,
+    getParents: (i) => {
+      const { testById: testByExtId } = this;
+      return (function* () {
+        for (let parentId = i.parent; parentId; ) {
+          const parent = testByExtId.get(parentId);
+          if (!parent) {
+            break;
+          }
+
+          yield parent;
+          parentId = parent.parent;
+        }
+      })();
+    },
+  };
+
+  private addTestToRun(controllerId: string, item: ITestItem, parent: string | null) {
+    const node = itemToNode(controllerId, item, parent);
+    this.testById.set(item.extId, node);
+    this.counts[TestResultState.Unset]++;
+
+    if (parent) {
+      this.testById.get(parent)?.children.push(node);
+    }
+
+    if (this.tasks.length) {
+      this.tasks.forEach(() => {
+        node.tasks.push({ duration: undefined, messages: [], state: TestResultState.Queued });
+      });
+    }
+
+    return node;
+  }
+
+  private mustGetTaskIndex(taskId: string) {
+    const index = this.tasks.findIndex((t) => t.id === taskId);
+    if (index === -1) {
+      throw new Error(`Unknown task ${taskId} in updateState`);
+    }
+
+    return index;
+  }
+
+  private fireUpdateAndRefresh(entry: TestResultItem, taskIndex: number, newState: TestResultState) {
+    const previousOwnComputed = entry.ownComputedState;
+    entry.tasks[taskIndex].state = newState;
+    const newOwnComputed = maxPriority(...entry.tasks.map((t) => t.state));
+    if (newOwnComputed === previousOwnComputed) {
+      return;
+    }
+
+    entry.ownComputedState = newOwnComputed;
+    this.counts[previousOwnComputed]--;
+    this.counts[newOwnComputed]++;
+    refreshComputedState(this.computedStateAccessor, entry).forEach((t) =>
+      this.changeEmitter.fire(
+        t === entry
+          ? {
+              item: entry,
+              result: this,
+              reason: TestResultItemChangeReason.OwnStateChange,
+              previous: previousOwnComputed,
+            }
+          : { item: t, result: this, reason: TestResultItemChangeReason.ComputedStateChange },
+      ),
+    );
+  }
+
+  getStateById(testExtId: string): TestResultItem | undefined {
+    return this.testById.get(testExtId);
+  }
+
+  getOutput(): Promise<string> {
+    throw new Error('Method not implemented.');
+  }
+  toJSON(): ISerializedTestResults | undefined {
+    throw new Error('Method not implemented.');
+  }
+  updateState(testId: string, taskId: string, state: TestResultState, duration?: number): void {
+    const entry = this.testById.get(testId);
+    if (!entry) {
+      return;
+    }
+
+    const index = this.mustGetTaskIndex(taskId);
+    if (duration !== undefined) {
+      entry.tasks[index].duration = duration;
+      entry.ownDuration = Math.max(entry.ownDuration || 0, duration);
+    }
+
+    this.fireUpdateAndRefresh(entry, index, state);
+  }
+  appendMessage(testId: string, taskId: string, message: ITestMessage | SerializedTestMessage) {
+    const entry = this.testById.get(testId);
+    if (!entry) {
+      return;
+    }
+
+    entry.tasks[this.mustGetTaskIndex(taskId)].messages.push(message as ITestMessage);
+    this.changeEmitter.fire({
+      item: entry,
+      result: this,
+      reason: TestResultItemChangeReason.OwnStateChange,
+      previous: entry.ownComputedState,
+    });
+  }
+  appendOutput(output: string, taskId: string, location?: IRichLocation, testId?: string): void {
+    throw new Error('Method not implemented.');
+  }
+  addTestChainToRun(controllerId: string, chain: readonly ITestItem[]): void {
+    let parent = this.testById.get(chain[0].extId);
+    if (!parent) {
+      parent = this.addTestToRun(controllerId, chain[0], null);
+    }
+
+    for (let i = 1; i < chain.length; i++) {
+      parent = this.addTestToRun(controllerId, chain[i], parent.item.extId);
+    }
+
+    for (let i = 0; i < this.tasks.length; i++) {
+      this.fireUpdateAndRefresh(parent, i, TestResultState.Queued);
+    }
+
+    return undefined;
+  }
+  addTask(task: ITestRunTask): void {
+    const index = this.tasks.length;
+    // ** coverage not implemented **
+    this.tasks.push({ ...task, coverage: undefined, otherMessages: [] });
+    for (const test of this.tests) {
+      test.tasks.push({ duration: undefined, messages: [], state: TestResultState.Unset });
+      this.fireUpdateAndRefresh(test, index, TestResultState.Queued);
+    }
+  }
+  markTaskComplete(taskId: string): void {
+    this.tasks[this.mustGetTaskIndex(taskId)].running = false;
+    this.setAllToState(
+      TestResultState.Unset,
+      taskId,
+      (t) => t.state === TestResultState.Queued || t.state === TestResultState.Running,
+    );
+  }
+  markComplete(): void {
+    if (this._completedAt !== undefined) {
+      throw new Error('cannot complete a test result multiple times');
+    }
+
+    for (const task of this.tasks) {
+      if (task.running) {
+        this.markTaskComplete(task.id);
+      }
+    }
+
+    this._completedAt = Date.now();
+    this.completeEmitter.fire();
+  }
+}