| 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 "base/bind.h" | |
| 6 #include "base/file_path.h" | |
| 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 "base/time.h" | |
| 12 #include "chrome/browser/policy/cloud_policy_data_store.h" | |
| 13 #include "chrome/browser/policy/cros_user_policy_cache.h" | |
| 14 #include "chrome/browser/policy/proto/cloud_policy.pb.h" | |
| 15 #include "chrome/browser/policy/proto/device_management_backend.pb.h" | |
| 16 #include "chrome/browser/policy/proto/device_management_local.pb.h" | |
| 17 #include "chromeos/dbus/mock_session_manager_client.h" | |
| 18 #include "content/public/test/test_browser_thread.h" | |
| 19 #include "policy/policy_constants.h" | |
| 20 #include "testing/gmock/include/gmock/gmock.h" | |
| 21 #include "testing/gtest/include/gtest/gtest.h" | |
| 22 | |
| 23 using testing::InvokeArgument; | |
| 24 using testing::_; | |
| 25 | |
| 26 namespace em = enterprise_management; | |
| 27 | |
| 28 // These should probably be moved to a more central place. | |
| 29 ACTION_TEMPLATE(InvokeCallbackArgument, | |
| 30 HAS_1_TEMPLATE_PARAMS(int, k), | |
| 31 AND_1_VALUE_PARAMS(p1)) { | |
| 32 MessageLoop::current()->PostTask( | |
| 33 FROM_HERE, | |
| 34 base::Bind(::std::tr1::get<k>(args), p1)); | |
| 35 } | |
| 36 ACTION_TEMPLATE(InvokeCallbackArgument, | |
| 37 HAS_1_TEMPLATE_PARAMS(int, k), | |
| 38 AND_2_VALUE_PARAMS(p1, p2)) { | |
| 39 MessageLoop::current()->PostTask( | |
| 40 FROM_HERE, | |
| 41 base::Bind(::std::tr1::get<k>(args), p1, p2)); | |
| 42 } | |
| 43 | |
| 44 namespace policy { | |
| 45 namespace { | |
| 46 | |
| 47 const char kFakeToken[] = "token"; | |
| 48 const char kFakeSignature[] = "signature"; | |
| 49 const char kFakeMachineName[] = "machine-name"; | |
| 50 const char kFakeUsername[] = "username"; | |
| 51 const int kFakePublicKeyVersion = 17; | |
| 52 const char kFakeDeviceId[] = "device-id"; | |
| 53 | |
| 54 class CrosUserPolicyCacheTest : public testing::Test { | |
| 55 protected: | |
| 56 CrosUserPolicyCacheTest() | |
| 57 : loop_(MessageLoop::TYPE_UI), | |
| 58 data_store_(CloudPolicyDataStore::CreateForUserPolicies()), | |
| 59 ui_thread_(content::BrowserThread::UI, &loop_), | |
| 60 file_thread_(content::BrowserThread::FILE, &loop_) {} | |
| 61 | |
| 62 virtual void SetUp() { | |
| 63 ASSERT_TRUE(tmp_dir_.CreateUniqueTempDir()); | |
| 64 } | |
| 65 | |
| 66 void CreatePolicyResponse(em::PolicyFetchResponse* response) { | |
| 67 em::CloudPolicySettings policy_settings; | |
| 68 policy_settings.mutable_showhomebutton()->set_value(true); | |
| 69 | |
| 70 em::PolicyData policy_data; | |
| 71 policy_data.set_policy_type(dm_protocol::kChromeUserPolicyType); | |
| 72 policy_data.set_timestamp((base::Time::NowFromSystemTime() - | |
| 73 base::Time::UnixEpoch()).InMilliseconds()); | |
| 74 policy_data.set_request_token(kFakeToken); | |
| 75 ASSERT_TRUE( | |
| 76 policy_settings.SerializeToString(policy_data.mutable_policy_value())); | |
| 77 policy_data.set_machine_name(kFakeMachineName); | |
| 78 policy_data.set_public_key_version(kFakePublicKeyVersion); | |
| 79 policy_data.set_username(kFakeUsername); | |
| 80 policy_data.set_device_id(kFakeDeviceId); | |
| 81 policy_data.set_state(em::PolicyData::ACTIVE); | |
| 82 | |
| 83 ASSERT_TRUE(policy_data.SerializeToString(response->mutable_policy_data())); | |
| 84 response->set_policy_data_signature(kFakeSignature); | |
| 85 } | |
| 86 | |
| 87 FilePath token_file() { | |
| 88 return tmp_dir_.path().Append(FILE_PATH_LITERAL("token")); | |
| 89 } | |
| 90 | |
| 91 FilePath policy_file() { | |
| 92 return tmp_dir_.path().Append(FILE_PATH_LITERAL("policy")); | |
| 93 } | |
| 94 | |
| 95 MessageLoop loop_; | |
| 96 | |
| 97 chromeos::MockSessionManagerClient session_manager_client_; | |
| 98 scoped_ptr<CloudPolicyDataStore> data_store_; | |
| 99 | |
| 100 private: | |
| 101 content::TestBrowserThread ui_thread_; | |
| 102 content::TestBrowserThread file_thread_; | |
| 103 base::ScopedTempDir tmp_dir_; | |
| 104 | |
| 105 DISALLOW_COPY_AND_ASSIGN(CrosUserPolicyCacheTest); | |
| 106 }; | |
| 107 | |
| 108 TEST_F(CrosUserPolicyCacheTest, InitAndSetPolicy) { | |
| 109 CrosUserPolicyCache cache(&session_manager_client_, | |
| 110 data_store_.get(), | |
| 111 false, | |
| 112 token_file(), | |
| 113 policy_file()); | |
| 114 EXPECT_FALSE(cache.IsReady()); | |
| 115 EXPECT_FALSE(data_store_->token_cache_loaded()); | |
| 116 | |
| 117 // Initialize the cache. | |
| 118 EXPECT_CALL(session_manager_client_, RetrieveUserPolicy(_)) | |
| 119 .WillOnce(InvokeCallbackArgument<0>(std::string())); | |
| 120 | |
| 121 cache.Load(); | |
| 122 loop_.RunUntilIdle(); | |
| 123 | |
| 124 EXPECT_TRUE(cache.IsReady()); | |
| 125 EXPECT_TRUE(data_store_->token_cache_loaded()); | |
| 126 EXPECT_EQ(0U, cache.policy()->size()); | |
| 127 | |
| 128 // Set policy. | |
| 129 em::PolicyFetchResponse response; | |
| 130 CreatePolicyResponse(&response); | |
| 131 std::string serialized_response; | |
| 132 ASSERT_TRUE(response.SerializeToString(&serialized_response)); | |
| 133 testing::Sequence seq; | |
| 134 EXPECT_CALL(session_manager_client_, StoreUserPolicy(serialized_response, _)) | |
| 135 .InSequence(seq) | |
| 136 .WillOnce(InvokeCallbackArgument<1>(true)); | |
| 137 EXPECT_CALL(session_manager_client_, RetrieveUserPolicy(_)) | |
| 138 .InSequence(seq) | |
| 139 .WillOnce(InvokeCallbackArgument<0>(serialized_response)); | |
| 140 | |
| 141 EXPECT_TRUE(cache.SetPolicy(response)); | |
| 142 loop_.RunUntilIdle(); | |
| 143 | |
| 144 EXPECT_EQ(1U, cache.policy()->size()); | |
| 145 const PolicyMap::Entry* entry = cache.policy()->Get(key::kShowHomeButton); | |
| 146 ASSERT_TRUE(entry); | |
| 147 EXPECT_TRUE(base::FundamentalValue(true).Equals(entry->value)); | |
| 148 }; | |
| 149 | |
| 150 TEST_F(CrosUserPolicyCacheTest, Migration) { | |
| 151 std::string data; | |
| 152 | |
| 153 em::DeviceCredentials credentials; | |
| 154 credentials.set_device_token(kFakeToken); | |
| 155 credentials.set_device_id(kFakeDeviceId); | |
| 156 ASSERT_TRUE(credentials.SerializeToString(&data)); | |
| 157 ASSERT_NE(-1, file_util::WriteFile(token_file(), data.c_str(), data.size())); | |
| 158 | |
| 159 em::CachedCloudPolicyResponse policy; | |
| 160 CreatePolicyResponse(policy.mutable_cloud_policy()); | |
| 161 ASSERT_TRUE(policy.SerializeToString(&data)); | |
| 162 ASSERT_NE(-1, file_util::WriteFile(policy_file(), data.c_str(), data.size())); | |
| 163 | |
| 164 CrosUserPolicyCache cache(&session_manager_client_, | |
| 165 data_store_.get(), | |
| 166 false, | |
| 167 token_file(), | |
| 168 policy_file()); | |
| 169 EXPECT_FALSE(cache.IsReady()); | |
| 170 EXPECT_FALSE(data_store_->token_cache_loaded()); | |
| 171 | |
| 172 // Initialize the cache. | |
| 173 EXPECT_CALL(session_manager_client_, RetrieveUserPolicy(_)) | |
| 174 .WillOnce(InvokeCallbackArgument<0>(std::string())); | |
| 175 | |
| 176 cache.Load(); | |
| 177 loop_.RunUntilIdle(); | |
| 178 | |
| 179 EXPECT_TRUE(cache.IsReady()); | |
| 180 EXPECT_TRUE(data_store_->token_cache_loaded()); | |
| 181 EXPECT_EQ(kFakeDeviceId, data_store_->device_id()); | |
| 182 EXPECT_EQ(kFakeToken, data_store_->device_token()); | |
| 183 EXPECT_EQ(1U, cache.policy()->size()); | |
| 184 const PolicyMap::Entry* entry = cache.policy()->Get(key::kShowHomeButton); | |
| 185 ASSERT_TRUE(entry); | |
| 186 EXPECT_TRUE(base::FundamentalValue(true).Equals(entry->value)); | |
| 187 }; | |
| 188 | |
| 189 } // namespace | |
| 190 } // namespace policy | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 11946017:
Remove old cloud policy code. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src