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/cros/fake_system_state.h"
27 #include "update_engine/cros/mock_update_attempter.h"
28 #include "update_engine/cros/omaha_request_params.h"
29 #include "update_engine/update_manager/umtest_utils.h"
30 
31 using base::Time;
32 using base::TimeDelta;
33 using chromeos_update_engine::FakePrefs;
34 using chromeos_update_engine::FakeSystemState;
35 using chromeos_update_engine::OmahaRequestParams;
36 using std::string;
37 using std::unique_ptr;
38 using testing::_;
39 using testing::DoAll;
40 using testing::Return;
41 using testing::SetArgPointee;
42 using update_engine::UpdateAttemptFlags;
43 
44 namespace {
45 
46 // Generates a fixed timestamp for use in faking the current time.
FixedTime()47 Time FixedTime() {
48   Time::Exploded now_exp;
49   now_exp.year = 2014;
50   now_exp.month = 3;
51   now_exp.day_of_week = 2;
52   now_exp.day_of_month = 18;
53   now_exp.hour = 8;
54   now_exp.minute = 5;
55   now_exp.second = 33;
56   now_exp.millisecond = 675;
57   Time time;
58   ignore_result(Time::FromLocalExploded(now_exp, &time));
59   return time;
60 }
61 
62 // Rounds down a timestamp to the nearest second. This is useful when faking
63 // times that are converted to time_t (no sub-second resolution).
RoundedToSecond(Time time)64 Time RoundedToSecond(Time time) {
65   Time::Exploded exp;
66   time.LocalExplode(&exp);
67   exp.millisecond = 0;
68   Time rounded_time;
69   ignore_result(Time::FromLocalExploded(exp, &rounded_time));
70   return rounded_time;
71 }
72 
ACTION_P(ActionSetUpdateEngineStatusLastCheckedTime,time)73 ACTION_P(ActionSetUpdateEngineStatusLastCheckedTime, time) {
74   arg0->last_checked_time = time;
75 };
76 
ACTION_P(ActionSetUpdateEngineStatusProgress,progress)77 ACTION_P(ActionSetUpdateEngineStatusProgress, progress) {
78   arg0->progress = progress;
79 };
80 
ACTION_P(ActionSetUpdateEngineStatusStatus,status)81 ACTION_P(ActionSetUpdateEngineStatusStatus, status) {
82   arg0->status = status;
83 }
84 
ACTION_P(ActionSetUpdateEngineStatusNewVersion,new_version)85 ACTION_P(ActionSetUpdateEngineStatusNewVersion, new_version) {
86   arg0->new_version = new_version;
87 }
88 
ACTION_P(ActionSetUpdateEngineStatusNewSizeBytes,new_size_bytes)89 ACTION_P(ActionSetUpdateEngineStatusNewSizeBytes, new_size_bytes) {
90   arg0->new_size_bytes = new_size_bytes;
91 }
92 
93 }  // namespace
94 
95 namespace chromeos_update_manager {
96 
97 class UmRealUpdaterProviderTest : public ::testing::Test {
98  protected:
SetUp()99   void SetUp() override {
100     FakeSystemState::CreateInstance();
101     provider_.reset(new RealUpdaterProvider());
102     // Check that provider initializes correctly.
103     ASSERT_TRUE(provider_->Init());
104   }
105 
106   // Sets up mock expectations for testing the update completed time reporting.
107   // |valid| determines whether the returned time is valid. Returns the expected
108   // update completed time value.
SetupUpdateCompletedTime(bool valid)109   Time SetupUpdateCompletedTime(bool valid) {
110     const TimeDelta kDurationSinceUpdate = TimeDelta::FromMinutes(7);
111     const Time kUpdateBootTime = Time() + kDurationSinceUpdate * 2;
112     const Time kCurrBootTime = (valid ? kUpdateBootTime + kDurationSinceUpdate
113                                       : kUpdateBootTime - kDurationSinceUpdate);
114     const Time kCurrWallclockTime = FixedTime();
115     EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(),
116                 GetBootTimeAtUpdate(_))
117         .WillOnce(DoAll(SetArgPointee<0>(kUpdateBootTime), Return(true)));
118     FakeSystemState::Get()->fake_clock()->SetBootTime(kCurrBootTime);
119     FakeSystemState::Get()->fake_clock()->SetWallclockTime(kCurrWallclockTime);
120     return kCurrWallclockTime - kDurationSinceUpdate;
121   }
122 
123   unique_ptr<RealUpdaterProvider> provider_;
124 };
125 
TEST_F(UmRealUpdaterProviderTest,UpdaterStartedTimeIsWallclockTime)126 TEST_F(UmRealUpdaterProviderTest, UpdaterStartedTimeIsWallclockTime) {
127   FakeSystemState::Get()->fake_clock()->SetWallclockTime(
128       Time::FromDoubleT(123.456));
129   FakeSystemState::Get()->fake_clock()->SetMonotonicTime(
130       Time::FromDoubleT(456.123));
131   // Re-initialize to re-setup the provider under test to use these values.
132   provider_.reset(new RealUpdaterProvider());
133   ASSERT_TRUE(provider_->Init());
134   UmTestUtils::ExpectVariableHasValue(Time::FromDoubleT(123.456),
135                                       provider_->var_updater_started_time());
136 }
137 
TEST_F(UmRealUpdaterProviderTest,GetLastCheckedTimeOkay)138 TEST_F(UmRealUpdaterProviderTest, GetLastCheckedTimeOkay) {
139   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
140       .WillOnce(DoAll(
141           ActionSetUpdateEngineStatusLastCheckedTime(FixedTime().ToTimeT()),
142           Return(true)));
143   UmTestUtils::ExpectVariableHasValue(RoundedToSecond(FixedTime()),
144                                       provider_->var_last_checked_time());
145 }
146 
TEST_F(UmRealUpdaterProviderTest,GetLastCheckedTimeFailNoValue)147 TEST_F(UmRealUpdaterProviderTest, GetLastCheckedTimeFailNoValue) {
148   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
149       .WillOnce(Return(false));
150   UmTestUtils::ExpectVariableNotSet(provider_->var_last_checked_time());
151 }
152 
TEST_F(UmRealUpdaterProviderTest,GetProgressOkayMin)153 TEST_F(UmRealUpdaterProviderTest, GetProgressOkayMin) {
154   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
155       .WillOnce(DoAll(ActionSetUpdateEngineStatusProgress(0.0), Return(true)));
156   UmTestUtils::ExpectVariableHasValue(0.0, provider_->var_progress());
157 }
158 
TEST_F(UmRealUpdaterProviderTest,GetProgressOkayMid)159 TEST_F(UmRealUpdaterProviderTest, GetProgressOkayMid) {
160   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
161       .WillOnce(DoAll(ActionSetUpdateEngineStatusProgress(0.3), Return(true)));
162   UmTestUtils::ExpectVariableHasValue(0.3, provider_->var_progress());
163 }
164 
TEST_F(UmRealUpdaterProviderTest,GetProgressOkayMax)165 TEST_F(UmRealUpdaterProviderTest, GetProgressOkayMax) {
166   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
167       .WillOnce(DoAll(ActionSetUpdateEngineStatusProgress(1.0), Return(true)));
168   UmTestUtils::ExpectVariableHasValue(1.0, provider_->var_progress());
169 }
170 
TEST_F(UmRealUpdaterProviderTest,GetProgressFailNoValue)171 TEST_F(UmRealUpdaterProviderTest, GetProgressFailNoValue) {
172   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
173       .WillOnce(Return(false));
174   UmTestUtils::ExpectVariableNotSet(provider_->var_progress());
175 }
176 
TEST_F(UmRealUpdaterProviderTest,GetProgressFailTooSmall)177 TEST_F(UmRealUpdaterProviderTest, GetProgressFailTooSmall) {
178   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
179       .WillOnce(DoAll(ActionSetUpdateEngineStatusProgress(-2.0), Return(true)));
180   UmTestUtils::ExpectVariableNotSet(provider_->var_progress());
181 }
182 
TEST_F(UmRealUpdaterProviderTest,GetProgressFailTooBig)183 TEST_F(UmRealUpdaterProviderTest, GetProgressFailTooBig) {
184   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
185       .WillOnce(DoAll(ActionSetUpdateEngineStatusProgress(2.0), Return(true)));
186   UmTestUtils::ExpectVariableNotSet(provider_->var_progress());
187 }
188 
TEST_F(UmRealUpdaterProviderTest,GetStageOkayIdle)189 TEST_F(UmRealUpdaterProviderTest, GetStageOkayIdle) {
190   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
191       .WillOnce(DoAll(
192           ActionSetUpdateEngineStatusStatus(update_engine::UpdateStatus::IDLE),
193           Return(true)));
194   UmTestUtils::ExpectVariableHasValue(Stage::kIdle, provider_->var_stage());
195 }
196 
TEST_F(UmRealUpdaterProviderTest,GetStageOkayCheckingForUpdate)197 TEST_F(UmRealUpdaterProviderTest, GetStageOkayCheckingForUpdate) {
198   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
199       .WillOnce(DoAll(ActionSetUpdateEngineStatusStatus(
200                           update_engine::UpdateStatus::CHECKING_FOR_UPDATE),
201                       Return(true)));
202   UmTestUtils::ExpectVariableHasValue(Stage::kCheckingForUpdate,
203                                       provider_->var_stage());
204 }
205 
TEST_F(UmRealUpdaterProviderTest,GetStageOkayUpdateAvailable)206 TEST_F(UmRealUpdaterProviderTest, GetStageOkayUpdateAvailable) {
207   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
208       .WillOnce(DoAll(ActionSetUpdateEngineStatusStatus(
209                           update_engine::UpdateStatus::UPDATE_AVAILABLE),
210                       Return(true)));
211   UmTestUtils::ExpectVariableHasValue(Stage::kUpdateAvailable,
212                                       provider_->var_stage());
213 }
214 
TEST_F(UmRealUpdaterProviderTest,GetStageOkayDownloading)215 TEST_F(UmRealUpdaterProviderTest, GetStageOkayDownloading) {
216   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
217       .WillOnce(DoAll(ActionSetUpdateEngineStatusStatus(
218                           update_engine::UpdateStatus::DOWNLOADING),
219                       Return(true)));
220   UmTestUtils::ExpectVariableHasValue(Stage::kDownloading,
221                                       provider_->var_stage());
222 }
223 
TEST_F(UmRealUpdaterProviderTest,GetStageOkayVerifying)224 TEST_F(UmRealUpdaterProviderTest, GetStageOkayVerifying) {
225   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
226       .WillOnce(DoAll(ActionSetUpdateEngineStatusStatus(
227                           update_engine::UpdateStatus::VERIFYING),
228                       Return(true)));
229   UmTestUtils::ExpectVariableHasValue(Stage::kVerifying,
230                                       provider_->var_stage());
231 }
232 
TEST_F(UmRealUpdaterProviderTest,GetStageOkayFinalizing)233 TEST_F(UmRealUpdaterProviderTest, GetStageOkayFinalizing) {
234   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
235       .WillOnce(DoAll(ActionSetUpdateEngineStatusStatus(
236                           update_engine::UpdateStatus::FINALIZING),
237                       Return(true)));
238   UmTestUtils::ExpectVariableHasValue(Stage::kFinalizing,
239                                       provider_->var_stage());
240 }
241 
TEST_F(UmRealUpdaterProviderTest,GetStageOkayUpdatedNeedReboot)242 TEST_F(UmRealUpdaterProviderTest, GetStageOkayUpdatedNeedReboot) {
243   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
244       .WillOnce(DoAll(ActionSetUpdateEngineStatusStatus(
245                           update_engine::UpdateStatus::UPDATED_NEED_REBOOT),
246                       Return(true)));
247   UmTestUtils::ExpectVariableHasValue(Stage::kUpdatedNeedReboot,
248                                       provider_->var_stage());
249 }
250 
TEST_F(UmRealUpdaterProviderTest,GetStageOkayReportingErrorEvent)251 TEST_F(UmRealUpdaterProviderTest, GetStageOkayReportingErrorEvent) {
252   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
253       .WillOnce(DoAll(ActionSetUpdateEngineStatusStatus(
254                           update_engine::UpdateStatus::REPORTING_ERROR_EVENT),
255                       Return(true)));
256   UmTestUtils::ExpectVariableHasValue(Stage::kReportingErrorEvent,
257                                       provider_->var_stage());
258 }
259 
TEST_F(UmRealUpdaterProviderTest,GetStageOkayAttemptingRollback)260 TEST_F(UmRealUpdaterProviderTest, GetStageOkayAttemptingRollback) {
261   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
262       .WillOnce(DoAll(ActionSetUpdateEngineStatusStatus(
263                           update_engine::UpdateStatus::ATTEMPTING_ROLLBACK),
264                       Return(true)));
265   UmTestUtils::ExpectVariableHasValue(Stage::kAttemptingRollback,
266                                       provider_->var_stage());
267 }
268 
TEST_F(UmRealUpdaterProviderTest,GetStageFailNoValue)269 TEST_F(UmRealUpdaterProviderTest, GetStageFailNoValue) {
270   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
271       .WillOnce(Return(false));
272   UmTestUtils::ExpectVariableNotSet(provider_->var_stage());
273 }
274 
TEST_F(UmRealUpdaterProviderTest,GetNewVersionOkay)275 TEST_F(UmRealUpdaterProviderTest, GetNewVersionOkay) {
276   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
277       .WillOnce(
278           DoAll(ActionSetUpdateEngineStatusNewVersion("1.2.0"), Return(true)));
279   UmTestUtils::ExpectVariableHasValue(string("1.2.0"),
280                                       provider_->var_new_version());
281 }
282 
TEST_F(UmRealUpdaterProviderTest,GetNewVersionFailNoValue)283 TEST_F(UmRealUpdaterProviderTest, GetNewVersionFailNoValue) {
284   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
285       .WillOnce(Return(false));
286   UmTestUtils::ExpectVariableNotSet(provider_->var_new_version());
287 }
288 
TEST_F(UmRealUpdaterProviderTest,GetPayloadSizeOkayZero)289 TEST_F(UmRealUpdaterProviderTest, GetPayloadSizeOkayZero) {
290   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
291       .WillOnce(DoAll(
292           ActionSetUpdateEngineStatusNewSizeBytes(static_cast<uint64_t>(0)),
293           Return(true)));
294   UmTestUtils::ExpectVariableHasValue(static_cast<uint64_t>(0),
295                                       provider_->var_payload_size());
296 }
297 
TEST_F(UmRealUpdaterProviderTest,GetPayloadSizeOkayArbitrary)298 TEST_F(UmRealUpdaterProviderTest, GetPayloadSizeOkayArbitrary) {
299   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
300       .WillOnce(DoAll(ActionSetUpdateEngineStatusNewSizeBytes(
301                           static_cast<uint64_t>(567890)),
302                       Return(true)));
303   UmTestUtils::ExpectVariableHasValue(static_cast<uint64_t>(567890),
304                                       provider_->var_payload_size());
305 }
306 
TEST_F(UmRealUpdaterProviderTest,GetPayloadSizeOkayTwoGigabytes)307 TEST_F(UmRealUpdaterProviderTest, GetPayloadSizeOkayTwoGigabytes) {
308   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
309       .WillOnce(DoAll(ActionSetUpdateEngineStatusNewSizeBytes(
310                           static_cast<uint64_t>(1) << 31),
311                       Return(true)));
312   UmTestUtils::ExpectVariableHasValue(static_cast<uint64_t>(1) << 31,
313                                       provider_->var_payload_size());
314 }
315 
TEST_F(UmRealUpdaterProviderTest,GetPayloadSizeFailNoValue)316 TEST_F(UmRealUpdaterProviderTest, GetPayloadSizeFailNoValue) {
317   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(), GetStatus(_))
318       .WillOnce(Return(false));
319   UmTestUtils::ExpectVariableNotSet(provider_->var_payload_size());
320 }
321 
TEST_F(UmRealUpdaterProviderTest,GetCurrChannelOkay)322 TEST_F(UmRealUpdaterProviderTest, GetCurrChannelOkay) {
323   const string kChannelName("foo-channel");
324   OmahaRequestParams request_params;
325   request_params.Init("", "", {});
326   request_params.set_current_channel(kChannelName);
327   FakeSystemState::Get()->set_request_params(&request_params);
328   UmTestUtils::ExpectVariableHasValue(kChannelName,
329                                       provider_->var_curr_channel());
330 }
331 
TEST_F(UmRealUpdaterProviderTest,GetCurrChannelFailEmpty)332 TEST_F(UmRealUpdaterProviderTest, GetCurrChannelFailEmpty) {
333   OmahaRequestParams request_params;
334   request_params.Init("", "", {});
335   request_params.set_current_channel("");
336   FakeSystemState::Get()->set_request_params(&request_params);
337   UmTestUtils::ExpectVariableNotSet(provider_->var_curr_channel());
338 }
339 
TEST_F(UmRealUpdaterProviderTest,GetNewChannelOkay)340 TEST_F(UmRealUpdaterProviderTest, GetNewChannelOkay) {
341   const string kChannelName("foo-channel");
342   OmahaRequestParams request_params;
343   request_params.Init("", "", {});
344   request_params.set_target_channel(kChannelName);
345   FakeSystemState::Get()->set_request_params(&request_params);
346   UmTestUtils::ExpectVariableHasValue(kChannelName,
347                                       provider_->var_new_channel());
348 }
349 
TEST_F(UmRealUpdaterProviderTest,GetNewChannelFailEmpty)350 TEST_F(UmRealUpdaterProviderTest, GetNewChannelFailEmpty) {
351   OmahaRequestParams request_params;
352   request_params.Init("", "", {});
353   request_params.set_target_channel("");
354   FakeSystemState::Get()->set_request_params(&request_params);
355   UmTestUtils::ExpectVariableNotSet(provider_->var_new_channel());
356 }
357 
TEST_F(UmRealUpdaterProviderTest,GetP2PEnabledOkayPrefDoesntExist)358 TEST_F(UmRealUpdaterProviderTest, GetP2PEnabledOkayPrefDoesntExist) {
359   UmTestUtils::ExpectVariableHasValue(false, provider_->var_p2p_enabled());
360 }
361 
TEST_F(UmRealUpdaterProviderTest,GetP2PEnabledOkayPrefReadsFalse)362 TEST_F(UmRealUpdaterProviderTest, GetP2PEnabledOkayPrefReadsFalse) {
363   FakeSystemState::Get()->fake_prefs()->SetBoolean(
364       chromeos_update_engine::kPrefsP2PEnabled, false);
365   UmTestUtils::ExpectVariableHasValue(false, provider_->var_p2p_enabled());
366 }
367 
TEST_F(UmRealUpdaterProviderTest,GetP2PEnabledReadWhenInitialized)368 TEST_F(UmRealUpdaterProviderTest, GetP2PEnabledReadWhenInitialized) {
369   FakeSystemState::Get()->fake_prefs()->SetBoolean(
370       chromeos_update_engine::kPrefsP2PEnabled, true);
371   provider_.reset(new RealUpdaterProvider());
372   ASSERT_TRUE(provider_->Init());
373   UmTestUtils::ExpectVariableHasValue(true, provider_->var_p2p_enabled());
374 }
375 
TEST_F(UmRealUpdaterProviderTest,GetP2PEnabledUpdated)376 TEST_F(UmRealUpdaterProviderTest, GetP2PEnabledUpdated) {
377   auto* fake_prefs = FakeSystemState::Get()->fake_prefs();
378   fake_prefs->SetBoolean(chromeos_update_engine::kPrefsP2PEnabled, false);
379   UmTestUtils::ExpectVariableHasValue(false, provider_->var_p2p_enabled());
380   fake_prefs->SetBoolean(chromeos_update_engine::kPrefsP2PEnabled, true);
381   UmTestUtils::ExpectVariableHasValue(true, provider_->var_p2p_enabled());
382   fake_prefs->Delete(chromeos_update_engine::kPrefsP2PEnabled);
383   UmTestUtils::ExpectVariableHasValue(false, provider_->var_p2p_enabled());
384 }
385 
TEST_F(UmRealUpdaterProviderTest,GetCellularEnabledOkayPrefDoesntExist)386 TEST_F(UmRealUpdaterProviderTest, GetCellularEnabledOkayPrefDoesntExist) {
387   UmTestUtils::ExpectVariableHasValue(false, provider_->var_cellular_enabled());
388 }
389 
TEST_F(UmRealUpdaterProviderTest,GetCellularEnabledOkayPrefReadsTrue)390 TEST_F(UmRealUpdaterProviderTest, GetCellularEnabledOkayPrefReadsTrue) {
391   FakeSystemState::Get()->fake_prefs()->SetBoolean(
392       chromeos_update_engine::kPrefsUpdateOverCellularPermission, true);
393   UmTestUtils::ExpectVariableHasValue(true, provider_->var_cellular_enabled());
394 }
395 
TEST_F(UmRealUpdaterProviderTest,GetUpdateCompletedTimeOkay)396 TEST_F(UmRealUpdaterProviderTest, GetUpdateCompletedTimeOkay) {
397   Time expected = SetupUpdateCompletedTime(true);
398   UmTestUtils::ExpectVariableHasValue(expected,
399                                       provider_->var_update_completed_time());
400 }
401 
TEST_F(UmRealUpdaterProviderTest,GetUpdateCompletedTimeFailNoValue)402 TEST_F(UmRealUpdaterProviderTest, GetUpdateCompletedTimeFailNoValue) {
403   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(),
404               GetBootTimeAtUpdate(_))
405       .WillOnce(Return(false));
406   UmTestUtils::ExpectVariableNotSet(provider_->var_update_completed_time());
407 }
408 
TEST_F(UmRealUpdaterProviderTest,GetUpdateCompletedTimeFailInvalidValue)409 TEST_F(UmRealUpdaterProviderTest, GetUpdateCompletedTimeFailInvalidValue) {
410   SetupUpdateCompletedTime(false);
411   UmTestUtils::ExpectVariableNotSet(provider_->var_update_completed_time());
412 }
413 
TEST_F(UmRealUpdaterProviderTest,GetConsecutiveFailedUpdateChecks)414 TEST_F(UmRealUpdaterProviderTest, GetConsecutiveFailedUpdateChecks) {
415   const unsigned int kNumFailedChecks = 3;
416   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(),
417               consecutive_failed_update_checks())
418       .WillRepeatedly(Return(kNumFailedChecks));
419   UmTestUtils::ExpectVariableHasValue(
420       kNumFailedChecks, provider_->var_consecutive_failed_update_checks());
421 }
422 
TEST_F(UmRealUpdaterProviderTest,GetServerDictatedPollInterval)423 TEST_F(UmRealUpdaterProviderTest, GetServerDictatedPollInterval) {
424   const unsigned int kPollInterval = 2 * 60 * 60;  // Two hours.
425   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(),
426               server_dictated_poll_interval())
427       .WillRepeatedly(Return(kPollInterval));
428   UmTestUtils::ExpectVariableHasValue(
429       kPollInterval, provider_->var_server_dictated_poll_interval());
430 }
431 
TEST_F(UmRealUpdaterProviderTest,GetUpdateRestrictions)432 TEST_F(UmRealUpdaterProviderTest, GetUpdateRestrictions) {
433   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(),
434               GetCurrentUpdateAttemptFlags())
435       .WillRepeatedly(Return(UpdateAttemptFlags::kFlagRestrictDownload |
436                              UpdateAttemptFlags::kFlagNonInteractive));
437   UmTestUtils::ExpectVariableHasValue(UpdateRestrictions::kRestrictDownloading,
438                                       provider_->var_update_restrictions());
439 }
440 
TEST_F(UmRealUpdaterProviderTest,GetUpdateRestrictionsNone)441 TEST_F(UmRealUpdaterProviderTest, GetUpdateRestrictionsNone) {
442   EXPECT_CALL(*FakeSystemState::Get()->mock_update_attempter(),
443               GetCurrentUpdateAttemptFlags())
444       .WillRepeatedly(Return(UpdateAttemptFlags::kNone));
445   UmTestUtils::ExpectVariableHasValue(UpdateRestrictions::kNone,
446                                       provider_->var_update_restrictions());
447 }
448 
TEST_F(UmRealUpdaterProviderTest,TestUpdateCheckIntervalTimeout)449 TEST_F(UmRealUpdaterProviderTest, TestUpdateCheckIntervalTimeout) {
450   UmTestUtils::ExpectVariableNotSet(
451       provider_->var_test_update_check_interval_timeout());
452   auto* fake_prefs = FakeSystemState::Get()->fake_prefs();
453   fake_prefs->SetInt64(
454       chromeos_update_engine::kPrefsTestUpdateCheckIntervalTimeout, 1);
455   UmTestUtils::ExpectVariableHasValue(
456       static_cast<int64_t>(1),
457       provider_->var_test_update_check_interval_timeout());
458 
459   // Make sure the value does not exceed a threshold of 10 minutes.
460   fake_prefs->SetInt64(
461       chromeos_update_engine::kPrefsTestUpdateCheckIntervalTimeout, 11 * 60);
462   // The next 5 reads should return valid values.
463   for (int i = 0; i < 5; ++i)
464     UmTestUtils::ExpectVariableHasValue(
465         static_cast<int64_t>(10 * 60),
466         provider_->var_test_update_check_interval_timeout());
467 
468   // Just to make sure it is not cached anywhere and deleted. The variable is
469   // allowd to be read 6 times.
470   UmTestUtils::ExpectVariableNotSet(
471       provider_->var_test_update_check_interval_timeout());
472 }
473 
474 }  // namespace chromeos_update_manager
475