sync_user_settings_impl_unittest.cc 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389
  1. // Copyright 2019 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "components/sync/driver/sync_user_settings_impl.h"
  5. #include <memory>
  6. #include "base/callback.h"
  7. #include "base/callback_helpers.h"
  8. #include "base/test/scoped_feature_list.h"
  9. #include "build/chromeos_buildflags.h"
  10. #include "components/prefs/pref_registry_simple.h"
  11. #include "components/prefs/testing_pref_service.h"
  12. #include "components/sync/base/features.h"
  13. #include "components/sync/base/model_type.h"
  14. #include "components/sync/base/pref_names.h"
  15. #include "components/sync/base/sync_prefs.h"
  16. #include "components/sync/base/user_selectable_type.h"
  17. #include "components/sync/driver/sync_service_crypto.h"
  18. #include "components/sync/engine/configure_reason.h"
  19. #include "testing/gmock/include/gmock/gmock.h"
  20. #include "testing/gtest/include/gtest/gtest.h"
  21. #if BUILDFLAG(IS_CHROMEOS_ASH)
  22. #include "ash/constants/ash_features.h"
  23. #endif
  24. namespace syncer {
  25. namespace {
  26. ModelTypeSet GetUserTypes() {
  27. ModelTypeSet user_types = UserTypes();
  28. #if BUILDFLAG(IS_CHROMEOS_ASH)
  29. // These types only exist when SyncSettingsCategorization is enabled.
  30. if (!chromeos::features::IsSyncSettingsCategorizationEnabled()) {
  31. user_types.RemoveAll(
  32. {OS_PREFERENCES, OS_PRIORITY_PREFERENCES, WIFI_CONFIGURATIONS});
  33. }
  34. #else
  35. // Ignore all Chrome OS types on non-Chrome OS platforms.
  36. user_types.RemoveAll(
  37. {APP_LIST, ARC_PACKAGE, OS_PREFERENCES, OS_PRIORITY_PREFERENCES, PRINTERS,
  38. PRINTERS_AUTHORIZATION_SERVERS, WIFI_CONFIGURATIONS, WORKSPACE_DESK});
  39. #endif
  40. return user_types;
  41. }
  42. ModelTypeSet GetPreferredUserTypes(
  43. const SyncUserSettingsImpl& sync_user_settings) {
  44. return Intersection(UserTypes(), sync_user_settings.GetPreferredDataTypes());
  45. }
  46. class MockSyncServiceCryptoDelegate : public SyncServiceCrypto::Delegate {
  47. public:
  48. MockSyncServiceCryptoDelegate() = default;
  49. ~MockSyncServiceCryptoDelegate() override = default;
  50. MOCK_METHOD(void, CryptoStateChanged, (), (override));
  51. MOCK_METHOD(void, CryptoRequiredUserActionChanged, (), (override));
  52. MOCK_METHOD(void, ReconfigureDataTypesDueToCrypto, (), (override));
  53. MOCK_METHOD(void,
  54. SetEncryptionBootstrapToken,
  55. (const std::string&),
  56. (override));
  57. MOCK_METHOD(std::string, GetEncryptionBootstrapToken, (), (override));
  58. };
  59. class SyncUserSettingsImplTest : public testing::Test {
  60. protected:
  61. SyncUserSettingsImplTest() {
  62. SyncPrefs::RegisterProfilePrefs(pref_service_.registry());
  63. sync_prefs_ = std::make_unique<SyncPrefs>(&pref_service_);
  64. sync_service_crypto_ =
  65. std::make_unique<SyncServiceCrypto>(&sync_service_crypto_delegate_,
  66. /*trusted_vault_client=*/nullptr);
  67. }
  68. std::unique_ptr<SyncUserSettingsImpl> MakeSyncUserSettings(
  69. ModelTypeSet registered_types) {
  70. return std::make_unique<SyncUserSettingsImpl>(
  71. sync_service_crypto_.get(), sync_prefs_.get(),
  72. /*preference_provider=*/nullptr, registered_types);
  73. }
  74. // The order of fields matters because it determines destruction order and
  75. // fields are dependent.
  76. TestingPrefServiceSimple pref_service_;
  77. std::unique_ptr<SyncPrefs> sync_prefs_;
  78. testing::NiceMock<MockSyncServiceCryptoDelegate>
  79. sync_service_crypto_delegate_;
  80. std::unique_ptr<SyncServiceCrypto> sync_service_crypto_;
  81. };
  82. TEST_F(SyncUserSettingsImplTest, PreferredTypesSyncEverything) {
  83. std::unique_ptr<SyncUserSettingsImpl> sync_user_settings =
  84. MakeSyncUserSettings(GetUserTypes());
  85. ModelTypeSet expected_types = GetUserTypes();
  86. EXPECT_TRUE(sync_user_settings->IsSyncEverythingEnabled());
  87. EXPECT_EQ(expected_types, GetPreferredUserTypes(*sync_user_settings));
  88. UserSelectableTypeSet all_registered_types =
  89. sync_user_settings->GetRegisteredSelectableTypes();
  90. for (UserSelectableType type : all_registered_types) {
  91. sync_user_settings->SetSelectedTypes(/*sync_everything=*/true,
  92. /*selected_type=*/{type});
  93. EXPECT_EQ(expected_types, GetPreferredUserTypes(*sync_user_settings));
  94. }
  95. }
  96. #if BUILDFLAG(IS_CHROMEOS_ASH)
  97. TEST_F(SyncUserSettingsImplTest, PreferredTypesSyncAllOsTypes) {
  98. base::test::ScopedFeatureList feature_list;
  99. feature_list.InitAndEnableFeature(
  100. chromeos::features::kSyncSettingsCategorization);
  101. std::unique_ptr<SyncUserSettingsImpl> sync_user_settings =
  102. MakeSyncUserSettings(GetUserTypes());
  103. EXPECT_TRUE(sync_user_settings->IsSyncAllOsTypesEnabled());
  104. EXPECT_EQ(GetUserTypes(), GetPreferredUserTypes(*sync_user_settings));
  105. for (UserSelectableOsType type : UserSelectableOsTypeSet::All()) {
  106. sync_user_settings->SetSelectedOsTypes(/*sync_all_os_types=*/true,
  107. /*selected_types=*/{type});
  108. EXPECT_EQ(GetUserTypes(), GetPreferredUserTypes(*sync_user_settings));
  109. }
  110. }
  111. #endif // BUILDFLAG(IS_CHROMEOS_ASH)
  112. TEST_F(SyncUserSettingsImplTest, PreferredTypesNotKeepEverythingSynced) {
  113. std::unique_ptr<SyncUserSettingsImpl> sync_user_settings =
  114. MakeSyncUserSettings(GetUserTypes());
  115. sync_user_settings->SetSelectedTypes(
  116. /*sync_everything=*/false,
  117. /*selected_types=*/UserSelectableTypeSet());
  118. #if BUILDFLAG(IS_CHROMEOS_ASH)
  119. if (chromeos::features::IsSyncSettingsCategorizationEnabled()) {
  120. // GetPreferredUserTypes() returns ModelTypes, which includes both browser
  121. // and OS types. However, this test exercises browser UserSelectableTypes,
  122. // so disable OS selectable types.
  123. sync_user_settings->SetSelectedOsTypes(/*sync_all_os_types=*/false,
  124. UserSelectableOsTypeSet());
  125. }
  126. #endif // BUILDFLAG(IS_CHROMEOS_ASH)
  127. // No user selectable types are enabled, so only the "always preferred" types
  128. // are preferred.
  129. ASSERT_EQ(AlwaysPreferredUserTypes(),
  130. GetPreferredUserTypes(*sync_user_settings));
  131. UserSelectableTypeSet all_registered_types =
  132. sync_user_settings->GetRegisteredSelectableTypes();
  133. for (UserSelectableType type : all_registered_types) {
  134. ModelTypeSet expected_preferred_types =
  135. UserSelectableTypeToAllModelTypes(type);
  136. expected_preferred_types.PutAll(AlwaysPreferredUserTypes());
  137. sync_user_settings->SetSelectedTypes(/*sync_everything=*/false,
  138. /*selected_types=*/{type});
  139. EXPECT_EQ(expected_preferred_types,
  140. GetPreferredUserTypes(*sync_user_settings));
  141. }
  142. }
  143. #if BUILDFLAG(IS_CHROMEOS_ASH)
  144. TEST_F(SyncUserSettingsImplTest, PreferredTypesNotAllOsTypesSynced) {
  145. base::test::ScopedFeatureList feature_list;
  146. feature_list.InitAndEnableFeature(
  147. chromeos::features::kSyncSettingsCategorization);
  148. std::unique_ptr<SyncUserSettingsImpl> sync_user_settings =
  149. MakeSyncUserSettings(GetUserTypes());
  150. sync_user_settings->SetSelectedTypes(
  151. /*sync_everything=*/false,
  152. /*selected_types=*/UserSelectableTypeSet());
  153. sync_user_settings->SetSelectedOsTypes(
  154. /*sync_all_os_types=*/false,
  155. /*selected_types=*/UserSelectableOsTypeSet());
  156. EXPECT_FALSE(sync_user_settings->IsSyncEverythingEnabled());
  157. EXPECT_FALSE(sync_user_settings->IsSyncAllOsTypesEnabled());
  158. EXPECT_EQ(AlwaysPreferredUserTypes(),
  159. GetPreferredUserTypes(*sync_user_settings));
  160. for (UserSelectableOsType type : UserSelectableOsTypeSet::All()) {
  161. ModelTypeSet expected_preferred_types =
  162. UserSelectableOsTypeToAllModelTypes(type);
  163. expected_preferred_types.PutAll(AlwaysPreferredUserTypes());
  164. sync_user_settings->SetSelectedOsTypes(/*sync_all_os_types=*/false,
  165. /*selected_types=*/{type});
  166. EXPECT_EQ(expected_preferred_types,
  167. GetPreferredUserTypes(*sync_user_settings));
  168. }
  169. }
  170. #endif // BUILDFLAG(IS_CHROMEOS_ASH)
  171. // Device info should always be enabled.
  172. TEST_F(SyncUserSettingsImplTest, DeviceInfo) {
  173. std::unique_ptr<SyncUserSettingsImpl> sync_user_settings =
  174. MakeSyncUserSettings(GetUserTypes());
  175. EXPECT_TRUE(sync_user_settings->GetPreferredDataTypes().Has(DEVICE_INFO));
  176. UserSelectableTypeSet all_registered_types =
  177. sync_user_settings->GetRegisteredSelectableTypes();
  178. sync_user_settings->SetSelectedTypes(
  179. /*keep_everything_synced=*/true,
  180. /*selected_types=*/all_registered_types);
  181. EXPECT_TRUE(sync_user_settings->GetPreferredDataTypes().Has(DEVICE_INFO));
  182. sync_user_settings->SetSelectedTypes(
  183. /*keep_everything_synced=*/false,
  184. /*selected_types=*/all_registered_types);
  185. EXPECT_TRUE(sync_user_settings->GetPreferredDataTypes().Has(DEVICE_INFO));
  186. sync_user_settings = MakeSyncUserSettings(ModelTypeSet(DEVICE_INFO));
  187. sync_user_settings->SetSelectedTypes(
  188. /*keep_everything_synced=*/false,
  189. /*selected_types=*/UserSelectableTypeSet());
  190. EXPECT_TRUE(sync_user_settings->GetPreferredDataTypes().Has(DEVICE_INFO));
  191. }
  192. // User Consents should always be enabled.
  193. TEST_F(SyncUserSettingsImplTest, UserConsents) {
  194. std::unique_ptr<SyncUserSettingsImpl> sync_user_settings =
  195. MakeSyncUserSettings(GetUserTypes());
  196. EXPECT_TRUE(sync_user_settings->GetPreferredDataTypes().Has(USER_CONSENTS));
  197. UserSelectableTypeSet all_registered_types =
  198. sync_user_settings->GetRegisteredSelectableTypes();
  199. sync_user_settings->SetSelectedTypes(
  200. /*keep_everything_synced=*/true,
  201. /*selected_types=*/all_registered_types);
  202. EXPECT_TRUE(sync_user_settings->GetPreferredDataTypes().Has(USER_CONSENTS));
  203. sync_user_settings->SetSelectedTypes(
  204. /*keep_everything_synced=*/false,
  205. /*selected_types=*/all_registered_types);
  206. EXPECT_TRUE(sync_user_settings->GetPreferredDataTypes().Has(USER_CONSENTS));
  207. sync_user_settings = MakeSyncUserSettings(ModelTypeSet(USER_CONSENTS));
  208. sync_user_settings->SetSelectedTypes(
  209. /*keep_everything_synced=*/false,
  210. /*selected_types=*/UserSelectableTypeSet());
  211. EXPECT_TRUE(sync_user_settings->GetPreferredDataTypes().Has(USER_CONSENTS));
  212. }
  213. #if BUILDFLAG(IS_CHROMEOS_ASH)
  214. TEST_F(SyncUserSettingsImplTest, AlwaysPreferredTypes_ChromeOS) {
  215. base::test::ScopedFeatureList feature_list;
  216. feature_list.InitAndEnableFeature(
  217. chromeos::features::kSyncSettingsCategorization);
  218. std::unique_ptr<SyncUserSettingsImpl> sync_user_settings =
  219. MakeSyncUserSettings(GetUserTypes());
  220. // Disable all browser types.
  221. sync_user_settings->SetSelectedTypes(
  222. /*keep_everything_synced=*/false,
  223. /*selected_types=*/UserSelectableTypeSet());
  224. // Disable all OS types.
  225. sync_user_settings->SetSelectedOsTypes(
  226. /*sync_all_os_types=*/false,
  227. /*selected_types=*/UserSelectableOsTypeSet());
  228. // Important types are still preferred.
  229. ModelTypeSet preferred_types = sync_user_settings->GetPreferredDataTypes();
  230. EXPECT_TRUE(preferred_types.Has(DEVICE_INFO));
  231. EXPECT_TRUE(preferred_types.Has(USER_CONSENTS));
  232. }
  233. TEST_F(SyncUserSettingsImplTest, AppsAreHandledByOsSettings) {
  234. base::test::ScopedFeatureList feature_list;
  235. feature_list.InitAndEnableFeature(
  236. chromeos::features::kSyncSettingsCategorization);
  237. std::unique_ptr<SyncUserSettingsImpl> settings =
  238. MakeSyncUserSettings(GetUserTypes());
  239. ASSERT_TRUE(settings->IsSyncEverythingEnabled());
  240. ASSERT_TRUE(settings->IsSyncAllOsTypesEnabled());
  241. // App model types are enabled.
  242. EXPECT_TRUE(settings->GetPreferredDataTypes().Has(APP_LIST));
  243. EXPECT_TRUE(settings->GetPreferredDataTypes().Has(APP_SETTINGS));
  244. EXPECT_TRUE(settings->GetPreferredDataTypes().Has(APPS));
  245. EXPECT_TRUE(settings->GetPreferredDataTypes().Has(ARC_PACKAGE));
  246. EXPECT_TRUE(settings->GetPreferredDataTypes().Has(WEB_APPS));
  247. // Disable browser types.
  248. settings->SetSelectedTypes(
  249. /*keep_everything_synced=*/false,
  250. /*selected_types=*/UserSelectableTypeSet());
  251. // App model types are still enabled.
  252. EXPECT_TRUE(settings->GetPreferredDataTypes().Has(APP_LIST));
  253. EXPECT_TRUE(settings->GetPreferredDataTypes().Has(APP_SETTINGS));
  254. EXPECT_TRUE(settings->GetPreferredDataTypes().Has(APPS));
  255. EXPECT_TRUE(settings->GetPreferredDataTypes().Has(ARC_PACKAGE));
  256. EXPECT_TRUE(settings->GetPreferredDataTypes().Has(WEB_APPS));
  257. // Disable OS types.
  258. settings->SetSelectedOsTypes(
  259. /*sync_all_os_types=*/false,
  260. /*selected_types=*/UserSelectableOsTypeSet());
  261. // Apps are disabled.
  262. EXPECT_FALSE(settings->GetPreferredDataTypes().Has(APP_LIST));
  263. EXPECT_FALSE(settings->GetPreferredDataTypes().Has(APP_SETTINGS));
  264. EXPECT_FALSE(settings->GetPreferredDataTypes().Has(APPS));
  265. EXPECT_FALSE(settings->GetPreferredDataTypes().Has(ARC_PACKAGE));
  266. EXPECT_FALSE(settings->GetPreferredDataTypes().Has(WEB_APPS));
  267. }
  268. #endif // BUILDFLAG(IS_CHROMEOS_ASH)
  269. #if BUILDFLAG(IS_CHROMEOS_LACROS)
  270. TEST_F(SyncUserSettingsImplTest, AppsAreHandledByOsSettings) {
  271. base::test::ScopedFeatureList feature_list;
  272. feature_list.InitAndEnableFeature(kSyncChromeOSAppsToggleSharing);
  273. std::unique_ptr<SyncUserSettingsImpl> settings =
  274. MakeSyncUserSettings(GetUserTypes());
  275. ASSERT_TRUE(settings->IsSyncEverythingEnabled());
  276. // App model types are disabled by default, even though "Sync everything" is
  277. // on.
  278. EXPECT_FALSE(settings->GetPreferredDataTypes().Has(APP_SETTINGS));
  279. EXPECT_FALSE(settings->GetPreferredDataTypes().Has(APPS));
  280. EXPECT_FALSE(settings->GetPreferredDataTypes().Has(WEB_APPS));
  281. // Mimic apps toggle enabled in the OS.
  282. settings->SetAppsSyncEnabledByOs(true);
  283. // App model types should become enabled.
  284. EXPECT_TRUE(settings->GetPreferredDataTypes().Has(APP_SETTINGS));
  285. EXPECT_TRUE(settings->GetPreferredDataTypes().Has(APPS));
  286. EXPECT_TRUE(settings->GetPreferredDataTypes().Has(WEB_APPS));
  287. // Mimic "Sync everything" and all individual types toggle are disabled, app
  288. // model types should stay enabled.
  289. settings->SetSelectedTypes(/*sync_everything=*/false,
  290. UserSelectableTypeSet());
  291. ASSERT_FALSE(settings->IsSyncEverythingEnabled());
  292. EXPECT_TRUE(settings->GetPreferredDataTypes().Has(APP_SETTINGS));
  293. EXPECT_TRUE(settings->GetPreferredDataTypes().Has(APPS));
  294. EXPECT_TRUE(settings->GetPreferredDataTypes().Has(WEB_APPS));
  295. }
  296. #endif // BUILDFLAG(IS_CHROMEOS_LACROS)
  297. TEST_F(SyncUserSettingsImplTest, ShouldMutePassphrasePrompt) {
  298. std::unique_ptr<SyncUserSettingsImpl> sync_user_settings =
  299. MakeSyncUserSettings(GetUserTypes());
  300. EXPECT_FALSE(
  301. sync_user_settings->IsPassphrasePromptMutedForCurrentProductVersion());
  302. sync_user_settings->MarkPassphrasePromptMutedForCurrentProductVersion();
  303. EXPECT_TRUE(
  304. sync_user_settings->IsPassphrasePromptMutedForCurrentProductVersion());
  305. // Clearing the preference should unmute the prompt.
  306. sync_prefs_->ClearPassphrasePromptMutedProductVersion();
  307. EXPECT_FALSE(
  308. sync_user_settings->IsPassphrasePromptMutedForCurrentProductVersion());
  309. }
  310. TEST_F(SyncUserSettingsImplTest, ShouldClearPassphrasePromptMuteUponUpgrade) {
  311. // Mimic an old product version being written to prefs.
  312. sync_prefs_->SetPassphrasePromptMutedProductVersion(/*major_version=*/73);
  313. std::unique_ptr<SyncUserSettingsImpl> sync_user_settings =
  314. MakeSyncUserSettings(GetUserTypes());
  315. EXPECT_FALSE(
  316. sync_user_settings->IsPassphrasePromptMutedForCurrentProductVersion());
  317. // Muting should still work.
  318. sync_user_settings->MarkPassphrasePromptMutedForCurrentProductVersion();
  319. EXPECT_TRUE(
  320. sync_user_settings->IsPassphrasePromptMutedForCurrentProductVersion());
  321. }
  322. } // namespace
  323. } // namespace syncer