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