Index: update_attempter_unittest.cc |
diff --git a/update_attempter_unittest.cc b/update_attempter_unittest.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..0a02d1cc9e68c7334e36e58c77623defaa77f593 |
--- /dev/null |
+++ b/update_attempter_unittest.cc |
@@ -0,0 +1,156 @@ |
+// Copyright (c) 2010 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 <base/file_util.h> |
+#include <gtest/gtest.h> |
+ |
+#include "update_engine/action_mock.h" |
+#include "update_engine/action_processor_mock.h" |
+#include "update_engine/filesystem_copier_action.h" |
+#include "update_engine/postinstall_runner_action.h" |
+#include "update_engine/set_bootable_flag_action.h" |
+#include "update_engine/update_attempter.h" |
+ |
+using std::string; |
+using testing::InSequence; |
+using testing::Property; |
+using testing::Return; |
+ |
+namespace chromeos_update_engine { |
+ |
+// Test a subclass rather than the main class directly so that we can mock out |
+// methods within the class. There're explicit unit test for the mocked out |
+// methods. |
+class UpdateAttempterUnderTest : public UpdateAttempter { |
+ public: |
+ UpdateAttempterUnderTest() |
+ : UpdateAttempter(NULL, NULL) {} |
+}; |
+ |
+class UpdateAttempterTest : public ::testing::Test { |
+ protected: |
+ virtual void SetUp() { |
+ EXPECT_EQ(NULL, attempter_.dbus_service_); |
+ EXPECT_EQ(NULL, attempter_.prefs_); |
+ EXPECT_EQ(NULL, attempter_.metrics_lib_); |
+ EXPECT_EQ(NULL, attempter_.update_check_scheduler_); |
+ EXPECT_EQ(0, attempter_.http_response_code_); |
+ EXPECT_EQ(utils::kProcessPriorityNormal, attempter_.priority_); |
+ EXPECT_EQ(NULL, attempter_.manage_priority_source_); |
+ EXPECT_FALSE(attempter_.download_active_); |
+ EXPECT_EQ(UPDATE_STATUS_IDLE, attempter_.status_); |
+ EXPECT_EQ(0.0, attempter_.download_progress_); |
+ EXPECT_EQ(0, attempter_.last_checked_time_); |
+ EXPECT_EQ("0.0.0.0", attempter_.new_version_); |
+ EXPECT_EQ(0, attempter_.new_size_); |
+ processor_ = new ActionProcessorMock(); |
+ attempter_.processor_.reset(processor_); // Transfers ownership. |
+ } |
+ |
+ UpdateAttempterUnderTest attempter_; |
+ ActionProcessorMock* processor_; |
+}; |
+ |
+TEST_F(UpdateAttempterTest, ConstructWithUpdatedMarkerTest) { |
+ extern const char* kUpdateCompletedMarker; |
+ const FilePath kMarker(kUpdateCompletedMarker); |
+ EXPECT_EQ(0, file_util::WriteFile(kMarker, "", 0)); |
+ UpdateAttempterUnderTest attempter; |
+ EXPECT_EQ(UPDATE_STATUS_UPDATED_NEED_REBOOT, attempter.status()); |
+ EXPECT_TRUE(file_util::Delete(kMarker, false)); |
+} |
+ |
+TEST_F(UpdateAttempterTest, GetErrorCodeForActionTest) { |
+ extern ActionExitCode GetErrorCodeForAction(AbstractAction* action, |
+ ActionExitCode code); |
+ EXPECT_EQ(kActionCodeSuccess, |
+ GetErrorCodeForAction(NULL, kActionCodeSuccess)); |
+ |
+ OmahaRequestParams params; |
+ OmahaRequestAction omaha_request_action(NULL, params, NULL, NULL); |
+ EXPECT_EQ(kActionCodeOmahaRequestError, |
+ GetErrorCodeForAction(&omaha_request_action, kActionCodeError)); |
+ OmahaResponseHandlerAction omaha_response_handler_action; |
+ EXPECT_EQ(kActionCodeOmahaResponseHandlerError, |
+ GetErrorCodeForAction(&omaha_response_handler_action, |
+ kActionCodeError)); |
+ FilesystemCopierAction filesystem_copier_action(false); |
+ EXPECT_EQ(kActionCodeFilesystemCopierError, |
+ GetErrorCodeForAction(&filesystem_copier_action, kActionCodeError)); |
+ PostinstallRunnerAction postinstall_runner_action(true); |
+ EXPECT_EQ(kActionCodePostinstallRunnerError, |
+ GetErrorCodeForAction(&postinstall_runner_action, |
+ kActionCodeError)); |
+ SetBootableFlagAction set_bootable_flag_action; |
+ EXPECT_EQ(kActionCodeSetBootableFlagError, |
+ GetErrorCodeForAction(&set_bootable_flag_action, |
+ kActionCodeError)); |
+ ActionMock action_mock; |
+ EXPECT_CALL(action_mock, Type()).Times(1).WillOnce(Return("ActionMock")); |
+ EXPECT_EQ(kActionCodeError, |
+ GetErrorCodeForAction(&action_mock, kActionCodeError)); |
+} |
+ |
+TEST_F(UpdateAttempterTest, UpdateStatusToStringTest) { |
+ extern const char* UpdateStatusToString(UpdateStatus); |
+ EXPECT_STREQ("UPDATE_STATUS_IDLE", UpdateStatusToString(UPDATE_STATUS_IDLE)); |
+ EXPECT_STREQ("UPDATE_STATUS_CHECKING_FOR_UPDATE", |
+ UpdateStatusToString(UPDATE_STATUS_CHECKING_FOR_UPDATE)); |
+ EXPECT_STREQ("UPDATE_STATUS_UPDATE_AVAILABLE", |
+ UpdateStatusToString(UPDATE_STATUS_UPDATE_AVAILABLE)); |
+ EXPECT_STREQ("UPDATE_STATUS_DOWNLOADING", |
+ UpdateStatusToString(UPDATE_STATUS_DOWNLOADING)); |
+ EXPECT_STREQ("UPDATE_STATUS_VERIFYING", |
+ UpdateStatusToString(UPDATE_STATUS_VERIFYING)); |
+ EXPECT_STREQ("UPDATE_STATUS_FINALIZING", |
+ UpdateStatusToString(UPDATE_STATUS_FINALIZING)); |
+ EXPECT_STREQ("UPDATE_STATUS_UPDATED_NEED_REBOOT", |
+ UpdateStatusToString(UPDATE_STATUS_UPDATED_NEED_REBOOT)); |
+ EXPECT_STREQ("UPDATE_STATUS_REPORTING_ERROR_EVENT", |
+ UpdateStatusToString(UPDATE_STATUS_REPORTING_ERROR_EVENT)); |
+ EXPECT_STREQ("unknown status", |
+ UpdateStatusToString(static_cast<UpdateStatus>(-1))); |
+} |
+ |
+TEST_F(UpdateAttempterTest, UpdateTest) { |
+ attempter_.set_http_response_code(200); |
+ InSequence s; |
+ const string kActionTypes[] = { |
+ OmahaRequestAction::StaticType(), |
+ OmahaResponseHandlerAction::StaticType(), |
+ FilesystemCopierAction::StaticType(), |
+ FilesystemCopierAction::StaticType(), |
+ OmahaRequestAction::StaticType(), |
+ DownloadAction::StaticType(), |
+ OmahaRequestAction::StaticType(), |
+ PostinstallRunnerAction::StaticType(), |
+ SetBootableFlagAction::StaticType(), |
+ PostinstallRunnerAction::StaticType(), |
+ OmahaRequestAction::StaticType() |
+ }; |
+ for (size_t i = 0; i < arraysize(kActionTypes); ++i) { |
+ EXPECT_CALL(*processor_, |
+ EnqueueAction(Property(&AbstractAction::Type, |
+ kActionTypes[i]))).Times(1); |
+ } |
+ EXPECT_CALL(*processor_, StartProcessing()).Times(1); |
+ |
+ attempter_.Update("", ""); |
+ |
+ EXPECT_EQ(0, attempter_.http_response_code()); |
+ EXPECT_EQ(&attempter_, processor_->delegate()); |
+ EXPECT_EQ(arraysize(kActionTypes), attempter_.actions_.size()); |
+ for (size_t i = 0; i < arraysize(kActionTypes); ++i) { |
+ EXPECT_EQ(kActionTypes[i], attempter_.actions_[i]->Type()); |
+ } |
+ EXPECT_EQ(attempter_.response_handler_action_.get(), |
+ attempter_.actions_[1].get()); |
+ DownloadAction* download_action = |
+ dynamic_cast<DownloadAction*>(attempter_.actions_[5].get()); |
+ ASSERT_TRUE(download_action != NULL); |
+ EXPECT_EQ(&attempter_, download_action->delegate()); |
+ EXPECT_EQ(UPDATE_STATUS_CHECKING_FOR_UPDATE, attempter_.status()); |
+} |
+ |
+} // namespace chromeos_update_engine |