Updated icons and tooltip in test explorer indicating status of test files/suites

news/1 Enhancements/4583.md

@@ -0,0 +1 @@
+Update icons and tooltip in test explorer indicating status of test files/suites

src/client/unittests/common/services/testResultsService.ts

@@ -1,4 +1,6 @@
 import { inject, injectable, named } from 'inversify';
+import { TestDataItem } from '../../types';
+import { visitParentsRecursive } from '../testVisitors/visitor';
 import { ITestResultsService, ITestVisitor, TestFile, TestFolder, Tests, TestStatus, TestSuite } from './../types';
 
 @injectable()
@@ -12,100 +14,114 @@ export class TestResultsService implements ITestResultsService {
     }
     public updateResults(tests: Tests): void {
         tests.testFiles.forEach(test => this.updateTestFileResults(test));
-        tests.testFolders.forEach(folder => this.updateTestFolderResults(folder));
+        tests.rootTestFolders.forEach(folder => this.updateTestFolderResults(folder));
+        // List items should be updated in order
+        [TestStatus.Pass, TestStatus.Fail].forEach(item => this.updateParentStatus(tests, item));
     }
     private updateTestSuiteResults(test: TestSuite): void {
         this.updateTestSuiteAndFileResults(test);
     }
     private updateTestFileResults(test: TestFile): void {
         this.updateTestSuiteAndFileResults(test);
     }
+    private updateParentStatus(tests: Tests, status: TestStatus): void {
+        const visitor = (item: TestDataItem) => {
+            item.status = status;
+        };
+        tests.testFiles.forEach(item => {
+            if (typeof item.passed === 'boolean') {
+                if (status === TestStatus.Pass ? item.passed : !item.passed) {
+                    visitParentsRecursive(tests, item, visitor);
+                }
+            }
+        });
+    }
     private updateTestFolderResults(testFolder: TestFolder): void {
+        let totalTime = 0;
         let allFilesPassed = true;
-        let allFilesRan = true;
+        let allFilesSkipped = true;
 
         testFolder.testFiles.forEach(fl => {
-            if (allFilesPassed && typeof fl.passed === 'boolean') {
+            totalTime += fl.time;
+            if (typeof fl.passed === 'boolean') {
+                allFilesSkipped = false;
                 if (!fl.passed) {
                     allFilesPassed = false;
                 }
-            } else {
-                allFilesRan = false;
             }
 
             testFolder.functionsFailed! += fl.functionsFailed!;
             testFolder.functionsPassed! += fl.functionsPassed!;
         });
 
         let allFoldersPassed = true;
-        let allFoldersRan = true;
+        let allFoldersSkipped = true;
 
         testFolder.folders.forEach(folder => {
+            totalTime += folder.time;
             this.updateTestFolderResults(folder);
-            if (allFoldersPassed && typeof folder.passed === 'boolean') {
+            if (typeof folder.passed === 'boolean') {
+                allFoldersSkipped = false;
                 if (!folder.passed) {
                     allFoldersPassed = false;
                 }
-            } else {
-                allFoldersRan = false;
             }
 
             testFolder.functionsFailed! += folder.functionsFailed!;
             testFolder.functionsPassed! += folder.functionsPassed!;
         });
 
-        if (allFilesRan && allFoldersRan) {
-            testFolder.passed = allFilesPassed && allFoldersPassed;
-            testFolder.status = testFolder.passed ? TestStatus.Idle : TestStatus.Fail;
-        } else {
+        testFolder.time = totalTime;
+        if (allFilesSkipped && allFoldersSkipped) {
             testFolder.passed = undefined;
             testFolder.status = TestStatus.Unknown;
+        } else {
+            testFolder.passed = allFilesPassed && allFoldersPassed;
+            testFolder.status = testFolder.passed ? TestStatus.Pass : TestStatus.Fail;
         }
     }
     private updateTestSuiteAndFileResults(test: TestSuite | TestFile): void {
         let totalTime = 0;
         let allFunctionsPassed = true;
-        let allFunctionsRan = true;
+        let allFunctionsSkipped = true;
 
         test.functions.forEach(fn => {
             totalTime += fn.time;
             if (typeof fn.passed === 'boolean') {
+                allFunctionsSkipped = false;
                 if (fn.passed) {
                     test.functionsPassed! += 1;
                 } else {
                     test.functionsFailed! += 1;
                     allFunctionsPassed = false;
                 }
-            } else {
-                allFunctionsRan = false;
             }
         });
 
         let allSuitesPassed = true;
-        let allSuitesRan = true;
+        let allSuitesSkipped = true;
 
         test.suites.forEach(suite => {
             this.updateTestSuiteResults(suite);
             totalTime += suite.time;
-            if (allSuitesRan && typeof suite.passed === 'boolean') {
+            if (typeof suite.passed === 'boolean') {
+                allSuitesSkipped = false;
                 if (!suite.passed) {
                     allSuitesPassed = false;
                 }
-            } else {
-                allSuitesRan = false;
             }
 
             test.functionsFailed! += suite.functionsFailed!;
             test.functionsPassed! += suite.functionsPassed!;
         });
 
         test.time = totalTime;
-        if (allSuitesRan && allFunctionsRan) {
-            test.passed = allFunctionsPassed && allSuitesPassed;
-            test.status = test.passed ? TestStatus.Idle : TestStatus.Error;
-        } else {
+        if (allSuitesSkipped && allFunctionsSkipped) {
             test.passed = undefined;
             test.status = TestStatus.Unknown;
+        } else {
+            test.passed = allFunctionsPassed && allSuitesPassed;
+            test.status = test.passed ? TestStatus.Pass : TestStatus.Error;
         }
     }
 }

src/client/unittests/explorer/testTreeViewItem.ts

@@ -53,6 +53,10 @@ export abstract class TestTreeItem extends TreeItem {
             case TestStatus.Running: {
                 return getIcon(Icons.discovering);
             }
+            case TestStatus.Idle:
+            case TestStatus.Unknown: {
+                return getIcon(Icons.unknown);
+            }
             default: {
                 switch (this.testType) {
                     case TestType.testFile: {
@@ -75,6 +79,31 @@ export abstract class TestTreeItem extends TreeItem {
         return this.parentData;
     }
 
+    public get tooltip(): string {
+        if (!this.data) {
+            return '';
+        }
+        if (this.testType !== TestType.testFunction) {
+            return `${this.data.functionsFailed} failed, ${this.data.functionsPassed} passed in ${this.data.time} seconds`;
+        }
+        switch (this.data.status) {
+            case TestStatus.Error:
+            case TestStatus.Fail: {
+                return `Failed in ${this.data.time} seconds`;
+            }
+            case TestStatus.Pass: {
+                return `Passed in ${this.data.time} seconds`;
+            }
+            case TestStatus.Discovering:
+            case TestStatus.Running: {
+                return 'Loading...';
+            }
+            default: {
+                return '';
+            }
+        }
+    }
+
     /**
      * Tooltip for our tree nodes is the test status
      */