device_settings_service_unittest.cc revision 2385ea399aae016c0806a4f9ef3c9cfe3d2a39df 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/chromeos/settings/device_settings_service.h"
6
7#include "base/basictypes.h"
8#include "base/bind.h"
9#include "base/bind_helpers.h"
10#include "base/compiler_specific.h"
11#include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
12#include "chrome/browser/policy/proto/chromeos/chrome_device_policy.pb.h"
13#include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h"
14#include "testing/gmock/include/gmock/gmock.h"
15#include "testing/gtest/include/gtest/gtest.h"
16
17namespace em = enterprise_management;
18
19using ::testing::Mock;
20
21namespace chromeos {
22
23namespace {
24
25class MockDeviceSettingsObserver : public DeviceSettingsService::Observer {
26 public:
27  virtual ~MockDeviceSettingsObserver() {}
28
29  MOCK_METHOD0(OwnershipStatusChanged, void());
30  MOCK_METHOD0(DeviceSettingsUpdated, void());
31};
32
33}  // namespace
34
35class DeviceSettingsServiceTest : public DeviceSettingsTestBase {
36 public:
37  void SetOperationCompleted() {
38    operation_completed_ = true;
39  }
40
41  void SetOwnershipStatus(
42      DeviceSettingsService::OwnershipStatus ownership_status,
43      bool is_owner) {
44    is_owner_ = is_owner;
45    ownership_status_ = ownership_status;
46  }
47
48 protected:
49  DeviceSettingsServiceTest()
50      : operation_completed_(false),
51        is_owner_(true),
52        ownership_status_(DeviceSettingsService::OWNERSHIP_UNKNOWN) {}
53
54  virtual void SetUp() OVERRIDE {
55    device_policy_.payload().mutable_device_policy_refresh_rate()->
56        set_device_policy_refresh_rate(120);
57    DeviceSettingsTestBase::SetUp();
58  }
59
60  void CheckPolicy() {
61    ASSERT_TRUE(device_settings_service_.policy_data());
62    EXPECT_EQ(device_policy_.policy_data().SerializeAsString(),
63              device_settings_service_.policy_data()->SerializeAsString());
64    ASSERT_TRUE(device_settings_service_.device_settings());
65    EXPECT_EQ(device_policy_.payload().SerializeAsString(),
66              device_settings_service_.device_settings()->SerializeAsString());
67  }
68
69  bool operation_completed_;
70  bool is_owner_;
71  DeviceSettingsService::OwnershipStatus ownership_status_;
72
73 private:
74  DISALLOW_COPY_AND_ASSIGN(DeviceSettingsServiceTest);
75};
76
77TEST_F(DeviceSettingsServiceTest, LoadNoKey) {
78  owner_key_util_->Clear();
79  ReloadDeviceSettings();
80
81  EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE,
82            device_settings_service_.status());
83  EXPECT_FALSE(device_settings_service_.policy_data());
84  EXPECT_FALSE(device_settings_service_.device_settings());
85}
86
87TEST_F(DeviceSettingsServiceTest, LoadNoPolicy) {
88  device_settings_test_helper_.set_policy_blob(std::string());
89  ReloadDeviceSettings();
90
91  EXPECT_EQ(DeviceSettingsService::STORE_NO_POLICY,
92            device_settings_service_.status());
93  EXPECT_FALSE(device_settings_service_.policy_data());
94  EXPECT_FALSE(device_settings_service_.device_settings());
95}
96
97TEST_F(DeviceSettingsServiceTest, LoadValidationError) {
98  device_policy_.policy().set_policy_data_signature("bad");
99  device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
100  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
101  ReloadDeviceSettings();
102
103  EXPECT_EQ(DeviceSettingsService::STORE_VALIDATION_ERROR,
104            device_settings_service_.status());
105  EXPECT_FALSE(device_settings_service_.policy_data());
106  EXPECT_FALSE(device_settings_service_.device_settings());
107}
108
109TEST_F(DeviceSettingsServiceTest, LoadValidationErrorFutureTimestamp) {
110  base::Time timestamp(base::Time::NowFromSystemTime() +
111                       base::TimeDelta::FromDays(5000));
112  device_policy_.policy_data().set_timestamp(
113      (timestamp - base::Time::UnixEpoch()).InMilliseconds());
114  device_policy_.Build();
115  device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
116  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
117  ReloadDeviceSettings();
118
119  EXPECT_EQ(DeviceSettingsService::STORE_TEMP_VALIDATION_ERROR,
120            device_settings_service_.status());
121  EXPECT_FALSE(device_settings_service_.policy_data());
122  EXPECT_FALSE(device_settings_service_.device_settings());
123}
124
125TEST_F(DeviceSettingsServiceTest, LoadSuccess) {
126  ReloadDeviceSettings();
127
128  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
129            device_settings_service_.status());
130  CheckPolicy();
131}
132
133TEST_F(DeviceSettingsServiceTest, SignAndStoreNoKey) {
134  ReloadDeviceSettings();
135  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
136            device_settings_service_.status());
137
138  scoped_ptr<em::ChromeDeviceSettingsProto> new_device_settings(
139      new em::ChromeDeviceSettingsProto(device_policy_.payload()));
140  new_device_settings->mutable_device_policy_refresh_rate()->
141      set_device_policy_refresh_rate(300);
142  device_settings_service_.SignAndStore(
143      new_device_settings.Pass(),
144      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
145                 base::Unretained(this)));
146  FlushDeviceSettings();
147  EXPECT_TRUE(operation_completed_);
148  EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE,
149            device_settings_service_.status());
150  CheckPolicy();
151}
152
153TEST_F(DeviceSettingsServiceTest, SignAndStoreFailure) {
154  ReloadDeviceSettings();
155  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
156            device_settings_service_.status());
157
158  owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
159  device_settings_service_.SetUsername(device_policy_.policy_data().username());
160  FlushDeviceSettings();
161
162  scoped_ptr<em::ChromeDeviceSettingsProto> new_device_settings(
163      new em::ChromeDeviceSettingsProto(device_policy_.payload()));
164  new_device_settings->mutable_device_policy_refresh_rate()->
165      set_device_policy_refresh_rate(300);
166  device_settings_test_helper_.set_store_result(false);
167  device_settings_service_.SignAndStore(
168      new_device_settings.Pass(),
169      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
170                 base::Unretained(this)));
171  FlushDeviceSettings();
172  EXPECT_TRUE(operation_completed_);
173  EXPECT_EQ(DeviceSettingsService::STORE_OPERATION_FAILED,
174            device_settings_service_.status());
175  CheckPolicy();
176}
177
178TEST_F(DeviceSettingsServiceTest, SignAndStoreSuccess) {
179  ReloadDeviceSettings();
180  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
181            device_settings_service_.status());
182
183  owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
184  device_settings_service_.SetUsername(device_policy_.policy_data().username());
185  FlushDeviceSettings();
186
187  device_policy_.payload().mutable_device_policy_refresh_rate()->
188      set_device_policy_refresh_rate(300);
189  device_policy_.Build();
190  device_settings_service_.SignAndStore(
191      scoped_ptr<em::ChromeDeviceSettingsProto>(
192          new em::ChromeDeviceSettingsProto(device_policy_.payload())),
193      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
194                 base::Unretained(this)));
195  FlushDeviceSettings();
196  EXPECT_TRUE(operation_completed_);
197  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
198            device_settings_service_.status());
199  ASSERT_TRUE(device_settings_service_.device_settings());
200  EXPECT_EQ(device_policy_.payload().SerializeAsString(),
201            device_settings_service_.device_settings()->SerializeAsString());
202}
203
204TEST_F(DeviceSettingsServiceTest, StoreFailure) {
205  owner_key_util_->Clear();
206  device_settings_test_helper_.set_policy_blob(std::string());
207  ReloadDeviceSettings();
208  EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE,
209            device_settings_service_.status());
210
211  device_settings_test_helper_.set_store_result(false);
212  device_settings_service_.Store(
213      device_policy_.GetCopy(),
214      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
215                 base::Unretained(this)));
216  FlushDeviceSettings();
217  EXPECT_TRUE(operation_completed_);
218  EXPECT_EQ(DeviceSettingsService::STORE_OPERATION_FAILED,
219            device_settings_service_.status());
220}
221
222TEST_F(DeviceSettingsServiceTest, StoreSuccess) {
223  owner_key_util_->Clear();
224  device_settings_test_helper_.set_policy_blob(std::string());
225  ReloadDeviceSettings();
226  EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE,
227            device_settings_service_.status());
228
229  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
230  device_settings_service_.Store(
231      device_policy_.GetCopy(),
232      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
233                 base::Unretained(this)));
234  FlushDeviceSettings();
235  EXPECT_TRUE(operation_completed_);
236  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
237            device_settings_service_.status());
238  CheckPolicy();
239}
240
241TEST_F(DeviceSettingsServiceTest, StoreRotation) {
242  ReloadDeviceSettings();
243  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
244            device_settings_service_.status());
245
246  device_policy_.payload().mutable_device_policy_refresh_rate()->
247      set_device_policy_refresh_rate(300);
248  device_policy_.SetDefaultNewSigningKey();
249  device_policy_.Build();
250  device_settings_service_.Store(device_policy_.GetCopy(), base::Closure());
251  FlushDeviceSettings();
252  owner_key_util_->SetPublicKeyFromPrivateKey(
253      *device_policy_.GetNewSigningKey());
254  device_settings_service_.OwnerKeySet(true);
255  FlushDeviceSettings();
256  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
257            device_settings_service_.status());
258  CheckPolicy();
259
260  // Check the new key has been loaded.
261  std::vector<uint8> key;
262  ASSERT_TRUE(device_policy_.GetNewSigningKey()->ExportPublicKey(&key));
263  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
264}
265
266TEST_F(DeviceSettingsServiceTest, OwnershipStatus) {
267  owner_key_util_->Clear();
268
269  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
270  EXPECT_FALSE(device_settings_service_.GetOwnerKey().get());
271  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_UNKNOWN,
272            device_settings_service_.GetOwnershipStatus());
273
274  device_settings_service_.GetOwnershipStatusAsync(
275      base::Bind(&DeviceSettingsServiceTest::SetOwnershipStatus,
276                 base::Unretained(this)));
277  FlushDeviceSettings();
278  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
279  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
280  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->public_key());
281  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key());
282  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_NONE,
283            device_settings_service_.GetOwnershipStatus());
284  EXPECT_FALSE(is_owner_);
285  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_NONE, ownership_status_);
286
287  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
288  ReloadDeviceSettings();
289  device_settings_service_.GetOwnershipStatusAsync(
290      base::Bind(&DeviceSettingsServiceTest::SetOwnershipStatus,
291                 base::Unretained(this)));
292  FlushDeviceSettings();
293  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
294  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
295  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
296  std::vector<uint8> key;
297  ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key));
298  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
299  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key());
300  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
301            device_settings_service_.GetOwnershipStatus());
302  EXPECT_FALSE(is_owner_);
303  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, ownership_status_);
304
305  owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
306  device_settings_service_.SetUsername(device_policy_.policy_data().username());
307  device_settings_service_.GetOwnershipStatusAsync(
308      base::Bind(&DeviceSettingsServiceTest::SetOwnershipStatus,
309                 base::Unretained(this)));
310  FlushDeviceSettings();
311  EXPECT_TRUE(device_settings_service_.HasPrivateOwnerKey());
312  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
313  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
314  ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key));
315  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
316  EXPECT_TRUE(device_settings_service_.GetOwnerKey()->private_key());
317  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
318            device_settings_service_.GetOwnershipStatus());
319  EXPECT_TRUE(is_owner_);
320  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, ownership_status_);
321}
322
323TEST_F(DeviceSettingsServiceTest, Observer) {
324  owner_key_util_->Clear();
325  MockDeviceSettingsObserver observer_;
326  device_settings_service_.AddObserver(&observer_);
327
328  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(1);
329  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
330  ReloadDeviceSettings();
331  Mock::VerifyAndClearExpectations(&observer_);
332
333  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(1);
334  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
335  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
336  ReloadDeviceSettings();
337  Mock::VerifyAndClearExpectations(&observer_);
338
339  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(0);
340  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
341  device_settings_service_.Store(device_policy_.GetCopy(), base::Closure());
342  FlushDeviceSettings();
343  Mock::VerifyAndClearExpectations(&observer_);
344
345  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(0);
346  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
347  device_settings_service_.PropertyChangeComplete(true);
348  FlushDeviceSettings();
349  Mock::VerifyAndClearExpectations(&observer_);
350
351  device_settings_service_.RemoveObserver(&observer_);
352}
353
354}  // namespace chromeos
355