device_settings_provider_unittest.cc revision c2e0dbddbe15c98d52c4786dac06cb8952a8ae6d
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_provider.h" 6 7#include <string> 8 9#include "base/bind.h" 10#include "base/callback.h" 11#include "base/file_util.h" 12#include "base/path_service.h" 13#include "base/test/scoped_path_override.h" 14#include "base/values.h" 15#include "chrome/browser/chromeos/cros/cros_library.h" 16#include "chrome/browser/chromeos/settings/cros_settings_names.h" 17#include "chrome/browser/chromeos/settings/device_settings_test_helper.h" 18#include "chrome/browser/policy/proto/chromeos/chrome_device_policy.pb.h" 19#include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h" 20#include "chrome/common/chrome_paths.h" 21#include "chrome/test/base/scoped_testing_local_state.h" 22#include "chrome/test/base/testing_browser_process.h" 23#include "testing/gmock/include/gmock/gmock.h" 24#include "testing/gtest/include/gtest/gtest.h" 25 26namespace em = enterprise_management; 27 28namespace chromeos { 29 30using ::testing::AnyNumber; 31using ::testing::Mock; 32using ::testing::_; 33 34class DeviceSettingsProviderTest : public DeviceSettingsTestBase { 35 public: 36 MOCK_METHOD1(SettingChanged, void(const std::string&)); 37 MOCK_METHOD0(GetTrustedCallback, void(void)); 38 39 protected: 40 DeviceSettingsProviderTest() 41 : local_state_(TestingBrowserProcess::GetGlobal()), 42 user_data_dir_override_(chrome::DIR_USER_DATA) {} 43 44 virtual void SetUp() OVERRIDE { 45 DeviceSettingsTestBase::SetUp(); 46 47 EXPECT_CALL(*this, SettingChanged(_)).Times(AnyNumber()); 48 provider_.reset( 49 new DeviceSettingsProvider( 50 base::Bind(&DeviceSettingsProviderTest::SettingChanged, 51 base::Unretained(this)), 52 &device_settings_service_)); 53 Mock::VerifyAndClearExpectations(this); 54 } 55 56 virtual void TearDown() OVERRIDE { 57 DeviceSettingsTestBase::TearDown(); 58 } 59 60 ScopedStubCrosEnabler stub_cros_enabler_; 61 62 ScopedTestingLocalState local_state_; 63 64 scoped_ptr<DeviceSettingsProvider> provider_; 65 66 base::ScopedPathOverride user_data_dir_override_; 67 68 private: 69 DISALLOW_COPY_AND_ASSIGN(DeviceSettingsProviderTest); 70}; 71 72TEST_F(DeviceSettingsProviderTest, InitializationTest) { 73 // Have the service load a settings blob. 74 EXPECT_CALL(*this, SettingChanged(_)).Times(AnyNumber()); 75 ReloadDeviceSettings(); 76 Mock::VerifyAndClearExpectations(this); 77 78 // Verify that the policy blob has been correctly parsed and trusted. 79 // The trusted flag should be set before the call to PrepareTrustedValues. 80 EXPECT_EQ(CrosSettingsProvider::TRUSTED, 81 provider_->PrepareTrustedValues(base::Closure())); 82 const base::Value* value = provider_->Get(kStatsReportingPref); 83 ASSERT_TRUE(value); 84 bool bool_value; 85 EXPECT_TRUE(value->GetAsBoolean(&bool_value)); 86 EXPECT_FALSE(bool_value); 87} 88 89TEST_F(DeviceSettingsProviderTest, InitializationTestUnowned) { 90 // Have the service check the key. 91 owner_key_util_->Clear(); 92 ReloadDeviceSettings(); 93 94 // The trusted flag should be set before the call to PrepareTrustedValues. 95 EXPECT_EQ(CrosSettingsProvider::TRUSTED, 96 provider_->PrepareTrustedValues(base::Closure())); 97 const base::Value* value = provider_->Get(kReleaseChannel); 98 ASSERT_TRUE(value); 99 std::string string_value; 100 EXPECT_TRUE(value->GetAsString(&string_value)); 101 EXPECT_TRUE(string_value.empty()); 102 103 // Sets should succeed though and be readable from the cache. 104 EXPECT_CALL(*this, SettingChanged(_)).Times(AnyNumber()); 105 EXPECT_CALL(*this, SettingChanged(kReleaseChannel)).Times(1); 106 base::StringValue new_value("stable-channel"); 107 provider_->Set(kReleaseChannel, new_value); 108 Mock::VerifyAndClearExpectations(this); 109 110 // This shouldn't trigger a write. 111 device_settings_test_helper_.set_policy_blob(std::string()); 112 FlushDeviceSettings(); 113 EXPECT_EQ(std::string(), device_settings_test_helper_.policy_blob()); 114 115 // Verify the change has been applied. 116 const base::Value* saved_value = provider_->Get(kReleaseChannel); 117 ASSERT_TRUE(saved_value); 118 EXPECT_TRUE(saved_value->GetAsString(&string_value)); 119 ASSERT_EQ("stable-channel", string_value); 120} 121 122TEST_F(DeviceSettingsProviderTest, SetPrefFailed) { 123 // If we are not the owner no sets should work. 124 base::FundamentalValue value(true); 125 EXPECT_CALL(*this, SettingChanged(kStatsReportingPref)).Times(1); 126 provider_->Set(kStatsReportingPref, value); 127 Mock::VerifyAndClearExpectations(this); 128 129 // This shouldn't trigger a write. 130 device_settings_test_helper_.set_policy_blob(std::string()); 131 FlushDeviceSettings(); 132 EXPECT_EQ(std::string(), device_settings_test_helper_.policy_blob()); 133 134 // Verify the change has not been applied. 135 const base::Value* saved_value = provider_->Get(kStatsReportingPref); 136 ASSERT_TRUE(saved_value); 137 bool bool_value; 138 EXPECT_TRUE(saved_value->GetAsBoolean(&bool_value)); 139 EXPECT_FALSE(bool_value); 140} 141 142TEST_F(DeviceSettingsProviderTest, SetPrefSucceed) { 143 owner_key_util_->SetPrivateKey(device_policy_.signing_key()); 144 device_settings_service_.SetUsername(device_policy_.policy_data().username()); 145 FlushDeviceSettings(); 146 147 base::FundamentalValue value(true); 148 EXPECT_CALL(*this, SettingChanged(_)).Times(AnyNumber()); 149 EXPECT_CALL(*this, SettingChanged(kStatsReportingPref)).Times(1); 150 provider_->Set(kStatsReportingPref, value); 151 Mock::VerifyAndClearExpectations(this); 152 153 // Process the store. 154 device_settings_test_helper_.set_policy_blob(std::string()); 155 FlushDeviceSettings(); 156 157 // Verify that the device policy has been adjusted. 158 ASSERT_TRUE(device_settings_service_.device_settings()); 159 EXPECT_TRUE(device_settings_service_.device_settings()-> 160 metrics_enabled().metrics_enabled()); 161 162 // Verify the change has been applied. 163 const base::Value* saved_value = provider_->Get(kStatsReportingPref); 164 ASSERT_TRUE(saved_value); 165 bool bool_value; 166 EXPECT_TRUE(saved_value->GetAsBoolean(&bool_value)); 167 EXPECT_TRUE(bool_value); 168} 169 170TEST_F(DeviceSettingsProviderTest, SetPrefTwice) { 171 owner_key_util_->SetPrivateKey(device_policy_.signing_key()); 172 device_settings_service_.SetUsername(device_policy_.policy_data().username()); 173 FlushDeviceSettings(); 174 175 EXPECT_CALL(*this, SettingChanged(_)).Times(AnyNumber()); 176 177 base::StringValue value1("beta"); 178 provider_->Set(kReleaseChannel, value1); 179 base::StringValue value2("dev"); 180 provider_->Set(kReleaseChannel, value2); 181 182 // Let the changes propagate through the system. 183 device_settings_test_helper_.set_policy_blob(std::string()); 184 FlushDeviceSettings(); 185 186 // Verify the second change has been applied. 187 const base::Value* saved_value = provider_->Get(kReleaseChannel); 188 EXPECT_TRUE(value2.Equals(saved_value)); 189 190 Mock::VerifyAndClearExpectations(this); 191} 192 193TEST_F(DeviceSettingsProviderTest, PolicyRetrievalFailedBadSignature) { 194 owner_key_util_->SetPublicKeyFromPrivateKey(device_policy_.signing_key()); 195 device_policy_.policy().set_policy_data_signature("bad signature"); 196 device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob()); 197 ReloadDeviceSettings(); 198 199 // Verify that the cached settings blob is not "trusted". 200 EXPECT_EQ(DeviceSettingsService::STORE_VALIDATION_ERROR, 201 device_settings_service_.status()); 202 EXPECT_EQ(CrosSettingsProvider::PERMANENTLY_UNTRUSTED, 203 provider_->PrepareTrustedValues(base::Closure())); 204} 205 206TEST_F(DeviceSettingsProviderTest, PolicyRetrievalNoPolicy) { 207 owner_key_util_->SetPublicKeyFromPrivateKey(device_policy_.signing_key()); 208 device_settings_test_helper_.set_policy_blob(std::string()); 209 ReloadDeviceSettings(); 210 211 // Verify that the cached settings blob is not "trusted". 212 EXPECT_EQ(DeviceSettingsService::STORE_NO_POLICY, 213 device_settings_service_.status()); 214 EXPECT_EQ(CrosSettingsProvider::PERMANENTLY_UNTRUSTED, 215 provider_->PrepareTrustedValues(base::Closure())); 216} 217 218TEST_F(DeviceSettingsProviderTest, PolicyFailedPermanentlyNotification) { 219 device_settings_test_helper_.set_policy_blob(std::string()); 220 221 EXPECT_CALL(*this, GetTrustedCallback()); 222 EXPECT_EQ(CrosSettingsProvider::TEMPORARILY_UNTRUSTED, 223 provider_->PrepareTrustedValues( 224 base::Bind(&DeviceSettingsProviderTest::GetTrustedCallback, 225 base::Unretained(this)))); 226 227 ReloadDeviceSettings(); 228 Mock::VerifyAndClearExpectations(this); 229 230 EXPECT_EQ(CrosSettingsProvider::PERMANENTLY_UNTRUSTED, 231 provider_->PrepareTrustedValues(base::Closure())); 232} 233 234TEST_F(DeviceSettingsProviderTest, PolicyLoadNotification) { 235 EXPECT_CALL(*this, GetTrustedCallback()); 236 237 EXPECT_EQ(CrosSettingsProvider::TEMPORARILY_UNTRUSTED, 238 provider_->PrepareTrustedValues( 239 base::Bind(&DeviceSettingsProviderTest::GetTrustedCallback, 240 base::Unretained(this)))); 241 242 ReloadDeviceSettings(); 243 Mock::VerifyAndClearExpectations(this); 244} 245 246TEST_F(DeviceSettingsProviderTest, StatsReportingMigration) { 247 // Create the legacy consent file. 248 base::FilePath consent_file; 249 ASSERT_TRUE(PathService::Get(chrome::DIR_USER_DATA, &consent_file)); 250 consent_file = consent_file.AppendASCII("Consent To Send Stats"); 251 ASSERT_EQ(1, file_util::WriteFile(consent_file, "0", 1)); 252 253 // This should trigger migration because the metrics policy isn't in the blob. 254 device_settings_test_helper_.set_policy_blob(std::string()); 255 FlushDeviceSettings(); 256 EXPECT_EQ(std::string(), device_settings_test_helper_.policy_blob()); 257 258 // Verify that migration has kicked in. 259 const base::Value* saved_value = provider_->Get(kStatsReportingPref); 260 ASSERT_TRUE(saved_value); 261 bool bool_value; 262 EXPECT_TRUE(saved_value->GetAsBoolean(&bool_value)); 263 EXPECT_FALSE(bool_value); 264} 265 266TEST_F(DeviceSettingsProviderTest, LegacyDeviceLocalAccounts) { 267 EXPECT_CALL(*this, SettingChanged(_)).Times(AnyNumber()); 268 em::DeviceLocalAccountInfoProto* account = 269 device_policy_.payload().mutable_device_local_accounts()->add_account(); 270 account->set_id(policy::PolicyBuilder::kFakeUsername); 271 device_policy_.Build(); 272 device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob()); 273 ReloadDeviceSettings(); 274 Mock::VerifyAndClearExpectations(this); 275 276 // On load, the deprecated spec should have been converted to the new format. 277 base::ListValue expected_accounts; 278 scoped_ptr<base::DictionaryValue> entry_dict(new base::DictionaryValue()); 279 entry_dict->SetString(kAccountsPrefDeviceLocalAccountsKeyId, 280 policy::PolicyBuilder::kFakeUsername); 281 entry_dict->SetInteger(kAccountsPrefDeviceLocalAccountsKeyType, 282 DEVICE_LOCAL_ACCOUNT_TYPE_PUBLIC_SESSION); 283 expected_accounts.Append(entry_dict.release()); 284 const base::Value* actual_accounts = 285 provider_->Get(kAccountsPrefDeviceLocalAccounts); 286 EXPECT_TRUE(base::Value::Equals(&expected_accounts, actual_accounts)); 287} 288 289} // namespace chromeos 290