common_service_unittest.cc revision 3a9c9623f2ffbe256f2d4d8897939f3d48b3cf52 
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/common_service.h"
18
19#include <gtest/gtest.h>
20#include <string>
21
22#include <brillo/errors/error.h>
23#include <policy/libpolicy.h>
24#include <policy/mock_device_policy.h>
25
26#include "update_engine/common/fake_prefs.h"
27#include "update_engine/fake_system_state.h"
28#include "update_engine/omaha_utils.h"
29
30using std::string;
31using testing::_;
32using testing::Return;
33using testing::SetArgumentPointee;
34using update_engine::UpdateAttemptFlags;
35
36namespace chromeos_update_engine {
37
38class UpdateEngineServiceTest : public ::testing::Test {
39 protected:
40  UpdateEngineServiceTest()
41      : mock_update_attempter_(fake_system_state_.mock_update_attempter()),
42        common_service_(&fake_system_state_) {}
43
44  void SetUp() override {
45    fake_system_state_.set_device_policy(nullptr);
46  }
47
48  // Fake/mock infrastructure.
49  FakeSystemState fake_system_state_;
50  policy::MockDevicePolicy mock_device_policy_;
51
52  // Shortcut for fake_system_state_.mock_update_attempter().
53  MockUpdateAttempter* mock_update_attempter_;
54
55  brillo::ErrorPtr error_;
56  UpdateEngineService common_service_;
57};
58
59TEST_F(UpdateEngineServiceTest, AttemptUpdate) {
60  EXPECT_CALL(
61      *mock_update_attempter_,
62      CheckForUpdate("app_ver", "url", UpdateAttemptFlags::kFlagNonInteractive))
63      .WillOnce(Return(true));
64
65  // The non-interactive flag needs to be passed through to CheckForUpdate.
66  bool result = false;
67  EXPECT_TRUE(
68      common_service_.AttemptUpdate(&error_,
69                                    "app_ver",
70                                    "url",
71                                    UpdateAttemptFlags::kFlagNonInteractive,
72                                    &result));
73  EXPECT_EQ(nullptr, error_);
74  EXPECT_TRUE(result);
75}
76
77TEST_F(UpdateEngineServiceTest, AttemptUpdateReturnsFalse) {
78  EXPECT_CALL(*mock_update_attempter_,
79              CheckForUpdate("app_ver", "url", UpdateAttemptFlags::kNone))
80      .WillOnce(Return(false));
81  bool result = true;
82  EXPECT_TRUE(common_service_.AttemptUpdate(
83      &error_, "app_ver", "url", UpdateAttemptFlags::kNone, &result));
84  EXPECT_EQ(nullptr, error_);
85  EXPECT_FALSE(result);
86}
87
88// SetChannel is allowed when there's no device policy (the device is not
89// enterprise enrolled).
90TEST_F(UpdateEngineServiceTest, SetChannelWithNoPolicy) {
91  EXPECT_CALL(*mock_update_attempter_, RefreshDevicePolicy());
92  // If SetTargetChannel is called it means the policy check passed.
93  EXPECT_CALL(*fake_system_state_.mock_request_params(),
94              SetTargetChannel("stable-channel", true, _))
95      .WillOnce(Return(true));
96  EXPECT_TRUE(common_service_.SetChannel(&error_, "stable-channel", true));
97  ASSERT_EQ(nullptr, error_);
98}
99
100// When the policy is present, the delegated value should be checked.
101TEST_F(UpdateEngineServiceTest, SetChannelWithDelegatedPolicy) {
102  policy::MockDevicePolicy mock_device_policy;
103  fake_system_state_.set_device_policy(&mock_device_policy);
104  EXPECT_CALL(mock_device_policy, GetReleaseChannelDelegated(_))
105      .WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true)));
106  EXPECT_CALL(*fake_system_state_.mock_request_params(),
107              SetTargetChannel("beta-channel", true, _))
108      .WillOnce(Return(true));
109
110  EXPECT_TRUE(common_service_.SetChannel(&error_, "beta-channel", true));
111  ASSERT_EQ(nullptr, error_);
112}
113
114// When passing an invalid value (SetTargetChannel fails) an error should be
115// raised.
116TEST_F(UpdateEngineServiceTest, SetChannelWithInvalidChannel) {
117  EXPECT_CALL(*mock_update_attempter_, RefreshDevicePolicy());
118  EXPECT_CALL(*fake_system_state_.mock_request_params(),
119              SetTargetChannel("foo-channel", true, _)).WillOnce(Return(false));
120
121  EXPECT_FALSE(common_service_.SetChannel(&error_, "foo-channel", true));
122  ASSERT_NE(nullptr, error_);
123  EXPECT_TRUE(error_->HasError(UpdateEngineService::kErrorDomain,
124                               UpdateEngineService::kErrorFailed));
125}
126
127TEST_F(UpdateEngineServiceTest, GetChannel) {
128  fake_system_state_.mock_request_params()->set_current_channel("current");
129  fake_system_state_.mock_request_params()->set_target_channel("target");
130  string channel;
131  EXPECT_TRUE(common_service_.GetChannel(
132      &error_, true /* get_current_channel */, &channel));
133  EXPECT_EQ(nullptr, error_);
134  EXPECT_EQ("current", channel);
135
136  EXPECT_TRUE(common_service_.GetChannel(
137      &error_, false /* get_current_channel */, &channel));
138  EXPECT_EQ(nullptr, error_);
139  EXPECT_EQ("target", channel);
140}
141
142TEST_F(UpdateEngineServiceTest, ResetStatusSucceeds) {
143  EXPECT_CALL(*mock_update_attempter_, ResetStatus()).WillOnce(Return(true));
144  EXPECT_TRUE(common_service_.ResetStatus(&error_));
145  EXPECT_EQ(nullptr, error_);
146}
147
148TEST_F(UpdateEngineServiceTest, ResetStatusFails) {
149  EXPECT_CALL(*mock_update_attempter_, ResetStatus()).WillOnce(Return(false));
150  EXPECT_FALSE(common_service_.ResetStatus(&error_));
151  ASSERT_NE(nullptr, error_);
152  EXPECT_TRUE(error_->HasError(UpdateEngineService::kErrorDomain,
153                               UpdateEngineService::kErrorFailed));
154}
155
156TEST_F(UpdateEngineServiceTest, GetEolStatusTest) {
157  FakePrefs fake_prefs;
158  fake_system_state_.set_prefs(&fake_prefs);
159  // The default value should be "supported".
160  int32_t eol_status = static_cast<int32_t>(EolStatus::kEol);
161  EXPECT_TRUE(common_service_.GetEolStatus(&error_, &eol_status));
162  EXPECT_EQ(nullptr, error_);
163  EXPECT_EQ(EolStatus::kSupported, static_cast<EolStatus>(eol_status));
164
165  fake_prefs.SetString(kPrefsOmahaEolStatus, "security-only");
166  EXPECT_TRUE(common_service_.GetEolStatus(&error_, &eol_status));
167  EXPECT_EQ(nullptr, error_);
168  EXPECT_EQ(EolStatus::kSecurityOnly, static_cast<EolStatus>(eol_status));
169}
170
171}  // namespace chromeos_update_engine
172