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

components/cryptauth/cryptauth_device_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_device_manager.h"
+#include "components/cryptauth/cryptauth_device_manager.h"
 
 #include <stddef.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/strings/stringprintf.h"
 #include "base/test/simple_test_clock.h"
+#include "components/cryptauth/fake_cryptauth_gcm_manager.h"
+#include "components/cryptauth/mock_cryptauth_client.h"
+#include "components/cryptauth/mock_sync_scheduler.h"
+#include "components/cryptauth/pref_names.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/prefs/testing_pref_service.h"
-#include "components/proximity_auth/cryptauth/fake_cryptauth_gcm_manager.h"
-#include "components/proximity_auth/cryptauth/mock_cryptauth_client.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::DoAll;
 using ::testing::NiceMock;
 using ::testing::Return;
 using ::testing::SaveArg;
 
-namespace proximity_auth {
+namespace cryptauth {
 namespace {
 
 // The initial "Now" time for testing.
 const double kInitialTimeNowSeconds = 20000000;
 
 // A later "Now" time for testing.
 const double kLaterTimeNowSeconds = kInitialTimeNowSeconds + 30;
 
 // The timestamp of a last successful sync in seconds.
 const double kLastSyncTimeSeconds = kInitialTimeNowSeconds - (60 * 60 * 5);
@@ skipping 104 matching lines @@
   // the super class.
   // This should be safe because the life-time this SyncScheduler will always be
   // within the life of the TestCryptAuthDeviceManager object.
   base::WeakPtrFactory<MockSyncScheduler> weak_sync_scheduler_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TestCryptAuthDeviceManager);
 };
 
 }  // namespace
 
-class ProximityAuthCryptAuthDeviceManagerTest
+class CryptAuthDeviceManagerTest
     : public testing::Test,
       public CryptAuthDeviceManager::Observer,
       public MockCryptAuthClientFactory::Observer {
  protected:
-  ProximityAuthCryptAuthDeviceManagerTest()
+  CryptAuthDeviceManagerTest()
       : clock_(new base::SimpleTestClock()),
         client_factory_(new MockCryptAuthClientFactory(
             MockCryptAuthClientFactory::MockType::MAKE_STRICT_MOCKS)),
         gcm_manager_("existing gcm registration id") {
     client_factory_->AddObserver(this);
   }
 
-  ~ProximityAuthCryptAuthDeviceManagerTest() {
+  ~CryptAuthDeviceManagerTest() {
     client_factory_->RemoveObserver(this);
   }
 
   // testing::Test:
   void SetUp() override {
     clock_->SetNow(base::Time::FromDoubleT(kInitialTimeNowSeconds));
 
     CryptAuthDeviceManager::RegisterPrefs(pref_service_.registry());
     pref_service_.SetUserPref(
         prefs::kCryptAuthDeviceSyncIsRecoveringFromFailure,
@@ skipping 116 matching lines @@
   std::unique_ptr<TestCryptAuthDeviceManager> device_manager_;
 
   cryptauth::GetMyDevicesResponse get_my_devices_response_;
 
   cryptauth::GetMyDevicesRequest get_my_devices_request_;
 
   CryptAuthClient::GetMyDevicesCallback success_callback_;
 
   CryptAuthClient::ErrorCallback error_callback_;
 
-  DISALLOW_COPY_AND_ASSIGN(ProximityAuthCryptAuthDeviceManagerTest);
+  DISALLOW_COPY_AND_ASSIGN(CryptAuthDeviceManagerTest);
 };
 
-TEST_F(ProximityAuthCryptAuthDeviceManagerTest, RegisterPrefs) {
+TEST_F(CryptAuthDeviceManagerTest, RegisterPrefs) {
   TestingPrefServiceSimple pref_service;
   CryptAuthDeviceManager::RegisterPrefs(pref_service.registry());
   EXPECT_TRUE(pref_service.FindPreference(
       prefs::kCryptAuthDeviceSyncLastSyncTimeSeconds));
   EXPECT_TRUE(pref_service.FindPreference(
       prefs::kCryptAuthDeviceSyncIsRecoveringFromFailure));
   EXPECT_TRUE(pref_service.FindPreference(prefs::kCryptAuthDeviceSyncReason));
   EXPECT_TRUE(
       pref_service.FindPreference(prefs::kCryptAuthDeviceSyncUnlockKeys));
 }
 
-TEST_F(ProximityAuthCryptAuthDeviceManagerTest, GetSyncState) {
+TEST_F(CryptAuthDeviceManagerTest, GetSyncState) {
   device_manager_->Start();
 
   ON_CALL(*sync_scheduler(), GetStrategy())
       .WillByDefault(Return(SyncScheduler::Strategy::PERIODIC_REFRESH));
   EXPECT_FALSE(device_manager_->IsRecoveringFromFailure());
 
   ON_CALL(*sync_scheduler(), GetStrategy())
       .WillByDefault(Return(SyncScheduler::Strategy::AGGRESSIVE_RECOVERY));
   EXPECT_TRUE(device_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, device_manager_->GetTimeToNextAttempt());
 
   ON_CALL(*sync_scheduler(), GetSyncState())
       .WillByDefault(Return(SyncScheduler::SyncState::SYNC_IN_PROGRESS));
   EXPECT_TRUE(device_manager_->IsSyncInProgress());
 
   ON_CALL(*sync_scheduler(), GetSyncState())
       .WillByDefault(Return(SyncScheduler::SyncState::WAITING_FOR_REFRESH));
   EXPECT_FALSE(device_manager_->IsSyncInProgress());
 }
 
-TEST_F(ProximityAuthCryptAuthDeviceManagerTest, InitWithDefaultPrefs) {
+TEST_F(CryptAuthDeviceManagerTest, 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;
   CryptAuthDeviceManager::RegisterPrefs(pref_service.registry());
 
   TestCryptAuthDeviceManager device_manager(
       std::move(clock),
       base::MakeUnique<MockCryptAuthClientFactory>(
           MockCryptAuthClientFactory::MockType::MAKE_STRICT_MOCKS),
       &gcm_manager_, &pref_service);
 
   EXPECT_CALL(
       *(device_manager.GetSyncScheduler()),
       Start(elapsed_time, SyncScheduler::Strategy::AGGRESSIVE_RECOVERY));
   device_manager.Start();
   EXPECT_TRUE(device_manager.GetLastSyncTime().is_null());
   EXPECT_EQ(0u, device_manager.unlock_keys().size());
 }
 
-TEST_F(ProximityAuthCryptAuthDeviceManagerTest, InitWithExistingPrefs) {
+TEST_F(CryptAuthDeviceManagerTest, InitWithExistingPrefs) {
   EXPECT_CALL(
       *sync_scheduler(),
       Start(clock_->Now() - base::Time::FromDoubleT(kLastSyncTimeSeconds),
             SyncScheduler::Strategy::PERIODIC_REFRESH));
 
   device_manager_->Start();
   EXPECT_EQ(base::Time::FromDoubleT(kLastSyncTimeSeconds),
             device_manager_->GetLastSyncTime());
 
   auto unlock_keys = device_manager_->unlock_keys();
   ASSERT_EQ(1u, unlock_keys.size());
   EXPECT_EQ(kStoredPublicKey, unlock_keys[0].public_key());
   EXPECT_EQ(kStoredDeviceName, unlock_keys[0].friendly_device_name());
   EXPECT_EQ(kStoredBluetoothAddress, unlock_keys[0].bluetooth_address());
   EXPECT_TRUE(unlock_keys[0].unlock_key());
 }
 
-TEST_F(ProximityAuthCryptAuthDeviceManagerTest, SyncSucceedsForFirstTime) {
+TEST_F(CryptAuthDeviceManagerTest, SyncSucceedsForFirstTime) {
   pref_service_.ClearPref(prefs::kCryptAuthDeviceSyncLastSyncTimeSeconds);
   device_manager_->Start();
 
   FireSchedulerForSync(cryptauth::INVOCATION_REASON_INITIALIZATION);
   ASSERT_FALSE(success_callback_.is_null());
 
   clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNowSeconds));
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
 
   success_callback_.Run(get_my_devices_response_);
   EXPECT_EQ(clock_->Now(), device_manager_->GetLastSyncTime());
 
   ExpectUnlockKeysAndPrefAreEqual(std::vector<cryptauth::ExternalDeviceInfo>(
                                       1, get_my_devices_response_.devices(0)),
                                   device_manager_->unlock_keys(),
                                   pref_service_);
 }
 
-TEST_F(ProximityAuthCryptAuthDeviceManagerTest, ForceSync) {
+TEST_F(CryptAuthDeviceManagerTest, ForceSync) {
   device_manager_->Start();
 
   EXPECT_CALL(*sync_scheduler(), ForceSync());
   device_manager_->ForceSyncNow(cryptauth::INVOCATION_REASON_MANUAL);
 
   FireSchedulerForSync(cryptauth::INVOCATION_REASON_MANUAL);
 
   clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNowSeconds));
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
   success_callback_.Run(get_my_devices_response_);
   EXPECT_EQ(clock_->Now(), device_manager_->GetLastSyncTime());
 
   ExpectUnlockKeysAndPrefAreEqual(std::vector<cryptauth::ExternalDeviceInfo>(
                                       1, get_my_devices_response_.devices(0)),
                                   device_manager_->unlock_keys(),
                                   pref_service_);
 }
 
-TEST_F(ProximityAuthCryptAuthDeviceManagerTest, ForceSyncFailsThenSucceeds) {
+TEST_F(CryptAuthDeviceManagerTest, ForceSyncFailsThenSucceeds) {
   device_manager_->Start();
   EXPECT_FALSE(pref_service_.GetBoolean(
       prefs::kCryptAuthDeviceSyncIsRecoveringFromFailure));
   base::Time old_sync_time = device_manager_->GetLastSyncTime();
 
   // The first force sync fails.
   EXPECT_CALL(*sync_scheduler(), ForceSync());
   device_manager_->ForceSyncNow(cryptauth::INVOCATION_REASON_MANUAL);
   FireSchedulerForSync(cryptauth::INVOCATION_REASON_MANUAL);
   clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNowSeconds));
@@ skipping 26 matching lines @@
 
   EXPECT_FLOAT_EQ(
       clock_->Now().ToDoubleT(),
       pref_service_.GetDouble(prefs::kCryptAuthDeviceSyncLastSyncTimeSeconds));
   EXPECT_EQ(static_cast<int>(cryptauth::INVOCATION_REASON_UNKNOWN),
             pref_service_.GetInteger(prefs::kCryptAuthDeviceSyncReason));
   EXPECT_FALSE(pref_service_.GetBoolean(
       prefs::kCryptAuthDeviceSyncIsRecoveringFromFailure));
 }
 
-TEST_F(ProximityAuthCryptAuthDeviceManagerTest, PeriodicSyncFailsThenSucceeds) {
+TEST_F(CryptAuthDeviceManagerTest, PeriodicSyncFailsThenSucceeds) {
   device_manager_->Start();
   base::Time old_sync_time = device_manager_->GetLastSyncTime();
 
   // The first periodic sync fails.
   FireSchedulerForSync(cryptauth::INVOCATION_REASON_PERIODIC);
   clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNowSeconds));
   EXPECT_CALL(*this,
               OnSyncFinishedProxy(
                   CryptAuthDeviceManager::SyncResult::FAILURE,
                   CryptAuthDeviceManager::DeviceChangeResult::UNCHANGED));
@@ skipping 18 matching lines @@
                                   device_manager_->unlock_keys(),
                                   pref_service_);
 
   EXPECT_FLOAT_EQ(
       clock_->Now().ToDoubleT(),
       pref_service_.GetDouble(prefs::kCryptAuthDeviceSyncLastSyncTimeSeconds));
   EXPECT_FALSE(pref_service_.GetBoolean(
       prefs::kCryptAuthDeviceSyncIsRecoveringFromFailure));
 }
 
-TEST_F(ProximityAuthCryptAuthDeviceManagerTest, SyncSameDevice) {
+TEST_F(CryptAuthDeviceManagerTest, SyncSameDevice) {
   device_manager_->Start();
   auto original_unlock_keys = device_manager_->unlock_keys();
 
   // Sync new devices.
   FireSchedulerForSync(cryptauth::INVOCATION_REASON_PERIODIC);
   ASSERT_FALSE(success_callback_.is_null());
   EXPECT_CALL(*this,
               OnSyncFinishedProxy(
                   CryptAuthDeviceManager::SyncResult::SUCCESS,
                   CryptAuthDeviceManager::DeviceChangeResult::UNCHANGED));
 
   // Sync the same device.
   cryptauth::ExternalDeviceInfo synced_unlock_key;
   synced_unlock_key.set_public_key(kStoredPublicKey);
   synced_unlock_key.set_friendly_device_name(kStoredDeviceName);
   synced_unlock_key.set_bluetooth_address(kStoredBluetoothAddress);
   synced_unlock_key.set_unlock_key(true);
   synced_unlock_key.set_unlockable(false);
   cryptauth::GetMyDevicesResponse get_my_devices_response;
   get_my_devices_response.add_devices()->CopyFrom(synced_unlock_key);
   success_callback_.Run(get_my_devices_response);
 
   // Check that unlock keys are still the same after sync.
   ExpectUnlockKeysAndPrefAreEqual(
       original_unlock_keys, device_manager_->unlock_keys(), pref_service_);
 }
 
-TEST_F(ProximityAuthCryptAuthDeviceManagerTest, SyncEmptyDeviceList) {
+TEST_F(CryptAuthDeviceManagerTest, SyncEmptyDeviceList) {
   cryptauth::GetMyDevicesResponse empty_response;
 
   device_manager_->Start();
   EXPECT_EQ(1u, device_manager_->unlock_keys().size());
 
   FireSchedulerForSync(cryptauth::INVOCATION_REASON_PERIODIC);
   ASSERT_FALSE(success_callback_.is_null());
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
   success_callback_.Run(empty_response);
 
   ExpectUnlockKeysAndPrefAreEqual(std::vector<cryptauth::ExternalDeviceInfo>(),
                                   device_manager_->unlock_keys(),
                                   pref_service_);
 }
 
-TEST_F(ProximityAuthCryptAuthDeviceManagerTest, SyncTwoUnlockKeys) {
+TEST_F(CryptAuthDeviceManagerTest, SyncTwoUnlockKeys) {
   cryptauth::GetMyDevicesResponse response(get_my_devices_response_);
   cryptauth::ExternalDeviceInfo unlock_key2;
   unlock_key2.set_public_key("new public key");
   unlock_key2.set_friendly_device_name("new device name");
   unlock_key2.set_bluetooth_address("aa:bb:cc:dd:ee:ff");
   unlock_key2.set_unlock_key(true);
   response.add_devices()->CopyFrom(unlock_key2);
 
   std::vector<cryptauth::ExternalDeviceInfo> expected_unlock_keys;
   expected_unlock_keys.push_back(get_my_devices_response_.devices(0));
   expected_unlock_keys.push_back(unlock_key2);
 
   device_manager_->Start();
   EXPECT_EQ(1u, device_manager_->unlock_keys().size());
   EXPECT_EQ(1u, pref_service_.GetList(prefs::kCryptAuthDeviceSyncUnlockKeys)
                     ->GetSize());
 
   FireSchedulerForSync(cryptauth::INVOCATION_REASON_PERIODIC);
   ASSERT_FALSE(success_callback_.is_null());
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
   success_callback_.Run(response);
 
   ExpectUnlockKeysAndPrefAreEqual(
       expected_unlock_keys, device_manager_->unlock_keys(), pref_service_);
 }
 
-TEST_F(ProximityAuthCryptAuthDeviceManagerTest, SyncOnGCMPushMessage) {
+TEST_F(CryptAuthDeviceManagerTest, SyncOnGCMPushMessage) {
   device_manager_->Start();
 
   EXPECT_CALL(*sync_scheduler(), ForceSync());
   gcm_manager_.PushResyncMessage();
 
   FireSchedulerForSync(cryptauth::INVOCATION_REASON_SERVER_INITIATED);
 
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
   success_callback_.Run(get_my_devices_response_);
 
   ExpectUnlockKeysAndPrefAreEqual(std::vector<cryptauth::ExternalDeviceInfo>(
                                       1, get_my_devices_response_.devices(0)),
                                   device_manager_->unlock_keys(),
                                   pref_service_);
 }
 
-}  // namespace proximity_auth
+}  // namespace cryptauth