Moved //components/proximity_auth/cryptauth to //components/cryptauth.

components/cryptauth/cryptauth_enrollment_manager_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "components/proximity_auth/cryptauth/cryptauth_enrollment_manager.h"
+#include "components/cryptauth/cryptauth_enrollment_manager.h"
 
 #include <utility>
 
 #include "base/base64url.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/test/simple_test_clock.h"
 #include "base/time/clock.h"
 #include "base/time/time.h"
+#include "components/cryptauth/cryptauth_enroller.h"
+#include "components/cryptauth/fake_cryptauth_gcm_manager.h"
+#include "components/cryptauth/fake_secure_message_delegate.h"
+#include "components/cryptauth/mock_sync_scheduler.h"
+#include "components/cryptauth/pref_names.h"
 #include "components/prefs/testing_pref_service.h"
-#include "components/proximity_auth/cryptauth/cryptauth_enroller.h"
-#include "components/proximity_auth/cryptauth/fake_cryptauth_gcm_manager.h"
-#include "components/proximity_auth/cryptauth/fake_secure_message_delegate.h"
-#include "components/proximity_auth/cryptauth/mock_sync_scheduler.h"
-#include "components/proximity_auth/cryptauth/pref_names.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::NiceMock;
 using ::testing::Return;
 using ::testing::SaveArg;
 
-namespace proximity_auth {
+namespace cryptauth {
 
 namespace {
 
 // The GCM registration id from a successful registration.
 const char kGCMRegistrationId[] = "new gcm registration id";
 
 // The user's persistent public key identifying the local device.
 const char kUserPublicKey[] = "user public key";
 
 // The initial "Now" time for testing.
@@ skipping 93 matching lines @@
   // the super class.
   // This should be safe because the life-time this SyncScheduler will always be
   // within the life of the TestCryptAuthEnrollmentManager object.
   base::WeakPtrFactory<MockSyncScheduler> weak_sync_scheduler_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TestCryptAuthEnrollmentManager);
 };
 
 }  // namespace
 
-class ProximityAuthCryptAuthEnrollmentManagerTest
+class CryptAuthEnrollmentManagerTest
     : public testing::Test,
       public CryptAuthEnrollmentManager::Observer {
  protected:
-  ProximityAuthCryptAuthEnrollmentManagerTest()
+  CryptAuthEnrollmentManagerTest()
       : public_key_(kUserPublicKey),
         clock_(new base::SimpleTestClock()),
         enroller_factory_(new MockCryptAuthEnrollerFactory()),
         secure_message_delegate_(new FakeSecureMessageDelegate()),
         gcm_manager_(kGCMRegistrationId),
         enrollment_manager_(base::WrapUnique(clock_),
                             base::WrapUnique(enroller_factory_),
                             base::WrapUnique(secure_message_delegate_),
                             device_info_,
                             &gcm_manager_,
@@ skipping 95 matching lines @@
   FakeSecureMessageDelegate* secure_message_delegate_;
 
   cryptauth::GcmDeviceInfo device_info_;
 
   TestingPrefServiceSimple pref_service_;
 
   FakeCryptAuthGCMManager gcm_manager_;
 
   TestCryptAuthEnrollmentManager enrollment_manager_;
 
-  DISALLOW_COPY_AND_ASSIGN(ProximityAuthCryptAuthEnrollmentManagerTest);
+  DISALLOW_COPY_AND_ASSIGN(CryptAuthEnrollmentManagerTest);
 };
 
-TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, RegisterPrefs) {
+TEST_F(CryptAuthEnrollmentManagerTest, RegisterPrefs) {
   TestingPrefServiceSimple pref_service;
   CryptAuthEnrollmentManager::RegisterPrefs(pref_service.registry());
   EXPECT_TRUE(pref_service.FindPreference(
       prefs::kCryptAuthEnrollmentLastEnrollmentTimeSeconds));
   EXPECT_TRUE(pref_service.FindPreference(
       prefs::kCryptAuthEnrollmentIsRecoveringFromFailure));
   EXPECT_TRUE(pref_service.FindPreference(prefs::kCryptAuthEnrollmentReason));
 }
 
-TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, GetEnrollmentState) {
+TEST_F(CryptAuthEnrollmentManagerTest, GetEnrollmentState) {
   enrollment_manager_.Start();
 
   ON_CALL(*sync_scheduler(), GetStrategy())
       .WillByDefault(Return(SyncScheduler::Strategy::PERIODIC_REFRESH));
   EXPECT_FALSE(enrollment_manager_.IsRecoveringFromFailure());
 
   ON_CALL(*sync_scheduler(), GetStrategy())
       .WillByDefault(Return(SyncScheduler::Strategy::AGGRESSIVE_RECOVERY));
   EXPECT_TRUE(enrollment_manager_.IsRecoveringFromFailure());
 
   base::TimeDelta time_to_next_sync = base::TimeDelta::FromMinutes(60);
   ON_CALL(*sync_scheduler(), GetTimeToNextSync())
       .WillByDefault(Return(time_to_next_sync));
   EXPECT_EQ(time_to_next_sync, enrollment_manager_.GetTimeToNextAttempt());
 
   ON_CALL(*sync_scheduler(), GetSyncState())
       .WillByDefault(Return(SyncScheduler::SyncState::SYNC_IN_PROGRESS));
   EXPECT_TRUE(enrollment_manager_.IsEnrollmentInProgress());
 
   ON_CALL(*sync_scheduler(), GetSyncState())
       .WillByDefault(Return(SyncScheduler::SyncState::WAITING_FOR_REFRESH));
   EXPECT_FALSE(enrollment_manager_.IsEnrollmentInProgress());
 }
 
-TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, InitWithDefaultPrefs) {
+TEST_F(CryptAuthEnrollmentManagerTest, InitWithDefaultPrefs) {
   std::unique_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock());
   clock->SetNow(base::Time::FromDoubleT(kInitialTimeNowSeconds));
   base::TimeDelta elapsed_time = clock->Now() - base::Time::FromDoubleT(0);
 
   TestingPrefServiceSimple pref_service;
   CryptAuthEnrollmentManager::RegisterPrefs(pref_service.registry());
 
   TestCryptAuthEnrollmentManager enrollment_manager(
       std::move(clock), base::MakeUnique<MockCryptAuthEnrollerFactory>(),
       base::MakeUnique<FakeSecureMessageDelegate>(), device_info_,
       &gcm_manager_, &pref_service);
 
   EXPECT_CALL(
       *enrollment_manager.GetSyncScheduler(),
       Start(elapsed_time, SyncScheduler::Strategy::AGGRESSIVE_RECOVERY));
   enrollment_manager.Start();
 
   EXPECT_FALSE(enrollment_manager.IsEnrollmentValid());
   EXPECT_TRUE(enrollment_manager.GetLastEnrollmentTime().is_null());
 }
 
-TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, InitWithExistingPrefs) {
+TEST_F(CryptAuthEnrollmentManagerTest, InitWithExistingPrefs) {
   EXPECT_CALL(
       *sync_scheduler(),
       Start(clock_->Now() - base::Time::FromDoubleT(kLastEnrollmentTimeSeconds),
             SyncScheduler::Strategy::PERIODIC_REFRESH));
 
   enrollment_manager_.Start();
   EXPECT_TRUE(enrollment_manager_.IsEnrollmentValid());
   EXPECT_EQ(base::Time::FromDoubleT(kLastEnrollmentTimeSeconds),
             enrollment_manager_.GetLastEnrollmentTime());
 }
 
-TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, InitWithExpiredEnrollment) {
+TEST_F(CryptAuthEnrollmentManagerTest, InitWithExpiredEnrollment) {
   pref_service_.SetUserPref(
       prefs::kCryptAuthEnrollmentLastEnrollmentTimeSeconds,
       new base::FundamentalValue(kLastExpiredEnrollmentTimeSeconds));
 
   EXPECT_CALL(*sync_scheduler(),
               Start(clock_->Now() - base::Time::FromDoubleT(
                                         kLastExpiredEnrollmentTimeSeconds),
                     SyncScheduler::Strategy::AGGRESSIVE_RECOVERY));
 
   enrollment_manager_.Start();
   EXPECT_FALSE(enrollment_manager_.IsEnrollmentValid());
   EXPECT_EQ(base::Time::FromDoubleT(kLastExpiredEnrollmentTimeSeconds),
             enrollment_manager_.GetLastEnrollmentTime());
 }
 
-TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, ForceEnrollment) {
+TEST_F(CryptAuthEnrollmentManagerTest, ForceEnrollment) {
   enrollment_manager_.Start();
 
   EXPECT_CALL(*sync_scheduler(), ForceSync());
   enrollment_manager_.ForceEnrollmentNow(
       cryptauth::INVOCATION_REASON_SERVER_INITIATED);
 
   auto completion_callback =
       FireSchedulerForEnrollment(cryptauth::INVOCATION_REASON_SERVER_INITIATED);
 
   clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNow));
   EXPECT_CALL(*this, OnEnrollmentFinishedProxy(true));
   completion_callback.Run(true);
   EXPECT_EQ(clock_->Now(), enrollment_manager_.GetLastEnrollmentTime());
 }
 
-TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest,
+TEST_F(CryptAuthEnrollmentManagerTest,
        EnrollmentFailsThenSucceeds) {
   enrollment_manager_.Start();
   base::Time old_enrollment_time = enrollment_manager_.GetLastEnrollmentTime();
 
   // The first periodic enrollment fails.
   ON_CALL(*sync_scheduler(), GetStrategy())
       .WillByDefault(Return(SyncScheduler::Strategy::PERIODIC_REFRESH));
   auto completion_callback =
       FireSchedulerForEnrollment(cryptauth::INVOCATION_REASON_PERIODIC);
   clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNow));
   EXPECT_CALL(*this, OnEnrollmentFinishedProxy(false));
   completion_callback.Run(false);
   EXPECT_EQ(old_enrollment_time, enrollment_manager_.GetLastEnrollmentTime());
   EXPECT_TRUE(pref_service_.GetBoolean(
       prefs::kCryptAuthEnrollmentIsRecoveringFromFailure));
 
   // The second recovery enrollment succeeds.
   ON_CALL(*sync_scheduler(), GetStrategy())
       .WillByDefault(Return(SyncScheduler::Strategy::AGGRESSIVE_RECOVERY));
   completion_callback =
       FireSchedulerForEnrollment(cryptauth::INVOCATION_REASON_FAILURE_RECOVERY);
   clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNow + 30));
   EXPECT_CALL(*this, OnEnrollmentFinishedProxy(true));
   completion_callback.Run(true);
   EXPECT_EQ(clock_->Now(), enrollment_manager_.GetLastEnrollmentTime());
   EXPECT_FALSE(pref_service_.GetBoolean(
       prefs::kCryptAuthEnrollmentIsRecoveringFromFailure));
 }
 
-TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest,
+TEST_F(CryptAuthEnrollmentManagerTest,
        EnrollmentSucceedsForFirstTime) {
   // Initialize |enrollment_manager_|.
   ON_CALL(*sync_scheduler(), GetStrategy())
       .WillByDefault(Return(SyncScheduler::Strategy::PERIODIC_REFRESH));
   gcm_manager_.set_registration_id(std::string());
   pref_service_.ClearPref(prefs::kCryptAuthEnrollmentUserPublicKey);
   pref_service_.ClearPref(prefs::kCryptAuthEnrollmentUserPrivateKey);
   pref_service_.ClearPref(prefs::kCryptAuthEnrollmentLastEnrollmentTimeSeconds);
   enrollment_manager_.Start();
   EXPECT_FALSE(enrollment_manager_.IsEnrollmentValid());
@@ skipping 20 matching lines @@
   EXPECT_CALL(*this, OnEnrollmentFinishedProxy(true));
   enrollment_callback.Run(true);
   EXPECT_EQ(clock_->Now(), enrollment_manager_.GetLastEnrollmentTime());
   EXPECT_TRUE(enrollment_manager_.IsEnrollmentValid());
 
   // Check that CryptAuthEnrollmentManager returns the expected key-pair.
   EXPECT_EQ(public_key_, enrollment_manager_.GetUserPublicKey());
   EXPECT_EQ(private_key_, enrollment_manager_.GetUserPrivateKey());
 }
 
-TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, GCMRegistrationFails) {
+TEST_F(CryptAuthEnrollmentManagerTest, GCMRegistrationFails) {
   // Initialize |enrollment_manager_|.
   ON_CALL(*sync_scheduler(), GetStrategy())
       .WillByDefault(Return(SyncScheduler::Strategy::PERIODIC_REFRESH));
   gcm_manager_.set_registration_id(std::string());
   enrollment_manager_.Start();
 
   // Trigger a sync request.
   EXPECT_CALL(*this, OnEnrollmentStartedProxy());
   auto sync_request = base::MakeUnique<SyncScheduler::SyncRequest>(
       enrollment_manager_.GetSyncScheduler());
   static_cast<SyncScheduler::Delegate*>(&enrollment_manager_)
       ->OnSyncRequested(std::move(sync_request));
 
   // Complete GCM registration with failure.
   EXPECT_CALL(*this, OnEnrollmentFinishedProxy(false));
   gcm_manager_.CompleteRegistration(std::string());
 }
 
-TEST_F(ProximityAuthCryptAuthEnrollmentManagerTest, ReenrollOnGCMPushMessage) {
+TEST_F(CryptAuthEnrollmentManagerTest, ReenrollOnGCMPushMessage) {
   enrollment_manager_.Start();
 
   // Simulate receiving a GCM push message, forcing the device to re-enroll.
   gcm_manager_.PushReenrollMessage();
   auto completion_callback =
       FireSchedulerForEnrollment(cryptauth::INVOCATION_REASON_SERVER_INITIATED);
 
   EXPECT_CALL(*this, OnEnrollmentFinishedProxy(true));
   completion_callback.Run(true);
 }
 
-}  // namespace proximity_auth
+}  // namespace cryptauth