Auto expand first level of the test explorer tree view (microsoft#5023)

For microsoft#4767

Author: DonJayamanne

news/1 Enhancements/4767.md

@@ -0,0 +1 @@
+Auto-expand the first level of the test explorer tree view.

src/client/unittests/explorer/testTreeViewItem.ts

@@ -14,6 +14,10 @@ import { getTestType, isSubtestsParent } from '../common/testUtils';
 import { TestResult, TestStatus, TestSuite, TestType } from '../common/types';
 import { TestDataItem } from '../types';
 
+function getDefaultCollapsibleState(data: TestDataItem): TreeItemCollapsibleState {
+ return getTestType(data) === TestType.testFunction ? TreeItemCollapsibleState.None : TreeItemCollapsibleState.Collapsed;
+}
+
 /**
  * Class that represents a visual node on the
  * Test Explorer tree view. Is essentially a wrapper for the underlying
@@ -24,15 +28,13 @@ export class TestTreeItem extends TreeItem {
 
  constructor(
  public readonly resource: Uri,
- public readonly data: Readonly<TestDataItem>
+ public readonly data: Readonly<TestDataItem>,
+ collapsibleStatue: TreeItemCollapsibleState = getDefaultCollapsibleState(data)
  ) {
- super(data.name, TestTreeItem.getCollapsibleState(data));
+ super(data.name, collapsibleStatue);
  this.testType = getTestType(this.data);
  this.setCommand();
  }
- private static getCollapsibleState(data: TestDataItem): TreeItemCollapsibleState {
- return getTestType(data) === TestType.testFunction ? TreeItemCollapsibleState.None : TreeItemCollapsibleState.Collapsed;
- }
  public get contextValue(): string {
  return this.testType;
  }

src/client/unittests/explorer/testTreeViewProvider.ts

@@ -4,15 +4,15 @@
 'use strict';
 
 import { inject, injectable } from 'inversify';
-import { Event, EventEmitter, TreeItem, Uri } from 'vscode';
+import { Event, EventEmitter, TreeItem, TreeItemCollapsibleState, Uri } from 'vscode';
 import { ICommandManager, IWorkspaceService } from '../../common/application/types';
 import { Commands } from '../../common/constants';
 import { IDisposable, IDisposableRegistry } from '../../common/types';
 import { sendTelemetryEvent } from '../../telemetry';
 import { EventName } from '../../telemetry/constants';
 import { CommandSource } from '../common/constants';
-import { getChildren, getParent } from '../common/testUtils';
-import { ITestCollectionStorageService, TestStatus } from '../common/types';
+import { getChildren, getParent, getTestType } from '../common/testUtils';
+import { ITestCollectionStorageService, TestStatus, TestType } from '../common/types';
 import { ITestDataItemResource, ITestTreeViewProvider, IUnitTestManagementService, TestDataItem, TestWorkspaceFolder, WorkspaceTestStatus } from '../types';
 import { TestTreeItem } from './testTreeViewItem';
 
@@ -73,7 +73,8 @@ export class TestTreeViewProvider implements ITestTreeViewProvider, ITestDataIte
  * @return [TreeItem](#TreeItem) representation of the element
  */
  public async getTreeItem(element: TestDataItem): Promise<TreeItem> {
- return new TestTreeItem(element.resource, element);
+ const defaultCollapsibleState = await this.shouldElementBeExpandedByDefault(element) ? TreeItemCollapsibleState.Expanded : undefined;
+ return new TestTreeItem(element.resource, element, defaultCollapsibleState);
  }
 
  /**
@@ -164,4 +165,12 @@ export class TestTreeViewProvider implements ITestTreeViewProvider, ITestDataIte
  this.testsAreBeingDiscovered.set(e.workspace.fsPath, false);
  this.refresh(e.workspace);
  }
+
+ private async shouldElementBeExpandedByDefault(element: TestDataItem) {
+ const parent = await this.getParent(element);
+ if (!parent || getTestType(parent) === TestType.testWorkspaceFolder) {
+ return true;
+ }
+ return false;
+ }
 }

src/test/unittests/explorer/testTreeViewProvider.unit.test.ts

@@ -6,7 +6,7 @@
 import { expect } from 'chai';
 import { instance, mock, verify, when } from 'ts-mockito';
 import * as typemoq from 'typemoq';
-import { Uri } from 'vscode';
+import { TreeItemCollapsibleState, Uri } from 'vscode';
 import { CommandManager } from '../../../client/common/application/commandManager';
 import { WorkspaceService } from '../../../client/common/application/workspace';
 import { Commands } from '../../../client/common/constants';
@@ -15,7 +15,7 @@ import { CommandSource } from '../../../client/unittests/common/constants';
 import { TestCollectionStorageService } from '../../../client/unittests/common/services/storageService';
 import { getTestType } from '../../../client/unittests/common/testUtils';
 import {
- ITestCollectionStorageService, TestStatus, TestType
+ ITestCollectionStorageService, TestFile, TestFolder, TestStatus, TestType
 } from '../../../client/unittests/common/types';
 import { TestTreeItem } from '../../../client/unittests/explorer/testTreeViewItem';
 import { TestTreeViewProvider } from '../../../client/unittests/explorer/testTreeViewProvider';
@@ -611,4 +611,93 @@ suite('Unit Tests Test Explorer TestTreeViewProvider', () => {
  verify(commandManager.executeCommand(Commands.Tests_Discover, testWorkspaceFolder, CommandSource.testExplorer, undefined)).once();
  });
  });
+ test('Expand tree item if it does not have any parent', async () => {
+ const commandManager = mock(CommandManager);
+ const testStore = mock(TestCollectionStorageService);
+ const testWorkspaceFolder = new TestWorkspaceFolder({ uri: Uri.file(__filename), name: '', index: 0 });
+ when(testStore.getTests(testWorkspaceFolder.workspaceFolder.uri)).thenReturn();
+ when(testStore.onDidChange).thenReturn(noop as any);
+ const testTreeProvider = createMockTestTreeProvider(instance(testStore), undefined, undefined, undefined, instance(commandManager));
+
+ // No parent
+ testTreeProvider.getParent = () => Promise.resolve(undefined);
+
+ const element: TestFile = {
+ fullPath: __filename,
+ functions: [],
+ suites: [],
+ name: 'name',
+ time: 0,
+ resource: Uri.file(__filename),
+ xmlName: '',
+ nameToRun: ''
+ };
+
+ const node = await testTreeProvider.getTreeItem(element);
+
+ expect(node.collapsibleState).to.equal(TreeItemCollapsibleState.Expanded);
+ });
+ test('Expand tree item if the parent is the Workspace Folder in a multiroot scenario', async () => {
+ const commandManager = mock(CommandManager);
+ const testStore = mock(TestCollectionStorageService);
+ const testWorkspaceFolder = new TestWorkspaceFolder({ uri: Uri.file(__filename), name: '', index: 0 });
+ when(testStore.getTests(testWorkspaceFolder.workspaceFolder.uri)).thenReturn();
+ when(testStore.onDidChange).thenReturn(noop as any);
+ const testTreeProvider = createMockTestTreeProvider(instance(testStore), undefined, undefined, undefined, instance(commandManager));
+
+ // Has a workspace folder as parent.
+ const parentFolder = new TestWorkspaceFolder({ name: '', index: 0, uri: Uri.file(__filename) });
+
+ testTreeProvider.getParent = () => Promise.resolve(parentFolder);
+
+ const element: TestFile = {
+ fullPath: __filename,
+ functions: [],
+ suites: [],
+ name: 'name',
+ time: 0,
+ resource: Uri.file(__filename),
+ xmlName: '',
+ nameToRun: ''
+ };
+
+ const node = await testTreeProvider.getTreeItem(element);
+
+ expect(node.collapsibleState).to.equal(TreeItemCollapsibleState.Expanded);
+ });
+ test('Do not expand tree item if it does not have any parent', async () => {
+ const commandManager = mock(CommandManager);
+ const testStore = mock(TestCollectionStorageService);
+ const testWorkspaceFolder = new TestWorkspaceFolder({ uri: Uri.file(__filename), name: '', index: 0 });
+ when(testStore.getTests(testWorkspaceFolder.workspaceFolder.uri)).thenReturn();
+ when(testStore.onDidChange).thenReturn(noop as any);
+ const testTreeProvider = createMockTestTreeProvider(instance(testStore), undefined, undefined, undefined, instance(commandManager));
+
+ // Has a parent folder
+ const parentFolder: TestFolder = {
+ name: '',
+ nameToRun: '',
+ resource: Uri.file(__filename),
+ time: 0,
+ testFiles: [],
+ folders: []
+ };
+
+ testTreeProvider.getParent = () => Promise.resolve(parentFolder);
+
+ const element: TestFile = {
+ fullPath: __filename,
+ functions: [],
+ suites: [],
+ name: 'name',
+ time: 0,
+ resource: Uri.file(__filename),
+ xmlName: '',
+ nameToRun: ''
+ };
+
+ const node = await testTreeProvider.getTreeItem(element);
+
+ expect(node.collapsibleState).to.not.equal(TreeItemCollapsibleState.Expanded);
+ });
 });