| // 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/logs/logs_utils.h" |
| |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include <base/containers/contains.h> |
| #include <base/files/file_util.h> |
| #include <base/files/scoped_temp_dir.h> |
| #include <base/json/json_writer.h> |
| #include <base/memory/scoped_refptr.h> |
| #include <base/values.h> |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| |
| #include "rmad/logs/logs_constants.h" |
| #include "rmad/utils/json_store.h" |
| |
| using testing::_; |
| using testing::Return; |
| |
| namespace { |
| |
| constexpr char kTestJsonStoreFilename[] = "test.json"; |
| constexpr char kDefaultJson[] = R"( |
| { |
| "metrics": {}, |
| "other": {}, |
| "running_time": 446.1482148170471, |
| "setup_timestamp": 1663970456.867931 |
| } |
| )"; |
| constexpr char kSampleLogsJson[] = R"( |
| { |
| "logs": { |
| "events": [ |
| { |
| "details": { |
| }, |
| "state_id": 1, |
| "timestamp": 1668635055.687762, |
| "type": 1 |
| }, |
| { |
| "details": { |
| "is_compliant": false, |
| "unqualified_components": "Display" |
| }, |
| "state_id": 1, |
| "timestamp": 1668635055.687762, |
| "type": 1 |
| }, |
| { |
| "details": { |
| "from_state_id": 1, |
| "to_state_id": 10 |
| }, |
| "state_id": 1, |
| "timestamp": 1668635055.687762, |
| "type": 0 |
| }, |
| { |
| "details": { |
| "replaced_components": [ |
| "RMAD_COMPONENT_KEYBOARD", |
| "RMAD_COMPONENT_CAMERA" |
| ], |
| "rework_selected": false |
| }, |
| "state_id": 2, |
| "timestamp": 1668810230.12951, |
| "type": 1 |
| }, |
| { |
| "details": { |
| "occurred_error": 41 |
| }, |
| "state_id": 15, |
| "timestamp": 1668635055.687762, |
| "type": 2 |
| }, |
| { |
| "details": { |
| "from_state_id": 10, |
| "to_state_id": 14 |
| }, |
| "state_id": 10, |
| "timestamp": 1668635055.688008, |
| "type": 0 |
| }, |
| { |
| "details": { |
| "wp_disable_method": "RMAD_WP_DISABLE_RSU" |
| }, |
| "state_id": 4, |
| "timestamp": 1668812821.203501, |
| "type": 1 |
| }, |
| { |
| "details": { |
| "challenge_code": "ABC123", |
| "hwid": "FLEEX" |
| }, |
| "state_id": 5, |
| "timestamp": 1668812821.417402, |
| "type": 1 |
| }, |
| { |
| "details": { |
| "firmware_status": 3 |
| }, |
| "state_id": 9, |
| "timestamp": 1668812972.125672, |
| "type": 1 |
| }, |
| { |
| "details": { |
| "restock_option": false |
| }, |
| "state_id": 10, |
| "timestamp": 1668812984.62641, |
| "type": 1 |
| }, |
| { |
| "details": { |
| "calibration_components": [ |
| { |
| "calibration_status": 0, |
| "component": "RMAD_COMPONENT_BASE_ACCELEROMETER" |
| }, |
| { |
| "calibration_status": 1, |
| "component": "RMAD_COMPONENT_BASE_GYROSCOPE" |
| }, |
| { |
| "calibration_status": 2, |
| "component": "RMAD_COMPONENT_LID_ACCELEROMETER" |
| } |
| ] |
| }, |
| "state_id": 12, |
| "timestamp": 1668813225.410572, |
| "type": 1 |
| }, |
| { |
| "details": { |
| "calibration_instruction": 2 |
| }, |
| "state_id": 13, |
| "timestamp": 1668813225.410572, |
| "type": 1 |
| } |
| ] |
| } |
| } |
| )"; |
| constexpr char kExpectedLogText[] = |
| "[2022-11-16 21:44:15] Welcome: Shimless RMA Started\n" |
| "[2022-11-16 21:44:15] Welcome: Unqualified components detected - Display\n" |
| "[2022-11-16 21:44:15] Transitioned from Welcome to Restock\n" |
| "[2022-11-18 22:23:50] ComponentsRepair: Selected RMAD_COMPONENT_KEYBOARD," |
| " RMAD_COMPONENT_CAMERA\n" |
| "[2022-11-16 21:44:15] ERROR in ProvisionDevice: RMAD_ERROR_WP_ENABLED\n" |
| "[2022-11-16 21:44:15] Transitioned from Restock to RunCalibration\n" |
| "[2022-11-18 23:07:01] WpDisableMethod: Selected to disable write protect" |
| " via RMAD_WP_DISABLE_RSU\n" |
| "[2022-11-18 23:07:01] WpDisableRsu: The RSU challenge code is ABC123\n" |
| "[2022-11-18 23:09:32] UpdateRoFirmware: Firmware update complete\n" |
| "[2022-11-18 23:09:44] Restock: Continuing\n" |
| "[2022-11-18 23:13:45] CheckCalibration: Calibration for" |
| " RMAD_COMPONENT_BASE_ACCELEROMETER - Failed, RMAD_COMPONENT_BASE_GYROSCOPE" |
| " - Skipped, RMAD_COMPONENT_LID_ACCELEROMETER - Retried\n" |
| "[2022-11-18 23:13:45] SetupCalibration: Place lid on flat surface\n"; |
| |
| } // namespace |
| |
| namespace rmad { |
| |
| class LogsUtilsTest : public testing::Test { |
| public: |
| LogsUtilsTest() = 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_; |
| }; |
| |
| // Simulates adding two events to an empty `logs` json. |
| TEST_F(LogsUtilsTest, RecordStateTransition) { |
| const RmadState::StateCase state1 = RmadState::kWelcome; |
| const RmadState::StateCase state2 = RmadState::kRestock; |
| const RmadState::StateCase state3 = RmadState::kRunCalibration; |
| |
| EXPECT_TRUE(CreateInputFile(kDefaultJson, std::size(kDefaultJson) - 1)); |
| |
| EXPECT_TRUE(RecordStateTransitionToLogs(json_store_, state1, state2)); |
| base::Value logs(base::Value::Type::DICT); |
| json_store_->GetValue(kLogs, &logs); |
| |
| const base::Value::List* events = logs.GetDict().FindList(kEvents); |
| EXPECT_EQ(1, events->size()); |
| const base::Value::Dict& event1 = (*events)[0].GetDict(); |
| EXPECT_EQ(static_cast<int>(state1), |
| event1.FindDict(kDetails)->FindInt(kFromStateId)); |
| EXPECT_EQ(static_cast<int>(state2), |
| event1.FindDict(kDetails)->FindInt(kToStateId)); |
| |
| EXPECT_TRUE(RecordStateTransitionToLogs(json_store_, state2, state3)); |
| json_store_->GetValue(kLogs, &logs); |
| |
| events = logs.GetDict().FindList(kEvents); |
| EXPECT_EQ(2, events->size()); |
| const base::Value::Dict& event2 = (*events)[1].GetDict(); |
| EXPECT_EQ(static_cast<int>(state2), |
| event2.FindDict(kDetails)->FindInt(kFromStateId)); |
| EXPECT_EQ(static_cast<int>(state3), |
| event2.FindDict(kDetails)->FindInt(kToStateId)); |
| } |
| |
| // Simulates adding the repair start to an empty `logs` json. |
| TEST_F(LogsUtilsTest, RecordRepairStart) { |
| EXPECT_TRUE(CreateInputFile(kDefaultJson, std::size(kDefaultJson) - 1)); |
| |
| EXPECT_TRUE(RecordRepairStartToLogs(json_store_)); |
| base::Value logs(base::Value::Type::DICT); |
| json_store_->GetValue(kLogs, &logs); |
| |
| const base::Value::List* events = logs.GetDict().FindList(kEvents); |
| EXPECT_EQ(1, events->size()); |
| const base::Value::Dict& event = (*events)[0].GetDict(); |
| EXPECT_EQ(static_cast<int>(RmadState::kWelcome), event.FindInt(kStateId)); |
| EXPECT_EQ(static_cast<int>(LogEventType::kData), event.FindInt(kType)); |
| |
| // Attempt to record again and verify it's not added. |
| EXPECT_FALSE(RecordRepairStartToLogs(json_store_)); |
| } |
| |
| // Simulates adding unqualified components to an empty `logs` json. |
| TEST_F(LogsUtilsTest, RecordUnqualifiedComponents) { |
| EXPECT_TRUE(CreateInputFile(kDefaultJson, std::size(kDefaultJson) - 1)); |
| |
| const bool is_compliant = true; |
| const std::string battery = RmadComponent_Name(RMAD_COMPONENT_BATTERY); |
| |
| EXPECT_TRUE( |
| RecordUnqualifiedComponentsToLogs(json_store_, is_compliant, battery)); |
| base::Value logs(base::Value::Type::DICT); |
| json_store_->GetValue(kLogs, &logs); |
| |
| const base::Value::List* events = logs.GetDict().FindList(kEvents); |
| EXPECT_EQ(1, events->size()); |
| const base::Value::Dict& event = (*events)[0].GetDict(); |
| EXPECT_EQ(static_cast<int>(RmadState::kWelcome), event.FindInt(kStateId)); |
| EXPECT_EQ(static_cast<int>(LogEventType::kData), event.FindInt(kType)); |
| |
| EXPECT_EQ(is_compliant, |
| event.FindDict(kDetails)->FindBool(kLogIsCompliant).value()); |
| EXPECT_EQ(battery, |
| *event.FindDict(kDetails)->FindString(kLogUnqualifiedComponents)); |
| } |
| |
| // Simulates adding replaced components to an empty `logs` json. |
| TEST_F(LogsUtilsTest, RecordSelectedComponents) { |
| EXPECT_TRUE(CreateInputFile(kDefaultJson, std::size(kDefaultJson) - 1)); |
| |
| const bool rework_selected_expected_value = true; |
| const std::string audio_codec = |
| RmadComponent_Name(RMAD_COMPONENT_AUDIO_CODEC); |
| const std::string battery = RmadComponent_Name(RMAD_COMPONENT_BATTERY); |
| |
| EXPECT_TRUE(RecordSelectedComponentsToLogs( |
| json_store_, std::vector<std::string>({audio_codec, battery}), |
| rework_selected_expected_value)); |
| base::Value logs(base::Value::Type::DICT); |
| json_store_->GetValue(kLogs, &logs); |
| |
| const base::Value::List* events = logs.GetDict().FindList(kEvents); |
| EXPECT_EQ(1, events->size()); |
| const base::Value::Dict& event = (*events)[0].GetDict(); |
| EXPECT_EQ(static_cast<int>(RmadState::kComponentsRepair), |
| event.FindInt(kStateId)); |
| EXPECT_EQ(static_cast<int>(LogEventType::kData), event.FindInt(kType)); |
| |
| const base::Value::List* components = |
| event.FindDict(kDetails)->FindList(kLogReplacedComponents); |
| EXPECT_EQ(2, components->size()); |
| EXPECT_EQ(audio_codec, (*components)[0].GetString()); |
| EXPECT_EQ(battery, (*components)[1].GetString()); |
| EXPECT_TRUE(event.FindDict(kDetails)->FindBool(kLogReworkSelected).value()); |
| } |
| |
| // Simulates adding the device destination to an empty `logs` json. |
| TEST_F(LogsUtilsTest, RecordDeviceDestination) { |
| EXPECT_TRUE(CreateInputFile(kDefaultJson, std::size(kDefaultJson) - 1)); |
| |
| const std::string device_destination = |
| ReturningOwner_Name(ReturningOwner::RMAD_RETURNING_OWNER_DIFFERENT_OWNER); |
| |
| EXPECT_TRUE(RecordDeviceDestinationToLogs(json_store_, device_destination)); |
| base::Value logs(base::Value::Type::DICT); |
| json_store_->GetValue(kLogs, &logs); |
| |
| const base::Value::List* events = logs.GetDict().FindList(kEvents); |
| EXPECT_EQ(1, events->size()); |
| const base::Value::Dict& event = (*events)[0].GetDict(); |
| EXPECT_EQ(static_cast<int>(RmadState::kDeviceDestination), |
| event.FindInt(kStateId)); |
| EXPECT_EQ(static_cast<int>(LogEventType::kData), event.FindInt(kType)); |
| EXPECT_EQ(device_destination, |
| *event.FindDict(kDetails)->FindString(kLogDestination)); |
| } |
| |
| // Simulates adding the wipe device decision to an empty `logs` json. |
| TEST_F(LogsUtilsTest, RecordWipeDevice) { |
| EXPECT_TRUE(CreateInputFile(kDefaultJson, std::size(kDefaultJson) - 1)); |
| |
| const bool wipe_device = true; |
| |
| EXPECT_TRUE(RecordWipeDeviceToLogs(json_store_, wipe_device)); |
| base::Value logs(base::Value::Type::DICT); |
| json_store_->GetValue(kLogs, &logs); |
| |
| const base::Value::List* events = logs.GetDict().FindList(kEvents); |
| EXPECT_EQ(1, events->size()); |
| const base::Value::Dict& event = (*events)[0].GetDict(); |
| EXPECT_EQ(static_cast<int>(RmadState::kWipeSelection), |
| event.FindInt(kStateId)); |
| EXPECT_EQ(static_cast<int>(LogEventType::kData), event.FindInt(kType)); |
| EXPECT_TRUE(event.FindDict(kDetails)->FindBool(kLogWipeDevice).value()); |
| } |
| |
| // Simulates adding the wp disable method to an empty `logs` json. |
| TEST_F(LogsUtilsTest, RecordWpDisableMethod) { |
| EXPECT_TRUE(CreateInputFile(kDefaultJson, std::size(kDefaultJson) - 1)); |
| |
| const std::string wp_disable_method = |
| WpDisableMethod_Name(RMAD_WP_DISABLE_METHOD_RSU); |
| |
| EXPECT_TRUE(RecordWpDisableMethodToLogs(json_store_, wp_disable_method)); |
| base::Value logs(base::Value::Type::DICT); |
| json_store_->GetValue(kLogs, &logs); |
| |
| const base::Value::List* events = logs.GetDict().FindList(kEvents); |
| EXPECT_EQ(1, events->size()); |
| const base::Value::Dict& event = (*events)[0].GetDict(); |
| EXPECT_EQ(static_cast<int>(RmadState::kWpDisableMethod), |
| event.FindInt(kStateId)); |
| EXPECT_EQ(static_cast<int>(LogEventType::kData), event.FindInt(kType)); |
| EXPECT_EQ(wp_disable_method, |
| *event.FindDict(kDetails)->FindString(kLogWpDisableMethod)); |
| } |
| |
| // Simulates adding the RSU challenge code to an empty `logs` json. |
| TEST_F(LogsUtilsTest, RecordRsuChallengeCode) { |
| EXPECT_TRUE(CreateInputFile(kDefaultJson, std::size(kDefaultJson) - 1)); |
| |
| const std::string challenge_code = "H65SFQL111PBRSB6PDIRTMFO0KHG3QZW0YSF04PW"; |
| const std::string hwid = "BOOK_C4B-A3F-B4U-E2U-B4E-A6T"; |
| |
| EXPECT_TRUE(RecordRsuChallengeCodeToLogs(json_store_, challenge_code, hwid)); |
| base::Value logs(base::Value::Type::DICT); |
| json_store_->GetValue(kLogs, &logs); |
| |
| const base::Value::List* events = logs.GetDict().FindList(kEvents); |
| EXPECT_EQ(1, events->size()); |
| const base::Value::Dict& event = (*events)[0].GetDict(); |
| EXPECT_EQ(static_cast<int>(RmadState::kWpDisableRsu), |
| event.FindInt(kStateId)); |
| EXPECT_EQ(static_cast<int>(LogEventType::kData), event.FindInt(kType)); |
| EXPECT_EQ(challenge_code, |
| *event.FindDict(kDetails)->FindString(kLogRsuChallengeCode)); |
| EXPECT_EQ(hwid, *event.FindDict(kDetails)->FindString(kLogRsuHwid)); |
| } |
| |
| // Simulates adding the restock option to an empty `logs` json. |
| TEST_F(LogsUtilsTest, RecordRestockOption) { |
| EXPECT_TRUE(CreateInputFile(kDefaultJson, std::size(kDefaultJson) - 1)); |
| |
| EXPECT_TRUE(RecordRestockOptionToLogs(json_store_, /*restock=*/false)); |
| base::Value logs(base::Value::Type::DICT); |
| json_store_->GetValue(kLogs, &logs); |
| |
| const base::Value::List* events = logs.GetDict().FindList(kEvents); |
| EXPECT_EQ(1, events->size()); |
| const base::Value::Dict& event = (*events)[0].GetDict(); |
| EXPECT_EQ(static_cast<int>(RmadState::kRestock), event.FindInt(kStateId)); |
| EXPECT_EQ(static_cast<int>(LogEventType::kData), event.FindInt(kType)); |
| EXPECT_FALSE(event.FindDict(kDetails)->FindBool(kLogRestockOption).value()); |
| } |
| |
| // Simulates adding an error to an empty `logs` json. |
| TEST_F(LogsUtilsTest, RecordError) { |
| EXPECT_TRUE(CreateInputFile(kDefaultJson, std::size(kDefaultJson) - 1)); |
| |
| const RmadState::StateCase current_state = RmadState::kComponentsRepair; |
| const RmadErrorCode error = RmadErrorCode::RMAD_ERROR_CANNOT_CANCEL_RMA; |
| |
| EXPECT_TRUE(RecordOccurredErrorToLogs(json_store_, current_state, error)); |
| base::Value logs(base::Value::Type::DICT); |
| json_store_->GetValue(kLogs, &logs); |
| |
| const base::Value::List* events = logs.GetDict().FindList(kEvents); |
| EXPECT_EQ(1, events->size()); |
| const base::Value::Dict& event = (*events)[0].GetDict(); |
| EXPECT_EQ(static_cast<int>(current_state), event.FindInt(kStateId)); |
| EXPECT_EQ(static_cast<int>(LogEventType::kError), event.FindInt(kType)); |
| EXPECT_EQ(static_cast<int>(error), |
| event.FindDict(kDetails)->FindInt(kOccurredError)); |
| } |
| |
| // Simulates adding component calibration statuses to an empty `logs` json. |
| TEST_F(LogsUtilsTest, RecordComponentCalibrationStatus) { |
| EXPECT_TRUE(CreateInputFile(kDefaultJson, std::size(kDefaultJson) - 1)); |
| |
| const std::string component1 = |
| RmadComponent_Name(RMAD_COMPONENT_BASE_ACCELEROMETER); |
| const LogCalibrationStatus status1 = LogCalibrationStatus::kFailed; |
| const std::string component2 = |
| RmadComponent_Name(RMAD_COMPONENT_BASE_GYROSCOPE); |
| const LogCalibrationStatus status2 = LogCalibrationStatus::kSkip; |
| const std::string component3 = |
| RmadComponent_Name(RMAD_COMPONENT_LID_ACCELEROMETER); |
| const LogCalibrationStatus status3 = LogCalibrationStatus::kRetry; |
| |
| std::vector<std::pair<std::string, LogCalibrationStatus>> |
| calibration_statuses{ |
| {component1, status1}, {component2, status2}, {component3, status3}}; |
| |
| EXPECT_TRUE(RecordComponentCalibrationStatusToLogs(json_store_, |
| calibration_statuses)); |
| base::Value logs(base::Value::Type::DICT); |
| json_store_->GetValue(kLogs, &logs); |
| |
| const base::Value::List* events = logs.GetDict().FindList(kEvents); |
| EXPECT_EQ(1, events->size()); |
| const base::Value::Dict& event = (*events)[0].GetDict(); |
| EXPECT_EQ(static_cast<int>(RmadState::kCheckCalibration), |
| event.FindInt(kStateId)); |
| EXPECT_EQ(static_cast<int>(LogEventType::kData), event.FindInt(kType)); |
| |
| const base::Value::List* components = |
| event.FindDict(kDetails)->FindList(kLogCalibrationComponents); |
| EXPECT_EQ(3, components->size()); |
| EXPECT_EQ(component1, *(*components)[0].GetDict().FindString(kLogComponent)); |
| EXPECT_EQ(static_cast<int>(status1), |
| (*components)[0].GetDict().FindInt(kLogCalibrationStatus)); |
| EXPECT_EQ(component2, *(*components)[1].GetDict().FindString(kLogComponent)); |
| EXPECT_EQ(static_cast<int>(status2), |
| (*components)[1].GetDict().FindInt(kLogCalibrationStatus)); |
| EXPECT_EQ(component3, *(*components)[2].GetDict().FindString(kLogComponent)); |
| EXPECT_EQ(static_cast<int>(status3), |
| (*components)[2].GetDict().FindInt(kLogCalibrationStatus)); |
| } |
| |
| // Simulates adding component calibration setup instruction to an empty `logs` |
| // json. |
| TEST_F(LogsUtilsTest, RecordComponentCalibrationSetupInstruction) { |
| EXPECT_TRUE(CreateInputFile(kDefaultJson, std::size(kDefaultJson) - 1)); |
| |
| const CalibrationSetupInstruction calibration_instruction = |
| RMAD_CALIBRATION_INSTRUCTION_PLACE_BASE_ON_FLAT_SURFACE; |
| |
| EXPECT_TRUE(RecordCalibrationSetupInstructionToLogs(json_store_, |
| calibration_instruction)); |
| base::Value logs(base::Value::Type::DICT); |
| json_store_->GetValue(kLogs, &logs); |
| |
| const base::Value::List* events = logs.GetDict().FindList(kEvents); |
| EXPECT_EQ(1, events->size()); |
| const base::Value::Dict& event = (*events)[0].GetDict(); |
| EXPECT_EQ(static_cast<int>(RmadState::kSetupCalibration), |
| event.FindInt(kStateId)); |
| EXPECT_EQ(static_cast<int>(LogEventType::kData), event.FindInt(kType)); |
| EXPECT_EQ( |
| static_cast<int>(calibration_instruction), |
| *event.FindDict(kDetails)->FindInt(kLogCalibrationSetupInstruction)); |
| } |
| |
| // Simulates adding the firmware update status updates to an empty `logs` json. |
| TEST_F(LogsUtilsTest, RecordFirmwareUpdateStatus) { |
| EXPECT_TRUE(CreateInputFile(kDefaultJson, std::size(kDefaultJson) - 1)); |
| |
| const FirmwareUpdateStatus status1 = FirmwareUpdateStatus::kFirmwareUpdated; |
| const FirmwareUpdateStatus status2 = FirmwareUpdateStatus::kFirmwareComplete; |
| |
| EXPECT_TRUE(RecordFirmwareUpdateStatusToLogs(json_store_, status1)); |
| EXPECT_TRUE(RecordFirmwareUpdateStatusToLogs(json_store_, status2)); |
| // Adding a duplicate `kFirmwareComplete` should not be recorded to logs. |
| EXPECT_FALSE(RecordFirmwareUpdateStatusToLogs(json_store_, status2)); |
| base::Value logs(base::Value::Type::DICT); |
| json_store_->GetValue(kLogs, &logs); |
| |
| const base::Value::List* events = logs.GetDict().FindList(kEvents); |
| EXPECT_EQ(2, events->size()); |
| const base::Value::Dict& event1 = (*events)[0].GetDict(); |
| EXPECT_EQ(static_cast<int>(status1), |
| event1.FindDict(kDetails)->FindInt(kFirmwareStatus)); |
| const base::Value::Dict& event2 = (*events)[1].GetDict(); |
| EXPECT_EQ(static_cast<int>(status2), |
| event2.FindDict(kDetails)->FindInt(kFirmwareStatus)); |
| } |
| |
| // Simulates generating a text log. |
| TEST_F(LogsUtilsTest, GenerateTextLog) { |
| EXPECT_TRUE(CreateInputFile(kSampleLogsJson, std::size(kSampleLogsJson) - 1)); |
| EXPECT_EQ(kExpectedLogText, GenerateLogsText(json_store_)); |
| } |
| |
| // Simulates generating the logs JSON. |
| TEST_F(LogsUtilsTest, GenerateLogsJson) { |
| EXPECT_TRUE(CreateInputFile(kSampleLogsJson, std::size(kSampleLogsJson) - 1)); |
| base::Value logs(base::Value::Type::DICT); |
| json_store_->GetValue(kLogs, &logs); |
| |
| std::string expected_logs_json; |
| base::JSONWriter::WriteWithOptions( |
| logs, base::JSONWriter::OPTIONS_PRETTY_PRINT, &expected_logs_json); |
| EXPECT_EQ(expected_logs_json, GenerateLogsJson(json_store_)); |
| } |
| |
| } // namespace rmad |
