1 //
2 // Copyright (C) 2012 The Android Open Source Project
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16
17 #include "update_engine/common/prefs.h"
18
19 #include <inttypes.h>
20
21 #include <limits>
22 #include <string>
23 #include <vector>
24
25 #include <base/files/file_util.h>
26 #include <base/files/scoped_temp_dir.h>
27 #include <android-base/macros.h>
28 #include <android-base/stringprintf.h>
29 #include <gmock/gmock.h>
30 #include <gtest/gtest.h>
31
32 using std::string;
33 using std::vector;
34 using testing::_;
35 using testing::ElementsAre;
36 using testing::Eq;
37 using testing::UnorderedElementsAre;
38
39 namespace {
40 // Test key used along the tests.
41 const char kKey[] = "test-key";
42 } // namespace
43
44 namespace chromeos_update_engine {
45
46 class BasePrefsTest : public ::testing::Test {
47 protected:
MultiNamespaceKeyTest()48 void MultiNamespaceKeyTest() {
49 ASSERT_TRUE(common_prefs_);
50 auto key0 = common_prefs_->CreateSubKey({"ns1", "key"});
51 // Corner case for "ns1".
52 auto key0corner = common_prefs_->CreateSubKey({"ns11", "key"});
53 auto key1A = common_prefs_->CreateSubKey({"ns1", "nsA", "keyA"});
54 auto key1B = common_prefs_->CreateSubKey({"ns1", "nsA", "keyB"});
55 auto key2 = common_prefs_->CreateSubKey({"ns1", "nsB", "key"});
56 // Corner case for "ns1/nsB".
57 auto key2corner = common_prefs_->CreateSubKey({"ns1", "nsB1", "key"});
58 EXPECT_FALSE(common_prefs_->Exists(key0));
59 EXPECT_FALSE(common_prefs_->Exists(key1A));
60 EXPECT_FALSE(common_prefs_->Exists(key1B));
61 EXPECT_FALSE(common_prefs_->Exists(key2));
62
63 EXPECT_TRUE(common_prefs_->SetString(key0, ""));
64 EXPECT_TRUE(common_prefs_->SetString(key0corner, ""));
65 EXPECT_TRUE(common_prefs_->SetString(key1A, ""));
66 EXPECT_TRUE(common_prefs_->SetString(key1B, ""));
67 EXPECT_TRUE(common_prefs_->SetString(key2, ""));
68 EXPECT_TRUE(common_prefs_->SetString(key2corner, ""));
69
70 EXPECT_TRUE(common_prefs_->Exists(key0));
71 EXPECT_TRUE(common_prefs_->Exists(key0corner));
72 EXPECT_TRUE(common_prefs_->Exists(key1A));
73 EXPECT_TRUE(common_prefs_->Exists(key1B));
74 EXPECT_TRUE(common_prefs_->Exists(key2));
75 EXPECT_TRUE(common_prefs_->Exists(key2corner));
76
77 vector<string> keys2;
78 EXPECT_TRUE(common_prefs_->GetSubKeys("ns1/nsB/", &keys2));
79 EXPECT_THAT(keys2, ElementsAre(key2));
80 for (const auto& key : keys2)
81 EXPECT_TRUE(common_prefs_->Delete(key));
82 EXPECT_TRUE(common_prefs_->Exists(key0));
83 EXPECT_TRUE(common_prefs_->Exists(key0corner));
84 EXPECT_TRUE(common_prefs_->Exists(key1A));
85 EXPECT_TRUE(common_prefs_->Exists(key1B));
86 EXPECT_FALSE(common_prefs_->Exists(key2));
87 EXPECT_TRUE(common_prefs_->Exists(key2corner));
88
89 vector<string> keys2corner;
90 EXPECT_TRUE(common_prefs_->GetSubKeys("ns1/nsB", &keys2corner));
91 EXPECT_THAT(keys2corner, ElementsAre(key2corner));
92 for (const auto& key : keys2corner)
93 EXPECT_TRUE(common_prefs_->Delete(key));
94 EXPECT_FALSE(common_prefs_->Exists(key2corner));
95
96 vector<string> keys1;
97 EXPECT_TRUE(common_prefs_->GetSubKeys("ns1/nsA/", &keys1));
98 EXPECT_THAT(keys1, UnorderedElementsAre(key1A, key1B));
99 for (const auto& key : keys1)
100 EXPECT_TRUE(common_prefs_->Delete(key));
101 EXPECT_TRUE(common_prefs_->Exists(key0));
102 EXPECT_TRUE(common_prefs_->Exists(key0corner));
103 EXPECT_FALSE(common_prefs_->Exists(key1A));
104 EXPECT_FALSE(common_prefs_->Exists(key1B));
105
106 vector<string> keys0;
107 EXPECT_TRUE(common_prefs_->GetSubKeys("ns1/", &keys0));
108 EXPECT_THAT(keys0, ElementsAre(key0));
109 for (const auto& key : keys0)
110 EXPECT_TRUE(common_prefs_->Delete(key));
111 EXPECT_FALSE(common_prefs_->Exists(key0));
112 EXPECT_TRUE(common_prefs_->Exists(key0corner));
113
114 vector<string> keys0corner;
115 EXPECT_TRUE(common_prefs_->GetSubKeys("ns1", &keys0corner));
116 EXPECT_THAT(keys0corner, ElementsAre(key0corner));
117 for (const auto& key : keys0corner)
118 EXPECT_TRUE(common_prefs_->Delete(key));
119 EXPECT_FALSE(common_prefs_->Exists(key0corner));
120
121 // Test sub directory namespace.
122 const string kDlcPrefsSubDir = "foo-dir";
123 key1A = common_prefs_->CreateSubKey({kDlcPrefsSubDir, "dlc1", "keyA"});
124 EXPECT_TRUE(common_prefs_->SetString(key1A, "fp_1A"));
125 key1B = common_prefs_->CreateSubKey({kDlcPrefsSubDir, "dlc1", "keyB"});
126 EXPECT_TRUE(common_prefs_->SetString(key1B, "fp_1B"));
127 auto key2A = common_prefs_->CreateSubKey({kDlcPrefsSubDir, "dlc2", "keyA"});
128 EXPECT_TRUE(common_prefs_->SetString(key2A, "fp_A2"));
129
130 vector<string> fpKeys;
131 EXPECT_TRUE(common_prefs_->GetSubKeys(kDlcPrefsSubDir, &fpKeys));
132 EXPECT_EQ(fpKeys.size(), 3UL);
133 EXPECT_TRUE(common_prefs_->Delete(fpKeys[0]));
134 EXPECT_TRUE(common_prefs_->Delete(fpKeys[1]));
135 EXPECT_TRUE(common_prefs_->Delete(fpKeys[2]));
136 EXPECT_FALSE(common_prefs_->Exists(key1A));
137 }
138
139 PrefsInterface* common_prefs_;
140 };
141
142 class PrefsTest : public BasePrefsTest {
143 protected:
SetUp()144 void SetUp() override {
145 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
146 prefs_dir_ = temp_dir_.GetPath();
147 ASSERT_TRUE(prefs_.Init(prefs_dir_));
148 common_prefs_ = &prefs_;
149 }
150
SetValue(const string & key,const string & value)151 bool SetValue(const string& key, const string& value) {
152 return base::WriteFile(prefs_dir_.Append(key),
153 value.data(),
154 value.length()) == static_cast<int>(value.length());
155 }
156
157 base::ScopedTempDir temp_dir_;
158 base::FilePath prefs_dir_;
159 Prefs prefs_;
160 };
161
TEST(Prefs,Init)162 TEST(Prefs, Init) {
163 Prefs prefs;
164 const string ns1 = "ns1";
165 const string ns2A = "ns2A";
166 const string ns2B = "ns2B";
167 const string sub_pref = "sp";
168
169 base::ScopedTempDir temp_dir;
170 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
171 auto ns1_path = temp_dir.GetPath().Append(ns1);
172 auto ns2A_path = ns1_path.Append(ns2A);
173 auto ns2B_path = ns1_path.Append(ns2B);
174 auto sub_pref_path = ns2A_path.Append(sub_pref);
175
176 EXPECT_TRUE(base::CreateDirectory(ns2B_path));
177 EXPECT_TRUE(base::PathExists(ns2B_path));
178
179 EXPECT_TRUE(base::CreateDirectory(sub_pref_path));
180 EXPECT_TRUE(base::PathExists(sub_pref_path));
181
182 EXPECT_TRUE(base::PathExists(ns1_path));
183 ASSERT_TRUE(prefs.Init(temp_dir.GetPath()));
184 EXPECT_FALSE(base::PathExists(ns1_path));
185 }
186
TEST_F(PrefsTest,GetFileNameForKey)187 TEST_F(PrefsTest, GetFileNameForKey) {
188 const char kAllvalidCharsKey[] =
189 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-";
190 base::FilePath path;
191 EXPECT_TRUE(prefs_.file_storage_.GetFileNameForKey(kAllvalidCharsKey, &path));
192 EXPECT_EQ(prefs_dir_.Append(kAllvalidCharsKey).value(), path.value());
193 }
194
TEST_F(PrefsTest,GetFileNameForKeyBadCharacter)195 TEST_F(PrefsTest, GetFileNameForKeyBadCharacter) {
196 base::FilePath path;
197 EXPECT_FALSE(prefs_.file_storage_.GetFileNameForKey("ABC abc", &path));
198 }
199
TEST_F(PrefsTest,GetFileNameForKeyEmpty)200 TEST_F(PrefsTest, GetFileNameForKeyEmpty) {
201 base::FilePath path;
202 EXPECT_FALSE(prefs_.file_storage_.GetFileNameForKey("", &path));
203 }
204
TEST_F(PrefsTest,CreateSubKey)205 TEST_F(PrefsTest, CreateSubKey) {
206 const string name_space = "ns";
207 const string sub_pref1 = "sp1";
208 const string sub_pref2 = "sp2";
209 const string sub_key = "sk";
210
211 EXPECT_EQ(PrefsInterface::CreateSubKey({name_space, sub_pref1, sub_key}),
212 "ns/sp1/sk");
213 EXPECT_EQ(PrefsInterface::CreateSubKey({name_space, sub_pref2, sub_key}),
214 "ns/sp2/sk");
215 }
216
TEST_F(PrefsTest,GetString)217 TEST_F(PrefsTest, GetString) {
218 const string test_data = "test data";
219 ASSERT_TRUE(SetValue(kKey, test_data));
220 string value;
221 EXPECT_TRUE(prefs_.GetString(kKey, &value));
222 EXPECT_EQ(test_data, value);
223 }
224
TEST_F(PrefsTest,GetStringBadKey)225 TEST_F(PrefsTest, GetStringBadKey) {
226 string value;
227 EXPECT_FALSE(prefs_.GetString(",bad", &value));
228 }
229
TEST_F(PrefsTest,GetStringNonExistentKey)230 TEST_F(PrefsTest, GetStringNonExistentKey) {
231 string value;
232 EXPECT_FALSE(prefs_.GetString("non-existent-key", &value));
233 }
234
TEST_F(PrefsTest,SetString)235 TEST_F(PrefsTest, SetString) {
236 const char kValue[] = "some test value\non 2 lines";
237 EXPECT_TRUE(prefs_.SetString(kKey, kValue));
238 string value;
239 EXPECT_TRUE(base::ReadFileToString(prefs_dir_.Append(kKey), &value));
240 EXPECT_EQ(kValue, value);
241 }
242
TEST_F(PrefsTest,SetStringBadKey)243 TEST_F(PrefsTest, SetStringBadKey) {
244 const char kKeyWithDots[] = ".no-dots";
245 EXPECT_FALSE(prefs_.SetString(kKeyWithDots, "some value"));
246 EXPECT_FALSE(base::PathExists(prefs_dir_.Append(kKeyWithDots)));
247 }
248
TEST_F(PrefsTest,SetStringCreateDir)249 TEST_F(PrefsTest, SetStringCreateDir) {
250 const char kValue[] = "test value";
251 base::FilePath subdir = prefs_dir_.Append("subdir1").Append("subdir2");
252 EXPECT_TRUE(prefs_.Init(subdir));
253 EXPECT_TRUE(prefs_.SetString(kKey, kValue));
254 string value;
255 EXPECT_TRUE(base::ReadFileToString(subdir.Append(kKey), &value));
256 EXPECT_EQ(kValue, value);
257 }
258
TEST_F(PrefsTest,SetStringDirCreationFailure)259 TEST_F(PrefsTest, SetStringDirCreationFailure) {
260 EXPECT_TRUE(prefs_.Init(base::FilePath("/dev/null")));
261 EXPECT_FALSE(prefs_.SetString(kKey, "test value"));
262 }
263
TEST_F(PrefsTest,SetStringFileCreationFailure)264 TEST_F(PrefsTest, SetStringFileCreationFailure) {
265 base::CreateDirectory(prefs_dir_.Append(kKey));
266 EXPECT_FALSE(prefs_.SetString(kKey, "test value"));
267 EXPECT_TRUE(base::DirectoryExists(prefs_dir_.Append(kKey)));
268 }
269
TEST_F(PrefsTest,GetInt64)270 TEST_F(PrefsTest, GetInt64) {
271 ASSERT_TRUE(SetValue(kKey, " \n 25 \t "));
272 int64_t value;
273 EXPECT_TRUE(prefs_.GetInt64(kKey, &value));
274 EXPECT_EQ(25, value);
275 }
276
TEST_F(PrefsTest,GetInt64BadValue)277 TEST_F(PrefsTest, GetInt64BadValue) {
278 ASSERT_TRUE(SetValue(kKey, "30a"));
279 int64_t value;
280 EXPECT_FALSE(prefs_.GetInt64(kKey, &value));
281 }
282
TEST_F(PrefsTest,GetInt64Max)283 TEST_F(PrefsTest, GetInt64Max) {
284 ASSERT_TRUE(SetValue(kKey,
285 android::base::StringPrintf(
286 "%" PRIi64, std::numeric_limits<int64_t>::max())));
287 int64_t value;
288 EXPECT_TRUE(prefs_.GetInt64(kKey, &value));
289 EXPECT_EQ(std::numeric_limits<int64_t>::max(), value);
290 }
291
TEST_F(PrefsTest,GetInt64Min)292 TEST_F(PrefsTest, GetInt64Min) {
293 ASSERT_TRUE(SetValue(kKey,
294 android::base::StringPrintf(
295 "%" PRIi64, std::numeric_limits<int64_t>::min())));
296 int64_t value;
297 EXPECT_TRUE(prefs_.GetInt64(kKey, &value));
298 EXPECT_EQ(std::numeric_limits<int64_t>::min(), value);
299 }
300
TEST_F(PrefsTest,GetInt64Negative)301 TEST_F(PrefsTest, GetInt64Negative) {
302 ASSERT_TRUE(SetValue(kKey, " \t -100 \n "));
303 int64_t value;
304 EXPECT_TRUE(prefs_.GetInt64(kKey, &value));
305 EXPECT_EQ(-100, value);
306 }
307
TEST_F(PrefsTest,GetInt64NonExistentKey)308 TEST_F(PrefsTest, GetInt64NonExistentKey) {
309 int64_t value;
310 EXPECT_FALSE(prefs_.GetInt64("random-key", &value));
311 }
312
TEST_F(PrefsTest,SetInt64)313 TEST_F(PrefsTest, SetInt64) {
314 EXPECT_TRUE(prefs_.SetInt64(kKey, -123));
315 string value;
316 EXPECT_TRUE(base::ReadFileToString(prefs_dir_.Append(kKey), &value));
317 EXPECT_EQ("-123", value);
318 }
319
TEST_F(PrefsTest,SetInt64BadKey)320 TEST_F(PrefsTest, SetInt64BadKey) {
321 const char kKeyWithSpaces[] = "s p a c e s";
322 EXPECT_FALSE(prefs_.SetInt64(kKeyWithSpaces, 20));
323 EXPECT_FALSE(base::PathExists(prefs_dir_.Append(kKeyWithSpaces)));
324 }
325
TEST_F(PrefsTest,SetInt64Max)326 TEST_F(PrefsTest, SetInt64Max) {
327 EXPECT_TRUE(prefs_.SetInt64(kKey, std::numeric_limits<int64_t>::max()));
328 string value;
329 EXPECT_TRUE(base::ReadFileToString(prefs_dir_.Append(kKey), &value));
330 EXPECT_EQ(android::base::StringPrintf("%" PRIi64,
331 std::numeric_limits<int64_t>::max()),
332 value);
333 }
334
TEST_F(PrefsTest,SetInt64Min)335 TEST_F(PrefsTest, SetInt64Min) {
336 EXPECT_TRUE(prefs_.SetInt64(kKey, std::numeric_limits<int64_t>::min()));
337 string value;
338 EXPECT_TRUE(base::ReadFileToString(prefs_dir_.Append(kKey), &value));
339 EXPECT_EQ(android::base::StringPrintf("%" PRIi64,
340 std::numeric_limits<int64_t>::min()),
341 value);
342 }
343
TEST_F(PrefsTest,GetBooleanFalse)344 TEST_F(PrefsTest, GetBooleanFalse) {
345 ASSERT_TRUE(SetValue(kKey, " \n false \t "));
346 bool value;
347 EXPECT_TRUE(prefs_.GetBoolean(kKey, &value));
348 EXPECT_FALSE(value);
349 }
350
TEST_F(PrefsTest,GetBooleanTrue)351 TEST_F(PrefsTest, GetBooleanTrue) {
352 const char kKey[] = "test-key";
353 ASSERT_TRUE(SetValue(kKey, " \t true \n "));
354 bool value;
355 EXPECT_TRUE(prefs_.GetBoolean(kKey, &value));
356 EXPECT_TRUE(value);
357 }
358
TEST_F(PrefsTest,GetBooleanBadValue)359 TEST_F(PrefsTest, GetBooleanBadValue) {
360 const char kKey[] = "test-key";
361 ASSERT_TRUE(SetValue(kKey, "1"));
362 bool value;
363 EXPECT_FALSE(prefs_.GetBoolean(kKey, &value));
364 }
365
TEST_F(PrefsTest,GetBooleanBadEmptyValue)366 TEST_F(PrefsTest, GetBooleanBadEmptyValue) {
367 const char kKey[] = "test-key";
368 ASSERT_TRUE(SetValue(kKey, ""));
369 bool value;
370 EXPECT_FALSE(prefs_.GetBoolean(kKey, &value));
371 }
372
TEST_F(PrefsTest,GetBooleanNonExistentKey)373 TEST_F(PrefsTest, GetBooleanNonExistentKey) {
374 bool value;
375 EXPECT_FALSE(prefs_.GetBoolean("random-key", &value));
376 }
377
TEST_F(PrefsTest,SetBooleanTrue)378 TEST_F(PrefsTest, SetBooleanTrue) {
379 const char kKey[] = "test-bool";
380 EXPECT_TRUE(prefs_.SetBoolean(kKey, true));
381 string value;
382 EXPECT_TRUE(base::ReadFileToString(prefs_dir_.Append(kKey), &value));
383 EXPECT_EQ("true", value);
384 }
385
TEST_F(PrefsTest,SetBooleanFalse)386 TEST_F(PrefsTest, SetBooleanFalse) {
387 const char kKey[] = "test-bool";
388 EXPECT_TRUE(prefs_.SetBoolean(kKey, false));
389 string value;
390 EXPECT_TRUE(base::ReadFileToString(prefs_dir_.Append(kKey), &value));
391 EXPECT_EQ("false", value);
392 }
393
TEST_F(PrefsTest,SetBooleanBadKey)394 TEST_F(PrefsTest, SetBooleanBadKey) {
395 const char kKey[] = "s p a c e s";
396 EXPECT_FALSE(prefs_.SetBoolean(kKey, true));
397 EXPECT_FALSE(base::PathExists(prefs_dir_.Append(kKey)));
398 }
399
TEST_F(PrefsTest,ExistsWorks)400 TEST_F(PrefsTest, ExistsWorks) {
401 // test that the key doesn't exist before we set it.
402 EXPECT_FALSE(prefs_.Exists(kKey));
403
404 // test that the key exists after we set it.
405 ASSERT_TRUE(prefs_.SetInt64(kKey, 8));
406 EXPECT_TRUE(prefs_.Exists(kKey));
407 }
408
TEST_F(PrefsTest,DeleteWorks)409 TEST_F(PrefsTest, DeleteWorks) {
410 // test that it's alright to delete a non-existent key.
411 EXPECT_TRUE(prefs_.Delete(kKey));
412
413 // delete the key after we set it.
414 ASSERT_TRUE(prefs_.SetInt64(kKey, 0));
415 EXPECT_TRUE(prefs_.Delete(kKey));
416
417 // make sure it doesn't exist anymore.
418 EXPECT_FALSE(prefs_.Exists(kKey));
419 }
420
TEST_F(PrefsTest,SetDeleteSubKey)421 TEST_F(PrefsTest, SetDeleteSubKey) {
422 const string name_space = "ns";
423 const string sub_pref = "sp";
424 const string sub_key1 = "sk1";
425 const string sub_key2 = "sk2";
426 auto key1 = prefs_.CreateSubKey({name_space, sub_pref, sub_key1});
427 auto key2 = prefs_.CreateSubKey({name_space, sub_pref, sub_key2});
428 base::FilePath sub_pref_path = prefs_dir_.Append(name_space).Append(sub_pref);
429
430 ASSERT_TRUE(prefs_.SetInt64(key1, 0));
431 ASSERT_TRUE(prefs_.SetInt64(key2, 0));
432 EXPECT_TRUE(base::PathExists(sub_pref_path.Append(sub_key1)));
433 EXPECT_TRUE(base::PathExists(sub_pref_path.Append(sub_key2)));
434
435 ASSERT_TRUE(prefs_.Delete(key1));
436 EXPECT_FALSE(base::PathExists(sub_pref_path.Append(sub_key1)));
437 EXPECT_TRUE(base::PathExists(sub_pref_path.Append(sub_key2)));
438 ASSERT_TRUE(prefs_.Delete(key2));
439 EXPECT_FALSE(base::PathExists(sub_pref_path.Append(sub_key2)));
440 prefs_.Init(prefs_dir_);
441 EXPECT_FALSE(base::PathExists(prefs_dir_.Append(name_space)));
442 }
443
TEST_F(PrefsTest,DeletePrefs)444 TEST_F(PrefsTest, DeletePrefs) {
445 const string kPrefsSubDir = "foo-dir";
446 const string kFpKey = "kPrefFp";
447 const string kNotFpKey = "NotkPrefFp";
448 const string kOtherKey = "kPrefNotFp";
449
450 EXPECT_TRUE(prefs_.SetString(kFpKey, "3.000"));
451 EXPECT_TRUE(prefs_.SetString(kOtherKey, "not_fp_val"));
452
453 auto key1_fp = prefs_.CreateSubKey({kPrefsSubDir, "id-1", kFpKey});
454 EXPECT_TRUE(prefs_.SetString(key1_fp, "3.7"));
455 auto key_not_fp = prefs_.CreateSubKey({kPrefsSubDir, "id-1", kOtherKey});
456 EXPECT_TRUE(prefs_.SetString(key_not_fp, "not_fp_val"));
457 auto key2_fp = prefs_.CreateSubKey({kPrefsSubDir, "id-2", kFpKey});
458 EXPECT_TRUE(prefs_.SetString(key2_fp, "3.9"));
459 auto key3_fp = prefs_.CreateSubKey({kPrefsSubDir, "id-3", kFpKey});
460 EXPECT_TRUE(prefs_.SetString(key3_fp, "3.45"));
461
462 // Pref key does not match full subkey at end, should not delete.
463 auto key_middle_fp = prefs_.CreateSubKey({kPrefsSubDir, kFpKey, kOtherKey});
464 EXPECT_TRUE(prefs_.SetString(key_middle_fp, "not_fp_val"));
465 auto key_end_not_fp = prefs_.CreateSubKey({kPrefsSubDir, "id-1", kNotFpKey});
466 EXPECT_TRUE(prefs_.SetString(key_end_not_fp, "not_fp_val"));
467
468 // Delete key in platform and one namespace.
469 prefs_.Delete(kFpKey, {kPrefsSubDir});
470
471 EXPECT_FALSE(prefs_.Exists(kFpKey));
472 EXPECT_FALSE(prefs_.Exists(key1_fp));
473 EXPECT_FALSE(prefs_.Exists(key2_fp));
474 EXPECT_FALSE(prefs_.Exists(key3_fp));
475
476 // Check other keys are not deleted.
477 EXPECT_TRUE(prefs_.Exists(kOtherKey));
478 EXPECT_TRUE(prefs_.Exists(key_not_fp));
479 EXPECT_TRUE(prefs_.Exists(key_middle_fp));
480 EXPECT_TRUE(prefs_.Exists(key_end_not_fp));
481 }
482
TEST_F(PrefsTest,DeleteMultipleNamespaces)483 TEST_F(PrefsTest, DeleteMultipleNamespaces) {
484 const string kFirstSubDir = "foo-dir";
485 const string kSecondarySubDir = "bar-dir";
486 const string kTertiarySubDir = "ter-dir";
487 const string kFpKey = "kPrefFp";
488
489 EXPECT_TRUE(prefs_.SetString(kFpKey, "3.000"));
490 // Set pref key in different namespaces.
491 auto key1_fp = prefs_.CreateSubKey({kFirstSubDir, "id-1", kFpKey});
492 EXPECT_TRUE(prefs_.SetString(key1_fp, "3.7"));
493 auto key2_fp = prefs_.CreateSubKey({kSecondarySubDir, "id-3", kFpKey});
494 EXPECT_TRUE(prefs_.SetString(key2_fp, "7.45"));
495 auto key3_fp = prefs_.CreateSubKey({kTertiarySubDir, "id-3", kFpKey});
496 EXPECT_TRUE(prefs_.SetString(key3_fp, "7.45"));
497
498 // Delete key in platform and given namespaces.
499 prefs_.Delete(kFpKey, {kFirstSubDir, kSecondarySubDir});
500
501 EXPECT_FALSE(prefs_.Exists(kFpKey));
502 EXPECT_FALSE(prefs_.Exists(key1_fp));
503 EXPECT_FALSE(prefs_.Exists(key2_fp));
504
505 // Tertiary namespace not given to delete. Key should still exist.
506 EXPECT_TRUE(prefs_.Exists(key3_fp));
507 }
508
509 class MockPrefsObserver : public PrefsInterface::ObserverInterface {
510 public:
511 MOCK_METHOD1(OnPrefSet, void(std::string_view));
512 MOCK_METHOD1(OnPrefDeleted, void(std::string_view));
513 };
514
TEST_F(PrefsTest,ObserversCalled)515 TEST_F(PrefsTest, ObserversCalled) {
516 MockPrefsObserver mock_obserser;
517 prefs_.AddObserver(kKey, &mock_obserser);
518
519 EXPECT_CALL(mock_obserser, OnPrefSet(Eq(kKey)));
520 EXPECT_CALL(mock_obserser, OnPrefDeleted(_)).Times(0);
521 prefs_.SetString(kKey, "value");
522 testing::Mock::VerifyAndClearExpectations(&mock_obserser);
523
524 EXPECT_CALL(mock_obserser, OnPrefSet(_)).Times(0);
525 EXPECT_CALL(mock_obserser, OnPrefDeleted(Eq(kKey)));
526 prefs_.Delete(kKey);
527 testing::Mock::VerifyAndClearExpectations(&mock_obserser);
528
529 auto key1 = prefs_.CreateSubKey({"ns", "sp1", "key1"});
530 prefs_.AddObserver(key1, &mock_obserser);
531
532 EXPECT_CALL(mock_obserser, OnPrefSet(key1));
533 EXPECT_CALL(mock_obserser, OnPrefDeleted(_)).Times(0);
534 prefs_.SetString(key1, "value");
535 testing::Mock::VerifyAndClearExpectations(&mock_obserser);
536
537 EXPECT_CALL(mock_obserser, OnPrefSet(_)).Times(0);
538 EXPECT_CALL(mock_obserser, OnPrefDeleted(Eq(key1)));
539 prefs_.Delete(key1);
540 testing::Mock::VerifyAndClearExpectations(&mock_obserser);
541
542 prefs_.RemoveObserver(kKey, &mock_obserser);
543 }
544
TEST_F(PrefsTest,OnlyCalledOnObservedKeys)545 TEST_F(PrefsTest, OnlyCalledOnObservedKeys) {
546 MockPrefsObserver mock_obserser;
547 const char kUnusedKey[] = "unused-key";
548 prefs_.AddObserver(kUnusedKey, &mock_obserser);
549
550 EXPECT_CALL(mock_obserser, OnPrefSet(_)).Times(0);
551 EXPECT_CALL(mock_obserser, OnPrefDeleted(_)).Times(0);
552 prefs_.SetString(kKey, "value");
553 prefs_.Delete(kKey);
554
555 prefs_.RemoveObserver(kUnusedKey, &mock_obserser);
556 }
557
TEST_F(PrefsTest,RemovedObserversNotCalled)558 TEST_F(PrefsTest, RemovedObserversNotCalled) {
559 MockPrefsObserver mock_obserser_a, mock_obserser_b;
560 prefs_.AddObserver(kKey, &mock_obserser_a);
561 prefs_.AddObserver(kKey, &mock_obserser_b);
562 EXPECT_CALL(mock_obserser_a, OnPrefSet(_)).Times(2);
563 EXPECT_CALL(mock_obserser_b, OnPrefSet(_)).Times(1);
564 EXPECT_TRUE(prefs_.SetString(kKey, "value"));
565 prefs_.RemoveObserver(kKey, &mock_obserser_b);
566 EXPECT_TRUE(prefs_.SetString(kKey, "other value"));
567 prefs_.RemoveObserver(kKey, &mock_obserser_a);
568 EXPECT_TRUE(prefs_.SetString(kKey, "yet another value"));
569 }
570
TEST_F(PrefsTest,UnsuccessfulCallsNotObserved)571 TEST_F(PrefsTest, UnsuccessfulCallsNotObserved) {
572 MockPrefsObserver mock_obserser;
573 const char kInvalidKey[] = "no spaces or .";
574 prefs_.AddObserver(kInvalidKey, &mock_obserser);
575
576 EXPECT_CALL(mock_obserser, OnPrefSet(_)).Times(0);
577 EXPECT_CALL(mock_obserser, OnPrefDeleted(_)).Times(0);
578 EXPECT_FALSE(prefs_.SetString(kInvalidKey, "value"));
579 EXPECT_FALSE(prefs_.Delete(kInvalidKey));
580
581 prefs_.RemoveObserver(kInvalidKey, &mock_obserser);
582 }
583
TEST_F(PrefsTest,MultiNamespaceKeyTest)584 TEST_F(PrefsTest, MultiNamespaceKeyTest) {
585 MultiNamespaceKeyTest();
586 }
587
588 class MemoryPrefsTest : public BasePrefsTest {
589 protected:
SetUp()590 void SetUp() override { common_prefs_ = &prefs_; }
591
592 MemoryPrefs prefs_;
593 };
594
TEST_F(MemoryPrefsTest,BasicTest)595 TEST_F(MemoryPrefsTest, BasicTest) {
596 EXPECT_FALSE(prefs_.Exists(kKey));
597 int64_t value = 0;
598 EXPECT_FALSE(prefs_.GetInt64(kKey, &value));
599
600 EXPECT_TRUE(prefs_.SetInt64(kKey, 1234));
601 EXPECT_TRUE(prefs_.Exists(kKey));
602 EXPECT_TRUE(prefs_.GetInt64(kKey, &value));
603 EXPECT_EQ(1234, value);
604
605 EXPECT_TRUE(prefs_.Delete(kKey));
606 EXPECT_FALSE(prefs_.Exists(kKey));
607 EXPECT_TRUE(prefs_.Delete(kKey));
608
609 auto key = prefs_.CreateSubKey({"ns", "sp", "sk"});
610 ASSERT_TRUE(prefs_.SetInt64(key, 0));
611 EXPECT_TRUE(prefs_.Exists(key));
612 EXPECT_TRUE(prefs_.Delete(kKey));
613 }
614
TEST_F(MemoryPrefsTest,MultiNamespaceKeyTest)615 TEST_F(MemoryPrefsTest, MultiNamespaceKeyTest) {
616 MultiNamespaceKeyTest();
617 }
618
619 } // namespace chromeos_update_engine
620