// Copyright 2019 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <limits>
#include <string>
#include <tuple>
#include <type_traits>
#include <vector>

#include <base/bind.h>
#include <base/callback.h>
#include <base/run_loop.h>
#include <base/test/task_environment.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include "diagnostics/wilco_dtc_supportd/fake_diagnostics_service.h"
#include "diagnostics/wilco_dtc_supportd/routine_service.h"
#include "mojo/cros_healthd_diagnostics.mojom.h"

using testing::ElementsAreArray;

namespace diagnostics {
namespace mojo_ipc = ::chromeos::cros_healthd::mojom;

namespace {

grpc_api::RunRoutineRequest MakeBatteryRoutineRequest() {
  grpc_api::RunRoutineRequest request;
  request.set_routine(grpc_api::ROUTINE_BATTERY);
  request.mutable_battery_params()->set_low_mah(10);
  request.mutable_battery_params()->set_high_mah(100);
  return request;
}

grpc_api::RunRoutineRequest MakeDefaultBatteryRoutineRequest() {
  grpc_api::RunRoutineRequest request;
  request.set_routine(grpc_api::ROUTINE_BATTERY);
  request.mutable_battery_params();
  return request;
}

grpc_api::RunRoutineRequest MakeBatterySysfsRoutineRequest() {
  grpc_api::RunRoutineRequest request;
  request.set_routine(grpc_api::ROUTINE_BATTERY_SYSFS);
  request.mutable_battery_sysfs_params()->set_maximum_cycle_count(2);
  request.mutable_battery_sysfs_params()->set_percent_battery_wear_allowed(30);
  return request;
}

grpc_api::RunRoutineRequest MakeUrandomRoutineRequest() {
  grpc_api::RunRoutineRequest request;
  request.set_routine(grpc_api::ROUTINE_URANDOM);
  request.mutable_urandom_params()->set_length_seconds(10);
  return request;
}

grpc_api::RunRoutineRequest MakeSmartctlCheckRoutineRequest() {
  grpc_api::RunRoutineRequest request;
  request.set_routine(grpc_api::ROUTINE_SMARTCTL_CHECK);
  request.mutable_smartctl_check_params();
  return request;
}

grpc_api::RunRoutineRequest MakeCpuCacheRoutineRequest() {
  grpc_api::RunRoutineRequest request;
  request.set_routine(grpc_api::ROUTINE_CPU_CACHE);
  request.mutable_cpu_params()->set_length_seconds(10);
  return request;
}

grpc_api::RunRoutineRequest MakeCpuStressRoutineRequest() {
  grpc_api::RunRoutineRequest request;
  request.set_routine(grpc_api::ROUTINE_CPU_STRESS);
  request.mutable_cpu_params()->set_length_seconds(300);
  return request;
}

grpc_api::RunRoutineRequest MakeFloatingPointAccuracyRoutineRequest() {
  grpc_api::RunRoutineRequest request;
  request.set_routine(grpc_api::ROUTINE_FLOATING_POINT_ACCURACY);
  request.mutable_floating_point_accuracy_params()->set_length_seconds(2);
  return request;
}

grpc_api::RunRoutineRequest MakeNvmeWearLevelRoutineRequest() {
  grpc_api::RunRoutineRequest request;
  request.set_routine(grpc_api::ROUTINE_NVME_WEAR_LEVEL);
  request.mutable_nvme_wear_level_params()->set_wear_level_threshold(50);
  return request;
}
grpc_api::RunRoutineRequest MakeNvmeSelfTestShortRoutineRequest() {
  grpc_api::RunRoutineRequest request;
  request.set_routine(grpc_api::ROUTINE_NVME_SHORT_SELF_TEST);
  request.mutable_nvme_short_self_test_params();
  return request;
}

grpc_api::RunRoutineRequest MakeNvmeSelfTestLongRoutineRequest() {
  grpc_api::RunRoutineRequest request;
  request.set_routine(grpc_api::ROUTINE_NVME_LONG_SELF_TEST);
  request.mutable_nvme_long_self_test_params();
  return request;
}

grpc_api::RunRoutineRequest MakeDiskLinearReadRoutineRequest() {
  grpc_api::RunRoutineRequest request;
  request.set_routine(grpc_api::ROUTINE_DISK_LINEAR_READ);
  request.mutable_disk_linear_read_params()->set_length_seconds(10);
  request.mutable_disk_linear_read_params()->set_file_size_mb(1024);
  return request;
}

grpc_api::RunRoutineRequest MakeDiskRandomReadRoutineRequest() {
  grpc_api::RunRoutineRequest request;
  request.set_routine(grpc_api::ROUTINE_DISK_RANDOM_READ);
  request.mutable_disk_random_read_params()->set_length_seconds(10);
  request.mutable_disk_random_read_params()->set_file_size_mb(1024);
  return request;
}

void SaveGetAvailableRoutinesResponse(
    base::Closure callback,
    grpc_api::GetAvailableRoutinesResponse* response,
    const std::vector<grpc_api::DiagnosticRoutine>& returned_routines,
    grpc_api::RoutineServiceStatus service_status) {
  for (const auto& routine : returned_routines)
    response->add_routines(routine);
  response->set_service_status(service_status);
  callback.Run();
}

void SaveRunRoutineResponse(base::Closure callback,
                            grpc_api::RunRoutineResponse* response,
                            int uuid,
                            grpc_api::DiagnosticRoutineStatus status,
                            grpc_api::RoutineServiceStatus service_status) {
  response->set_uuid(uuid);
  response->set_status(status);
  response->set_service_status(service_status);
  callback.Run();
}

void SaveGetRoutineUpdateResponse(
    base::Closure callback,
    grpc_api::GetRoutineUpdateResponse* response,
    int uuid,
    grpc_api::DiagnosticRoutineStatus status,
    int progress_percent,
    grpc_api::DiagnosticRoutineUserMessage user_message,
    const std::string& output,
    const std::string& status_message,
    grpc_api::RoutineServiceStatus service_status) {
  response->set_uuid(uuid);
  response->set_status(status);
  response->set_progress_percent(progress_percent);
  response->set_user_message(user_message);
  response->set_output(output);
  response->set_status_message(status_message);
  response->set_service_status(service_status);
  callback.Run();
}

// Tests for the RoutineService class.
class RoutineServiceTest : public testing::Test {
 protected:
  RoutineServiceTest() = default;

  FakeDiagnosticsService* diagnostics_service() {
    return &diagnostics_service_;
  }

  grpc_api::GetAvailableRoutinesResponse ExecuteGetAvailableRoutines() {
    base::RunLoop run_loop;
    grpc_api::GetAvailableRoutinesResponse response;
    service_.GetAvailableRoutines(base::Bind(
        &SaveGetAvailableRoutinesResponse, run_loop.QuitClosure(), &response));
    run_loop.Run();
    return response;
  }

  grpc_api::RunRoutineResponse ExecuteRunRoutine(
      const grpc_api::RunRoutineRequest& request) {
    base::RunLoop run_loop;
    grpc_api::RunRoutineResponse response;
    service_.RunRoutine(request, base::Bind(&SaveRunRoutineResponse,
                                            run_loop.QuitClosure(), &response));
    run_loop.Run();
    return response;
  }

  grpc_api::GetRoutineUpdateResponse ExecuteGetRoutineUpdate(
      const int uuid,
      const grpc_api::GetRoutineUpdateRequest::Command command,
      const bool include_output) {
    base::RunLoop run_loop;
    grpc_api::GetRoutineUpdateResponse response;
    service_.GetRoutineUpdate(uuid, command, include_output,
                              base::Bind(&SaveGetRoutineUpdateResponse,
                                         run_loop.QuitClosure(), &response));
    run_loop.Run();
    return response;
  }

 private:
  base::test::TaskEnvironment task_environment_{
      base::test::TaskEnvironment::ThreadingMode::MAIN_THREAD_ONLY};
  FakeDiagnosticsService diagnostics_service_;
  RoutineService service_{&diagnostics_service_};
};

// Test that GetAvailableRoutines returns the expected list of routines.
TEST_F(RoutineServiceTest, GetAvailableRoutines) {
  diagnostics_service()->SetGetAvailableRoutinesResponse(
      {mojo_ipc::DiagnosticRoutineEnum::kBatteryCapacity,
       mojo_ipc::DiagnosticRoutineEnum::kBatteryHealth,
       mojo_ipc::DiagnosticRoutineEnum::kSmartctlCheck,
       mojo_ipc::DiagnosticRoutineEnum::kUrandom,
       mojo_ipc::DiagnosticRoutineEnum::kCpuCache,
       mojo_ipc::DiagnosticRoutineEnum::kCpuStress,
       mojo_ipc::DiagnosticRoutineEnum::kFloatingPointAccuracy,
       mojo_ipc::DiagnosticRoutineEnum::kNvmeWearLevel,
       mojo_ipc::DiagnosticRoutineEnum::kNvmeSelfTest,
       mojo_ipc::DiagnosticRoutineEnum::kDiskRead});

  const auto reply = ExecuteGetAvailableRoutines();
  EXPECT_THAT(reply.routines(),
              ElementsAreArray(
                  {grpc_api::ROUTINE_BATTERY, grpc_api::ROUTINE_BATTERY_SYSFS,
                   grpc_api::ROUTINE_SMARTCTL_CHECK, grpc_api::ROUTINE_URANDOM,
                   grpc_api::ROUTINE_CPU_CACHE, grpc_api::ROUTINE_CPU_STRESS,
                   grpc_api::ROUTINE_FLOATING_POINT_ACCURACY,
                   grpc_api::ROUTINE_NVME_WEAR_LEVEL,
                   grpc_api::ROUTINE_NVME_SHORT_SELF_TEST,
                   grpc_api::ROUTINE_NVME_LONG_SELF_TEST,
                   grpc_api::ROUTINE_DISK_LINEAR_READ,
                   grpc_api::ROUTINE_DISK_RANDOM_READ}));
  EXPECT_EQ(reply.service_status(), grpc_api::ROUTINE_SERVICE_STATUS_OK);
}

// Test that an unknown mojo routine enum is handled sanely.
TEST_F(RoutineServiceTest, GetAvailableRoutinesInvalidMojoRoutineEnum) {
  diagnostics_service()->SetGetAvailableRoutinesResponse(
      std::vector<mojo_ipc::DiagnosticRoutineEnum>{
          static_cast<mojo_ipc::DiagnosticRoutineEnum>(
              std::numeric_limits<std::underlying_type<
                  mojo_ipc::DiagnosticRoutineEnum>::type>::max()),
          mojo_ipc::DiagnosticRoutineEnum::kBatteryCapacity});

  const auto reply = ExecuteGetAvailableRoutines();
  EXPECT_THAT(reply.routines(), ElementsAreArray({grpc_api::ROUTINE_BATTERY}));
  EXPECT_EQ(reply.service_status(), grpc_api::ROUTINE_SERVICE_STATUS_OK);
}

// Test that an invalid RunRoutineRequest is handled sanely.
TEST_F(RoutineServiceTest, InvalidRunRoutineRequest) {
  grpc_api::RunRoutineRequest request;
  request.set_routine(static_cast<grpc_api::DiagnosticRoutine>(
      std::numeric_limits<
          std::underlying_type<grpc_api::DiagnosticRoutine>::type>::max()));

  const auto reply = ExecuteRunRoutine(request);
  EXPECT_EQ(reply.uuid(), 0);
  EXPECT_EQ(reply.status(), grpc_api::ROUTINE_STATUS_INVALID_FIELD);
  EXPECT_EQ(reply.service_status(), grpc_api::ROUTINE_SERVICE_STATUS_OK);
}

// Test that a routine reporting an invalid user message is handled sanely.
TEST_F(RoutineServiceTest, GetRoutineUpdateInvalidUserMessage) {
  diagnostics_service()->SetInteractiveUpdate(
      static_cast<mojo_ipc::DiagnosticRoutineUserMessageEnum>(
          std::numeric_limits<std::underlying_type<
              mojo_ipc::DiagnosticRoutineUserMessageEnum>::type>::max()),
      0 /* progress_percent */, "" /* output */);

  const auto update_response = ExecuteGetRoutineUpdate(
      0 /* uuid */, grpc_api::GetRoutineUpdateRequest::GET_STATUS,
      false /* include_output */);
  EXPECT_EQ(update_response.status(), grpc_api::ROUTINE_STATUS_ERROR);
  EXPECT_EQ(update_response.service_status(),
            grpc_api::ROUTINE_SERVICE_STATUS_OK);
}

// Test that a routine update reporting an invalid status is handled sanely.
TEST_F(RoutineServiceTest, InvalidGetRoutineUpdateStatus) {
  diagnostics_service()->SetNonInteractiveUpdate(
      static_cast<mojo_ipc::DiagnosticRoutineStatusEnum>(
          std::numeric_limits<std::underlying_type<
              mojo_ipc::DiagnosticRoutineStatusEnum>::type>::max()),
      "" /* status_message */, 0 /* progress_percent */, "" /* output */);

  const auto update_response = ExecuteGetRoutineUpdate(
      0 /* uuid */, grpc_api::GetRoutineUpdateRequest::GET_STATUS,
      false /* include_output */);
  EXPECT_EQ(update_response.status(), grpc_api::ROUTINE_STATUS_ERROR);
  EXPECT_EQ(update_response.service_status(),
            grpc_api::ROUTINE_SERVICE_STATUS_OK);
}

// Test that a run routine response reporting an invalid status is handled
// sanely.
TEST_F(RoutineServiceTest, InvalidRunRoutineResponseStatus) {
  diagnostics_service()->SetRunSomeRoutineResponse(
      0 /* uuid */,
      static_cast<mojo_ipc::DiagnosticRoutineStatusEnum>(
          std::numeric_limits<std::underlying_type<
              mojo_ipc::DiagnosticRoutineStatusEnum>::type>::max()));

  const auto response = ExecuteRunRoutine(MakeSmartctlCheckRoutineRequest());
  EXPECT_EQ(response.status(), grpc_api::ROUTINE_STATUS_ERROR);
  EXPECT_EQ(response.uuid(), 0);
  EXPECT_EQ(response.service_status(), grpc_api::ROUTINE_SERVICE_STATUS_OK);
}

// Test that an invalid command passed to the routine service is handled sanely.
TEST_F(RoutineServiceTest, GetRoutineUpdateInvalidCommand) {
  diagnostics_service()->SetNonInteractiveUpdate(
      mojo_ipc::DiagnosticRoutineStatusEnum::kReady, "" /* status_message */,
      0 /* progress_percent */, "" /* output */);

  const auto update_response = ExecuteGetRoutineUpdate(
      0 /* uuid */,
      static_cast<grpc_api::GetRoutineUpdateRequest::Command>(
          std::numeric_limits<std::underlying_type<
              grpc_api::GetRoutineUpdateRequest::Command>::type>::max()),
      false /* include_output */);
  EXPECT_EQ(update_response.status(), grpc_api::ROUTINE_STATUS_INVALID_FIELD);
  EXPECT_EQ(update_response.progress_percent(), 0);
  EXPECT_EQ(update_response.user_message(),
            grpc_api::ROUTINE_USER_MESSAGE_UNSET);
  EXPECT_EQ(update_response.output(), "");
  EXPECT_EQ(update_response.status_message(), "");
  EXPECT_EQ(update_response.service_status(),
            grpc_api::ROUTINE_SERVICE_STATUS_OK);
}

// Test that the routine service doesn't attempt to rebind a valid mojo service
// pointer.
TEST_F(RoutineServiceTest, NoRebindService) {
  constexpr uint32_t kExpectedId = 55;
  diagnostics_service()->SetRunSomeRoutineResponse(
      kExpectedId, mojo_ipc::DiagnosticRoutineStatusEnum::kRunning);
  // Send the first mojo IPC to the diagnostics service. This IPC should
  // bootstrap the mojo connection. Ignore the response, because we're only
  // interested in whether or not the next request tries to bootstrap the mojo
  // connection again.
  ExecuteRunRoutine(MakeSmartctlCheckRoutineRequest());

  // Tell the service to respond with an error if a second bootstrapping is
  // requested.
  diagnostics_service()->SetMojoServiceIsAvailable(false);

  // Send another request. This shouldn't see an error, because it shouldn't try
  // to bootstrap the mojo connection a second time.
  const auto reply = ExecuteRunRoutine(MakeSmartctlCheckRoutineRequest());

  // If the bootstrap was requested a second time, we would receive a uuid of 0
  // and a status of grpc_api::FAILED_TO_START.
  EXPECT_EQ(reply.uuid(), kExpectedId);
  EXPECT_EQ(reply.status(), grpc_api::ROUTINE_STATUS_RUNNING);
  EXPECT_EQ(reply.service_status(), grpc_api::ROUTINE_SERVICE_STATUS_OK);
}

// Test that the routine service handles a GetAvailableRoutines request sent
// before wilco_dtc_supportd's mojo service is established.
TEST_F(RoutineServiceTest, GetAvailableRoutinesNoService) {
  diagnostics_service()->SetMojoServiceIsAvailable(false);

  const auto reply = ExecuteGetAvailableRoutines();
  EXPECT_EQ(reply.routines_size(), 0);
  EXPECT_EQ(reply.service_status(),
            grpc_api::ROUTINE_SERVICE_STATUS_UNAVAILABLE);
}

// Test that the routine service handles a RunRoutine request sent before
// wilco_dtc_supportd's mojo service is established.
TEST_F(RoutineServiceTest, RunRoutineNoService) {
  diagnostics_service()->SetMojoServiceIsAvailable(false);

  const auto response = ExecuteRunRoutine(MakeSmartctlCheckRoutineRequest());
  EXPECT_EQ(response.status(), grpc_api::ROUTINE_STATUS_FAILED_TO_START);
  EXPECT_EQ(response.uuid(), 0);
  EXPECT_EQ(response.service_status(),
            grpc_api::ROUTINE_SERVICE_STATUS_UNAVAILABLE);
}

// Test that the routine service handles a GetRoutineUpdate request sent before
// wilco_dtc_supportd's mojo service is established.
TEST_F(RoutineServiceTest, GetRoutineUpdateNoService) {
  diagnostics_service()->SetMojoServiceIsAvailable(false);

  const auto update_response = ExecuteGetRoutineUpdate(
      0 /* uuid */, grpc_api::GetRoutineUpdateRequest::GET_STATUS,
      false /* include_output */);
  EXPECT_EQ(update_response.status(), grpc_api::ROUTINE_STATUS_ERROR);
  EXPECT_EQ(update_response.progress_percent(), 0);
  EXPECT_EQ(update_response.user_message(),
            grpc_api::ROUTINE_USER_MESSAGE_UNSET);
  EXPECT_EQ(update_response.output(), "");
  EXPECT_EQ(update_response.status_message(), "");
  EXPECT_EQ(update_response.service_status(),
            grpc_api::ROUTINE_SERVICE_STATUS_UNAVAILABLE);
}

// Test that the routine service can recover from an early gRPC request if
// wilco_dtc_supportd's mojo service is established later.
TEST_F(RoutineServiceTest, RecoverFromNoServiceRequest) {
  // Deal with a request sent before the mojo service is available.
  diagnostics_service()->SetMojoServiceIsAvailable(false);

  const auto unavailable_reply = ExecuteGetAvailableRoutines();
  EXPECT_EQ(unavailable_reply.routines_size(), 0);
  EXPECT_EQ(unavailable_reply.service_status(),
            grpc_api::ROUTINE_SERVICE_STATUS_UNAVAILABLE);
  base::RunLoop().RunUntilIdle();

  // Make the mojo service available, and make sure a valid response is
  // received.
  diagnostics_service()->SetMojoServiceIsAvailable(true);
  diagnostics_service()->SetGetAvailableRoutinesResponse(
      {mojo_ipc::DiagnosticRoutineEnum::kBatteryCapacity,
       mojo_ipc::DiagnosticRoutineEnum::kBatteryHealth,
       mojo_ipc::DiagnosticRoutineEnum::kSmartctlCheck,
       mojo_ipc::DiagnosticRoutineEnum::kUrandom,
       mojo_ipc::DiagnosticRoutineEnum::kCpuCache,
       mojo_ipc::DiagnosticRoutineEnum::kCpuStress,
       mojo_ipc::DiagnosticRoutineEnum::kFloatingPointAccuracy,
       mojo_ipc::DiagnosticRoutineEnum::kNvmeWearLevel,
       mojo_ipc::DiagnosticRoutineEnum::kNvmeSelfTest,
       mojo_ipc::DiagnosticRoutineEnum::kDiskRead});

  const auto reply = ExecuteGetAvailableRoutines();
  EXPECT_THAT(reply.routines(),
              ElementsAreArray(
                  {grpc_api::ROUTINE_BATTERY, grpc_api::ROUTINE_BATTERY_SYSFS,
                   grpc_api::ROUTINE_SMARTCTL_CHECK, grpc_api::ROUTINE_URANDOM,
                   grpc_api::ROUTINE_CPU_CACHE, grpc_api::ROUTINE_CPU_STRESS,
                   grpc_api::ROUTINE_FLOATING_POINT_ACCURACY,
                   grpc_api::ROUTINE_NVME_WEAR_LEVEL,
                   grpc_api::ROUTINE_NVME_SHORT_SELF_TEST,
                   grpc_api::ROUTINE_NVME_LONG_SELF_TEST,
                   grpc_api::ROUTINE_DISK_LINEAR_READ,
                   grpc_api::ROUTINE_DISK_RANDOM_READ}));
  EXPECT_EQ(reply.service_status(), grpc_api::ROUTINE_SERVICE_STATUS_OK);
}

// Test that the routine service handles a GetAvailableRoutines request sent
// when cros_healthd is unresponsive.
TEST_F(RoutineServiceTest, GetAvailableRoutinesUnresponsiveService) {
  diagnostics_service()->SetMojoServiceIsResponsive(false);

  const auto reply = ExecuteGetAvailableRoutines();
  EXPECT_EQ(reply.routines_size(), 0);
  EXPECT_EQ(reply.service_status(),
            grpc_api::ROUTINE_SERVICE_STATUS_UNAVAILABLE);
}

// Test that the routine service handles a RunRoutine request sent when
// cros_healthd is unresponsive.
TEST_F(RoutineServiceTest, RunRoutineUnresponsiveService) {
  diagnostics_service()->SetMojoServiceIsResponsive(false);

  const auto response = ExecuteRunRoutine(MakeSmartctlCheckRoutineRequest());
  EXPECT_EQ(response.status(), grpc_api::ROUTINE_STATUS_FAILED_TO_START);
  EXPECT_EQ(response.uuid(), 0);
  EXPECT_EQ(response.service_status(),
            grpc_api::ROUTINE_SERVICE_STATUS_UNAVAILABLE);
}

// Test that the routine service handles a GetRoutineUpdate request sent when
// cros_healthd is unresponsive.
TEST_F(RoutineServiceTest, GetRoutineUpdateUnresponsiveService) {
  diagnostics_service()->SetMojoServiceIsResponsive(false);

  constexpr int kUuid = 11;
  const auto update_response = ExecuteGetRoutineUpdate(
      kUuid, grpc_api::GetRoutineUpdateRequest::GET_STATUS,
      false /* include_output */);
  EXPECT_EQ(update_response.uuid(), kUuid);
  EXPECT_EQ(update_response.status(), grpc_api::ROUTINE_STATUS_ERROR);
  EXPECT_EQ(update_response.progress_percent(), 0);
  EXPECT_EQ(update_response.user_message(),
            grpc_api::ROUTINE_USER_MESSAGE_UNSET);
  EXPECT_EQ(update_response.output(), "");
  EXPECT_EQ(update_response.status_message(), "");
  EXPECT_EQ(update_response.service_status(),
            grpc_api::ROUTINE_SERVICE_STATUS_UNAVAILABLE);
}

// Test that the routine service can recover from a dropped connection.
TEST_F(RoutineServiceTest, RecoverFromDroppedConnection) {
  // Establish a valid connection.
  diagnostics_service()->SetGetAvailableRoutinesResponse(
      {mojo_ipc::DiagnosticRoutineEnum::kBatteryCapacity,
       mojo_ipc::DiagnosticRoutineEnum::kBatteryHealth,
       mojo_ipc::DiagnosticRoutineEnum::kSmartctlCheck,
       mojo_ipc::DiagnosticRoutineEnum::kUrandom,
       mojo_ipc::DiagnosticRoutineEnum::kCpuCache,
       mojo_ipc::DiagnosticRoutineEnum::kCpuStress,
       mojo_ipc::DiagnosticRoutineEnum::kFloatingPointAccuracy,
       mojo_ipc::DiagnosticRoutineEnum::kNvmeWearLevel,
       mojo_ipc::DiagnosticRoutineEnum::kNvmeSelfTest,
       mojo_ipc::DiagnosticRoutineEnum::kDiskRead});

  const auto reply = ExecuteGetAvailableRoutines();
  EXPECT_THAT(reply.routines(),
              ElementsAreArray(
                  {grpc_api::ROUTINE_BATTERY, grpc_api::ROUTINE_BATTERY_SYSFS,
                   grpc_api::ROUTINE_SMARTCTL_CHECK, grpc_api::ROUTINE_URANDOM,
                   grpc_api::ROUTINE_CPU_CACHE, grpc_api::ROUTINE_CPU_STRESS,
                   grpc_api::ROUTINE_FLOATING_POINT_ACCURACY,
                   grpc_api::ROUTINE_NVME_WEAR_LEVEL,
                   grpc_api::ROUTINE_NVME_SHORT_SELF_TEST,
                   grpc_api::ROUTINE_NVME_LONG_SELF_TEST,
                   grpc_api::ROUTINE_DISK_LINEAR_READ,
                   grpc_api::ROUTINE_DISK_RANDOM_READ}));
  EXPECT_EQ(reply.service_status(), grpc_api::ROUTINE_SERVICE_STATUS_OK);

  // Reset the connection, make cros_healthd unresponsive, and check to see that
  // the routine service responds appropriately.
  diagnostics_service()->ResetMojoConnection();
  diagnostics_service()->SetMojoServiceIsResponsive(false);

  const auto dropped_reply = ExecuteGetAvailableRoutines();
  EXPECT_EQ(dropped_reply.routines_size(), 0);
  EXPECT_EQ(dropped_reply.service_status(),
            grpc_api::ROUTINE_SERVICE_STATUS_UNAVAILABLE);

  // Set cros_healthd as available again, and make sure the routine service can
  // get valid responses.
  diagnostics_service()->SetMojoServiceIsResponsive(true);
  constexpr uint32_t kExpectedId = 77;
  diagnostics_service()->SetRunSomeRoutineResponse(
      kExpectedId, mojo_ipc::DiagnosticRoutineStatusEnum::kRunning);

  const auto reconnected_reply =
      ExecuteRunRoutine(MakeSmartctlCheckRoutineRequest());
  EXPECT_EQ(reconnected_reply.uuid(), kExpectedId);
  EXPECT_EQ(reconnected_reply.status(), grpc_api::ROUTINE_STATUS_RUNNING);
  EXPECT_EQ(reconnected_reply.service_status(),
            grpc_api::ROUTINE_SERVICE_STATUS_OK);
}

// Tests for the GetRoutineUpdate() method of RoutineService when an
// interactive update is returned.
//
// This is a parameterized test with the following parameters:
// * |mojo_message| - mojo's DiagnosticRoutineUserMessageEnum returned in the
//                    routine's update.
// * |grpc_message| - gRPC's DiagnosticRoutineUserMessage expected to be
//                    returned by the routine service.
class GetInteractiveUpdateTest
    : public RoutineServiceTest,
      public testing::WithParamInterface<
          std::tuple<mojo_ipc::DiagnosticRoutineUserMessageEnum,
                     grpc_api::DiagnosticRoutineUserMessage>> {
 protected:
  // Accessors to individual test parameters from the test parameter tuple
  // returned by gtest's GetParam():

  mojo_ipc::DiagnosticRoutineUserMessageEnum mojo_message() const {
    return std::get<0>(GetParam());
  }

  grpc_api::DiagnosticRoutineUserMessage grpc_message() const {
    return std::get<1>(GetParam());
  }
};

// Test that after a routine has started, we can access its interactive data.
TEST_P(GetInteractiveUpdateTest, AccessInteractiveRunningRoutine) {
  constexpr uint32_t kExpectedProgressPercent = 17;
  constexpr char kExpectedOutput[] = "Expected output.";
  diagnostics_service()->SetInteractiveUpdate(
      mojo_message(), kExpectedProgressPercent, kExpectedOutput);

  const auto update_response = ExecuteGetRoutineUpdate(
      0 /* uuid */, grpc_api::GetRoutineUpdateRequest::GET_STATUS,
      true /* include_output */);
  EXPECT_EQ(update_response.user_message(), grpc_message());
  EXPECT_EQ(update_response.progress_percent(), kExpectedProgressPercent);
  EXPECT_EQ(update_response.output(), kExpectedOutput);
  EXPECT_EQ(update_response.service_status(),
            grpc_api::ROUTINE_SERVICE_STATUS_OK);
}

INSTANTIATE_TEST_SUITE_P(
    ,
    GetInteractiveUpdateTest,
    testing::Values(std::make_tuple(
        mojo_ipc::DiagnosticRoutineUserMessageEnum::kUnplugACPower,
        grpc_api::ROUTINE_USER_MESSAGE_UNPLUG_AC_POWER)));

// Tests for the GetRoutineUpdate() method of RoutineService when a
// noninteractive update is returned.
//
// This is a parameterized test with the following parameters:
// * |mojo_status| - mojo's DiagnosticRoutineStatusEnum returned in the
//                   routine's update.
// * |grpc_status| - gRPC's DiagnosticRoutineStatus expected to be
//                   returned by the routine service.
class GetNonInteractiveUpdateTest
    : public RoutineServiceTest,
      public testing::WithParamInterface<
          std::tuple<mojo_ipc::DiagnosticRoutineStatusEnum,
                     grpc_api::DiagnosticRoutineStatus>> {
 protected:
  // Accessors to individual test parameters from the test parameter tuple
  // returned by gtest's GetParam():

  mojo_ipc::DiagnosticRoutineStatusEnum mojo_status() const {
    return std::get<0>(GetParam());
  }

  grpc_api::DiagnosticRoutineStatus grpc_status() const {
    return std::get<1>(GetParam());
  }
};

// Test that after a routine has started, we can access its noninteractive data.
TEST_P(GetNonInteractiveUpdateTest, AccessNonInteractiveRunningRoutine) {
  constexpr char kExpectedStatusMessage[] = "Expected status message.";
  constexpr uint32_t kExpectedProgressPercent = 18;
  constexpr char kExpectedOutput[] = "Expected output.";
  diagnostics_service()->SetNonInteractiveUpdate(
      mojo_status(), kExpectedStatusMessage, kExpectedProgressPercent,
      kExpectedOutput);

  const auto update_response = ExecuteGetRoutineUpdate(
      0 /* uuid */, grpc_api::GetRoutineUpdateRequest::GET_STATUS,
      true /* include_output */);
  EXPECT_EQ(update_response.status(), grpc_status());
  EXPECT_EQ(update_response.status_message(), kExpectedStatusMessage);
  EXPECT_EQ(update_response.progress_percent(), kExpectedProgressPercent);
  EXPECT_EQ(update_response.output(), kExpectedOutput);
  EXPECT_EQ(update_response.service_status(),
            grpc_api::ROUTINE_SERVICE_STATUS_OK);
}

INSTANTIATE_TEST_SUITE_P(
    ,
    GetNonInteractiveUpdateTest,
    testing::Values(
        std::make_tuple(mojo_ipc::DiagnosticRoutineStatusEnum::kReady,
                        grpc_api::ROUTINE_STATUS_READY),
        std::make_tuple(mojo_ipc::DiagnosticRoutineStatusEnum::kRunning,
                        grpc_api::ROUTINE_STATUS_RUNNING),
        std::make_tuple(mojo_ipc::DiagnosticRoutineStatusEnum::kWaiting,
                        grpc_api::ROUTINE_STATUS_WAITING),
        std::make_tuple(mojo_ipc::DiagnosticRoutineStatusEnum::kPassed,
                        grpc_api::ROUTINE_STATUS_PASSED),
        std::make_tuple(mojo_ipc::DiagnosticRoutineStatusEnum::kFailed,
                        grpc_api::ROUTINE_STATUS_FAILED),
        std::make_tuple(mojo_ipc::DiagnosticRoutineStatusEnum::kError,
                        grpc_api::ROUTINE_STATUS_ERROR),
        std::make_tuple(mojo_ipc::DiagnosticRoutineStatusEnum::kCancelled,
                        grpc_api::ROUTINE_STATUS_CANCELLED),
        std::make_tuple(mojo_ipc::DiagnosticRoutineStatusEnum::kFailedToStart,
                        grpc_api::ROUTINE_STATUS_FAILED_TO_START),
        std::make_tuple(mojo_ipc::DiagnosticRoutineStatusEnum::kRemoved,
                        grpc_api::ROUTINE_STATUS_REMOVED),
        std::make_tuple(mojo_ipc::DiagnosticRoutineStatusEnum::kCancelling,
                        grpc_api::ROUTINE_STATUS_CANCELLING)));

// Tests for the GetRoutineUpdate() method of RoutineService with different
// commands.
//
// This is a parameterized test with the following parameters:
// * |command| - gRPC's GetRoutineUpdateRequest::Command included in the
//               GetRoutineUpdateRequest.
class GetRoutineUpdateCommandTest
    : public RoutineServiceTest,
      public testing::WithParamInterface<
          grpc_api::GetRoutineUpdateRequest::Command> {
 protected:
  // Accessors to the test parameter returned by gtest's GetParam():

  grpc_api::GetRoutineUpdateRequest::Command command() const {
    return GetParam();
  }
};

// Test that we can send the given command.
TEST_P(GetRoutineUpdateCommandTest, SendCommand) {
  constexpr char kExpectedStatusMessage[] = "Expected status message.";
  constexpr uint32_t kExpectedProgressPercent = 19;
  constexpr char kExpectedOutput[] = "Expected output.";
  constexpr mojo_ipc::DiagnosticRoutineStatusEnum kMojoStatus =
      mojo_ipc::DiagnosticRoutineStatusEnum::kRunning;
  constexpr grpc_api::DiagnosticRoutineStatus kExpectedStatus =
      grpc_api::ROUTINE_STATUS_RUNNING;
  diagnostics_service()->SetNonInteractiveUpdate(
      kMojoStatus, kExpectedStatusMessage, kExpectedProgressPercent,
      kExpectedOutput);

  const auto update_response = ExecuteGetRoutineUpdate(
      0 /* uuid */, command(), true /* include_output */);
  EXPECT_EQ(update_response.status(), kExpectedStatus);
  EXPECT_EQ(update_response.status_message(), kExpectedStatusMessage);
  EXPECT_EQ(update_response.progress_percent(), kExpectedProgressPercent);
  EXPECT_EQ(update_response.output(), kExpectedOutput);
  EXPECT_EQ(update_response.service_status(),
            grpc_api::ROUTINE_SERVICE_STATUS_OK);
}

INSTANTIATE_TEST_SUITE_P(
    ,
    GetRoutineUpdateCommandTest,
    testing::Values(grpc_api::GetRoutineUpdateRequest::RESUME,
                    grpc_api::GetRoutineUpdateRequest::CANCEL,
                    grpc_api::GetRoutineUpdateRequest::REMOVE,
                    grpc_api::GetRoutineUpdateRequest::GET_STATUS));

// Tests for the RunRoutine() method of RoutineService with different requests.
//
// This is a parameterized test with the following parameters:
// * |request| - gRPC's RunRoutineRequest to be requested.
class RunRoutineTest
    : public RoutineServiceTest,
      public testing::WithParamInterface<grpc_api::RunRoutineRequest> {
 public:
  RunRoutineTest() = default;
  RunRoutineTest(const RunRoutineTest&) = delete;
  RunRoutineTest& operator=(const RunRoutineTest&) = delete;

  // Accessors to the test parameter returned by gtest's GetParam():

  grpc_api::RunRoutineRequest request() const { return GetParam(); }
};

// Test that we can request that the given routine is run.
TEST_P(RunRoutineTest, RunRoutine) {
  constexpr uint32_t kExpectedId = 77;
  diagnostics_service()->SetRunSomeRoutineResponse(
      kExpectedId, mojo_ipc::DiagnosticRoutineStatusEnum::kRunning);

  const auto reply = ExecuteRunRoutine(request());
  EXPECT_EQ(reply.uuid(), kExpectedId);
  EXPECT_EQ(reply.status(), grpc_api::ROUTINE_STATUS_RUNNING);
  EXPECT_EQ(reply.service_status(), grpc_api::ROUTINE_SERVICE_STATUS_OK);
}

INSTANTIATE_TEST_SUITE_P(
    ,
    RunRoutineTest,
    testing::Values(MakeBatteryRoutineRequest(),
                    MakeDefaultBatteryRoutineRequest(),
                    MakeBatterySysfsRoutineRequest(),
                    MakeUrandomRoutineRequest(),
                    MakeSmartctlCheckRoutineRequest(),
                    MakeCpuCacheRoutineRequest(),
                    MakeCpuStressRoutineRequest(),
                    MakeFloatingPointAccuracyRoutineRequest(),
                    MakeNvmeWearLevelRoutineRequest(),
                    MakeNvmeSelfTestShortRoutineRequest(),
                    MakeNvmeSelfTestLongRoutineRequest(),
                    MakeDiskLinearReadRoutineRequest(),
                    MakeDiskRandomReadRoutineRequest()));

}  // namespace

}  // namespace diagnostics