1//
2// Copyright (C) 2012 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#ifndef UPDATE_ENGINE_FAKE_SYSTEM_STATE_H_
18#define UPDATE_ENGINE_FAKE_SYSTEM_STATE_H_
19
20#include <base/logging.h>
21#include <gmock/gmock.h>
22#include <policy/mock_device_policy.h>
23#include <power_manager/dbus-proxies.h>
24#include <power_manager/dbus-proxy-mocks.h>
25
26#include "metrics/metrics_library_mock.h"
27#include "update_engine/common/fake_boot_control.h"
28#include "update_engine/common/fake_clock.h"
29#include "update_engine/common/fake_hardware.h"
30#include "update_engine/common/mock_prefs.h"
31#include "update_engine/mock_connection_manager.h"
32#include "update_engine/mock_omaha_request_params.h"
33#include "update_engine/mock_p2p_manager.h"
34#include "update_engine/mock_payload_state.h"
35#include "update_engine/mock_update_attempter.h"
36#include "update_engine/system_state.h"
37#include "update_engine/update_manager/fake_update_manager.h"
38
39namespace chromeos_update_engine {
40
41// Mock the SystemStateInterface so that we could lie that
42// OOBE is completed even when there's no such marker file, etc.
43class FakeSystemState : public SystemState {
44 public:
45  FakeSystemState();
46
47  // Base class overrides. All getters return the current implementation of
48  // various members, either the default (fake/mock) or the one set to override
49  // it by client code.
50
51  BootControlInterface* boot_control() override { return boot_control_; }
52
53  inline ClockInterface* clock() override { return clock_; }
54
55  inline void set_device_policy(
56      const policy::DevicePolicy* device_policy) override {
57    device_policy_ = device_policy;
58  }
59
60  inline const policy::DevicePolicy* device_policy() override {
61    return device_policy_;
62  }
63
64  inline ConnectionManagerInterface* connection_manager() override {
65    return connection_manager_;
66  }
67
68  inline HardwareInterface* hardware() override { return hardware_; }
69
70  inline MetricsLibraryInterface* metrics_lib() override {
71    return metrics_lib_;
72  }
73
74  inline PrefsInterface* prefs() override { return prefs_; }
75
76  inline PrefsInterface* powerwash_safe_prefs() override {
77    return powerwash_safe_prefs_;
78  }
79
80  inline PayloadStateInterface* payload_state() override {
81    return payload_state_;
82  }
83
84  inline UpdateAttempter* update_attempter() override {
85    return update_attempter_;
86  }
87
88  inline WeaveServiceInterface* weave_service() override { return nullptr; }
89
90  inline OmahaRequestParams* request_params() override {
91    return request_params_;
92  }
93
94  inline P2PManager* p2p_manager() override { return p2p_manager_; }
95
96  inline chromeos_update_manager::UpdateManager* update_manager() override {
97    return update_manager_;
98  }
99
100  inline org::chromium::PowerManagerProxyInterface* power_manager_proxy()
101      override {
102    return power_manager_proxy_;
103  }
104
105  inline bool system_rebooted() override { return fake_system_rebooted_; }
106
107  // Setters for the various members, can be used for overriding the default
108  // implementations. For convenience, setting to a null pointer will restore
109  // the default implementation.
110
111  void set_boot_control(BootControlInterface* boot_control) {
112    boot_control_ = boot_control ? boot_control : &fake_boot_control_;
113  }
114
115  inline void set_clock(ClockInterface* clock) {
116    clock_ = clock ? clock : &fake_clock_;
117  }
118
119  inline void set_connection_manager(
120      ConnectionManagerInterface* connection_manager) {
121    connection_manager_ = (connection_manager ? connection_manager :
122                           &mock_connection_manager_);
123  }
124
125  inline void set_hardware(HardwareInterface* hardware) {
126    hardware_ = hardware ? hardware : &fake_hardware_;
127  }
128
129  inline void set_metrics_lib(MetricsLibraryInterface* metrics_lib) {
130    metrics_lib_ = metrics_lib ? metrics_lib : &mock_metrics_lib_;
131  }
132
133  inline void set_prefs(PrefsInterface* prefs) {
134    prefs_ = prefs ? prefs : &mock_prefs_;
135  }
136
137  inline void set_powerwash_safe_prefs(PrefsInterface* powerwash_safe_prefs) {
138    powerwash_safe_prefs_ = (powerwash_safe_prefs ? powerwash_safe_prefs :
139                             &mock_powerwash_safe_prefs_);
140  }
141
142  inline void set_payload_state(PayloadStateInterface *payload_state) {
143    payload_state_ = payload_state ? payload_state : &mock_payload_state_;
144  }
145
146  inline void set_update_attempter(UpdateAttempter* update_attempter) {
147    update_attempter_ = (update_attempter ? update_attempter :
148                         &mock_update_attempter_);
149  }
150
151  inline void set_request_params(OmahaRequestParams* request_params) {
152    request_params_ = (request_params ? request_params :
153                       &mock_request_params_);
154  }
155
156  inline void set_p2p_manager(P2PManager *p2p_manager) {
157    p2p_manager_ = p2p_manager ? p2p_manager : &mock_p2p_manager_;
158  }
159
160  inline void set_update_manager(
161      chromeos_update_manager::UpdateManager *update_manager) {
162    update_manager_ = update_manager ? update_manager : &fake_update_manager_;
163  }
164
165  inline void set_system_rebooted(bool system_rebooted) {
166    fake_system_rebooted_ = system_rebooted;
167  }
168
169  // Getters for the built-in default implementations. These return the actual
170  // concrete type of each implementation. For additional safety, they will fail
171  // whenever the requested default was overridden by a different
172  // implementation.
173
174  inline FakeBootControl* fake_boot_control() {
175    CHECK(boot_control_ == &fake_boot_control_);
176    return &fake_boot_control_;
177  }
178
179  inline FakeClock* fake_clock() {
180    CHECK(clock_ == &fake_clock_);
181    return &fake_clock_;
182  }
183
184  inline testing::NiceMock<MockConnectionManager>* mock_connection_manager() {
185    CHECK(connection_manager_ == &mock_connection_manager_);
186    return &mock_connection_manager_;
187  }
188
189  inline FakeHardware* fake_hardware() {
190    CHECK(hardware_ == &fake_hardware_);
191    return &fake_hardware_;
192  }
193
194  inline testing::NiceMock<MetricsLibraryMock>* mock_metrics_lib() {
195    CHECK(metrics_lib_ == &mock_metrics_lib_);
196    return &mock_metrics_lib_;
197  }
198
199  inline testing::NiceMock<MockPrefs> *mock_prefs() {
200    CHECK(prefs_ == &mock_prefs_);
201    return &mock_prefs_;
202  }
203
204  inline testing::NiceMock<MockPrefs> *mock_powerwash_safe_prefs() {
205    CHECK(powerwash_safe_prefs_ == &mock_powerwash_safe_prefs_);
206    return &mock_powerwash_safe_prefs_;
207  }
208
209  inline testing::NiceMock<MockPayloadState>* mock_payload_state() {
210    CHECK(payload_state_ == &mock_payload_state_);
211    return &mock_payload_state_;
212  }
213
214  inline testing::NiceMock<MockUpdateAttempter>* mock_update_attempter() {
215    CHECK(update_attempter_ == &mock_update_attempter_);
216    return &mock_update_attempter_;
217  }
218
219  inline testing::NiceMock<MockOmahaRequestParams>* mock_request_params() {
220    CHECK(request_params_ == &mock_request_params_);
221    return &mock_request_params_;
222  }
223
224  inline testing::NiceMock<MockP2PManager>* mock_p2p_manager() {
225    CHECK(p2p_manager_ == &mock_p2p_manager_);
226    return &mock_p2p_manager_;
227  }
228
229  inline chromeos_update_manager::FakeUpdateManager* fake_update_manager() {
230    CHECK(update_manager_ == &fake_update_manager_);
231    return &fake_update_manager_;
232  }
233
234 private:
235  // Default mock/fake implementations (owned).
236  FakeBootControl fake_boot_control_;
237  FakeClock fake_clock_;
238  testing::NiceMock<MockConnectionManager> mock_connection_manager_;
239  FakeHardware fake_hardware_;
240  testing::NiceMock<MetricsLibraryMock> mock_metrics_lib_;
241  testing::NiceMock<MockPrefs> mock_prefs_;
242  testing::NiceMock<MockPrefs> mock_powerwash_safe_prefs_;
243  testing::NiceMock<MockPayloadState> mock_payload_state_;
244  testing::NiceMock<MockUpdateAttempter> mock_update_attempter_;
245  testing::NiceMock<MockOmahaRequestParams> mock_request_params_;
246  testing::NiceMock<MockP2PManager> mock_p2p_manager_;
247  chromeos_update_manager::FakeUpdateManager fake_update_manager_;
248  org::chromium::PowerManagerProxyMock mock_power_manager_;
249
250  // Pointers to objects that client code can override. They are initialized to
251  // the default implementations above.
252  BootControlInterface* boot_control_{&fake_boot_control_};
253  ClockInterface* clock_;
254  ConnectionManagerInterface* connection_manager_;
255  HardwareInterface* hardware_;
256  MetricsLibraryInterface* metrics_lib_;
257  PrefsInterface* prefs_;
258  PrefsInterface* powerwash_safe_prefs_;
259  PayloadStateInterface* payload_state_;
260  UpdateAttempter* update_attempter_;
261  OmahaRequestParams* request_params_;
262  P2PManager* p2p_manager_;
263  chromeos_update_manager::UpdateManager* update_manager_;
264  org::chromium::PowerManagerProxyInterface* power_manager_proxy_{
265      &mock_power_manager_};
266
267  // Other object pointers (not preinitialized).
268  const policy::DevicePolicy* device_policy_;
269
270  // Other data members.
271  bool fake_system_rebooted_;
272};
273
274}  // namespace chromeos_update_engine
275
276#endif  // UPDATE_ENGINE_FAKE_SYSTEM_STATE_H_
277