device_settings_service_unittest.cc revision 5c02ac1a9c1b504631c0a3d2b6e737b5d738bae1 
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, SetManagementSettingsModeTransition) {
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  // The initial management mode should be NOT_MANAGED.
236  EXPECT_EQ(em::PolicyData::NOT_MANAGED,
237            device_settings_service_.policy_data()->management_mode());
238
239  // NOT_MANAGED -> CONSUMER_MANAGED: Okay.
240  device_settings_service_.SetManagementSettings(
241      em::PolicyData::CONSUMER_MANAGED,
242      "fake_request_token",
243      "fake_device_id",
244      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
245                 base::Unretained(this)));
246  FlushDeviceSettings();
247
248  EXPECT_TRUE(operation_completed_);
249  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
250            device_settings_service_.status());
251  EXPECT_EQ(em::PolicyData::CONSUMER_MANAGED,
252            device_settings_service_.policy_data()->management_mode());
253
254  // CONSUMER_MANAGED -> ENTERPRISE_MANAGED: Invalid.
255  device_settings_service_.SetManagementSettings(
256      em::PolicyData::ENTERPRISE_MANAGED,
257      "fake_request_token",
258      "fake_device_id",
259      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
260                 base::Unretained(this)));
261  FlushDeviceSettings();
262
263  EXPECT_TRUE(operation_completed_);
264  EXPECT_EQ(DeviceSettingsService::STORE_POLICY_ERROR,
265            device_settings_service_.status());
266  EXPECT_EQ(em::PolicyData::CONSUMER_MANAGED,
267            device_settings_service_.policy_data()->management_mode());
268
269  // CONSUMER_MANAGED -> NOT_MANAGED: Okay.
270  device_settings_service_.SetManagementSettings(
271      em::PolicyData::NOT_MANAGED,
272      "fake_request_token",
273      "fake_device_id",
274      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
275                 base::Unretained(this)));
276  FlushDeviceSettings();
277
278  EXPECT_TRUE(operation_completed_);
279  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
280            device_settings_service_.status());
281  EXPECT_EQ(em::PolicyData::NOT_MANAGED,
282            device_settings_service_.policy_data()->management_mode());
283
284  // NOT_MANAGED -> ENTERPRISE_MANAGED: Invalid.
285  device_settings_service_.SetManagementSettings(
286      em::PolicyData::ENTERPRISE_MANAGED,
287      "fake_request_token",
288      "fake_device_id",
289      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
290                 base::Unretained(this)));
291  FlushDeviceSettings();
292
293  EXPECT_TRUE(operation_completed_);
294  EXPECT_EQ(DeviceSettingsService::STORE_POLICY_ERROR,
295            device_settings_service_.status());
296  EXPECT_EQ(em::PolicyData::NOT_MANAGED,
297            device_settings_service_.policy_data()->management_mode());
298
299  // Inject a policy data with management mode set to ENTERPRISE_MANAGED.
300  device_policy_.policy_data().set_management_mode(
301      em::PolicyData::ENTERPRISE_MANAGED);
302  device_policy_.Build();
303  device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
304  ReloadDeviceSettings();
305  EXPECT_EQ(em::PolicyData::ENTERPRISE_MANAGED,
306            device_settings_service_.policy_data()->management_mode());
307
308  // ENTERPRISE_MANAGED -> NOT_MANAGED: Invalid.
309  device_settings_service_.SetManagementSettings(
310      em::PolicyData::NOT_MANAGED,
311      "fake_request_token",
312      "fake_device_id",
313      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
314                 base::Unretained(this)));
315  FlushDeviceSettings();
316
317  EXPECT_TRUE(operation_completed_);
318  EXPECT_EQ(DeviceSettingsService::STORE_POLICY_ERROR,
319            device_settings_service_.status());
320  EXPECT_EQ(em::PolicyData::ENTERPRISE_MANAGED,
321            device_settings_service_.policy_data()->management_mode());
322
323  // ENTERPRISE_MANAGED -> CONSUMER_MANAGED: Invalid.
324  device_settings_service_.SetManagementSettings(
325      em::PolicyData::CONSUMER_MANAGED,
326      "fake_request_token",
327      "fake_device_id",
328      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
329                 base::Unretained(this)));
330  FlushDeviceSettings();
331
332  EXPECT_TRUE(operation_completed_);
333  EXPECT_EQ(DeviceSettingsService::STORE_POLICY_ERROR,
334            device_settings_service_.status());
335  EXPECT_EQ(em::PolicyData::ENTERPRISE_MANAGED,
336            device_settings_service_.policy_data()->management_mode());
337
338}
339
340TEST_F(DeviceSettingsServiceTest, SetManagementSettingsSuccess) {
341  ReloadDeviceSettings();
342  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
343            device_settings_service_.status());
344
345  owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
346  device_settings_service_.SetUsername(device_policy_.policy_data().username());
347  FlushDeviceSettings();
348
349  device_settings_service_.SetManagementSettings(
350      em::PolicyData::CONSUMER_MANAGED,
351      "fake_request_token",
352      "fake_device_id",
353      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
354                 base::Unretained(this)));
355  FlushDeviceSettings();
356
357  EXPECT_TRUE(operation_completed_);
358  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
359            device_settings_service_.status());
360  ASSERT_TRUE(device_settings_service_.device_settings());
361
362  // Check that the loaded policy_data contains the expected values.
363  const em::PolicyData* policy_data = device_settings_service_.policy_data();
364  EXPECT_EQ(policy::dm_protocol::kChromeDevicePolicyType,
365            policy_data->policy_type());
366  EXPECT_EQ(device_settings_service_.GetUsername(),
367            policy_data->username());
368  EXPECT_EQ(em::PolicyData::CONSUMER_MANAGED, policy_data->management_mode());
369  EXPECT_EQ("fake_request_token", policy_data->request_token());
370  EXPECT_EQ("fake_device_id", policy_data->device_id());
371}
372
373TEST_F(DeviceSettingsServiceTest, StoreFailure) {
374  owner_key_util_->Clear();
375  device_settings_test_helper_.set_policy_blob(std::string());
376  ReloadDeviceSettings();
377  EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE,
378            device_settings_service_.status());
379
380  device_settings_test_helper_.set_store_result(false);
381  device_settings_service_.Store(
382      device_policy_.GetCopy(),
383      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
384                 base::Unretained(this)));
385  FlushDeviceSettings();
386  EXPECT_TRUE(operation_completed_);
387  EXPECT_EQ(DeviceSettingsService::STORE_OPERATION_FAILED,
388            device_settings_service_.status());
389}
390
391TEST_F(DeviceSettingsServiceTest, StoreSuccess) {
392  owner_key_util_->Clear();
393  device_settings_test_helper_.set_policy_blob(std::string());
394  ReloadDeviceSettings();
395  EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE,
396            device_settings_service_.status());
397
398  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
399  device_settings_service_.Store(
400      device_policy_.GetCopy(),
401      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
402                 base::Unretained(this)));
403  FlushDeviceSettings();
404  EXPECT_TRUE(operation_completed_);
405  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
406            device_settings_service_.status());
407  CheckPolicy();
408}
409
410TEST_F(DeviceSettingsServiceTest, StoreRotation) {
411  ReloadDeviceSettings();
412  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
413            device_settings_service_.status());
414
415  device_policy_.payload().mutable_device_policy_refresh_rate()->
416      set_device_policy_refresh_rate(300);
417  device_policy_.SetDefaultNewSigningKey();
418  device_policy_.Build();
419  device_settings_service_.Store(device_policy_.GetCopy(), base::Closure());
420  FlushDeviceSettings();
421  owner_key_util_->SetPublicKeyFromPrivateKey(
422      *device_policy_.GetNewSigningKey());
423  device_settings_service_.OwnerKeySet(true);
424  FlushDeviceSettings();
425  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
426            device_settings_service_.status());
427  CheckPolicy();
428
429  // Check the new key has been loaded.
430  std::vector<uint8> key;
431  ASSERT_TRUE(device_policy_.GetNewSigningKey()->ExportPublicKey(&key));
432  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
433}
434
435TEST_F(DeviceSettingsServiceTest, OwnershipStatus) {
436  owner_key_util_->Clear();
437
438  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
439  EXPECT_FALSE(device_settings_service_.GetOwnerKey().get());
440  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_UNKNOWN,
441            device_settings_service_.GetOwnershipStatus());
442
443  device_settings_service_.GetOwnershipStatusAsync(
444      base::Bind(&DeviceSettingsServiceTest::SetOwnershipStatus,
445                 base::Unretained(this)));
446  FlushDeviceSettings();
447  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
448  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
449  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->public_key());
450  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key());
451  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_NONE,
452            device_settings_service_.GetOwnershipStatus());
453  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_NONE, ownership_status_);
454
455  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
456  ReloadDeviceSettings();
457  device_settings_service_.GetOwnershipStatusAsync(
458      base::Bind(&DeviceSettingsServiceTest::SetOwnershipStatus,
459                 base::Unretained(this)));
460  FlushDeviceSettings();
461  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
462  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
463  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
464  std::vector<uint8> key;
465  ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key));
466  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
467  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key());
468  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
469            device_settings_service_.GetOwnershipStatus());
470  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, ownership_status_);
471
472  owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
473  device_settings_service_.SetUsername(device_policy_.policy_data().username());
474  device_settings_service_.GetOwnershipStatusAsync(
475      base::Bind(&DeviceSettingsServiceTest::SetOwnershipStatus,
476                 base::Unretained(this)));
477  FlushDeviceSettings();
478  EXPECT_TRUE(device_settings_service_.HasPrivateOwnerKey());
479  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
480  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
481  ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key));
482  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
483  EXPECT_TRUE(device_settings_service_.GetOwnerKey()->private_key());
484  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
485            device_settings_service_.GetOwnershipStatus());
486  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, ownership_status_);
487}
488
489TEST_F(DeviceSettingsServiceTest, OnTPMTokenReadyForNonOwner) {
490  owner_key_util_->Clear();
491
492  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
493  EXPECT_FALSE(device_settings_service_.GetOwnerKey().get());
494  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_UNKNOWN,
495            device_settings_service_.GetOwnershipStatus());
496
497  device_settings_service_.IsCurrentUserOwnerAsync(
498      base::Bind(&DeviceSettingsServiceTest::OnIsOwner,
499                 base::Unretained(this)));
500
501  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
502  ReloadDeviceSettings();
503
504  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
505  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
506  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
507  std::vector<uint8> key;
508  ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key));
509  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
510  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key());
511  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
512            device_settings_service_.GetOwnershipStatus());
513  EXPECT_FALSE(is_owner_set_);
514
515  device_settings_service_.OnTPMTokenReady();
516  FlushDeviceSettings();
517
518  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
519  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
520  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
521  ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key));
522  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
523  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key());
524  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
525            device_settings_service_.GetOwnershipStatus());
526  EXPECT_TRUE(is_owner_set_);
527  EXPECT_FALSE(is_owner_);
528}
529
530TEST_F(DeviceSettingsServiceTest, OnTPMTokenReadyForOwner) {
531  owner_key_util_->Clear();
532
533  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
534  EXPECT_FALSE(device_settings_service_.GetOwnerKey().get());
535  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_UNKNOWN,
536            device_settings_service_.GetOwnershipStatus());
537
538  device_settings_service_.IsCurrentUserOwnerAsync(
539      base::Bind(&DeviceSettingsServiceTest::OnIsOwner,
540                 base::Unretained(this)));
541
542  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
543  ReloadDeviceSettings();
544
545  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
546  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
547  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
548  std::vector<uint8> key;
549  ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key));
550  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
551  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key());
552  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
553            device_settings_service_.GetOwnershipStatus());
554  EXPECT_FALSE(is_owner_set_);
555
556  owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
557  device_settings_service_.SetUsername(device_policy_.policy_data().username());
558  device_settings_service_.OnTPMTokenReady();
559  FlushDeviceSettings();
560
561  EXPECT_TRUE(device_settings_service_.HasPrivateOwnerKey());
562  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
563  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
564  ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key));
565  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
566  EXPECT_TRUE(device_settings_service_.GetOwnerKey()->private_key());
567  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
568            device_settings_service_.GetOwnershipStatus());
569  EXPECT_TRUE(is_owner_set_);
570  EXPECT_TRUE(is_owner_);
571}
572
573TEST_F(DeviceSettingsServiceTest, IsCurrentUserOwnerAsyncWithLoadedCerts) {
574  owner_key_util_->Clear();
575
576  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
577  EXPECT_FALSE(device_settings_service_.GetOwnerKey().get());
578  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_UNKNOWN,
579            device_settings_service_.GetOwnershipStatus());
580
581  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
582  owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
583  device_settings_service_.SetUsername(device_policy_.policy_data().username());
584  ReloadDeviceSettings();
585
586  device_settings_service_.OnTPMTokenReady();
587  FlushDeviceSettings();
588
589  EXPECT_TRUE(device_settings_service_.HasPrivateOwnerKey());
590  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
591  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
592  std::vector<uint8> key;
593  ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key));
594  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
595  EXPECT_TRUE(device_settings_service_.GetOwnerKey()->private_key());
596  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
597            device_settings_service_.GetOwnershipStatus());
598  EXPECT_FALSE(is_owner_set_);
599
600  device_settings_service_.IsCurrentUserOwnerAsync(
601      base::Bind(&DeviceSettingsServiceTest::OnIsOwner,
602                 base::Unretained(this)));
603  // The callback should be called immediately.
604  base::MessageLoop::current()->RunUntilIdle();
605
606  EXPECT_TRUE(device_settings_service_.HasPrivateOwnerKey());
607  ASSERT_TRUE(device_settings_service_.GetOwnerKey().get());
608  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
609  ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key));
610  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
611  EXPECT_TRUE(device_settings_service_.GetOwnerKey()->private_key());
612  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
613            device_settings_service_.GetOwnershipStatus());
614  EXPECT_TRUE(is_owner_set_);
615  EXPECT_TRUE(is_owner_);
616}
617
618TEST_F(DeviceSettingsServiceTest, Observer) {
619  owner_key_util_->Clear();
620  MockDeviceSettingsObserver observer_;
621  device_settings_service_.AddObserver(&observer_);
622
623  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(1);
624  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
625  ReloadDeviceSettings();
626  Mock::VerifyAndClearExpectations(&observer_);
627
628  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(1);
629  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
630  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
631  ReloadDeviceSettings();
632  Mock::VerifyAndClearExpectations(&observer_);
633
634  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(0);
635  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
636  device_settings_service_.Store(device_policy_.GetCopy(), base::Closure());
637  FlushDeviceSettings();
638  Mock::VerifyAndClearExpectations(&observer_);
639
640  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(0);
641  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
642  device_settings_service_.PropertyChangeComplete(true);
643  FlushDeviceSettings();
644  Mock::VerifyAndClearExpectations(&observer_);
645
646  device_settings_service_.RemoveObserver(&observer_);
647}
648
649}  // namespace chromeos
650