OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/bind.h" | 5 #include "base/bind.h" |
6 #include "base/location.h" | 6 #include "base/location.h" |
7 #include "base/run_loop.h" | 7 #include "base/run_loop.h" |
8 #include "base/single_thread_task_runner.h" | 8 #include "base/single_thread_task_runner.h" |
9 #include "base/threading/thread_task_runner_handle.h" | 9 #include "base/threading/thread_task_runner_handle.h" |
10 #include "chrome/browser/extensions/extension_install_checker.h" | 10 #include "chrome/browser/extensions/extension_install_checker.h" |
11 #include "testing/gtest/include/gtest/gtest.h" | 11 #include "testing/gtest/include/gtest/gtest.h" |
12 | 12 |
13 namespace extensions { | 13 namespace extensions { |
14 | 14 |
15 namespace { | 15 namespace { |
16 | 16 |
17 const BlacklistState kBlacklistStateError = BLACKLISTED_MALWARE; | 17 const BlacklistState kBlacklistStateError = BLACKLISTED_MALWARE; |
18 const char kDummyRequirementsError[] = "Requirements error"; | 18 const char kDummyRequirementsError[] = "Requirements error"; |
19 const char kDummyPolicyError[] = "Cannot install extension"; | 19 const char kDummyPolicyError[] = "Cannot install extension"; |
20 | 20 |
| 21 const char kDummyPolicyError2[] = "Another policy error"; |
| 22 const char kDummyRequirementsError2[] = "Another requirements error"; |
| 23 const BlacklistState kBlacklistState2 = BLACKLISTED_SECURITY_VULNERABILITY; |
| 24 |
21 } // namespace | 25 } // namespace |
22 | 26 |
23 // Stubs most of the checks since we are interested in validating the logic in | 27 // Stubs most of the checks since we are interested in validating the logic in |
24 // the install checker. This class implements a synchronous version of all | 28 // the install checker. This class implements a synchronous version of all |
25 // checks. | 29 // checks. |
26 class ExtensionInstallCheckerForTest : public ExtensionInstallChecker { | 30 class ExtensionInstallCheckerForTest : public ExtensionInstallChecker { |
27 public: | 31 public: |
28 ExtensionInstallCheckerForTest(int enabled_checks, bool fail_fast) | 32 ExtensionInstallCheckerForTest() |
29 : ExtensionInstallChecker(nullptr, nullptr, enabled_checks, fail_fast), | 33 : ExtensionInstallChecker(NULL), |
30 requirements_check_called_(false), | 34 requirements_check_called_(false), |
31 blacklist_check_called_(false), | 35 blacklist_check_called_(false), |
32 policy_check_called_(false), | 36 policy_check_called_(false), |
33 blacklist_state_(NOT_BLACKLISTED) {} | 37 blacklist_state_(NOT_BLACKLISTED) {} |
34 | 38 |
35 ~ExtensionInstallCheckerForTest() override {} | 39 ~ExtensionInstallCheckerForTest() override {} |
36 | 40 |
37 void set_requirements_error(const std::string& error) { | 41 void set_requirements_error(const std::string& error) { |
38 requirements_error_ = error; | 42 requirements_error_ = error; |
39 } | 43 } |
40 void set_policy_check_error(const std::string& error) { | 44 void set_policy_check_error(const std::string& error) { |
41 policy_check_error_ = error; | 45 policy_check_error_ = error; |
42 } | 46 } |
43 void set_blacklist_state(BlacklistState state) { blacklist_state_ = state; } | 47 void set_blacklist_state(BlacklistState state) { blacklist_state_ = state; } |
44 | 48 |
45 bool requirements_check_called() const { return requirements_check_called_; } | 49 bool requirements_check_called() const { return requirements_check_called_; } |
46 bool blacklist_check_called() const { return blacklist_check_called_; } | 50 bool blacklist_check_called() const { return blacklist_check_called_; } |
47 bool policy_check_called() const { return policy_check_called_; } | 51 bool policy_check_called() const { return policy_check_called_; } |
48 | 52 |
49 void MockCheckRequirements() { | 53 void MockCheckRequirements(int sequence_number) { |
50 if (!is_running()) | |
51 return; | |
52 std::vector<std::string> errors; | 54 std::vector<std::string> errors; |
53 if (!requirements_error_.empty()) | 55 if (!requirements_error_.empty()) |
54 errors.push_back(requirements_error_); | 56 errors.push_back(requirements_error_); |
55 OnRequirementsCheckDone(errors); | 57 OnRequirementsCheckDone(sequence_number, errors); |
56 } | 58 } |
57 | 59 |
58 void MockCheckBlacklistState() { | 60 void MockCheckBlacklistState(int sequence_number) { |
59 if (!is_running()) | 61 OnBlacklistStateCheckDone(sequence_number, blacklist_state_); |
60 return; | |
61 OnBlacklistStateCheckDone(blacklist_state_); | |
62 } | 62 } |
63 | 63 |
64 protected: | 64 protected: |
65 void CheckRequirements() override { | 65 void CheckRequirements() override { |
66 requirements_check_called_ = true; | 66 requirements_check_called_ = true; |
67 MockCheckRequirements(); | 67 MockCheckRequirements(current_sequence_number()); |
68 } | 68 } |
69 | 69 |
70 void CheckManagementPolicy() override { | 70 void CheckManagementPolicy() override { |
71 policy_check_called_ = true; | 71 policy_check_called_ = true; |
72 OnManagementPolicyCheckDone(policy_check_error_.empty(), | 72 OnManagementPolicyCheckDone(policy_check_error_.empty(), |
73 policy_check_error_); | 73 policy_check_error_); |
74 } | 74 } |
75 | 75 |
76 void CheckBlacklistState() override { | 76 void CheckBlacklistState() override { |
77 blacklist_check_called_ = true; | 77 blacklist_check_called_ = true; |
78 MockCheckBlacklistState(); | 78 MockCheckBlacklistState(current_sequence_number()); |
| 79 } |
| 80 |
| 81 void ResetResults() override { |
| 82 ExtensionInstallChecker::ResetResults(); |
| 83 |
| 84 requirements_check_called_ = false; |
| 85 blacklist_check_called_ = false; |
| 86 policy_check_called_ = false; |
79 } | 87 } |
80 | 88 |
81 bool requirements_check_called_; | 89 bool requirements_check_called_; |
82 bool blacklist_check_called_; | 90 bool blacklist_check_called_; |
83 bool policy_check_called_; | 91 bool policy_check_called_; |
84 | 92 |
85 // Dummy errors for testing. | 93 // Dummy errors for testing. |
86 std::string requirements_error_; | 94 std::string requirements_error_; |
87 std::string policy_check_error_; | 95 std::string policy_check_error_; |
88 BlacklistState blacklist_state_; | 96 BlacklistState blacklist_state_; |
89 }; | 97 }; |
90 | 98 |
91 // This class implements asynchronous mocks of the requirements and blacklist | 99 // This class implements asynchronous mocks of the requirements and blacklist |
92 // checks. | 100 // checks. |
93 class ExtensionInstallCheckerAsync : public ExtensionInstallCheckerForTest { | 101 class ExtensionInstallCheckerAsync : public ExtensionInstallCheckerForTest { |
94 public: | |
95 ExtensionInstallCheckerAsync(int enabled_checks, bool fail_fast) | |
96 : ExtensionInstallCheckerForTest(enabled_checks, fail_fast) {} | |
97 | |
98 protected: | 102 protected: |
99 void CheckRequirements() override { | 103 void CheckRequirements() override { |
100 requirements_check_called_ = true; | 104 requirements_check_called_ = true; |
101 | 105 |
102 base::ThreadTaskRunnerHandle::Get()->PostTask( | 106 base::ThreadTaskRunnerHandle::Get()->PostTask( |
103 FROM_HERE, | 107 FROM_HERE, |
104 base::Bind(&ExtensionInstallCheckerForTest::MockCheckRequirements, | 108 base::Bind(&ExtensionInstallCheckerForTest::MockCheckRequirements, |
105 base::Unretained(this))); | 109 base::Unretained(this), current_sequence_number())); |
106 } | 110 } |
107 | 111 |
108 void CheckBlacklistState() override { | 112 void CheckBlacklistState() override { |
109 blacklist_check_called_ = true; | 113 blacklist_check_called_ = true; |
110 | 114 |
111 base::ThreadTaskRunnerHandle::Get()->PostTask( | 115 base::ThreadTaskRunnerHandle::Get()->PostTask( |
112 FROM_HERE, | 116 FROM_HERE, |
113 base::Bind(&ExtensionInstallCheckerForTest::MockCheckBlacklistState, | 117 base::Bind(&ExtensionInstallCheckerForTest::MockCheckBlacklistState, |
114 base::Unretained(this))); | 118 base::Unretained(this), current_sequence_number())); |
115 } | 119 } |
116 }; | 120 }; |
117 | 121 |
118 class CheckObserver { | 122 class CheckObserver { |
119 public: | 123 public: |
120 CheckObserver() : result_(0), call_count_(0) {} | 124 CheckObserver() : result_(0), call_count_(0) {} |
121 | 125 |
122 int result() const { return result_; } | 126 int result() const { return result_; } |
123 int call_count() const { return call_count_; } | 127 int call_count() const { return call_count_; } |
124 | 128 |
(...skipping 12 matching lines...) Expand all Loading... |
137 private: | 141 private: |
138 int result_; | 142 int result_; |
139 int call_count_; | 143 int call_count_; |
140 }; | 144 }; |
141 | 145 |
142 class ExtensionInstallCheckerTest : public testing::Test { | 146 class ExtensionInstallCheckerTest : public testing::Test { |
143 public: | 147 public: |
144 ExtensionInstallCheckerTest() {} | 148 ExtensionInstallCheckerTest() {} |
145 ~ExtensionInstallCheckerTest() override {} | 149 ~ExtensionInstallCheckerTest() override {} |
146 | 150 |
| 151 void RunSecondInvocation(ExtensionInstallCheckerForTest* checker, |
| 152 int checks_failed) { |
| 153 EXPECT_GT(checks_failed, 0); |
| 154 EXPECT_FALSE(checker->is_running()); |
| 155 ValidateExpectedCalls(ExtensionInstallChecker::CHECK_ALL, *checker); |
| 156 |
| 157 // Set up different return values. |
| 158 checker->set_blacklist_state(kBlacklistState2); |
| 159 checker->set_policy_check_error(kDummyPolicyError2); |
| 160 checker->set_requirements_error(kDummyRequirementsError2); |
| 161 |
| 162 // Run the install checker again and ensure the second set of return values |
| 163 // is received. |
| 164 checker->Start( |
| 165 ExtensionInstallChecker::CHECK_ALL, |
| 166 false /* fail fast */, |
| 167 base::Bind(&ExtensionInstallCheckerTest::ValidateSecondInvocation, |
| 168 base::Unretained(this), |
| 169 checker)); |
| 170 } |
| 171 |
| 172 void ValidateSecondInvocation(ExtensionInstallCheckerForTest* checker, |
| 173 int checks_failed) { |
| 174 EXPECT_FALSE(checker->is_running()); |
| 175 EXPECT_EQ(ExtensionInstallChecker::CHECK_REQUIREMENTS | |
| 176 ExtensionInstallChecker::CHECK_MANAGEMENT_POLICY, |
| 177 checks_failed); |
| 178 ValidateExpectedCalls(ExtensionInstallChecker::CHECK_ALL, *checker); |
| 179 |
| 180 EXPECT_EQ(kBlacklistState2, checker->blacklist_state()); |
| 181 ExpectPolicyError(kDummyPolicyError2, *checker); |
| 182 ExpectRequirementsError(kDummyRequirementsError2, *checker); |
| 183 } |
| 184 |
147 protected: | 185 protected: |
148 void SetAllErrors(ExtensionInstallCheckerForTest* checker) { | 186 void SetAllErrors(ExtensionInstallCheckerForTest* checker) { |
149 checker->set_blacklist_state(kBlacklistStateError); | 187 checker->set_blacklist_state(kBlacklistStateError); |
150 checker->set_policy_check_error(kDummyPolicyError); | 188 checker->set_policy_check_error(kDummyPolicyError); |
151 checker->set_requirements_error(kDummyRequirementsError); | 189 checker->set_requirements_error(kDummyRequirementsError); |
152 } | 190 } |
153 | 191 |
154 void ValidateExpectedCalls(int call_mask, | 192 void ValidateExpectedCalls(int call_mask, |
155 const ExtensionInstallCheckerForTest& checker) { | 193 const ExtensionInstallCheckerForTest& checker) { |
156 bool expect_blacklist_checked = | 194 bool expect_blacklist_checked = |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
197 EXPECT_FALSE(checker.policy_allows_load()); | 235 EXPECT_FALSE(checker.policy_allows_load()); |
198 EXPECT_FALSE(checker.policy_error().empty()); | 236 EXPECT_FALSE(checker.policy_error().empty()); |
199 EXPECT_EQ(std::string(expected_error), checker.policy_error()); | 237 EXPECT_EQ(std::string(expected_error), checker.policy_error()); |
200 } | 238 } |
201 | 239 |
202 void ExpectPolicyError(const ExtensionInstallCheckerForTest& checker) { | 240 void ExpectPolicyError(const ExtensionInstallCheckerForTest& checker) { |
203 ExpectPolicyError(kDummyPolicyError, checker); | 241 ExpectPolicyError(kDummyPolicyError, checker); |
204 } | 242 } |
205 | 243 |
206 void RunChecker(ExtensionInstallCheckerForTest* checker, | 244 void RunChecker(ExtensionInstallCheckerForTest* checker, |
| 245 bool fail_fast, |
| 246 int checks_to_run, |
207 int expected_checks_run, | 247 int expected_checks_run, |
208 int expected_result) { | 248 int expected_result) { |
209 CheckObserver observer; | 249 CheckObserver observer; |
210 checker->Start(base::Bind(&CheckObserver::OnChecksComplete, | 250 checker->Start(checks_to_run, |
| 251 fail_fast, |
| 252 base::Bind(&CheckObserver::OnChecksComplete, |
211 base::Unretained(&observer))); | 253 base::Unretained(&observer))); |
212 observer.Wait(); | 254 observer.Wait(); |
213 | 255 |
214 EXPECT_FALSE(checker->is_running()); | 256 EXPECT_FALSE(checker->is_running()); |
215 EXPECT_EQ(expected_result, observer.result()); | 257 EXPECT_EQ(expected_result, observer.result()); |
216 EXPECT_EQ(1, observer.call_count()); | 258 EXPECT_EQ(1, observer.call_count()); |
217 ValidateExpectedCalls(expected_checks_run, *checker); | 259 ValidateExpectedCalls(expected_checks_run, *checker); |
218 } | 260 } |
219 | 261 |
220 void DoRunAllChecksPass(ExtensionInstallCheckerForTest* checker) { | 262 void DoRunAllChecksPass(ExtensionInstallCheckerForTest* checker) { |
221 RunChecker(checker, | 263 RunChecker(checker, |
| 264 false /* fail fast */, |
| 265 ExtensionInstallChecker::CHECK_ALL, |
222 ExtensionInstallChecker::CHECK_ALL, | 266 ExtensionInstallChecker::CHECK_ALL, |
223 0); | 267 0); |
224 | 268 |
225 ExpectRequirementsPass(*checker); | 269 ExpectRequirementsPass(*checker); |
226 ExpectPolicyPass(*checker); | 270 ExpectPolicyPass(*checker); |
227 ExpectBlacklistPass(*checker); | 271 ExpectBlacklistPass(*checker); |
228 } | 272 } |
229 | 273 |
230 void DoRunAllChecksFail(ExtensionInstallCheckerForTest* checker) { | 274 void DoRunAllChecksFail(ExtensionInstallCheckerForTest* checker) { |
231 SetAllErrors(checker); | 275 SetAllErrors(checker); |
232 RunChecker(checker, | 276 RunChecker(checker, |
| 277 false /* fail fast */, |
| 278 ExtensionInstallChecker::CHECK_ALL, |
233 ExtensionInstallChecker::CHECK_ALL, | 279 ExtensionInstallChecker::CHECK_ALL, |
234 ExtensionInstallChecker::CHECK_ALL); | 280 ExtensionInstallChecker::CHECK_ALL); |
235 | 281 |
236 ExpectRequirementsError(*checker); | 282 ExpectRequirementsError(*checker); |
237 ExpectPolicyError(*checker); | 283 ExpectPolicyError(*checker); |
238 ExpectBlacklistError(*checker); | 284 ExpectBlacklistError(*checker); |
239 } | 285 } |
240 | 286 |
241 void DoRunSubsetOfChecks(int checks_to_run) { | 287 void DoRunSubsetOfChecks(ExtensionInstallCheckerForTest* checker) { |
242 ExtensionInstallCheckerForTest sync_checker(checks_to_run, | 288 // Test check set 1. |
243 /*fail_fast=*/false); | 289 int tests_to_run = ExtensionInstallChecker::CHECK_MANAGEMENT_POLICY | |
244 ExtensionInstallCheckerAsync async_checker(checks_to_run, | 290 ExtensionInstallChecker::CHECK_REQUIREMENTS; |
245 /*fail_fast=*/false); | 291 SetAllErrors(checker); |
246 ExtensionInstallCheckerForTest* checkers[] = { | 292 RunChecker(checker, false, tests_to_run, tests_to_run, tests_to_run); |
247 &sync_checker, &async_checker, | |
248 }; | |
249 | 293 |
250 for (auto* checker : checkers) { | 294 ExpectRequirementsError(*checker); |
251 SetAllErrors(checker); | 295 ExpectPolicyError(*checker); |
252 RunChecker(checker, checks_to_run, checks_to_run); | 296 ExpectBlacklistPass(*checker); |
253 | 297 |
254 if (checks_to_run & ExtensionInstallChecker::CHECK_REQUIREMENTS) | 298 // Test check set 2. |
255 ExpectRequirementsError(*checker); | 299 tests_to_run = ExtensionInstallChecker::CHECK_BLACKLIST | |
256 else | 300 ExtensionInstallChecker::CHECK_REQUIREMENTS; |
257 ExpectRequirementsPass(*checker); | 301 SetAllErrors(checker); |
| 302 RunChecker(checker, false, tests_to_run, tests_to_run, tests_to_run); |
258 | 303 |
259 if (checks_to_run & ExtensionInstallChecker::CHECK_MANAGEMENT_POLICY) | 304 ExpectRequirementsError(*checker); |
260 ExpectPolicyError(*checker); | 305 ExpectPolicyPass(*checker); |
261 else | 306 ExpectBlacklistError(*checker); |
262 ExpectPolicyPass(*checker); | |
263 | 307 |
264 if (checks_to_run & ExtensionInstallChecker::CHECK_BLACKLIST) | 308 // Test a single check. |
265 ExpectBlacklistError(*checker); | 309 tests_to_run = ExtensionInstallChecker::CHECK_BLACKLIST; |
266 else | 310 SetAllErrors(checker); |
267 ExpectBlacklistPass(*checker); | 311 RunChecker(checker, false, tests_to_run, tests_to_run, tests_to_run); |
268 } | 312 |
| 313 ExpectRequirementsPass(*checker); |
| 314 ExpectPolicyPass(*checker); |
| 315 ExpectBlacklistError(*checker); |
269 } | 316 } |
270 | 317 |
271 private: | 318 private: |
272 // A message loop is required for the asynchronous tests. | 319 // A message loop is required for the asynchronous tests. |
273 base::MessageLoop message_loop; | 320 base::MessageLoop message_loop; |
274 }; | 321 }; |
275 | 322 |
| 323 class ExtensionInstallCheckerMultipleInvocationTest |
| 324 : public ExtensionInstallCheckerTest { |
| 325 public: |
| 326 ExtensionInstallCheckerMultipleInvocationTest() : callback_count_(0) {} |
| 327 ~ExtensionInstallCheckerMultipleInvocationTest() override {} |
| 328 |
| 329 void RunSecondInvocation(ExtensionInstallCheckerForTest* checker, |
| 330 int checks_failed) { |
| 331 ASSERT_EQ(0, callback_count_); |
| 332 ++callback_count_; |
| 333 EXPECT_FALSE(checker->is_running()); |
| 334 EXPECT_GT(checks_failed, 0); |
| 335 ValidateExpectedCalls(ExtensionInstallChecker::CHECK_ALL, *checker); |
| 336 |
| 337 // Set up different return values. |
| 338 checker->set_blacklist_state(kBlacklistState2); |
| 339 checker->set_policy_check_error(kDummyPolicyError2); |
| 340 checker->set_requirements_error(kDummyRequirementsError2); |
| 341 |
| 342 // Run the install checker again and ensure the second set of return values |
| 343 // is received. |
| 344 checker->Start(ExtensionInstallChecker::CHECK_ALL, |
| 345 false /* fail fast */, |
| 346 base::Bind(&ExtensionInstallCheckerMultipleInvocationTest:: |
| 347 ValidateSecondInvocation, |
| 348 base::Unretained(this), |
| 349 checker)); |
| 350 } |
| 351 |
| 352 void ValidateSecondInvocation(ExtensionInstallCheckerForTest* checker, |
| 353 int checks_failed) { |
| 354 ASSERT_EQ(1, callback_count_); |
| 355 EXPECT_FALSE(checker->is_running()); |
| 356 EXPECT_EQ(ExtensionInstallChecker::CHECK_REQUIREMENTS | |
| 357 ExtensionInstallChecker::CHECK_MANAGEMENT_POLICY, |
| 358 checks_failed); |
| 359 ValidateExpectedCalls(ExtensionInstallChecker::CHECK_ALL, *checker); |
| 360 |
| 361 EXPECT_EQ(kBlacklistState2, checker->blacklist_state()); |
| 362 ExpectPolicyError(kDummyPolicyError2, *checker); |
| 363 ExpectRequirementsError(kDummyRequirementsError2, *checker); |
| 364 } |
| 365 |
| 366 private: |
| 367 int callback_count_; |
| 368 }; |
| 369 |
276 // Test the case where all tests pass. | 370 // Test the case where all tests pass. |
277 TEST_F(ExtensionInstallCheckerTest, AllSucceeded) { | 371 TEST_F(ExtensionInstallCheckerTest, AllSucceeded) { |
278 ExtensionInstallCheckerForTest sync_checker( | 372 ExtensionInstallCheckerForTest sync_checker; |
279 ExtensionInstallChecker::CHECK_ALL, /*fail_fast=*/false); | |
280 DoRunAllChecksPass(&sync_checker); | 373 DoRunAllChecksPass(&sync_checker); |
281 | 374 |
282 ExtensionInstallCheckerAsync async_checker(ExtensionInstallChecker::CHECK_ALL, | 375 ExtensionInstallCheckerAsync async_checker; |
283 /*fail_fast=*/false); | |
284 DoRunAllChecksPass(&async_checker); | 376 DoRunAllChecksPass(&async_checker); |
285 } | 377 } |
286 | 378 |
287 // Test the case where all tests fail. | 379 // Test the case where all tests fail. |
288 TEST_F(ExtensionInstallCheckerTest, AllFailed) { | 380 TEST_F(ExtensionInstallCheckerTest, AllFailed) { |
289 ExtensionInstallCheckerForTest sync_checker( | 381 ExtensionInstallCheckerForTest sync_checker; |
290 ExtensionInstallChecker::CHECK_ALL, /*fail_fast=*/false); | |
291 DoRunAllChecksFail(&sync_checker); | 382 DoRunAllChecksFail(&sync_checker); |
292 | 383 |
293 ExtensionInstallCheckerAsync async_checker(ExtensionInstallChecker::CHECK_ALL, | 384 ExtensionInstallCheckerAsync async_checker; |
294 /*fail_fast=*/false); | |
295 DoRunAllChecksFail(&async_checker); | 385 DoRunAllChecksFail(&async_checker); |
296 } | 386 } |
297 | 387 |
298 // Test running only a subset of tests. | 388 // Test running only a subset of tests. |
299 TEST_F(ExtensionInstallCheckerTest, RunSubsetOfChecks) { | 389 TEST_F(ExtensionInstallCheckerTest, RunSubsetOfChecks) { |
300 DoRunSubsetOfChecks(ExtensionInstallChecker::CHECK_MANAGEMENT_POLICY | | 390 ExtensionInstallCheckerForTest sync_checker; |
301 ExtensionInstallChecker::CHECK_REQUIREMENTS); | 391 ExtensionInstallCheckerAsync async_checker; |
302 DoRunSubsetOfChecks(ExtensionInstallChecker::CHECK_BLACKLIST | | 392 DoRunSubsetOfChecks(&sync_checker); |
303 ExtensionInstallChecker::CHECK_REQUIREMENTS); | 393 DoRunSubsetOfChecks(&async_checker); |
304 DoRunSubsetOfChecks(ExtensionInstallChecker::CHECK_BLACKLIST); | |
305 } | 394 } |
306 | 395 |
307 // Test fail fast with synchronous callbacks. | 396 // Test fail fast with synchronous callbacks. |
308 TEST_F(ExtensionInstallCheckerTest, FailFastSync) { | 397 TEST_F(ExtensionInstallCheckerTest, FailFastSync) { |
309 // This test assumes some internal knowledge of the implementation - that | 398 // This test assumes some internal knowledge of the implementation - that |
310 // the policy check runs first. | 399 // the policy check runs first. |
311 { | 400 ExtensionInstallCheckerForTest checker; |
312 ExtensionInstallCheckerForTest checker(ExtensionInstallChecker::CHECK_ALL, | 401 SetAllErrors(&checker); |
313 /*fail_fast=*/true); | 402 RunChecker(&checker, |
314 SetAllErrors(&checker); | 403 true /* fail fast */, |
315 RunChecker(&checker, ExtensionInstallChecker::CHECK_MANAGEMENT_POLICY, | 404 ExtensionInstallChecker::CHECK_ALL, |
316 ExtensionInstallChecker::CHECK_MANAGEMENT_POLICY); | 405 ExtensionInstallChecker::CHECK_MANAGEMENT_POLICY, |
| 406 ExtensionInstallChecker::CHECK_MANAGEMENT_POLICY); |
317 | 407 |
318 ExpectRequirementsPass(checker); | 408 ExpectRequirementsPass(checker); |
319 ExpectPolicyError(checker); | 409 ExpectPolicyError(checker); |
320 ExpectBlacklistPass(checker); | 410 ExpectBlacklistPass(checker); |
321 } | |
322 | 411 |
323 { | 412 // This test assumes some internal knowledge of the implementation - that |
324 ExtensionInstallCheckerForTest checker( | 413 // the requirements check runs before the blacklist check. |
325 ExtensionInstallChecker::CHECK_REQUIREMENTS | | 414 SetAllErrors(&checker); |
326 ExtensionInstallChecker::CHECK_BLACKLIST, | 415 RunChecker(&checker, |
327 /*fail_fast=*/true); | 416 true /* fail fast */, |
328 SetAllErrors(&checker); | 417 ExtensionInstallChecker::CHECK_REQUIREMENTS | |
329 RunChecker(&checker, ExtensionInstallChecker::CHECK_REQUIREMENTS, | 418 ExtensionInstallChecker::CHECK_BLACKLIST, |
330 ExtensionInstallChecker::CHECK_REQUIREMENTS); | 419 ExtensionInstallChecker::CHECK_REQUIREMENTS, |
| 420 ExtensionInstallChecker::CHECK_REQUIREMENTS); |
331 | 421 |
332 ExpectRequirementsError(checker); | 422 ExpectRequirementsError(checker); |
333 ExpectPolicyPass(checker); | 423 ExpectPolicyPass(checker); |
334 ExpectBlacklistPass(checker); | 424 ExpectBlacklistPass(checker); |
335 } | |
336 } | 425 } |
337 | 426 |
338 // Test fail fast with asynchronous callbacks. | 427 // Test fail fast with asynchronous callbacks. |
339 TEST_F(ExtensionInstallCheckerTest, FailFastAsync) { | 428 TEST_F(ExtensionInstallCheckerTest, FailFastAsync) { |
340 // This test assumes some internal knowledge of the implementation - that | 429 // This test assumes some internal knowledge of the implementation - that |
341 // the requirements check runs before the blacklist check. Both checks should | 430 // the requirements check runs before the blacklist check. Both checks should |
342 // be called, but the requirements check callback arrives first and the | 431 // be called, but the requirements check callback arrives first and the |
343 // blacklist result will be discarded. | 432 // blacklist result will be discarded. |
344 ExtensionInstallCheckerAsync checker(ExtensionInstallChecker::CHECK_ALL, | 433 ExtensionInstallCheckerAsync checker; |
345 /*fail_fast=*/true); | |
346 | |
347 SetAllErrors(&checker); | 434 SetAllErrors(&checker); |
348 | 435 |
349 // The policy check is synchronous and needs to pass for the other tests to | 436 // The policy check is synchronous and needs to pass for the other tests to |
350 // run. | 437 // run. |
351 checker.set_policy_check_error(std::string()); | 438 checker.set_policy_check_error(std::string()); |
352 | 439 |
353 RunChecker(&checker, | 440 RunChecker(&checker, |
| 441 true /* fail fast */, |
| 442 ExtensionInstallChecker::CHECK_ALL, |
354 ExtensionInstallChecker::CHECK_ALL, | 443 ExtensionInstallChecker::CHECK_ALL, |
355 ExtensionInstallChecker::CHECK_REQUIREMENTS); | 444 ExtensionInstallChecker::CHECK_REQUIREMENTS); |
356 | 445 |
357 ExpectRequirementsError(checker); | 446 ExpectRequirementsError(checker); |
358 ExpectPolicyPass(checker); | 447 ExpectPolicyPass(checker); |
359 ExpectBlacklistPass(checker); | 448 ExpectBlacklistPass(checker); |
360 } | 449 } |
361 | 450 |
| 451 // Test multiple invocations of the install checker. Wait for all checks to |
| 452 // complete. |
| 453 TEST_F(ExtensionInstallCheckerMultipleInvocationTest, CompleteAll) { |
| 454 ExtensionInstallCheckerAsync checker; |
| 455 SetAllErrors(&checker); |
| 456 |
| 457 // Start the second check as soon as the callback of the first run is invoked. |
| 458 checker.Start( |
| 459 ExtensionInstallChecker::CHECK_ALL, |
| 460 false /* fail fast */, |
| 461 base::Bind( |
| 462 &ExtensionInstallCheckerMultipleInvocationTest::RunSecondInvocation, |
| 463 base::Unretained(this), |
| 464 &checker)); |
| 465 base::RunLoop().RunUntilIdle(); |
| 466 } |
| 467 |
| 468 // Test multiple invocations of the install checker and fail fast. |
| 469 TEST_F(ExtensionInstallCheckerMultipleInvocationTest, FailFast) { |
| 470 ExtensionInstallCheckerAsync checker; |
| 471 SetAllErrors(&checker); |
| 472 |
| 473 // The policy check is synchronous and needs to pass for the other tests to |
| 474 // run. |
| 475 checker.set_policy_check_error(std::string()); |
| 476 |
| 477 // Start the second check as soon as the callback of the first run is invoked. |
| 478 checker.Start( |
| 479 ExtensionInstallChecker::CHECK_ALL, |
| 480 true /* fail fast */, |
| 481 base::Bind( |
| 482 &ExtensionInstallCheckerMultipleInvocationTest::RunSecondInvocation, |
| 483 base::Unretained(this), |
| 484 &checker)); |
| 485 base::RunLoop().RunUntilIdle(); |
| 486 } |
| 487 |
362 } // namespace extensions | 488 } // namespace extensions |
OLD | NEW |