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 
24 #include <base/files/file_util.h>
25 #include <base/files/scoped_temp_dir.h>
26 #include <base/macros.h>
27 #include <base/strings/string_util.h>
28 #include <base/strings/stringprintf.h>
29 #include <gmock/gmock.h>
30 #include <gtest/gtest.h>
31 
32 using std::string;
33 using testing::Eq;
34 using testing::_;
35 
36 namespace {
37 // Test key used along the tests.
38 const char kKey[] = "test-key";
39 }
40 
41 namespace chromeos_update_engine {
42 
43 class PrefsTest : public ::testing::Test {
44  protected:
SetUp()45   void SetUp() override {
46     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
47     prefs_dir_ = temp_dir_.path();
48     ASSERT_TRUE(prefs_.Init(prefs_dir_));
49   }
50 
SetValue(const string & key,const string & value)51   bool SetValue(const string& key, const string& value) {
52     return base::WriteFile(prefs_dir_.Append(key), value.data(),
53                            value.length()) == static_cast<int>(value.length());
54   }
55 
56   base::ScopedTempDir temp_dir_;
57   base::FilePath prefs_dir_;
58   Prefs prefs_;
59 };
60 
TEST_F(PrefsTest,GetFileNameForKey)61 TEST_F(PrefsTest, GetFileNameForKey) {
62   const char kAllvalidCharsKey[] =
63       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-";
64   base::FilePath path;
65   EXPECT_TRUE(prefs_.file_storage_.GetFileNameForKey(kAllvalidCharsKey, &path));
66   EXPECT_EQ(prefs_dir_.Append(kAllvalidCharsKey).value(), path.value());
67 }
68 
TEST_F(PrefsTest,GetFileNameForKeyBadCharacter)69 TEST_F(PrefsTest, GetFileNameForKeyBadCharacter) {
70   base::FilePath path;
71   EXPECT_FALSE(prefs_.file_storage_.GetFileNameForKey("ABC abc", &path));
72 }
73 
TEST_F(PrefsTest,GetFileNameForKeyEmpty)74 TEST_F(PrefsTest, GetFileNameForKeyEmpty) {
75   base::FilePath path;
76   EXPECT_FALSE(prefs_.file_storage_.GetFileNameForKey("", &path));
77 }
78 
TEST_F(PrefsTest,GetString)79 TEST_F(PrefsTest, GetString) {
80   const string test_data = "test data";
81   ASSERT_TRUE(SetValue(kKey, test_data));
82   string value;
83   EXPECT_TRUE(prefs_.GetString(kKey, &value));
84   EXPECT_EQ(test_data, value);
85 }
86 
TEST_F(PrefsTest,GetStringBadKey)87 TEST_F(PrefsTest, GetStringBadKey) {
88   string value;
89   EXPECT_FALSE(prefs_.GetString(",bad", &value));
90 }
91 
TEST_F(PrefsTest,GetStringNonExistentKey)92 TEST_F(PrefsTest, GetStringNonExistentKey) {
93   string value;
94   EXPECT_FALSE(prefs_.GetString("non-existent-key", &value));
95 }
96 
TEST_F(PrefsTest,SetString)97 TEST_F(PrefsTest, SetString) {
98   const char kValue[] = "some test value\non 2 lines";
99   EXPECT_TRUE(prefs_.SetString(kKey, kValue));
100   string value;
101   EXPECT_TRUE(base::ReadFileToString(prefs_dir_.Append(kKey), &value));
102   EXPECT_EQ(kValue, value);
103 }
104 
TEST_F(PrefsTest,SetStringBadKey)105 TEST_F(PrefsTest, SetStringBadKey) {
106   const char kKeyWithDots[] = ".no-dots";
107   EXPECT_FALSE(prefs_.SetString(kKeyWithDots, "some value"));
108   EXPECT_FALSE(base::PathExists(prefs_dir_.Append(kKeyWithDots)));
109 }
110 
TEST_F(PrefsTest,SetStringCreateDir)111 TEST_F(PrefsTest, SetStringCreateDir) {
112   const char kValue[] = "test value";
113   base::FilePath subdir = prefs_dir_.Append("subdir1").Append("subdir2");
114   EXPECT_TRUE(prefs_.Init(subdir));
115   EXPECT_TRUE(prefs_.SetString(kKey, kValue));
116   string value;
117   EXPECT_TRUE(base::ReadFileToString(subdir.Append(kKey), &value));
118   EXPECT_EQ(kValue, value);
119 }
120 
TEST_F(PrefsTest,SetStringDirCreationFailure)121 TEST_F(PrefsTest, SetStringDirCreationFailure) {
122   EXPECT_TRUE(prefs_.Init(base::FilePath("/dev/null")));
123   EXPECT_FALSE(prefs_.SetString(kKey, "test value"));
124 }
125 
TEST_F(PrefsTest,SetStringFileCreationFailure)126 TEST_F(PrefsTest, SetStringFileCreationFailure) {
127   base::CreateDirectory(prefs_dir_.Append(kKey));
128   EXPECT_FALSE(prefs_.SetString(kKey, "test value"));
129   EXPECT_TRUE(base::DirectoryExists(prefs_dir_.Append(kKey)));
130 }
131 
TEST_F(PrefsTest,GetInt64)132 TEST_F(PrefsTest, GetInt64) {
133   ASSERT_TRUE(SetValue(kKey, " \n 25 \t "));
134   int64_t value;
135   EXPECT_TRUE(prefs_.GetInt64(kKey, &value));
136   EXPECT_EQ(25, value);
137 }
138 
TEST_F(PrefsTest,GetInt64BadValue)139 TEST_F(PrefsTest, GetInt64BadValue) {
140   ASSERT_TRUE(SetValue(kKey, "30a"));
141   int64_t value;
142   EXPECT_FALSE(prefs_.GetInt64(kKey, &value));
143 }
144 
TEST_F(PrefsTest,GetInt64Max)145 TEST_F(PrefsTest, GetInt64Max) {
146   ASSERT_TRUE(SetValue(kKey, base::StringPrintf(
147       "%" PRIi64, std::numeric_limits<int64_t>::max())));
148   int64_t value;
149   EXPECT_TRUE(prefs_.GetInt64(kKey, &value));
150   EXPECT_EQ(std::numeric_limits<int64_t>::max(), value);
151 }
152 
TEST_F(PrefsTest,GetInt64Min)153 TEST_F(PrefsTest, GetInt64Min) {
154   ASSERT_TRUE(SetValue(kKey, base::StringPrintf(
155         "%" PRIi64, std::numeric_limits<int64_t>::min())));
156   int64_t value;
157   EXPECT_TRUE(prefs_.GetInt64(kKey, &value));
158   EXPECT_EQ(std::numeric_limits<int64_t>::min(), value);
159 }
160 
TEST_F(PrefsTest,GetInt64Negative)161 TEST_F(PrefsTest, GetInt64Negative) {
162   ASSERT_TRUE(SetValue(kKey, " \t -100 \n "));
163   int64_t value;
164   EXPECT_TRUE(prefs_.GetInt64(kKey, &value));
165   EXPECT_EQ(-100, value);
166 }
167 
TEST_F(PrefsTest,GetInt64NonExistentKey)168 TEST_F(PrefsTest, GetInt64NonExistentKey) {
169   int64_t value;
170   EXPECT_FALSE(prefs_.GetInt64("random-key", &value));
171 }
172 
TEST_F(PrefsTest,SetInt64)173 TEST_F(PrefsTest, SetInt64) {
174   EXPECT_TRUE(prefs_.SetInt64(kKey, -123));
175   string value;
176   EXPECT_TRUE(base::ReadFileToString(prefs_dir_.Append(kKey), &value));
177   EXPECT_EQ("-123", value);
178 }
179 
TEST_F(PrefsTest,SetInt64BadKey)180 TEST_F(PrefsTest, SetInt64BadKey) {
181   const char kKeyWithSpaces[] = "s p a c e s";
182   EXPECT_FALSE(prefs_.SetInt64(kKeyWithSpaces, 20));
183   EXPECT_FALSE(base::PathExists(prefs_dir_.Append(kKeyWithSpaces)));
184 }
185 
TEST_F(PrefsTest,SetInt64Max)186 TEST_F(PrefsTest, SetInt64Max) {
187   EXPECT_TRUE(prefs_.SetInt64(kKey, std::numeric_limits<int64_t>::max()));
188   string value;
189   EXPECT_TRUE(base::ReadFileToString(prefs_dir_.Append(kKey), &value));
190   EXPECT_EQ(base::StringPrintf("%" PRIi64, std::numeric_limits<int64_t>::max()),
191             value);
192 }
193 
TEST_F(PrefsTest,SetInt64Min)194 TEST_F(PrefsTest, SetInt64Min) {
195   EXPECT_TRUE(prefs_.SetInt64(kKey, std::numeric_limits<int64_t>::min()));
196   string value;
197   EXPECT_TRUE(base::ReadFileToString(prefs_dir_.Append(kKey), &value));
198   EXPECT_EQ(base::StringPrintf("%" PRIi64, std::numeric_limits<int64_t>::min()),
199             value);
200 }
201 
TEST_F(PrefsTest,GetBooleanFalse)202 TEST_F(PrefsTest, GetBooleanFalse) {
203   ASSERT_TRUE(SetValue(kKey, " \n false \t "));
204   bool value;
205   EXPECT_TRUE(prefs_.GetBoolean(kKey, &value));
206   EXPECT_FALSE(value);
207 }
208 
TEST_F(PrefsTest,GetBooleanTrue)209 TEST_F(PrefsTest, GetBooleanTrue) {
210   const char kKey[] = "test-key";
211   ASSERT_TRUE(SetValue(kKey, " \t true \n "));
212   bool value;
213   EXPECT_TRUE(prefs_.GetBoolean(kKey, &value));
214   EXPECT_TRUE(value);
215 }
216 
TEST_F(PrefsTest,GetBooleanBadValue)217 TEST_F(PrefsTest, GetBooleanBadValue) {
218   const char kKey[] = "test-key";
219   ASSERT_TRUE(SetValue(kKey, "1"));
220   bool value;
221   EXPECT_FALSE(prefs_.GetBoolean(kKey, &value));
222 }
223 
TEST_F(PrefsTest,GetBooleanBadEmptyValue)224 TEST_F(PrefsTest, GetBooleanBadEmptyValue) {
225   const char kKey[] = "test-key";
226   ASSERT_TRUE(SetValue(kKey, ""));
227   bool value;
228   EXPECT_FALSE(prefs_.GetBoolean(kKey, &value));
229 }
230 
TEST_F(PrefsTest,GetBooleanNonExistentKey)231 TEST_F(PrefsTest, GetBooleanNonExistentKey) {
232   bool value;
233   EXPECT_FALSE(prefs_.GetBoolean("random-key", &value));
234 }
235 
TEST_F(PrefsTest,SetBooleanTrue)236 TEST_F(PrefsTest, SetBooleanTrue) {
237   const char kKey[] = "test-bool";
238   EXPECT_TRUE(prefs_.SetBoolean(kKey, true));
239   string value;
240   EXPECT_TRUE(base::ReadFileToString(prefs_dir_.Append(kKey), &value));
241   EXPECT_EQ("true", value);
242 }
243 
TEST_F(PrefsTest,SetBooleanFalse)244 TEST_F(PrefsTest, SetBooleanFalse) {
245   const char kKey[] = "test-bool";
246   EXPECT_TRUE(prefs_.SetBoolean(kKey, false));
247   string value;
248   EXPECT_TRUE(base::ReadFileToString(prefs_dir_.Append(kKey), &value));
249   EXPECT_EQ("false", value);
250 }
251 
TEST_F(PrefsTest,SetBooleanBadKey)252 TEST_F(PrefsTest, SetBooleanBadKey) {
253   const char kKey[] = "s p a c e s";
254   EXPECT_FALSE(prefs_.SetBoolean(kKey, true));
255   EXPECT_FALSE(base::PathExists(prefs_dir_.Append(kKey)));
256 }
257 
TEST_F(PrefsTest,ExistsWorks)258 TEST_F(PrefsTest, ExistsWorks) {
259   // test that the key doesn't exist before we set it.
260   EXPECT_FALSE(prefs_.Exists(kKey));
261 
262   // test that the key exists after we set it.
263   ASSERT_TRUE(prefs_.SetInt64(kKey, 8));
264   EXPECT_TRUE(prefs_.Exists(kKey));
265 }
266 
TEST_F(PrefsTest,DeleteWorks)267 TEST_F(PrefsTest, DeleteWorks) {
268   // test that it's alright to delete a non-existent key.
269   EXPECT_TRUE(prefs_.Delete(kKey));
270 
271   // delete the key after we set it.
272   ASSERT_TRUE(prefs_.SetInt64(kKey, 0));
273   EXPECT_TRUE(prefs_.Delete(kKey));
274 
275   // make sure it doesn't exist anymore.
276   EXPECT_FALSE(prefs_.Exists(kKey));
277 }
278 
279 class MockPrefsObserver : public PrefsInterface::ObserverInterface {
280  public:
281   MOCK_METHOD1(OnPrefSet, void(const string&));
282   MOCK_METHOD1(OnPrefDeleted, void(const string& key));
283 };
284 
TEST_F(PrefsTest,ObserversCalled)285 TEST_F(PrefsTest, ObserversCalled) {
286   MockPrefsObserver mock_obserser;
287   prefs_.AddObserver(kKey, &mock_obserser);
288 
289   EXPECT_CALL(mock_obserser, OnPrefSet(Eq(kKey)));
290   EXPECT_CALL(mock_obserser, OnPrefDeleted(_)).Times(0);
291   prefs_.SetString(kKey, "value");
292   testing::Mock::VerifyAndClearExpectations(&mock_obserser);
293 
294   EXPECT_CALL(mock_obserser, OnPrefSet(_)).Times(0);
295   EXPECT_CALL(mock_obserser, OnPrefDeleted(Eq(kKey)));
296   prefs_.Delete(kKey);
297   testing::Mock::VerifyAndClearExpectations(&mock_obserser);
298 
299   prefs_.RemoveObserver(kKey, &mock_obserser);
300 }
301 
TEST_F(PrefsTest,OnlyCalledOnObservedKeys)302 TEST_F(PrefsTest, OnlyCalledOnObservedKeys) {
303   MockPrefsObserver mock_obserser;
304   const char kUnusedKey[] = "unused-key";
305   prefs_.AddObserver(kUnusedKey, &mock_obserser);
306 
307   EXPECT_CALL(mock_obserser, OnPrefSet(_)).Times(0);
308   EXPECT_CALL(mock_obserser, OnPrefDeleted(_)).Times(0);
309   prefs_.SetString(kKey, "value");
310   prefs_.Delete(kKey);
311 
312   prefs_.RemoveObserver(kUnusedKey, &mock_obserser);
313 }
314 
TEST_F(PrefsTest,RemovedObserversNotCalled)315 TEST_F(PrefsTest, RemovedObserversNotCalled) {
316   MockPrefsObserver mock_obserser_a, mock_obserser_b;
317   prefs_.AddObserver(kKey, &mock_obserser_a);
318   prefs_.AddObserver(kKey, &mock_obserser_b);
319   EXPECT_CALL(mock_obserser_a, OnPrefSet(_)).Times(2);
320   EXPECT_CALL(mock_obserser_b, OnPrefSet(_)).Times(1);
321   EXPECT_TRUE(prefs_.SetString(kKey, "value"));
322   prefs_.RemoveObserver(kKey, &mock_obserser_b);
323   EXPECT_TRUE(prefs_.SetString(kKey, "other value"));
324   prefs_.RemoveObserver(kKey, &mock_obserser_a);
325   EXPECT_TRUE(prefs_.SetString(kKey, "yet another value"));
326 }
327 
TEST_F(PrefsTest,UnsuccessfulCallsNotObserved)328 TEST_F(PrefsTest, UnsuccessfulCallsNotObserved) {
329   MockPrefsObserver mock_obserser;
330   const char kInvalidKey[] = "no spaces or .";
331   prefs_.AddObserver(kInvalidKey, &mock_obserser);
332 
333   EXPECT_CALL(mock_obserser, OnPrefSet(_)).Times(0);
334   EXPECT_CALL(mock_obserser, OnPrefDeleted(_)).Times(0);
335   EXPECT_FALSE(prefs_.SetString(kInvalidKey, "value"));
336   EXPECT_FALSE(prefs_.Delete(kInvalidKey));
337 
338   prefs_.RemoveObserver(kInvalidKey, &mock_obserser);
339 }
340 
341 class MemoryPrefsTest : public ::testing::Test {
342  protected:
343   MemoryPrefs prefs_;
344 };
345 
TEST_F(MemoryPrefsTest,BasicTest)346 TEST_F(MemoryPrefsTest, BasicTest) {
347   EXPECT_FALSE(prefs_.Exists(kKey));
348   int64_t value = 0;
349   EXPECT_FALSE(prefs_.GetInt64(kKey, &value));
350 
351   EXPECT_TRUE(prefs_.SetInt64(kKey, 1234));
352   EXPECT_TRUE(prefs_.Exists(kKey));
353   EXPECT_TRUE(prefs_.GetInt64(kKey, &value));
354   EXPECT_EQ(1234, value);
355 
356   EXPECT_TRUE(prefs_.Delete(kKey));
357   EXPECT_FALSE(prefs_.Exists(kKey));
358   EXPECT_FALSE(prefs_.Delete(kKey));
359 }
360 
361 }  // namespace chromeos_update_engine
362