Darin Petkov | 18c7bce | 2011-06-16 14:07:00 -0700 | [diff] [blame] | 1 | // Copyright (c) 2011 The Chromium OS Authors. All rights reserved. |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | #include <base/file_util.h> |
| 6 | #include <gtest/gtest.h> |
Patrick Dubroy | 7fbbe8a | 2011-08-01 17:28:22 +0200 | [diff] [blame] | 7 | #include <policy/libpolicy.h> |
| 8 | #include <policy/mock_device_policy.h> |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 9 | |
| 10 | #include "update_engine/action_mock.h" |
| 11 | #include "update_engine/action_processor_mock.h" |
| 12 | #include "update_engine/filesystem_copier_action.h" |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 13 | #include "update_engine/mock_dbus_interface.h" |
Darin Petkov | 1b00310 | 2010-11-30 10:18:36 -0800 | [diff] [blame] | 14 | #include "update_engine/mock_http_fetcher.h" |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 15 | #include "update_engine/postinstall_runner_action.h" |
Darin Petkov | 3627577 | 2010-10-01 11:40:57 -0700 | [diff] [blame] | 16 | #include "update_engine/prefs_mock.h" |
Darin Petkov | 1b00310 | 2010-11-30 10:18:36 -0800 | [diff] [blame] | 17 | #include "update_engine/test_utils.h" |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 18 | #include "update_engine/update_attempter.h" |
Darin Petkov | 1b00310 | 2010-11-30 10:18:36 -0800 | [diff] [blame] | 19 | #include "update_engine/update_check_scheduler.h" |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 20 | |
| 21 | using std::string; |
Darin Petkov | 3627577 | 2010-10-01 11:40:57 -0700 | [diff] [blame] | 22 | using testing::_; |
| 23 | using testing::DoAll; |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 24 | using testing::InSequence; |
Darin Petkov | 2dd0109 | 2010-10-08 15:43:05 -0700 | [diff] [blame] | 25 | using testing::Ne; |
Darin Petkov | 9c096d6 | 2010-11-17 14:49:04 -0800 | [diff] [blame] | 26 | using testing::NiceMock; |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 27 | using testing::Property; |
| 28 | using testing::Return; |
Darin Petkov | 3627577 | 2010-10-01 11:40:57 -0700 | [diff] [blame] | 29 | using testing::SetArgumentPointee; |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 30 | |
| 31 | namespace chromeos_update_engine { |
| 32 | |
| 33 | // Test a subclass rather than the main class directly so that we can mock out |
Darin Petkov | cd1666f | 2010-09-23 09:53:44 -0700 | [diff] [blame] | 34 | // methods within the class. There're explicit unit tests for the mocked out |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 35 | // methods. |
| 36 | class UpdateAttempterUnderTest : public UpdateAttempter { |
| 37 | public: |
Andrew de los Reyes | 000d895 | 2011-03-02 15:21:14 -0800 | [diff] [blame] | 38 | explicit UpdateAttempterUnderTest(MockDbusGlib* dbus) |
| 39 | : UpdateAttempter(NULL, NULL, dbus) {} |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 40 | }; |
| 41 | |
| 42 | class UpdateAttempterTest : public ::testing::Test { |
| 43 | protected: |
Darin Petkov | e6ef2f8 | 2011-03-07 17:31:11 -0800 | [diff] [blame] | 44 | UpdateAttempterTest() : attempter_(&dbus_), loop_(NULL) {} |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 45 | virtual void SetUp() { |
| 46 | EXPECT_EQ(NULL, attempter_.dbus_service_); |
| 47 | EXPECT_EQ(NULL, attempter_.prefs_); |
| 48 | EXPECT_EQ(NULL, attempter_.metrics_lib_); |
| 49 | EXPECT_EQ(NULL, attempter_.update_check_scheduler_); |
| 50 | EXPECT_EQ(0, attempter_.http_response_code_); |
| 51 | EXPECT_EQ(utils::kProcessPriorityNormal, attempter_.priority_); |
| 52 | EXPECT_EQ(NULL, attempter_.manage_priority_source_); |
| 53 | EXPECT_FALSE(attempter_.download_active_); |
| 54 | EXPECT_EQ(UPDATE_STATUS_IDLE, attempter_.status_); |
| 55 | EXPECT_EQ(0.0, attempter_.download_progress_); |
| 56 | EXPECT_EQ(0, attempter_.last_checked_time_); |
| 57 | EXPECT_EQ("0.0.0.0", attempter_.new_version_); |
| 58 | EXPECT_EQ(0, attempter_.new_size_); |
| 59 | processor_ = new ActionProcessorMock(); |
| 60 | attempter_.processor_.reset(processor_); // Transfers ownership. |
Darin Petkov | 3627577 | 2010-10-01 11:40:57 -0700 | [diff] [blame] | 61 | attempter_.prefs_ = &prefs_; |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 62 | } |
| 63 | |
Patrick Dubroy | 7fbbe8a | 2011-08-01 17:28:22 +0200 | [diff] [blame] | 64 | void QuitMainLoop(); |
| 65 | static gboolean StaticQuitMainLoop(gpointer data); |
| 66 | |
Darin Petkov | e6ef2f8 | 2011-03-07 17:31:11 -0800 | [diff] [blame] | 67 | void UpdateTestStart(); |
| 68 | void UpdateTestVerify(); |
| 69 | static gboolean StaticUpdateTestStart(gpointer data); |
| 70 | static gboolean StaticUpdateTestVerify(gpointer data); |
Patrick Dubroy | 7fbbe8a | 2011-08-01 17:28:22 +0200 | [diff] [blame] | 71 | |
Thieu Le | 116fda3 | 2011-04-19 11:01:54 -0700 | [diff] [blame] | 72 | void PingOmahaTestStart(); |
Thieu Le | 116fda3 | 2011-04-19 11:01:54 -0700 | [diff] [blame] | 73 | static gboolean StaticPingOmahaTestStart(gpointer data); |
Patrick Dubroy | 7fbbe8a | 2011-08-01 17:28:22 +0200 | [diff] [blame] | 74 | |
| 75 | void ReadTrackFromPolicyTestStart(); |
| 76 | static gboolean StaticReadTrackFromPolicyTestStart(gpointer data); |
Darin Petkov | e6ef2f8 | 2011-03-07 17:31:11 -0800 | [diff] [blame] | 77 | |
Jay Srinivasan | 0a70874 | 2012-03-20 11:26:12 -0700 | [diff] [blame] | 78 | void ReadUpdateDisabledFromPolicyTestStart(); |
| 79 | static gboolean StaticReadUpdateDisabledFromPolicyTestStart(gpointer data); |
| 80 | |
| 81 | void ReadTargetVersionPrefixFromPolicyTestStart(); |
| 82 | static gboolean StaticReadTargetVersionPrefixFromPolicyTestStart( |
| 83 | gpointer data); |
| 84 | |
Andrew de los Reyes | 000d895 | 2011-03-02 15:21:14 -0800 | [diff] [blame] | 85 | MockDbusGlib dbus_; |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 86 | UpdateAttempterUnderTest attempter_; |
| 87 | ActionProcessorMock* processor_; |
Darin Petkov | 9c096d6 | 2010-11-17 14:49:04 -0800 | [diff] [blame] | 88 | NiceMock<PrefsMock> prefs_; |
Darin Petkov | e6ef2f8 | 2011-03-07 17:31:11 -0800 | [diff] [blame] | 89 | GMainLoop* loop_; |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 90 | }; |
| 91 | |
Darin Petkov | 1b00310 | 2010-11-30 10:18:36 -0800 | [diff] [blame] | 92 | TEST_F(UpdateAttempterTest, ActionCompletedDownloadTest) { |
| 93 | scoped_ptr<MockHttpFetcher> fetcher(new MockHttpFetcher("", 0, NULL)); |
| 94 | fetcher->FailTransfer(503); // Sets the HTTP response code. |
| 95 | DownloadAction action(&prefs_, fetcher.release()); |
| 96 | EXPECT_CALL(prefs_, GetInt64(kPrefsDeltaUpdateFailures, _)).Times(0); |
| 97 | attempter_.ActionCompleted(NULL, &action, kActionCodeSuccess); |
| 98 | EXPECT_EQ(503, attempter_.http_response_code()); |
| 99 | EXPECT_EQ(UPDATE_STATUS_FINALIZING, attempter_.status()); |
| 100 | ASSERT_TRUE(attempter_.error_event_.get() == NULL); |
| 101 | } |
| 102 | |
| 103 | TEST_F(UpdateAttempterTest, ActionCompletedErrorTest) { |
| 104 | ActionMock action; |
| 105 | EXPECT_CALL(action, Type()).WillRepeatedly(Return("ActionMock")); |
| 106 | attempter_.status_ = UPDATE_STATUS_DOWNLOADING; |
| 107 | EXPECT_CALL(prefs_, GetInt64(kPrefsDeltaUpdateFailures, _)) |
| 108 | .WillOnce(Return(false)); |
| 109 | attempter_.ActionCompleted(NULL, &action, kActionCodeError); |
| 110 | ASSERT_TRUE(attempter_.error_event_.get() != NULL); |
| 111 | } |
| 112 | |
| 113 | TEST_F(UpdateAttempterTest, ActionCompletedOmahaRequestTest) { |
| 114 | scoped_ptr<MockHttpFetcher> fetcher(new MockHttpFetcher("", 0, NULL)); |
| 115 | fetcher->FailTransfer(500); // Sets the HTTP response code. |
| 116 | OmahaRequestParams params; |
Thieu Le | 116fda3 | 2011-04-19 11:01:54 -0700 | [diff] [blame] | 117 | OmahaRequestAction action(&prefs_, params, NULL, fetcher.release(), false); |
Darin Petkov | 1b00310 | 2010-11-30 10:18:36 -0800 | [diff] [blame] | 118 | ObjectCollectorAction<OmahaResponse> collector_action; |
| 119 | BondActions(&action, &collector_action); |
| 120 | OmahaResponse response; |
| 121 | response.poll_interval = 234; |
| 122 | action.SetOutputObject(response); |
| 123 | UpdateCheckScheduler scheduler(&attempter_); |
| 124 | attempter_.set_update_check_scheduler(&scheduler); |
| 125 | EXPECT_CALL(prefs_, GetInt64(kPrefsDeltaUpdateFailures, _)).Times(0); |
| 126 | attempter_.ActionCompleted(NULL, &action, kActionCodeSuccess); |
| 127 | EXPECT_EQ(500, attempter_.http_response_code()); |
| 128 | EXPECT_EQ(UPDATE_STATUS_IDLE, attempter_.status()); |
| 129 | EXPECT_EQ(234, scheduler.poll_interval()); |
| 130 | ASSERT_TRUE(attempter_.error_event_.get() == NULL); |
| 131 | } |
| 132 | |
Darin Petkov | cd1666f | 2010-09-23 09:53:44 -0700 | [diff] [blame] | 133 | TEST_F(UpdateAttempterTest, RunAsRootConstructWithUpdatedMarkerTest) { |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 134 | extern const char* kUpdateCompletedMarker; |
| 135 | const FilePath kMarker(kUpdateCompletedMarker); |
| 136 | EXPECT_EQ(0, file_util::WriteFile(kMarker, "", 0)); |
Andrew de los Reyes | 000d895 | 2011-03-02 15:21:14 -0800 | [diff] [blame] | 137 | MockDbusGlib dbus; |
| 138 | UpdateAttempterUnderTest attempter(&dbus); |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 139 | EXPECT_EQ(UPDATE_STATUS_UPDATED_NEED_REBOOT, attempter.status()); |
| 140 | EXPECT_TRUE(file_util::Delete(kMarker, false)); |
| 141 | } |
| 142 | |
| 143 | TEST_F(UpdateAttempterTest, GetErrorCodeForActionTest) { |
| 144 | extern ActionExitCode GetErrorCodeForAction(AbstractAction* action, |
| 145 | ActionExitCode code); |
| 146 | EXPECT_EQ(kActionCodeSuccess, |
| 147 | GetErrorCodeForAction(NULL, kActionCodeSuccess)); |
| 148 | |
| 149 | OmahaRequestParams params; |
Thieu Le | 116fda3 | 2011-04-19 11:01:54 -0700 | [diff] [blame] | 150 | OmahaRequestAction omaha_request_action(NULL, params, NULL, NULL, false); |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 151 | EXPECT_EQ(kActionCodeOmahaRequestError, |
| 152 | GetErrorCodeForAction(&omaha_request_action, kActionCodeError)); |
Darin Petkov | 73058b4 | 2010-10-06 16:32:19 -0700 | [diff] [blame] | 153 | OmahaResponseHandlerAction omaha_response_handler_action(&prefs_); |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 154 | EXPECT_EQ(kActionCodeOmahaResponseHandlerError, |
| 155 | GetErrorCodeForAction(&omaha_response_handler_action, |
| 156 | kActionCodeError)); |
Darin Petkov | 3aefa86 | 2010-12-07 14:45:00 -0800 | [diff] [blame] | 157 | FilesystemCopierAction filesystem_copier_action(false, false); |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 158 | EXPECT_EQ(kActionCodeFilesystemCopierError, |
| 159 | GetErrorCodeForAction(&filesystem_copier_action, kActionCodeError)); |
Darin Petkov | 6d5dbf6 | 2010-11-08 16:09:55 -0800 | [diff] [blame] | 160 | PostinstallRunnerAction postinstall_runner_action; |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 161 | EXPECT_EQ(kActionCodePostinstallRunnerError, |
| 162 | GetErrorCodeForAction(&postinstall_runner_action, |
| 163 | kActionCodeError)); |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 164 | ActionMock action_mock; |
| 165 | EXPECT_CALL(action_mock, Type()).Times(1).WillOnce(Return("ActionMock")); |
| 166 | EXPECT_EQ(kActionCodeError, |
| 167 | GetErrorCodeForAction(&action_mock, kActionCodeError)); |
| 168 | } |
| 169 | |
Darin Petkov | 3627577 | 2010-10-01 11:40:57 -0700 | [diff] [blame] | 170 | TEST_F(UpdateAttempterTest, DisableDeltaUpdateIfNeededTest) { |
| 171 | attempter_.omaha_request_params_.delta_okay = true; |
| 172 | EXPECT_CALL(prefs_, GetInt64(kPrefsDeltaUpdateFailures, _)) |
| 173 | .WillOnce(Return(false)); |
| 174 | attempter_.DisableDeltaUpdateIfNeeded(); |
| 175 | EXPECT_TRUE(attempter_.omaha_request_params_.delta_okay); |
| 176 | EXPECT_CALL(prefs_, GetInt64(kPrefsDeltaUpdateFailures, _)) |
| 177 | .WillOnce(DoAll( |
| 178 | SetArgumentPointee<1>(UpdateAttempter::kMaxDeltaUpdateFailures - 1), |
| 179 | Return(true))); |
| 180 | attempter_.DisableDeltaUpdateIfNeeded(); |
| 181 | EXPECT_TRUE(attempter_.omaha_request_params_.delta_okay); |
| 182 | EXPECT_CALL(prefs_, GetInt64(kPrefsDeltaUpdateFailures, _)) |
| 183 | .WillOnce(DoAll( |
| 184 | SetArgumentPointee<1>(UpdateAttempter::kMaxDeltaUpdateFailures), |
| 185 | Return(true))); |
| 186 | attempter_.DisableDeltaUpdateIfNeeded(); |
| 187 | EXPECT_FALSE(attempter_.omaha_request_params_.delta_okay); |
| 188 | EXPECT_CALL(prefs_, GetInt64(_, _)).Times(0); |
| 189 | attempter_.DisableDeltaUpdateIfNeeded(); |
| 190 | EXPECT_FALSE(attempter_.omaha_request_params_.delta_okay); |
| 191 | } |
| 192 | |
| 193 | TEST_F(UpdateAttempterTest, MarkDeltaUpdateFailureTest) { |
Darin Petkov | 3627577 | 2010-10-01 11:40:57 -0700 | [diff] [blame] | 194 | EXPECT_CALL(prefs_, GetInt64(kPrefsDeltaUpdateFailures, _)) |
| 195 | .WillOnce(Return(false)) |
| 196 | .WillOnce(DoAll(SetArgumentPointee<1>(-1), Return(true))) |
| 197 | .WillOnce(DoAll(SetArgumentPointee<1>(1), Return(true))) |
| 198 | .WillOnce(DoAll( |
| 199 | SetArgumentPointee<1>(UpdateAttempter::kMaxDeltaUpdateFailures), |
| 200 | Return(true))); |
Darin Petkov | 2dd0109 | 2010-10-08 15:43:05 -0700 | [diff] [blame] | 201 | EXPECT_CALL(prefs_, SetInt64(Ne(kPrefsDeltaUpdateFailures), _)) |
| 202 | .WillRepeatedly(Return(true)); |
Darin Petkov | 3627577 | 2010-10-01 11:40:57 -0700 | [diff] [blame] | 203 | EXPECT_CALL(prefs_, SetInt64(kPrefsDeltaUpdateFailures, 1)).Times(2); |
| 204 | EXPECT_CALL(prefs_, SetInt64(kPrefsDeltaUpdateFailures, 2)).Times(1); |
| 205 | EXPECT_CALL(prefs_, SetInt64(kPrefsDeltaUpdateFailures, |
| 206 | UpdateAttempter::kMaxDeltaUpdateFailures + 1)) |
| 207 | .Times(1); |
| 208 | for (int i = 0; i < 4; i ++) |
| 209 | attempter_.MarkDeltaUpdateFailure(); |
| 210 | } |
| 211 | |
Darin Petkov | 1b00310 | 2010-11-30 10:18:36 -0800 | [diff] [blame] | 212 | TEST_F(UpdateAttempterTest, ScheduleErrorEventActionNoEventTest) { |
| 213 | EXPECT_CALL(*processor_, EnqueueAction(_)).Times(0); |
| 214 | EXPECT_CALL(*processor_, StartProcessing()).Times(0); |
| 215 | attempter_.ScheduleErrorEventAction(); |
| 216 | } |
| 217 | |
| 218 | TEST_F(UpdateAttempterTest, ScheduleErrorEventActionTest) { |
| 219 | EXPECT_CALL(*processor_, |
| 220 | EnqueueAction(Property(&AbstractAction::Type, |
| 221 | OmahaRequestAction::StaticType()))) |
| 222 | .Times(1); |
| 223 | EXPECT_CALL(*processor_, StartProcessing()).Times(1); |
| 224 | attempter_.error_event_.reset(new OmahaEvent(OmahaEvent::kTypeUpdateComplete, |
| 225 | OmahaEvent::kResultError, |
| 226 | kActionCodeError)); |
| 227 | attempter_.ScheduleErrorEventAction(); |
| 228 | EXPECT_EQ(UPDATE_STATUS_REPORTING_ERROR_EVENT, attempter_.status()); |
| 229 | } |
| 230 | |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 231 | TEST_F(UpdateAttempterTest, UpdateStatusToStringTest) { |
| 232 | extern const char* UpdateStatusToString(UpdateStatus); |
| 233 | EXPECT_STREQ("UPDATE_STATUS_IDLE", UpdateStatusToString(UPDATE_STATUS_IDLE)); |
| 234 | EXPECT_STREQ("UPDATE_STATUS_CHECKING_FOR_UPDATE", |
| 235 | UpdateStatusToString(UPDATE_STATUS_CHECKING_FOR_UPDATE)); |
| 236 | EXPECT_STREQ("UPDATE_STATUS_UPDATE_AVAILABLE", |
| 237 | UpdateStatusToString(UPDATE_STATUS_UPDATE_AVAILABLE)); |
| 238 | EXPECT_STREQ("UPDATE_STATUS_DOWNLOADING", |
| 239 | UpdateStatusToString(UPDATE_STATUS_DOWNLOADING)); |
| 240 | EXPECT_STREQ("UPDATE_STATUS_VERIFYING", |
| 241 | UpdateStatusToString(UPDATE_STATUS_VERIFYING)); |
| 242 | EXPECT_STREQ("UPDATE_STATUS_FINALIZING", |
| 243 | UpdateStatusToString(UPDATE_STATUS_FINALIZING)); |
| 244 | EXPECT_STREQ("UPDATE_STATUS_UPDATED_NEED_REBOOT", |
| 245 | UpdateStatusToString(UPDATE_STATUS_UPDATED_NEED_REBOOT)); |
| 246 | EXPECT_STREQ("UPDATE_STATUS_REPORTING_ERROR_EVENT", |
| 247 | UpdateStatusToString(UPDATE_STATUS_REPORTING_ERROR_EVENT)); |
| 248 | EXPECT_STREQ("unknown status", |
| 249 | UpdateStatusToString(static_cast<UpdateStatus>(-1))); |
| 250 | } |
| 251 | |
Patrick Dubroy | 7fbbe8a | 2011-08-01 17:28:22 +0200 | [diff] [blame] | 252 | void UpdateAttempterTest::QuitMainLoop() { |
| 253 | g_main_loop_quit(loop_); |
| 254 | } |
| 255 | |
| 256 | gboolean UpdateAttempterTest::StaticQuitMainLoop(gpointer data) { |
| 257 | reinterpret_cast<UpdateAttempterTest*>(data)->QuitMainLoop(); |
| 258 | return FALSE; |
| 259 | } |
| 260 | |
Darin Petkov | e6ef2f8 | 2011-03-07 17:31:11 -0800 | [diff] [blame] | 261 | gboolean UpdateAttempterTest::StaticUpdateTestStart(gpointer data) { |
| 262 | reinterpret_cast<UpdateAttempterTest*>(data)->UpdateTestStart(); |
| 263 | return FALSE; |
| 264 | } |
| 265 | |
| 266 | gboolean UpdateAttempterTest::StaticUpdateTestVerify(gpointer data) { |
| 267 | reinterpret_cast<UpdateAttempterTest*>(data)->UpdateTestVerify(); |
| 268 | return FALSE; |
| 269 | } |
| 270 | |
Thieu Le | 116fda3 | 2011-04-19 11:01:54 -0700 | [diff] [blame] | 271 | gboolean UpdateAttempterTest::StaticPingOmahaTestStart(gpointer data) { |
| 272 | reinterpret_cast<UpdateAttempterTest*>(data)->PingOmahaTestStart(); |
| 273 | return FALSE; |
| 274 | } |
| 275 | |
Patrick Dubroy | 7fbbe8a | 2011-08-01 17:28:22 +0200 | [diff] [blame] | 276 | gboolean UpdateAttempterTest::StaticReadTrackFromPolicyTestStart( |
| 277 | gpointer data) { |
| 278 | reinterpret_cast<UpdateAttempterTest*>(data)->ReadTrackFromPolicyTestStart(); |
Thieu Le | 116fda3 | 2011-04-19 11:01:54 -0700 | [diff] [blame] | 279 | return FALSE; |
| 280 | } |
| 281 | |
Jay Srinivasan | 0a70874 | 2012-03-20 11:26:12 -0700 | [diff] [blame] | 282 | gboolean UpdateAttempterTest::StaticReadUpdateDisabledFromPolicyTestStart( |
| 283 | gpointer data) { |
| 284 | UpdateAttempterTest* ua_test = reinterpret_cast<UpdateAttempterTest*>(data); |
| 285 | ua_test->ReadUpdateDisabledFromPolicyTestStart(); |
| 286 | return FALSE; |
| 287 | } |
| 288 | |
| 289 | gboolean UpdateAttempterTest::StaticReadTargetVersionPrefixFromPolicyTestStart( |
| 290 | gpointer data) { |
| 291 | UpdateAttempterTest* ua_test = reinterpret_cast<UpdateAttempterTest*>(data); |
| 292 | ua_test->ReadTargetVersionPrefixFromPolicyTestStart(); |
| 293 | return FALSE; |
| 294 | } |
| 295 | |
Darin Petkov | e6ef2f8 | 2011-03-07 17:31:11 -0800 | [diff] [blame] | 296 | namespace { |
| 297 | const string kActionTypes[] = { |
| 298 | OmahaRequestAction::StaticType(), |
| 299 | OmahaResponseHandlerAction::StaticType(), |
| 300 | FilesystemCopierAction::StaticType(), |
| 301 | FilesystemCopierAction::StaticType(), |
| 302 | OmahaRequestAction::StaticType(), |
| 303 | DownloadAction::StaticType(), |
| 304 | OmahaRequestAction::StaticType(), |
| 305 | FilesystemCopierAction::StaticType(), |
| 306 | FilesystemCopierAction::StaticType(), |
| 307 | PostinstallRunnerAction::StaticType(), |
| 308 | OmahaRequestAction::StaticType() |
| 309 | }; |
| 310 | } // namespace {} |
| 311 | |
| 312 | void UpdateAttempterTest::UpdateTestStart() { |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 313 | attempter_.set_http_response_code(200); |
| 314 | InSequence s; |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 315 | for (size_t i = 0; i < arraysize(kActionTypes); ++i) { |
| 316 | EXPECT_CALL(*processor_, |
| 317 | EnqueueAction(Property(&AbstractAction::Type, |
| 318 | kActionTypes[i]))).Times(1); |
| 319 | } |
| 320 | EXPECT_CALL(*processor_, StartProcessing()).Times(1); |
| 321 | |
Gilad Arnold | 1ebd813 | 2012-03-05 10:19:29 -0800 | [diff] [blame] | 322 | attempter_.Update("", "", false, false, false); |
Darin Petkov | e6ef2f8 | 2011-03-07 17:31:11 -0800 | [diff] [blame] | 323 | g_idle_add(&StaticUpdateTestVerify, this); |
| 324 | } |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 325 | |
Darin Petkov | e6ef2f8 | 2011-03-07 17:31:11 -0800 | [diff] [blame] | 326 | void UpdateAttempterTest::UpdateTestVerify() { |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 327 | EXPECT_EQ(0, attempter_.http_response_code()); |
| 328 | EXPECT_EQ(&attempter_, processor_->delegate()); |
| 329 | EXPECT_EQ(arraysize(kActionTypes), attempter_.actions_.size()); |
| 330 | for (size_t i = 0; i < arraysize(kActionTypes); ++i) { |
| 331 | EXPECT_EQ(kActionTypes[i], attempter_.actions_[i]->Type()); |
| 332 | } |
| 333 | EXPECT_EQ(attempter_.response_handler_action_.get(), |
| 334 | attempter_.actions_[1].get()); |
| 335 | DownloadAction* download_action = |
| 336 | dynamic_cast<DownloadAction*>(attempter_.actions_[5].get()); |
| 337 | ASSERT_TRUE(download_action != NULL); |
| 338 | EXPECT_EQ(&attempter_, download_action->delegate()); |
| 339 | EXPECT_EQ(UPDATE_STATUS_CHECKING_FOR_UPDATE, attempter_.status()); |
Darin Petkov | e6ef2f8 | 2011-03-07 17:31:11 -0800 | [diff] [blame] | 340 | g_main_loop_quit(loop_); |
| 341 | } |
| 342 | |
| 343 | TEST_F(UpdateAttempterTest, UpdateTest) { |
| 344 | loop_ = g_main_loop_new(g_main_context_default(), FALSE); |
| 345 | g_idle_add(&StaticUpdateTestStart, this); |
| 346 | g_main_loop_run(loop_); |
| 347 | g_main_loop_unref(loop_); |
| 348 | loop_ = NULL; |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 349 | } |
| 350 | |
Thieu Le | 116fda3 | 2011-04-19 11:01:54 -0700 | [diff] [blame] | 351 | void UpdateAttempterTest::PingOmahaTestStart() { |
| 352 | EXPECT_CALL(*processor_, |
| 353 | EnqueueAction(Property(&AbstractAction::Type, |
| 354 | OmahaRequestAction::StaticType()))) |
| 355 | .Times(1); |
| 356 | EXPECT_CALL(*processor_, StartProcessing()).Times(1); |
| 357 | attempter_.PingOmaha(); |
Patrick Dubroy | 7fbbe8a | 2011-08-01 17:28:22 +0200 | [diff] [blame] | 358 | g_idle_add(&StaticQuitMainLoop, this); |
Thieu Le | 116fda3 | 2011-04-19 11:01:54 -0700 | [diff] [blame] | 359 | } |
| 360 | |
| 361 | TEST_F(UpdateAttempterTest, PingOmahaTest) { |
| 362 | UpdateCheckScheduler scheduler(&attempter_); |
| 363 | scheduler.enabled_ = true; |
Andrew de los Reyes | e05fc28 | 2011-06-02 09:50:08 -0700 | [diff] [blame] | 364 | EXPECT_FALSE(scheduler.scheduled_); |
Thieu Le | 116fda3 | 2011-04-19 11:01:54 -0700 | [diff] [blame] | 365 | attempter_.set_update_check_scheduler(&scheduler); |
| 366 | loop_ = g_main_loop_new(g_main_context_default(), FALSE); |
| 367 | g_idle_add(&StaticPingOmahaTestStart, this); |
| 368 | g_main_loop_run(loop_); |
| 369 | g_main_loop_unref(loop_); |
| 370 | loop_ = NULL; |
| 371 | EXPECT_EQ(UPDATE_STATUS_UPDATED_NEED_REBOOT, attempter_.status()); |
| 372 | EXPECT_EQ(true, scheduler.scheduled_); |
| 373 | } |
| 374 | |
Darin Petkov | 18c7bce | 2011-06-16 14:07:00 -0700 | [diff] [blame] | 375 | TEST_F(UpdateAttempterTest, CreatePendingErrorEventTest) { |
| 376 | ActionMock action; |
| 377 | const ActionExitCode kCode = kActionCodeDownloadTransferError; |
| 378 | attempter_.CreatePendingErrorEvent(&action, kCode); |
| 379 | ASSERT_TRUE(attempter_.error_event_.get() != NULL); |
| 380 | EXPECT_EQ(OmahaEvent::kTypeUpdateComplete, attempter_.error_event_->type); |
| 381 | EXPECT_EQ(OmahaEvent::kResultError, attempter_.error_event_->result); |
| 382 | EXPECT_EQ(kCode, attempter_.error_event_->error_code); |
| 383 | } |
| 384 | |
| 385 | TEST_F(UpdateAttempterTest, CreatePendingErrorEventResumedTest) { |
| 386 | OmahaResponseHandlerAction *response_action = |
| 387 | new OmahaResponseHandlerAction(&prefs_); |
| 388 | response_action->install_plan_.is_resume = true; |
| 389 | attempter_.response_handler_action_.reset(response_action); |
| 390 | ActionMock action; |
| 391 | const ActionExitCode kCode = kActionCodeInstallDeviceOpenError; |
| 392 | attempter_.CreatePendingErrorEvent(&action, kCode); |
| 393 | ASSERT_TRUE(attempter_.error_event_.get() != NULL); |
| 394 | EXPECT_EQ(OmahaEvent::kTypeUpdateComplete, attempter_.error_event_->type); |
| 395 | EXPECT_EQ(OmahaEvent::kResultError, attempter_.error_event_->result); |
| 396 | EXPECT_EQ(kCode | kActionCodeResumedFlag, |
| 397 | attempter_.error_event_->error_code); |
| 398 | } |
| 399 | |
Patrick Dubroy | 7fbbe8a | 2011-08-01 17:28:22 +0200 | [diff] [blame] | 400 | TEST_F(UpdateAttempterTest, ReadTrackFromPolicy) { |
| 401 | loop_ = g_main_loop_new(g_main_context_default(), FALSE); |
| 402 | g_idle_add(&StaticReadTrackFromPolicyTestStart, this); |
| 403 | g_main_loop_run(loop_); |
| 404 | g_main_loop_unref(loop_); |
| 405 | loop_ = NULL; |
| 406 | } |
| 407 | |
| 408 | void UpdateAttempterTest::ReadTrackFromPolicyTestStart() { |
| 409 | // Tests that the update track (aka release channel) is properly fetched |
| 410 | // from the device policy. |
| 411 | |
| 412 | policy::MockDevicePolicy* device_policy = new policy::MockDevicePolicy(); |
| 413 | attempter_.policy_provider_.reset(new policy::PolicyProvider(device_policy)); |
| 414 | |
| 415 | EXPECT_CALL(*device_policy, LoadPolicy()).WillRepeatedly(Return(true)); |
| 416 | |
| 417 | EXPECT_CALL(*device_policy, GetReleaseChannel(_)) |
| 418 | .WillRepeatedly(DoAll( |
| 419 | SetArgumentPointee<0>(std::string("canary-channel")), |
| 420 | Return(true))); |
| 421 | |
Gilad Arnold | 1ebd813 | 2012-03-05 10:19:29 -0800 | [diff] [blame] | 422 | attempter_.Update("", "", false, false, false); |
Patrick Dubroy | 7fbbe8a | 2011-08-01 17:28:22 +0200 | [diff] [blame] | 423 | EXPECT_EQ("canary-channel", attempter_.omaha_request_params_.app_track); |
| 424 | |
| 425 | g_idle_add(&StaticQuitMainLoop, this); |
| 426 | } |
| 427 | |
Jay Srinivasan | 0a70874 | 2012-03-20 11:26:12 -0700 | [diff] [blame] | 428 | TEST_F(UpdateAttempterTest, ReadUpdateDisabledFromPolicy) { |
| 429 | loop_ = g_main_loop_new(g_main_context_default(), FALSE); |
| 430 | g_idle_add(&StaticReadUpdateDisabledFromPolicyTestStart, this); |
| 431 | g_main_loop_run(loop_); |
| 432 | g_main_loop_unref(loop_); |
| 433 | loop_ = NULL; |
| 434 | } |
| 435 | |
| 436 | void UpdateAttempterTest::ReadUpdateDisabledFromPolicyTestStart() { |
| 437 | // Tests that the update_disbled flag is properly fetched |
| 438 | // from the device policy. |
| 439 | |
| 440 | policy::MockDevicePolicy* device_policy = new policy::MockDevicePolicy(); |
| 441 | attempter_.policy_provider_.reset(new policy::PolicyProvider(device_policy)); |
| 442 | |
| 443 | EXPECT_CALL(*device_policy, LoadPolicy()).WillRepeatedly(Return(true)); |
| 444 | |
| 445 | EXPECT_CALL(*device_policy, GetUpdateDisabled(_)) |
| 446 | .WillRepeatedly(DoAll( |
| 447 | SetArgumentPointee<0>(true), |
| 448 | Return(true))); |
| 449 | |
| 450 | attempter_.Update("", "", false, false, false); |
| 451 | EXPECT_TRUE(attempter_.omaha_request_params_.update_disabled); |
| 452 | |
| 453 | g_idle_add(&StaticQuitMainLoop, this); |
| 454 | } |
| 455 | |
| 456 | TEST_F(UpdateAttempterTest, ReadTargetVersionPrefixFromPolicy) { |
| 457 | loop_ = g_main_loop_new(g_main_context_default(), FALSE); |
| 458 | g_idle_add(&StaticReadTargetVersionPrefixFromPolicyTestStart, this); |
| 459 | g_main_loop_run(loop_); |
| 460 | g_main_loop_unref(loop_); |
| 461 | loop_ = NULL; |
| 462 | } |
| 463 | |
| 464 | void UpdateAttempterTest::ReadTargetVersionPrefixFromPolicyTestStart() { |
| 465 | // Tests that the target_version_prefix value is properly fetched |
| 466 | // from the device policy. |
| 467 | |
| 468 | const std::string target_version_prefix = "1412."; |
| 469 | |
| 470 | policy::MockDevicePolicy* device_policy = new policy::MockDevicePolicy(); |
| 471 | attempter_.policy_provider_.reset(new policy::PolicyProvider(device_policy)); |
| 472 | |
| 473 | EXPECT_CALL(*device_policy, LoadPolicy()).WillRepeatedly(Return(true)); |
| 474 | |
| 475 | EXPECT_CALL(*device_policy, GetTargetVersionPrefix(_)) |
| 476 | .WillRepeatedly(DoAll( |
| 477 | SetArgumentPointee<0>(target_version_prefix), |
| 478 | Return(true))); |
| 479 | |
| 480 | attempter_.Update("", "", false, false, false); |
| 481 | EXPECT_EQ(target_version_prefix.c_str(), |
| 482 | attempter_.omaha_request_params_.target_version_prefix); |
| 483 | |
| 484 | g_idle_add(&StaticQuitMainLoop, this); |
| 485 | } |
| 486 | |
| 487 | |
Darin Petkov | f42cc1c | 2010-09-01 09:03:02 -0700 | [diff] [blame] | 488 | } // namespace chromeos_update_engine |