OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 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 "components/proximity_auth/cryptauth/cryptauth_enrollment_manager.h" | 5 #include "components/proximity_auth/cryptauth/cryptauth_enrollment_manager.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/base64url.h" | 9 #include "base/base64url.h" |
10 #include "base/macros.h" | 10 #include "base/macros.h" |
(...skipping 203 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
214 | 214 |
215 // Simulates firing the SyncScheduler to trigger an enrollment attempt. | 215 // Simulates firing the SyncScheduler to trigger an enrollment attempt. |
216 CryptAuthEnroller::EnrollmentFinishedCallback FireSchedulerForEnrollment( | 216 CryptAuthEnroller::EnrollmentFinishedCallback FireSchedulerForEnrollment( |
217 cryptauth::InvocationReason expected_invocation_reason) { | 217 cryptauth::InvocationReason expected_invocation_reason) { |
218 CryptAuthEnroller::EnrollmentFinishedCallback completion_callback; | 218 CryptAuthEnroller::EnrollmentFinishedCallback completion_callback; |
219 EXPECT_CALL( | 219 EXPECT_CALL( |
220 *next_cryptauth_enroller(), | 220 *next_cryptauth_enroller(), |
221 Enroll(public_key_, private_key_, _, expected_invocation_reason, _)) | 221 Enroll(public_key_, private_key_, _, expected_invocation_reason, _)) |
222 .WillOnce(SaveArg<4>(&completion_callback)); | 222 .WillOnce(SaveArg<4>(&completion_callback)); |
223 | 223 |
224 auto sync_request = base::WrapUnique( | 224 auto sync_request = base::MakeUnique<SyncScheduler::SyncRequest>( |
225 new SyncScheduler::SyncRequest(enrollment_manager_.GetSyncScheduler())); | 225 enrollment_manager_.GetSyncScheduler()); |
226 EXPECT_CALL(*this, OnEnrollmentStartedProxy()); | 226 EXPECT_CALL(*this, OnEnrollmentStartedProxy()); |
227 | 227 |
228 SyncScheduler::Delegate* delegate = | 228 SyncScheduler::Delegate* delegate = |
229 static_cast<SyncScheduler::Delegate*>(&enrollment_manager_); | 229 static_cast<SyncScheduler::Delegate*>(&enrollment_manager_); |
230 delegate->OnSyncRequested(std::move(sync_request)); | 230 delegate->OnSyncRequested(std::move(sync_request)); |
231 | 231 |
232 return completion_callback; | 232 return completion_callback; |
233 } | 233 } |
234 | 234 |
235 MockSyncScheduler* sync_scheduler() { | 235 MockSyncScheduler* sync_scheduler() { |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
301 | 301 |
302 TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, InitWithDefaultPrefs) { | 302 TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, InitWithDefaultPrefs) { |
303 std::unique_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock()); | 303 std::unique_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock()); |
304 clock->SetNow(base::Time::FromDoubleT(kInitialTimeNowSeconds)); | 304 clock->SetNow(base::Time::FromDoubleT(kInitialTimeNowSeconds)); |
305 base::TimeDelta elapsed_time = clock->Now() - base::Time::FromDoubleT(0); | 305 base::TimeDelta elapsed_time = clock->Now() - base::Time::FromDoubleT(0); |
306 | 306 |
307 TestingPrefServiceSimple pref_service; | 307 TestingPrefServiceSimple pref_service; |
308 CryptAuthEnrollmentManager::RegisterPrefs(pref_service.registry()); | 308 CryptAuthEnrollmentManager::RegisterPrefs(pref_service.registry()); |
309 | 309 |
310 TestCryptAuthEnrollmentManager enrollment_manager( | 310 TestCryptAuthEnrollmentManager enrollment_manager( |
311 std::move(clock), base::WrapUnique(new MockCryptAuthEnrollerFactory()), | 311 std::move(clock), base::MakeUnique<MockCryptAuthEnrollerFactory>(), |
312 base::WrapUnique(new FakeSecureMessageDelegate()), device_info_, | 312 base::MakeUnique<FakeSecureMessageDelegate>(), device_info_, |
313 &gcm_manager_, &pref_service); | 313 &gcm_manager_, &pref_service); |
314 | 314 |
315 EXPECT_CALL( | 315 EXPECT_CALL( |
316 *enrollment_manager.GetSyncScheduler(), | 316 *enrollment_manager.GetSyncScheduler(), |
317 Start(elapsed_time, SyncScheduler::Strategy::AGGRESSIVE_RECOVERY)); | 317 Start(elapsed_time, SyncScheduler::Strategy::AGGRESSIVE_RECOVERY)); |
318 enrollment_manager.Start(); | 318 enrollment_manager.Start(); |
319 | 319 |
320 EXPECT_FALSE(enrollment_manager.IsEnrollmentValid()); | 320 EXPECT_FALSE(enrollment_manager.IsEnrollmentValid()); |
321 EXPECT_TRUE(enrollment_manager.GetLastEnrollmentTime().is_null()); | 321 EXPECT_TRUE(enrollment_manager.GetLastEnrollmentTime().is_null()); |
322 } | 322 } |
(...skipping 79 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
402 .WillByDefault(Return(SyncScheduler::Strategy::PERIODIC_REFRESH)); | 402 .WillByDefault(Return(SyncScheduler::Strategy::PERIODIC_REFRESH)); |
403 gcm_manager_.set_registration_id(std::string()); | 403 gcm_manager_.set_registration_id(std::string()); |
404 pref_service_.ClearPref(prefs::kCryptAuthEnrollmentUserPublicKey); | 404 pref_service_.ClearPref(prefs::kCryptAuthEnrollmentUserPublicKey); |
405 pref_service_.ClearPref(prefs::kCryptAuthEnrollmentUserPrivateKey); | 405 pref_service_.ClearPref(prefs::kCryptAuthEnrollmentUserPrivateKey); |
406 pref_service_.ClearPref(prefs::kCryptAuthEnrollmentLastEnrollmentTimeSeconds); | 406 pref_service_.ClearPref(prefs::kCryptAuthEnrollmentLastEnrollmentTimeSeconds); |
407 enrollment_manager_.Start(); | 407 enrollment_manager_.Start(); |
408 EXPECT_FALSE(enrollment_manager_.IsEnrollmentValid()); | 408 EXPECT_FALSE(enrollment_manager_.IsEnrollmentValid()); |
409 | 409 |
410 // Trigger a sync request. | 410 // Trigger a sync request. |
411 EXPECT_CALL(*this, OnEnrollmentStartedProxy()); | 411 EXPECT_CALL(*this, OnEnrollmentStartedProxy()); |
412 auto sync_request = base::WrapUnique( | 412 auto sync_request = base::MakeUnique<SyncScheduler::SyncRequest>( |
413 new SyncScheduler::SyncRequest(enrollment_manager_.GetSyncScheduler())); | 413 enrollment_manager_.GetSyncScheduler()); |
414 static_cast<SyncScheduler::Delegate*>(&enrollment_manager_) | 414 static_cast<SyncScheduler::Delegate*>(&enrollment_manager_) |
415 ->OnSyncRequested(std::move(sync_request)); | 415 ->OnSyncRequested(std::move(sync_request)); |
416 | 416 |
417 // Complete GCM registration successfully, and expect an enrollment. | 417 // Complete GCM registration successfully, and expect an enrollment. |
418 CryptAuthEnroller::EnrollmentFinishedCallback enrollment_callback; | 418 CryptAuthEnroller::EnrollmentFinishedCallback enrollment_callback; |
419 EXPECT_CALL(*next_cryptauth_enroller(), | 419 EXPECT_CALL(*next_cryptauth_enroller(), |
420 Enroll(public_key_, private_key_, _, | 420 Enroll(public_key_, private_key_, _, |
421 cryptauth::INVOCATION_REASON_INITIALIZATION, _)) | 421 cryptauth::INVOCATION_REASON_INITIALIZATION, _)) |
422 .WillOnce(SaveArg<4>(&enrollment_callback)); | 422 .WillOnce(SaveArg<4>(&enrollment_callback)); |
423 ASSERT_TRUE(gcm_manager_.registration_in_progress()); | 423 ASSERT_TRUE(gcm_manager_.registration_in_progress()); |
(...skipping 14 matching lines...) Expand all Loading... |
438 | 438 |
439 TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, GCMRegistrationFails) { | 439 TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, GCMRegistrationFails) { |
440 // Initialize |enrollment_manager_|. | 440 // Initialize |enrollment_manager_|. |
441 ON_CALL(*sync_scheduler(), GetStrategy()) | 441 ON_CALL(*sync_scheduler(), GetStrategy()) |
442 .WillByDefault(Return(SyncScheduler::Strategy::PERIODIC_REFRESH)); | 442 .WillByDefault(Return(SyncScheduler::Strategy::PERIODIC_REFRESH)); |
443 gcm_manager_.set_registration_id(std::string()); | 443 gcm_manager_.set_registration_id(std::string()); |
444 enrollment_manager_.Start(); | 444 enrollment_manager_.Start(); |
445 | 445 |
446 // Trigger a sync request. | 446 // Trigger a sync request. |
447 EXPECT_CALL(*this, OnEnrollmentStartedProxy()); | 447 EXPECT_CALL(*this, OnEnrollmentStartedProxy()); |
448 auto sync_request = base::WrapUnique( | 448 auto sync_request = base::MakeUnique<SyncScheduler::SyncRequest>( |
449 new SyncScheduler::SyncRequest(enrollment_manager_.GetSyncScheduler())); | 449 enrollment_manager_.GetSyncScheduler()); |
450 static_cast<SyncScheduler::Delegate*>(&enrollment_manager_) | 450 static_cast<SyncScheduler::Delegate*>(&enrollment_manager_) |
451 ->OnSyncRequested(std::move(sync_request)); | 451 ->OnSyncRequested(std::move(sync_request)); |
452 | 452 |
453 // Complete GCM registration with failure. | 453 // Complete GCM registration with failure. |
454 EXPECT_CALL(*this, OnEnrollmentFinishedProxy(false)); | 454 EXPECT_CALL(*this, OnEnrollmentFinishedProxy(false)); |
455 gcm_manager_.CompleteRegistration(std::string()); | 455 gcm_manager_.CompleteRegistration(std::string()); |
456 } | 456 } |
457 | 457 |
458 TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, ReenrollOnGCMPushMessage) { | 458 TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, ReenrollOnGCMPushMessage) { |
459 enrollment_manager_.Start(); | 459 enrollment_manager_.Start(); |
460 | 460 |
461 // Simulate receiving a GCM push message, forcing the device to re-enroll. | 461 // Simulate receiving a GCM push message, forcing the device to re-enroll. |
462 gcm_manager_.PushReenrollMessage(); | 462 gcm_manager_.PushReenrollMessage(); |
463 auto completion_callback = | 463 auto completion_callback = |
464 FireSchedulerForEnrollment(cryptauth::INVOCATION_REASON_SERVER_INITIATED); | 464 FireSchedulerForEnrollment(cryptauth::INVOCATION_REASON_SERVER_INITIATED); |
465 | 465 |
466 EXPECT_CALL(*this, OnEnrollmentFinishedProxy(true)); | 466 EXPECT_CALL(*this, OnEnrollmentFinishedProxy(true)); |
467 completion_callback.Run(true); | 467 completion_callback.Run(true); |
468 } | 468 } |
469 | 469 |
470 } // namespace proximity_auth | 470 } // namespace proximity_auth |
OLD | NEW |