Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(869)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: components/proximity_auth/cryptauth/cryptauth_device_manager_unittest.cc

Issue 2502343003: Moved //components/proximity_auth/cryptauth to //components/cryptauth. (Closed)
Patch Set: Fixed proto #includes. Created 4 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « components/proximity_auth/cryptauth/cryptauth_device_manager.cc ('k') | components/proximity_auth/cryptauth/cryptauth_enroller.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: components/proximity_auth/cryptauth/cryptauth_device_manager_unittest.cc
diff --git a/components/proximity_auth/cryptauth/cryptauth_device_manager_unittest.cc b/components/proximity_auth/cryptauth/cryptauth_device_manager_unittest.cc
deleted file mode 100644
index d5c71218634bdf0d1054a3e81ea591757fe7ac12..0000000000000000000000000000000000000000
--- a/components/proximity_auth/cryptauth/cryptauth_device_manager_unittest.cc
+++ /dev/null
@@ -1,609 +0,0 @@
-// 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 <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/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 {
-
-// 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);
-
-// Unlock key fields originally stored in the user prefs.
-const char kStoredPublicKey[] = "AAPL";
-const char kStoredDeviceName[] = "iPhone 6";
-const char kStoredBluetoothAddress[] = "12:34:56:78:90:AB";
-
-// ExternalDeviceInfo fields for the synced unlock key.
-const char kPublicKey1[] = "GOOG";
-const char kDeviceName1[] = "Nexus 5";
-const char kBluetoothAddress1[] = "aa:bb:cc:ee:dd:ff";
-
-// ExternalDeviceInfo fields for a non-synced unlockable device.
-const char kPublicKey2[] = "MSFT";
-const char kDeviceName2[] = "Surface Pro 3";
-
-// Validates that |unlock_keys| and the corresponding preferences stored by
-// |pref_service| are equal to |expected_unlock_keys|.
-void ExpectUnlockKeysAndPrefAreEqual(
- const std::vector<cryptauth::ExternalDeviceInfo>& expected_unlock_keys,
- const std::vector<cryptauth::ExternalDeviceInfo>& unlock_keys,
- const PrefService& pref_service) {
- ASSERT_EQ(expected_unlock_keys.size(), unlock_keys.size());
- for (size_t i = 0; i < unlock_keys.size(); ++i) {
- SCOPED_TRACE(
- base::StringPrintf("Compare protos at index=%d", static_cast<int>(i)));
- const auto& expected_unlock_key = expected_unlock_keys[i];
- const auto& unlock_key = unlock_keys.at(i);
- EXPECT_EQ(expected_unlock_key.public_key(), unlock_key.public_key());
- EXPECT_EQ(expected_unlock_key.friendly_device_name(),
- unlock_key.friendly_device_name());
- EXPECT_EQ(expected_unlock_key.bluetooth_address(),
- unlock_key.bluetooth_address());
- EXPECT_TRUE(expected_unlock_key.unlock_key());
- EXPECT_FALSE(expected_unlock_key.unlockable());
- }
-
- const base::ListValue* unlock_keys_pref =
- pref_service.GetList(prefs::kCryptAuthDeviceSyncUnlockKeys);
- ASSERT_EQ(expected_unlock_keys.size(), unlock_keys_pref->GetSize());
- for (size_t i = 0; i < unlock_keys_pref->GetSize(); ++i) {
- SCOPED_TRACE(base::StringPrintf("Compare pref dictionary at index=%d",
- static_cast<int>(i)));
- const base::DictionaryValue* unlock_key_dictionary;
- EXPECT_TRUE(unlock_keys_pref->GetDictionary(i, &unlock_key_dictionary));
- std::string public_key_b64, device_name_b64, bluetooth_address_b64;
- ASSERT_TRUE(
- unlock_key_dictionary->GetString("public_key", &public_key_b64));
- ASSERT_TRUE(
- unlock_key_dictionary->GetString("device_name", &device_name_b64));
- ASSERT_TRUE(unlock_key_dictionary->GetString("bluetooth_address",
- &bluetooth_address_b64));
-
- std::string public_key, device_name, bluetooth_address;
- ASSERT_TRUE(base::Base64UrlDecode(
- public_key_b64, base::Base64UrlDecodePolicy::REQUIRE_PADDING,
- &public_key));
- ASSERT_TRUE(base::Base64UrlDecode(
- device_name_b64, base::Base64UrlDecodePolicy::REQUIRE_PADDING,
- &device_name));
- ASSERT_TRUE(base::Base64UrlDecode(
- bluetooth_address_b64, base::Base64UrlDecodePolicy::REQUIRE_PADDING,
- &bluetooth_address));
-
- const auto& expected_unlock_key = expected_unlock_keys[i];
- EXPECT_EQ(expected_unlock_key.public_key(), public_key);
- EXPECT_EQ(expected_unlock_key.friendly_device_name(), device_name);
- EXPECT_EQ(expected_unlock_key.bluetooth_address(), bluetooth_address);
- EXPECT_TRUE(expected_unlock_key.unlock_key());
- EXPECT_FALSE(expected_unlock_key.unlockable());
- }
-}
-
-// Harness for testing CryptAuthDeviceManager.
-class TestCryptAuthDeviceManager : public CryptAuthDeviceManager {
- public:
- TestCryptAuthDeviceManager(
- std::unique_ptr<base::Clock> clock,
- std::unique_ptr<CryptAuthClientFactory> client_factory,
- CryptAuthGCMManager* gcm_manager,
- PrefService* pref_service)
- : CryptAuthDeviceManager(std::move(clock),
- std::move(client_factory),
- gcm_manager,
- pref_service),
- scoped_sync_scheduler_(new NiceMock<MockSyncScheduler>()),
- weak_sync_scheduler_factory_(scoped_sync_scheduler_.get()) {}
-
- ~TestCryptAuthDeviceManager() override {}
-
- std::unique_ptr<SyncScheduler> CreateSyncScheduler() override {
- EXPECT_TRUE(scoped_sync_scheduler_);
- return std::move(scoped_sync_scheduler_);
- }
-
- base::WeakPtr<MockSyncScheduler> GetSyncScheduler() {
- return weak_sync_scheduler_factory_.GetWeakPtr();
- }
-
- private:
- // Ownership is passed to |CryptAuthDeviceManager| super class when
- // |CreateSyncScheduler()| is called.
- std::unique_ptr<MockSyncScheduler> scoped_sync_scheduler_;
-
- // Stores the pointer of |scoped_sync_scheduler_| after ownership is passed to
- // 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
- : public testing::Test,
- public CryptAuthDeviceManager::Observer,
- public MockCryptAuthClientFactory::Observer {
- protected:
- ProximityAuthCryptAuthDeviceManagerTest()
- : clock_(new base::SimpleTestClock()),
- client_factory_(new MockCryptAuthClientFactory(
- MockCryptAuthClientFactory::MockType::MAKE_STRICT_MOCKS)),
- gcm_manager_("existing gcm registration id") {
- client_factory_->AddObserver(this);
- }
-
- ~ProximityAuthCryptAuthDeviceManagerTest() {
- 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,
- new base::FundamentalValue(false));
- pref_service_.SetUserPref(prefs::kCryptAuthDeviceSyncLastSyncTimeSeconds,
- new base::FundamentalValue(kLastSyncTimeSeconds));
- pref_service_.SetUserPref(
- prefs::kCryptAuthDeviceSyncReason,
- new base::FundamentalValue(cryptauth::INVOCATION_REASON_UNKNOWN));
-
- std::unique_ptr<base::DictionaryValue> unlock_key_dictionary(
- new base::DictionaryValue());
-
- std::string public_key_b64, device_name_b64, bluetooth_address_b64;
- base::Base64UrlEncode(kStoredPublicKey,
- base::Base64UrlEncodePolicy::INCLUDE_PADDING,
- &public_key_b64);
- base::Base64UrlEncode(kStoredDeviceName,
- base::Base64UrlEncodePolicy::INCLUDE_PADDING,
- &device_name_b64);
- base::Base64UrlEncode(kStoredBluetoothAddress,
- base::Base64UrlEncodePolicy::INCLUDE_PADDING,
- &bluetooth_address_b64);
-
- unlock_key_dictionary->SetString("public_key", public_key_b64);
- unlock_key_dictionary->SetString("device_name", device_name_b64);
- unlock_key_dictionary->SetString("bluetooth_address",
- bluetooth_address_b64);
- {
- ListPrefUpdate update(&pref_service_,
- prefs::kCryptAuthDeviceSyncUnlockKeys);
- update.Get()->Append(std::move(unlock_key_dictionary));
- }
-
- device_manager_.reset(new TestCryptAuthDeviceManager(
- base::WrapUnique(clock_), base::WrapUnique(client_factory_),
- &gcm_manager_, &pref_service_));
- device_manager_->AddObserver(this);
-
- cryptauth::ExternalDeviceInfo unlock_key;
- unlock_key.set_public_key(kPublicKey1);
- unlock_key.set_friendly_device_name(kDeviceName1);
- unlock_key.set_bluetooth_address(kBluetoothAddress1);
- unlock_key.set_unlock_key(true);
- unlock_key.set_unlockable(false);
-
- cryptauth::ExternalDeviceInfo unlockable_device;
- unlockable_device.set_public_key(kPublicKey2);
- unlockable_device.set_friendly_device_name(kDeviceName2);
- unlockable_device.set_unlock_key(false);
- unlockable_device.set_unlockable(true);
-
- get_my_devices_response_.add_devices()->CopyFrom(unlock_key);
- get_my_devices_response_.add_devices()->CopyFrom(unlockable_device);
-
- ON_CALL(*sync_scheduler(), GetStrategy())
- .WillByDefault(Return(SyncScheduler::Strategy::PERIODIC_REFRESH));
- }
-
- void TearDown() override { device_manager_->RemoveObserver(this); }
-
- // CryptAuthDeviceManager::Observer:
- void OnSyncStarted() override { OnSyncStartedProxy(); }
-
- void OnSyncFinished(CryptAuthDeviceManager::SyncResult sync_result,
- CryptAuthDeviceManager::DeviceChangeResult
- device_change_result) override {
- OnSyncFinishedProxy(sync_result, device_change_result);
- }
-
- MOCK_METHOD0(OnSyncStartedProxy, void());
- MOCK_METHOD2(OnSyncFinishedProxy,
- void(CryptAuthDeviceManager::SyncResult,
- CryptAuthDeviceManager::DeviceChangeResult));
-
- // Simulates firing the SyncScheduler to trigger a device sync attempt.
- void FireSchedulerForSync(
- cryptauth::InvocationReason expected_invocation_reason) {
- SyncScheduler::Delegate* delegate =
- static_cast<SyncScheduler::Delegate*>(device_manager_.get());
-
- std::unique_ptr<SyncScheduler::SyncRequest> sync_request =
- base::MakeUnique<SyncScheduler::SyncRequest>(
- device_manager_->GetSyncScheduler());
- EXPECT_CALL(*this, OnSyncStartedProxy());
- delegate->OnSyncRequested(std::move(sync_request));
-
- EXPECT_EQ(expected_invocation_reason,
- get_my_devices_request_.invocation_reason());
-
- // The allow_stale_read flag is set if the sync was not forced.
- bool allow_stale_read =
- pref_service_.GetInteger(prefs::kCryptAuthDeviceSyncReason) !=
- cryptauth::INVOCATION_REASON_UNKNOWN;
- EXPECT_EQ(allow_stale_read, get_my_devices_request_.allow_stale_read());
- }
-
- // MockCryptAuthClientFactory::Observer:
- void OnCryptAuthClientCreated(MockCryptAuthClient* client) override {
- EXPECT_CALL(*client, GetMyDevices(_, _, _))
- .WillOnce(DoAll(SaveArg<0>(&get_my_devices_request_),
- SaveArg<1>(&success_callback_),
- SaveArg<2>(&error_callback_)));
- }
-
- MockSyncScheduler* sync_scheduler() {
- return device_manager_->GetSyncScheduler().get();
- }
-
- // Owned by |device_manager_|.
- base::SimpleTestClock* clock_;
-
- // Owned by |device_manager_|.
- MockCryptAuthClientFactory* client_factory_;
-
- TestingPrefServiceSimple pref_service_;
-
- FakeCryptAuthGCMManager gcm_manager_;
-
- 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);
-};
-
-TEST_F(ProximityAuthCryptAuthDeviceManagerTest, 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) {
- 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) {
- 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) {
- 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) {
- 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) {
- 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) {
- 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));
- EXPECT_CALL(*this,
- OnSyncFinishedProxy(
- CryptAuthDeviceManager::SyncResult::FAILURE,
- CryptAuthDeviceManager::DeviceChangeResult::UNCHANGED));
- error_callback_.Run("404");
- EXPECT_EQ(old_sync_time, device_manager_->GetLastSyncTime());
- EXPECT_TRUE(pref_service_.GetBoolean(
- prefs::kCryptAuthDeviceSyncIsRecoveringFromFailure));
- EXPECT_EQ(static_cast<int>(cryptauth::INVOCATION_REASON_MANUAL),
- pref_service_.GetInteger(prefs::kCryptAuthDeviceSyncReason));
-
- // The second recovery sync succeeds.
- ON_CALL(*sync_scheduler(), GetStrategy())
- .WillByDefault(Return(SyncScheduler::Strategy::AGGRESSIVE_RECOVERY));
- FireSchedulerForSync(cryptauth::INVOCATION_REASON_MANUAL);
- clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNowSeconds + 30));
- 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_);
-
- 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) {
- 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));
- error_callback_.Run("401");
- EXPECT_EQ(old_sync_time, device_manager_->GetLastSyncTime());
- EXPECT_TRUE(pref_service_.GetBoolean(
- prefs::kCryptAuthDeviceSyncIsRecoveringFromFailure));
-
- // The second recovery sync succeeds.
- ON_CALL(*sync_scheduler(), GetStrategy())
- .WillByDefault(Return(SyncScheduler::Strategy::AGGRESSIVE_RECOVERY));
- FireSchedulerForSync(cryptauth::INVOCATION_REASON_FAILURE_RECOVERY);
- clock_->SetNow(base::Time::FromDoubleT(kLaterTimeNowSeconds + 30));
- 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_);
-
- EXPECT_FLOAT_EQ(
- clock_->Now().ToDoubleT(),
- pref_service_.GetDouble(prefs::kCryptAuthDeviceSyncLastSyncTimeSeconds));
- EXPECT_FALSE(pref_service_.GetBoolean(
- prefs::kCryptAuthDeviceSyncIsRecoveringFromFailure));
-}
-
-TEST_F(ProximityAuthCryptAuthDeviceManagerTest, 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) {
- 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) {
- 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) {
- 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
« no previous file with comments | « components/proximity_auth/cryptauth/cryptauth_device_manager.cc ('k') | components/proximity_auth/cryptauth/cryptauth_enroller.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698