Add DeviceSettingsService.

chrome/browser/chromeos/settings/device_settings_service_unittest.cc

+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/chromeos/settings/device_settings_service.h"
+
+#include "base/basictypes.h"
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/compiler_specific.h"
+#include "base/memory/ref_counted.h"
+#include "base/message_loop.h"
+#include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
+#include "chrome/browser/chromeos/settings/mock_owner_key_util.h"
+#include "chrome/browser/policy/policy_builder.h"
+#include "chrome/browser/policy/proto/chrome_device_policy.pb.h"
+#include "chrome/browser/policy/proto/device_management_backend.pb.h"
+#include "content/public/test/test_browser_thread.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace em = enterprise_management;
+
+using ::testing::Mock;
+
+namespace chromeos {
+
+namespace {
+
+class MockDeviceSettingsObserver : public DeviceSettingsService::Observer {
+ public:
+  virtual ~MockDeviceSettingsObserver() {}
+
+  MOCK_METHOD0(OwnershipStatusChanged, void());
+  MOCK_METHOD0(DeviceSettingsUpdated, void());
+};
+
+}  // namespace
+
+class DeviceSettingsServiceTest : public testing::Test {
+ public:
+  void SetOperationCompleted() {
+    operation_completed_ = true;
+  }
+
+  void SetOwnershipStatus(
+      DeviceSettingsService::OwnershipStatus ownership_status,
+      bool is_owner) {
+    is_owner_ = is_owner;
+    ownership_status_ = ownership_status;
+  }
+
+ protected:
+  DeviceSettingsServiceTest()
+      : owner_key_util_(new chromeos::MockOwnerKeyUtil()),
+        message_loop_(MessageLoop::TYPE_UI),
+        ui_thread_(content::BrowserThread::UI, &message_loop_),
+        file_thread_(content::BrowserThread::FILE, &message_loop_),
+        operation_completed_(false),
+        is_owner_(true),
+        ownership_status_(DeviceSettingsService::OWNERSHIP_UNKNOWN) {}
+
+  virtual void SetUp() OVERRIDE {
+    policy_.payload().mutable_device_policy_refresh_rate()->
+        set_device_policy_refresh_rate(120);
+    policy_.Build();
+    device_settings_test_helper_.set_policy_blob(policy_.GetBlob());
+
+    device_settings_service_.Initialize(&device_settings_test_helper_,
+                                        owner_key_util_);
+  }
+
+  virtual void TearDown() OVERRIDE {
+    device_settings_test_helper_.Flush();
+    device_settings_service_.Shutdown();
+  }
+
+  void CheckPolicy() {
+    ASSERT_TRUE(device_settings_service_.policy_data());
+    EXPECT_EQ(policy_.policy_data().SerializeAsString(),
+              device_settings_service_.policy_data()->SerializeAsString());
+    ASSERT_TRUE(device_settings_service_.device_settings());
+    EXPECT_EQ(policy_.payload().SerializeAsString(),
+              device_settings_service_.device_settings()->SerializeAsString());
+  }
+
+  policy::DevicePolicyBuilder policy_;
+  scoped_refptr<MockOwnerKeyUtil> owner_key_util_;
+
+  DeviceSettingsTestHelper device_settings_test_helper_;
+  DeviceSettingsService device_settings_service_;
+
+  MessageLoop message_loop_;
+  content::TestBrowserThread ui_thread_;
+  content::TestBrowserThread file_thread_;
+
+  bool operation_completed_;
+  bool is_owner_;
+  DeviceSettingsService::OwnershipStatus ownership_status_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DeviceSettingsServiceTest);
+};
+
+TEST_F(DeviceSettingsServiceTest, LoadNoKey) {
+  device_settings_service_.Load();
+  device_settings_test_helper_.Flush();
+
+  EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE,
+            device_settings_service_.status());
+  EXPECT_FALSE(device_settings_service_.policy_data());
+  EXPECT_FALSE(device_settings_service_.device_settings());
+}
+
+TEST_F(DeviceSettingsServiceTest, LoadNoPolicy) {
+  device_settings_test_helper_.set_policy_blob(std::string());
+  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
+  device_settings_service_.Load();
+  device_settings_test_helper_.Flush();
+
+  EXPECT_EQ(DeviceSettingsService::STORE_NO_POLICY,
+            device_settings_service_.status());
+  EXPECT_FALSE(device_settings_service_.policy_data());
+  EXPECT_FALSE(device_settings_service_.device_settings());
+}
+
+TEST_F(DeviceSettingsServiceTest, LoadValidationError) {
+  policy_.policy().set_policy_data_signature("bad");
+  device_settings_test_helper_.set_policy_blob(policy_.GetBlob());
+  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
+  device_settings_service_.Load();
+  device_settings_test_helper_.Flush();
+
+  EXPECT_EQ(DeviceSettingsService::STORE_VALIDATION_ERROR,
+            device_settings_service_.status());
+  EXPECT_FALSE(device_settings_service_.policy_data());
+  EXPECT_FALSE(device_settings_service_.device_settings());
+}
+
+TEST_F(DeviceSettingsServiceTest, LoadSuccess) {
+  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
+  device_settings_service_.Load();
+  device_settings_test_helper_.Flush();
+
+  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
+            device_settings_service_.status());
+  CheckPolicy();
+}
+
+TEST_F(DeviceSettingsServiceTest, SignAndStoreNoKey) {
+  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
+  device_settings_service_.Load();
+  device_settings_test_helper_.Flush();
+  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
+            device_settings_service_.status());
+
+  scoped_ptr<em::ChromeDeviceSettingsProto> new_device_settings(
+      new em::ChromeDeviceSettingsProto(policy_.payload()));
+  new_device_settings->mutable_device_policy_refresh_rate()->
+      set_device_policy_refresh_rate(300);
+  device_settings_service_.SignAndStore(
+      new_device_settings.Pass(),
+      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
+                 base::Unretained(this)));
+  device_settings_test_helper_.Flush();
+  EXPECT_TRUE(operation_completed_);
+  EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE,
+            device_settings_service_.status());
+  CheckPolicy();
+}
+
+TEST_F(DeviceSettingsServiceTest, SignAndStoreFailure) {
+  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
+  device_settings_service_.Load();
+  device_settings_test_helper_.Flush();
+  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
+            device_settings_service_.status());
+
+  owner_key_util_->SetPrivateKey(policy_.signing_key());
+  device_settings_service_.SetUsername(policy_.policy_data().username());
+  device_settings_test_helper_.Flush();
+
+  scoped_ptr<em::ChromeDeviceSettingsProto> new_device_settings(
+      new em::ChromeDeviceSettingsProto(policy_.payload()));
+  new_device_settings->mutable_device_policy_refresh_rate()->
+      set_device_policy_refresh_rate(300);
+  device_settings_test_helper_.set_store_result(false);
+  device_settings_service_.SignAndStore(
+      new_device_settings.Pass(),
+      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
+                 base::Unretained(this)));
+  device_settings_test_helper_.Flush();
+  EXPECT_TRUE(operation_completed_);
+  EXPECT_EQ(DeviceSettingsService::STORE_OPERATION_FAILED,
+            device_settings_service_.status());
+  CheckPolicy();
+}
+
+TEST_F(DeviceSettingsServiceTest, SignAndStoreSuccess) {
+  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
+  device_settings_service_.Load();
+  device_settings_test_helper_.Flush();
+  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
+            device_settings_service_.status());
+
+  owner_key_util_->SetPrivateKey(policy_.signing_key());
+  device_settings_service_.SetUsername(policy_.policy_data().username());
+  device_settings_test_helper_.Flush();
+
+  policy_.payload().mutable_device_policy_refresh_rate()->
+      set_device_policy_refresh_rate(300);
+  policy_.Build();
+  device_settings_service_.SignAndStore(
+      scoped_ptr<em::ChromeDeviceSettingsProto>(
+          new em::ChromeDeviceSettingsProto(policy_.payload())),
+      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
+                 base::Unretained(this)));
+  device_settings_test_helper_.Flush();
+  EXPECT_TRUE(operation_completed_);
+  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
+            device_settings_service_.status());
+  ASSERT_TRUE(device_settings_service_.device_settings());
+  EXPECT_EQ(policy_.payload().SerializeAsString(),
+            device_settings_service_.device_settings()->SerializeAsString());
+}
+
+TEST_F(DeviceSettingsServiceTest, StoreFailure) {
+  device_settings_test_helper_.set_policy_blob(std::string());
+  device_settings_service_.Load();
+  device_settings_test_helper_.Flush();
+  EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE,
+            device_settings_service_.status());
+
+  device_settings_test_helper_.set_store_result(false);
+  device_settings_service_.Store(
+      policy_.GetBlob(),
+      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
+                 base::Unretained(this)));
+  device_settings_test_helper_.Flush();
+  EXPECT_TRUE(operation_completed_);
+  EXPECT_EQ(DeviceSettingsService::STORE_OPERATION_FAILED,
+            device_settings_service_.status());
+}
+
+TEST_F(DeviceSettingsServiceTest, StoreSuccess) {
+  device_settings_test_helper_.set_policy_blob(std::string());
+  device_settings_service_.Load();
+  device_settings_test_helper_.Flush();
+  EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE,
+            device_settings_service_.status());
+
+  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
+  device_settings_service_.Store(
+      policy_.GetBlob(),
+      base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted,
+                 base::Unretained(this)));
+  device_settings_test_helper_.Flush();
+  EXPECT_TRUE(operation_completed_);
+  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
+            device_settings_service_.status());
+  CheckPolicy();
+}
+
+TEST_F(DeviceSettingsServiceTest, StoreRotation) {
+  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
+  device_settings_service_.Load();
+  device_settings_test_helper_.Flush();
+  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
+            device_settings_service_.status());
+
+  policy_.payload().mutable_device_policy_refresh_rate()->
+      set_device_policy_refresh_rate(300);
+  policy_.set_new_signing_key(policy::PolicyBuilder::CreateTestNewSigningKey());
+  policy_.Build();
+  device_settings_service_.Store(policy_.GetBlob(), base::Closure());
+  device_settings_test_helper_.FlushStore();
+  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.new_signing_key());
+  device_settings_service_.OwnerKeySet(true);
+  device_settings_test_helper_.Flush();
+  EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
+            device_settings_service_.status());
+  CheckPolicy();
+
+  // Check the new key has been loaded.
+  std::vector<uint8> key;
+  ASSERT_TRUE(policy_.new_signing_key()->ExportPublicKey(&key));
+  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
+}
+
+TEST_F(DeviceSettingsServiceTest, OwnershipStatus) {
+  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
+  EXPECT_FALSE(device_settings_service_.GetOwnerKey());
+  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_UNKNOWN,
+            device_settings_service_.GetOwnershipStatus());
+
+  device_settings_service_.GetOwnershipStatusAsync(
+      base::Bind(&DeviceSettingsServiceTest::SetOwnershipStatus,
+                 base::Unretained(this)));
+  device_settings_test_helper_.Flush();
+  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
+  ASSERT_TRUE(device_settings_service_.GetOwnerKey());
+  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->public_key());
+  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key());
+  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_NONE,
+            device_settings_service_.GetOwnershipStatus());
+  EXPECT_FALSE(is_owner_);
+  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_NONE, ownership_status_);
+
+  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
+  device_settings_service_.Load();
+  device_settings_test_helper_.Flush();
+  device_settings_service_.GetOwnershipStatusAsync(
+      base::Bind(&DeviceSettingsServiceTest::SetOwnershipStatus,
+                 base::Unretained(this)));
+  device_settings_test_helper_.Flush();
+  EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey());
+  ASSERT_TRUE(device_settings_service_.GetOwnerKey());
+  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
+  std::vector<uint8> key;
+  ASSERT_TRUE(policy_.signing_key()->ExportPublicKey(&key));
+  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
+  EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key());
+  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
+            device_settings_service_.GetOwnershipStatus());
+  EXPECT_FALSE(is_owner_);
+  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, ownership_status_);
+
+  owner_key_util_->SetPrivateKey(policy_.signing_key());
+  device_settings_service_.SetUsername(policy_.policy_data().username());
+  device_settings_service_.GetOwnershipStatusAsync(
+      base::Bind(&DeviceSettingsServiceTest::SetOwnershipStatus,
+                 base::Unretained(this)));
+  device_settings_test_helper_.Flush();
+  EXPECT_TRUE(device_settings_service_.HasPrivateOwnerKey());
+  ASSERT_TRUE(device_settings_service_.GetOwnerKey());
+  ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key());
+  ASSERT_TRUE(policy_.signing_key()->ExportPublicKey(&key));
+  EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key);
+  EXPECT_TRUE(device_settings_service_.GetOwnerKey()->private_key());
+  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN,
+            device_settings_service_.GetOwnershipStatus());
+  EXPECT_TRUE(is_owner_);
+  EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, ownership_status_);
+}
+
+TEST_F(DeviceSettingsServiceTest, Observer) {
+  MockDeviceSettingsObserver observer_;
+  device_settings_service_.AddObserver(&observer_);
+
+  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(1);
+  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
+  device_settings_service_.Load();
+  device_settings_test_helper_.Flush();
+  Mock::VerifyAndClearExpectations(&observer_);
+
+  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(1);
+  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
+  owner_key_util_->SetPublicKeyFromPrivateKey(policy_.signing_key());
+  device_settings_service_.OwnerKeySet(true);
+  device_settings_test_helper_.Flush();
+  Mock::VerifyAndClearExpectations(&observer_);
+
+  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(0);
+  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
+  device_settings_service_.Store(policy_.GetBlob(), base::Closure());
+  device_settings_test_helper_.Flush();
+  Mock::VerifyAndClearExpectations(&observer_);
+
+  EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(0);
+  EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1);
+  device_settings_service_.PropertyChangeComplete(true);
+  device_settings_test_helper_.Flush();
+  Mock::VerifyAndClearExpectations(&observer_);
+
+  device_settings_service_.RemoveObserver(&observer_);
+}
+
+}  // namespace chromeos