diagnostics: Implement and use GetSupportedRoutines()

Bug: 1125150
Test: browser_tests --gtest_filter=Diagnostics*
Change-Id: I4e4754937c0694814faa75dcad22b9cba457527d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2550249
Commit-Queue: Joon Ahn <joonbug@chromium.org>
Reviewed-by: Zentaro Kavanagh <zentaro@chromium.org>
Cr-Commit-Position: refs/heads/master@{#829677}

chrome/test/data/webui/chromeos/diagnostics/BUILD.gn

@@ -91,6 +91,7 @@ js_library("diagnostics_test_utils") {
     "//chromeos/components/diagnostics_ui/resources:battery_status_card",
     "//chromeos/components/diagnostics_ui/resources:cpu_card",
     "//chromeos/components/diagnostics_ui/resources:data_point",
+    "//chromeos/components/diagnostics_ui/resources:fake_data",
     "//chromeos/components/diagnostics_ui/resources:memory_card",
     "//chromeos/components/diagnostics_ui/resources:percent_bar_chart",
     "//chromeos/components/diagnostics_ui/resources:realtime_cpu_chart",

chrome/test/data/webui/chromeos/diagnostics/fake_system_routine_controller_test.js

@@ -5,7 +5,8 @@
 import {RoutineName, RoutineRunner, StandardRoutineResult} from 'chrome://diagnostics/diagnostics_types.js';
 import {FakeSystemRoutineController} from 'chrome://diagnostics/fake_system_routine_controller.js';
 import {PromiseResolver} from 'chrome://resources/js/promise_resolver.m.js';
-import {assertEquals, assertFalse, assertTrue} from '../../chai_assert.js';
+
+import {assertDeepEquals, assertEquals, assertFalse, assertTrue} from '../../chai_assert.js';
 
 export function fakeSystemRoutineContollerTestSuite() {
   /** @type {?FakeSystemRoutineController} */
@@ -173,4 +174,14 @@ export function fakeSystemRoutineContollerTestSuite() {
     return runRoutineAndAssertStandardResultManualResolve(
         routineName, expectedResult);
   });
+
+  test('GetSupportedRoutines', () => {
+    /** @type {!Array<!RoutineName>} */
+    const expected = [RoutineName.kCpuStress, RoutineName.kCpuCache];
+
+    controller.setFakeSupportedRoutines(expected);
+    return controller.getSupportedRoutines().then((result) => {
+      assertDeepEquals(expected, result.routines);
+    });
+  });
 }

chrome/test/data/webui/chromeos/diagnostics/routine_section_test.js

@@ -6,6 +6,7 @@ import 'chrome://diagnostics/routine_result_entry.js';
 import 'chrome://diagnostics/routine_section.js';
 
 import {RoutineName, StandardRoutineResult} from 'chrome://diagnostics/diagnostics_types.js';
+import {fakeBatteryRoutineResults, fakeRoutineResults} from 'chrome://diagnostics/fake_data.js';
 import {FakeSystemRoutineController} from 'chrome://diagnostics/fake_system_routine_controller.js';
 import {setSystemRoutineControllerForTesting} from 'chrome://diagnostics/mojo_interface_provider.js';
 import {ExecutionProgress} from 'chrome://diagnostics/routine_list_executor.js';
@@ -30,6 +31,11 @@ export function routineSectionTestSuite() {
     // done explicitly.
     routineController = new FakeSystemRoutineController();
     routineController.setDelayTimeInMillisecondsForTesting(-1);
+
+    // Enable all routines by default.
+    routineController.setFakeSupportedRoutines(
+        [...fakeRoutineResults.keys(), ...fakeBatteryRoutineResults.keys()]);
+
     setSystemRoutineControllerForTesting(routineController);
   });
 
@@ -273,6 +279,40 @@ export function routineSectionTestSuite() {
         });
   });
 
+  test('ResultListFiltersBySupported', () => {
+    /** @type {!Array<!RoutineName>} */
+    const routines = [
+      RoutineName.kCpuCache,
+      RoutineName.kMemory,
+    ];
+
+    routineController.setFakeStandardRoutineResult(
+        RoutineName.kMemory, StandardRoutineResult.kTestPassed);
+    routineController.setFakeStandardRoutineResult(
+        RoutineName.kCpuCache, StandardRoutineResult.kTestPassed);
+    routineController.setFakeSupportedRoutines([RoutineName.kMemory]);
+
+    return initializeRoutineSection(routines)
+        .then(() => {
+          return clickRunTestsButton();
+        })
+        .then(() => {
+          const entries = getEntries();
+          assertEquals(1, entries.length);
+          assertEquals(RoutineName.kMemory, entries[0].item.routine);
+          // Resolve the running test.
+          return routineController.resolveRoutineForTesting();
+        })
+        .then(() => {
+          return flushTasks();
+        })
+        .then(() => {
+          const entries = getEntries();
+          assertEquals(1, entries.length);
+          assertEquals(RoutineName.kMemory, entries[0].item.routine);
+        });
+  });
+
   test('ResultListStatusSuccess', () => {
     /** @type {!Array<!RoutineName>} */
     const routines = [

chromeos/components/diagnostics_ui/resources/fake_system_routine_controller.js

@@ -6,6 +6,7 @@ import {assert} from 'chrome://resources/js/assert.m.js';
 import {PromiseResolver} from 'chrome://resources/js/promise_resolver.m.js';
 
 import {BatteryRateRoutineResult, RoutineName, RoutineResult, RoutineResultInfo, RoutineRunner, StandardRoutineResult} from './diagnostics_types.js';
+import {FakeMethodResolver} from './fake_method_resolver.js';
 
 /**
  * @fileoverview
@@ -14,6 +15,9 @@ import {BatteryRateRoutineResult, RoutineName, RoutineResult, RoutineResultInfo,
 
 export class FakeSystemRoutineController {
   constructor() {
+    /** @private {!FakeMethodResolver} */
+    this.methods_ = new FakeMethodResolver();
+
     /** private !Map<!RoutineName, !RoutineResult> */
     this.routineResults_ = new Map();
 
@@ -42,6 +46,24 @@ export class FakeSystemRoutineController {
      * @private {?RoutineName}
      */
     this.routineName_ = null;
+
+    this.registerMethods();
+  }
+
+  /*
+   * Implements SystemRoutineController.GetSupportedRoutines
+   * @return {!Promise<!{routines: !Array<!RoutineName>}>}
+   */
+  getSupportedRoutines() {
+    return this.methods_.resolveMethod('getSupportedRoutines');
+  }
+
+  /**
+   * Sets the value that will be returned when calling getSupportedRoutines().
+   * @param {!Array<!RoutineName>} routines
+   */
+  setFakeSupportedRoutines(routines) {
+    this.methods_.setResult('getSupportedRoutines', {routines: routines});
   }
 
   /*
@@ -66,6 +88,13 @@ export class FakeSystemRoutineController {
     return this.resolver_.promise;
   }
 
+  /**
+   * Setup method resolvers.
+   */
+  registerMethods() {
+    this.methods_.register('getSupportedRoutines');
+  }
+
   /**
    *
    * @param {!RoutineName} routineName

chromeos/components/diagnostics_ui/resources/mojo_interface_provider.js

@@ -62,13 +62,16 @@ function setupFakeSystemRoutineController_() {
         /** @type{!StandardRoutineResult} */ (result));
   }
 
-  // Add fake battery routine results.
   for (const [routine, result] of fakeBatteryRoutineResults.entries()) {
     controller.setFakeBatteryRateRoutineResult(
         /** @type {!RoutineName} */ (routine),
         /** @type {!BatteryRateRoutineResult} */ (result));
   }
 
+  // Enable fake set of routines.
+  controller.setFakeSupportedRoutines(
+      [...fakeRoutineResults.keys(), ...fakeBatteryRoutineResults.keys()]);
+
   // Set the fake controller.
   setSystemRoutineControllerForTesting(controller);
 }

chromeos/components/diagnostics_ui/resources/routine_section.js

@@ -8,11 +8,11 @@ import './routine_result_list.js';
 import './text_badge.js';
 import './strings.m.js';
 
-import {I18nBehavior} from 'chrome://resources/js/i18n_behavior.m.js';
 import {assert} from 'chrome://resources/js/assert.m.js';
+import {I18nBehavior} from 'chrome://resources/js/i18n_behavior.m.js';
 import {html, Polymer} from 'chrome://resources/polymer/v3_0/polymer/polymer_bundled.min.js';
 
-import {RoutineName, StandardRoutineResult} from './diagnostics_types.js';
+import {RoutineName, StandardRoutineResult, SystemRoutineControllerInterface} from './diagnostics_types.js';
 import {getSystemRoutineController} from './mojo_interface_provider.js';
 import {ExecutionProgress, RoutineListExecutor} from './routine_list_executor.js';
 import {lookupEnumValueName} from './routine_result_entry.js';
@@ -49,6 +49,9 @@ Polymer({
    */
   hasTestFailure_: false,
 
+  /** @private {?SystemRoutineControllerInterface} */
+  systemRoutineController_: null,
+
   properties: {
     /** @type {!Array<!RoutineName>} */
     routines: {
@@ -98,31 +101,41 @@ Polymer({
   onRunTestsClicked_() {
     this.isRunTestsDisabled_ = true;
     this.hasTestFailure_ = false;
-    const resultListElem = this.getResultListElem_();
-    resultListElem.initializeTestRun(this.routines);
-
-    this.executor_ = new RoutineListExecutor(getSystemRoutineController());
-    this.executionStatus_ = ExecutionProgress.kRunning;
-    this.executor_
-        .runRoutines(
-            this.routines,
-            (status) => {
-              // TODO(joonbug): Update this function to use localized test name
-              this.currentTestName_ =
-                  lookupEnumValueName(RoutineName, status.routine);
-
-              if (status.result &&
-                  status.result.simpleResult !==
-                      StandardRoutineResult.kTestPassed) {
-                this.hasTestFailure_ = true;
-              }
-
-              resultListElem.onStatusUpdate.call(resultListElem, status);
-            })
-        .then(() => {
-          this.executionStatus_ = ExecutionProgress.kCompleted;
-          this.isRunTestsDisabled_ = false;
-        });
+
+    this.systemRoutineController_ = getSystemRoutineController();
+    this.systemRoutineController_.getSupportedRoutines().then((supported) => {
+      const filteredRoutines =
+          this.routines.filter(routine => supported.routines.includes(routine));
+
+      const resultListElem = this.getResultListElem_();
+      resultListElem.initializeTestRun(filteredRoutines);
+
+      this.executor_ =
+          new RoutineListExecutor(assert(this.systemRoutineController_));
+      this.executionStatus_ = ExecutionProgress.kRunning;
+      this.executor_
+          .runRoutines(
+              filteredRoutines,
+              (status) => {
+                // TODO(joonbug): Update this function to use localized test
+                // name
+                this.currentTestName_ =
+                    lookupEnumValueName(RoutineName, status.routine);
+
+                if (status.result &&
+                    status.result.simpleResult !==
+                        StandardRoutineResult.kTestPassed) {
+                  this.hasTestFailure_ = true;
+                }
+
+                resultListElem.onStatusUpdate.call(resultListElem, status);
+              })
+          .then(() => {
+            this.executionStatus_ = ExecutionProgress.kCompleted;
+            this.systemRoutineController_ = null;
+            this.isRunTestsDisabled_ = false;
+          });
+    });
   },
 
   /** @private */