@opensumi/ide-testing 2.21.13 → 2.22.0

package/src/browser/testing.contribution.ts

@@ -0,0 +1,471 @@
+import { Injectable, Autowired, INJECTOR_TOKEN, Injector } from '@opensumi/di';
+import {
+  ClientAppContribution,
+  CommandContribution,
+  CommandRegistry,
+  CommandService,
+  ComponentContribution,
+  ComponentRegistry,
+  Domain,
+  EDITOR_COMMANDS,
+  Event,
+  FileType,
+  getIcon,
+  KeybindingContribution,
+  KeybindingRegistry,
+  MaybePromise,
+  TabBarToolbarContribution,
+  ToolbarRegistry,
+  URI,
+} from '@opensumi/ide-core-browser';
+import { TestingCanRefreshTests, TestingIsPeekVisible } from '@opensumi/ide-core-browser/lib/contextkey/testing';
+import { IMenuRegistry, MenuContribution, MenuId } from '@opensumi/ide-core-browser/lib/menu/next';
+import { Emitter, IMarkdownString } from '@opensumi/ide-core-common';
+import {
+  BrowserEditorContribution,
+  IEditorFeatureRegistry,
+  IEditorDocumentModelContentRegistry,
+  IEditorDocumentModelContentProvider,
+  WorkbenchEditorService,
+  EditorComponentRegistry,
+  ResourceService,
+  IResource,
+  EditorOpenType,
+} from '@opensumi/ide-editor/lib/browser';
+import { IEditor } from '@opensumi/ide-editor/lib/common';
+import { IFileServiceClient } from '@opensumi/ide-file-service';
+import { MARKDOWN_EDITOR_COMPONENT_ID } from '@opensumi/ide-markdown/lib/browser/contribution';
+import { MarkdownEditorComponent } from '@opensumi/ide-markdown/lib/browser/editor.markdown';
+
+import { TestServiceToken } from '../common';
+import {
+  ClearTestResults,
+  ClosePeekTest,
+  DebugAllTestCommand,
+  DebugTestCommand,
+  GoToNextMessage,
+  GoToPreviousMessage,
+  GoToTestCommand,
+  OpenMessageInEditor,
+  PeekTestError,
+  RefreshTestsCommand,
+  RuntAllTestCommand,
+  RuntTestCommand,
+  TestingDebugCurrentFile,
+  TestingRunCurrentFile,
+} from '../common/commands';
+import { Testing } from '../common/constants';
+import { TestResultServiceToken } from '../common/test-result';
+import { TestRunProfileBitset } from '../common/testCollection';
+import { TestingPeekOpenerServiceToken } from '../common/testingPeekOpener';
+import { ITestTreeViewModel, TestTreeViewModelToken } from '../common/tree-view.model';
+
+import { TEST_DATA_SCHEME } from './../common/testingUri';
+import { TestOutputPeekContribution } from './outputPeek/test-output-peek';
+import { TestingPeekOpenerServiceImpl } from './outputPeek/test-peek-opener.service';
+import { TestDecorationsContribution } from './test-decorations';
+import { TestResultServiceImpl } from './test.result.service';
+import { TestServiceImpl } from './test.service';
+
+@Injectable()
+export class TestingOutputPeekDocumentProvider implements IEditorDocumentModelContentProvider {
+  @Autowired(TestResultServiceToken)
+  private readonly testResultService: TestResultServiceImpl;
+
+  private _onDidChangeContent = new Emitter<URI>();
+
+  onDidChangeContent: Event<URI> = this._onDidChangeContent.event;
+
+  provideEditorDocumentModelContent(uri: URI, encoding?: string): MaybePromise<string> {
+    const dto = this.testResultService.retrieveTest(uri);
+    if (!dto) {
+      return '';
+    }
+
+    const message = dto.messages[dto.messageIndex];
+
+    if (dto.isDiffable || typeof message.message === 'string') {
+      return '';
+    }
+
+    const mdStr = message.message;
+    const content = mdStr ? (mdStr as IMarkdownString).value.replace(/\t/g, '') : '';
+
+    return content;
+  }
+
+  isReadonly(uri: URI): MaybePromise<boolean> {
+    return true;
+  }
+
+  handlesScheme(scheme: string) {
+    return scheme === TEST_DATA_SCHEME;
+  }
+}
+
+@Injectable()
+@Domain(
+  ClientAppContribution,
+  ComponentContribution,
+  CommandContribution,
+  BrowserEditorContribution,
+  MenuContribution,
+  KeybindingContribution,
+  TabBarToolbarContribution,
+)
+export class TestingContribution
+  implements
+    ClientAppContribution,
+    ComponentContribution,
+    CommandContribution,
+    BrowserEditorContribution,
+    MenuContribution,
+    KeybindingContribution,
+    TabBarToolbarContribution
+{
+  @Autowired(TestTreeViewModelToken)
+  private readonly testTreeViewModel: ITestTreeViewModel;
+
+  @Autowired(IFileServiceClient)
+  protected readonly filesystem: IFileServiceClient;
+
+  @Autowired(CommandService)
+  private readonly commandService: CommandService;
+
+  @Autowired(INJECTOR_TOKEN)
+  private readonly injector: Injector;
+
+  @Autowired(TestingPeekOpenerServiceToken)
+  private readonly testingPeekOpenerService: TestingPeekOpenerServiceImpl;
+
+  @Autowired()
+  private readonly testingOutputPeekDocumentProvider: TestingOutputPeekDocumentProvider;
+
+  @Autowired(WorkbenchEditorService)
+  private readonly editorService: WorkbenchEditorService;
+
+  @Autowired(TestServiceToken)
+  private readonly testService: TestServiceImpl;
+
+  @Autowired(TestResultServiceToken)
+  private readonly testResultService: TestResultServiceImpl;
+
+  initialize(): void {
+    this.testTreeViewModel.initTreeModel();
+  }
+
+  registerComponent(registry: ComponentRegistry): void {}
+
+  registerCommands(commands: CommandRegistry): void {
+    commands.registerCommand(RuntTestCommand, {
+      execute: async (extId: string) => {
+        const test = this.testTreeViewModel.getTestItem(extId);
+        if (!test) {
+          return;
+        }
+
+        await this.testService.runTests({
+          group: TestRunProfileBitset.Run,
+          tests: [test],
+        });
+      },
+    });
+
+    commands.registerCommand(DebugTestCommand, {
+      execute: async (extId: string) => {
+        const test = this.testTreeViewModel.getTestItem(extId);
+        if (!test) {
+          return;
+        }
+
+        await this.testService.runTests({
+          group: TestRunProfileBitset.Debug,
+          tests: [test],
+        });
+      },
+    });
+
+    commands.registerCommand(GoToTestCommand, {
+      execute: async (extId: string) => {
+        const test = this.testTreeViewModel.getTestItem(extId);
+        if (!test) {
+          return;
+        }
+
+        const { range, uri } = test.item;
+        if (!uri) {
+          return;
+        }
+
+        const fileStat = await this.filesystem.getFileStat(uri.toString());
+
+        if (!fileStat) {
+          return;
+        }
+
+        if (fileStat.type === FileType.Directory) {
+          // ** filetree 未实现文件夹的 focus , 只能是将窗口切到资源管理器但无法选中文件夹 **
+          this.commandService.executeCommand('revealInExplorer', uri);
+          return;
+        }
+
+        if (fileStat.type === FileType.File) {
+          this.commandService.executeCommand(EDITOR_COMMANDS.OPEN_RESOURCE.id, URI.parse(uri.toString()), {
+            range,
+            focus: true,
+          });
+        }
+      },
+      isVisible: () => false,
+    });
+
+    commands.registerCommand(PeekTestError, {
+      execute: async (extId: string) => {
+        this.testingPeekOpenerService.open();
+      },
+      isVisible: () => false,
+    });
+
+    commands.registerCommand(ClosePeekTest, {
+      execute: async (uri: string | undefined) => {
+        uri = uri ?? this.editorService.currentEditor?.currentUri?.toString();
+
+        if (!uri) {
+          return;
+        }
+
+        const ctor = this.testingPeekOpenerService.peekControllerMap.get(uri);
+        if (ctor) {
+          ctor.removePeek();
+        }
+      },
+      isVisible: () => false,
+    });
+
+    commands.registerCommand(TestingRunCurrentFile, {
+      execute: async () => {
+        executeTestsInCurrentFile(TestRunProfileBitset.Run);
+      },
+    });
+
+    commands.registerCommand(TestingDebugCurrentFile, {
+      execute: async () => {
+        executeTestsInCurrentFile(TestRunProfileBitset.Debug);
+      },
+    });
+
+    const executeTestsInCurrentFile = (group: TestRunProfileBitset) => {
+      const currentEditor = this.editorService.currentEditor;
+      const monacoEditor = currentEditor?.monacoEditor;
+      const position = monacoEditor?.getPosition();
+      const model = monacoEditor?.getModel();
+
+      if (!position || !model || !('uri' in model)) {
+        return;
+      }
+
+      const demandedUri = model.uri.toString();
+      for (const test of this.testService.collection.all) {
+        if (test.item.uri?.toString() === demandedUri) {
+          this.testService.runTests({
+            tests: [test],
+            group,
+          });
+        }
+      }
+    };
+
+    commands.registerCommand(GoToPreviousMessage, {
+      execute: async (uri: string | undefined) => {
+        uri = uri ?? this.editorService.currentEditor?.currentUri?.toString();
+
+        if (!uri) {
+          return;
+        }
+
+        const ctor = this.testingPeekOpenerService.peekControllerMap.get(uri);
+        if (ctor) {
+          ctor.previous();
+        }
+      },
+    });
+
+    commands.registerCommand(GoToNextMessage, {
+      execute: async (uri: string | undefined) => {
+        uri = uri ?? this.editorService.currentEditor?.currentUri?.toString();
+
+        if (!uri) {
+          return;
+        }
+
+        const ctor = this.testingPeekOpenerService.peekControllerMap.get(uri);
+        if (ctor) {
+          ctor.next();
+        }
+      },
+    });
+
+    commands.registerCommand(ClearTestResults, {
+      execute: async (uri: string | undefined) => {
+        this.testResultService.clear();
+        this.commandService.executeCommand(ClosePeekTest.id, uri);
+      },
+    });
+
+    commands.registerCommand(OpenMessageInEditor, {
+      execute: async (uri: string | undefined) => {
+        uri = uri ?? this.editorService.currentEditor?.currentUri?.toString();
+
+        if (!uri) {
+          return;
+        }
+
+        const ctor = this.testingPeekOpenerService.peekControllerMap.get(uri);
+        if (ctor) {
+          ctor.openCurrentInEditor();
+        }
+      },
+    });
+
+    const runOrDebugAllTestsAction = async (group: TestRunProfileBitset) => {
+      const roots = [...this.testService.collection.rootItems];
+      if (!roots.length) {
+        return;
+      }
+
+      await this.testService.runTests({ tests: roots, group });
+    };
+
+    commands.registerCommand(RefreshTestsCommand, {
+      execute: async () => {
+        await this.testService.refreshTests();
+      },
+    });
+
+    commands.registerCommand(RuntAllTestCommand, {
+      execute: async () => {
+        await runOrDebugAllTestsAction(TestRunProfileBitset.Run);
+      },
+    });
+
+    commands.registerCommand(DebugAllTestCommand, {
+      execute: async () => {
+        await runOrDebugAllTestsAction(TestRunProfileBitset.Debug);
+      },
+    });
+  }
+
+  registerKeybindings(keybindings: KeybindingRegistry): void {
+    keybindings.registerKeybinding({
+      command: ClosePeekTest.id,
+      keybinding: 'esc',
+      when: TestingIsPeekVisible.equalsTo(true),
+    });
+  }
+
+  registerMenus(menuRegistry: IMenuRegistry) {
+    /** glyph margin start */
+    menuRegistry.registerMenuItem(MenuId.TestingGlyphMarginContext, {
+      command: RuntTestCommand.id,
+      group: '1_has_decoration',
+      order: 1,
+    });
+    menuRegistry.registerMenuItem(MenuId.TestingGlyphMarginContext, {
+      command: DebugTestCommand.id,
+      group: '1_has_decoration',
+      order: 2,
+    });
+    /** glyph margin end */
+
+    /** output peek view actions start */
+    menuRegistry.registerMenuItem(MenuId.TestPeekTitleContext, {
+      command: GoToPreviousMessage.id,
+      iconClass: GoToPreviousMessage.iconClass,
+      group: 'navigation',
+      order: 5,
+    });
+    menuRegistry.registerMenuItem(MenuId.TestPeekTitleContext, {
+      command: GoToNextMessage.id,
+      iconClass: GoToNextMessage.iconClass,
+      group: 'navigation',
+      order: 6,
+    });
+    menuRegistry.registerMenuItem(MenuId.TestPeekTitleContext, {
+      command: ClearTestResults.id,
+      iconClass: ClearTestResults.iconClass,
+      group: 'navigation',
+      order: 7,
+    });
+    menuRegistry.registerMenuItem(MenuId.TestPeekTitleContext, {
+      command: OpenMessageInEditor.id,
+      iconClass: OpenMessageInEditor.iconClass,
+      group: 'navigation',
+      order: 9,
+    });
+    /** output peek view actions end */
+  }
+
+  registerToolbarItems(registry: ToolbarRegistry): void {
+    registry.registerItem({
+      id: RefreshTestsCommand.id,
+      command: RefreshTestsCommand.id,
+      viewId: Testing.ExplorerViewId,
+      when: TestingCanRefreshTests.equalsTo(true),
+    });
+    registry.registerItem({
+      id: RuntAllTestCommand.id,
+      command: RuntAllTestCommand.id,
+      viewId: Testing.ExplorerViewId,
+    });
+    registry.registerItem({
+      id: DebugAllTestCommand.id,
+      command: DebugAllTestCommand.id,
+      viewId: Testing.ExplorerViewId,
+    });
+    registry.registerItem({
+      id: ClearTestResults.id,
+      command: ClearTestResults.id,
+      viewId: Testing.ExplorerViewId,
+    });
+  }
+
+  registerEditorFeature(registry: IEditorFeatureRegistry) {
+    registry.registerEditorFeatureContribution({
+      contribute: (editor: IEditor) => this.injector.get(TestDecorationsContribution, [editor]).contribute(),
+    });
+    registry.registerEditorFeatureContribution({
+      contribute: (editor: IEditor) => this.injector.get(TestOutputPeekContribution, [editor]).contribute(),
+    });
+  }
+
+  registerEditorDocumentModelContentProvider(registry: IEditorDocumentModelContentRegistry) {
+    registry.registerEditorDocumentModelContentProvider(this.testingOutputPeekDocumentProvider);
+  }
+
+  registerEditorComponent(componentRegistry: EditorComponentRegistry) {
+    componentRegistry.registerEditorComponent({
+      uid: MARKDOWN_EDITOR_COMPONENT_ID,
+      component: MarkdownEditorComponent,
+      scheme: TEST_DATA_SCHEME,
+    });
+
+    componentRegistry.registerEditorComponentResolver(TEST_DATA_SCHEME, (_, results) => {
+      results.push({
+        type: EditorOpenType.component,
+        componentId: MARKDOWN_EDITOR_COMPONENT_ID,
+        weight: 10,
+      });
+    });
+  }
+
+  registerResource(service: ResourceService) {
+    service.registerResourceProvider({
+      scheme: TEST_DATA_SCHEME,
+      provideResource: async (uri: URI): Promise<IResource<Partial<{ [prop: string]: any }>>> => ({
+        uri,
+        icon: getIcon('file-text'),
+        name: `Preview ${uri.displayName}`,
+      }),
+    });
+  }
+}

package/src/browser/theme.less

@@ -0,0 +1,6 @@
+.monaco-editor {
+  // error message
+  .testing-inline-message-severity-0 {
+    background: rgba(255, 0, 0, 0.2);
+  }
+}

package/src/common/commands.ts

@@ -0,0 +1,78 @@
+import { Command, getExternalIcon, getIcon } from '@opensumi/ide-core-browser';
+
+export const RuntTestCommand: Command = {
+  id: 'testing.run.test',
+  label: 'Run Test',
+};
+
+export const DebugTestCommand: Command = {
+  id: 'testing.debug.test',
+  label: 'Debug Test',
+};
+
+export const GoToTestCommand: Command = {
+  id: 'testing.goto.test',
+  label: 'Go To Test',
+};
+
+export const TestingRunCurrentFile: Command = {
+  id: 'testing.runCurrentFile',
+  label: 'Run Tests in Current File',
+};
+
+export const TestingDebugCurrentFile: Command = {
+  id: 'testing.debugCurrentFile',
+  label: 'Debug Tests in Current File',
+};
+
+export const PeekTestError: Command = {
+  id: 'testing.peek.test.error',
+  label: 'Peek Output',
+};
+
+export const ClosePeekTest: Command = {
+  id: 'testing.peek.test.close',
+  label: 'Close Peek Output',
+};
+
+export const GoToPreviousMessage: Command = {
+  id: 'testing.goToPreviousMessage',
+  label: 'Go to Previous Test Failure',
+  iconClass: getIcon('arrowup'),
+};
+
+export const GoToNextMessage: Command = {
+  id: 'testing.goToNextMessage',
+  label: 'Go to Next Test Failure',
+  iconClass: getIcon('arrowdown'),
+};
+
+export const ClearTestResults: Command = {
+  id: 'testing.clearTestResults',
+  label: 'Clear All Results',
+  iconClass: getExternalIcon('clear-all'),
+};
+
+export const OpenMessageInEditor: Command = {
+  id: 'testing.openMessageInEditor',
+  label: 'Open in Editor',
+  iconClass: getExternalIcon('link-external'),
+};
+
+export const RuntAllTestCommand: Command = {
+  id: 'testing.runAll',
+  label: 'Run All Test',
+  iconClass: getExternalIcon('run-all'),
+};
+
+export const DebugAllTestCommand: Command = {
+  id: 'testing.debugAll',
+  label: 'Debug All Test',
+  iconClass: getIcon('debug-alt-small'),
+};
+
+export const RefreshTestsCommand: Command = {
+  id: 'testing.refresshTests',
+  label: 'Refresh Tests',
+  iconClass: getIcon('refresh'),
+};

package/src/common/constants.ts

@@ -0,0 +1,57 @@
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { localize } from '@opensumi/ide-core-common';
+
+import { TestMessageType, TestResultState, TestRunProfileBitset } from './testCollection';
+
+export const enum Testing {
+  // marked as "extension" so that any existing test extensions are assigned to it.
+  ViewletId = 'workbench.view.extension.test',
+  ExplorerViewId = 'workbench.view.testing',
+  OutputPeekContributionId = 'editor.contrib.testingOutputPeek',
+  DecorationsContributionId = 'editor.contrib.testingDecorations',
+  FilterActionId = 'workbench.actions.treeView.testExplorer.filter',
+}
+
+export const enum TestExplorerViewMode {
+  List = 'list',
+  Tree = 'true',
+}
+
+export const enum TestExplorerViewSorting {
+  ByLocation = 'location',
+  ByStatus = 'status',
+}
+
+export const enum TestExplorerStateFilter {
+  OnlyFailed = 'failed',
+  OnlyExecuted = 'excuted',
+  All = 'all',
+}
+
+export const testStateNames: { [K in TestResultState]: string } = {
+  [TestResultState.Errored]: localize('testState.errored', 'Errored'),
+  [TestResultState.Failed]: localize('testState.failed', 'Failed'),
+  [TestResultState.Passed]: localize('testState.passed', 'Passed'),
+  [TestResultState.Queued]: localize('testState.queued', 'Queued'),
+  [TestResultState.Running]: localize('testState.running', 'Running'),
+  [TestResultState.Skipped]: localize('testState.skipped', 'Skipped'),
+  [TestResultState.Unset]: localize('testState.unset', 'Not yet run'),
+};
+
+export const labelForTestInState = (label: string, state: TestResultState) =>
+  'label then the unit tests state, for example "Addition Tests (Running)"';
+
+export const testConfigurationGroupNames: { [K in TestRunProfileBitset]: string } = {
+  [TestRunProfileBitset.Debug]: localize('testGroup.debug', 'Debug'),
+  [TestRunProfileBitset.Run]: localize('testGroup.run', 'Run'),
+  [TestRunProfileBitset.Coverage]: localize('testGroup.coverage', 'Coverage'),
+};
+
+export const testMessageSeverityColors = {
+  [TestMessageType.Error]: '#F14C4C',
+  [TestMessageType.Info]: '#33333380', // --> #333333 透明度 0.5 的结果
+};