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