| OLD | NEW |
|---|
| (Empty) |
| 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/policy/user_cloud_policy_store_chromeos.h" | |
| 6 | |
| 7 #include "base/file_util.h" | |
| 8 #include "base/files/scoped_temp_dir.h" | |
| 9 #include "base/memory/scoped_ptr.h" | |
| 10 #include "base/message_loop.h" | |
| 11 #include "chrome/browser/policy/cloud_policy_constants.h" | |
| 12 #include "chrome/browser/policy/mock_cloud_policy_store.h" | |
| 13 #include "chrome/browser/policy/policy_builder.h" | |
| 14 #include "chrome/browser/policy/proto/cloud_policy.pb.h" | |
| 15 #include "chrome/browser/policy/proto/device_management_local.pb.h" | |
| 16 #include "chromeos/dbus/mock_session_manager_client.h" | |
| 17 #include "content/public/test/test_browser_thread.h" | |
| 18 #include "policy/policy_constants.h" | |
| 19 #include "testing/gmock/include/gmock/gmock.h" | |
| 20 #include "testing/gtest/include/gtest/gtest.h" | |
| 21 | |
| 22 namespace em = enterprise_management; | |
| 23 | |
| 24 using testing::AllOf; | |
| 25 using testing::Eq; | |
| 26 using testing::Mock; | |
| 27 using testing::Property; | |
| 28 using testing::SaveArg; | |
| 29 using testing::_; | |
| 30 | |
| 31 namespace policy { | |
| 32 | |
| 33 namespace { | |
| 34 | |
| 35 const char kLegacyDeviceId[] = "legacy-device-id"; | |
| 36 const char kLegacyToken[] = "legacy-token"; | |
| 37 | |
| 38 class UserCloudPolicyStoreChromeOSTest : public testing::Test { | |
| 39 protected: | |
| 40 UserCloudPolicyStoreChromeOSTest() | |
| 41 : loop_(MessageLoop::TYPE_UI), | |
| 42 ui_thread_(content::BrowserThread::UI, &loop_), | |
| 43 file_thread_(content::BrowserThread::FILE, &loop_) {} | |
| 44 | |
| 45 virtual void SetUp() OVERRIDE { | |
| 46 ASSERT_TRUE(tmp_dir_.CreateUniqueTempDir()); | |
| 47 store_.reset(new UserCloudPolicyStoreChromeOS(&session_manager_client_, | |
| 48 PolicyBuilder::kFakeUsername, | |
| 49 token_file(), | |
| 50 policy_file())); | |
| 51 store_->AddObserver(&observer_); | |
| 52 | |
| 53 policy_.payload().mutable_showhomebutton()->set_value(true); | |
| 54 policy_.Build(); | |
| 55 } | |
| 56 | |
| 57 virtual void TearDown() OVERRIDE { | |
| 58 store_->RemoveObserver(&observer_); | |
| 59 store_.reset(); | |
| 60 loop_.RunUntilIdle(); | |
| 61 } | |
| 62 | |
| 63 // Install an expectation on |observer_| for an error code. | |
| 64 void ExpectError(CloudPolicyStore::Status error) { | |
| 65 EXPECT_CALL(observer_, | |
| 66 OnStoreError(AllOf(Eq(store_.get()), | |
| 67 Property(&CloudPolicyStore::status, | |
| 68 Eq(error))))); | |
| 69 } | |
| 70 | |
| 71 // Triggers a store_->Load() operation, handles the expected call to | |
| 72 // |session_manager_client_| and sends |response|. | |
| 73 void PerformPolicyLoad(const std::string& response) { | |
| 74 // Issue a load command. | |
| 75 chromeos::SessionManagerClient::RetrievePolicyCallback retrieve_callback; | |
| 76 EXPECT_CALL(session_manager_client_, RetrieveUserPolicy(_)) | |
| 77 .WillOnce(SaveArg<0>(&retrieve_callback)); | |
| 78 store_->Load(); | |
| 79 loop_.RunUntilIdle(); | |
| 80 Mock::VerifyAndClearExpectations(&session_manager_client_); | |
| 81 ASSERT_FALSE(retrieve_callback.is_null()); | |
| 82 | |
| 83 // Run the callback. | |
| 84 retrieve_callback.Run(response); | |
| 85 loop_.RunUntilIdle(); | |
| 86 } | |
| 87 | |
| 88 // Verifies that store_->policy_map() has the ShowHomeButton entry. | |
| 89 void VerifyPolicyMap() { | |
| 90 EXPECT_EQ(1U, store_->policy_map().size()); | |
| 91 const PolicyMap::Entry* entry = | |
| 92 store_->policy_map().Get(key::kShowHomeButton); | |
| 93 ASSERT_TRUE(entry); | |
| 94 EXPECT_TRUE(base::FundamentalValue(true).Equals(entry->value)); | |
| 95 } | |
| 96 | |
| 97 FilePath token_file() { | |
| 98 return tmp_dir_.path().AppendASCII("token"); | |
| 99 } | |
| 100 | |
| 101 FilePath policy_file() { | |
| 102 return tmp_dir_.path().AppendASCII("policy"); | |
| 103 } | |
| 104 | |
| 105 MessageLoop loop_; | |
| 106 chromeos::MockSessionManagerClient session_manager_client_; | |
| 107 UserPolicyBuilder policy_; | |
| 108 MockCloudPolicyStoreObserver observer_; | |
| 109 scoped_ptr<UserCloudPolicyStoreChromeOS> store_; | |
| 110 | |
| 111 private: | |
| 112 content::TestBrowserThread ui_thread_; | |
| 113 content::TestBrowserThread file_thread_; | |
| 114 base::ScopedTempDir tmp_dir_; | |
| 115 | |
| 116 DISALLOW_COPY_AND_ASSIGN(UserCloudPolicyStoreChromeOSTest); | |
| 117 }; | |
| 118 | |
| 119 TEST_F(UserCloudPolicyStoreChromeOSTest, Store) { | |
| 120 // Store policy. | |
| 121 chromeos::SessionManagerClient::StorePolicyCallback store_callback; | |
| 122 EXPECT_CALL(session_manager_client_, StoreUserPolicy(policy_.GetBlob(), _)) | |
| 123 .WillOnce(SaveArg<1>(&store_callback)); | |
| 124 store_->Store(policy_.policy()); | |
| 125 loop_.RunUntilIdle(); | |
| 126 Mock::VerifyAndClearExpectations(&session_manager_client_); | |
| 127 ASSERT_FALSE(store_callback.is_null()); | |
| 128 | |
| 129 // No policy should be present yet. | |
| 130 EXPECT_FALSE(store_->policy()); | |
| 131 EXPECT_TRUE(store_->policy_map().empty()); | |
| 132 EXPECT_EQ(CloudPolicyStore::STATUS_OK, store_->status()); | |
| 133 | |
| 134 // Let the store operation complete. | |
| 135 chromeos::SessionManagerClient::RetrievePolicyCallback retrieve_callback; | |
| 136 EXPECT_CALL(session_manager_client_, RetrieveUserPolicy(_)) | |
| 137 .WillOnce(SaveArg<0>(&retrieve_callback)); | |
| 138 store_callback.Run(true); | |
| 139 loop_.RunUntilIdle(); | |
| 140 EXPECT_TRUE(store_->policy_map().empty()); | |
| 141 EXPECT_EQ(CloudPolicyStore::STATUS_OK, store_->status()); | |
| 142 Mock::VerifyAndClearExpectations(&session_manager_client_); | |
| 143 ASSERT_FALSE(retrieve_callback.is_null()); | |
| 144 | |
| 145 // Finish the retrieve callback. | |
| 146 EXPECT_CALL(observer_, OnStoreLoaded(store_.get())); | |
| 147 retrieve_callback.Run(policy_.GetBlob()); | |
| 148 loop_.RunUntilIdle(); | |
| 149 ASSERT_TRUE(store_->policy()); | |
| 150 EXPECT_EQ(policy_.policy_data().SerializeAsString(), | |
| 151 store_->policy()->SerializeAsString()); | |
| 152 VerifyPolicyMap(); | |
| 153 EXPECT_EQ(CloudPolicyStore::STATUS_OK, store_->status()); | |
| 154 } | |
| 155 | |
| 156 TEST_F(UserCloudPolicyStoreChromeOSTest, StoreFail) { | |
| 157 // Store policy. | |
| 158 chromeos::SessionManagerClient::StorePolicyCallback store_callback; | |
| 159 EXPECT_CALL(session_manager_client_, StoreUserPolicy(policy_.GetBlob(), _)) | |
| 160 .WillOnce(SaveArg<1>(&store_callback)); | |
| 161 store_->Store(policy_.policy()); | |
| 162 loop_.RunUntilIdle(); | |
| 163 Mock::VerifyAndClearExpectations(&session_manager_client_); | |
| 164 ASSERT_FALSE(store_callback.is_null()); | |
| 165 | |
| 166 // Let the store operation complete. | |
| 167 ExpectError(CloudPolicyStore::STATUS_STORE_ERROR); | |
| 168 store_callback.Run(false); | |
| 169 loop_.RunUntilIdle(); | |
| 170 EXPECT_FALSE(store_->policy()); | |
| 171 EXPECT_TRUE(store_->policy_map().empty()); | |
| 172 EXPECT_EQ(CloudPolicyStore::STATUS_STORE_ERROR, store_->status()); | |
| 173 } | |
| 174 | |
| 175 TEST_F(UserCloudPolicyStoreChromeOSTest, StoreValidationError) { | |
| 176 policy_.policy_data().clear_policy_type(); | |
| 177 policy_.Build(); | |
| 178 | |
| 179 // Store policy. | |
| 180 chromeos::SessionManagerClient::StorePolicyCallback store_callback; | |
| 181 ExpectError(CloudPolicyStore::STATUS_VALIDATION_ERROR); | |
| 182 EXPECT_CALL(session_manager_client_, StoreUserPolicy(policy_.GetBlob(), _)) | |
| 183 .Times(0); | |
| 184 store_->Store(policy_.policy()); | |
| 185 loop_.RunUntilIdle(); | |
| 186 Mock::VerifyAndClearExpectations(&session_manager_client_); | |
| 187 } | |
| 188 | |
| 189 TEST_F(UserCloudPolicyStoreChromeOSTest, Load) { | |
| 190 EXPECT_CALL(observer_, OnStoreLoaded(store_.get())); | |
| 191 ASSERT_NO_FATAL_FAILURE(PerformPolicyLoad(policy_.GetBlob())); | |
| 192 Mock::VerifyAndClearExpectations(&observer_); | |
| 193 | |
| 194 // Verify that the policy has been loaded. | |
| 195 ASSERT_TRUE(store_->policy()); | |
| 196 EXPECT_EQ(policy_.policy_data().SerializeAsString(), | |
| 197 store_->policy()->SerializeAsString()); | |
| 198 VerifyPolicyMap(); | |
| 199 EXPECT_EQ(CloudPolicyStore::STATUS_OK, store_->status()); | |
| 200 } | |
| 201 | |
| 202 TEST_F(UserCloudPolicyStoreChromeOSTest, LoadNoPolicy) { | |
| 203 EXPECT_CALL(observer_, OnStoreLoaded(store_.get())); | |
| 204 ASSERT_NO_FATAL_FAILURE(PerformPolicyLoad("")); | |
| 205 Mock::VerifyAndClearExpectations(&observer_); | |
| 206 | |
| 207 // Verify no policy has been installed. | |
| 208 EXPECT_FALSE(store_->policy()); | |
| 209 EXPECT_TRUE(store_->policy_map().empty()); | |
| 210 EXPECT_EQ(CloudPolicyStore::STATUS_OK, store_->status()); | |
| 211 } | |
| 212 | |
| 213 TEST_F(UserCloudPolicyStoreChromeOSTest, LoadInvalidPolicy) { | |
| 214 ExpectError(CloudPolicyStore::STATUS_PARSE_ERROR); | |
| 215 ASSERT_NO_FATAL_FAILURE(PerformPolicyLoad("invalid")); | |
| 216 | |
| 217 // Verify no policy has been installed. | |
| 218 EXPECT_FALSE(store_->policy()); | |
| 219 EXPECT_TRUE(store_->policy_map().empty()); | |
| 220 EXPECT_EQ(CloudPolicyStore::STATUS_PARSE_ERROR, store_->status()); | |
| 221 } | |
| 222 | |
| 223 TEST_F(UserCloudPolicyStoreChromeOSTest, LoadValidationError) { | |
| 224 policy_.policy_data().clear_policy_type(); | |
| 225 policy_.Build(); | |
| 226 | |
| 227 ExpectError(CloudPolicyStore::STATUS_VALIDATION_ERROR); | |
| 228 ASSERT_NO_FATAL_FAILURE(PerformPolicyLoad(policy_.GetBlob())); | |
| 229 | |
| 230 // Verify no policy has been installed. | |
| 231 EXPECT_FALSE(store_->policy()); | |
| 232 EXPECT_TRUE(store_->policy_map().empty()); | |
| 233 EXPECT_EQ(CloudPolicyStore::STATUS_VALIDATION_ERROR, store_->status()); | |
| 234 } | |
| 235 | |
| 236 TEST_F(UserCloudPolicyStoreChromeOSTest, MigrationFull) { | |
| 237 std::string data; | |
| 238 | |
| 239 em::DeviceCredentials credentials; | |
| 240 credentials.set_device_token(kLegacyToken); | |
| 241 credentials.set_device_id(kLegacyDeviceId); | |
| 242 ASSERT_TRUE(credentials.SerializeToString(&data)); | |
| 243 ASSERT_NE(-1, file_util::WriteFile(token_file(), data.c_str(), data.size())); | |
| 244 | |
| 245 em::CachedCloudPolicyResponse cached_policy; | |
| 246 cached_policy.mutable_cloud_policy()->CopyFrom(policy_.policy()); | |
| 247 ASSERT_TRUE(cached_policy.SerializeToString(&data)); | |
| 248 ASSERT_NE(-1, file_util::WriteFile(policy_file(), data.c_str(), data.size())); | |
| 249 | |
| 250 EXPECT_CALL(observer_, OnStoreLoaded(store_.get())); | |
| 251 ASSERT_NO_FATAL_FAILURE(PerformPolicyLoad("")); | |
| 252 Mock::VerifyAndClearExpectations(&observer_); | |
| 253 | |
| 254 // Verify that legacy user policy and token have been loaded. | |
| 255 em::PolicyData expected_policy_data; | |
| 256 EXPECT_TRUE(expected_policy_data.ParseFromString( | |
| 257 cached_policy.cloud_policy().policy_data())); | |
| 258 expected_policy_data.clear_public_key_version(); | |
| 259 expected_policy_data.set_request_token(kLegacyToken); | |
| 260 expected_policy_data.set_device_id(kLegacyDeviceId); | |
| 261 ASSERT_TRUE(store_->policy()); | |
| 262 EXPECT_EQ(expected_policy_data.SerializeAsString(), | |
| 263 store_->policy()->SerializeAsString()); | |
| 264 VerifyPolicyMap(); | |
| 265 EXPECT_EQ(CloudPolicyStore::STATUS_OK, store_->status()); | |
| 266 }; | |
| 267 | |
| 268 TEST_F(UserCloudPolicyStoreChromeOSTest, MigrationNoToken) { | |
| 269 std::string data; | |
| 270 testing::Sequence seq; | |
| 271 | |
| 272 em::CachedCloudPolicyResponse cached_policy; | |
| 273 cached_policy.mutable_cloud_policy()->CopyFrom(policy_.policy()); | |
| 274 ASSERT_TRUE(cached_policy.SerializeToString(&data)); | |
| 275 ASSERT_NE(-1, file_util::WriteFile(policy_file(), data.c_str(), data.size())); | |
| 276 | |
| 277 EXPECT_CALL(observer_, OnStoreLoaded(store_.get())); | |
| 278 ASSERT_NO_FATAL_FAILURE(PerformPolicyLoad("")); | |
| 279 Mock::VerifyAndClearExpectations(&observer_); | |
| 280 | |
| 281 // Verify the legacy cache has been loaded. | |
| 282 em::PolicyData expected_policy_data; | |
| 283 EXPECT_TRUE(expected_policy_data.ParseFromString( | |
| 284 cached_policy.cloud_policy().policy_data())); | |
| 285 expected_policy_data.clear_public_key_version(); | |
| 286 ASSERT_TRUE(store_->policy()); | |
| 287 EXPECT_EQ(expected_policy_data.SerializeAsString(), | |
| 288 store_->policy()->SerializeAsString()); | |
| 289 VerifyPolicyMap(); | |
| 290 EXPECT_EQ(CloudPolicyStore::STATUS_OK, store_->status()); | |
| 291 }; | |
| 292 | |
| 293 TEST_F(UserCloudPolicyStoreChromeOSTest, MigrationNoPolicy) { | |
| 294 std::string data; | |
| 295 | |
| 296 em::DeviceCredentials credentials; | |
| 297 credentials.set_device_token(kLegacyToken); | |
| 298 credentials.set_device_id(kLegacyDeviceId); | |
| 299 ASSERT_TRUE(credentials.SerializeToString(&data)); | |
| 300 ASSERT_NE(-1, file_util::WriteFile(token_file(), data.c_str(), data.size())); | |
| 301 | |
| 302 EXPECT_CALL(observer_, OnStoreLoaded(store_.get())); | |
| 303 ASSERT_NO_FATAL_FAILURE(PerformPolicyLoad("")); | |
| 304 Mock::VerifyAndClearExpectations(&observer_); | |
| 305 | |
| 306 // Verify that legacy user policy and token have been loaded. | |
| 307 em::PolicyData expected_policy_data; | |
| 308 expected_policy_data.set_request_token(kLegacyToken); | |
| 309 expected_policy_data.set_device_id(kLegacyDeviceId); | |
| 310 ASSERT_TRUE(store_->policy()); | |
| 311 EXPECT_EQ(expected_policy_data.SerializeAsString(), | |
| 312 store_->policy()->SerializeAsString()); | |
| 313 EXPECT_TRUE(store_->policy_map().empty()); | |
| 314 EXPECT_EQ(CloudPolicyStore::STATUS_OK, store_->status()); | |
| 315 }; | |
| 316 | |
| 317 } // namespace | |
| 318 | |
| 319 } // namespace policy | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 12189011:
Split up chrome/browser/policy subdirectory (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src