1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471 |
- // Copyright 2018 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 <algorithm>
- #include <memory>
- #include <vector>
- #include "ash/components/multidevice/remote_device_test_util.h"
- #include "ash/constants/ash_features.h"
- #include "ash/services/device_sync/public/cpp/fake_device_sync_client.h"
- #include "ash/services/device_sync/public/cpp/fake_gcm_device_info_provider.h"
- #include "ash/services/multidevice_setup/account_status_change_delegate_notifier_impl.h"
- #include "ash/services/multidevice_setup/android_sms_app_installing_status_observer.h"
- #include "ash/services/multidevice_setup/eligible_host_devices_provider_impl.h"
- #include "ash/services/multidevice_setup/fake_account_status_change_delegate.h"
- #include "ash/services/multidevice_setup/fake_account_status_change_delegate_notifier.h"
- #include "ash/services/multidevice_setup/fake_eligible_host_devices_provider.h"
- #include "ash/services/multidevice_setup/fake_feature_state_manager.h"
- #include "ash/services/multidevice_setup/fake_feature_state_observer.h"
- #include "ash/services/multidevice_setup/fake_global_state_feature_manager.h"
- #include "ash/services/multidevice_setup/fake_host_backend_delegate.h"
- #include "ash/services/multidevice_setup/fake_host_device_timestamp_manager.h"
- #include "ash/services/multidevice_setup/fake_host_status_observer.h"
- #include "ash/services/multidevice_setup/fake_host_status_provider.h"
- #include "ash/services/multidevice_setup/fake_host_verifier.h"
- #include "ash/services/multidevice_setup/feature_state_manager_impl.h"
- #include "ash/services/multidevice_setup/global_state_feature_manager.h"
- #include "ash/services/multidevice_setup/global_state_feature_manager_impl.h"
- #include "ash/services/multidevice_setup/grandfathered_easy_unlock_host_disabler.h"
- #include "ash/services/multidevice_setup/host_backend_delegate_impl.h"
- #include "ash/services/multidevice_setup/host_device_timestamp_manager_impl.h"
- #include "ash/services/multidevice_setup/host_status_provider_impl.h"
- #include "ash/services/multidevice_setup/host_verifier_impl.h"
- #include "ash/services/multidevice_setup/multidevice_setup_impl.h"
- #include "ash/services/multidevice_setup/public/cpp/fake_android_sms_app_helper_delegate.h"
- #include "ash/services/multidevice_setup/public/cpp/fake_android_sms_pairing_state_tracker.h"
- #include "ash/services/multidevice_setup/public/cpp/fake_auth_token_validator.h"
- #include "ash/services/multidevice_setup/public/cpp/oobe_completion_tracker.h"
- #include "ash/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
- #include "ash/services/multidevice_setup/wifi_sync_notification_controller.h"
- #include "base/bind.h"
- #include "base/containers/flat_map.h"
- #include "base/run_loop.h"
- #include "base/test/scoped_feature_list.h"
- #include "base/test/task_environment.h"
- #include "components/sync_preferences/testing_pref_service_syncable.h"
- #include "testing/gtest/include/gtest/gtest.h"
- namespace ash {
- namespace multidevice_setup {
- namespace {
- const size_t kNumTestDevices = 3;
- const char kValidAuthToken[] = "validAuthToken";
- multidevice::RemoteDeviceList RefListToRawList(
- const multidevice::RemoteDeviceRefList& ref_list) {
- multidevice::RemoteDeviceList raw_list;
- std::transform(ref_list.begin(), ref_list.end(), std::back_inserter(raw_list),
- [](const multidevice::RemoteDeviceRef ref) {
- return *GetMutableRemoteDevice(ref);
- });
- return raw_list;
- }
- absl::optional<multidevice::RemoteDevice> RefToRaw(
- const absl::optional<multidevice::RemoteDeviceRef>& ref) {
- if (!ref)
- return absl::nullopt;
- return *GetMutableRemoteDevice(*ref);
- }
- class FakeEligibleHostDevicesProviderFactory
- : public EligibleHostDevicesProviderImpl::Factory {
- public:
- explicit FakeEligibleHostDevicesProviderFactory(
- device_sync::FakeDeviceSyncClient* expected_device_sync_client)
- : expected_device_sync_client_(expected_device_sync_client) {}
- FakeEligibleHostDevicesProviderFactory(
- const FakeEligibleHostDevicesProviderFactory&) = delete;
- FakeEligibleHostDevicesProviderFactory& operator=(
- const FakeEligibleHostDevicesProviderFactory&) = delete;
- ~FakeEligibleHostDevicesProviderFactory() override = default;
- FakeEligibleHostDevicesProvider* instance() { return instance_; }
- private:
- // EligibleHostDevicesProviderImpl::Factory:
- std::unique_ptr<EligibleHostDevicesProvider> CreateInstance(
- device_sync::DeviceSyncClient* device_sync_client) override {
- EXPECT_FALSE(instance_);
- EXPECT_EQ(expected_device_sync_client_, device_sync_client);
- auto instance = std::make_unique<FakeEligibleHostDevicesProvider>();
- instance_ = instance.get();
- return instance;
- }
- device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
- FakeEligibleHostDevicesProvider* instance_ = nullptr;
- };
- class FakeHostBackendDelegateFactory : public HostBackendDelegateImpl::Factory {
- public:
- FakeHostBackendDelegateFactory(
- FakeEligibleHostDevicesProviderFactory*
- fake_eligible_host_devices_provider_factory,
- sync_preferences::TestingPrefServiceSyncable*
- expected_testing_pref_service,
- device_sync::FakeDeviceSyncClient* expected_device_sync_client)
- : fake_eligible_host_devices_provider_factory_(
- fake_eligible_host_devices_provider_factory),
- expected_testing_pref_service_(expected_testing_pref_service),
- expected_device_sync_client_(expected_device_sync_client) {}
- FakeHostBackendDelegateFactory(const FakeHostBackendDelegateFactory&) =
- delete;
- FakeHostBackendDelegateFactory& operator=(
- const FakeHostBackendDelegateFactory&) = delete;
- ~FakeHostBackendDelegateFactory() override = default;
- FakeHostBackendDelegate* instance() { return instance_; }
- private:
- // HostBackendDelegateImpl::Factory:
- std::unique_ptr<HostBackendDelegate> CreateInstance(
- EligibleHostDevicesProvider* eligible_host_devices_provider,
- PrefService* pref_service,
- device_sync::DeviceSyncClient* device_sync_client,
- std::unique_ptr<base::OneShotTimer> timer) override {
- EXPECT_FALSE(instance_);
- EXPECT_EQ(fake_eligible_host_devices_provider_factory_->instance(),
- eligible_host_devices_provider);
- EXPECT_EQ(expected_testing_pref_service_, pref_service);
- EXPECT_EQ(expected_device_sync_client_, device_sync_client);
- auto instance = std::make_unique<FakeHostBackendDelegate>();
- instance_ = instance.get();
- return instance;
- }
- FakeEligibleHostDevicesProviderFactory*
- fake_eligible_host_devices_provider_factory_;
- sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
- device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
- FakeHostBackendDelegate* instance_ = nullptr;
- };
- class FakeHostVerifierFactory : public HostVerifierImpl::Factory {
- public:
- FakeHostVerifierFactory(
- FakeHostBackendDelegateFactory* fake_host_backend_delegate_factory,
- device_sync::FakeDeviceSyncClient* expected_device_sync_client,
- sync_preferences::TestingPrefServiceSyncable*
- expected_testing_pref_service)
- : fake_host_backend_delegate_factory_(fake_host_backend_delegate_factory),
- expected_device_sync_client_(expected_device_sync_client),
- expected_testing_pref_service_(expected_testing_pref_service) {}
- FakeHostVerifierFactory(const FakeHostVerifierFactory&) = delete;
- FakeHostVerifierFactory& operator=(const FakeHostVerifierFactory&) = delete;
- ~FakeHostVerifierFactory() override = default;
- FakeHostVerifier* instance() { return instance_; }
- private:
- // HostVerifierImpl::Factory:
- std::unique_ptr<HostVerifier> CreateInstance(
- HostBackendDelegate* host_backend_delegate,
- device_sync::DeviceSyncClient* device_sync_client,
- PrefService* pref_service,
- base::Clock* clock,
- std::unique_ptr<base::OneShotTimer> retry_timer,
- std::unique_ptr<base::OneShotTimer> sync_timer) override {
- EXPECT_FALSE(instance_);
- EXPECT_EQ(fake_host_backend_delegate_factory_->instance(),
- host_backend_delegate);
- EXPECT_EQ(expected_device_sync_client_, device_sync_client);
- EXPECT_EQ(expected_testing_pref_service_, pref_service);
- auto instance = std::make_unique<FakeHostVerifier>();
- instance_ = instance.get();
- return instance;
- }
- FakeHostBackendDelegateFactory* fake_host_backend_delegate_factory_;
- device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
- sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
- FakeHostVerifier* instance_ = nullptr;
- };
- class FakeHostStatusProviderFactory : public HostStatusProviderImpl::Factory {
- public:
- FakeHostStatusProviderFactory(
- FakeEligibleHostDevicesProviderFactory*
- fake_eligible_host_devices_provider_factory,
- FakeHostBackendDelegateFactory* fake_host_backend_delegate_factory,
- FakeHostVerifierFactory* fake_host_verifier_factory,
- device_sync::FakeDeviceSyncClient* expected_device_sync_client)
- : fake_eligible_host_devices_provider_factory_(
- fake_eligible_host_devices_provider_factory),
- fake_host_backend_delegate_factory_(fake_host_backend_delegate_factory),
- fake_host_verifier_factory_(fake_host_verifier_factory),
- expected_device_sync_client_(expected_device_sync_client) {}
- FakeHostStatusProviderFactory(const FakeHostStatusProviderFactory&) = delete;
- FakeHostStatusProviderFactory& operator=(
- const FakeHostStatusProviderFactory&) = delete;
- ~FakeHostStatusProviderFactory() override = default;
- FakeHostStatusProvider* instance() { return instance_; }
- private:
- // HostStatusProviderImpl::Factory:
- std::unique_ptr<HostStatusProvider> CreateInstance(
- EligibleHostDevicesProvider* eligible_host_devices_provider,
- HostBackendDelegate* host_backend_delegate,
- HostVerifier* host_verifier,
- device_sync::DeviceSyncClient* device_sync_client) override {
- EXPECT_FALSE(instance_);
- EXPECT_EQ(fake_eligible_host_devices_provider_factory_->instance(),
- eligible_host_devices_provider);
- EXPECT_EQ(fake_host_backend_delegate_factory_->instance(),
- host_backend_delegate);
- EXPECT_EQ(fake_host_verifier_factory_->instance(), host_verifier);
- EXPECT_EQ(expected_device_sync_client_, device_sync_client);
- auto instance = std::make_unique<FakeHostStatusProvider>();
- instance_ = instance.get();
- return instance;
- }
- FakeEligibleHostDevicesProviderFactory*
- fake_eligible_host_devices_provider_factory_;
- FakeHostBackendDelegateFactory* fake_host_backend_delegate_factory_;
- FakeHostVerifierFactory* fake_host_verifier_factory_;
- device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
- FakeHostStatusProvider* instance_ = nullptr;
- };
- class FakeGlobalStateFeatureManagerFactory
- : public GlobalStateFeatureManagerImpl::Factory {
- public:
- FakeGlobalStateFeatureManagerFactory(
- FakeHostStatusProviderFactory* fake_host_status_provider_factory,
- sync_preferences::TestingPrefServiceSyncable*
- expected_testing_pref_service,
- device_sync::FakeDeviceSyncClient* expected_device_sync_client)
- : fake_host_status_provider_factory_(fake_host_status_provider_factory),
- expected_testing_pref_service_(expected_testing_pref_service),
- expected_device_sync_client_(expected_device_sync_client) {}
- FakeGlobalStateFeatureManagerFactory(
- const FakeGlobalStateFeatureManagerFactory&) = delete;
- FakeGlobalStateFeatureManagerFactory& operator=(
- const FakeGlobalStateFeatureManagerFactory&) = delete;
- ~FakeGlobalStateFeatureManagerFactory() override = default;
- private:
- // GlobalStateFeatureManagerImpl::Factory:
- std::unique_ptr<GlobalStateFeatureManager> CreateInstance(
- GlobalStateFeatureManagerImpl::Factory::Option option,
- HostStatusProvider* host_status_provider,
- PrefService* pref_service,
- device_sync::DeviceSyncClient* device_sync_client,
- std::unique_ptr<base::OneShotTimer> timer) override {
- EXPECT_EQ(fake_host_status_provider_factory_->instance(),
- host_status_provider);
- EXPECT_EQ(expected_testing_pref_service_, pref_service);
- EXPECT_EQ(expected_device_sync_client_, device_sync_client);
- return std::make_unique<FakeGlobalStateFeatureManager>();
- }
- FakeHostStatusProviderFactory* fake_host_status_provider_factory_;
- sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
- device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
- };
- class FakeWifiSyncNotificationControllerFactory
- : public WifiSyncNotificationController::Factory {
- public:
- FakeWifiSyncNotificationControllerFactory(
- FakeHostStatusProviderFactory* fake_host_status_provider_factory,
- sync_preferences::TestingPrefServiceSyncable*
- expected_testing_pref_service,
- device_sync::FakeDeviceSyncClient* expected_device_sync_client)
- : fake_host_status_provider_factory_(fake_host_status_provider_factory),
- expected_testing_pref_service_(expected_testing_pref_service),
- expected_device_sync_client_(expected_device_sync_client) {}
- FakeWifiSyncNotificationControllerFactory(
- const FakeWifiSyncNotificationControllerFactory&) = delete;
- FakeWifiSyncNotificationControllerFactory& operator=(
- const FakeWifiSyncNotificationControllerFactory&) = delete;
- ~FakeWifiSyncNotificationControllerFactory() override = default;
- private:
- // WifiSyncNotificationController::Factory:
- std::unique_ptr<WifiSyncNotificationController> CreateInstance(
- GlobalStateFeatureManager* wifi_sync_feature_manager,
- HostStatusProvider* host_status_provider,
- PrefService* pref_service,
- device_sync::DeviceSyncClient* device_sync_client,
- AccountStatusChangeDelegateNotifier* delegate_notifier) override {
- EXPECT_EQ(fake_host_status_provider_factory_->instance(),
- host_status_provider);
- EXPECT_EQ(expected_testing_pref_service_, pref_service);
- EXPECT_EQ(expected_device_sync_client_, device_sync_client);
- // Only check inputs and return nullptr. We do not want to trigger any logic
- // in these unit tests.
- return nullptr;
- }
- FakeHostStatusProviderFactory* fake_host_status_provider_factory_;
- sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
- device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
- };
- class FakeGrandfatheredEasyUnlockHostDisablerFactory
- : public GrandfatheredEasyUnlockHostDisabler::Factory {
- public:
- FakeGrandfatheredEasyUnlockHostDisablerFactory(
- FakeHostBackendDelegateFactory* fake_host_backend_delegate_factory,
- device_sync::FakeDeviceSyncClient* expected_device_sync_client,
- sync_preferences::TestingPrefServiceSyncable*
- expected_testing_pref_service)
- : fake_host_backend_delegate_factory_(fake_host_backend_delegate_factory),
- expected_device_sync_client_(expected_device_sync_client),
- expected_testing_pref_service_(expected_testing_pref_service) {}
- FakeGrandfatheredEasyUnlockHostDisablerFactory(
- const FakeGrandfatheredEasyUnlockHostDisablerFactory&) = delete;
- FakeGrandfatheredEasyUnlockHostDisablerFactory& operator=(
- const FakeGrandfatheredEasyUnlockHostDisablerFactory&) = delete;
- ~FakeGrandfatheredEasyUnlockHostDisablerFactory() override = default;
- private:
- // GrandfatheredEasyUnlockHostDisabler::Factory:
- std::unique_ptr<GrandfatheredEasyUnlockHostDisabler> CreateInstance(
- HostBackendDelegate* host_backend_delegate,
- device_sync::DeviceSyncClient* device_sync_client,
- PrefService* pref_service,
- std::unique_ptr<base::OneShotTimer> timer) override {
- EXPECT_EQ(fake_host_backend_delegate_factory_->instance(),
- host_backend_delegate);
- EXPECT_EQ(expected_device_sync_client_, device_sync_client);
- EXPECT_EQ(expected_testing_pref_service_, pref_service);
- // Only check inputs and return nullptr. We do not want to trigger any logic
- // in these unit tests.
- return nullptr;
- }
- FakeHostBackendDelegateFactory* fake_host_backend_delegate_factory_;
- device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
- sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
- };
- class FakeFeatureStateManagerFactory : public FeatureStateManagerImpl::Factory {
- public:
- FakeFeatureStateManagerFactory(
- sync_preferences::TestingPrefServiceSyncable*
- expected_testing_pref_service,
- FakeHostStatusProviderFactory* fake_host_status_provider_factory,
- device_sync::FakeDeviceSyncClient* expected_device_sync_client,
- FakeAndroidSmsPairingStateTracker*
- expected_android_sms_pairing_state_tracker,
- bool expected_is_secondary_user)
- : expected_testing_pref_service_(expected_testing_pref_service),
- fake_host_status_provider_factory_(fake_host_status_provider_factory),
- expected_device_sync_client_(expected_device_sync_client),
- expected_android_sms_pairing_state_tracker_(
- expected_android_sms_pairing_state_tracker),
- expected_is_secondary_user_(expected_is_secondary_user) {}
- FakeFeatureStateManagerFactory(const FakeFeatureStateManagerFactory&) =
- delete;
- FakeFeatureStateManagerFactory& operator=(
- const FakeFeatureStateManagerFactory&) = delete;
- ~FakeFeatureStateManagerFactory() override = default;
- FakeFeatureStateManager* instance() { return instance_; }
- private:
- // FeatureStateManagerImpl::Factory:
- std::unique_ptr<FeatureStateManager> CreateInstance(
- PrefService* pref_service,
- HostStatusProvider* host_status_provider,
- device_sync::DeviceSyncClient* device_sync_client,
- AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
- const base::flat_map<mojom::Feature, GlobalStateFeatureManager*>&
- global_state_feature_managers,
- bool is_secondary_user) override {
- EXPECT_FALSE(instance_);
- EXPECT_EQ(expected_testing_pref_service_, pref_service);
- EXPECT_EQ(fake_host_status_provider_factory_->instance(),
- host_status_provider);
- EXPECT_EQ(expected_device_sync_client_, device_sync_client);
- EXPECT_EQ(expected_android_sms_pairing_state_tracker_,
- android_sms_pairing_state_tracker);
- EXPECT_EQ(expected_is_secondary_user_, is_secondary_user);
- auto instance = std::make_unique<FakeFeatureStateManager>();
- instance_ = instance.get();
- return instance;
- }
- sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
- FakeHostStatusProviderFactory* fake_host_status_provider_factory_;
- device_sync::FakeDeviceSyncClient* expected_device_sync_client_;
- FakeAndroidSmsPairingStateTracker*
- expected_android_sms_pairing_state_tracker_;
- bool expected_is_secondary_user_;
- FakeFeatureStateManager* instance_ = nullptr;
- };
- class FakeHostDeviceTimestampManagerFactory
- : public HostDeviceTimestampManagerImpl::Factory {
- public:
- FakeHostDeviceTimestampManagerFactory(
- FakeHostStatusProviderFactory* fake_host_status_provider_factory,
- sync_preferences::TestingPrefServiceSyncable*
- expected_testing_pref_service)
- : fake_host_status_provider_factory_(fake_host_status_provider_factory),
- expected_testing_pref_service_(expected_testing_pref_service) {}
- FakeHostDeviceTimestampManagerFactory(
- const FakeHostDeviceTimestampManagerFactory&) = delete;
- FakeHostDeviceTimestampManagerFactory& operator=(
- const FakeHostDeviceTimestampManagerFactory&) = delete;
- ~FakeHostDeviceTimestampManagerFactory() override = default;
- FakeHostDeviceTimestampManager* instance() { return instance_; }
- private:
- // HostDeviceTimestampManagerImpl::Factory:
- std::unique_ptr<HostDeviceTimestampManager> CreateInstance(
- HostStatusProvider* host_status_provider,
- PrefService* pref_service,
- base::Clock* clock) override {
- EXPECT_FALSE(instance_);
- EXPECT_EQ(fake_host_status_provider_factory_->instance(),
- host_status_provider);
- EXPECT_EQ(expected_testing_pref_service_, pref_service);
- auto instance = std::make_unique<FakeHostDeviceTimestampManager>();
- instance_ = instance.get();
- return instance;
- }
- FakeHostStatusProviderFactory* fake_host_status_provider_factory_;
- sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
- FakeHostDeviceTimestampManager* instance_ = nullptr;
- };
- class FakeAccountStatusChangeDelegateNotifierFactory
- : public AccountStatusChangeDelegateNotifierImpl::Factory {
- public:
- FakeAccountStatusChangeDelegateNotifierFactory(
- FakeHostStatusProviderFactory* fake_host_status_provider_factory,
- sync_preferences::TestingPrefServiceSyncable*
- expected_testing_pref_service,
- FakeHostDeviceTimestampManagerFactory*
- fake_host_device_timestamp_manager_factory,
- OobeCompletionTracker* expected_oobe_completion_tracker)
- : fake_host_status_provider_factory_(fake_host_status_provider_factory),
- expected_testing_pref_service_(expected_testing_pref_service),
- fake_host_device_timestamp_manager_factory_(
- fake_host_device_timestamp_manager_factory),
- expected_oobe_completion_tracker_(expected_oobe_completion_tracker) {}
- FakeAccountStatusChangeDelegateNotifierFactory(
- const FakeAccountStatusChangeDelegateNotifierFactory&) = delete;
- FakeAccountStatusChangeDelegateNotifierFactory& operator=(
- const FakeAccountStatusChangeDelegateNotifierFactory&) = delete;
- ~FakeAccountStatusChangeDelegateNotifierFactory() override = default;
- FakeAccountStatusChangeDelegateNotifier* instance() { return instance_; }
- private:
- // AccountStatusChangeDelegateNotifierImpl::Factory:
- std::unique_ptr<AccountStatusChangeDelegateNotifier> CreateInstance(
- HostStatusProvider* host_status_provider,
- PrefService* pref_service,
- HostDeviceTimestampManager* host_device_timestamp_manager,
- OobeCompletionTracker* oobe_completion_tracker,
- base::Clock* clock) override {
- EXPECT_FALSE(instance_);
- EXPECT_EQ(fake_host_status_provider_factory_->instance(),
- host_status_provider);
- EXPECT_EQ(expected_testing_pref_service_, pref_service);
- EXPECT_EQ(fake_host_device_timestamp_manager_factory_->instance(),
- host_device_timestamp_manager);
- EXPECT_EQ(expected_oobe_completion_tracker_, oobe_completion_tracker);
- auto instance = std::make_unique<FakeAccountStatusChangeDelegateNotifier>();
- instance_ = instance.get();
- return instance;
- }
- FakeHostStatusProviderFactory* fake_host_status_provider_factory_;
- sync_preferences::TestingPrefServiceSyncable* expected_testing_pref_service_;
- FakeHostDeviceTimestampManagerFactory*
- fake_host_device_timestamp_manager_factory_;
- OobeCompletionTracker* expected_oobe_completion_tracker_;
- FakeAccountStatusChangeDelegateNotifier* instance_ = nullptr;
- };
- class FakeAndroidSmsAppInstallingStatusObserverFactory
- : public AndroidSmsAppInstallingStatusObserver::Factory {
- public:
- FakeAndroidSmsAppInstallingStatusObserverFactory(
- FakeHostStatusProviderFactory* fake_host_status_provider_factory,
- FakeFeatureStateManagerFactory* fake_feature_state_manager_factory,
- AndroidSmsAppHelperDelegate* expected_android_sms_app_helper_delegate)
- : fake_host_status_provider_factory_(fake_host_status_provider_factory),
- fake_feature_state_manager_factory_(fake_feature_state_manager_factory),
- expected_android_sms_app_helper_delegate_(
- expected_android_sms_app_helper_delegate) {}
- FakeAndroidSmsAppInstallingStatusObserverFactory(
- const FakeAndroidSmsAppInstallingStatusObserverFactory&) = delete;
- FakeAndroidSmsAppInstallingStatusObserverFactory& operator=(
- const FakeAndroidSmsAppInstallingStatusObserverFactory&) = delete;
- ~FakeAndroidSmsAppInstallingStatusObserverFactory() override = default;
- private:
- // AndroidSmsAppInstallingStatusObserver::Factory:
- std::unique_ptr<AndroidSmsAppInstallingStatusObserver> CreateInstance(
- HostStatusProvider* host_status_provider,
- FeatureStateManager* feature_state_manager,
- AndroidSmsAppHelperDelegate* android_sms_app_helper_delegate) override {
- EXPECT_EQ(fake_host_status_provider_factory_->instance(),
- host_status_provider);
- EXPECT_EQ(fake_feature_state_manager_factory_->instance(),
- feature_state_manager);
- EXPECT_EQ(expected_android_sms_app_helper_delegate_,
- android_sms_app_helper_delegate);
- // Only check inputs and return nullptr. We do not want to trigger the
- // AndroidSmsAppInstallingStatusObserver logic in these unit tests.
- return nullptr;
- }
- FakeHostStatusProviderFactory* fake_host_status_provider_factory_;
- FakeFeatureStateManagerFactory* fake_feature_state_manager_factory_;
- AndroidSmsAppHelperDelegate* expected_android_sms_app_helper_delegate_;
- };
- } // namespace
- class MultiDeviceSetupImplTest : public ::testing::TestWithParam<bool> {
- public:
- MultiDeviceSetupImplTest(const MultiDeviceSetupImplTest&) = delete;
- MultiDeviceSetupImplTest& operator=(const MultiDeviceSetupImplTest&) = delete;
- protected:
- MultiDeviceSetupImplTest()
- : test_devices_(
- multidevice::CreateRemoteDeviceRefListForTest(kNumTestDevices)) {}
- ~MultiDeviceSetupImplTest() override = default;
- void SetUp() override {
- SetDeviceSyncFeatureFlags(IsV1DeviceSyncEnabled());
- test_pref_service_ =
- std::make_unique<sync_preferences::TestingPrefServiceSyncable>();
- fake_device_sync_client_ =
- std::make_unique<device_sync::FakeDeviceSyncClient>();
- fake_auth_token_validator_ = std::make_unique<FakeAuthTokenValidator>();
- fake_auth_token_validator_->set_expected_auth_token(kValidAuthToken);
- fake_oobe_completion_tracker_ = std::make_unique<OobeCompletionTracker>();
- fake_android_sms_app_helper_delegate_ =
- std::make_unique<FakeAndroidSmsAppHelperDelegate>();
- fake_android_sms_pairing_state_tracker_ =
- std::make_unique<FakeAndroidSmsPairingStateTracker>();
- fake_gcm_device_info_provider_ =
- std::make_unique<device_sync::FakeGcmDeviceInfoProvider>(
- cryptauth::GcmDeviceInfo());
- fake_eligible_host_devices_provider_factory_ =
- std::make_unique<FakeEligibleHostDevicesProviderFactory>(
- fake_device_sync_client_.get());
- EligibleHostDevicesProviderImpl::Factory::SetFactoryForTesting(
- fake_eligible_host_devices_provider_factory_.get());
- fake_host_backend_delegate_factory_ =
- std::make_unique<FakeHostBackendDelegateFactory>(
- fake_eligible_host_devices_provider_factory_.get(),
- test_pref_service_.get(), fake_device_sync_client_.get());
- HostBackendDelegateImpl::Factory::SetFactoryForTesting(
- fake_host_backend_delegate_factory_.get());
- fake_host_verifier_factory_ = std::make_unique<FakeHostVerifierFactory>(
- fake_host_backend_delegate_factory_.get(),
- fake_device_sync_client_.get(), test_pref_service_.get());
- HostVerifierImpl::Factory::SetFactoryForTesting(
- fake_host_verifier_factory_.get());
- fake_host_status_provider_factory_ =
- std::make_unique<FakeHostStatusProviderFactory>(
- fake_eligible_host_devices_provider_factory_.get(),
- fake_host_backend_delegate_factory_.get(),
- fake_host_verifier_factory_.get(), fake_device_sync_client_.get());
- HostStatusProviderImpl::Factory::SetFactoryForTesting(
- fake_host_status_provider_factory_.get());
- fake_global_state_feature_manager_factory_ =
- std::make_unique<FakeGlobalStateFeatureManagerFactory>(
- fake_host_status_provider_factory_.get(), test_pref_service_.get(),
- fake_device_sync_client_.get());
- GlobalStateFeatureManagerImpl::Factory::SetFactoryForTesting(
- fake_global_state_feature_manager_factory_.get());
- fake_wifi_sync_notification_controller_factory_ =
- std::make_unique<FakeWifiSyncNotificationControllerFactory>(
- fake_host_status_provider_factory_.get(), test_pref_service_.get(),
- fake_device_sync_client_.get());
- WifiSyncNotificationController::Factory::SetFactoryForTesting(
- fake_wifi_sync_notification_controller_factory_.get());
- fake_grandfathered_easy_unlock_host_disabler_factory_ =
- std::make_unique<FakeGrandfatheredEasyUnlockHostDisablerFactory>(
- fake_host_backend_delegate_factory_.get(),
- fake_device_sync_client_.get(), test_pref_service_.get());
- GrandfatheredEasyUnlockHostDisabler::Factory::SetFactoryForTesting(
- fake_grandfathered_easy_unlock_host_disabler_factory_.get());
- fake_feature_state_manager_factory_ =
- std::make_unique<FakeFeatureStateManagerFactory>(
- test_pref_service_.get(), fake_host_status_provider_factory_.get(),
- fake_device_sync_client_.get(),
- fake_android_sms_pairing_state_tracker_.get(), is_secondary_user_);
- FeatureStateManagerImpl::Factory::SetFactoryForTesting(
- fake_feature_state_manager_factory_.get());
- fake_host_device_timestamp_manager_factory_ =
- std::make_unique<FakeHostDeviceTimestampManagerFactory>(
- fake_host_status_provider_factory_.get(), test_pref_service_.get());
- HostDeviceTimestampManagerImpl::Factory::SetFactoryForTesting(
- fake_host_device_timestamp_manager_factory_.get());
- fake_account_status_change_delegate_notifier_factory_ =
- std::make_unique<FakeAccountStatusChangeDelegateNotifierFactory>(
- fake_host_status_provider_factory_.get(), test_pref_service_.get(),
- fake_host_device_timestamp_manager_factory_.get(),
- fake_oobe_completion_tracker_.get());
- AccountStatusChangeDelegateNotifierImpl::Factory::SetFactoryForTesting(
- fake_account_status_change_delegate_notifier_factory_.get());
- fake_android_sms_app_installing_status_observer_factory_ =
- std::make_unique<FakeAndroidSmsAppInstallingStatusObserverFactory>(
- fake_host_status_provider_factory_.get(),
- fake_feature_state_manager_factory_.get(),
- fake_android_sms_app_helper_delegate_.get());
- AndroidSmsAppInstallingStatusObserver::Factory::SetFactoryForTesting(
- fake_android_sms_app_installing_status_observer_factory_.get());
- multidevice_setup_ = MultiDeviceSetupImpl::Factory::Create(
- test_pref_service_.get(), fake_device_sync_client_.get(),
- fake_auth_token_validator_.get(), fake_oobe_completion_tracker_.get(),
- fake_android_sms_app_helper_delegate_.get(),
- fake_android_sms_pairing_state_tracker_.get(),
- fake_gcm_device_info_provider_.get(), is_secondary_user_);
- }
- void TearDown() override {
- EligibleHostDevicesProviderImpl::Factory::SetFactoryForTesting(nullptr);
- HostBackendDelegateImpl::Factory::SetFactoryForTesting(nullptr);
- HostVerifierImpl::Factory::SetFactoryForTesting(nullptr);
- HostStatusProviderImpl::Factory::SetFactoryForTesting(nullptr);
- GrandfatheredEasyUnlockHostDisabler::Factory::SetFactoryForTesting(nullptr);
- FeatureStateManagerImpl::Factory::SetFactoryForTesting(nullptr);
- HostDeviceTimestampManagerImpl::Factory::SetFactoryForTesting(nullptr);
- AccountStatusChangeDelegateNotifierImpl::Factory::SetFactoryForTesting(
- nullptr);
- AndroidSmsAppInstallingStatusObserver::Factory::SetFactoryForTesting(
- nullptr);
- GlobalStateFeatureManagerImpl::Factory::SetFactoryForTesting(nullptr);
- WifiSyncNotificationController::Factory::SetFactoryForTesting(nullptr);
- }
- bool IsV1DeviceSyncEnabled() { return GetParam(); }
- void CallSetAccountStatusChangeDelegate() {
- EXPECT_FALSE(fake_account_status_change_delegate_);
- fake_account_status_change_delegate_ =
- std::make_unique<FakeAccountStatusChangeDelegate>();
- EXPECT_FALSE(fake_account_status_change_delegate_notifier()->delegate());
- multidevice_setup_->SetAccountStatusChangeDelegate(
- fake_account_status_change_delegate_->GenerateRemote());
- EXPECT_TRUE(fake_account_status_change_delegate_notifier()->delegate());
- }
- multidevice::RemoteDeviceList CallGetEligibleHostDevices() {
- base::RunLoop run_loop;
- multidevice_setup_->GetEligibleHostDevices(
- base::BindOnce(&MultiDeviceSetupImplTest::OnEligibleDevicesFetched,
- base::Unretained(this), run_loop.QuitClosure()));
- run_loop.Run();
- multidevice::RemoteDeviceList eligible_devices_list =
- *last_eligible_devices_list_;
- last_eligible_devices_list_.reset();
- return eligible_devices_list;
- }
- std::vector<mojom::HostDevicePtr> CallGetEligibleActiveHostDevices() {
- base::RunLoop run_loop;
- multidevice_setup_->GetEligibleActiveHostDevices(base::BindOnce(
- &MultiDeviceSetupImplTest::OnEligibleActiveHostDevicesFetched,
- base::Unretained(this), run_loop.QuitClosure()));
- run_loop.Run();
- std::vector<mojom::HostDevicePtr> eligible_devices_list =
- std::move(*last_eligible_active_devices_list_);
- last_eligible_active_devices_list_.reset();
- return eligible_devices_list;
- }
- bool CallSetHostDevice(
- const std::string& host_instance_id_or_legacy_device_id,
- const std::string& auth_token) {
- base::RunLoop run_loop;
- multidevice_setup_->SetHostDevice(
- host_instance_id_or_legacy_device_id, auth_token,
- base::BindOnce(&MultiDeviceSetupImplTest::OnSetHostDeviceResult,
- base::Unretained(this), run_loop.QuitClosure()));
- run_loop.Run();
- bool success = *last_set_host_success_;
- last_set_host_success_.reset();
- return success;
- }
- bool CallSetHostDeviceWithoutAuth(
- const std::string& host_instance_id_or_legacy_device_id) {
- base::RunLoop run_loop;
- multidevice_setup_->SetHostDeviceWithoutAuthToken(
- host_instance_id_or_legacy_device_id,
- base::BindOnce(
- &MultiDeviceSetupImplTest::OnSetHostDeviceWithoutAuthResult,
- base::Unretained(this), run_loop.QuitClosure()));
- run_loop.Run();
- bool success = *last_set_host_without_auth_success_;
- last_set_host_without_auth_success_.reset();
- return success;
- }
- std::pair<mojom::HostStatus, absl::optional<multidevice::RemoteDevice>>
- CallGetHostStatus() {
- base::RunLoop run_loop;
- multidevice_setup_->GetHostStatus(
- base::BindOnce(&MultiDeviceSetupImplTest::OnHostStatusReceived,
- base::Unretained(this), run_loop.QuitClosure()));
- run_loop.Run();
- std::pair<mojom::HostStatus, absl::optional<multidevice::RemoteDevice>>
- host_status_update = *last_host_status_;
- last_host_status_.reset();
- return host_status_update;
- }
- bool CallSetFeatureEnabledState(
- mojom::Feature feature,
- bool enabled,
- const absl::optional<std::string>& auth_token) {
- base::RunLoop run_loop;
- multidevice_setup_->SetFeatureEnabledState(
- feature, enabled, auth_token,
- base::BindOnce(&MultiDeviceSetupImplTest::OnSetFeatureEnabled,
- base::Unretained(this), run_loop.QuitClosure()));
- run_loop.Run();
- bool success = *last_set_feature_enabled_state_success_;
- last_set_feature_enabled_state_success_.reset();
- return success;
- }
- base::flat_map<mojom::Feature, mojom::FeatureState> CallGetFeatureStates() {
- base::RunLoop run_loop;
- multidevice_setup_->GetFeatureStates(
- base::BindOnce(&MultiDeviceSetupImplTest::OnGetFeatureStates,
- base::Unretained(this), run_loop.QuitClosure()));
- run_loop.Run();
- base::flat_map<mojom::Feature, mojom::FeatureState> feature_states_map =
- *last_get_feature_states_result_;
- last_get_feature_states_result_.reset();
- return feature_states_map;
- }
- bool CallRetrySetHostNow() {
- base::RunLoop run_loop;
- multidevice_setup_->RetrySetHostNow(
- base::BindOnce(&MultiDeviceSetupImplTest::OnHostRetried,
- base::Unretained(this), run_loop.QuitClosure()));
- run_loop.Run();
- bool success = *last_retry_success_;
- last_retry_success_.reset();
- return success;
- }
- bool CallTriggerEventForDebugging(mojom::EventTypeForDebugging type) {
- base::RunLoop run_loop;
- multidevice_setup_->TriggerEventForDebugging(
- type, base::BindOnce(&MultiDeviceSetupImplTest::OnDebugEventTriggered,
- base::Unretained(this), run_loop.QuitClosure()));
- run_loop.Run();
- bool success = *last_debug_event_success_;
- last_debug_event_success_.reset();
- // If the delegate was set, fire off any pending Mojo messages.
- if (success)
- fake_account_status_change_delegate_notifier()->FlushForTesting();
- return success;
- }
- void VerifyCurrentHostStatus(
- mojom::HostStatus host_status,
- const absl::optional<multidevice::RemoteDeviceRef>& host_device,
- FakeHostStatusObserver* observer = nullptr,
- size_t expected_observer_index = 0u) {
- std::pair<mojom::HostStatus, absl::optional<multidevice::RemoteDevice>>
- host_status_and_device = CallGetHostStatus();
- EXPECT_EQ(host_status, host_status_and_device.first);
- EXPECT_EQ(RefToRaw(host_device), host_status_and_device.second);
- if (!observer)
- return;
- EXPECT_EQ(host_status,
- observer->host_status_updates()[expected_observer_index].first);
- EXPECT_EQ(RefToRaw(host_device),
- observer->host_status_updates()[expected_observer_index].second);
- }
- void SendPendingObserverMessages() {
- MultiDeviceSetupImpl* derived_ptr =
- static_cast<MultiDeviceSetupImpl*>(multidevice_setup_.get());
- derived_ptr->FlushForTesting();
- }
- FakeAccountStatusChangeDelegate* fake_account_status_change_delegate() {
- return fake_account_status_change_delegate_.get();
- }
- FakeEligibleHostDevicesProvider* fake_eligible_host_devices_provider() {
- return fake_eligible_host_devices_provider_factory_->instance();
- }
- FakeHostBackendDelegate* fake_host_backend_delegate() {
- return fake_host_backend_delegate_factory_->instance();
- }
- FakeHostVerifier* fake_host_verifier() {
- return fake_host_verifier_factory_->instance();
- }
- FakeHostStatusProvider* fake_host_status_provider() {
- return fake_host_status_provider_factory_->instance();
- }
- FakeFeatureStateManager* fake_feature_state_manager() {
- return fake_feature_state_manager_factory_->instance();
- }
- FakeHostDeviceTimestampManager* fake_host_device_timestamp_manager() {
- return fake_host_device_timestamp_manager_factory_->instance();
- }
- FakeAccountStatusChangeDelegateNotifier*
- fake_account_status_change_delegate_notifier() {
- return fake_account_status_change_delegate_notifier_factory_->instance();
- }
- multidevice::RemoteDeviceRefList& test_devices() { return test_devices_; }
- MultiDeviceSetupBase* multidevice_setup() { return multidevice_setup_.get(); }
- private:
- void SetDeviceSyncFeatureFlags(bool use_v1) {
- std::vector<base::Feature> enabled_features;
- std::vector<base::Feature> disabled_features;
- // These flags have no direct effect; however, v2 Enrollment and v2
- // DeviceSync are prerequisites for disabling v1 DeviceSync.
- enabled_features.push_back(chromeos::features::kCryptAuthV2Enrollment);
- enabled_features.push_back(chromeos::features::kCryptAuthV2DeviceSync);
- if (use_v1) {
- disabled_features.push_back(
- chromeos::features::kDisableCryptAuthV1DeviceSync);
- } else {
- enabled_features.push_back(
- chromeos::features::kDisableCryptAuthV1DeviceSync);
- }
- scoped_feature_list_.InitWithFeatures(enabled_features, disabled_features);
- }
- void OnEligibleDevicesFetched(
- base::OnceClosure quit_closure,
- const multidevice::RemoteDeviceList& eligible_devices_list) {
- EXPECT_FALSE(last_eligible_devices_list_);
- last_eligible_devices_list_ = eligible_devices_list;
- std::move(quit_closure).Run();
- }
- void OnEligibleActiveHostDevicesFetched(
- base::OnceClosure quit_closure,
- std::vector<mojom::HostDevicePtr> eligible_active_devices_list) {
- EXPECT_FALSE(last_eligible_active_devices_list_);
- last_eligible_active_devices_list_ =
- std::move(eligible_active_devices_list);
- std::move(quit_closure).Run();
- }
- void OnSetHostDeviceResult(base::OnceClosure quit_closure, bool success) {
- EXPECT_FALSE(last_set_host_success_);
- last_set_host_success_ = success;
- std::move(quit_closure).Run();
- }
- void OnSetHostDeviceWithoutAuthResult(base::OnceClosure quit_closure,
- bool success) {
- EXPECT_FALSE(last_set_host_without_auth_success_);
- last_set_host_without_auth_success_ = success;
- std::move(quit_closure).Run();
- }
- void OnHostStatusReceived(
- base::OnceClosure quit_closure,
- mojom::HostStatus host_status,
- const absl::optional<multidevice::RemoteDevice>& host_device) {
- EXPECT_FALSE(last_host_status_);
- last_host_status_ = std::make_pair(host_status, host_device);
- std::move(quit_closure).Run();
- }
- void OnSetFeatureEnabled(base::OnceClosure quit_closure, bool success) {
- EXPECT_FALSE(last_set_feature_enabled_state_success_);
- last_set_feature_enabled_state_success_ = success;
- std::move(quit_closure).Run();
- }
- void OnGetFeatureStates(
- base::OnceClosure quit_closure,
- const base::flat_map<mojom::Feature, mojom::FeatureState>&
- feature_states_map) {
- EXPECT_FALSE(last_get_feature_states_result_);
- last_get_feature_states_result_ = feature_states_map;
- std::move(quit_closure).Run();
- }
- void OnHostRetried(base::OnceClosure quit_closure, bool success) {
- EXPECT_FALSE(last_retry_success_);
- last_retry_success_ = success;
- std::move(quit_closure).Run();
- }
- void OnDebugEventTriggered(base::OnceClosure quit_closure, bool success) {
- EXPECT_FALSE(last_debug_event_success_);
- last_debug_event_success_ = success;
- std::move(quit_closure).Run();
- }
- base::test::TaskEnvironment task_environment_;
- multidevice::RemoteDeviceRefList test_devices_;
- std::unique_ptr<sync_preferences::TestingPrefServiceSyncable>
- test_pref_service_;
- std::unique_ptr<device_sync::FakeDeviceSyncClient> fake_device_sync_client_;
- std::unique_ptr<FakeAuthTokenValidator> fake_auth_token_validator_;
- std::unique_ptr<OobeCompletionTracker> fake_oobe_completion_tracker_;
- std::unique_ptr<device_sync::FakeGcmDeviceInfoProvider>
- fake_gcm_device_info_provider_;
- bool is_secondary_user_ = false;
- std::unique_ptr<FakeEligibleHostDevicesProviderFactory>
- fake_eligible_host_devices_provider_factory_;
- std::unique_ptr<FakeHostBackendDelegateFactory>
- fake_host_backend_delegate_factory_;
- std::unique_ptr<FakeHostVerifierFactory> fake_host_verifier_factory_;
- std::unique_ptr<FakeHostStatusProviderFactory>
- fake_host_status_provider_factory_;
- std::unique_ptr<FakeGlobalStateFeatureManagerFactory>
- fake_global_state_feature_manager_factory_;
- std::unique_ptr<FakeWifiSyncNotificationControllerFactory>
- fake_wifi_sync_notification_controller_factory_;
- std::unique_ptr<FakeGrandfatheredEasyUnlockHostDisablerFactory>
- fake_grandfathered_easy_unlock_host_disabler_factory_;
- std::unique_ptr<FakeFeatureStateManagerFactory>
- fake_feature_state_manager_factory_;
- std::unique_ptr<FakeHostDeviceTimestampManagerFactory>
- fake_host_device_timestamp_manager_factory_;
- std::unique_ptr<FakeAccountStatusChangeDelegateNotifierFactory>
- fake_account_status_change_delegate_notifier_factory_;
- std::unique_ptr<FakeAndroidSmsAppInstallingStatusObserverFactory>
- fake_android_sms_app_installing_status_observer_factory_;
- std::unique_ptr<FakeAndroidSmsAppHelperDelegate>
- fake_android_sms_app_helper_delegate_;
- std::unique_ptr<FakeAndroidSmsPairingStateTracker>
- fake_android_sms_pairing_state_tracker_;
- std::unique_ptr<FakeAccountStatusChangeDelegate>
- fake_account_status_change_delegate_;
- base::test::ScopedFeatureList scoped_feature_list_;
- absl::optional<bool> last_debug_event_success_;
- absl::optional<multidevice::RemoteDeviceList> last_eligible_devices_list_;
- absl::optional<std::vector<mojom::HostDevicePtr>>
- last_eligible_active_devices_list_;
- absl::optional<bool> last_set_host_success_;
- absl::optional<bool> last_set_host_without_auth_success_;
- absl::optional<
- std::pair<mojom::HostStatus, absl::optional<multidevice::RemoteDevice>>>
- last_host_status_;
- absl::optional<bool> last_set_feature_enabled_state_success_;
- absl::optional<base::flat_map<mojom::Feature, mojom::FeatureState>>
- last_get_feature_states_result_;
- absl::optional<bool> last_retry_success_;
- std::unique_ptr<MultiDeviceSetupBase> multidevice_setup_;
- };
- TEST_P(MultiDeviceSetupImplTest, AccountStatusChangeDelegate) {
- // All requests to trigger debug events should fail before the delegate has
- // been set.
- EXPECT_FALSE(CallTriggerEventForDebugging(
- mojom::EventTypeForDebugging::kNewUserPotentialHostExists));
- EXPECT_FALSE(CallTriggerEventForDebugging(
- mojom::EventTypeForDebugging::kExistingUserConnectedHostSwitched));
- EXPECT_FALSE(CallTriggerEventForDebugging(
- mojom::EventTypeForDebugging::kExistingUserNewChromebookAdded));
- CallSetAccountStatusChangeDelegate();
- // All debug trigger events should now succeed.
- EXPECT_TRUE(CallTriggerEventForDebugging(
- mojom::EventTypeForDebugging::kNewUserPotentialHostExists));
- EXPECT_EQ(1u, fake_account_status_change_delegate()
- ->num_new_user_potential_host_events_handled());
- EXPECT_TRUE(CallTriggerEventForDebugging(
- mojom::EventTypeForDebugging::kExistingUserConnectedHostSwitched));
- EXPECT_EQ(1u, fake_account_status_change_delegate()
- ->num_existing_user_host_switched_events_handled());
- EXPECT_TRUE(CallTriggerEventForDebugging(
- mojom::EventTypeForDebugging::kExistingUserNewChromebookAdded));
- EXPECT_EQ(1u, fake_account_status_change_delegate()
- ->num_existing_user_chromebook_added_events_handled());
- }
- // The feature mojom::Feature::kInstantTethering is used throughout this test
- // because it never requires authentication for either enabling or disabling.
- TEST_P(MultiDeviceSetupImplTest, FeatureStateChanges_NoAuthTokenRequired) {
- auto observer = std::make_unique<FakeFeatureStateObserver>();
- multidevice_setup()->AddFeatureStateObserver(observer->GenerateRemote());
- EXPECT_EQ(mojom::FeatureState::kUnavailableNoVerifiedHost_NoEligibleHosts,
- CallGetFeatureStates()[mojom::Feature::kInstantTethering]);
- fake_feature_state_manager()->SetFeatureState(
- mojom::Feature::kInstantTethering,
- mojom::FeatureState::kNotSupportedByChromebook);
- SendPendingObserverMessages();
- EXPECT_EQ(mojom::FeatureState::kNotSupportedByChromebook,
- CallGetFeatureStates()[mojom::Feature::kInstantTethering]);
- EXPECT_EQ(1u, observer->feature_state_updates().size());
- fake_feature_state_manager()->SetFeatureState(
- mojom::Feature::kInstantTethering, mojom::FeatureState::kEnabledByUser);
- SendPendingObserverMessages();
- EXPECT_EQ(mojom::FeatureState::kEnabledByUser,
- CallGetFeatureStates()[mojom::Feature::kInstantTethering]);
- EXPECT_EQ(2u, observer->feature_state_updates().size());
- EXPECT_TRUE(CallSetFeatureEnabledState(mojom::Feature::kInstantTethering,
- false /* enabled */,
- absl::nullopt /* auth_token */));
- SendPendingObserverMessages();
- EXPECT_EQ(mojom::FeatureState::kDisabledByUser,
- CallGetFeatureStates()[mojom::Feature::kInstantTethering]);
- EXPECT_EQ(3u, observer->feature_state_updates().size());
- }
- // mojom::Feature::kSmartLock requires authentication when attempting to enable.
- TEST_P(MultiDeviceSetupImplTest,
- FeatureStateChanges_AuthTokenRequired_SmartLock) {
- auto observer = std::make_unique<FakeFeatureStateObserver>();
- multidevice_setup()->AddFeatureStateObserver(observer->GenerateRemote());
- EXPECT_EQ(mojom::FeatureState::kUnavailableNoVerifiedHost_NoEligibleHosts,
- CallGetFeatureStates()[mojom::Feature::kSmartLock]);
- fake_feature_state_manager()->SetFeatureState(
- mojom::Feature::kSmartLock, mojom::FeatureState::kEnabledByUser);
- SendPendingObserverMessages();
- EXPECT_EQ(mojom::FeatureState::kEnabledByUser,
- CallGetFeatureStates()[mojom::Feature::kSmartLock]);
- EXPECT_EQ(1u, observer->feature_state_updates().size());
- // No authentication is required to disable the feature.
- EXPECT_TRUE(CallSetFeatureEnabledState(mojom::Feature::kSmartLock,
- false /* enabled */,
- absl::nullopt /* auth_token */));
- SendPendingObserverMessages();
- EXPECT_EQ(mojom::FeatureState::kDisabledByUser,
- CallGetFeatureStates()[mojom::Feature::kSmartLock]);
- EXPECT_EQ(2u, observer->feature_state_updates().size());
- // However, authentication is required to enable the feature.
- EXPECT_FALSE(CallSetFeatureEnabledState(
- mojom::Feature::kSmartLock, true /* enabled */, "invalidAuthToken"));
- SendPendingObserverMessages();
- EXPECT_EQ(mojom::FeatureState::kDisabledByUser,
- CallGetFeatureStates()[mojom::Feature::kSmartLock]);
- EXPECT_EQ(2u, observer->feature_state_updates().size());
- // Now, send a valid auth token; it should successfully enable.
- EXPECT_TRUE(CallSetFeatureEnabledState(mojom::Feature::kSmartLock,
- true /* enabled */, kValidAuthToken));
- SendPendingObserverMessages();
- EXPECT_EQ(mojom::FeatureState::kEnabledByUser,
- CallGetFeatureStates()[mojom::Feature::kSmartLock]);
- EXPECT_EQ(3u, observer->feature_state_updates().size());
- }
- // mojom::Feature::kBetterTogetherSuite requires authentication when attempting
- // to enable, but only if the Smart Lock pref is enabled.
- TEST_P(MultiDeviceSetupImplTest,
- FeatureStateChanges_AuthTokenRequired_BetterTogetherSuite) {
- auto observer = std::make_unique<FakeFeatureStateObserver>();
- multidevice_setup()->AddFeatureStateObserver(observer->GenerateRemote());
- EXPECT_EQ(mojom::FeatureState::kUnavailableNoVerifiedHost_NoEligibleHosts,
- CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
- fake_feature_state_manager()->SetFeatureState(
- mojom::Feature::kBetterTogetherSuite,
- mojom::FeatureState::kEnabledByUser);
- SendPendingObserverMessages();
- EXPECT_EQ(mojom::FeatureState::kEnabledByUser,
- CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
- EXPECT_EQ(1u, observer->feature_state_updates().size());
- // No authentication is required to disable the feature.
- EXPECT_TRUE(CallSetFeatureEnabledState(mojom::Feature::kBetterTogetherSuite,
- false /* enabled */,
- absl::nullopt /* auth_token */));
- SendPendingObserverMessages();
- EXPECT_EQ(mojom::FeatureState::kDisabledByUser,
- CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
- EXPECT_EQ(2u, observer->feature_state_updates().size());
- // Authentication is required to enable the feature if SmartLock's state is
- // kUnavailableInsufficientSecurity.
- fake_feature_state_manager()->SetFeatureState(
- mojom::Feature::kSmartLock,
- mojom::FeatureState::kUnavailableInsufficientSecurity);
- EXPECT_FALSE(CallSetFeatureEnabledState(mojom::Feature::kBetterTogetherSuite,
- true /* enabled */,
- "invalidAuthToken"));
- SendPendingObserverMessages();
- EXPECT_EQ(mojom::FeatureState::kDisabledByUser,
- CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
- EXPECT_EQ(3u, observer->feature_state_updates().size());
- // Now, send a valid auth token; it should successfully enable.
- EXPECT_TRUE(CallSetFeatureEnabledState(mojom::Feature::kBetterTogetherSuite,
- true /* enabled */, kValidAuthToken));
- SendPendingObserverMessages();
- EXPECT_EQ(mojom::FeatureState::kEnabledByUser,
- CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
- EXPECT_EQ(4u, observer->feature_state_updates().size());
- // Disable one more time.
- EXPECT_TRUE(CallSetFeatureEnabledState(mojom::Feature::kBetterTogetherSuite,
- false /* enabled */,
- absl::nullopt /* auth_token */));
- SendPendingObserverMessages();
- EXPECT_EQ(mojom::FeatureState::kDisabledByUser,
- CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
- EXPECT_EQ(5u, observer->feature_state_updates().size());
- // Authentication is required to enable the feature if SmartLock's state is
- // kUnavailableSuiteDisabled.
- fake_feature_state_manager()->SetFeatureState(
- mojom::Feature::kSmartLock,
- mojom::FeatureState::kUnavailableSuiteDisabled);
- EXPECT_FALSE(CallSetFeatureEnabledState(mojom::Feature::kBetterTogetherSuite,
- true /* enabled */,
- "invalidAuthToken"));
- SendPendingObserverMessages();
- EXPECT_EQ(mojom::FeatureState::kDisabledByUser,
- CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
- EXPECT_EQ(6u, observer->feature_state_updates().size());
- // Now, send a valid auth token; it should successfully enable.
- EXPECT_TRUE(CallSetFeatureEnabledState(mojom::Feature::kBetterTogetherSuite,
- true /* enabled */, kValidAuthToken));
- SendPendingObserverMessages();
- EXPECT_EQ(mojom::FeatureState::kEnabledByUser,
- CallGetFeatureStates()[mojom::Feature::kBetterTogetherSuite]);
- EXPECT_EQ(7u, observer->feature_state_updates().size());
- }
- TEST_P(MultiDeviceSetupImplTest, ComprehensiveHostTest) {
- // Start with no eligible devices.
- EXPECT_TRUE(CallGetEligibleHostDevices().empty());
- VerifyCurrentHostStatus(mojom::HostStatus::kNoEligibleHosts,
- absl::nullopt /* host_device */);
- // Cannot retry without a host.
- EXPECT_FALSE(CallRetrySetHostNow());
- // Add a status observer.
- auto observer = std::make_unique<FakeHostStatusObserver>();
- multidevice_setup()->AddHostStatusObserver(observer->GenerateRemote());
- // Simulate a sync occurring; now, all of the test devices are eligible hosts.
- fake_eligible_host_devices_provider()->set_eligible_host_devices(
- test_devices());
- EXPECT_EQ(RefListToRawList(test_devices()), CallGetEligibleHostDevices());
- fake_host_status_provider()->SetHostWithStatus(
- mojom::HostStatus::kEligibleHostExistsButNoHostSet,
- absl::nullopt /* host_device */);
- SendPendingObserverMessages();
- VerifyCurrentHostStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet,
- absl::nullopt /* host_device */, observer.get(),
- 0u /* expected_observer_index */);
- // There are eligible hosts, but none is set; thus, cannot retry.
- EXPECT_FALSE(CallRetrySetHostNow());
- // Set an invalid host as the host device; this should fail.
- EXPECT_FALSE(CallSetHostDevice("invalidHostDeviceId", kValidAuthToken));
- EXPECT_FALSE(fake_host_backend_delegate()->HasPendingHostRequest());
- // Set device 0 as the host; this should succeed.
- std::string host_id = IsV1DeviceSyncEnabled()
- ? test_devices()[0].GetDeviceId()
- : test_devices()[0].instance_id();
- EXPECT_TRUE(CallSetHostDevice(host_id, kValidAuthToken));
- EXPECT_TRUE(fake_host_backend_delegate()->HasPendingHostRequest());
- EXPECT_EQ(test_devices()[0],
- fake_host_backend_delegate()->GetPendingHostRequest());
- fake_host_status_provider()->SetHostWithStatus(
- mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
- test_devices()[0]);
- SendPendingObserverMessages();
- VerifyCurrentHostStatus(
- mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
- test_devices()[0], observer.get(), 1u /* expected_observer_index */);
- // It should now be possible to retry.
- EXPECT_TRUE(CallRetrySetHostNow());
- // Simulate the retry succeeding and the host being set on the back-end.
- fake_host_backend_delegate()->NotifyHostChangedOnBackend(test_devices()[0]);
- fake_host_status_provider()->SetHostWithStatus(
- mojom::HostStatus::kHostSetButNotYetVerified, test_devices()[0]);
- SendPendingObserverMessages();
- VerifyCurrentHostStatus(mojom::HostStatus::kHostSetButNotYetVerified,
- test_devices()[0], observer.get(),
- 2u /* expected_observer_index */);
- // It should still be possible to retry (this time, retrying verification).
- EXPECT_TRUE(CallRetrySetHostNow());
- // Simulate verification succeeding.
- fake_host_verifier()->set_is_host_verified(true);
- fake_host_status_provider()->SetHostWithStatus(
- mojom::HostStatus::kHostVerified, test_devices()[0]);
- SendPendingObserverMessages();
- VerifyCurrentHostStatus(mojom::HostStatus::kHostVerified, test_devices()[0],
- observer.get(), 3u /* expected_observer_index */);
- // Remove the host.
- multidevice_setup()->RemoveHostDevice();
- fake_host_verifier()->set_is_host_verified(false);
- fake_host_status_provider()->SetHostWithStatus(
- mojom::HostStatus::kEligibleHostExistsButNoHostSet,
- absl::nullopt /* host_device */);
- SendPendingObserverMessages();
- VerifyCurrentHostStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet,
- absl::nullopt /* host_device */, observer.get(),
- 4u /* expected_observer_index */);
- // Simulate the host being removed on the back-end.
- fake_host_backend_delegate()->NotifyHostChangedOnBackend(absl::nullopt);
- }
- TEST_P(MultiDeviceSetupImplTest, TestGetEligibleActiveHosts) {
- // Start with no eligible devices.
- EXPECT_TRUE(CallGetEligibleActiveHostDevices().empty());
- multidevice::DeviceWithConnectivityStatusList host_device_list;
- for (auto remote_device_ref : test_devices()) {
- host_device_list.emplace_back(multidevice::DeviceWithConnectivityStatus(
- remote_device_ref, cryptauthv2::ConnectivityStatus::ONLINE));
- }
- // Simulate a sync occurring; now, all of the test devices are eligible hosts.
- fake_eligible_host_devices_provider()->set_eligible_active_host_devices(
- host_device_list);
- std::vector<mojom::HostDevicePtr> result_hosts =
- CallGetEligibleActiveHostDevices();
- for (size_t i = 0; i < kNumTestDevices; i++) {
- EXPECT_EQ(*GetMutableRemoteDevice(test_devices()[i]),
- result_hosts[i]->remote_device);
- EXPECT_EQ(cryptauthv2::ConnectivityStatus::ONLINE,
- result_hosts[i]->connectivity_status);
- }
- }
- TEST_P(MultiDeviceSetupImplTest, TestSetHostDevice_InvalidAuthToken) {
- // Start valid eligible host devices.
- fake_eligible_host_devices_provider()->set_eligible_host_devices(
- test_devices());
- EXPECT_EQ(RefListToRawList(test_devices()), CallGetEligibleHostDevices());
- fake_host_status_provider()->SetHostWithStatus(
- mojom::HostStatus::kEligibleHostExistsButNoHostSet,
- absl::nullopt /* host_device */);
- // Set a valid host as the host device, but pass an invalid token.
- std::string host_id = IsV1DeviceSyncEnabled()
- ? test_devices()[0].GetDeviceId()
- : test_devices()[0].instance_id();
- EXPECT_FALSE(CallSetHostDevice(host_id, "invalidAuthToken"));
- EXPECT_FALSE(fake_host_backend_delegate()->HasPendingHostRequest());
- }
- TEST_P(MultiDeviceSetupImplTest, TestSetHostDeviceWithoutAuthToken) {
- // Add a status observer.
- auto observer = std::make_unique<FakeHostStatusObserver>();
- multidevice_setup()->AddHostStatusObserver(observer->GenerateRemote());
- // Start valid eligible host devices.
- fake_eligible_host_devices_provider()->set_eligible_host_devices(
- test_devices());
- EXPECT_EQ(RefListToRawList(test_devices()), CallGetEligibleHostDevices());
- fake_host_status_provider()->SetHostWithStatus(
- mojom::HostStatus::kEligibleHostExistsButNoHostSet,
- absl::nullopt /* host_device */);
- SendPendingObserverMessages();
- VerifyCurrentHostStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet,
- absl::nullopt /* host_device */, observer.get(),
- 0u /* expected_observer_index */);
- // Set a valid host as the host device without an auth token.
- std::string host_id = IsV1DeviceSyncEnabled()
- ? test_devices()[0].GetDeviceId()
- : test_devices()[0].instance_id();
- EXPECT_TRUE(CallSetHostDeviceWithoutAuth(host_id));
- EXPECT_TRUE(fake_host_backend_delegate()->HasPendingHostRequest());
- EXPECT_EQ(test_devices()[0],
- fake_host_backend_delegate()->GetPendingHostRequest());
- fake_host_status_provider()->SetHostWithStatus(
- mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
- test_devices()[0]);
- SendPendingObserverMessages();
- VerifyCurrentHostStatus(
- mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
- test_devices()[0], observer.get(), 1u /* expected_observer_index */);
- }
- TEST_P(MultiDeviceSetupImplTest,
- TestSetHostDevice_AcceptInstanceIdOrLegacyDeviceId) {
- // We can set the host using the legacy device ID or the Instance ID if and
- // only if v1 DeviceSync is enabled.
- if (!IsV1DeviceSyncEnabled())
- return;
- // Add a status observer.
- auto observer = std::make_unique<FakeHostStatusObserver>();
- multidevice_setup()->AddHostStatusObserver(observer->GenerateRemote());
- // Start valid eligible host devices.
- fake_eligible_host_devices_provider()->set_eligible_host_devices(
- test_devices());
- EXPECT_EQ(RefListToRawList(test_devices()), CallGetEligibleHostDevices());
- fake_host_status_provider()->SetHostWithStatus(
- mojom::HostStatus::kEligibleHostExistsButNoHostSet,
- absl::nullopt /* host_device */);
- SendPendingObserverMessages();
- VerifyCurrentHostStatus(mojom::HostStatus::kEligibleHostExistsButNoHostSet,
- absl::nullopt /* host_device */, observer.get(),
- 0u /* expected_observer_index */);
- // Set the host device using its legacy device ID.
- EXPECT_TRUE(
- CallSetHostDevice(test_devices()[0].GetDeviceId(), kValidAuthToken));
- EXPECT_TRUE(fake_host_backend_delegate()->HasPendingHostRequest());
- EXPECT_EQ(test_devices()[0],
- fake_host_backend_delegate()->GetPendingHostRequest());
- fake_host_status_provider()->SetHostWithStatus(
- mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
- test_devices()[0]);
- SendPendingObserverMessages();
- VerifyCurrentHostStatus(
- mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
- test_devices()[0], observer.get(), 1u /* expected_observer_index */);
- // Set the host device using its Instance ID.
- EXPECT_TRUE(
- CallSetHostDevice(test_devices()[1].instance_id(), kValidAuthToken));
- EXPECT_TRUE(fake_host_backend_delegate()->HasPendingHostRequest());
- EXPECT_EQ(test_devices()[1],
- fake_host_backend_delegate()->GetPendingHostRequest());
- fake_host_status_provider()->SetHostWithStatus(
- mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
- test_devices()[1]);
- SendPendingObserverMessages();
- VerifyCurrentHostStatus(
- mojom::HostStatus::kHostSetLocallyButWaitingForBackendConfirmation,
- test_devices()[1], observer.get(), 2u /* expected_observer_index */);
- }
- // Runs tests twice; once with v1 DeviceSync enabled and once with it disabled.
- // TODO(https://crbug.com/1019206): Remove when v1 DeviceSync is disabled,
- // when all devices should have an Instance ID.
- INSTANTIATE_TEST_SUITE_P(All, MultiDeviceSetupImplTest, ::testing::Bool());
- } // namespace multidevice_setup
- } // namespace ash
|