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/update_manager.h"
18
19#include <unistd.h>
20
21#include <algorithm>
22#include <memory>
23#include <string>
24#include <tuple>
25#include <utility>
26#include <vector>
27
28#include <base/bind.h>
29#include <base/test/simple_test_clock.h>
30#include <base/time/time.h>
31#include <brillo/message_loops/fake_message_loop.h>
32#include <brillo/message_loops/message_loop.h>
33#include <brillo/message_loops/message_loop_utils.h>
34#include <gmock/gmock.h>
35#include <gtest/gtest.h>
36
37#include "update_engine/common/fake_clock.h"
38#include "update_engine/update_manager/default_policy.h"
39#include "update_engine/update_manager/fake_state.h"
40#include "update_engine/update_manager/mock_policy.h"
41#include "update_engine/update_manager/umtest_utils.h"
42
43using base::Bind;
44using base::Callback;
45using base::Time;
46using base::TimeDelta;
47using brillo::MessageLoop;
48using brillo::MessageLoopRunMaxIterations;
49using chromeos_update_engine::ErrorCode;
50using chromeos_update_engine::FakeClock;
51using std::pair;
52using std::string;
53using std::tuple;
54using std::unique_ptr;
55using std::vector;
56
57namespace {
58
59// Generates a fixed timestamp for use in faking the current time.
60Time FixedTime() {
61  Time::Exploded now_exp;
62  now_exp.year = 2014;
63  now_exp.month = 3;
64  now_exp.day_of_week = 2;
65  now_exp.day_of_month = 18;
66  now_exp.hour = 8;
67  now_exp.minute = 5;
68  now_exp.second = 33;
69  now_exp.millisecond = 675;
70  return Time::FromLocalExploded(now_exp);
71}
72
73}  // namespace
74
75namespace chromeos_update_manager {
76
77class UmUpdateManagerTest : public ::testing::Test {
78 protected:
79  void SetUp() override {
80    loop_.SetAsCurrent();
81    fake_state_ = new FakeState();
82    umut_.reset(new UpdateManager(&fake_clock_, TimeDelta::FromSeconds(5),
83                                  TimeDelta::FromSeconds(1), fake_state_));
84  }
85
86  void TearDown() override {
87    EXPECT_FALSE(loop_.PendingTasks());
88  }
89
90  base::SimpleTestClock test_clock_;
91  brillo::FakeMessageLoop loop_{&test_clock_};
92  FakeState* fake_state_;  // Owned by the umut_.
93  FakeClock fake_clock_;
94  unique_ptr<UpdateManager> umut_;
95};
96
97// The FailingPolicy implements a single method and make it always fail. This
98// class extends the DefaultPolicy class to allow extensions of the Policy
99// class without extending nor changing this test.
100class FailingPolicy : public DefaultPolicy {
101 public:
102  explicit FailingPolicy(int* num_called_p) : num_called_p_(num_called_p) {}
103  FailingPolicy() : FailingPolicy(nullptr) {}
104  EvalStatus UpdateCheckAllowed(EvaluationContext* ec, State* state,
105                                string* error,
106                                UpdateCheckParams* result) const override {
107    if (num_called_p_)
108      (*num_called_p_)++;
109    *error = "FailingPolicy failed.";
110    return EvalStatus::kFailed;
111  }
112
113 protected:
114  string PolicyName() const override { return "FailingPolicy"; }
115
116 private:
117  int* num_called_p_;
118};
119
120// The LazyPolicy always returns EvalStatus::kAskMeAgainLater.
121class LazyPolicy : public DefaultPolicy {
122  EvalStatus UpdateCheckAllowed(EvaluationContext* ec, State* state,
123                                string* error,
124                                UpdateCheckParams* result) const override {
125    return EvalStatus::kAskMeAgainLater;
126  }
127
128 protected:
129  string PolicyName() const override { return "LazyPolicy"; }
130};
131
132// A policy that sleeps for a predetermined amount of time, then checks for a
133// wallclock-based time threshold (if given) and returns
134// EvalStatus::kAskMeAgainLater if not passed; otherwise, returns
135// EvalStatus::kSucceeded. Increments a counter every time it is being queried,
136// if a pointer to it is provided.
137class DelayPolicy : public DefaultPolicy {
138 public:
139  DelayPolicy(int sleep_secs, Time time_threshold, int* num_called_p)
140      : sleep_secs_(sleep_secs), time_threshold_(time_threshold),
141        num_called_p_(num_called_p) {}
142  EvalStatus UpdateCheckAllowed(EvaluationContext* ec, State* state,
143                                string* error,
144                                UpdateCheckParams* result) const override {
145    if (num_called_p_)
146      (*num_called_p_)++;
147
148    // Sleep for a predetermined amount of time.
149    if (sleep_secs_ > 0)
150      sleep(sleep_secs_);
151
152    // Check for a time threshold. This can be used to ensure that the policy
153    // has some non-constant dependency.
154    if (time_threshold_ < Time::Max() &&
155        ec->IsWallclockTimeGreaterThan(time_threshold_))
156      return EvalStatus::kSucceeded;
157
158    return EvalStatus::kAskMeAgainLater;
159  }
160
161 protected:
162  string PolicyName() const override { return "DelayPolicy"; }
163
164 private:
165  int sleep_secs_;
166  Time time_threshold_;
167  int* num_called_p_;
168};
169
170// AccumulateCallsCallback() adds to the passed |acc| accumulator vector pairs
171// of EvalStatus and T instances. This allows to create a callback that keeps
172// track of when it is called and the arguments passed to it, to be used with
173// the UpdateManager::AsyncPolicyRequest().
174template<typename T>
175static void AccumulateCallsCallback(vector<pair<EvalStatus, T>>* acc,
176                                    EvalStatus status, const T& result) {
177  acc->push_back(std::make_pair(status, result));
178}
179
180// Tests that policy requests are completed successfully. It is important that
181// this tests cover all policy requests as defined in Policy.
182TEST_F(UmUpdateManagerTest, PolicyRequestCallUpdateCheckAllowed) {
183  UpdateCheckParams result;
184  EXPECT_EQ(EvalStatus::kSucceeded, umut_->PolicyRequest(
185      &Policy::UpdateCheckAllowed, &result));
186}
187
188TEST_F(UmUpdateManagerTest, PolicyRequestCallUpdateCanStart) {
189  UpdateState update_state = UpdateState();
190  update_state.is_interactive = true;
191  update_state.is_delta_payload = false;
192  update_state.first_seen = FixedTime();
193  update_state.num_checks = 1;
194  update_state.num_failures = 0;
195  update_state.failures_last_updated = Time();
196  update_state.download_urls = vector<string>{"http://fake/url/"};
197  update_state.download_errors_max = 10;
198  update_state.p2p_downloading_disabled = false;
199  update_state.p2p_sharing_disabled = false;
200  update_state.p2p_num_attempts = 0;
201  update_state.p2p_first_attempted = Time();
202  update_state.last_download_url_idx = -1;
203  update_state.last_download_url_num_errors = 0;
204  update_state.download_errors = vector<tuple<int, ErrorCode, Time>>();
205  update_state.backoff_expiry = Time();
206  update_state.is_backoff_disabled = false;
207  update_state.scatter_wait_period = TimeDelta::FromSeconds(15);
208  update_state.scatter_check_threshold = 4;
209  update_state.scatter_wait_period_max = TimeDelta::FromSeconds(60);
210  update_state.scatter_check_threshold_min = 2;
211  update_state.scatter_check_threshold_max = 8;
212
213  UpdateDownloadParams result;
214  EXPECT_EQ(EvalStatus::kSucceeded,
215            umut_->PolicyRequest(&Policy::UpdateCanStart, &result,
216                                 update_state));
217}
218
219TEST_F(UmUpdateManagerTest, PolicyRequestCallsDefaultOnError) {
220  umut_->set_policy(new FailingPolicy());
221
222  // Tests that the DefaultPolicy instance is called when the method fails,
223  // which will set this as true.
224  UpdateCheckParams result;
225  result.updates_enabled = false;
226  EvalStatus status = umut_->PolicyRequest(
227      &Policy::UpdateCheckAllowed, &result);
228  EXPECT_EQ(EvalStatus::kSucceeded, status);
229  EXPECT_TRUE(result.updates_enabled);
230}
231
232// This test only applies to debug builds where DCHECK is enabled.
233#if DCHECK_IS_ON
234TEST_F(UmUpdateManagerTest, PolicyRequestDoesntBlockDeathTest) {
235  // The update manager should die (DCHECK) if a policy called synchronously
236  // returns a kAskMeAgainLater value.
237  UpdateCheckParams result;
238  umut_->set_policy(new LazyPolicy());
239  EXPECT_DEATH(umut_->PolicyRequest(&Policy::UpdateCheckAllowed, &result), "");
240}
241#endif  // DCHECK_IS_ON
242
243TEST_F(UmUpdateManagerTest, AsyncPolicyRequestDelaysEvaluation) {
244  // To avoid differences in code execution order between an AsyncPolicyRequest
245  // call on a policy that returns AskMeAgainLater the first time and one that
246  // succeeds the first time, we ensure that the passed callback is called from
247  // the main loop in both cases even when we could evaluate it right now.
248  umut_->set_policy(new FailingPolicy());
249
250  vector<pair<EvalStatus, UpdateCheckParams>> calls;
251  Callback<void(EvalStatus, const UpdateCheckParams&)> callback = Bind(
252      AccumulateCallsCallback<UpdateCheckParams>, &calls);
253
254  umut_->AsyncPolicyRequest(callback, &Policy::UpdateCheckAllowed);
255  // The callback should wait until we run the main loop for it to be executed.
256  EXPECT_EQ(0U, calls.size());
257  MessageLoopRunMaxIterations(MessageLoop::current(), 100);
258  EXPECT_EQ(1U, calls.size());
259}
260
261TEST_F(UmUpdateManagerTest, AsyncPolicyRequestTimeoutDoesNotFire) {
262  // Set up an async policy call to return immediately, then wait a little and
263  // ensure that the timeout event does not fire.
264  int num_called = 0;
265  umut_->set_policy(new FailingPolicy(&num_called));
266
267  vector<pair<EvalStatus, UpdateCheckParams>> calls;
268  Callback<void(EvalStatus, const UpdateCheckParams&)> callback =
269      Bind(AccumulateCallsCallback<UpdateCheckParams>, &calls);
270
271  umut_->AsyncPolicyRequest(callback, &Policy::UpdateCheckAllowed);
272  // Run the main loop, ensure that policy was attempted once before deferring
273  // to the default.
274  MessageLoopRunMaxIterations(MessageLoop::current(), 100);
275  EXPECT_EQ(1, num_called);
276  ASSERT_EQ(1U, calls.size());
277  EXPECT_EQ(EvalStatus::kSucceeded, calls[0].first);
278  // Wait for the timeout to expire, run the main loop again, ensure that
279  // nothing happened.
280  test_clock_.Advance(TimeDelta::FromSeconds(2));
281  MessageLoopRunMaxIterations(MessageLoop::current(), 10);
282  EXPECT_EQ(1, num_called);
283  EXPECT_EQ(1U, calls.size());
284}
285
286TEST_F(UmUpdateManagerTest, AsyncPolicyRequestTimesOut) {
287  // Set up an async policy call to exceed its expiration timeout, make sure
288  // that the default policy was not used (no callback) and that evaluation is
289  // reattempted.
290  int num_called = 0;
291  umut_->set_policy(new DelayPolicy(
292          0, fake_clock_.GetWallclockTime() + TimeDelta::FromSeconds(3),
293          &num_called));
294
295  vector<pair<EvalStatus, UpdateCheckParams>> calls;
296  Callback<void(EvalStatus, const UpdateCheckParams&)> callback =
297      Bind(AccumulateCallsCallback<UpdateCheckParams>, &calls);
298
299  umut_->AsyncPolicyRequest(callback, &Policy::UpdateCheckAllowed);
300  // Run the main loop, ensure that policy was attempted once but the callback
301  // was not invoked.
302  MessageLoopRunMaxIterations(MessageLoop::current(), 100);
303  EXPECT_EQ(1, num_called);
304  EXPECT_EQ(0U, calls.size());
305  // Wait for the expiration timeout to expire, run the main loop again,
306  // ensure that reevaluation occurred but callback was not invoked (i.e.
307  // default policy was not consulted).
308  test_clock_.Advance(TimeDelta::FromSeconds(2));
309  fake_clock_.SetWallclockTime(fake_clock_.GetWallclockTime() +
310                               TimeDelta::FromSeconds(2));
311  MessageLoopRunMaxIterations(MessageLoop::current(), 10);
312  EXPECT_EQ(2, num_called);
313  EXPECT_EQ(0U, calls.size());
314  // Wait for reevaluation due to delay to happen, ensure that it occurs and
315  // that the callback is invoked.
316  test_clock_.Advance(TimeDelta::FromSeconds(2));
317  fake_clock_.SetWallclockTime(fake_clock_.GetWallclockTime() +
318                               TimeDelta::FromSeconds(2));
319  MessageLoopRunMaxIterations(MessageLoop::current(), 10);
320  EXPECT_EQ(3, num_called);
321  ASSERT_EQ(1U, calls.size());
322  EXPECT_EQ(EvalStatus::kSucceeded, calls[0].first);
323}
324
325}  // namespace chromeos_update_manager
326