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 |