1 //
2 // Copyright (C) 2017 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/next_update_check_policy_impl.h"
18
19 #include <memory>
20
21 #include "update_engine/update_manager/policy_test_utils.h"
22
23 using base::Time;
24 using base::TimeDelta;
25 using std::string;
26
27 namespace chromeos_update_manager {
28
29 const NextUpdateCheckPolicyConstants policy_test_constants = {
30 // these are specifically NOT the values used by real Policy
31 // implementations.
32 .timeout_initial_interval = 3 * 60,
33 .timeout_periodic_interval = 2 * 60 * 60,
34 .timeout_max_backoff_interval = 8 * 60 * 60,
35 .timeout_regular_fuzz = 5 * 60,
36 .attempt_backoff_max_interval_in_days = 12,
37 .attempt_backoff_fuzz_in_hours = 10,
38 };
39
40 class UmNextUpdateCheckTimePolicyImplTest : public UmPolicyTestBase {
41 protected:
UmNextUpdateCheckTimePolicyImplTest()42 UmNextUpdateCheckTimePolicyImplTest() {
43 policy_ =
44 std::make_unique<NextUpdateCheckTimePolicyImpl>(policy_test_constants);
45 }
46 };
47
TEST_F(UmNextUpdateCheckTimePolicyImplTest,FirstCheckIsAtMostInitialIntervalAfterStart)48 TEST_F(UmNextUpdateCheckTimePolicyImplTest,
49 FirstCheckIsAtMostInitialIntervalAfterStart) {
50 Time next_update_check;
51
52 // Set the last update time so it'll appear as if this is a first update check
53 // in the lifetime of the current updater.
54 fake_state_.updater_provider()->var_last_checked_time()->reset(
55 new Time(fake_clock_->GetWallclockTime() - TimeDelta::FromMinutes(10)));
56
57 CallMethodWithContext(&NextUpdateCheckTimePolicyImpl::NextUpdateCheckTime,
58 &next_update_check,
59 policy_test_constants);
60
61 EXPECT_LE(fake_clock_->GetWallclockTime(), next_update_check);
62 EXPECT_GE(fake_clock_->GetWallclockTime() +
63 TimeDelta::FromSeconds(
64 policy_test_constants.timeout_initial_interval +
65 policy_test_constants.timeout_regular_fuzz / 2),
66 next_update_check);
67 }
68
TEST_F(UmNextUpdateCheckTimePolicyImplTest,RecurringCheckBaseIntervalAndFuzz)69 TEST_F(UmNextUpdateCheckTimePolicyImplTest, RecurringCheckBaseIntervalAndFuzz) {
70 // Ensure that we're using the correct interval (kPeriodicInterval) and fuzz
71 // (ktimeout_regular_fuzz) as base values for period updates.
72 Time next_update_check;
73
74 CallMethodWithContext(&NextUpdateCheckTimePolicyImpl::NextUpdateCheckTime,
75 &next_update_check,
76 policy_test_constants);
77
78 EXPECT_LE(fake_clock_->GetWallclockTime() +
79 TimeDelta::FromSeconds(
80 policy_test_constants.timeout_periodic_interval -
81 policy_test_constants.timeout_regular_fuzz / 2),
82 next_update_check);
83 EXPECT_GE(fake_clock_->GetWallclockTime() +
84 TimeDelta::FromSeconds(
85 policy_test_constants.timeout_periodic_interval +
86 policy_test_constants.timeout_regular_fuzz / 2),
87 next_update_check);
88 }
89
TEST_F(UmNextUpdateCheckTimePolicyImplTest,RecurringCheckBackoffIntervalAndFuzz)90 TEST_F(UmNextUpdateCheckTimePolicyImplTest,
91 RecurringCheckBackoffIntervalAndFuzz) {
92 // Ensure that we're properly backing off and fuzzing in the presence of
93 // failed updates attempts.
94 Time next_update_check;
95
96 fake_state_.updater_provider()->var_consecutive_failed_update_checks()->reset(
97 new unsigned int{2});
98
99 ExpectStatus(EvalStatus::kSucceeded,
100 NextUpdateCheckTimePolicyImpl::NextUpdateCheckTime,
101 &next_update_check,
102 policy_test_constants);
103
104 int expected_interval = policy_test_constants.timeout_periodic_interval * 4;
105 EXPECT_LE(
106 fake_clock_->GetWallclockTime() +
107 TimeDelta::FromSeconds(expected_interval - expected_interval / 2),
108 next_update_check);
109 EXPECT_GE(
110 fake_clock_->GetWallclockTime() +
111 TimeDelta::FromSeconds(expected_interval + expected_interval / 2),
112 next_update_check);
113 }
114
TEST_F(UmNextUpdateCheckTimePolicyImplTest,RecurringCheckServerDictatedPollInterval)115 TEST_F(UmNextUpdateCheckTimePolicyImplTest,
116 RecurringCheckServerDictatedPollInterval) {
117 // Policy honors the server provided check poll interval.
118 Time next_update_check;
119
120 const auto kInterval = policy_test_constants.timeout_periodic_interval * 4;
121 fake_state_.updater_provider()->var_server_dictated_poll_interval()->reset(
122 new unsigned int(kInterval)); // NOLINT(readability/casting)
123 // We should not be backing off in this case.
124 fake_state_.updater_provider()->var_consecutive_failed_update_checks()->reset(
125 new unsigned int(2)); // NOLINT(readability/casting)
126
127 ExpectStatus(EvalStatus::kSucceeded,
128 &NextUpdateCheckTimePolicyImpl::NextUpdateCheckTime,
129 &next_update_check,
130 policy_test_constants);
131
132 EXPECT_LE(fake_clock_->GetWallclockTime() +
133 TimeDelta::FromSeconds(kInterval - kInterval / 2),
134 next_update_check);
135 EXPECT_GE(fake_clock_->GetWallclockTime() +
136 TimeDelta::FromSeconds(kInterval + kInterval / 2),
137 next_update_check);
138 }
139
TEST_F(UmNextUpdateCheckTimePolicyImplTest,ExponentialBackoffIsCapped)140 TEST_F(UmNextUpdateCheckTimePolicyImplTest, ExponentialBackoffIsCapped) {
141 Time next_update_check;
142
143 fake_state_.updater_provider()->var_consecutive_failed_update_checks()->reset(
144 new unsigned int(100)); // NOLINT(readability/casting)
145
146 ExpectStatus(EvalStatus::kSucceeded,
147 &NextUpdateCheckTimePolicyImpl::NextUpdateCheckTime,
148 &next_update_check,
149 policy_test_constants);
150
151 EXPECT_LE(fake_clock_->GetWallclockTime() +
152 TimeDelta::FromSeconds(
153 policy_test_constants.timeout_max_backoff_interval -
154 policy_test_constants.timeout_max_backoff_interval / 2),
155 next_update_check);
156 EXPECT_GE(fake_clock_->GetWallclockTime() +
157 TimeDelta::FromSeconds(
158 policy_test_constants.timeout_max_backoff_interval +
159 policy_test_constants.timeout_max_backoff_interval / 2),
160 next_update_check);
161 }
162
163 } // namespace chromeos_update_manager
164