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