1 //
2 // Copyright (C) 2014 The Android Open Source Project
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16
17 #include "update_engine/update_manager/real_updater_provider.h"
18
19 #include <memory>
20 #include <string>
21
22 #include <base/time/time.h>
23 #include <gtest/gtest.h>
24 #include <update_engine/dbus-constants.h>
25
26 #include "update_engine/common/fake_clock.h"
27 #include "update_engine/common/fake_prefs.h"
28 #include "update_engine/fake_system_state.h"
29 #include "update_engine/mock_update_attempter.h"
30 #include "update_engine/omaha_request_params.h"
31 #include "update_engine/update_manager/umtest_utils.h"
32
33 using base::Time;
34 using base::TimeDelta;
35 using chromeos_update_engine::FakeClock;
36 using chromeos_update_engine::FakePrefs;
37 using chromeos_update_engine::FakeSystemState;
38 using chromeos_update_engine::OmahaRequestParams;
39 using std::string;
40 using std::unique_ptr;
41 using testing::Return;
42 using testing::SetArgPointee;
43 using testing::_;
44
45 namespace {
46
47 // Generates a fixed timestamp for use in faking the current time.
FixedTime()48 Time FixedTime() {
49 Time::Exploded now_exp;
50 now_exp.year = 2014;
51 now_exp.month = 3;
52 now_exp.day_of_week = 2;
53 now_exp.day_of_month = 18;
54 now_exp.hour = 8;
55 now_exp.minute = 5;
56 now_exp.second = 33;
57 now_exp.millisecond = 675;
58 return Time::FromLocalExploded(now_exp);
59 }
60
61 // Rounds down a timestamp to the nearest second. This is useful when faking
62 // times that are converted to time_t (no sub-second resolution).
RoundedToSecond(Time time)63 Time RoundedToSecond(Time time) {
64 Time::Exploded exp;
65 time.LocalExplode(&exp);
66 exp.millisecond = 0;
67 return Time::FromLocalExploded(exp);
68 }
69
70 } // namespace
71
72 namespace chromeos_update_manager {
73
74 class UmRealUpdaterProviderTest : public ::testing::Test {
75 protected:
SetUp()76 void SetUp() override {
77 fake_clock_ = fake_sys_state_.fake_clock();
78 fake_sys_state_.set_prefs(&fake_prefs_);
79 provider_.reset(new RealUpdaterProvider(&fake_sys_state_));
80 ASSERT_NE(nullptr, provider_.get());
81 // Check that provider initializes correctly.
82 ASSERT_TRUE(provider_->Init());
83 }
84
85 // Sets up mock expectations for testing the update completed time reporting.
86 // |valid| determines whether the returned time is valid. Returns the expected
87 // update completed time value.
SetupUpdateCompletedTime(bool valid)88 Time SetupUpdateCompletedTime(bool valid) {
89 const TimeDelta kDurationSinceUpdate = TimeDelta::FromMinutes(7);
90 const Time kUpdateBootTime = Time() + kDurationSinceUpdate * 2;
91 const Time kCurrBootTime = (valid ?
92 kUpdateBootTime + kDurationSinceUpdate :
93 kUpdateBootTime - kDurationSinceUpdate);
94 const Time kCurrWallclockTime = FixedTime();
95 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
96 GetBootTimeAtUpdate(_))
97 .WillOnce(DoAll(SetArgPointee<0>(kUpdateBootTime), Return(true)));
98 fake_clock_->SetBootTime(kCurrBootTime);
99 fake_clock_->SetWallclockTime(kCurrWallclockTime);
100 return kCurrWallclockTime - kDurationSinceUpdate;
101 }
102
103 FakeSystemState fake_sys_state_;
104 FakeClock* fake_clock_; // Short for fake_sys_state_.fake_clock()
105 FakePrefs fake_prefs_;
106 unique_ptr<RealUpdaterProvider> provider_;
107 };
108
TEST_F(UmRealUpdaterProviderTest,UpdaterStartedTimeIsWallclockTime)109 TEST_F(UmRealUpdaterProviderTest, UpdaterStartedTimeIsWallclockTime) {
110 fake_clock_->SetWallclockTime(Time::FromDoubleT(123.456));
111 fake_clock_->SetMonotonicTime(Time::FromDoubleT(456.123));
112 // Run SetUp again to re-setup the provider under test to use these values.
113 SetUp();
114 UmTestUtils::ExpectVariableHasValue(Time::FromDoubleT(123.456),
115 provider_->var_updater_started_time());
116 }
117
TEST_F(UmRealUpdaterProviderTest,GetLastCheckedTimeOkay)118 TEST_F(UmRealUpdaterProviderTest, GetLastCheckedTimeOkay) {
119 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
120 GetStatus(_, _, _, _, _))
121 .WillOnce(DoAll(SetArgPointee<0>(FixedTime().ToTimeT()), Return(true)));
122 UmTestUtils::ExpectVariableHasValue(RoundedToSecond(FixedTime()),
123 provider_->var_last_checked_time());
124 }
125
TEST_F(UmRealUpdaterProviderTest,GetLastCheckedTimeFailNoValue)126 TEST_F(UmRealUpdaterProviderTest, GetLastCheckedTimeFailNoValue) {
127 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
128 GetStatus(_, _, _, _, _))
129 .WillOnce(Return(false));
130 UmTestUtils::ExpectVariableNotSet(provider_->var_last_checked_time());
131 }
132
TEST_F(UmRealUpdaterProviderTest,GetProgressOkayMin)133 TEST_F(UmRealUpdaterProviderTest, GetProgressOkayMin) {
134 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
135 GetStatus(_, _, _, _, _))
136 .WillOnce(DoAll(SetArgPointee<1>(0.0), Return(true)));
137 UmTestUtils::ExpectVariableHasValue(0.0, provider_->var_progress());
138 }
139
TEST_F(UmRealUpdaterProviderTest,GetProgressOkayMid)140 TEST_F(UmRealUpdaterProviderTest, GetProgressOkayMid) {
141 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
142 GetStatus(_, _, _, _, _))
143 .WillOnce(DoAll(SetArgPointee<1>(0.3), Return(true)));
144 UmTestUtils::ExpectVariableHasValue(0.3, provider_->var_progress());
145 }
146
TEST_F(UmRealUpdaterProviderTest,GetProgressOkayMax)147 TEST_F(UmRealUpdaterProviderTest, GetProgressOkayMax) {
148 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
149 GetStatus(_, _, _, _, _))
150 .WillOnce(DoAll(SetArgPointee<1>(1.0), Return(true)));
151 UmTestUtils::ExpectVariableHasValue(1.0, provider_->var_progress());
152 }
153
TEST_F(UmRealUpdaterProviderTest,GetProgressFailNoValue)154 TEST_F(UmRealUpdaterProviderTest, GetProgressFailNoValue) {
155 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
156 GetStatus(_, _, _, _, _))
157 .WillOnce(Return(false));
158 UmTestUtils::ExpectVariableNotSet(provider_->var_progress());
159 }
160
TEST_F(UmRealUpdaterProviderTest,GetProgressFailTooSmall)161 TEST_F(UmRealUpdaterProviderTest, GetProgressFailTooSmall) {
162 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
163 GetStatus(_, _, _, _, _))
164 .WillOnce(DoAll(SetArgPointee<1>(-2.0), Return(true)));
165 UmTestUtils::ExpectVariableNotSet(provider_->var_progress());
166 }
167
TEST_F(UmRealUpdaterProviderTest,GetProgressFailTooBig)168 TEST_F(UmRealUpdaterProviderTest, GetProgressFailTooBig) {
169 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
170 GetStatus(_, _, _, _, _))
171 .WillOnce(DoAll(SetArgPointee<1>(2.0), Return(true)));
172 UmTestUtils::ExpectVariableNotSet(provider_->var_progress());
173 }
174
TEST_F(UmRealUpdaterProviderTest,GetStageOkayIdle)175 TEST_F(UmRealUpdaterProviderTest, GetStageOkayIdle) {
176 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
177 GetStatus(_, _, _, _, _))
178 .WillOnce(DoAll(SetArgPointee<2>(update_engine::kUpdateStatusIdle),
179 Return(true)));
180 UmTestUtils::ExpectVariableHasValue(Stage::kIdle, provider_->var_stage());
181 }
182
TEST_F(UmRealUpdaterProviderTest,GetStageOkayCheckingForUpdate)183 TEST_F(UmRealUpdaterProviderTest, GetStageOkayCheckingForUpdate) {
184 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
185 GetStatus(_, _, _, _, _))
186 .WillOnce(DoAll(
187 SetArgPointee<2>(update_engine::kUpdateStatusCheckingForUpdate),
188 Return(true)));
189 UmTestUtils::ExpectVariableHasValue(Stage::kCheckingForUpdate,
190 provider_->var_stage());
191 }
192
TEST_F(UmRealUpdaterProviderTest,GetStageOkayUpdateAvailable)193 TEST_F(UmRealUpdaterProviderTest, GetStageOkayUpdateAvailable) {
194 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
195 GetStatus(_, _, _, _, _))
196 .WillOnce(DoAll(
197 SetArgPointee<2>(update_engine::kUpdateStatusUpdateAvailable),
198 Return(true)));
199 UmTestUtils::ExpectVariableHasValue(Stage::kUpdateAvailable,
200 provider_->var_stage());
201 }
202
TEST_F(UmRealUpdaterProviderTest,GetStageOkayDownloading)203 TEST_F(UmRealUpdaterProviderTest, GetStageOkayDownloading) {
204 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
205 GetStatus(_, _, _, _, _))
206 .WillOnce(DoAll(SetArgPointee<2>(update_engine::kUpdateStatusDownloading),
207 Return(true)));
208 UmTestUtils::ExpectVariableHasValue(Stage::kDownloading,
209 provider_->var_stage());
210 }
211
TEST_F(UmRealUpdaterProviderTest,GetStageOkayVerifying)212 TEST_F(UmRealUpdaterProviderTest, GetStageOkayVerifying) {
213 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
214 GetStatus(_, _, _, _, _))
215 .WillOnce(DoAll(SetArgPointee<2>(update_engine::kUpdateStatusVerifying),
216 Return(true)));
217 UmTestUtils::ExpectVariableHasValue(Stage::kVerifying,
218 provider_->var_stage());
219 }
220
TEST_F(UmRealUpdaterProviderTest,GetStageOkayFinalizing)221 TEST_F(UmRealUpdaterProviderTest, GetStageOkayFinalizing) {
222 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
223 GetStatus(_, _, _, _, _))
224 .WillOnce(DoAll(SetArgPointee<2>(update_engine::kUpdateStatusFinalizing),
225 Return(true)));
226 UmTestUtils::ExpectVariableHasValue(Stage::kFinalizing,
227 provider_->var_stage());
228 }
229
TEST_F(UmRealUpdaterProviderTest,GetStageOkayUpdatedNeedReboot)230 TEST_F(UmRealUpdaterProviderTest, GetStageOkayUpdatedNeedReboot) {
231 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
232 GetStatus(_, _, _, _, _))
233 .WillOnce(DoAll(
234 SetArgPointee<2>(update_engine::kUpdateStatusUpdatedNeedReboot),
235 Return(true)));
236 UmTestUtils::ExpectVariableHasValue(Stage::kUpdatedNeedReboot,
237 provider_->var_stage());
238 }
239
TEST_F(UmRealUpdaterProviderTest,GetStageOkayReportingErrorEvent)240 TEST_F(UmRealUpdaterProviderTest, GetStageOkayReportingErrorEvent) {
241 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
242 GetStatus(_, _, _, _, _))
243 .WillOnce(DoAll(
244 SetArgPointee<2>(update_engine::kUpdateStatusReportingErrorEvent),
245 Return(true)));
246 UmTestUtils::ExpectVariableHasValue(Stage::kReportingErrorEvent,
247 provider_->var_stage());
248 }
249
TEST_F(UmRealUpdaterProviderTest,GetStageOkayAttemptingRollback)250 TEST_F(UmRealUpdaterProviderTest, GetStageOkayAttemptingRollback) {
251 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
252 GetStatus(_, _, _, _, _))
253 .WillOnce(DoAll(
254 SetArgPointee<2>(update_engine::kUpdateStatusAttemptingRollback),
255 Return(true)));
256 UmTestUtils::ExpectVariableHasValue(Stage::kAttemptingRollback,
257 provider_->var_stage());
258 }
259
TEST_F(UmRealUpdaterProviderTest,GetStageFailNoValue)260 TEST_F(UmRealUpdaterProviderTest, GetStageFailNoValue) {
261 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
262 GetStatus(_, _, _, _, _))
263 .WillOnce(Return(false));
264 UmTestUtils::ExpectVariableNotSet(provider_->var_stage());
265 }
266
TEST_F(UmRealUpdaterProviderTest,GetStageFailUnknown)267 TEST_F(UmRealUpdaterProviderTest, GetStageFailUnknown) {
268 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
269 GetStatus(_, _, _, _, _))
270 .WillOnce(DoAll(SetArgPointee<2>("FooUpdateEngineState"),
271 Return(true)));
272 UmTestUtils::ExpectVariableNotSet(provider_->var_stage());
273 }
274
TEST_F(UmRealUpdaterProviderTest,GetStageFailEmpty)275 TEST_F(UmRealUpdaterProviderTest, GetStageFailEmpty) {
276 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
277 GetStatus(_, _, _, _, _))
278 .WillOnce(DoAll(SetArgPointee<2>(""), Return(true)));
279 UmTestUtils::ExpectVariableNotSet(provider_->var_stage());
280 }
281
TEST_F(UmRealUpdaterProviderTest,GetNewVersionOkay)282 TEST_F(UmRealUpdaterProviderTest, GetNewVersionOkay) {
283 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
284 GetStatus(_, _, _, _, _))
285 .WillOnce(DoAll(SetArgPointee<3>("1.2.0"), Return(true)));
286 UmTestUtils::ExpectVariableHasValue(string("1.2.0"),
287 provider_->var_new_version());
288 }
289
TEST_F(UmRealUpdaterProviderTest,GetNewVersionFailNoValue)290 TEST_F(UmRealUpdaterProviderTest, GetNewVersionFailNoValue) {
291 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
292 GetStatus(_, _, _, _, _))
293 .WillOnce(Return(false));
294 UmTestUtils::ExpectVariableNotSet(provider_->var_new_version());
295 }
296
TEST_F(UmRealUpdaterProviderTest,GetPayloadSizeOkayZero)297 TEST_F(UmRealUpdaterProviderTest, GetPayloadSizeOkayZero) {
298 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
299 GetStatus(_, _, _, _, _))
300 .WillOnce(DoAll(SetArgPointee<4>(static_cast<int64_t>(0)), Return(true)));
301 UmTestUtils::ExpectVariableHasValue(static_cast<int64_t>(0),
302 provider_->var_payload_size());
303 }
304
TEST_F(UmRealUpdaterProviderTest,GetPayloadSizeOkayArbitrary)305 TEST_F(UmRealUpdaterProviderTest, GetPayloadSizeOkayArbitrary) {
306 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
307 GetStatus(_, _, _, _, _))
308 .WillOnce(DoAll(SetArgPointee<4>(static_cast<int64_t>(567890)),
309 Return(true)));
310 UmTestUtils::ExpectVariableHasValue(static_cast<int64_t>(567890),
311 provider_->var_payload_size());
312 }
313
TEST_F(UmRealUpdaterProviderTest,GetPayloadSizeOkayTwoGigabytes)314 TEST_F(UmRealUpdaterProviderTest, GetPayloadSizeOkayTwoGigabytes) {
315 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
316 GetStatus(_, _, _, _, _))
317 .WillOnce(DoAll(SetArgPointee<4>(static_cast<int64_t>(1) << 31),
318 Return(true)));
319 UmTestUtils::ExpectVariableHasValue(static_cast<int64_t>(1) << 31,
320 provider_->var_payload_size());
321 }
322
TEST_F(UmRealUpdaterProviderTest,GetPayloadSizeFailNoValue)323 TEST_F(UmRealUpdaterProviderTest, GetPayloadSizeFailNoValue) {
324 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
325 GetStatus(_, _, _, _, _))
326 .WillOnce(Return(false));
327 UmTestUtils::ExpectVariableNotSet(provider_->var_payload_size());
328 }
329
TEST_F(UmRealUpdaterProviderTest,GetPayloadSizeFailNegative)330 TEST_F(UmRealUpdaterProviderTest, GetPayloadSizeFailNegative) {
331 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
332 GetStatus(_, _, _, _, _))
333 .WillOnce(DoAll(SetArgPointee<4>(static_cast<int64_t>(-1024)),
334 Return(true)));
335 UmTestUtils::ExpectVariableNotSet(provider_->var_payload_size());
336 }
337
TEST_F(UmRealUpdaterProviderTest,GetCurrChannelOkay)338 TEST_F(UmRealUpdaterProviderTest, GetCurrChannelOkay) {
339 const string kChannelName("foo-channel");
340 OmahaRequestParams request_params(&fake_sys_state_);
341 request_params.Init("", "", false);
342 request_params.set_current_channel(kChannelName);
343 fake_sys_state_.set_request_params(&request_params);
344 UmTestUtils::ExpectVariableHasValue(kChannelName,
345 provider_->var_curr_channel());
346 }
347
TEST_F(UmRealUpdaterProviderTest,GetCurrChannelFailEmpty)348 TEST_F(UmRealUpdaterProviderTest, GetCurrChannelFailEmpty) {
349 OmahaRequestParams request_params(&fake_sys_state_);
350 request_params.Init("", "", false);
351 request_params.set_current_channel("");
352 fake_sys_state_.set_request_params(&request_params);
353 UmTestUtils::ExpectVariableNotSet(provider_->var_curr_channel());
354 }
355
TEST_F(UmRealUpdaterProviderTest,GetNewChannelOkay)356 TEST_F(UmRealUpdaterProviderTest, GetNewChannelOkay) {
357 const string kChannelName("foo-channel");
358 OmahaRequestParams request_params(&fake_sys_state_);
359 request_params.Init("", "", false);
360 request_params.set_target_channel(kChannelName);
361 fake_sys_state_.set_request_params(&request_params);
362 UmTestUtils::ExpectVariableHasValue(kChannelName,
363 provider_->var_new_channel());
364 }
365
TEST_F(UmRealUpdaterProviderTest,GetNewChannelFailEmpty)366 TEST_F(UmRealUpdaterProviderTest, GetNewChannelFailEmpty) {
367 OmahaRequestParams request_params(&fake_sys_state_);
368 request_params.Init("", "", false);
369 request_params.set_target_channel("");
370 fake_sys_state_.set_request_params(&request_params);
371 UmTestUtils::ExpectVariableNotSet(provider_->var_new_channel());
372 }
373
TEST_F(UmRealUpdaterProviderTest,GetP2PEnabledOkayPrefDoesntExist)374 TEST_F(UmRealUpdaterProviderTest, GetP2PEnabledOkayPrefDoesntExist) {
375 UmTestUtils::ExpectVariableHasValue(false, provider_->var_p2p_enabled());
376 }
377
TEST_F(UmRealUpdaterProviderTest,GetP2PEnabledOkayPrefReadsFalse)378 TEST_F(UmRealUpdaterProviderTest, GetP2PEnabledOkayPrefReadsFalse) {
379 fake_prefs_.SetBoolean(chromeos_update_engine::kPrefsP2PEnabled, false);
380 UmTestUtils::ExpectVariableHasValue(false, provider_->var_p2p_enabled());
381 }
382
TEST_F(UmRealUpdaterProviderTest,GetP2PEnabledReadWhenInitialized)383 TEST_F(UmRealUpdaterProviderTest, GetP2PEnabledReadWhenInitialized) {
384 fake_prefs_.SetBoolean(chromeos_update_engine::kPrefsP2PEnabled, true);
385 SetUp();
386 UmTestUtils::ExpectVariableHasValue(true, provider_->var_p2p_enabled());
387 }
388
TEST_F(UmRealUpdaterProviderTest,GetP2PEnabledUpdated)389 TEST_F(UmRealUpdaterProviderTest, GetP2PEnabledUpdated) {
390 fake_prefs_.SetBoolean(chromeos_update_engine::kPrefsP2PEnabled, false);
391 UmTestUtils::ExpectVariableHasValue(false, provider_->var_p2p_enabled());
392 fake_prefs_.SetBoolean(chromeos_update_engine::kPrefsP2PEnabled, true);
393 UmTestUtils::ExpectVariableHasValue(true, provider_->var_p2p_enabled());
394 fake_prefs_.Delete(chromeos_update_engine::kPrefsP2PEnabled);
395 UmTestUtils::ExpectVariableHasValue(false, provider_->var_p2p_enabled());
396 }
397
TEST_F(UmRealUpdaterProviderTest,GetCellularEnabledOkayPrefDoesntExist)398 TEST_F(UmRealUpdaterProviderTest, GetCellularEnabledOkayPrefDoesntExist) {
399 UmTestUtils::ExpectVariableHasValue(false, provider_->var_cellular_enabled());
400 }
401
TEST_F(UmRealUpdaterProviderTest,GetCellularEnabledOkayPrefReadsTrue)402 TEST_F(UmRealUpdaterProviderTest, GetCellularEnabledOkayPrefReadsTrue) {
403 fake_prefs_.SetBoolean(
404 chromeos_update_engine::kPrefsUpdateOverCellularPermission, true);
405 UmTestUtils::ExpectVariableHasValue(true, provider_->var_cellular_enabled());
406 }
407
TEST_F(UmRealUpdaterProviderTest,GetUpdateCompletedTimeOkay)408 TEST_F(UmRealUpdaterProviderTest, GetUpdateCompletedTimeOkay) {
409 Time expected = SetupUpdateCompletedTime(true);
410 UmTestUtils::ExpectVariableHasValue(expected,
411 provider_->var_update_completed_time());
412 }
413
TEST_F(UmRealUpdaterProviderTest,GetUpdateCompletedTimeFailNoValue)414 TEST_F(UmRealUpdaterProviderTest, GetUpdateCompletedTimeFailNoValue) {
415 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetBootTimeAtUpdate(_))
416 .WillOnce(Return(false));
417 UmTestUtils::ExpectVariableNotSet(provider_->var_update_completed_time());
418 }
419
TEST_F(UmRealUpdaterProviderTest,GetUpdateCompletedTimeFailInvalidValue)420 TEST_F(UmRealUpdaterProviderTest, GetUpdateCompletedTimeFailInvalidValue) {
421 SetupUpdateCompletedTime(false);
422 UmTestUtils::ExpectVariableNotSet(provider_->var_update_completed_time());
423 }
424
TEST_F(UmRealUpdaterProviderTest,GetConsecutiveFailedUpdateChecks)425 TEST_F(UmRealUpdaterProviderTest, GetConsecutiveFailedUpdateChecks) {
426 const unsigned int kNumFailedChecks = 3;
427 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
428 consecutive_failed_update_checks())
429 .WillRepeatedly(Return(kNumFailedChecks));
430 UmTestUtils::ExpectVariableHasValue(
431 kNumFailedChecks, provider_->var_consecutive_failed_update_checks());
432 }
433
TEST_F(UmRealUpdaterProviderTest,GetServerDictatedPollInterval)434 TEST_F(UmRealUpdaterProviderTest, GetServerDictatedPollInterval) {
435 const unsigned int kPollInterval = 2 * 60 * 60; // Two hours.
436 EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
437 server_dictated_poll_interval())
438 .WillRepeatedly(Return(kPollInterval));
439 UmTestUtils::ExpectVariableHasValue(
440 kPollInterval, provider_->var_server_dictated_poll_interval());
441 }
442
443 } // namespace chromeos_update_manager
444