device_settings_service_unittest.cc revision 0529e5d033099cbfc42635f6f6183833b09dff6e 
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/time/time.h"
12#include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
13#include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
14#include "components/policy/core/common/cloud/cloud_policy_constants.h"
15#include "policy/proto/device_management_backend.pb.h"
16#include "testing/gmock/include/gmock/gmock.h"
17#include "testing/gtest/include/gtest/gtest.h"
18
19namespace em = enterprise_management;
20
21using ::testing::Mock;
22
23namespace chromeos {
24
25namespace {
26
27class MockDeviceSettingsObserver : public DeviceSettingsService::Observer {
28 public:
29  virtual ~MockDeviceSettingsObserver() {}
30
31  MOCK_METHOD0(OwnershipStatusChanged, void());
32  MOCK_METHOD0(DeviceSettingsUpdated, void());
33};
34
35}  // namespace
36
37class DeviceSettingsServiceTest : public DeviceSettingsTestBase {
38 public:
39  void SetOperationCompleted() {
40    operation_completed_ = true;
41  }
42
43  void SetOwnershipStatus(
44      DeviceSettingsService::OwnershipStatus ownership_status) {
45    ownership_status_ = ownership_status;
46  }
47
48  void OnIsOwner(bool is_owner) {
49    is_owner_ = is_owner;
50    is_owner_set_ = true;
51  }
52
53 protected:
54  DeviceSettingsServiceTest()
55      : operation_completed_(false),
56        is_owner_(true),
57        is_owner_set_(false),
58        ownership_status_(DeviceSettingsService::OWNERSHIP_UNKNOWN) {}
59
60  virtual void SetUp() OVERRIDE {
61    device_policy_.payload().mutable_device_policy_refresh_rate()->
62        set_device_policy_refresh_rate(120);
63    DeviceSettingsTestBase::SetUp();
64  }
65
66  void CheckPolicy() {
67    ASSERT_TRUE(device_settings_service_.policy_data());
68    EXPECT_EQ(device_policy_.policy_data().SerializeAsString(),
69              device_settings_service_.policy_data()->SerializeAsString());
70    ASSERT_TRUE(device_settings_service_.device_settings());
71    EXPECT_EQ(device_policy_.payload().SerializeAsString(),
72              device_settings_service_.device_settings()->SerializeAsString());
73  }
74
75  bool operation_completed_;
76  bool is_owner_;
77  bool is_owner_set_;
78  DeviceSettingsService::OwnershipStatus ownership_status_;
79
80 private:
81  DISALLOW_COPY_AND_ASSIGN(DeviceSettingsServiceTest);
82};
83
84TEST_F(DeviceSettingsServiceTest, LoadNoKey) {
85  owner_key_util_->Clear();
86  ReloadDeviceSettings();
87
88  EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE,
89            device_settings_service_.status());
90  EXPECT_FALSE(device_settings_service_.policy_data());
91  EXPECT_FALSE(device_settings_service_.device_settings());
92}
93
94TEST_F(DeviceSettingsServiceTest, LoadNoPolicy) {
95  device_settings_test_helper_.set_policy_blob(std::string());
96  ReloadDeviceSettings();
97
98  EXPECT_EQ(DeviceSettingsService::STORE_NO_POLICY,
99            device_settings_service_.status());
100  EXPECT_FALSE(device_settings_service_.policy_data());
101  EXPECT_FALSE(device_settings_service_.device_settings());
102}
103
104TEST_F(DeviceSettingsServiceTest, LoadValidationError) {
105  device_policy_.policy().set_policy_data_signature("bad");
106  device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
107  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
108  ReloadDeviceSettings();
109
110  EXPECT_EQ(DeviceSettingsService::STORE_VALIDATION_ERROR,
111            device_settings_service_.status());
112  EXPECT_FALSE(device_settings_service_.policy_data());
113  EXPECT_FALSE(device_settings_service_.device_settings());
114}
115
116TEST_F(DeviceSettingsServiceTest, LoadValidationErrorFutureTimestamp) {
117  base::Time timestamp(base::Time::NowFromSystemTime() +
118                       base::TimeDelta::FromDays(5000));
119  device_policy_.policy_data().set_timestamp(
120      (timestamp - base::Time::UnixEpoch()).InMilliseconds());
121  device_policy_.Build();
122  device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
123  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
124  ReloadDeviceSettings();
125
126  // Loading a cached device policy with a timestamp in the future should work,
127  // since this may be due to a broken clock on the client device.
128  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
129            device_settings_service_.status());
130  CheckPolicy();
131}
132
133TEST_F(DeviceSettingsServiceTest, LoadSuccess) {
134  ReloadDeviceSettings();
135
136  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
137            device_settings_service_.status());
138  CheckPolicy();
139}
140
141TEST_F(DeviceSettingsServiceTest, SignAndStoreNoKey) {
142  ReloadDeviceSettings();
143  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
144            device_settings_service_.status());
145
146  scoped_ptr<em::ChromeDeviceSettingsProto> new_device_settings(
147      new em::ChromeDeviceSettingsProto(device_policy_.payload()));
148  new_device_settings->mutable_device_policy_refresh_rate()->
149      set_device_policy_refresh_rate(300);
150  device_settings_service_.SignAndStore(
151      new_device_settings.Pass(),
152      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
153                 base::Unretained(this)));
154  FlushDeviceSettings();
155  EXPECT_TRUE(operation_completed_);
156  EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE,
157            device_settings_service_.status());
158  CheckPolicy();
159}
160
161TEST_F(DeviceSettingsServiceTest, SignAndStoreFailure) {
162  ReloadDeviceSettings();
163  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
164            device_settings_service_.status());
165
166  owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
167  device_settings_service_.SetUsername(device_policy_.policy_data().username());
168  FlushDeviceSettings();
169
170  scoped_ptr<em::ChromeDeviceSettingsProto> new_device_settings(
171      new em::ChromeDeviceSettingsProto(device_policy_.payload()));
172  new_device_settings->mutable_device_policy_refresh_rate()->
173      set_device_policy_refresh_rate(300);
174  device_settings_test_helper_.set_store_result(false);
175  device_settings_service_.SignAndStore(
176      new_device_settings.Pass(),
177      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
178                 base::Unretained(this)));
179  FlushDeviceSettings();
180  EXPECT_TRUE(operation_completed_);
181  EXPECT_EQ(DeviceSettingsService::STORE_OPERATION_FAILED,
182            device_settings_service_.status());
183  CheckPolicy();
184}
185
186TEST_F(DeviceSettingsServiceTest, SignAndStoreSuccess) {
187  const base::Time before(base::Time::Now());
188  ReloadDeviceSettings();
189  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
190            device_settings_service_.status());
191
192  owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
193  device_settings_service_.SetUsername(device_policy_.policy_data().username());
194  FlushDeviceSettings();
195
196  device_policy_.payload().mutable_device_policy_refresh_rate()->
197      set_device_policy_refresh_rate(300);
198  device_policy_.Build();
199  device_settings_service_.SignAndStore(
200      scoped_ptr<em::ChromeDeviceSettingsProto>(
201          new em::ChromeDeviceSettingsProto(device_policy_.payload())),
202      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
203                 base::Unretained(this)));
204  FlushDeviceSettings();
205  const base::Time after(base::Time::Now());
206
207  EXPECT_TRUE(operation_completed_);
208  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
209            device_settings_service_.status());
210  ASSERT_TRUE(device_settings_service_.device_settings());
211  EXPECT_EQ(device_policy_.payload().SerializeAsString(),
212            device_settings_service_.device_settings()->SerializeAsString());
213
214   // Check that the loaded policy_data contains the expected values.
215  const em::PolicyData* policy_data = device_settings_service_.policy_data();
216  EXPECT_EQ(policy::dm_protocol::kChromeDevicePolicyType,
217            policy_data->policy_type());
218  EXPECT_LE((before - base::Time::UnixEpoch()).InMilliseconds(),
219            policy_data->timestamp());
220  EXPECT_GE((after - base::Time::UnixEpoch()).InMilliseconds(),
221            policy_data->timestamp());
222  EXPECT_EQ(device_settings_service_.GetUsername(),
223            policy_data->username());
224}
225
226TEST_F(DeviceSettingsServiceTest, SetManagementSettingsSuccess) {
227  ReloadDeviceSettings();
228  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
229            device_settings_service_.status());
230
231  owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
232  device_settings_service_.SetUsername(device_policy_.policy_data().username());
233  FlushDeviceSettings();
234
235  device_settings_service_.SetManagementSettings(
236      em::PolicyData::CONSUMER_MANAGED,
237      "fake_request_token",
238      "fake_device_id",
239      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
240                 base::Unretained(this)));
241  FlushDeviceSettings();
242
243  EXPECT_TRUE(operation_completed_);
244  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
245            device_settings_service_.status());
246  ASSERT_TRUE(device_settings_service_.device_settings());
247
248  // Check that the loaded policy_data contains the expected values.
249  const em::PolicyData* policy_data = device_settings_service_.policy_data();
250  EXPECT_EQ(policy::dm_protocol::kChromeDevicePolicyType,
251            policy_data->policy_type());
252  EXPECT_EQ(device_settings_service_.GetUsername(),
253            policy_data->username());
254  EXPECT_EQ(em::PolicyData::CONSUMER_MANAGED, policy_data->management_mode());
255  EXPECT_EQ("fake_request_token", policy_data->request_token());
256  EXPECT_EQ("fake_device_id", policy_data->device_id());
257}
258
259TEST_F(DeviceSettingsServiceTest, StoreFailure) {
260  owner_key_util_->Clear();
261  device_settings_test_helper_.set_policy_blob(std::string());
262  ReloadDeviceSettings();
263  EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE,
264            device_settings_service_.status());
265
266  device_settings_test_helper_.set_store_result(false);
267  device_settings_service_.Store(
268      device_policy_.GetCopy(),
269      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
270                 base::Unretained(this)));
271  FlushDeviceSettings();
272  EXPECT_TRUE(operation_completed_);
273  EXPECT_EQ(DeviceSettingsService::STORE_OPERATION_FAILED,
274            device_settings_service_.status());
275}
276
277TEST_F(DeviceSettingsServiceTest, StoreSuccess) {
278  owner_key_util_->Clear();
279  device_settings_test_helper_.set_policy_blob(std::string());
280  ReloadDeviceSettings();
281  EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE,
282            device_settings_service_.status());
283
284  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
285  device_settings_service_.Store(
286      device_policy_.GetCopy(),
287      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
288                 base::Unretained(this)));
289  FlushDeviceSettings();
290  EXPECT_TRUE(operation_completed_);
291  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
292            device_settings_service_.status());
293  CheckPolicy();
294}
295
296TEST_F(DeviceSettingsServiceTest, StoreRotation) {
297  ReloadDeviceSettings();
298  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
299            device_settings_service_.status());
300
301  device_policy_.payload().mutable_device_policy_refresh_rate()->
302      set_device_policy_refresh_rate(300);
303  device_policy_.SetDefaultNewSigningKey();
304  device_policy_.Build();
305  device_settings_service_.Store(device_policy_.GetCopy(), base::Closure());
306  FlushDeviceSettings();
307  owner_key_util_->SetPublicKeyFromPrivateKey(
308      *device_policy_.GetNewSigningKey());
309  device_settings_service_.OwnerKeySet(true);
310  FlushDeviceSettings();
311  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
312            device_settings_service_.status());
313  CheckPolicy();
314
315  // Check the new key has been loaded.
316  std::vector<uint8> key;
317  ASSERT_TRUE(device_policy_.GetNewSigningKey()->ExportPublicKey(&key));
318  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
319}
320
321TEST_F(DeviceSettingsServiceTest, OwnershipStatus) {
322  owner_key_util_->Clear();
323
324  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
325  EXPECT_FALSE(device_settings_service_.GetOwnerKey().get());
326  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_UNKNOWN,
327            device_settings_service_.GetOwnershipStatus());
328
329  device_settings_service_.GetOwnershipStatusAsync(
330      base::Bind(&DeviceSettingsServiceTest::SetOwnershipStatus,
331                 base::Unretained(this)));
332  FlushDeviceSettings();
333  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
334  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
335  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->public_key());
336  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key());
337  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_NONE,
338            device_settings_service_.GetOwnershipStatus());
339  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_NONE, ownership_status_);
340
341  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
342  ReloadDeviceSettings();
343  device_settings_service_.GetOwnershipStatusAsync(
344      base::Bind(&DeviceSettingsServiceTest::SetOwnershipStatus,
345                 base::Unretained(this)));
346  FlushDeviceSettings();
347  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
348  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
349  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
350  std::vector<uint8> key;
351  ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key));
352  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
353  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key());
354  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
355            device_settings_service_.GetOwnershipStatus());
356  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, ownership_status_);
357
358  owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
359  device_settings_service_.SetUsername(device_policy_.policy_data().username());
360  device_settings_service_.GetOwnershipStatusAsync(
361      base::Bind(&DeviceSettingsServiceTest::SetOwnershipStatus,
362                 base::Unretained(this)));
363  FlushDeviceSettings();
364  EXPECT_TRUE(device_settings_service_.HasPrivateOwnerKey());
365  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
366  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
367  ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key));
368  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
369  EXPECT_TRUE(device_settings_service_.GetOwnerKey()->private_key());
370  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
371            device_settings_service_.GetOwnershipStatus());
372  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, ownership_status_);
373}
374
375TEST_F(DeviceSettingsServiceTest, OnTPMTokenReadyForNonOwner) {
376  owner_key_util_->Clear();
377
378  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
379  EXPECT_FALSE(device_settings_service_.GetOwnerKey().get());
380  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_UNKNOWN,
381            device_settings_service_.GetOwnershipStatus());
382
383  device_settings_service_.IsCurrentUserOwnerAsync(
384      base::Bind(&DeviceSettingsServiceTest::OnIsOwner,
385                 base::Unretained(this)));
386
387  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
388  ReloadDeviceSettings();
389
390  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
391  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
392  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
393  std::vector<uint8> key;
394  ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key));
395  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
396  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key());
397  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
398            device_settings_service_.GetOwnershipStatus());
399  EXPECT_FALSE(is_owner_set_);
400
401  device_settings_service_.OnTPMTokenReady();
402  FlushDeviceSettings();
403
404  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
405  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
406  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
407  ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key));
408  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
409  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key());
410  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
411            device_settings_service_.GetOwnershipStatus());
412  EXPECT_TRUE(is_owner_set_);
413  EXPECT_FALSE(is_owner_);
414}
415
416TEST_F(DeviceSettingsServiceTest, OnTPMTokenReadyForOwner) {
417  owner_key_util_->Clear();
418
419  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
420  EXPECT_FALSE(device_settings_service_.GetOwnerKey().get());
421  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_UNKNOWN,
422            device_settings_service_.GetOwnershipStatus());
423
424  device_settings_service_.IsCurrentUserOwnerAsync(
425      base::Bind(&DeviceSettingsServiceTest::OnIsOwner,
426                 base::Unretained(this)));
427
428  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
429  ReloadDeviceSettings();
430
431  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
432  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
433  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
434  std::vector<uint8> key;
435  ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key));
436  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
437  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key());
438  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
439            device_settings_service_.GetOwnershipStatus());
440  EXPECT_FALSE(is_owner_set_);
441
442  owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
443  device_settings_service_.SetUsername(device_policy_.policy_data().username());
444  device_settings_service_.OnTPMTokenReady();
445  FlushDeviceSettings();
446
447  EXPECT_TRUE(device_settings_service_.HasPrivateOwnerKey());
448  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
449  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
450  ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key));
451  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
452  EXPECT_TRUE(device_settings_service_.GetOwnerKey()->private_key());
453  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
454            device_settings_service_.GetOwnershipStatus());
455  EXPECT_TRUE(is_owner_set_);
456  EXPECT_TRUE(is_owner_);
457}
458
459TEST_F(DeviceSettingsServiceTest, IsCurrentUserOwnerAsyncWithLoadedCerts) {
460  owner_key_util_->Clear();
461
462  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
463  EXPECT_FALSE(device_settings_service_.GetOwnerKey().get());
464  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_UNKNOWN,
465            device_settings_service_.GetOwnershipStatus());
466
467  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
468  owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
469  device_settings_service_.SetUsername(device_policy_.policy_data().username());
470  ReloadDeviceSettings();
471
472  device_settings_service_.OnTPMTokenReady();
473  FlushDeviceSettings();
474
475  EXPECT_TRUE(device_settings_service_.HasPrivateOwnerKey());
476  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
477  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
478  std::vector<uint8> key;
479  ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key));
480  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
481  EXPECT_TRUE(device_settings_service_.GetOwnerKey()->private_key());
482  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
483            device_settings_service_.GetOwnershipStatus());
484  EXPECT_FALSE(is_owner_set_);
485
486  device_settings_service_.IsCurrentUserOwnerAsync(
487      base::Bind(&DeviceSettingsServiceTest::OnIsOwner,
488                 base::Unretained(this)));
489  // The callback should be called immediately.
490  base::MessageLoop::current()->RunUntilIdle();
491
492  EXPECT_TRUE(device_settings_service_.HasPrivateOwnerKey());
493  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
494  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
495  ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key));
496  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
497  EXPECT_TRUE(device_settings_service_.GetOwnerKey()->private_key());
498  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
499            device_settings_service_.GetOwnershipStatus());
500  EXPECT_TRUE(is_owner_set_);
501  EXPECT_TRUE(is_owner_);
502}
503
504TEST_F(DeviceSettingsServiceTest, Observer) {
505  owner_key_util_->Clear();
506  MockDeviceSettingsObserver observer_;
507  device_settings_service_.AddObserver(&observer_);
508
509  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(1);
510  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
511  ReloadDeviceSettings();
512  Mock::VerifyAndClearExpectations(&observer_);
513
514  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(1);
515  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
516  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
517  ReloadDeviceSettings();
518  Mock::VerifyAndClearExpectations(&observer_);
519
520  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(0);
521  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
522  device_settings_service_.Store(device_policy_.GetCopy(), base::Closure());
523  FlushDeviceSettings();
524  Mock::VerifyAndClearExpectations(&observer_);
525
526  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(0);
527  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
528  device_settings_service_.PropertyChangeComplete(true);
529  FlushDeviceSettings();
530  Mock::VerifyAndClearExpectations(&observer_);
531
532  device_settings_service_.RemoveObserver(&observer_);
533}
534
535}  // namespace chromeos
536