@opensumi/ide-testing 2.21.13 → 2.22.0

package/src/common/testId.ts

@@ -0,0 +1,191 @@
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export const enum TestIdPathParts {
+  /** Delimiter for path parts in test IDs */
+  Delimiter = '\0',
+}
+
+/**
+ * Enum for describing relative positions of tests. Similar to
+ * `node.compareDocumentPosition` in the DOM.
+ */
+export const enum TestPosition {
+  /** a === b */
+  IsSame,
+  /** Neither a nor b are a child of one another. They may share a common parent, though. */
+  Disconnected,
+  /** b is a child of a */
+  IsChild,
+  /** b is a parent of a */
+  IsParent,
+}
+
+export interface TestItemLike {
+  id: string;
+  parent?: TestItemLike;
+}
+
+/**
+ * The test ID is a stringifiable client that
+ */
+export class TestId {
+  private stringifed?: string;
+
+  /**
+   * Creates a test ID from an ext host test item.
+   */
+  public static fromExtHostTestItem(item: TestItemLike, rootId: string, parent = item.parent) {
+    if (item.id === rootId) {
+      return new TestId([rootId]);
+    }
+
+    const path = [item.id];
+    for (let i = parent; i && i.id !== rootId; i = i.parent) {
+      path.push(i.id);
+    }
+    path.push(rootId);
+
+    return new TestId(path.reverse());
+  }
+
+  /**
+   * Cheaply ets whether the ID refers to the root .
+   */
+  public static isRoot(idString: string) {
+    return !idString.includes(TestIdPathParts.Delimiter);
+  }
+
+  /**
+   * Creates a test ID from a serialized TestId instance.
+   */
+  public static fromString(idString: string) {
+    return new TestId(idString.split(TestIdPathParts.Delimiter));
+  }
+
+  /**
+   * Gets the ID resulting from adding b to the base ID.
+   */
+  public static join(base: TestId, b: string) {
+    return new TestId([...base.path, b]);
+  }
+
+  /**
+   * Gets the string ID resulting from adding b to the base ID.
+   */
+  public static joinToString(base: string | TestId, b: string) {
+    return base.toString() + TestIdPathParts.Delimiter + b;
+  }
+
+  /**
+   * Compares the position of the two ID strings.
+   */
+  public static compare(a: string, b: string) {
+    if (a === b) {
+      return TestPosition.IsSame;
+    }
+
+    if (b.startsWith(a + TestIdPathParts.Delimiter)) {
+      return TestPosition.IsChild;
+    }
+
+    if (a.startsWith(b + TestIdPathParts.Delimiter)) {
+      return TestPosition.IsParent;
+    }
+
+    return TestPosition.Disconnected;
+  }
+
+  constructor(public readonly path: readonly string[], private readonly viewEnd = path.length) {
+    if (path.length === 0 || viewEnd < 1) {
+      throw new Error('cannot create test with empty path');
+    }
+  }
+
+  /**
+   * Gets the ID of the parent test.
+   */
+  public get parentId(): TestId {
+    return this.viewEnd > 1 ? new TestId(this.path, this.viewEnd - 1) : this;
+  }
+
+  /**
+   * Gets the local ID of the current full test ID.
+   */
+  public get localId() {
+    return this.path[this.viewEnd - 1];
+  }
+
+  /**
+   * Gets whether this ID refers to the root.
+   */
+  public get controllerId() {
+    return this.path[0];
+  }
+
+  /**
+   * Gets whether this ID refers to the root.
+   */
+  public get isRoot() {
+    return this.viewEnd === 1;
+  }
+
+  /**
+   * Returns an iterable that yields IDs of all parent items down to and
+   * including the current item.
+   */
+  public *idsFromRoot() {
+    for (let i = 1; i <= this.viewEnd; i++) {
+      yield new TestId(this.path, i);
+    }
+  }
+
+  /**
+   * Compares the other test ID with this one.
+   */
+  public compare(other: TestId | string) {
+    if (typeof other === 'string') {
+      return TestId.compare(this.toString(), other);
+    }
+
+    for (let i = 0; i < other.viewEnd && i < this.viewEnd; i++) {
+      if (other.path[i] !== this.path[i]) {
+        return TestPosition.Disconnected;
+      }
+    }
+
+    if (other.viewEnd > this.viewEnd) {
+      return TestPosition.IsChild;
+    }
+
+    if (other.viewEnd < this.viewEnd) {
+      return TestPosition.IsParent;
+    }
+
+    return TestPosition.IsSame;
+  }
+
+  /**
+   * Serializes the ID.
+   */
+  public toJSON() {
+    return this.toString();
+  }
+
+  /**
+   * Serializes the ID to a string.
+   */
+  public toString() {
+    if (!this.stringifed) {
+      this.stringifed = this.path[0];
+      for (let i = 1; i < this.viewEnd; i++) {
+        this.stringifed += TestIdPathParts.Delimiter;
+        this.stringifed += this.path[i];
+      }
+    }
+
+    return this.stringifed;
+  }
+}

package/src/common/testing-view.ts

@@ -0,0 +1,28 @@
+import { IBasicInlineMenu, IBasicInlineMenuPosition } from '@opensumi/ide-components';
+
+import { DebugTestCommand, GoToTestCommand, RuntTestCommand } from './commands';
+
+export const TestingViewId = '@opensumi/ide-testing';
+
+export const TestingContainerId = 'testing';
+
+export const TestingExplorerInlineMenus: IBasicInlineMenu[] = [
+  {
+    icon: 'start',
+    title: 'Run Test',
+    command: RuntTestCommand.id,
+    position: IBasicInlineMenuPosition.TREE_CONTAINER,
+  },
+  {
+    icon: 'debug-alt-small',
+    title: 'Debug Test',
+    command: DebugTestCommand.id,
+    position: IBasicInlineMenuPosition.TREE_CONTAINER,
+  },
+  {
+    icon: 'openfile',
+    title: 'Go To Test',
+    command: GoToTestCommand.id,
+    position: IBasicInlineMenuPosition.TREE_CONTAINER,
+  },
+];

package/src/common/testingPeekOpener.ts

@@ -0,0 +1,31 @@
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import type { ITextEditorOptions } from '@opensumi/monaco-editor-core/esm/vs/platform/editor/common/editor';
+
+import { ITestResult } from './test-result';
+import { TestResultItem } from './testCollection';
+
+export const TestingPeekOpenerServiceToken = Symbol('TestingPeekOpenerService');
+
+export interface ITestingPeekOpenerService {
+  _serviceBrand: undefined;
+
+  /**
+   * Tries to peek the first test error, if the item is in a failed state.
+   * @returns a boolean indicating whether a peek was opened
+   */
+  tryPeekFirstError(result: ITestResult, test: TestResultItem, options?: Partial<ITextEditorOptions>): boolean;
+
+  /**
+   * Opens the peek. Shows any available message.
+   */
+  open(): void;
+
+  /**
+   * Closes peeks for all visible editors.
+   */
+  closeAllPeeks(): void;
+}

package/src/common/testingStates.ts

@@ -0,0 +1,92 @@
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { parseMarkdown } from '@opensumi/ide-components/lib/utils';
+import { strings } from '@opensumi/ide-core-common';
+
+import { ITestErrorMessage, TestResultState } from './testCollection';
+
+const { count } = strings;
+
+export interface TreeStateNode {
+  statusNode: true;
+  state: TestResultState;
+  priority: number;
+}
+
+/**
+ * List of display priorities for different run states. When tests update,
+ * the highest-priority state from any of their children will be the state
+ * reflected in the parent node.
+ */
+export const statePriority: { [K in TestResultState]: number } = {
+  [TestResultState.Running]: 6,
+  [TestResultState.Errored]: 5,
+  [TestResultState.Failed]: 4,
+  [TestResultState.Queued]: 3,
+  [TestResultState.Passed]: 2,
+  [TestResultState.Unset]: 1,
+  [TestResultState.Skipped]: 0,
+};
+
+export const isFailedState = (s: TestResultState) => s === TestResultState.Errored || s === TestResultState.Failed;
+export const isStateWithResult = (s: TestResultState) =>
+  s === TestResultState.Errored || s === TestResultState.Failed || s === TestResultState.Passed;
+
+export const stateNodes = Object.entries(statePriority).reduce((acc, [stateStr, priority]) => {
+  const state = Number(stateStr) as TestResultState;
+  acc[state] = { statusNode: true, state, priority };
+  return acc;
+}, {} as { [K in TestResultState]: TreeStateNode });
+
+export const cmpPriority = (a: TestResultState, b: TestResultState) => statePriority[b] - statePriority[a];
+
+export const maxPriority = (...states: TestResultState[]) => {
+  switch (states.length) {
+    case 0:
+      return TestResultState.Unset;
+    case 1:
+      return states[0];
+    case 2:
+      return statePriority[states[0]] > statePriority[states[1]] ? states[0] : states[1];
+    default: {
+      let max = states[0];
+      for (let i = 1; i < states.length; i++) {
+        if (statePriority[max] < statePriority[states[i]]) {
+          max = states[i];
+        }
+      }
+      return max;
+    }
+  }
+};
+
+export const statesInOrder = Object.keys(statePriority)
+  .map((s) => Number(s) as TestResultState)
+  .sort(cmpPriority);
+
+export const isRunningState = (s: TestResultState) => s === TestResultState.Queued || s === TestResultState.Running;
+
+export const firstLine = (str: string) => {
+  const index = str.indexOf('\n');
+  return index === -1 ? str : str.slice(0, index);
+};
+
+const domParser = new DOMParser();
+
+export const parseMarkdownText = (value: string) =>
+  domParser.parseFromString(parseMarkdown(value) || '', 'text/html').documentElement.outerText;
+
+export const isDiffable = (
+  message: ITestErrorMessage,
+): message is ITestErrorMessage & { actualOutput: string; expectedOutput: string } =>
+  message.actual !== undefined && message.expected !== undefined;
+
+const hintPeekStrHeight = (str: string | undefined) => Math.min(Math.max(count(str || '', '\n') + 3, 8), 20);
+
+export const hintMessagePeekHeight = (msg: ITestErrorMessage) =>
+  isDiffable(msg)
+    ? Math.max(hintPeekStrHeight(msg.actual), hintPeekStrHeight(msg.expected))
+    : hintPeekStrHeight(typeof msg.message === 'string' ? msg.message : msg.message.value);

package/src/common/testingUri.ts

@@ -0,0 +1,101 @@
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { URI } from '@opensumi/ide-core-common';
+
+export const TEST_DATA_SCHEME = 'opensumi-test-data';
+
+export const enum TestUriType {
+  ResultMessage,
+  ResultActualOutput,
+  ResultExpectedOutput,
+}
+
+interface IResultTestUri {
+  resultId: string;
+  taskIndex: number;
+  testExtId: string;
+}
+
+interface IResultTestMessageReference extends IResultTestUri {
+  type: TestUriType.ResultMessage;
+  messageIndex: number;
+}
+
+interface IResultTestOutputReference extends IResultTestUri {
+  type: TestUriType.ResultActualOutput | TestUriType.ResultExpectedOutput;
+  messageIndex: number;
+}
+
+export type ParsedTestUri = IResultTestMessageReference | IResultTestOutputReference;
+
+const enum TestUriParts {
+  Results = 'results',
+
+  Messages = 'message',
+  Text = 'TestFailureMessage',
+  ActualOutput = 'ActualOutput',
+  ExpectedOutput = 'ExpectedOutput',
+}
+
+export const parseTestUri = (uri: URI): ParsedTestUri | undefined => {
+  const type = uri.authority;
+  const [locationId, ...request] = uri.path.toString().slice(1).split('/');
+
+  if (request[0] === TestUriParts.Messages) {
+    const taskIndex = Number(request[1]);
+    const index = Number(request[2]);
+    const part = request[3];
+    const testExtId = uri.query;
+    if (type === TestUriParts.Results) {
+      switch (part) {
+        case TestUriParts.Text:
+          return { resultId: locationId, taskIndex, testExtId, messageIndex: index, type: TestUriType.ResultMessage };
+        case TestUriParts.ActualOutput:
+          return {
+            resultId: locationId,
+            taskIndex,
+            testExtId,
+            messageIndex: index,
+            type: TestUriType.ResultActualOutput,
+          };
+        case TestUriParts.ExpectedOutput:
+          return {
+            resultId: locationId,
+            taskIndex,
+            testExtId,
+            messageIndex: index,
+            type: TestUriType.ResultExpectedOutput,
+          };
+      }
+    }
+  }
+
+  return undefined;
+};
+
+export const buildTestUri = (parsed: ParsedTestUri): URI => {
+  const uriParts = {
+    scheme: TEST_DATA_SCHEME,
+    authority: TestUriParts.Results,
+  };
+  const msgRef = (locationId: string, ...remaining: (string | number)[]) =>
+    URI.from({
+      ...uriParts,
+      query: parsed.testExtId,
+      path: ['', locationId, TestUriParts.Messages, ...remaining].join('/'),
+    });
+
+  switch (parsed.type) {
+    case TestUriType.ResultActualOutput:
+      return msgRef(parsed.resultId, parsed.taskIndex, parsed.messageIndex, TestUriParts.ActualOutput);
+    case TestUriType.ResultExpectedOutput:
+      return msgRef(parsed.resultId, parsed.taskIndex, parsed.messageIndex, TestUriParts.ExpectedOutput);
+    case TestUriType.ResultMessage:
+      return msgRef(parsed.resultId, parsed.taskIndex, parsed.messageIndex, TestUriParts.Text);
+    default:
+      throw new Error('Invalid test uri');
+  }
+};

package/src/common/tree-view.model.ts

@@ -0,0 +1,41 @@
+import { IBasicTreeData, IRecycleTreeHandle } from '@opensumi/ide-components';
+import { Event } from '@opensumi/ide-core-browser';
+
+import { InternalTestItem, TestResultState, IncrementalTestCollectionItem } from './testCollection';
+
+export const TestTreeViewModelToken = Symbol('TestTreeViewModel');
+
+export interface ITestTreeViewModel {
+  roots: Iterable<ITestTreeItem>;
+  onUpdate: Event<void>;
+
+  initTreeModel(): Promise<void>;
+
+  expandElement(element: ITestTreeItem, depth: number): void;
+
+  setTreeHandlerApi(handle: IRecycleTreeHandle): void;
+
+  getTestItem(extId: string): IncrementalTestCollectionItem | undefined;
+}
+
+export interface ITestTreeItem {
+  state: TestResultState;
+
+  test: InternalTestItem;
+
+  parent: ITestTreeItem | undefined;
+
+  children: Set<ITestTreeItem>;
+
+  depth: number;
+
+  tests: InternalTestItem[];
+
+  duration: number | undefined;
+
+  label: string;
+}
+
+export interface ITestTreeData<T = ITestTreeItem> extends IBasicTreeData {
+  rawItem: T;
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './common';