chrome/browser/ash/system_logs/reven_log_source_unittest.cc

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

#include "chrome/browser/ash/system_logs/reven_log_source.h"

#include <optional>

#include "base/strings/strcat.h"
#include "base/strings/string_number_conversions.h"
#include "base/test/task_environment.h"
#include "base/time/time.h"
#include "chromeos/ash/components/mojo_service_manager/fake_mojo_service_manager.h"
#include "chromeos/ash/services/cros_healthd/public/cpp/fake_cros_healthd.h"
#include "chromeos/ash/services/cros_healthd/public/mojom/cros_healthd.mojom.h"
#include "chromeos/ash/services/cros_healthd/public/mojom/cros_healthd_probe.mojom-shared.h"
#include "chromeos/ash/services/cros_healthd/public/mojom/cros_healthd_probe.mojom.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace system_logs {

namespace {

namespace healthd = ::ash::cros_healthd::mojom;
using ::testing::HasSubstr;

constexpr char kRevenAvailableMemoryKey[] = "chromeosflex_available_memory";
constexpr char kRevenBiosVersionKey[] = "chromeosflex_bios_version";
constexpr char kRevenBluetoothDriverKey[] = "chromeosflex_bluetooth_driver";
constexpr char kRevenBluetoothIdKey[] = "chromeosflex_bluetooth_id";
constexpr char kRevenBluetoothNameKey[] = "chromeosflex_bluetooth_name";
constexpr char kRevenCpuNameKey[] = "chromeosflex_cpu_name";
constexpr char kRevenEthernetDriverKey[] = "chromeosflex_ethernet_driver";
constexpr char kRevenEthernetIdKey[] = "chromeosflex_ethernet_id";
constexpr char kRevenEthernetNameKey[] = "chromeosflex_ethernet_name";
constexpr char kRevenFreeMemoryKey[] = "chromeosflex_free_memory";
constexpr char kRevenGlExtensionsKey[] = "chromeosflex_gl_extensions";
constexpr char kRevenGlRendererKey[] = "chromeosflex_gl_renderer";
constexpr char kRevenGlShadingVersionKey[] = "chromeosflex_gl_shading_version";
constexpr char kRevenGlVendorKey[] = "chromeosflex_gl_vendor";
constexpr char kRevenGlVersionKey[] = "chromeosflex_gl_version";
constexpr char kRevenGpuDriverKey[] = "chromeosflex_gpu_driver";
constexpr char kRevenGpuIdKey[] = "chromeosflex_gpu_id";
constexpr char kRevenGpuNameKey[] = "chromeosflex_gpu_name";
constexpr char kRevenProductNameKey[] = "chromeosflex_product_name";
constexpr char kRevenProductVendorKey[] = "chromeosflex_product_vendor";
constexpr char kRevenProductVersionKey[] = "chromeosflex_product_version";
constexpr char kRevenSecurebootKey[] = "chromeosflex_secureboot";
constexpr char kRevenTotalMemoryKey[] = "chromeosflex_total_memory";
constexpr char kRevenTouchpadStack[] = "chromeosflex_touchpad";
constexpr char kRevenTpmAllowListedKey[] = "chromeosflex_tpm_allow_listed";
constexpr char kRevenTpmDidVidKey[] = "chromeosflex_tpm_did_vid";
constexpr char kRevenTpmManufacturerKey[] = "chromeosflex_tpm_manufacturer";
constexpr char kRevenTpmOwnedKey[] = "chromeosflex_tpm_owned";
constexpr char kRevenTpmSpecLevelKey[] = "chromeosflex_tpm_spec_level";
constexpr char kRevenTpmVersionKey[] = "chromeosflex_tpm_version";
constexpr char kRevenUefiKey[] = "chromeosflex_uefi";
constexpr char kRevenWirelessDriverKey[] = "chromeosflex_wireless_driver";
constexpr char kRevenWirelessIdKey[] = "chromeosflex_wireless_id";
constexpr char kRevenWirelessNameKey[] = "chromeosflex_wireless_name";

constexpr char kCpuNameVal[] = "Intel(R) Core(TM) i5-10210U CPU @ 1.60GHz";

constexpr int kTotalMemory = 2048;
constexpr int kFreeMemory = 1024;
constexpr int kAvailableMemory = 512;

void SetCpuInfo(healthd::TelemetryInfoPtr& telemetry_info) {
  auto cpu_info = healthd::CpuInfo::New();
  auto physical_cpu_info = healthd::PhysicalCpuInfo::New();
  auto logical_cpu_info = healthd::LogicalCpuInfo::New();
  physical_cpu_info->logical_cpus.push_back(std::move(logical_cpu_info));
  physical_cpu_info->model_name = kCpuNameVal;
  cpu_info->num_total_threads = 2;
  cpu_info->physical_cpus.emplace_back(std::move(physical_cpu_info));

  telemetry_info->cpu_result =
      healthd::CpuResult::NewCpuInfo(std::move(cpu_info));
}

void SetCpuInfoWithProbeError(healthd::TelemetryInfoPtr& telemetry_info) {
  auto probe_error =
      healthd::ProbeError::New(healthd::ErrorType::kFileReadError, "");
  telemetry_info->cpu_result =
      healthd::CpuResult::NewError(std::move(probe_error));
}

void SetMemoryInfo(healthd::TelemetryInfoPtr& telemetry_info) {
  auto memory_info =
      healthd::MemoryInfo::New(kTotalMemory, kFreeMemory, kAvailableMemory, 0);
  telemetry_info->memory_result =
      healthd::MemoryResult::NewMemoryInfo(std::move(memory_info));
}

void SetMemoryInfoWithProbeError(healthd::TelemetryInfoPtr& telemetry_info) {
  auto probe_error =
      healthd::ProbeError::New(healthd::ErrorType::kFileReadError, "");
  telemetry_info->memory_result =
      healthd::MemoryResult::NewError(std::move(probe_error));
}

void SetSystemInfo(healthd::TelemetryInfoPtr& telemetry_info,
                   healthd::OsInfoPtr os_info,
                   healthd::DmiInfoPtr dmi_info) {
  auto system_info = healthd::SystemInfo::New();
  if (os_info) {
    system_info->os_info = std::move(os_info);
  }

  if (dmi_info) {
    system_info->dmi_info = std::move(dmi_info);
  }
  telemetry_info->system_result =
      healthd::SystemResult::NewSystemInfo(std::move(system_info));
}

healthd::OsInfoPtr CreateOsInfo(healthd::BootMode boot_mode) {
  healthd::OsInfoPtr os_info = healthd::OsInfo::New();
  os_info->os_version = healthd::OsVersion::New();
  os_info->boot_mode = boot_mode;
  return os_info;
}

healthd::DmiInfoPtr CreateDmiInfo() {
  healthd::DmiInfoPtr dmi_info = healthd::DmiInfo::New();
  dmi_info->sys_vendor = std::optional<std::string>("LENOVO");
  dmi_info->product_name = std::optional<std::string>("20U9001PUS");
  dmi_info->product_version =
      std::optional<std::string>("ThinkPad X1 Carbon Gen 8");
  dmi_info->bios_version = std::optional<std::string>("N2WET26W (1.16 )");
  return dmi_info;
}

healthd::BusDevicePtr CreatePciDevice(healthd::BusDeviceClass device_class,
                                      const std::string& vendor_name,
                                      const std::string& product_name,
                                      const std::string& driver,
                                      uint16_t vendor_id,
                                      uint16_t device_id) {
  auto device = healthd::BusDevice::New();
  device->device_class = device_class;
  device->vendor_name = vendor_name;
  device->product_name = product_name;

  auto pci_info = healthd::PciBusInfo::New();
  pci_info->vendor_id = vendor_id;
  pci_info->device_id = device_id;
  if (driver != "") {
    pci_info->driver = std::optional<std::string>(driver);
  }

  device->bus_info = healthd::BusInfo::NewPciBusInfo(std::move(pci_info));
  return device;
}

void SetPciEthernetDevices(healthd::TelemetryInfoPtr& telemetry_info) {
  std::vector<healthd::BusDevicePtr> bus_devices;
  bus_devices.push_back(
      CreatePciDevice(healthd::BusDeviceClass::kEthernetController, "intel",
                      "product1", "driver1", 0x12ab, 0x34cd));
  bus_devices.push_back(
      CreatePciDevice(healthd::BusDeviceClass::kEthernetController, "broadcom",
                      "product2", "", 0x56ab, 0x78cd));

  telemetry_info->bus_result =
      healthd::BusResult::NewBusDevices(std::move(bus_devices));
}

void SetPciWirelessDevices(healthd::TelemetryInfoPtr& telemetry_info) {
  std::vector<healthd::BusDevicePtr> bus_devices;
  bus_devices.push_back(
      CreatePciDevice(healthd::BusDeviceClass::kWirelessController, "intel",
                      "wireless_product1", "wireless_driver1", 0x12ab, 0x34cd));
  bus_devices.push_back(
      CreatePciDevice(healthd::BusDeviceClass::kWirelessController, "broadcom",
                      "wireless_product2", "", 0x56ab, 0x78cd));

  telemetry_info->bus_result =
      healthd::BusResult::NewBusDevices(std::move(bus_devices));
}

void SetPciBluetoothDevices(healthd::TelemetryInfoPtr& telemetry_info) {
  std::vector<healthd::BusDevicePtr> bus_devices;
  bus_devices.push_back(CreatePciDevice(
      healthd::BusDeviceClass::kBluetoothAdapter, "intel", "bluetooth_product1",
      "bluetooth_driver1", 0x12ab, 0x34cd));
  bus_devices.push_back(
      CreatePciDevice(healthd::BusDeviceClass::kBluetoothAdapter, "broadcom",
                      "bluetooth_product2", "", 0x56ab, 0x78cd));

  telemetry_info->bus_result =
      healthd::BusResult::NewBusDevices(std::move(bus_devices));
}

void SetPciDisplayDevices(healthd::TelemetryInfoPtr& telemetry_info) {
  std::vector<healthd::BusDevicePtr> bus_devices;
  bus_devices.push_back(
      CreatePciDevice(healthd::BusDeviceClass::kDisplayController, "intel",
                      "945GM", "driver1", 0x12ab, 0x34cd));

  telemetry_info->bus_result =
      healthd::BusResult::NewBusDevices(std::move(bus_devices));
}

healthd::BusDevicePtr CreateUsbDevice(healthd::BusDeviceClass device_class,
                                      const std::string& vendor_name,
                                      const std::string& product_name,
                                      const std::string& driver,
                                      uint16_t vendor_id,
                                      uint16_t product_id) {
  auto device = healthd::BusDevice::New();
  device->device_class = device_class;
  device->vendor_name = vendor_name;
  device->product_name = product_name;

  auto usb_info = healthd::UsbBusInfo::New();
  usb_info->vendor_id = vendor_id;
  usb_info->product_id = product_id;
  auto usb_if_info = healthd::UsbBusInterfaceInfo::New();
  if (driver != "") {
    usb_if_info->driver = std::optional<std::string>(driver);
  }
  usb_info->interfaces.push_back(std::move(usb_if_info));

  device->bus_info = healthd::BusInfo::NewUsbBusInfo(std::move(usb_info));
  return device;
}

void SetUsbEthernetDevices(healthd::TelemetryInfoPtr& telemetry_info) {
  std::vector<healthd::BusDevicePtr> bus_devices;
  bus_devices.push_back(
      CreateUsbDevice(healthd::BusDeviceClass::kEthernetController, "intel",
                      "product1", "driver1", 0x12ab, 0x34cd));
  bus_devices.push_back(
      CreateUsbDevice(healthd::BusDeviceClass::kEthernetController, "broadcom",
                      "product2", "", 0x56ab, 0x78cd));

  telemetry_info->bus_result =
      healthd::BusResult::NewBusDevices(std::move(bus_devices));
}

void SetUsbWirelessDevices(healthd::TelemetryInfoPtr& telemetry_info) {
  std::vector<healthd::BusDevicePtr> bus_devices;
  bus_devices.push_back(
      CreateUsbDevice(healthd::BusDeviceClass::kWirelessController, "intel",
                      "wireless_product1", "wireless_driver1", 0x12ab, 0x34cd));
  bus_devices.push_back(
      CreateUsbDevice(healthd::BusDeviceClass::kWirelessController, "broadcom",
                      "wireless_product2", "", 0x56ab, 0x78cd));

  telemetry_info->bus_result =
      healthd::BusResult::NewBusDevices(std::move(bus_devices));
}

void SetUsbBluetoothDevices(healthd::TelemetryInfoPtr& telemetry_info) {
  std::vector<healthd::BusDevicePtr> bus_devices;
  bus_devices.push_back(CreateUsbDevice(
      healthd::BusDeviceClass::kBluetoothAdapter, "intel", "bluetooth_product1",
      "bluetooth_driver1", 0x12ab, 0x34cd));
  bus_devices.push_back(
      CreateUsbDevice(healthd::BusDeviceClass::kBluetoothAdapter, "broadcom",
                      "bluetooth_product2", "", 0x56ab, 0x78cd));

  telemetry_info->bus_result =
      healthd::BusResult::NewBusDevices(std::move(bus_devices));
}

void SetUsbDisplayDevices(healthd::TelemetryInfoPtr& telemetry_info) {
  std::vector<healthd::BusDevicePtr> bus_devices;
  bus_devices.push_back(
      CreateUsbDevice(healthd::BusDeviceClass::kDisplayController, "intel",
                      "product1", "driver1", 0x12ab, 0x34cd));
  telemetry_info->bus_result =
      healthd::BusResult::NewBusDevices(std::move(bus_devices));
}

void SetTpmInfo(healthd::TelemetryInfoPtr& telemetry_info,
                const std::string& did_vid,
                uint32_t family,
                bool is_owned,
                bool is_allowed) {
  auto version = healthd::TpmVersion::New();
  version->family = family;
  version->manufacturer = 1129467731;
  version->spec_level = 116;

  auto status = healthd::TpmStatus::New();
  status->owned = is_owned;

  auto dictionary_attack = healthd::TpmDictionaryAttack::New();
  auto attestation = healthd::TpmAttestation::New();

  auto supported_features = healthd::TpmSupportedFeatures::New();
  supported_features->is_allowed = is_allowed;

  healthd::TpmInfoPtr tpm_info = healthd::TpmInfo::New();
  if (did_vid != "") {
    tpm_info->did_vid = std::optional<std::string>(did_vid);
  }

  tpm_info->version = std::move(version);
  tpm_info->status = std::move(status);
  tpm_info->dictionary_attack = std::move(dictionary_attack);
  tpm_info->attestation = std::move(attestation);
  tpm_info->supported_features = std::move(supported_features);

  telemetry_info->tpm_result =
      healthd::TpmResult::NewTpmInfo(std::move(tpm_info));
}

void SetGraphicsInfo(healthd::TelemetryInfoPtr& telemetry_info,
                     std::vector<std::string>& gl_extensions) {
  auto gles_info = healthd::GLESInfo::New();
  gles_info->version = "fake_version";
  gles_info->shading_version = "fake_shading_version";
  gles_info->vendor = "fake_vendor";
  gles_info->renderer = "fake_renderer";
  gles_info->extensions = gl_extensions;

  healthd::GraphicsInfoPtr graphics_info = healthd::GraphicsInfo::New();
  graphics_info->gles_info = std::move(gles_info);

  auto egl_info = healthd::EGLInfo::New();
  graphics_info->egl_info = std::move(egl_info);

  telemetry_info->graphics_result =
      healthd::GraphicsResult::NewGraphicsInfo(std::move(graphics_info));
}

}  // namespace

class RevenLogSourceTest : public ::testing::Test {
 public:
  RevenLogSourceTest() {
    ash::cros_healthd::FakeCrosHealthd::Initialize();
    source_ = std::make_unique<RevenLogSource>();
  }

  ~RevenLogSourceTest() override {
    source_.reset();
    ash::cros_healthd::FakeCrosHealthd::Shutdown();
    base::RunLoop().RunUntilIdle();
  }

  std::unique_ptr<SystemLogsResponse> Fetch() {
    std::unique_ptr<SystemLogsResponse> result;
    base::RunLoop run_loop;
    source_->Fetch(base::BindOnce(
        [](std::unique_ptr<SystemLogsResponse>* result,
           base::OnceClosure quit_closure,
           std::unique_ptr<SystemLogsResponse> response) {
          *result = std::move(response);
          std::move(quit_closure).Run();
        },
        &result, run_loop.QuitClosure()));
    run_loop.Run();

    return result;
  }

  void SetBootModeInfo(healthd::BootMode boot_mode) {
    auto info = healthd::TelemetryInfo::New();
    auto os_info = CreateOsInfo(boot_mode);
    auto dmi_info = CreateDmiInfo();
    SetSystemInfo(info, std::move(os_info), std::move(dmi_info));
    ash::cros_healthd::FakeCrosHealthd::Get()
        ->SetProbeTelemetryInfoResponseForTesting(info);
  }

  void VerifyOutputContains(const std::unique_ptr<SystemLogsResponse>& response,
                            const std::string& key,
                            const std::string& expected_output) {
    ASSERT_NE(response, nullptr);
    const auto response_iter = response->find(key);
    ASSERT_NE(response_iter, response->end());
    EXPECT_THAT(response_iter->second, HasSubstr(expected_output));
  }

 protected:
  base::test::TaskEnvironment task_environment_{
      base::test::TaskEnvironment::TimeSource::MOCK_TIME};
  ::ash::mojo_service_manager::FakeMojoServiceManager fake_service_manager_;
  std::unique_ptr<RevenLogSource> source_;
};

TEST_F(RevenLogSourceTest, FetchCpuInfoSuccess) {
  auto info = healthd::TelemetryInfo::New();
  SetCpuInfo(info);
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenCpuNameKey,
                       "Intel(R) Core(TM) i5-10210U CPU @ 1.60GHz");
}

TEST_F(RevenLogSourceTest, FetchCpuInfoFailure) {
  auto info = healthd::TelemetryInfo::New();
  SetCpuInfoWithProbeError(info);
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  VerifyOutputContains(Fetch(), kRevenCpuNameKey, "<not available>");
}

TEST_F(RevenLogSourceTest, FetchMemoryInfoSuccess) {
  auto info = healthd::TelemetryInfo::New();
  SetMemoryInfo(info);
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenTotalMemoryKey, "2048");
  VerifyOutputContains(response, kRevenFreeMemoryKey, "1024");
  VerifyOutputContains(response, kRevenAvailableMemoryKey, "512");
}

TEST_F(RevenLogSourceTest, FetchMemoryInfoFailure) {
  auto info = healthd::TelemetryInfo::New();
  SetMemoryInfoWithProbeError(info);
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  const std::string not_available = "<not available>";
  VerifyOutputContains(response, kRevenTotalMemoryKey, not_available);
  VerifyOutputContains(response, kRevenFreeMemoryKey, not_available);
  VerifyOutputContains(response, kRevenAvailableMemoryKey, not_available);
}

TEST_F(RevenLogSourceTest, FetchDmiInfoWithValues) {
  auto info = healthd::TelemetryInfo::New();
  auto os_info = CreateOsInfo(healthd::BootMode::kUnknown);
  auto dmi_info = CreateDmiInfo();
  SetSystemInfo(info, std::move(os_info), std::move(dmi_info));
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenProductVendorKey, "LENOVO");
  VerifyOutputContains(response, kRevenProductNameKey, "20U9001PUS");
  VerifyOutputContains(response, kRevenProductVersionKey,
                       "ThinkPad X1 Carbon Gen 8");
  VerifyOutputContains(response, kRevenBiosVersionKey, "N2WET26W (1.16 )");
}

TEST_F(RevenLogSourceTest, FetchDmiInfoWithoutValues) {
  auto info = healthd::TelemetryInfo::New();
  auto os_info = CreateOsInfo(healthd::BootMode::kCrosEfi);
  auto dmi_info = healthd::DmiInfo::New();
  SetSystemInfo(info, std::move(os_info), std::move(dmi_info));
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  const std::string not_available = "<not available>";
  VerifyOutputContains(response, kRevenProductVendorKey, not_available);
  VerifyOutputContains(response, kRevenProductNameKey, not_available);
  VerifyOutputContains(response, kRevenProductVersionKey, not_available);
  VerifyOutputContains(response, kRevenBiosVersionKey, not_available);
}

// BootMode::kCrosEfi: boot with EFI but not with secure boot.
TEST_F(RevenLogSourceTest, BiosBootMode_Uefi_True_SecureBoot_False) {
  SetBootModeInfo(healthd::BootMode::kCrosEfi);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenSecurebootKey, "false");
  VerifyOutputContains(response, kRevenUefiKey, "true");
}

// BootMode::kCrosEfiSecure: boot with EFI security boot.
TEST_F(RevenLogSourceTest, BiosBootMode_Uefi_True_SecureBoot_True) {
  SetBootModeInfo(healthd::BootMode::kCrosEfiSecure);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenSecurebootKey, "true");
  VerifyOutputContains(response, kRevenUefiKey, "true");
}

// BootMode::kCrosSecure: Chromebook/box firmware.
TEST_F(RevenLogSourceTest, BiosBootMode_CrosSecure) {
  SetBootModeInfo(healthd::BootMode::kCrosSecure);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenSecurebootKey, "false");
  VerifyOutputContains(response, kRevenUefiKey, "false");
}

// BootMode::kCrosLegacy: Old BIOS firmware, or UEFI in "compatibility mode".
TEST_F(RevenLogSourceTest, BiosBootMode_CrosLegacy) {
  SetBootModeInfo(healthd::BootMode::kCrosLegacy);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenSecurebootKey, "false");
  VerifyOutputContains(response, kRevenUefiKey, "false");
}

// BootMode::kUnknown: An issue with detection.
TEST_F(RevenLogSourceTest, BiosBootMode_Unknown) {
  SetBootModeInfo(healthd::BootMode::kUnknown);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenSecurebootKey, "false");
  VerifyOutputContains(response, kRevenUefiKey, "false");
}

TEST_F(RevenLogSourceTest, PciEthernetDevices) {
  auto info = healthd::TelemetryInfo::New();
  SetPciEthernetDevices(info);
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenEthernetNameKey, "intel product1");
  VerifyOutputContains(response, kRevenEthernetNameKey, "broadcom product2");
  VerifyOutputContains(response, kRevenEthernetIdKey, "pci:12ab:34cd");
  VerifyOutputContains(response, kRevenEthernetIdKey, "pci:56ab:78cd");
  VerifyOutputContains(response, kRevenEthernetDriverKey, "driver1");
}

TEST_F(RevenLogSourceTest, PciBluetoothDevices) {
  auto info = healthd::TelemetryInfo::New();
  SetPciBluetoothDevices(info);
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenBluetoothNameKey,
                       "intel bluetooth_product1");
  VerifyOutputContains(response, kRevenBluetoothNameKey,
                       "broadcom bluetooth_product2");
  VerifyOutputContains(response, kRevenBluetoothIdKey, "pci:12ab:34cd");
  VerifyOutputContains(response, kRevenBluetoothIdKey, "pci:56ab:78cd");
  VerifyOutputContains(response, kRevenBluetoothDriverKey, "bluetooth_driver1");
}

TEST_F(RevenLogSourceTest, PciWirelessDevices) {
  auto info = healthd::TelemetryInfo::New();
  SetPciWirelessDevices(info);
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenWirelessNameKey,
                       "intel wireless_product1");
  VerifyOutputContains(response, kRevenWirelessNameKey,
                       "broadcom wireless_product2");
  VerifyOutputContains(response, kRevenWirelessIdKey, "pci:12ab:34cd");
  VerifyOutputContains(response, kRevenWirelessIdKey, "pci:56ab:78cd");
  VerifyOutputContains(response, kRevenWirelessDriverKey, "wireless_driver1");
}

TEST_F(RevenLogSourceTest, PciGpuInfo) {
  auto info = healthd::TelemetryInfo::New();
  SetPciDisplayDevices(info);
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenGpuNameKey, "intel 945GM");
  VerifyOutputContains(response, kRevenGpuIdKey, "pci:12ab:34cd");
  VerifyOutputContains(response, kRevenGpuDriverKey, "driver1");
}

TEST_F(RevenLogSourceTest, UsbEthernetDevices) {
  auto info = healthd::TelemetryInfo::New();
  SetUsbEthernetDevices(info);
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenEthernetNameKey, "intel product1");
  VerifyOutputContains(response, kRevenEthernetNameKey, "broadcom product2");
  VerifyOutputContains(response, kRevenEthernetIdKey, "usb:12ab:34cd");
  VerifyOutputContains(response, kRevenEthernetIdKey, "usb:56ab:78cd");
  VerifyOutputContains(response, kRevenEthernetDriverKey, "driver1");
}

TEST_F(RevenLogSourceTest, UsbBluetoothDevices) {
  auto info = healthd::TelemetryInfo::New();
  SetUsbBluetoothDevices(info);
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenBluetoothNameKey,
                       "intel bluetooth_product1");
  VerifyOutputContains(response, kRevenBluetoothNameKey,
                       "broadcom bluetooth_product2");
  VerifyOutputContains(response, kRevenBluetoothIdKey, "usb:12ab:34cd");
  VerifyOutputContains(response, kRevenBluetoothIdKey, "usb:56ab:78cd");
  VerifyOutputContains(response, kRevenBluetoothDriverKey, "bluetooth_driver1");
}

TEST_F(RevenLogSourceTest, UsbWirelessDevices) {
  auto info = healthd::TelemetryInfo::New();
  SetUsbWirelessDevices(info);
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenWirelessNameKey,
                       "intel wireless_product1");
  VerifyOutputContains(response, kRevenWirelessNameKey,
                       "broadcom wireless_product2");
  VerifyOutputContains(response, kRevenWirelessIdKey, "usb:12ab:34cd");
  VerifyOutputContains(response, kRevenWirelessIdKey, "usb:56ab:78cd");
  VerifyOutputContains(response, kRevenWirelessDriverKey, "wireless_driver1");
}

TEST_F(RevenLogSourceTest, UsbGpuInfo) {
  auto info = healthd::TelemetryInfo::New();
  SetUsbDisplayDevices(info);
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenGpuNameKey, "intel product1");
  VerifyOutputContains(response, kRevenGpuIdKey, "usb:12ab:34cd");
  VerifyOutputContains(response, kRevenGpuDriverKey, "driver1");
}

TEST_F(RevenLogSourceTest, TpmInfoVersion_1_2WithDidVid_Owned_Allowed) {
  const uint32_t version = 0x312e3200;  // TPM 1.2
  const std::string did_vid = "286536196";
  const bool is_owned = true;
  const bool is_allowed = true;

  auto info = healthd::TelemetryInfo::New();
  SetTpmInfo(info, did_vid, version, is_owned, is_allowed);
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenTpmVersionKey, "1.2");
  VerifyOutputContains(response, kRevenTpmSpecLevelKey, "116");
  VerifyOutputContains(response, kRevenTpmManufacturerKey, "1129467731");
  VerifyOutputContains(response, kRevenTpmDidVidKey, "286536196");
  VerifyOutputContains(response, kRevenTpmOwnedKey, "true");
  VerifyOutputContains(response, kRevenTpmAllowListedKey, "true");
}

TEST_F(RevenLogSourceTest, TpmInfoVersion_2_0WithoutDidVid_Owned_NotAllowed) {
  const uint32_t version = 0x322e3000;  // TPM 2.0
  const std::string did_vid = "";
  const bool is_owned = true;
  const bool is_allowed = false;

  auto info = healthd::TelemetryInfo::New();
  SetTpmInfo(info, did_vid, version, is_owned, is_allowed);
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenTpmVersionKey, "2.0");
  VerifyOutputContains(response, kRevenTpmSpecLevelKey, "116");
  VerifyOutputContains(response, kRevenTpmManufacturerKey, "1129467731");
  VerifyOutputContains(response, kRevenTpmDidVidKey, "");
  VerifyOutputContains(response, kRevenTpmOwnedKey, "true");
  VerifyOutputContains(response, kRevenTpmAllowListedKey, "false");
}

TEST_F(RevenLogSourceTest,
       TpmInfoVersionUnknownWithoutDidVid_Allowed_NotOwned) {
  const uint32_t version = 0xaaaaaaaa;
  const std::string did_vid = "";
  const bool is_owned = false;
  const bool is_allowed = true;

  auto info = healthd::TelemetryInfo::New();
  SetTpmInfo(info, did_vid, version, is_owned, is_allowed);
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenTpmVersionKey, "unknown");
  VerifyOutputContains(response, kRevenTpmSpecLevelKey, "116");
  VerifyOutputContains(response, kRevenTpmManufacturerKey, "1129467731");
  VerifyOutputContains(response, kRevenTpmDidVidKey, "");
  VerifyOutputContains(response, kRevenTpmOwnedKey, "false");
  VerifyOutputContains(response, kRevenTpmAllowListedKey, "true");
}

TEST_F(RevenLogSourceTest,
       TpmInfoVersionUnknownWithoutDidVid_NotAllowed_NotOwned) {
  const uint32_t version = 0xaaaaaaaa;
  const std::string did_vid = "";
  const bool is_owned = false;
  const bool is_allowed = false;

  auto info = healthd::TelemetryInfo::New();
  SetTpmInfo(info, did_vid, version, is_owned, is_allowed);
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenTpmVersionKey, "unknown");
  VerifyOutputContains(response, kRevenTpmSpecLevelKey, "116");
  VerifyOutputContains(response, kRevenTpmManufacturerKey, "1129467731");
  VerifyOutputContains(response, kRevenTpmDidVidKey, "");
  VerifyOutputContains(response, kRevenTpmOwnedKey, "false");
  VerifyOutputContains(response, kRevenTpmAllowListedKey, "false");
}

TEST_F(RevenLogSourceTest, GraphicsInfoNoExtensions) {
  auto info = healthd::TelemetryInfo::New();
  std::vector<std::string> extensions;
  SetGraphicsInfo(info, extensions);
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenGlVersionKey, "fake_version");
  VerifyOutputContains(response, kRevenGlShadingVersionKey,
                       "fake_shading_version");
  VerifyOutputContains(response, kRevenGlVendorKey, "fake_vendor");
  VerifyOutputContains(response, kRevenGlRendererKey, "fake_renderer");
  VerifyOutputContains(response, kRevenGlExtensionsKey, "");
}

TEST_F(RevenLogSourceTest, GraphicsInfoOneExtension) {
  auto info = healthd::TelemetryInfo::New();
  std::vector<std::string> extensions{"ext1"};
  SetGraphicsInfo(info, extensions);
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenGlVersionKey, "fake_version");
  VerifyOutputContains(response, kRevenGlShadingVersionKey,
                       "fake_shading_version");
  VerifyOutputContains(response, kRevenGlVendorKey, "fake_vendor");
  VerifyOutputContains(response, kRevenGlRendererKey, "fake_renderer");
  VerifyOutputContains(response, kRevenGlExtensionsKey, "ext1");
}

TEST_F(RevenLogSourceTest, GraphicsInfoTwoExtensions) {
  auto info = healthd::TelemetryInfo::New();
  std::vector<std::string> extensions{"ext1", "ext2"};
  SetGraphicsInfo(info, extensions);
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  VerifyOutputContains(response, kRevenGlVersionKey, "fake_version");
  VerifyOutputContains(response, kRevenGlShadingVersionKey,
                       "fake_shading_version");
  VerifyOutputContains(response, kRevenGlVendorKey, "fake_vendor");
  VerifyOutputContains(response, kRevenGlRendererKey, "fake_renderer");
  VerifyOutputContains(response, kRevenGlExtensionsKey, "ext1, ext2");
}

TEST_F(RevenLogSourceTest, TouchpadStack) {
  auto info = healthd::TelemetryInfo::New();
  ash::cros_healthd::FakeCrosHealthd::Get()
      ->SetProbeTelemetryInfoResponseForTesting(info);

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  ASSERT_NE(response, nullptr);
  const auto response_iter = response->find(kRevenTouchpadStack);
  ASSERT_NE(response_iter, response->end());

  EXPECT_THAT(response_iter->second,
              AnyOf(HasSubstr("libinput"), HasSubstr("gestures"),
                    HasSubstr("Default EventConverterEvdev")));
}

TEST_F(RevenLogSourceTest, NothingAvailable) {
  auto info = healthd::TelemetryInfo::New();

  const std::unique_ptr<SystemLogsResponse> response = Fetch();
  const std::string not_available = "<not available>";
  VerifyOutputContains(response, kRevenProductVendorKey, not_available);
  VerifyOutputContains(response, kRevenProductNameKey, not_available);
  VerifyOutputContains(response, kRevenProductVersionKey, not_available);
  VerifyOutputContains(response, kRevenBiosVersionKey, not_available);
  VerifyOutputContains(response, kRevenEthernetNameKey, not_available);
  VerifyOutputContains(response, kRevenEthernetIdKey, not_available);
  VerifyOutputContains(response, kRevenEthernetDriverKey, not_available);
  VerifyOutputContains(response, kRevenWirelessNameKey, not_available);
  VerifyOutputContains(response, kRevenWirelessIdKey, not_available);
  VerifyOutputContains(response, kRevenWirelessDriverKey, not_available);
  VerifyOutputContains(response, kRevenBluetoothNameKey, not_available);
  VerifyOutputContains(response, kRevenBluetoothIdKey, not_available);
  VerifyOutputContains(response, kRevenBluetoothDriverKey, not_available);
  VerifyOutputContains(response, kRevenGpuNameKey, not_available);
  VerifyOutputContains(response, kRevenGpuIdKey, not_available);
  VerifyOutputContains(response, kRevenGpuDriverKey, not_available);
  VerifyOutputContains(response, kRevenCpuNameKey, not_available);
  VerifyOutputContains(response, kRevenTotalMemoryKey, not_available);
  VerifyOutputContains(response, kRevenFreeMemoryKey, not_available);
  VerifyOutputContains(response, kRevenAvailableMemoryKey, not_available);
  VerifyOutputContains(response, kRevenSecurebootKey, not_available);
  VerifyOutputContains(response, kRevenUefiKey, not_available);
  VerifyOutputContains(response, kRevenTpmVersionKey, not_available);
  VerifyOutputContains(response, kRevenTpmSpecLevelKey, not_available);
  VerifyOutputContains(response, kRevenTpmManufacturerKey, not_available);
  VerifyOutputContains(response, kRevenTpmDidVidKey, not_available);
  VerifyOutputContains(response, kRevenTpmAllowListedKey, not_available);
  VerifyOutputContains(response, kRevenTpmOwnedKey, not_available);
  VerifyOutputContains(response, kRevenGlVersionKey, not_available);
  VerifyOutputContains(response, kRevenGlShadingVersionKey, not_available);
  VerifyOutputContains(response, kRevenGlVendorKey, not_available);
  VerifyOutputContains(response, kRevenGlRendererKey, not_available);
  VerifyOutputContains(response, kRevenGlExtensionsKey, not_available);
  // Touchpad stack is always set to something.
  VerifyOutputContains(response, kRevenTouchpadStack, "");
  // To remind folks to add all new keys here, also check total number of keys.
  uint16_t expected_num_keys = 34;
  EXPECT_THAT(response->size(), expected_num_keys);
}

}  // namespace system_logs