rmad/metrics/metrics_utils_test.cc

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

#include "rmad/metrics/metrics_utils.h"
#include "rmad/metrics/metrics_utils_impl.h"
#include "rmad/metrics/mock_metrics_utils.h"

#include <map>
#include <memory>
#include <vector>

#include <base/files/file_util.h>
#include <base/files/scoped_temp_dir.h>
#include <base/memory/scoped_refptr.h>
#include <base/time/time.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include "rmad/constants.h"
#include "rmad/metrics/metrics_constants.h"
#include "rmad/metrics/state_metrics.h"
#include "rmad/utils/json_store.h"

using testing::_;
using testing::Return;

namespace {

constexpr char kTestJsonStoreFilename[] = "test.json";
constexpr char kDefaultMetricsJson[] = R"(
{
  "metrics": {
    "first_setup_timestamp": 123.456,
    "setup_timestamp": 456.789,
    "running_time": 333.333,
    "ro_firmware_verified": true,
    "replaced_component_names": [],
    "occurred_errors": ["RMAD_ERROR_MISSING_COMPONENT"],
    "additional_activities": ["RMAD_ADDITIONAL_ACTIVITY_REBOOT"],
    "state_metrics": {
      "1": {
        "state_case": 1,
        "state_is_aborted": false,
        "state_setup_timestamp": 0.0,
        "state_overall_time": 123.456,
        "state_transition_count": 2,
        "state_get_log_count": 3,
        "state_save_log_count": 4
      },
      "2": {
        "state_case": 2,
        "state_is_aborted": true,
        "state_setup_timestamp": 123.456,
        "state_overall_time": 332.544,
        "state_transition_count": 1,
        "state_get_log_count": 0,
        "state_save_log_count": 0
      }
    }
  }
}
)";
constexpr char kEmptyMetricsJson[] = "{}";
// This is the exact json string to match. DO NOT format it.
constexpr char kDefaultMetricsSummaryJson[] = R"({
   "additional_activities": [ "RMAD_ADDITIONAL_ACTIVITY_REBOOT" ],
   "occurred_errors": [ "RMAD_ERROR_MISSING_COMPONENT" ],
   "replaced_component_names": [  ],
   "ro_firmware_verified": true,
   "running_time": 333.333,
   "state_metrics": {
      "ComponentsRepair": {
         "state_case": 2,
         "state_get_log_count": 0,
         "state_is_aborted": true,
         "state_overall_time": 332.544,
         "state_save_log_count": 0,
         "state_transition_count": 1
      },
      "Welcome": {
         "state_case": 1,
         "state_get_log_count": 3,
         "state_is_aborted": false,
         "state_overall_time": 123.456,
         "state_save_log_count": 4,
         "state_transition_count": 2
      }
   }
}
)";

constexpr char kInvalidStateMetricsTimestampJson[] = R"(
{
  "metrics": {
    "state_metrics": {
      "1": {
        "state_case": 1,
        "state_is_aborted": false,
        "state_setup_timestamp": -1,
        "state_overall_time": 123.456,
        "state_transition_count": 2,
        "state_get_log_count": 3,
        "state_save_log_count": 4
      }
    }
  }
}
)";

constexpr double kDefaultFirstSetupTimestamp = 123.456;
constexpr double kDefaultSetupTimestamp = 456.789;
constexpr double kDefaultRunningTime = 333.333;
constexpr bool kDefaultRoFirmwareVerified = true;
const std::vector<std::string> kDefaultOccurredErrors = {
    "RMAD_ERROR_MISSING_COMPONENT"};
const std::vector<std::string> kDefaultAdditionalActivities = {
    "RMAD_ADDITIONAL_ACTIVITY_REBOOT"};
const std::map<int, rmad::StateMetricsData> kDefaultStateMetrics = {
    {1,
     {.state_case = rmad::RmadState::StateCase::kWelcome,
      .is_aborted = false,
      .setup_timestamp = 0.0,
      .overall_time = 123.456,
      .transition_count = 2,
      .get_log_count = 3,
      .save_log_count = 4}},
    {2,
     {.state_case = rmad::RmadState::StateCase::kComponentsRepair,
      .is_aborted = true,
      .setup_timestamp = 123.456,
      .overall_time = 332.544,
      .transition_count = 1,
      .get_log_count = 0,
      .save_log_count = 0}}};

constexpr double kTestFirstSetupTimestamp = 111.111;
constexpr double kTestSetupTimestamp = 666.666;
constexpr double kTestRunningTime = 555.555;
constexpr bool kTestRoFirmwareVerified = false;
const std::vector<std::string> kTestOccurredErrors = {
    "RMAD_ERROR_RMA_NOT_REQUIRED", "RMAD_ERROR_STATE_HANDLER_MISSING",
    "RMAD_ERROR_STATE_HANDLER_INITIALIZATION_FAILED"};
const std::vector<std::string> kTestAdditionalActivities = {
    "RMAD_ADDITIONAL_ACTIVITY_REBOOT",
    "RMAD_ADDITIONAL_ACTIVITY_BATTERY_CUTOFF",
    "RMAD_ADDITIONAL_ACTIVITY_DIAGNOSTICS"};

constexpr double kTestStateSetupTimestamp = 111.111;
constexpr double kTestStateLeaveTimestamp = 666.666;
constexpr double kTestStateOverallTime = 555.555;

}  // namespace

namespace rmad {

class MetricsUtilsTest : public testing::Test {
 public:
  MetricsUtilsTest() = default;

 protected:
  void SetUp() override {
    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
    file_path_ = temp_dir_.GetPath().AppendASCII(kTestJsonStoreFilename);
  }

  bool CreateInputFile(const char* str, int size) {
    if (base::WriteFile(file_path_, str, size) == size) {
      json_store_ = base::MakeRefCounted<JsonStore>(file_path_, false);
      return true;
    }
    return false;
  }

  base::ScopedTempDir temp_dir_;
  scoped_refptr<JsonStore> json_store_;
  base::FilePath file_path_;
};

TEST_F(MetricsUtilsTest, GetValue) {
  EXPECT_TRUE(
      CreateInputFile(kDefaultMetricsJson, std::size(kDefaultMetricsJson) - 1));

  double first_setup_ts;
  EXPECT_TRUE(MetricsUtils::GetMetricsValue(
      json_store_, kMetricsFirstSetupTimestamp, &first_setup_ts));
  EXPECT_EQ(first_setup_ts, kDefaultFirstSetupTimestamp);

  double setup_ts;
  EXPECT_TRUE(MetricsUtils::GetMetricsValue(json_store_, kMetricsSetupTimestamp,
                                            &setup_ts));
  EXPECT_EQ(setup_ts, kDefaultSetupTimestamp);

  double running_time;
  EXPECT_TRUE(MetricsUtils::GetMetricsValue(json_store_, kMetricsRunningTime,
                                            &running_time));
  EXPECT_EQ(running_time, kDefaultRunningTime);

  bool ro_fw_verified;
  EXPECT_TRUE(MetricsUtils::GetMetricsValue(
      json_store_, kMetricsRoFirmwareVerified, &ro_fw_verified));
  EXPECT_EQ(ro_fw_verified, kDefaultRoFirmwareVerified);

  std::vector<std::string> occurred_errors;
  EXPECT_TRUE(MetricsUtils::GetMetricsValue(json_store_, kMetricsOccurredErrors,
                                            &occurred_errors));
  EXPECT_EQ(occurred_errors, kDefaultOccurredErrors);

  std::vector<std::string> additional_activities;
  EXPECT_TRUE(MetricsUtils::GetMetricsValue(
      json_store_, kMetricsAdditionalActivities, &additional_activities));
  EXPECT_EQ(additional_activities, kDefaultAdditionalActivities);

  std::map<int, StateMetricsData> state_metrics;
  EXPECT_TRUE(MetricsUtils::GetMetricsValue(json_store_, kStateMetrics,
                                            &state_metrics));
  EXPECT_EQ(state_metrics, kDefaultStateMetrics);
}

TEST_F(MetricsUtilsTest, SetValue_FirstSetupTimestamp) {
  EXPECT_TRUE(
      CreateInputFile(kEmptyMetricsJson, std::size(kEmptyMetricsJson) - 1));

  EXPECT_TRUE(MetricsUtils::SetMetricsValue(
      json_store_, kMetricsFirstSetupTimestamp, kTestFirstSetupTimestamp));

  double first_setup_ts;
  EXPECT_TRUE(MetricsUtils::GetMetricsValue(
      json_store_, kMetricsFirstSetupTimestamp, &first_setup_ts));
  EXPECT_EQ(first_setup_ts, kTestFirstSetupTimestamp);
}

TEST_F(MetricsUtilsTest, SetValue_SetupTimestamp) {
  EXPECT_TRUE(
      CreateInputFile(kEmptyMetricsJson, std::size(kEmptyMetricsJson) - 1));

  EXPECT_TRUE(MetricsUtils::SetMetricsValue(json_store_, kMetricsSetupTimestamp,
                                            kTestSetupTimestamp));

  double setup_ts;
  EXPECT_TRUE(MetricsUtils::GetMetricsValue(json_store_, kMetricsSetupTimestamp,
                                            &setup_ts));
  EXPECT_EQ(setup_ts, kTestSetupTimestamp);
}

TEST_F(MetricsUtilsTest, SetValue_RunningTime) {
  EXPECT_TRUE(
      CreateInputFile(kEmptyMetricsJson, std::size(kEmptyMetricsJson) - 1));

  EXPECT_TRUE(MetricsUtils::SetMetricsValue(json_store_, kMetricsRunningTime,
                                            kTestRunningTime));

  double running_time;
  EXPECT_TRUE(MetricsUtils::GetMetricsValue(json_store_, kMetricsRunningTime,
                                            &running_time));
  EXPECT_EQ(running_time, kTestRunningTime);
}

TEST_F(MetricsUtilsTest, SetValue_RoFirmwareVerified) {
  EXPECT_TRUE(
      CreateInputFile(kEmptyMetricsJson, std::size(kEmptyMetricsJson) - 1));

  EXPECT_TRUE(MetricsUtils::SetMetricsValue(
      json_store_, kMetricsRoFirmwareVerified, kTestRoFirmwareVerified));

  bool ro_fw_verified;
  EXPECT_TRUE(MetricsUtils::GetMetricsValue(
      json_store_, kMetricsRoFirmwareVerified, &ro_fw_verified));
  EXPECT_EQ(ro_fw_verified, kTestRoFirmwareVerified);
}

TEST_F(MetricsUtilsTest, SetValue_OccurredErrors) {
  EXPECT_TRUE(
      CreateInputFile(kEmptyMetricsJson, std::size(kEmptyMetricsJson) - 1));

  EXPECT_TRUE(MetricsUtils::SetMetricsValue(json_store_, kMetricsOccurredErrors,
                                            kTestOccurredErrors));

  std::vector<std::string> occurred_errors;
  EXPECT_TRUE(MetricsUtils::GetMetricsValue(json_store_, kMetricsOccurredErrors,
                                            &occurred_errors));
  EXPECT_EQ(occurred_errors, kTestOccurredErrors);
}

TEST_F(MetricsUtilsTest, SetValue_AddtionalActivities) {
  EXPECT_TRUE(
      CreateInputFile(kEmptyMetricsJson, std::size(kEmptyMetricsJson) - 1));

  EXPECT_TRUE(MetricsUtils::SetMetricsValue(
      json_store_, kMetricsAdditionalActivities, kTestAdditionalActivities));

  std::vector<std::string> additional_activities;
  EXPECT_TRUE(MetricsUtils::GetMetricsValue(
      json_store_, kMetricsAdditionalActivities, &additional_activities));
  EXPECT_EQ(additional_activities, kTestAdditionalActivities);
}

TEST_F(MetricsUtilsTest, SetValue_StateMetrics) {
  EXPECT_TRUE(
      CreateInputFile(kEmptyMetricsJson, std::size(kEmptyMetricsJson) - 1));

  EXPECT_TRUE(MetricsUtils::SetMetricsValue(json_store_, kStateMetrics,
                                            kDefaultStateMetrics));

  std::map<int, StateMetricsData> state_metrics;
  EXPECT_TRUE(MetricsUtils::GetMetricsValue(json_store_, kStateMetrics,
                                            &state_metrics));
  EXPECT_EQ(state_metrics, kDefaultStateMetrics);
}

TEST_F(MetricsUtilsTest, UpdateStateMetricsOnStateTransition) {
  EXPECT_TRUE(
      CreateInputFile(kEmptyMetricsJson, std::size(kEmptyMetricsJson) - 1));

  RmadState::StateCase state_case = RmadState::StateCase::kRestock;
  EXPECT_TRUE(MetricsUtils::UpdateStateMetricsOnStateTransition(
      json_store_, RmadState::StateCase::STATE_NOT_SET, state_case,
      kTestStateSetupTimestamp));

  std::map<int, StateMetricsData> state_metrics;
  EXPECT_TRUE(MetricsUtils::GetMetricsValue(json_store_, kStateMetrics,
                                            &state_metrics));

  auto state_it = state_metrics.find(static_cast<int>(state_case));
  EXPECT_NE(state_it, state_metrics.end());
  EXPECT_NEAR(state_it->second.setup_timestamp, kTestStateSetupTimestamp, 1e-4);

  EXPECT_TRUE(MetricsUtils::UpdateStateMetricsOnStateTransition(
      json_store_, state_case, RmadState::StateCase::STATE_NOT_SET,
      kTestStateLeaveTimestamp));

  EXPECT_TRUE(MetricsUtils::GetMetricsValue(json_store_, kStateMetrics,
                                            &state_metrics));
  state_it = state_metrics.find(static_cast<int>(state_case));
  EXPECT_NE(state_it, state_metrics.end());
  EXPECT_NEAR(state_it->second.setup_timestamp, kTestStateLeaveTimestamp, 1e-4);
  EXPECT_NEAR(state_it->second.overall_time, kTestStateOverallTime, 1e-4);
}

TEST_F(MetricsUtilsTest, UpdateStateMetricsOnStateTransition_StateNotFound) {
  EXPECT_TRUE(
      CreateInputFile(kEmptyMetricsJson, std::size(kEmptyMetricsJson) - 1));

  EXPECT_FALSE(MetricsUtils::UpdateStateMetricsOnStateTransition(
      json_store_, RmadState::StateCase::kWelcome,
      RmadState::StateCase::kRestock, kTestStateSetupTimestamp));
}

TEST_F(MetricsUtilsTest, UpdateStateMetricsOnStateTransition_InvalidTimestamp) {
  EXPECT_TRUE(
      CreateInputFile(kInvalidStateMetricsTimestampJson,
                      std::size(kInvalidStateMetricsTimestampJson) - 1));

  RmadState::StateCase state_case = RmadState::StateCase::kRestock;
  EXPECT_FALSE(MetricsUtils::UpdateStateMetricsOnStateTransition(
      json_store_, RmadState::StateCase::kWelcome, state_case,
      kTestStateLeaveTimestamp));
}

TEST_F(MetricsUtilsTest,
       UpdateStateMetricsOnStateTransition_NotIncreasedTimestamp) {
  EXPECT_TRUE(
      CreateInputFile(kEmptyMetricsJson, std::size(kEmptyMetricsJson) - 1));

  RmadState::StateCase state_case = RmadState::StateCase::kRestock;
  EXPECT_TRUE(MetricsUtils::UpdateStateMetricsOnStateTransition(
      json_store_, RmadState::StateCase::STATE_NOT_SET, state_case,
      kTestStateSetupTimestamp));

  std::map<int, StateMetricsData> state_metrics;
  EXPECT_TRUE(MetricsUtils::GetMetricsValue(json_store_, kStateMetrics,
                                            &state_metrics));

  auto state_it = state_metrics.find(static_cast<int>(state_case));
  EXPECT_NE(state_it, state_metrics.end());
  EXPECT_NEAR(state_it->second.setup_timestamp, kTestStateSetupTimestamp, 1e-4);

  // Invalid timestamp: timestamp should be incremented each time.
  EXPECT_FALSE(MetricsUtils::UpdateStateMetricsOnStateTransition(
      json_store_, state_case, RmadState::StateCase::STATE_NOT_SET,
      kTestStateSetupTimestamp - 1));
}

TEST_F(MetricsUtilsTest, UpdateStateMetricsOnAbort) {
  EXPECT_TRUE(
      CreateInputFile(kEmptyMetricsJson, std::size(kEmptyMetricsJson) - 1));

  RmadState::StateCase state_case = RmadState::StateCase::kRestock;
  EXPECT_TRUE(MetricsUtils::UpdateStateMetricsOnStateTransition(
      json_store_, RmadState::StateCase::STATE_NOT_SET, state_case,
      kTestStateSetupTimestamp));

  std::map<int, StateMetricsData> state_metrics;
  EXPECT_TRUE(MetricsUtils::GetMetricsValue(json_store_, kStateMetrics,
                                            &state_metrics));

  auto state_it = state_metrics.find(static_cast<int>(state_case));
  EXPECT_NE(state_it, state_metrics.end());
  EXPECT_NEAR(state_it->second.setup_timestamp, kTestStateSetupTimestamp, 1e-4);

  EXPECT_TRUE(MetricsUtils::UpdateStateMetricsOnAbort(
      json_store_, state_case, kTestStateLeaveTimestamp));

  EXPECT_TRUE(MetricsUtils::GetMetricsValue(json_store_, kStateMetrics,
                                            &state_metrics));
  state_it = state_metrics.find(static_cast<int>(state_case));
  EXPECT_NE(state_it, state_metrics.end());
  EXPECT_NEAR(state_it->second.setup_timestamp, kTestStateLeaveTimestamp, 1e-4);
  EXPECT_NEAR(state_it->second.overall_time, kTestStateOverallTime, 1e-4);
  EXPECT_EQ(state_it->second.is_aborted, true);
}

TEST_F(MetricsUtilsTest, UpdateStateMetricsOnGetLog) {
  EXPECT_TRUE(
      CreateInputFile(kEmptyMetricsJson, std::size(kEmptyMetricsJson) - 1));

  RmadState::StateCase state_case = RmadState::StateCase::kRestock;
  EXPECT_TRUE(
      MetricsUtils::UpdateStateMetricsOnGetLog(json_store_, state_case));

  std::map<int, StateMetricsData> state_metrics;
  EXPECT_TRUE(MetricsUtils::GetMetricsValue(json_store_, kStateMetrics,
                                            &state_metrics));
  auto state_it = state_metrics.find(static_cast<int>(state_case));
  EXPECT_NE(state_it, state_metrics.end());
  EXPECT_EQ(state_it->second.get_log_count, 1);

  EXPECT_TRUE(
      MetricsUtils::UpdateStateMetricsOnGetLog(json_store_, state_case));

  EXPECT_TRUE(MetricsUtils::GetMetricsValue(json_store_, kStateMetrics,
                                            &state_metrics));
  state_it = state_metrics.find(static_cast<int>(state_case));
  EXPECT_NE(state_it, state_metrics.end());
  EXPECT_EQ(state_it->second.get_log_count, 2);
}

TEST_F(MetricsUtilsTest, UpdateStateMetricsOnSaveLog) {
  EXPECT_TRUE(
      CreateInputFile(kEmptyMetricsJson, std::size(kEmptyMetricsJson) - 1));

  RmadState::StateCase state_case = RmadState::StateCase::kRestock;
  EXPECT_TRUE(
      MetricsUtils::UpdateStateMetricsOnSaveLog(json_store_, state_case));

  std::map<int, StateMetricsData> state_metrics;
  EXPECT_TRUE(MetricsUtils::GetMetricsValue(json_store_, kStateMetrics,
                                            &state_metrics));
  auto state_it = state_metrics.find(static_cast<int>(state_case));
  EXPECT_NE(state_it, state_metrics.end());
  EXPECT_EQ(state_it->second.save_log_count, 1);

  EXPECT_TRUE(
      MetricsUtils::UpdateStateMetricsOnSaveLog(json_store_, state_case));

  EXPECT_TRUE(MetricsUtils::GetMetricsValue(json_store_, kStateMetrics,
                                            &state_metrics));
  state_it = state_metrics.find(static_cast<int>(state_case));
  EXPECT_NE(state_it, state_metrics.end());
  EXPECT_EQ(state_it->second.save_log_count, 2);
}

TEST_F(MetricsUtilsTest, GetMetricsSummaryAsString) {
  EXPECT_TRUE(
      CreateInputFile(kDefaultMetricsJson, std::size(kDefaultMetricsJson) - 1));

  EXPECT_EQ(MetricsUtils::GetMetricsSummaryAsString(json_store_),
            kDefaultMetricsSummaryJson);
}

TEST_F(MetricsUtilsTest, GetMetricsSummaryAsString_NoData) {
  EXPECT_TRUE(
      CreateInputFile(kEmptyMetricsJson, std::size(kEmptyMetricsJson) - 1));

  EXPECT_EQ(MetricsUtils::GetMetricsSummaryAsString(json_store_), "");
}

class MetricsUtilsImplTest : public testing::Test {
 public:
  MetricsUtilsImplTest() = default;

  void SetupShimlessRmaReportValues(bool first_timestamp = true,
                                    bool timestamp = true,
                                    bool is_complete = true,
                                    bool ro_verified = true,
                                    bool returning_owner = true,
                                    bool mlb_replacement = true,
                                    bool wp_method = true) {
    double current_timestamp = base::Time::Now().InSecondsFSinceUnixEpoch();
    if (first_timestamp) {
      EXPECT_TRUE(MetricsUtils::SetMetricsValue(
          json_store_, kMetricsFirstSetupTimestamp, current_timestamp));
    }

    if (timestamp) {
      EXPECT_TRUE(MetricsUtils::SetMetricsValue(
          json_store_, kMetricsSetupTimestamp, current_timestamp));
    }

    if (is_complete) {
      EXPECT_TRUE(
          MetricsUtils::SetMetricsValue(json_store_, kMetricsIsComplete, true));
    }

    if (ro_verified) {
      EXPECT_TRUE(MetricsUtils::SetMetricsValue(
          json_store_, kMetricsRoFirmwareVerified,
          RoVerificationStatus_Name(RMAD_RO_VERIFICATION_PASS)));
    }

    if (returning_owner) {
      EXPECT_TRUE(MetricsUtils::SetMetricsValue(
          json_store_, kMetricsReturningOwner,
          ReturningOwner_Name(
              ReturningOwner::RMAD_RETURNING_OWNER_DIFFERENT_OWNER)));
    }

    if (mlb_replacement) {
      EXPECT_TRUE(MetricsUtils::SetMetricsValue(json_store_,
                                                kMetricsMlbReplacement, true));
    }

    if (wp_method) {
      EXPECT_TRUE(MetricsUtils::SetMetricsValue(
          json_store_, kMetricsWpDisableMethod,
          WpDisableMethod_Name(WpDisableMethod::RMAD_WP_DISABLE_METHOD_RSU)));
    }
  }

  void SetupMetricsValues(bool is_report_valid = true,
                          bool is_replaced_components_valid = true,
                          bool is_occurred_errors_valid = true,
                          bool is_additional_activities_valid = true,
                          bool is_state_reports_valid = true) {
    if (is_report_valid) {
      SetupShimlessRmaReportValues();
    } else {
      SetupShimlessRmaReportValues(false);
    }

    if (is_replaced_components_valid) {
      EXPECT_TRUE(MetricsUtils::SetMetricsValue(
          json_store_, kMetricsReplacedComponents,
          std::vector<std::string>(
              {RmadComponent_Name(RMAD_COMPONENT_AUDIO_CODEC),
               RmadComponent_Name(RMAD_COMPONENT_BATTERY)})));
    } else {
      EXPECT_TRUE(
          MetricsUtils::SetMetricsValue(json_store_, kMetricsReplacedComponents,
                                        std::vector<std::string>({"test"})));
    }

    if (is_occurred_errors_valid) {
      EXPECT_TRUE(MetricsUtils::SetMetricsValue(
          json_store_, kMetricsOccurredErrors,
          std::vector<std::string>(
              {RmadErrorCode_Name(RMAD_ERROR_CANNOT_CANCEL_RMA),
               RmadErrorCode_Name(RMAD_ERROR_CANNOT_GET_LOG)})));
    } else {
      EXPECT_TRUE(
          MetricsUtils::SetMetricsValue(json_store_, kMetricsOccurredErrors,
                                        std::vector<std::string>({"test"})));
    }

    if (is_additional_activities_valid) {
      EXPECT_TRUE(MetricsUtils::SetMetricsValue(
          json_store_, kMetricsAdditionalActivities,
          std::vector<std::string>(
              {AdditionalActivity_Name(RMAD_ADDITIONAL_ACTIVITY_REBOOT),
               AdditionalActivity_Name(RMAD_ADDITIONAL_ACTIVITY_SHUTDOWN)})));
    } else {
      EXPECT_TRUE(MetricsUtils::SetMetricsValue(
          json_store_, kMetricsAdditionalActivities,
          std::vector<std::string>({"test"})));
    }

    if (is_state_reports_valid) {
      std::map<int, StateMetricsData> test_data;
      test_data[1] = StateMetricsData();
      // The transition count is always >= 1.
      test_data[1].transition_count = 1;
      EXPECT_TRUE(
          MetricsUtils::SetMetricsValue(json_store_, kStateMetrics, test_data));
    } else {
      std::map<int, StateMetricsData> test_data;
      test_data[1] = StateMetricsData();
      // The transition count should be >= 1.
      test_data[1].transition_count = 0;
      EXPECT_TRUE(
          MetricsUtils::SetMetricsValue(json_store_, kStateMetrics, test_data));
    }
  }

 protected:
  void SetUp() override {
    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
    base::FilePath file_path =
        temp_dir_.GetPath().AppendASCII(kTestJsonStoreFilename);
    json_store_ = base::MakeRefCounted<JsonStore>(file_path, false);
  }

  base::ScopedTempDir temp_dir_;
  scoped_refptr<JsonStore> json_store_;
};

TEST_F(MetricsUtilsImplTest, RecordShimlessRmaReport_Success) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  SetupShimlessRmaReportValues();

  EXPECT_TRUE(metrics_utils->RecordShimlessRmaReport(json_store_));
}

TEST_F(MetricsUtilsImplTest,
       RecordShimlessRmaReport_FirstSetupTimestampMissed) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  SetupShimlessRmaReportValues(false);

  EXPECT_FALSE(metrics_utils->RecordShimlessRmaReport(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordShimlessRmaReport_SetupTimestampMissed) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  SetupShimlessRmaReportValues(true, false);

  EXPECT_FALSE(metrics_utils->RecordShimlessRmaReport(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordShimlessRmaReport_Abort_Success) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  SetupShimlessRmaReportValues(true, true, false);

  EXPECT_TRUE(metrics_utils->RecordShimlessRmaReport(json_store_));
}

TEST_F(MetricsUtilsImplTest,
       RecordShimlessRmaReport_RoVerifiedUnsupported_Success) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  SetupShimlessRmaReportValues();
  EXPECT_TRUE(MetricsUtils::SetMetricsValue(
      json_store_, kMetricsRoFirmwareVerified,
      RoVerificationStatus_Name(RMAD_RO_VERIFICATION_UNSUPPORTED)));

  EXPECT_TRUE(metrics_utils->RecordShimlessRmaReport(json_store_));
}

TEST_F(MetricsUtilsImplTest,
       RecordShimlessRmaReport_UnknownRoVerified_Success) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  SetupShimlessRmaReportValues(true, true, true, false);

  EXPECT_TRUE(metrics_utils->RecordShimlessRmaReport(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordShimlessRmaReport_SameOnwer_Success) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  SetupShimlessRmaReportValues();
  EXPECT_TRUE(MetricsUtils::SetMetricsValue(
      json_store_, kMetricsReturningOwner,
      ReturningOwner_Name(ReturningOwner::RMAD_RETURNING_OWNER_SAME_OWNER)));

  EXPECT_TRUE(metrics_utils->RecordShimlessRmaReport(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordShimlessRmaReport_DifferentOnwer_Success) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  SetupShimlessRmaReportValues();
  EXPECT_TRUE(MetricsUtils::SetMetricsValue(
      json_store_, kMetricsReturningOwner,
      ReturningOwner_Name(
          ReturningOwner::RMAD_RETURNING_OWNER_DIFFERENT_OWNER)));

  EXPECT_TRUE(metrics_utils->RecordShimlessRmaReport(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordShimlessRmaReport_UnknownOnwer_Success) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  SetupShimlessRmaReportValues(true, true, true, true, false);

  EXPECT_TRUE(metrics_utils->RecordShimlessRmaReport(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordShimlessRmaReport_MlbReplaced_Success) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  SetupShimlessRmaReportValues();
  EXPECT_TRUE(MetricsUtils::SetMetricsValue(
      json_store_, kMetricsMlbReplacement,
      MainboardReplacement_Name(
          MainboardReplacement::RMAD_MLB_REPLACEMENT_REPLACED)));

  EXPECT_TRUE(metrics_utils->RecordShimlessRmaReport(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordShimlessRmaReport_MlbOriginal_Success) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  SetupShimlessRmaReportValues();
  EXPECT_TRUE(MetricsUtils::SetMetricsValue(
      json_store_, kMetricsMlbReplacement,
      MainboardReplacement_Name(
          MainboardReplacement::RMAD_MLB_REPLACEMENT_ORIGINAL)));

  EXPECT_TRUE(metrics_utils->RecordShimlessRmaReport(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordShimlessRmaReport_MlbUnknown_Success) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  SetupShimlessRmaReportValues(true, true, true, true, true, false);

  EXPECT_TRUE(metrics_utils->RecordShimlessRmaReport(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordShimlessRmaReport_WpDisableMethod_Success) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  SetupShimlessRmaReportValues(true, true, true, true, true, true, false);
  // The write protect disable method hasn't been set yet.
  EXPECT_TRUE(metrics_utils->RecordShimlessRmaReport(json_store_));

  std::array<WpDisableMethod, 5> methods = {
      RMAD_WP_DISABLE_METHOD_UNKNOWN, RMAD_WP_DISABLE_METHOD_SKIPPED,
      RMAD_WP_DISABLE_METHOD_RSU,
      RMAD_WP_DISABLE_METHOD_PHYSICAL_ASSEMBLE_DEVICE,
      RMAD_WP_DISABLE_METHOD_PHYSICAL_KEEP_DEVICE_OPEN};
  for (auto wp_disable_method : methods) {
    EXPECT_TRUE(
        MetricsUtils::SetMetricsValue(json_store_, kMetricsWpDisableMethod,
                                      WpDisableMethod_Name(wp_disable_method)));
    EXPECT_TRUE(
        MetricsUtils::SetMetricsValue(json_store_, kMetricsIsComplete, true));
    EXPECT_TRUE(metrics_utils->RecordShimlessRmaReport(json_store_));
  }
}

TEST_F(MetricsUtilsImplTest, RecordReplacedComponents_Success) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  EXPECT_TRUE(MetricsUtils::SetMetricsValue(
      json_store_, kMetricsReplacedComponents,
      std::vector<std::string>({RmadComponent_Name(RMAD_COMPONENT_AUDIO_CODEC),
                                RmadComponent_Name(RMAD_COMPONENT_BATTERY)})));

  EXPECT_TRUE(metrics_utils->RecordReplacedComponents(json_store_));
}

TEST_F(MetricsUtilsImplTest,
       RecordReplacedComponents_UnknownReplacedComponent) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  EXPECT_TRUE(
      MetricsUtils::SetMetricsValue(json_store_, kMetricsReplacedComponents,
                                    std::vector<std::string>({"test"})));

  EXPECT_FALSE(metrics_utils->RecordReplacedComponents(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordOccurredErrors_Success) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  EXPECT_TRUE(MetricsUtils::SetMetricsValue(
      json_store_, kMetricsOccurredErrors,
      std::vector<std::string>(
          {RmadErrorCode_Name(RMAD_ERROR_CANNOT_CANCEL_RMA),
           RmadErrorCode_Name(RMAD_ERROR_CANNOT_GET_LOG)})));

  EXPECT_TRUE(metrics_utils->RecordOccurredErrors(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordOccurredErrors_UnknownOccurredError) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  EXPECT_TRUE(MetricsUtils::SetMetricsValue(
      json_store_, kMetricsOccurredErrors, std::vector<std::string>({"test"})));

  EXPECT_FALSE(metrics_utils->RecordOccurredErrors(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordAdditionalActivities_Success) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  EXPECT_TRUE(MetricsUtils::SetMetricsValue(
      json_store_, kMetricsAdditionalActivities,
      std::vector<std::string>(
          {AdditionalActivity_Name(RMAD_ADDITIONAL_ACTIVITY_REBOOT),
           AdditionalActivity_Name(RMAD_ADDITIONAL_ACTIVITY_SHUTDOWN)})));

  EXPECT_TRUE(metrics_utils->RecordAdditionalActivities(json_store_));
}

TEST_F(MetricsUtilsImplTest,
       RecordAdditionalActivities_UnknownAdditionalActivity) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  EXPECT_TRUE(
      MetricsUtils::SetMetricsValue(json_store_, kMetricsAdditionalActivities,
                                    std::vector<std::string>({"test"})));

  EXPECT_FALSE(metrics_utils->RecordAdditionalActivities(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordShimlessRmaStateReport_Success) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  std::map<int, StateMetricsData> test_data;
  // The transition count should be >= 1.
  test_data[1] = {.transition_count = 1};
  EXPECT_TRUE(
      MetricsUtils::SetMetricsValue(json_store_, kStateMetrics, test_data));

  EXPECT_TRUE(metrics_utils->RecordShimlessRmaStateReport(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordShimlessRmaStateReport_WrongOverallTime) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  std::map<int, StateMetricsData> test_data;
  // The transition count should be >= 1; The overall time should be >= 0.
  test_data[1] = {.overall_time = -1, .transition_count = 1};
  EXPECT_TRUE(
      MetricsUtils::SetMetricsValue(json_store_, kStateMetrics, test_data));

  EXPECT_FALSE(metrics_utils->RecordShimlessRmaStateReport(json_store_));
}

TEST_F(MetricsUtilsImplTest,
       RecordShimlessRmaStateReport_WrongTransitionCount) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  std::map<int, StateMetricsData> test_data;
  // The transition count should be >= 1.
  test_data[1] = {.transition_count = 0};
  EXPECT_TRUE(
      MetricsUtils::SetMetricsValue(json_store_, kStateMetrics, test_data));

  EXPECT_FALSE(metrics_utils->RecordShimlessRmaStateReport(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordShimlessRmaStateReport_WrongGetLogCount) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  std::map<int, StateMetricsData> test_data;
  // The transition count should be >= 1; The get log count should be >= 0.
  test_data[1] = {.transition_count = 1, .get_log_count = -1};
  EXPECT_TRUE(
      MetricsUtils::SetMetricsValue(json_store_, kStateMetrics, test_data));

  EXPECT_FALSE(metrics_utils->RecordShimlessRmaStateReport(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordShimlessRmaStateReport_WrongSaveLogCount) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  std::map<int, StateMetricsData> test_data;
  // The transition count should be >= 1; The save log count should be >= 0.
  test_data[1] = {.transition_count = 1, .save_log_count = -1};
  EXPECT_TRUE(
      MetricsUtils::SetMetricsValue(json_store_, kStateMetrics, test_data));

  EXPECT_FALSE(metrics_utils->RecordShimlessRmaStateReport(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordAll_Success) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  SetupMetricsValues();

  EXPECT_TRUE(metrics_utils->RecordAll(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordAll_RecordShimleeRmaReportFailed) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  SetupMetricsValues(false);

  EXPECT_FALSE(metrics_utils->RecordAll(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordAll_RecordReplacedComponentsFailed) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  SetupMetricsValues(true, false);

  EXPECT_FALSE(metrics_utils->RecordAll(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordAll_RecordOccurredErrorsFailed) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  SetupMetricsValues(true, true, false);

  EXPECT_FALSE(metrics_utils->RecordAll(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordAll_RecordAdditionalActivitiesFailed) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  SetupMetricsValues(true, true, true, false);

  EXPECT_FALSE(metrics_utils->RecordAll(json_store_));
}

TEST_F(MetricsUtilsImplTest, RecordAll_RecordShimlessRmaStateReportFailed) {
  auto metrics_utils = std::make_unique<MetricsUtilsImpl>(false);
  SetupMetricsValues(true, true, true, true, false);

  EXPECT_FALSE(metrics_utils->RecordAll(json_store_));
}

}  // namespace rmad