| // Copyright 2021 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 <memory> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include <base/files/file_util.h> |
| #include <base/memory/scoped_refptr.h> |
| #include <base/run_loop.h> |
| #include <base/test/task_environment.h> |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| |
| #include "rmad/proto_bindings/rmad.pb.h" |
| #include "rmad/state_handler/finalize_state_handler.h" |
| #include "rmad/state_handler/state_handler_test_common.h" |
| #include "rmad/utils/json_store.h" |
| #include "rmad/utils/mock_cr50_utils.h" |
| #include "rmad/utils/mock_crossystem_utils.h" |
| #include "rmad/utils/mock_flashrom_utils.h" |
| |
| using testing::_; |
| using testing::DoAll; |
| using testing::Eq; |
| using testing::InSequence; |
| using testing::Invoke; |
| using testing::NiceMock; |
| using testing::Return; |
| using testing::SetArgPointee; |
| using testing::StrictMock; |
| |
| namespace rmad { |
| |
| class FinalizeStateHandlerTest : public StateHandlerTest { |
| public: |
| // Helper class to mock the callback function to send signal. |
| class SignalSender { |
| public: |
| MOCK_METHOD(void, |
| SendFinalizeProgressSignal, |
| (const FinalizeStatus&), |
| (const)); |
| }; |
| |
| scoped_refptr<FinalizeStateHandler> CreateStateHandler( |
| const std::vector<int>& wp_status_list, |
| bool enable_swwp_success, |
| bool disable_factory_mode_success) { |
| // Mock |Cr50Utils|. |
| auto mock_cr50_utils = std::make_unique<NiceMock<MockCr50Utils>>(); |
| ON_CALL(*mock_cr50_utils, DisableFactoryMode()) |
| .WillByDefault(Return(disable_factory_mode_success)); |
| // Mock |CrosSystemUtils|. |
| auto mock_crossystem_utils = |
| std::make_unique<StrictMock<MockCrosSystemUtils>>(); |
| { |
| InSequence seq; |
| for (int i = 0; i < wp_status_list.size(); ++i) { |
| EXPECT_CALL(*mock_crossystem_utils, |
| GetInt(Eq(CrosSystemUtils::kHwwpStatusProperty), _)) |
| .WillOnce(DoAll(SetArgPointee<1>(wp_status_list[i]), Return(true))); |
| } |
| } |
| // Mock |FlashromUtils|. |
| auto mock_flashrom_utils = std::make_unique<NiceMock<MockFlashromUtils>>(); |
| ON_CALL(*mock_flashrom_utils, EnableSoftwareWriteProtection()) |
| .WillByDefault(Return(enable_swwp_success)); |
| |
| auto handler = base::MakeRefCounted<FinalizeStateHandler>( |
| json_store_, std::move(mock_cr50_utils), |
| std::move(mock_crossystem_utils), std::move(mock_flashrom_utils)); |
| auto callback = |
| base::BindRepeating(&SignalSender::SendFinalizeProgressSignal, |
| base::Unretained(&signal_sender_)); |
| handler->RegisterSignalSender(callback); |
| return handler; |
| } |
| |
| protected: |
| StrictMock<SignalSender> signal_sender_; |
| |
| // Variables for TaskRunner. |
| base::test::TaskEnvironment task_environment_{ |
| base::test::TaskEnvironment::TimeSource::MOCK_TIME}; |
| base::RunLoop run_loop_; |
| }; |
| |
| TEST_F(FinalizeStateHandlerTest, InitializeState_HwwpDisabled_Success) { |
| auto handler = CreateStateHandler({0, 1}, true, true); |
| EXPECT_EQ(handler->InitializeState(), RMAD_ERROR_OK); |
| |
| EXPECT_CALL(signal_sender_, SendFinalizeProgressSignal(_)) |
| .WillOnce(Invoke([](const FinalizeStatus& status) { |
| EXPECT_EQ(status.status(), |
| FinalizeStatus::RMAD_FINALIZE_STATUS_COMPLETE); |
| EXPECT_EQ(status.progress(), 1); |
| EXPECT_EQ(status.error(), FinalizeStatus::RMAD_FINALIZE_ERROR_UNKNOWN); |
| })); |
| handler->RunState(); |
| task_environment_.FastForwardBy(FinalizeStateHandler::kReportStatusInterval); |
| } |
| |
| TEST_F(FinalizeStateHandlerTest, InitializeState_HwwpEnabled_Success) { |
| auto handler = CreateStateHandler({1, 1}, false, true); |
| EXPECT_EQ(handler->InitializeState(), RMAD_ERROR_OK); |
| |
| EXPECT_CALL(signal_sender_, SendFinalizeProgressSignal(_)) |
| .WillOnce(Invoke([](const FinalizeStatus& status) { |
| EXPECT_EQ(status.status(), |
| FinalizeStatus::RMAD_FINALIZE_STATUS_COMPLETE); |
| EXPECT_EQ(status.progress(), 1); |
| EXPECT_EQ(status.error(), FinalizeStatus::RMAD_FINALIZE_ERROR_UNKNOWN); |
| })); |
| handler->RunState(); |
| task_environment_.FastForwardBy(FinalizeStateHandler::kReportStatusInterval); |
| } |
| |
| TEST_F(FinalizeStateHandlerTest, InitializeState_EnableSwwpFailed) { |
| auto handler = CreateStateHandler({0}, false, true); |
| EXPECT_EQ(handler->InitializeState(), RMAD_ERROR_OK); |
| |
| EXPECT_CALL(signal_sender_, SendFinalizeProgressSignal(_)) |
| .WillOnce(Invoke([](const FinalizeStatus& status) { |
| EXPECT_EQ(status.status(), |
| FinalizeStatus::RMAD_FINALIZE_STATUS_FAILED_BLOCKING); |
| EXPECT_EQ(status.progress(), 0); |
| EXPECT_EQ(status.error(), |
| FinalizeStatus::RMAD_FINALIZE_ERROR_CANNOT_ENABLE_SWWP); |
| })); |
| handler->RunState(); |
| task_environment_.FastForwardBy(FinalizeStateHandler::kReportStatusInterval); |
| } |
| |
| TEST_F(FinalizeStateHandlerTest, InitializeState_DisableFactoryModeFailed) { |
| auto handler = CreateStateHandler({0}, true, false); |
| EXPECT_EQ(handler->InitializeState(), RMAD_ERROR_OK); |
| |
| EXPECT_CALL(signal_sender_, SendFinalizeProgressSignal(_)) |
| .WillOnce(Invoke([](const FinalizeStatus& status) { |
| EXPECT_EQ(status.status(), |
| FinalizeStatus::RMAD_FINALIZE_STATUS_FAILED_BLOCKING); |
| EXPECT_EQ(status.progress(), 0.5); |
| EXPECT_EQ(status.error(), |
| FinalizeStatus::RMAD_FINALIZE_ERROR_CANNOT_ENABLE_HWWP); |
| })); |
| handler->RunState(); |
| task_environment_.FastForwardBy(FinalizeStateHandler::kReportStatusInterval); |
| } |
| |
| TEST_F(FinalizeStateHandlerTest, InitializeState_HwwpDisabled) { |
| auto handler = CreateStateHandler({0, 0}, true, true); |
| EXPECT_EQ(handler->InitializeState(), RMAD_ERROR_OK); |
| |
| EXPECT_CALL(signal_sender_, SendFinalizeProgressSignal(_)) |
| .WillOnce(Invoke([](const FinalizeStatus& status) { |
| EXPECT_EQ(status.status(), |
| FinalizeStatus::RMAD_FINALIZE_STATUS_FAILED_BLOCKING); |
| EXPECT_EQ(status.progress(), 0.8); |
| EXPECT_EQ(status.error(), |
| FinalizeStatus::RMAD_FINALIZE_ERROR_CANNOT_ENABLE_HWWP); |
| })); |
| handler->RunState(); |
| task_environment_.FastForwardBy(FinalizeStateHandler::kReportStatusInterval); |
| } |
| |
| TEST_F(FinalizeStateHandlerTest, GetNextStateCase_Success) { |
| auto handler = CreateStateHandler({0, 1}, true, true); |
| EXPECT_EQ(handler->InitializeState(), RMAD_ERROR_OK); |
| handler->RunState(); |
| task_environment_.RunUntilIdle(); |
| |
| RmadState state; |
| state.mutable_finalize()->set_choice( |
| FinalizeState::RMAD_FINALIZE_CHOICE_CONTINUE); |
| |
| auto [error, state_case] = handler->GetNextStateCase(state); |
| EXPECT_EQ(error, RMAD_ERROR_OK); |
| EXPECT_EQ(state_case, RmadState::StateCase::kRepairComplete); |
| } |
| |
| TEST_F(FinalizeStateHandlerTest, GetNextStateCase_InProgress) { |
| auto handler = CreateStateHandler({0, 1}, true, true); |
| EXPECT_EQ(handler->InitializeState(), RMAD_ERROR_OK); |
| handler->RunState(); |
| |
| RmadState state; |
| state.mutable_finalize()->set_choice( |
| FinalizeState::RMAD_FINALIZE_CHOICE_CONTINUE); |
| |
| auto [error, state_case] = handler->GetNextStateCase(state); |
| EXPECT_EQ(error, RMAD_ERROR_WAIT); |
| EXPECT_EQ(state_case, RmadState::StateCase::kFinalize); |
| |
| task_environment_.RunUntilIdle(); |
| } |
| |
| TEST_F(FinalizeStateHandlerTest, GetNextStateCase_MissingState) { |
| auto handler = CreateStateHandler({0, 1}, true, true); |
| EXPECT_EQ(handler->InitializeState(), RMAD_ERROR_OK); |
| handler->RunState(); |
| task_environment_.RunUntilIdle(); |
| |
| RmadState state; |
| |
| auto [error, state_case] = handler->GetNextStateCase(state); |
| EXPECT_EQ(error, RMAD_ERROR_REQUEST_INVALID); |
| EXPECT_EQ(state_case, RmadState::StateCase::kFinalize); |
| } |
| |
| TEST_F(FinalizeStateHandlerTest, GetNextStateCase_MissingArgs) { |
| auto handler = CreateStateHandler({0, 1}, true, true); |
| EXPECT_EQ(handler->InitializeState(), RMAD_ERROR_OK); |
| handler->RunState(); |
| task_environment_.RunUntilIdle(); |
| |
| RmadState state; |
| state.mutable_finalize()->set_choice( |
| FinalizeState::RMAD_FINALIZE_CHOICE_UNKNOWN); |
| |
| auto [error, state_case] = handler->GetNextStateCase(state); |
| EXPECT_EQ(error, RMAD_ERROR_REQUEST_ARGS_MISSING); |
| EXPECT_EQ(state_case, RmadState::StateCase::kFinalize); |
| } |
| |
| TEST_F(FinalizeStateHandlerTest, GetNextStateCase_BlockingFailure_Retry) { |
| auto handler = CreateStateHandler({0, 0}, true, false); |
| EXPECT_EQ(handler->InitializeState(), RMAD_ERROR_OK); |
| handler->RunState(); |
| task_environment_.RunUntilIdle(); |
| |
| // Get blocking failure. |
| { |
| RmadState state; |
| state.mutable_finalize()->set_choice( |
| FinalizeState::RMAD_FINALIZE_CHOICE_CONTINUE); |
| |
| auto [error, state_case] = handler->GetNextStateCase(state); |
| EXPECT_EQ(error, RMAD_ERROR_FINALIZATION_FAILED); |
| EXPECT_EQ(state_case, RmadState::StateCase::kFinalize); |
| } |
| |
| // Request a retry. |
| { |
| RmadState state; |
| state.mutable_finalize()->set_choice( |
| FinalizeState::RMAD_FINALIZE_CHOICE_RETRY); |
| |
| auto [error, state_case] = handler->GetNextStateCase(state); |
| EXPECT_EQ(error, RMAD_ERROR_WAIT); |
| EXPECT_EQ(state_case, RmadState::StateCase::kFinalize); |
| } |
| |
| task_environment_.RunUntilIdle(); |
| |
| // Still fails. |
| { |
| RmadState state; |
| state.mutable_finalize()->set_choice( |
| FinalizeState::RMAD_FINALIZE_CHOICE_CONTINUE); |
| |
| auto [error, state_case] = handler->GetNextStateCase(state); |
| EXPECT_EQ(error, RMAD_ERROR_FINALIZATION_FAILED); |
| EXPECT_EQ(state_case, RmadState::StateCase::kFinalize); |
| } |
| } |
| |
| } // namespace rmad |