blob: c68050d74a9c0b13c91c658e3ead3b441e42a8a0 [file] [log] [blame]
// Copyright 2011 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/sync_preferences/pref_model_associator.h"
#include <memory>
#include <unordered_set>
#include "base/memory/ptr_util.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/ref_counted.h"
#include "base/test/gtest_util.h"
#include "base/test/scoped_feature_list.h"
#include "base/values.h"
#include "components/prefs/scoped_user_pref_update.h"
#include "components/prefs/testing_pref_store.h"
#include "components/sync/base/features.h"
#include "components/sync_preferences/pref_model_associator_client.h"
#include "components/sync_preferences/pref_service_mock_factory.h"
#include "components/sync_preferences/pref_service_syncable.h"
#include "components/sync_preferences/preferences_merge_helper.h"
#include "components/sync_preferences/syncable_prefs_database.h"
#include "components/sync_preferences/test_syncable_prefs_database.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace sync_preferences {
namespace {
using testing::NotNull;
const char kStringPrefName[] = "pref.string";
const char kListPrefName[] = "pref.list";
const char kDictionaryPrefName[] = "pref.dictionary";
const char kCustomMergePrefName[] = "pref.custom";
const char kStringPriorityPrefName[] = "priority.pref.string";
const char kStringOsPrefName[] = "os.pref.string";
const char kStringOsPriorityPrefName[] = "os.priority.pref.string";
// Assigning an id of 0 to all the test prefs.
const std::unordered_map<std::string, SyncablePrefMetadata>
kSyncablePrefsDatabase = {
{kStringPrefName, {0, syncer::PREFERENCES}},
{kListPrefName, {0, syncer::PREFERENCES}},
{kDictionaryPrefName, {0, syncer::PREFERENCES}},
{kCustomMergePrefName, {0, syncer::PREFERENCES}},
{kStringPriorityPrefName, {0, syncer::PRIORITY_PREFERENCES}},
{kStringOsPrefName, {0, syncer::OS_PREFERENCES}},
{kStringOsPriorityPrefName, {0, syncer::OS_PRIORITY_PREFERENCES}}};
class TestPrefModelAssociatorClient : public PrefModelAssociatorClient {
public:
TestPrefModelAssociatorClient()
: syncable_prefs_database_(kSyncablePrefsDatabase) {}
TestPrefModelAssociatorClient(const TestPrefModelAssociatorClient&) = delete;
TestPrefModelAssociatorClient& operator=(
const TestPrefModelAssociatorClient&) = delete;
~TestPrefModelAssociatorClient() override = default;
// PrefModelAssociatorClient implementation.
bool IsMergeableListPreference(const std::string& pref_name) const override {
return pref_name == kListPrefName;
}
bool IsMergeableDictionaryPreference(
const std::string& pref_name) const override {
return pref_name == kDictionaryPrefName;
}
base::Value MaybeMergePreferenceValues(
const std::string& pref_name,
const base::Value& local_value,
const base::Value& server_value) const override {
if (pref_name == kCustomMergePrefName) {
return local_value.Clone();
}
return base::Value();
}
private:
const SyncablePrefsDatabase& GetSyncablePrefsDatabase() const override {
return syncable_prefs_database_;
}
TestSyncablePrefsDatabase syncable_prefs_database_;
};
class AbstractPreferenceMergeTest : public testing::Test {
protected:
AbstractPreferenceMergeTest()
: pref_registry_(
base::MakeRefCounted<user_prefs::PrefRegistrySyncable>()),
user_prefs_(base::MakeRefCounted<TestingPrefStore>()) {
PrefServiceMockFactory factory;
factory.SetPrefModelAssociatorClient(&client_);
factory.set_user_prefs(user_prefs_);
pref_registry_->RegisterStringPref(
kStringPrefName, std::string(),
user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
pref_registry_->RegisterListPref(
kListPrefName, user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
pref_registry_->RegisterDictionaryPref(
kDictionaryPrefName, user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
pref_service_ = factory.CreateSyncable(pref_registry_.get());
pref_registry_->RegisterStringPref(
kCustomMergePrefName, std::string(),
user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
pref_sync_service_ = static_cast<PrefModelAssociator*>(
pref_service_->GetSyncableService(syncer::PREFERENCES));
}
void SetContentPattern(base::Value::Dict& patterns_dict,
const std::string& expression,
int setting) {
base::Value::Dict* expression_dict = patterns_dict.EnsureDict(expression);
expression_dict->Set("setting", setting);
}
void SetPrefToEmpty(const std::string& pref_name) {
std::unique_ptr<base::Value> empty_value;
const PrefService::Preference* pref =
pref_service_->FindPreference(pref_name);
ASSERT_TRUE(pref);
base::Value::Type type = pref->GetType();
if (type == base::Value::Type::DICT) {
pref_service_->SetDict(pref_name, base::Value::Dict());
} else if (type == base::Value::Type::LIST) {
pref_service_->SetList(pref_name, base::Value::List());
} else {
FAIL();
}
}
TestPrefModelAssociatorClient client_;
scoped_refptr<user_prefs::PrefRegistrySyncable> pref_registry_;
scoped_refptr<TestingPrefStore> user_prefs_;
std::unique_ptr<PrefServiceSyncable> pref_service_;
raw_ptr<PrefModelAssociator> pref_sync_service_;
};
using CustomPreferenceMergeTest = AbstractPreferenceMergeTest;
TEST_F(CustomPreferenceMergeTest, ClientMergesCustomPreference) {
pref_service_->SetString(kCustomMergePrefName, "local");
const PrefService::Preference* pref =
pref_service_->FindPreference(kCustomMergePrefName);
base::Value local_value(pref->GetValue()->Clone());
base::Value server_value("server");
base::Value merged_value(helper::MergePreference(
&client_, pref->name(), *pref->GetValue(), server_value));
// TestPrefModelAssociatorClient should have chosen local value instead of the
// default server value.
EXPECT_EQ(merged_value, local_value);
}
class ListPreferenceMergeTest : public AbstractPreferenceMergeTest {
protected:
ListPreferenceMergeTest()
: server_url0_("http://example.com/server0"),
server_url1_("http://example.com/server1"),
local_url0_("http://example.com/local0"),
local_url1_("http://example.com/local1") {
server_url_list_.Append(server_url0_);
server_url_list_.Append(server_url1_);
}
std::string server_url0_;
std::string server_url1_;
std::string local_url0_;
std::string local_url1_;
base::Value::List server_url_list_;
};
TEST_F(ListPreferenceMergeTest, NotListOrDictionary) {
pref_service_->SetString(kStringPrefName, local_url0_);
const PrefService::Preference* pref =
pref_service_->FindPreference(kStringPrefName);
base::Value server_value(server_url0_);
base::Value merged_value(helper::MergePreference(
&client_, pref->name(), *pref->GetValue(), server_value));
EXPECT_EQ(merged_value, server_value);
}
TEST_F(ListPreferenceMergeTest, LocalEmpty) {
SetPrefToEmpty(kListPrefName);
const PrefService::Preference* pref =
pref_service_->FindPreference(kListPrefName);
base::Value merged_value(
helper::MergePreference(&client_, pref->name(), *pref->GetValue(),
base::Value(server_url_list_.Clone())));
EXPECT_EQ(merged_value, server_url_list_);
}
TEST_F(ListPreferenceMergeTest, ServerNull) {
{
ScopedListPrefUpdate update(pref_service_.get(), kListPrefName);
update->Append(local_url0_);
}
const PrefService::Preference* pref =
pref_service_->FindPreference(kListPrefName);
base::Value merged_value(helper::MergePreference(
&client_, pref->name(), *pref->GetValue(), base::Value()));
const base::Value::List& local_list_value =
pref_service_->GetList(kListPrefName);
EXPECT_EQ(merged_value, local_list_value);
}
TEST_F(ListPreferenceMergeTest, ServerEmpty) {
base::Value::List empty_value;
{
ScopedListPrefUpdate update(pref_service_.get(), kListPrefName);
update->Append(local_url0_);
}
const PrefService::Preference* pref =
pref_service_->FindPreference(kListPrefName);
base::Value merged_value(
helper::MergePreference(&client_, pref->name(), *pref->GetValue(),
base::Value(empty_value.Clone())));
const base::Value::List& local_list_value =
pref_service_->GetList(kListPrefName);
EXPECT_EQ(merged_value, local_list_value);
}
TEST_F(ListPreferenceMergeTest, ServerCorrupt) {
{
ScopedListPrefUpdate update(pref_service_.get(), kListPrefName);
update->Append(local_url0_);
}
const PrefService::Preference* pref =
pref_service_->FindPreference(kListPrefName);
base::Value merged_value(helper::MergePreference(
&client_, pref->name(), *pref->GetValue(), base::Value("corrupt-type")));
const base::Value::List& local_list_value =
pref_service_->GetList(kListPrefName);
EXPECT_EQ(merged_value, local_list_value);
}
TEST_F(ListPreferenceMergeTest, Merge) {
{
ScopedListPrefUpdate update(pref_service_.get(), kListPrefName);
update->Append(local_url0_);
update->Append(local_url1_);
}
const PrefService::Preference* pref =
pref_service_->FindPreference(kListPrefName);
base::Value merged_value(
helper::MergePreference(&client_, pref->name(), *pref->GetValue(),
base::Value(server_url_list_.Clone())));
base::Value::List expected;
expected.Append(server_url0_);
expected.Append(server_url1_);
expected.Append(local_url0_);
expected.Append(local_url1_);
EXPECT_EQ(merged_value, expected);
}
TEST_F(ListPreferenceMergeTest, Duplicates) {
{
ScopedListPrefUpdate update(pref_service_.get(), kListPrefName);
update->Append(local_url0_);
update->Append(server_url0_);
update->Append(server_url1_);
}
const PrefService::Preference* pref =
pref_service_->FindPreference(kListPrefName);
base::Value merged_value(
helper::MergePreference(&client_, pref->name(), *pref->GetValue(),
base::Value(server_url_list_.Clone())));
base::Value::List expected;
expected.Append(server_url0_);
expected.Append(server_url1_);
expected.Append(local_url0_);
EXPECT_EQ(merged_value, expected);
}
TEST_F(ListPreferenceMergeTest, Equals) {
{
ScopedListPrefUpdate update(pref_service_.get(), kListPrefName);
update->Append(server_url0_);
update->Append(server_url1_);
}
base::Value::List original = server_url_list_.Clone();
const PrefService::Preference* pref =
pref_service_->FindPreference(kListPrefName);
base::Value merged_value(
helper::MergePreference(&client_, pref->name(), *pref->GetValue(),
base::Value(server_url_list_.Clone())));
EXPECT_EQ(merged_value, original);
}
class DictionaryPreferenceMergeTest : public AbstractPreferenceMergeTest {
protected:
DictionaryPreferenceMergeTest()
: expression0_("expression0"),
expression1_("expression1"),
expression2_("expression2"),
expression3_("expression3"),
expression4_("expression4") {
SetContentPattern(server_patterns_.GetDict(), expression0_, 1);
SetContentPattern(server_patterns_.GetDict(), expression1_, 2);
SetContentPattern(server_patterns_.GetDict(), expression2_, 1);
}
std::string expression0_;
std::string expression1_;
std::string expression2_;
std::string expression3_;
std::string expression4_;
base::Value server_patterns_{base::Value::Type::DICT};
};
TEST_F(DictionaryPreferenceMergeTest, LocalEmpty) {
SetPrefToEmpty(kDictionaryPrefName);
const PrefService::Preference* pref =
pref_service_->FindPreference(kDictionaryPrefName);
base::Value merged_value(helper::MergePreference(
&client_, pref->name(), *pref->GetValue(), server_patterns_));
EXPECT_EQ(merged_value, server_patterns_);
}
TEST_F(DictionaryPreferenceMergeTest, ServerNull) {
{
ScopedDictPrefUpdate update(pref_service_.get(), kDictionaryPrefName);
SetContentPattern(*update, expression3_, 1);
}
const PrefService::Preference* pref =
pref_service_->FindPreference(kDictionaryPrefName);
base::Value merged_value(helper::MergePreference(
&client_, pref->name(), *pref->GetValue(), base::Value()));
const base::Value::Dict& local_dict_value =
pref_service_->GetDict(kDictionaryPrefName);
EXPECT_EQ(merged_value, local_dict_value);
}
TEST_F(DictionaryPreferenceMergeTest, ServerEmpty) {
{
ScopedDictPrefUpdate update(pref_service_.get(), kDictionaryPrefName);
SetContentPattern(*update, expression3_, 1);
}
const PrefService::Preference* pref =
pref_service_->FindPreference(kDictionaryPrefName);
base::Value merged_value(helper::MergePreference(
&client_, pref->name(), *pref->GetValue(), base::Value()));
const base::Value::Dict& local_dict_value =
pref_service_->GetDict(kDictionaryPrefName);
EXPECT_EQ(merged_value, local_dict_value);
}
TEST_F(DictionaryPreferenceMergeTest, ServerCorrupt) {
{
ScopedDictPrefUpdate update(pref_service_.get(), kDictionaryPrefName);
SetContentPattern(*update, expression3_, 1);
}
const PrefService::Preference* pref =
pref_service_->FindPreference(kDictionaryPrefName);
base::Value merged_value(helper::MergePreference(
&client_, pref->name(), *pref->GetValue(), base::Value("corrupt-type")));
const base::Value::Dict& local_dict_value =
pref_service_->GetDict(kDictionaryPrefName);
EXPECT_EQ(merged_value, local_dict_value);
}
TEST_F(DictionaryPreferenceMergeTest, MergeNoConflicts) {
{
ScopedDictPrefUpdate update(pref_service_.get(), kDictionaryPrefName);
SetContentPattern(*update, expression3_, 1);
}
base::Value merged_value(helper::MergePreference(
&client_, kDictionaryPrefName,
*pref_service_->FindPreference(kDictionaryPrefName)->GetValue(),
server_patterns_));
base::Value::Dict expected;
SetContentPattern(expected, expression0_, 1);
SetContentPattern(expected, expression1_, 2);
SetContentPattern(expected, expression2_, 1);
SetContentPattern(expected, expression3_, 1);
EXPECT_EQ(merged_value, expected);
}
TEST_F(DictionaryPreferenceMergeTest, MergeConflicts) {
{
ScopedDictPrefUpdate update(pref_service_.get(), kDictionaryPrefName);
SetContentPattern(*update, expression0_, 2);
SetContentPattern(*update, expression2_, 1);
SetContentPattern(*update, expression3_, 1);
SetContentPattern(*update, expression4_, 2);
}
base::Value merged_value(helper::MergePreference(
&client_, kDictionaryPrefName,
*pref_service_->FindPreference(kDictionaryPrefName)->GetValue(),
server_patterns_));
base::Value::Dict expected;
SetContentPattern(expected, expression0_, 1);
SetContentPattern(expected, expression1_, 2);
SetContentPattern(expected, expression2_, 1);
SetContentPattern(expected, expression3_, 1);
SetContentPattern(expected, expression4_, 2);
EXPECT_EQ(merged_value, expected);
}
TEST_F(DictionaryPreferenceMergeTest, MergeValueToDictionary) {
base::Value::Dict local_dict_value;
local_dict_value.Set("key", 0);
base::Value::Dict server_dict_value;
server_dict_value.SetByDottedPath("key.subkey", 0);
// TODO(https://crbug.com/1187026): Migrate MergePreference() to
// take a base::Value::Dict.
base::Value merged_value(helper::MergePreference(
&client_, kDictionaryPrefName, base::Value(local_dict_value.Clone()),
base::Value(server_dict_value.Clone())));
EXPECT_EQ(merged_value, server_dict_value);
}
TEST_F(DictionaryPreferenceMergeTest, Equal) {
{
ScopedDictPrefUpdate update(pref_service_.get(), kDictionaryPrefName);
SetContentPattern(*update, expression0_, 1);
SetContentPattern(*update, expression1_, 2);
SetContentPattern(*update, expression2_, 1);
}
base::Value merged_value(helper::MergePreference(
&client_, kDictionaryPrefName,
*pref_service_->FindPreference(kDictionaryPrefName)->GetValue(),
server_patterns_));
EXPECT_EQ(merged_value, server_patterns_);
}
TEST_F(DictionaryPreferenceMergeTest, ConflictButServerWins) {
{
ScopedDictPrefUpdate update(pref_service_.get(), kDictionaryPrefName);
SetContentPattern(*update, expression0_, 2);
SetContentPattern(*update, expression1_, 2);
SetContentPattern(*update, expression2_, 1);
}
base::Value merged_value(helper::MergePreference(
&client_, kDictionaryPrefName,
*pref_service_->FindPreference(kDictionaryPrefName)->GetValue(),
server_patterns_));
EXPECT_EQ(merged_value, server_patterns_);
}
class IndividualPreferenceMergeTest : public AbstractPreferenceMergeTest {
protected:
IndividualPreferenceMergeTest()
: url0_("http://example.com/server0"),
url1_("http://example.com/server1"),
expression0_("expression0"),
expression1_("expression1") {
server_url_list_.Append(url0_);
SetContentPattern(server_patterns_.GetDict(), expression0_, 1);
}
bool MergeListPreference(const char* pref) {
{
ScopedListPrefUpdate update(pref_service_.get(), pref);
update->Append(url1_);
}
base::Value merged_value(helper::MergePreference(
&client_, pref, *pref_service_->GetUserPrefValue(pref),
base::Value(server_url_list_.Clone())));
base::Value::List expected;
expected.Append(url0_);
expected.Append(url1_);
return merged_value == expected;
}
bool MergeDictionaryPreference(const char* pref) {
{
ScopedDictPrefUpdate update(pref_service_.get(), pref);
SetContentPattern(*update, expression1_, 1);
}
base::Value merged_value(helper::MergePreference(
&client_, pref, *pref_service_->GetUserPrefValue(pref),
server_patterns_));
base::Value::Dict expected;
SetContentPattern(expected, expression0_, 1);
SetContentPattern(expected, expression1_, 1);
return merged_value == expected;
}
std::string url0_;
std::string url1_;
std::string expression0_;
std::string expression1_;
std::string content_type0_;
base::Value::List server_url_list_;
base::Value server_patterns_{base::Value::Type::DICT};
};
TEST_F(IndividualPreferenceMergeTest, ListPreference) {
EXPECT_TRUE(MergeListPreference(kListPrefName));
}
class SyncablePrefsDatabaseTest : public testing::Test {
protected:
SyncablePrefsDatabaseTest()
: feature_list_(syncer::kSyncEnforcePreferencesAllowlist),
pref_registry_(
base::MakeRefCounted<user_prefs::PrefRegistrySyncable>()) {
PrefServiceMockFactory factory;
factory.SetPrefModelAssociatorClient(&client_);
pref_service_ = factory.CreateSyncable(pref_registry_.get());
}
base::test::ScopedFeatureList feature_list_;
TestPrefModelAssociatorClient client_;
scoped_refptr<user_prefs::PrefRegistrySyncable> pref_registry_;
std::unique_ptr<PrefServiceSyncable> pref_service_;
};
TEST_F(SyncablePrefsDatabaseTest, ShouldAllowRegisteringSyncablePrefs) {
pref_registry_->RegisterStringPref(
kStringPrefName, std::string(),
user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
EXPECT_THAT(pref_service_->FindPreference(kStringPrefName), NotNull());
pref_registry_->RegisterListPref(
kListPrefName, user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
EXPECT_THAT(pref_service_->FindPreference(kListPrefName), NotNull());
pref_registry_->RegisterDictionaryPref(
kDictionaryPrefName, user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
EXPECT_THAT(pref_service_->FindPreference(kDictionaryPrefName), NotNull());
}
TEST_F(SyncablePrefsDatabaseTest, ShouldAllowRegisteringSyncablePriorityPrefs) {
pref_registry_->RegisterStringPref(
kStringPriorityPrefName, std::string(),
user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF);
EXPECT_THAT(pref_service_->FindPreference(kStringPriorityPrefName),
NotNull());
}
#if BUILDFLAG(IS_CHROMEOS_ASH)
TEST_F(SyncablePrefsDatabaseTest, ShouldAllowRegisteringSyncableOSPrefs) {
pref_registry_->RegisterStringPref(
kStringOsPrefName, std::string(),
user_prefs::PrefRegistrySyncable::SYNCABLE_OS_PREF);
EXPECT_THAT(pref_service_->FindPreference(kStringOsPrefName), NotNull());
}
TEST_F(SyncablePrefsDatabaseTest,
ShouldAllowRegisteringSyncableOSPriorityPrefs) {
pref_registry_->RegisterStringPref(
kStringOsPriorityPrefName, std::string(),
user_prefs::PrefRegistrySyncable::SYNCABLE_OS_PRIORITY_PREF);
EXPECT_THAT(pref_service_->FindPreference(kStringOsPriorityPrefName),
NotNull());
}
#endif
using SyncablePrefsDatabaseDeathTest = SyncablePrefsDatabaseTest;
TEST_F(SyncablePrefsDatabaseDeathTest, ShouldFailRegisteringIllegalPrefs) {
const std::string kIllegalStringPrefName = "not-allowed_string_pref";
const std::string kIllegalListPrefName = "not-allowed_list_pref";
const std::string kIllegalDictPrefName = "not-allowed_dict_pref";
const std::string kExpectedErrorMessageHint = "syncable prefs allowlist";
EXPECT_DCHECK_DEATH_WITH(pref_registry_->RegisterStringPref(
kIllegalStringPrefName, std::string(),
user_prefs::PrefRegistrySyncable::SYNCABLE_PREF),
kExpectedErrorMessageHint);
EXPECT_DCHECK_DEATH_WITH(pref_registry_->RegisterListPref(
kIllegalListPrefName,
user_prefs::PrefRegistrySyncable::SYNCABLE_PREF),
kExpectedErrorMessageHint);
EXPECT_DCHECK_DEATH_WITH(pref_registry_->RegisterDictionaryPref(
kIllegalDictPrefName,
user_prefs::PrefRegistrySyncable::SYNCABLE_PREF),
kExpectedErrorMessageHint);
}
TEST_F(SyncablePrefsDatabaseDeathTest,
ShouldFailRegisteringIllegalPriorityPrefs) {
const std::string kIllegalStringPrefName = "not-allowed_string_pref";
const std::string kIllegalListPrefName = "not-allowed_list_pref";
const std::string kIllegalDictPrefName = "not-allowed_dict_pref";
const std::string kExpectedErrorMessageHint = "syncable prefs allowlist";
EXPECT_DCHECK_DEATH_WITH(
pref_registry_->RegisterStringPref(
kIllegalStringPrefName, std::string(),
user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF),
kExpectedErrorMessageHint);
EXPECT_DCHECK_DEATH_WITH(
pref_registry_->RegisterListPref(
kIllegalListPrefName,
user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF),
kExpectedErrorMessageHint);
EXPECT_DCHECK_DEATH_WITH(
pref_registry_->RegisterDictionaryPref(
kIllegalDictPrefName,
user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF),
kExpectedErrorMessageHint);
}
#if BUILDFLAG(IS_CHROMEOS_ASH)
TEST_F(SyncablePrefsDatabaseDeathTest, ShouldFailRegisteringIllegalOSPrefs) {
const std::string kIllegalStringPrefName = "not-allowed_string_pref";
const std::string kIllegalListPrefName = "not-allowed_list_pref";
const std::string kIllegalDictPrefName = "not-allowed_dict_pref";
const std::string kExpectedErrorMessageHint = "syncable prefs allowlist";
EXPECT_DCHECK_DEATH_WITH(
pref_registry_->RegisterStringPref(
kIllegalStringPrefName, std::string(),
user_prefs::PrefRegistrySyncable::SYNCABLE_OS_PREF),
kExpectedErrorMessageHint);
EXPECT_DCHECK_DEATH_WITH(
pref_registry_->RegisterListPref(
kIllegalListPrefName,
user_prefs::PrefRegistrySyncable::SYNCABLE_OS_PREF),
kExpectedErrorMessageHint);
EXPECT_DCHECK_DEATH_WITH(
pref_registry_->RegisterDictionaryPref(
kIllegalDictPrefName,
user_prefs::PrefRegistrySyncable::SYNCABLE_OS_PREF),
kExpectedErrorMessageHint);
}
TEST_F(SyncablePrefsDatabaseDeathTest,
ShouldFailRegisteringIllegalOSPriorityPrefs) {
const std::string kIllegalStringPrefName = "not-allowed_string_pref";
const std::string kIllegalListPrefName = "not-allowed_list_pref";
const std::string kIllegalDictPrefName = "not-allowed_dict_pref";
const std::string kExpectedErrorMessageHint = "syncable prefs allowlist";
EXPECT_DCHECK_DEATH_WITH(
pref_registry_->RegisterStringPref(
kIllegalStringPrefName, std::string(),
user_prefs::PrefRegistrySyncable::SYNCABLE_OS_PRIORITY_PREF),
kExpectedErrorMessageHint);
EXPECT_DCHECK_DEATH_WITH(
pref_registry_->RegisterListPref(
kIllegalListPrefName,
user_prefs::PrefRegistrySyncable::SYNCABLE_OS_PRIORITY_PREF),
kExpectedErrorMessageHint);
EXPECT_DCHECK_DEATH_WITH(
pref_registry_->RegisterDictionaryPref(
kIllegalDictPrefName,
user_prefs::PrefRegistrySyncable::SYNCABLE_OS_PRIORITY_PREF),
kExpectedErrorMessageHint);
}
#endif
TEST_F(SyncablePrefsDatabaseDeathTest,
ShouldFailRegisteringPrefsWithInvalidType) {
const std::string kExpectedErrorMessageHint = "has incorrect data";
EXPECT_DCHECK_DEATH_WITH(
pref_registry_->RegisterStringPref(
kStringPrefName, std::string(),
user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF),
kExpectedErrorMessageHint);
EXPECT_DCHECK_DEATH_WITH(pref_registry_->RegisterStringPref(
kStringPriorityPrefName, std::string(),
user_prefs::PrefRegistrySyncable::SYNCABLE_PREF),
kExpectedErrorMessageHint);
#if BUILDFLAG(IS_CHROMEOS_ASH)
EXPECT_DCHECK_DEATH_WITH(
pref_registry_->RegisterStringPref(
kStringOsPrefName, std::string(),
user_prefs::PrefRegistrySyncable::SYNCABLE_OS_PRIORITY_PREF),
kExpectedErrorMessageHint);
EXPECT_DCHECK_DEATH_WITH(
pref_registry_->RegisterStringPref(
kStringOsPriorityPrefName, std::string(),
user_prefs::PrefRegistrySyncable::SYNCABLE_OS_PREF),
kExpectedErrorMessageHint);
#endif
}
} // namespace
} // namespace sync_preferences