device_settings_service_unittest.cc revision 5821806d5e7f356e8fa4b058a389a808ea183019 
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 "base/memory/ref_counted.h"
12#include "base/message_loop.h"
13#include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
14#include "chrome/browser/chromeos/settings/mock_owner_key_util.h"
15#include "chrome/browser/policy/policy_builder.h"
16#include "chrome/browser/policy/proto/chrome_device_policy.pb.h"
17#include "chrome/browser/policy/proto/device_management_backend.pb.h"
18#include "content/public/test/test_browser_thread.h"
19#include "testing/gmock/include/gmock/gmock.h"
20#include "testing/gtest/include/gtest/gtest.h"
21
22namespace em = enterprise_management;
23
24using ::testing::Mock;
25
26namespace chromeos {
27
28namespace {
29
30class MockDeviceSettingsObserver : public DeviceSettingsService::Observer {
31 public:
32  virtual ~MockDeviceSettingsObserver() {}
33
34  MOCK_METHOD0(OwnershipStatusChanged, void());
35  MOCK_METHOD0(DeviceSettingsUpdated, void());
36};
37
38}  // namespace
39
40class DeviceSettingsServiceTest : public testing::Test {
41 public:
42  void SetOperationCompleted() {
43    operation_completed_ = true;
44  }
45
46  void SetOwnershipStatus(
47      DeviceSettingsService::OwnershipStatus ownership_status,
48      bool is_owner) {
49    is_owner_ = is_owner;
50    ownership_status_ = ownership_status;
51  }
52
53 protected:
54  DeviceSettingsServiceTest()
55      : owner_key_util_(new chromeos::MockOwnerKeyUtil()),
56        message_loop_(MessageLoop::TYPE_UI),
57        ui_thread_(content::BrowserThread::UI, &message_loop_),
58        file_thread_(content::BrowserThread::FILE, &message_loop_),
59        operation_completed_(false),
60        is_owner_(true),
61        ownership_status_(DeviceSettingsService::OWNERSHIP_UNKNOWN) {}
62
63  virtual void SetUp() OVERRIDE {
64    policy_.payload().mutable_device_policy_refresh_rate()->
65        set_device_policy_refresh_rate(120);
66    policy_.Build();
67    device_settings_test_helper_.set_policy_blob(policy_.GetBlob());
68
69    device_settings_service_.Initialize(&device_settings_test_helper_,
70                                        owner_key_util_);
71  }
72
73  virtual void TearDown() OVERRIDE {
74    device_settings_test_helper_.Flush();
75    device_settings_service_.Shutdown();
76  }
77
78  void CheckPolicy() {
79    ASSERT_TRUE(device_settings_service_.policy_data());
80    EXPECT_EQ(policy_.policy_data().SerializeAsString(),
81              device_settings_service_.policy_data()->SerializeAsString());
82    ASSERT_TRUE(device_settings_service_.device_settings());
83    EXPECT_EQ(policy_.payload().SerializeAsString(),
84              device_settings_service_.device_settings()->SerializeAsString());
85  }
86
87  policy::DevicePolicyBuilder policy_;
88  scoped_refptr<MockOwnerKeyUtil> owner_key_util_;
89
90  DeviceSettingsTestHelper device_settings_test_helper_;
91  DeviceSettingsService device_settings_service_;
92
93  MessageLoop message_loop_;
94  content::TestBrowserThread ui_thread_;
95  content::TestBrowserThread file_thread_;
96
97  bool operation_completed_;
98  bool is_owner_;
99  DeviceSettingsService::OwnershipStatus ownership_status_;
100
101 private:
102  DISALLOW_COPY_AND_ASSIGN(DeviceSettingsServiceTest);
103};
104
105TEST_F(DeviceSettingsServiceTest, LoadNoKey) {
106  device_settings_service_.Load();
107  device_settings_test_helper_.Flush();
108
109  EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE,
110            device_settings_service_.status());
111  EXPECT_FALSE(device_settings_service_.policy_data());
112  EXPECT_FALSE(device_settings_service_.device_settings());
113}
114
115TEST_F(DeviceSettingsServiceTest, LoadNoPolicy) {
116  device_settings_test_helper_.set_policy_blob(std::string());
117  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
118  device_settings_service_.Load();
119  device_settings_test_helper_.Flush();
120
121  EXPECT_EQ(DeviceSettingsService::STORE_NO_POLICY,
122            device_settings_service_.status());
123  EXPECT_FALSE(device_settings_service_.policy_data());
124  EXPECT_FALSE(device_settings_service_.device_settings());
125}
126
127TEST_F(DeviceSettingsServiceTest, LoadValidationError) {
128  policy_.policy().set_policy_data_signature("bad");
129  device_settings_test_helper_.set_policy_blob(policy_.GetBlob());
130  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
131  device_settings_service_.Load();
132  device_settings_test_helper_.Flush();
133
134  EXPECT_EQ(DeviceSettingsService::STORE_VALIDATION_ERROR,
135            device_settings_service_.status());
136  EXPECT_FALSE(device_settings_service_.policy_data());
137  EXPECT_FALSE(device_settings_service_.device_settings());
138}
139
140TEST_F(DeviceSettingsServiceTest, LoadValidationErrorFutureTimestamp) {
141  base::Time timestamp(base::Time::NowFromSystemTime() +
142                       base::TimeDelta::FromDays(5000));
143  policy_.policy_data().set_timestamp(
144      (timestamp - base::Time::UnixEpoch()).InMilliseconds());
145  policy_.Build();
146  device_settings_test_helper_.set_policy_blob(policy_.GetBlob());
147  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
148  device_settings_service_.Load();
149  device_settings_test_helper_.Flush();
150
151  EXPECT_EQ(DeviceSettingsService::STORE_TEMP_VALIDATION_ERROR,
152            device_settings_service_.status());
153  EXPECT_FALSE(device_settings_service_.policy_data());
154  EXPECT_FALSE(device_settings_service_.device_settings());
155}
156
157TEST_F(DeviceSettingsServiceTest, LoadSuccess) {
158  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
159  device_settings_service_.Load();
160  device_settings_test_helper_.Flush();
161
162  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
163            device_settings_service_.status());
164  CheckPolicy();
165}
166
167TEST_F(DeviceSettingsServiceTest, SignAndStoreNoKey) {
168  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
169  device_settings_service_.Load();
170  device_settings_test_helper_.Flush();
171  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
172            device_settings_service_.status());
173
174  scoped_ptr<em::ChromeDeviceSettingsProto> new_device_settings(
175      new em::ChromeDeviceSettingsProto(policy_.payload()));
176  new_device_settings->mutable_device_policy_refresh_rate()->
177      set_device_policy_refresh_rate(300);
178  device_settings_service_.SignAndStore(
179      new_device_settings.Pass(),
180      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
181                 base::Unretained(this)));
182  device_settings_test_helper_.Flush();
183  EXPECT_TRUE(operation_completed_);
184  EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE,
185            device_settings_service_.status());
186  CheckPolicy();
187}
188
189TEST_F(DeviceSettingsServiceTest, SignAndStoreFailure) {
190  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
191  device_settings_service_.Load();
192  device_settings_test_helper_.Flush();
193  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
194            device_settings_service_.status());
195
196  owner_key_util_->SetPrivateKey(policy_.signing_key());
197  device_settings_service_.SetUsername(policy_.policy_data().username());
198  device_settings_test_helper_.Flush();
199
200  scoped_ptr<em::ChromeDeviceSettingsProto> new_device_settings(
201      new em::ChromeDeviceSettingsProto(policy_.payload()));
202  new_device_settings->mutable_device_policy_refresh_rate()->
203      set_device_policy_refresh_rate(300);
204  device_settings_test_helper_.set_store_result(false);
205  device_settings_service_.SignAndStore(
206      new_device_settings.Pass(),
207      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
208                 base::Unretained(this)));
209  device_settings_test_helper_.Flush();
210  EXPECT_TRUE(operation_completed_);
211  EXPECT_EQ(DeviceSettingsService::STORE_OPERATION_FAILED,
212            device_settings_service_.status());
213  CheckPolicy();
214}
215
216TEST_F(DeviceSettingsServiceTest, SignAndStoreSuccess) {
217  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
218  device_settings_service_.Load();
219  device_settings_test_helper_.Flush();
220  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
221            device_settings_service_.status());
222
223  owner_key_util_->SetPrivateKey(policy_.signing_key());
224  device_settings_service_.SetUsername(policy_.policy_data().username());
225  device_settings_test_helper_.Flush();
226
227  policy_.payload().mutable_device_policy_refresh_rate()->
228      set_device_policy_refresh_rate(300);
229  policy_.Build();
230  device_settings_service_.SignAndStore(
231      scoped_ptr<em::ChromeDeviceSettingsProto>(
232          new em::ChromeDeviceSettingsProto(policy_.payload())),
233      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
234                 base::Unretained(this)));
235  device_settings_test_helper_.Flush();
236  EXPECT_TRUE(operation_completed_);
237  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
238            device_settings_service_.status());
239  ASSERT_TRUE(device_settings_service_.device_settings());
240  EXPECT_EQ(policy_.payload().SerializeAsString(),
241            device_settings_service_.device_settings()->SerializeAsString());
242}
243
244TEST_F(DeviceSettingsServiceTest, StoreFailure) {
245  device_settings_test_helper_.set_policy_blob(std::string());
246  device_settings_service_.Load();
247  device_settings_test_helper_.Flush();
248  EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE,
249            device_settings_service_.status());
250
251  device_settings_test_helper_.set_store_result(false);
252  device_settings_service_.Store(
253      policy_.GetCopy(),
254      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
255                 base::Unretained(this)));
256  device_settings_test_helper_.Flush();
257  EXPECT_TRUE(operation_completed_);
258  EXPECT_EQ(DeviceSettingsService::STORE_OPERATION_FAILED,
259            device_settings_service_.status());
260}
261
262TEST_F(DeviceSettingsServiceTest, StoreSuccess) {
263  device_settings_test_helper_.set_policy_blob(std::string());
264  device_settings_service_.Load();
265  device_settings_test_helper_.Flush();
266  EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE,
267            device_settings_service_.status());
268
269  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
270  device_settings_service_.Store(
271      policy_.GetCopy(),
272      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
273                 base::Unretained(this)));
274  device_settings_test_helper_.Flush();
275  EXPECT_TRUE(operation_completed_);
276  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
277            device_settings_service_.status());
278  CheckPolicy();
279}
280
281TEST_F(DeviceSettingsServiceTest, StoreRotation) {
282  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
283  device_settings_service_.Load();
284  device_settings_test_helper_.Flush();
285  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
286            device_settings_service_.status());
287
288  policy_.payload().mutable_device_policy_refresh_rate()->
289      set_device_policy_refresh_rate(300);
290  policy_.set_new_signing_key(policy::PolicyBuilder::CreateTestNewSigningKey());
291  policy_.Build();
292  device_settings_service_.Store(policy_.GetCopy(), base::Closure());
293  device_settings_test_helper_.FlushStore();
294  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.new_signing_key());
295  device_settings_service_.OwnerKeySet(true);
296  device_settings_test_helper_.Flush();
297  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
298            device_settings_service_.status());
299  CheckPolicy();
300
301  // Check the new key has been loaded.
302  std::vector<uint8> key;
303  ASSERT_TRUE(policy_.new_signing_key()->ExportPublicKey(&key));
304  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
305}
306
307TEST_F(DeviceSettingsServiceTest, OwnershipStatus) {
308  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
309  EXPECT_FALSE(device_settings_service_.GetOwnerKey());
310  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_UNKNOWN,
311            device_settings_service_.GetOwnershipStatus());
312
313  device_settings_service_.GetOwnershipStatusAsync(
314      base::Bind(&DeviceSettingsServiceTest::SetOwnershipStatus,
315                 base::Unretained(this)));
316  device_settings_test_helper_.Flush();
317  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
318  ASSERT_TRUE(device_settings_service_.GetOwnerKey());
319  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->public_key());
320  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key());
321  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_NONE,
322            device_settings_service_.GetOwnershipStatus());
323  EXPECT_FALSE(is_owner_);
324  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_NONE, ownership_status_);
325
326  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
327  device_settings_service_.Load();
328  device_settings_test_helper_.Flush();
329  device_settings_service_.GetOwnershipStatusAsync(
330      base::Bind(&DeviceSettingsServiceTest::SetOwnershipStatus,
331                 base::Unretained(this)));
332  device_settings_test_helper_.Flush();
333  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
334  ASSERT_TRUE(device_settings_service_.GetOwnerKey());
335  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
336  std::vector<uint8> key;
337  ASSERT_TRUE(policy_.signing_key()->ExportPublicKey(&key));
338  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
339  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key());
340  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
341            device_settings_service_.GetOwnershipStatus());
342  EXPECT_FALSE(is_owner_);
343  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, ownership_status_);
344
345  owner_key_util_->SetPrivateKey(policy_.signing_key());
346  device_settings_service_.SetUsername(policy_.policy_data().username());
347  device_settings_service_.GetOwnershipStatusAsync(
348      base::Bind(&DeviceSettingsServiceTest::SetOwnershipStatus,
349                 base::Unretained(this)));
350  device_settings_test_helper_.Flush();
351  EXPECT_TRUE(device_settings_service_.HasPrivateOwnerKey());
352  ASSERT_TRUE(device_settings_service_.GetOwnerKey());
353  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
354  ASSERT_TRUE(policy_.signing_key()->ExportPublicKey(&key));
355  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
356  EXPECT_TRUE(device_settings_service_.GetOwnerKey()->private_key());
357  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
358            device_settings_service_.GetOwnershipStatus());
359  EXPECT_TRUE(is_owner_);
360  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, ownership_status_);
361}
362
363TEST_F(DeviceSettingsServiceTest, Observer) {
364  MockDeviceSettingsObserver observer_;
365  device_settings_service_.AddObserver(&observer_);
366
367  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(1);
368  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
369  device_settings_service_.Load();
370  device_settings_test_helper_.Flush();
371  Mock::VerifyAndClearExpectations(&observer_);
372
373  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(1);
374  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
375  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
376  device_settings_service_.OwnerKeySet(true);
377  device_settings_test_helper_.Flush();
378  Mock::VerifyAndClearExpectations(&observer_);
379
380  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(0);
381  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
382  device_settings_service_.Store(policy_.GetCopy(), base::Closure());
383  device_settings_test_helper_.Flush();
384  Mock::VerifyAndClearExpectations(&observer_);
385
386  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(0);
387  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
388  device_settings_service_.PropertyChangeComplete(true);
389  device_settings_test_helper_.Flush();
390  Mock::VerifyAndClearExpectations(&observer_);
391
392  device_settings_service_.RemoveObserver(&observer_);
393}
394
395}  // namespace chromeos
396