@opensumi/ide-testing 2.21.13 → 2.22.0

package/src/browser/test-tree-view.model.ts

@@ -0,0 +1,304 @@
+import { Autowired, Injectable } from '@opensumi/di';
+import { CompositeTreeNode, IRecycleTreeHandle, TreeNodeEvent } from '@opensumi/ide-components';
+import { BasicCompositeTreeNode } from '@opensumi/ide-components/lib/recycle-tree/basic/tree-node.define';
+import { Disposable, isDefined, filter, map, Emitter } from '@opensumi/ide-core-browser';
+import { Iterable } from '@opensumi/monaco-editor-core/esm/vs/base/common/iterator';
+
+import { ITestService, TestServiceToken } from '../common';
+import { IComputedStateAndDurationAccessor, refreshComputedState } from '../common/getComputedState';
+import { TestResultServiceToken } from '../common/test-result';
+import {
+  InternalTestItem,
+  TestDiffOpType,
+  TestItemExpandState,
+  TestResultState,
+  TestsDiff,
+} from '../common/testCollection';
+import { ITestTreeItem, ITestTreeViewModel } from '../common/tree-view.model';
+
+import { applyTestItemUpdate, IncrementalTestCollectionItem, ITestItemUpdate } from './../common/testCollection';
+import { ITestTreeData } from './../common/tree-view.model';
+import { ResultChangeEvent, TestResultServiceImpl } from './test.result.service';
+
+const computedStateAccessor: IComputedStateAndDurationAccessor<ITestTreeItem> = {
+  getOwnState: (i) => (i instanceof TestTreeItem ? i.ownState : TestResultState.Unset),
+  getCurrentComputedState: (i) => i.state,
+  setComputedState: (i, s) => (i.state = s),
+  getCurrentComputedDuration: (i) => i.duration,
+  getOwnDuration: (i) => (i instanceof TestTreeItem ? i.ownDuration : undefined),
+  setComputedDuration: (i, d) => (i.duration = d),
+  getChildren: (i) => Iterable.filter(i.children.values(), (t): t is TestTreeItem => t instanceof TestTreeItem),
+  *getParents(i) {
+    for (let parent = i.parent; parent; parent = parent.parent) {
+      yield parent;
+    }
+  },
+};
+
+export class TestTreeItem implements ITestTreeItem {
+  constructor(public test: InternalTestItem, public parent: ITestTreeItem | undefined) {}
+
+  readonly children = new Set<TestTreeItem>();
+
+  public get label() {
+    return this.test.item.label;
+  }
+
+  public get sortText() {
+    return this.test.item.sortText;
+  }
+
+  public state = TestResultState.Unset;
+
+  public ownState = TestResultState.Unset;
+
+  public depth: number = this.parent ? this.parent.depth + 1 : 0;
+
+  public get tests() {
+    return [this.test];
+  }
+
+  public update = (patch: ITestItemUpdate) => {
+    applyTestItemUpdate(this.test, patch);
+  };
+
+  public duration: number | undefined;
+
+  public ownDuration: number | undefined;
+
+  public retired = false;
+}
+
+@Injectable()
+export class TestTreeViewModelImpl extends Disposable implements ITestTreeViewModel {
+  @Autowired(TestServiceToken)
+  private readonly testService: ITestService;
+
+  @Autowired(TestResultServiceToken)
+  private readonly testResultService: TestResultServiceImpl;
+
+  private readonly items = new Map<string, TestTreeItem>();
+
+  private readonly updateEmitter = new Emitter<void>();
+  readonly onUpdate = this.updateEmitter.event;
+
+  public treeHandlerApi: IRecycleTreeHandle;
+
+  constructor() {
+    super();
+    this.addDispose(this.testService.onDidProcessDiff((diff) => this.applyDiff(diff)));
+
+    for (const test of this.testService.collection.all) {
+      this.didUpdateItem(this.createItem(test));
+    }
+  }
+
+  get roots(): Iterable<TestTreeItem> {
+    const rootsIt = map(this.testService.collection.rootItems, (r) => this.items.get(r.item.extId));
+    return filter(rootsIt, isDefined);
+  }
+
+  private getRevealDepth(element: TestTreeItem): number | undefined {
+    return element.depth === 0 ? 0 : undefined;
+  }
+
+  private createItem(item: InternalTestItem): TestTreeItem {
+    const parent = item.parent ? this.items.get(item.parent) : undefined;
+    return new TestTreeItem(item, parent);
+  }
+
+  private findTestTreeItemByExtId(extId: string | undefined): CompositeTreeNode | undefined {
+    if (!this.treeHandlerApi || !extId) {
+      return;
+    }
+
+    const model = this.treeHandlerApi.getModel();
+    if (!model) {
+      return;
+    }
+
+    const findTreeItemByExtId = model.root.flattenedBranch!.find(
+      (id) =>
+        ((model.root.getTreeNodeById(id) as BasicCompositeTreeNode).raw as ITestTreeData).rawItem.test.item.extId ===
+        extId,
+    );
+    const treeItem = model.root.getTreeNodeById(findTreeItemByExtId!) as CompositeTreeNode;
+    return treeItem;
+  }
+
+  private didUnStoreItem(items: Map<string, TestTreeItem>, item: TestTreeItem) {
+    const parent = item.parent;
+    parent?.children.delete(item);
+    items.delete(item.test.item.extId);
+    if (parent instanceof TestTreeItem) {
+      refreshComputedState(computedStateAccessor, parent);
+    }
+
+    return item.children;
+  }
+
+  private async didUpdateItem(item: TestTreeItem) {
+    item.parent?.children.add(item);
+    this.items.set(item.test.item.extId, item);
+    const reveal = this.getRevealDepth(item);
+    if (reveal !== undefined) {
+      await this.expandElement(item, reveal);
+    }
+
+    const prevState = this.testResultService.getStateById(item.test.item.extId)?.[1];
+    if (prevState) {
+      item.retired = prevState.retired;
+      item.ownState = prevState.computedState;
+      item.ownDuration = prevState.ownDuration;
+      refreshComputedState(computedStateAccessor, item);
+    }
+  }
+
+  private async applyDiff(diff: TestsDiff) {
+    for (const op of diff) {
+      switch (op[0]) {
+        case TestDiffOpType.Add: {
+          const item = this.createItem(op[1]);
+          await this.didUpdateItem(item);
+
+          const treeItem = this.findTestTreeItemByExtId(item.parent?.test.item.extId);
+          if (treeItem) {
+            treeItem.refresh();
+          }
+          break;
+        }
+        case TestDiffOpType.Update: {
+          const patch = op[1];
+          const existing = this.items.get(patch.extId);
+          if (!existing) {
+            break;
+          }
+
+          existing.update(patch);
+          break;
+        }
+        case TestDiffOpType.Remove: {
+          const toRemove = this.items.get(op[1]);
+          if (!toRemove) {
+            break;
+          }
+
+          const treeItem = this.findTestTreeItemByExtId(toRemove.test.item.extId);
+          if (treeItem) {
+            (treeItem.parent as CompositeTreeNode).unlinkItem(treeItem);
+          }
+
+          const queue: Iterable<TestTreeItem>[] = [[toRemove]];
+          while (queue.length) {
+            for (const item of queue.pop()!) {
+              if (item instanceof TestTreeItem) {
+                queue.push(this.didUnStoreItem(this.items, item));
+              }
+            }
+          }
+
+          break;
+        }
+      }
+    }
+
+    if (diff.length !== 0) {
+      this.updateEmitter.fire();
+    }
+  }
+
+  private listenTreeHandlerEvent(): void {
+    if (this.treeHandlerApi) {
+      const model = this.treeHandlerApi.getModel();
+      this.addDispose(
+        model.root.watcher.on(TreeNodeEvent.DidChangeExpansionState, async (node: BasicCompositeTreeNode) => {
+          if (node.expanded) {
+            const raw = node.raw as ITestTreeData;
+            const rawTest = raw.rawItem.test;
+            if (rawTest.expand === TestItemExpandState.NotExpandable) {
+              return;
+            }
+
+            await this.expandElement(raw.rawItem, raw.rawItem.depth);
+            await node.refresh();
+          }
+        }),
+      );
+      this.addDispose(
+        this.testResultService.onTestChanged(({ item: result }) => {
+          if (result.ownComputedState === TestResultState.Unset) {
+            const fallback = this.testResultService.getStateById(result.item.extId);
+            if (fallback) {
+              result = fallback[1];
+            }
+          }
+
+          const item = this.items.get(result.item.extId);
+          if (!item) {
+            return;
+          }
+
+          item.retired = result.retired;
+          item.ownState = result.ownComputedState;
+          item.ownDuration = result.ownDuration;
+          const explicitComputed = item.children.size ? undefined : result.computedState;
+          refreshComputedState(computedStateAccessor, item, explicitComputed);
+          model.dispatchChange();
+          this.revealTreeById(result.item.extId, false, false);
+          this.updateEmitter.fire();
+        }),
+      );
+      this.addDispose(
+        this.testResultService.onResultsChanged((evt: ResultChangeEvent) => {
+          if (!('removed' in evt)) {
+            return;
+          }
+
+          for (const inTree of [...this.items.values()].sort((a, b) => b.depth - a.depth)) {
+            const lookup = this.testResultService.getStateById(inTree.test.item.extId)?.[1];
+            inTree.ownDuration = lookup?.ownDuration;
+            refreshComputedState(computedStateAccessor, inTree, lookup?.ownComputedState ?? TestResultState.Unset);
+          }
+
+          model.dispatchChange();
+          this.updateEmitter.fire();
+        }),
+      );
+    }
+  }
+
+  private revealTreeById(id: string | undefined, expand = true, focus = true): void {
+    if (!id) {
+      return;
+    }
+
+    // ** 此处要定位到对应 tree 位置 **
+  }
+
+  public getTestItem(extId: string): IncrementalTestCollectionItem | undefined {
+    return this.testService.collection.getNodeById(extId);
+  }
+
+  public getTestTreeItem(extId: string): TestTreeItem | undefined {
+    return this.items.get(extId);
+  }
+
+  public expandElement(element: ITestTreeItem, depth: number): Promise<void> {
+    if (!(element instanceof TestTreeItem)) {
+      return Promise.resolve();
+    }
+    if (element.test.expand === TestItemExpandState.NotExpandable) {
+      return Promise.resolve();
+    }
+    return this.testService.collection.expand(element.test.item.extId, depth);
+  }
+
+  public initTreeModel(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  public setTreeHandlerApi(handle: IRecycleTreeHandle): void {
+    this.treeHandlerApi = handle;
+    this.listenTreeHandlerEvent();
+  }
+}

package/src/browser/test.result.service.ts

@@ -0,0 +1,193 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import { Emitter, IContextKey, IContextKeyService, URI, uuid, arrays } from '@opensumi/ide-core-browser';
+import { TestingHasAnyResults, TestingIsRunning } from '@opensumi/ide-core-browser/lib/contextkey/testing';
+
+import { ITestProfileService, TestProfileServiceToken } from '../common/test-profile';
+import {
+  ITestResult,
+  ITestResultService,
+  TestResultImpl,
+  TestResultItemChange,
+  TestResultItemChangeReason,
+} from '../common/test-result';
+import {
+  ResolvedTestRunRequest,
+  ExtensionRunTestsRequest,
+  ITestRunProfile,
+  TestResultItem,
+  TestResultState,
+} from '../common/testCollection';
+import { parseTestUri } from '../common/testingUri';
+
+import { TestDto } from './outputPeek/test-output-peek';
+
+const { findFirstInSorted } = arrays;
+
+export type ResultChangeEvent =
+  | { completed: ITestResult }
+  | { started: ITestResult }
+  | { inserted: ITestResult }
+  | { removed: ITestResult[] };
+
+export const isRunningTests = (service: ITestResultService) =>
+  service.results.length > 0 && service.results[0].completedAt === undefined;
+
+@Injectable()
+export class TestResultServiceImpl implements ITestResultService {
+  @Autowired(TestProfileServiceToken)
+  protected readonly testProfiles: ITestProfileService;
+
+  @Autowired(IContextKeyService)
+  private readonly contextKeyService: IContextKeyService;
+
+  private changeResultEmitter = new Emitter<ResultChangeEvent>();
+  private testChangeEmitter = new Emitter<TestResultItemChange>();
+
+  private _results: ITestResult[] = [];
+  private readonly hasAnyResults: IContextKey<boolean>;
+  private readonly isRunning: IContextKey<boolean>;
+
+  public get results(): ITestResult[] {
+    return this._results;
+  }
+
+  public readonly onResultsChanged = this.changeResultEmitter.event;
+  public readonly onTestChanged = this.testChangeEmitter.event;
+
+  constructor() {
+    this.hasAnyResults = TestingHasAnyResults.bind(this.contextKeyService);
+    this.isRunning = TestingIsRunning.bind(this.contextKeyService);
+  }
+
+  private onComplete(result: ITestResult) {
+    this.resort();
+    this.updateIsRunning();
+    this.changeResultEmitter.fire({ completed: result });
+  }
+
+  private resort() {
+    this.results.sort(
+      (a, b) => (b.completedAt ?? Number.MAX_SAFE_INTEGER) - (a.completedAt ?? Number.MAX_SAFE_INTEGER),
+    );
+  }
+
+  private updateIsRunning() {
+    this.isRunning.set(isRunningTests(this));
+  }
+
+  public retrieveTest(uri: URI): TestDto | undefined {
+    const parts = parseTestUri(uri);
+    if (!parts) {
+      return undefined;
+    }
+
+    const { resultId, testExtId, taskIndex, messageIndex } = parts;
+    const test = this.getResult(parts.resultId)?.getStateById(testExtId);
+    if (!test || !test.tasks[parts.taskIndex]) {
+      return;
+    }
+
+    return new TestDto(resultId, test, taskIndex, messageIndex);
+  }
+
+  public createTestResult(req: ResolvedTestRunRequest | ExtensionRunTestsRequest): ITestResult {
+    if ('targets' in req) {
+      const id = uuid();
+      const testResult = new TestResultImpl(id, req);
+      this.addTestResult(testResult);
+      return testResult;
+    }
+
+    let profile: ITestRunProfile | undefined;
+    if ((req as ExtensionRunTestsRequest).profile) {
+      const profiles = this.testProfiles.getControllerProfiles((req as ExtensionRunTestsRequest).controllerId);
+      profile = profiles.find((c) => c.profileId === (req as ExtensionRunTestsRequest).profile!.id);
+    }
+
+    const resolved: ResolvedTestRunRequest = {
+      targets: [],
+      exclude: (req as ExtensionRunTestsRequest).exclude,
+      isAutoRun: false,
+    };
+
+    if (profile) {
+      resolved.targets.push({
+        profileGroup: profile.group,
+        profileId: profile.profileId,
+        controllerId: (req as ExtensionRunTestsRequest).controllerId,
+        testIds: (req as ExtensionRunTestsRequest).include,
+      });
+    }
+
+    const result = new TestResultImpl((req as ExtensionRunTestsRequest).id, resolved);
+    this.addTestResult(result);
+    return result;
+  }
+
+  public getResult(resultId: string): ITestResult | undefined {
+    return this.results.find((r) => r.id === resultId);
+  }
+
+  public addTestResult(result: ITestResult): ITestResult {
+    if (result.completedAt === undefined) {
+      this.results.unshift(result);
+    } else {
+      const index = findFirstInSorted(
+        this.results,
+        (r) => r.completedAt !== undefined && r.completedAt <= result.completedAt!,
+      );
+      this.results.splice(index, 0, result);
+    }
+
+    this.hasAnyResults.set(true);
+
+    if (result instanceof TestResultImpl) {
+      result.onComplete(() => this.onComplete(result));
+      result.onChange(this.testChangeEmitter.fire, this.testChangeEmitter);
+      this.isRunning.set(true);
+      this.changeResultEmitter.fire({ started: result });
+    } else {
+      this.changeResultEmitter.fire({ inserted: result });
+      for (const item of result.tests) {
+        for (const otherResult of this.results) {
+          if (otherResult === result) {
+            this.testChangeEmitter.fire({ item, result, reason: TestResultItemChangeReason.ComputedStateChange });
+            break;
+          } else if (otherResult.getStateById(item.item.extId) !== undefined) {
+            break;
+          }
+        }
+      }
+    }
+
+    return result;
+  }
+
+  public getStateById(extId: string): [results: ITestResult, item: TestResultItem] | undefined {
+    for (const result of this.results) {
+      const lookup = result.getStateById(extId);
+      if (lookup && lookup.computedState !== TestResultState.Unset) {
+        return [result, lookup];
+      }
+    }
+    return undefined;
+  }
+
+  public clear() {
+    const keep: ITestResult[] = [];
+    const removed: ITestResult[] = [];
+    for (const result of this.results) {
+      if (result.completedAt !== undefined) {
+        removed.push(result);
+      } else {
+        keep.push(result);
+      }
+    }
+
+    this._results = keep;
+    if (keep.length === 0) {
+      this.hasAnyResults.set(false);
+    }
+    this.changeResultEmitter.fire({ removed });
+  }
+}

package/src/browser/test.service.ts

@@ -0,0 +1,190 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import {
+  CancellationToken,
+  CancellationTokenSource,
+  Disposable,
+  Emitter,
+  getIcon,
+  IDisposable,
+  localize,
+  SlotLocation,
+} from '@opensumi/ide-core-browser';
+import { IContextKey, IContextKeyService } from '@opensumi/ide-core-browser/lib/context-key';
+import { TestingCanRefreshTests, TestingServiceProviderCount } from '@opensumi/ide-core-browser/lib/contextkey/testing';
+import { IMainLayoutService } from '@opensumi/ide-main-layout';
+
+import { AmbiguousRunTestsRequest, ITestController, ITestService, TestId } from '../common';
+import { Testing } from '../common/constants';
+import { canUseProfileWithTest, ITestProfileService, TestProfileServiceToken } from '../common/test-profile';
+import { ITestResultService, TestResultServiceToken } from '../common/test-result';
+import { MainThreadTestCollection, ResolvedTestRunRequest, TestDiffOpType, TestsDiff } from '../common/testCollection';
+import { TestingContainerId } from '../common/testing-view';
+
+import { ITestResult } from './../common/test-result';
+import { TestingView } from './components/testing.view';
+
+@Injectable()
+export class TestServiceImpl extends Disposable implements ITestService {
+  private controllers = new Map<string, ITestController>();
+  private controllerCount: IContextKey<number>;
+  private canRefreshTests: IContextKey<boolean>;
+
+  private readonly processDiffEmitter = new Emitter<TestsDiff>();
+  private viewId = '';
+
+  readonly collection = new MainThreadTestCollection(this.expandTest.bind(this));
+  readonly onDidProcessDiff = this.processDiffEmitter.event;
+
+  @Autowired(IMainLayoutService)
+  protected readonly mainlayoutService: IMainLayoutService;
+
+  @Autowired(TestResultServiceToken)
+  protected readonly resultService: ITestResultService;
+
+  @Autowired(TestProfileServiceToken)
+  protected readonly testProfiles: ITestProfileService;
+
+  @Autowired(IContextKeyService)
+  private readonly contextKeyService: IContextKeyService;
+
+  constructor() {
+    super();
+    this.controllerCount = TestingServiceProviderCount.bind(this.contextKeyService);
+    this.canRefreshTests = TestingCanRefreshTests.bind(this.contextKeyService);
+  }
+
+  public getTestController(controllerId: string): ITestController | undefined {
+    return this.controllers.get(controllerId);
+  }
+
+  public async refreshTests(controllerId?: string): Promise<void> {
+    const cts = new CancellationTokenSource();
+    try {
+      if (controllerId) {
+        await this.controllers.get(controllerId)?.refreshTests(cts.token);
+      } else {
+        await Promise.all([...this.controllers.values()].map((c) => c.refreshTests(cts.token)));
+      }
+    } finally {
+      cts.dispose(true);
+    }
+  }
+
+  private registerTestingExplorerView(): string {
+    this.mainlayoutService.collectViewComponent;
+    return this.mainlayoutService.collectTabbarComponent(
+      [{ id: TestingContainerId }],
+      {
+        iconClass: getIcon('test'),
+        title: localize('test.title'),
+        priority: 1,
+        containerId: Testing.ExplorerViewId,
+        component: TestingView,
+        activateKeyBinding: 'ctrlcmd+shift+t',
+      },
+      SlotLocation.left,
+    );
+  }
+
+  registerTestController(id: string, testController: ITestController): IDisposable {
+    this.controllers.set(id, testController);
+    this.controllerCount.set(this.controllers.size);
+    this.updateCanRefresh();
+
+    if (this.controllers.size > 0 && !this.viewId) {
+      this.viewId = this.registerTestingExplorerView();
+    }
+
+    const disposable = new Disposable();
+
+    disposable.addDispose(
+      Disposable.create(() => {
+        const diff: TestsDiff = [];
+        for (const root of this.collection.rootItems) {
+          if (root.controllerId === id) {
+            diff.push([TestDiffOpType.Remove, root.item.extId]);
+          }
+        }
+        this.publishDiff(id, diff);
+
+        if (this.controllers.delete(id)) {
+          this.controllerCount.set(this.controllers.size);
+          this.updateCanRefresh();
+          if (this.controllers.size === 0 && this.viewId) {
+            this.mainlayoutService.disposeContainer(this.viewId);
+          }
+        }
+      }),
+    );
+
+    disposable.addDispose(testController.canRefresh.onDidChange(this.updateCanRefresh, this));
+
+    return disposable;
+  }
+
+  private updateCanRefresh() {
+    this.canRefreshTests.set(Array.from(this.controllers.values()).some((c) => c.canRefresh));
+  }
+
+  public async expandTest(id: string, levels: number) {
+    await this.controllers.get(TestId.fromString(id).controllerId)?.expandTest(id, levels);
+  }
+
+  publishDiff(_controllerId: string, diff: TestsDiff) {
+    this.collection.apply(diff);
+    this.processDiffEmitter.fire(diff);
+  }
+
+  runTests(req: AmbiguousRunTestsRequest, token = CancellationToken.None): Promise<ITestResult> {
+    const resolved: ResolvedTestRunRequest = {
+      targets: [],
+      exclude: req.exclude?.map((t) => t.item.extId),
+      isAutoRun: req.isAutoRun,
+    };
+    const profiles = this.testProfiles.getBaseDefaultsProfile(req.group);
+    for (const profile of profiles) {
+      const testIds = req.tests.filter((t) => canUseProfileWithTest(profile, t)).map((t) => t.item.extId);
+      resolved.targets.push({
+        testIds,
+        profileGroup: profile.group,
+        profileId: profile.profileId,
+        controllerId: profile.controllerId,
+      });
+    }
+
+    return this.runResolvedTests(resolved, token);
+  }
+
+  async runResolvedTests(req: ResolvedTestRunRequest, token?: CancellationToken): Promise<ITestResult> {
+    if (!req.exclude) {
+      // default exclude
+      req.exclude = [];
+    }
+
+    const result = this.resultService.createTestResult(req);
+    try {
+      const cancelSource = new CancellationTokenSource(token);
+      const requests = req.targets.map((group) =>
+        this.controllers
+          .get(group.controllerId)
+          ?.runTests(
+            {
+              runId: result.id,
+              excludeExtIds: req.exclude!.filter((t) => !group.testIds.includes(t)),
+              profileId: group.profileId,
+              controllerId: group.controllerId,
+              testIds: group.testIds,
+            },
+            cancelSource.token,
+          )
+          .catch(() => {
+            //
+          }),
+      );
+      await Promise.all(requests);
+      return result;
+    } finally {
+      result.markComplete();
+    }
+  }
+}