invalidator_storage_unittest.cc revision ca12bfac764ba476d6cd062bf1dde12cc64c3f40 
1// Copyright (c) 2012 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
5#include "chrome/browser/invalidation/invalidator_storage.h"
6
7#include "base/bind.h"
8#include "base/message_loop/message_loop.h"
9#include "base/message_loop/message_loop_proxy.h"
10#include "base/prefs/pref_service.h"
11#include "base/strings/string_number_conversions.h"
12#include "base/strings/string_util.h"
13#include "chrome/common/pref_names.h"
14#include "chrome/test/base/testing_pref_service_syncable.h"
15#include "sync/internal_api/public/base/invalidation_test_util.h"
16#include "testing/gmock/include/gmock/gmock.h"
17#include "testing/gtest/include/gtest/gtest.h"
18
19using syncer::InvalidationStateMap;
20
21namespace {
22
23const char kSourceKey[] = "source";
24const char kNameKey[] = "name";
25const char kMaxVersionKey[] = "max-version";
26const char kPayloadKey[] = "payload";
27const char kCurrentAckHandleKey[] = "current-ack";
28const char kExpectedAckHandleKey[] = "expected-ack";
29
30const int kChromeSyncSourceId = 1004;
31
32void GenerateAckHandlesTestHelper(syncer::AckHandleMap* output,
33                                  const syncer::AckHandleMap& input) {
34  *output = input;
35}
36
37}  // namespace
38
39namespace invalidation {
40
41class InvalidatorStorageTest : public testing::Test {
42 public:
43  InvalidatorStorageTest()
44      : kBookmarksId_(kChromeSyncSourceId, "BOOKMARK"),
45        kPreferencesId_(kChromeSyncSourceId, "PREFERENCE"),
46        kAppNotificationsId_(kChromeSyncSourceId, "APP_NOTIFICATION"),
47        kAutofillId_(kChromeSyncSourceId, "AUTOFILL") {}
48
49  virtual void SetUp() {
50    InvalidatorStorage::RegisterProfilePrefs(pref_service_.registry());
51  }
52
53 protected:
54  TestingPrefServiceSyncable pref_service_;
55
56  const invalidation::ObjectId kBookmarksId_;
57  const invalidation::ObjectId kPreferencesId_;
58  const invalidation::ObjectId kAppNotificationsId_;
59  const invalidation::ObjectId kAutofillId_;
60
61  base::MessageLoop loop_;
62};
63
64// Set invalidation states for various keys and verify that they are written and
65// read back correctly.
66TEST_F(InvalidatorStorageTest, SetMaxVersionAndPayload) {
67  InvalidatorStorage storage(&pref_service_);
68
69  InvalidationStateMap expected_states;
70  EXPECT_EQ(expected_states, storage.GetAllInvalidationStates());
71
72  expected_states[kBookmarksId_].version = 2;
73  expected_states[kBookmarksId_].payload = "hello";
74  storage.SetMaxVersionAndPayload(kBookmarksId_, 2, "hello");
75  EXPECT_EQ(expected_states, storage.GetAllInvalidationStates());
76
77  expected_states[kPreferencesId_].version = 5;
78  storage.SetMaxVersionAndPayload(kPreferencesId_, 5, std::string());
79  EXPECT_EQ(expected_states, storage.GetAllInvalidationStates());
80
81  expected_states[kAppNotificationsId_].version = 3;
82  expected_states[kAppNotificationsId_].payload = "world";
83  storage.SetMaxVersionAndPayload(kAppNotificationsId_, 3, "world");
84  EXPECT_EQ(expected_states, storage.GetAllInvalidationStates());
85
86  expected_states[kAppNotificationsId_].version = 4;
87  expected_states[kAppNotificationsId_].payload = "again";
88  storage.SetMaxVersionAndPayload(kAppNotificationsId_, 4, "again");
89  EXPECT_EQ(expected_states, storage.GetAllInvalidationStates());
90}
91
92// Forgetting an entry should cause that entry to be deleted.
93TEST_F(InvalidatorStorageTest, Forget) {
94  InvalidatorStorage storage(&pref_service_);
95  EXPECT_TRUE(storage.GetAllInvalidationStates().empty());
96
97  InvalidationStateMap expected_states;
98  expected_states[kBookmarksId_].version = 2;
99  expected_states[kBookmarksId_].payload = "a";
100  expected_states[kPreferencesId_].version = 5;
101  expected_states[kPreferencesId_].payload = "b";
102  storage.SetMaxVersionAndPayload(kBookmarksId_, 2, "a");
103  storage.SetMaxVersionAndPayload(kPreferencesId_, 5, "b");
104  EXPECT_EQ(expected_states, storage.GetAllInvalidationStates());
105
106  expected_states.erase(kPreferencesId_);
107  syncer::ObjectIdSet to_forget;
108  to_forget.insert(kPreferencesId_);
109  storage.Forget(to_forget);
110  EXPECT_EQ(expected_states, storage.GetAllInvalidationStates());
111}
112
113// Clearing the storage should erase all version map entries, bootstrap data,
114// and the client ID.
115TEST_F(InvalidatorStorageTest, Clear) {
116  InvalidatorStorage storage(&pref_service_);
117  EXPECT_TRUE(storage.GetAllInvalidationStates().empty());
118  EXPECT_TRUE(storage.GetBootstrapData().empty());
119  EXPECT_TRUE(storage.GetInvalidatorClientId().empty());
120
121  storage.SetInvalidatorClientId("fake_id");
122  EXPECT_EQ("fake_id", storage.GetInvalidatorClientId());
123
124  storage.SetBootstrapData("test");
125  EXPECT_EQ("test", storage.GetBootstrapData());
126
127  {
128    InvalidationStateMap expected_states;
129    expected_states[kAppNotificationsId_].version = 3;
130    storage.SetMaxVersionAndPayload(kAppNotificationsId_, 3, std::string());
131    EXPECT_EQ(expected_states, storage.GetAllInvalidationStates());
132  }
133
134  storage.Clear();
135
136  EXPECT_TRUE(storage.GetAllInvalidationStates().empty());
137  EXPECT_TRUE(storage.GetBootstrapData().empty());
138  EXPECT_TRUE(storage.GetInvalidatorClientId().empty());
139}
140
141TEST_F(InvalidatorStorageTest, SerializeEmptyMap) {
142  InvalidationStateMap empty_map;
143  base::ListValue list;
144  InvalidatorStorage::SerializeToList(empty_map, &list);
145  EXPECT_TRUE(list.empty());
146}
147
148// Make sure we don't choke on a variety of malformed input.
149TEST_F(InvalidatorStorageTest, DeserializeFromListInvalidFormat) {
150  InvalidationStateMap map;
151  base::ListValue list_with_invalid_format;
152  DictionaryValue* value;
153
154  // The various cases below use distinct values to make it easier to track down
155  // failures.
156  value = new DictionaryValue();
157  list_with_invalid_format.Append(value);
158
159  value = new DictionaryValue();
160  value->SetString("completely", "invalid");
161  list_with_invalid_format.Append(value);
162
163  // Missing two required fields
164  value = new DictionaryValue();
165  value->SetString(kSourceKey, "10");
166  list_with_invalid_format.Append(value);
167
168  value = new DictionaryValue();
169  value->SetString(kNameKey, "missing source and version");
170  list_with_invalid_format.Append(value);
171
172  value = new DictionaryValue();
173  value->SetString(kMaxVersionKey, "3");
174  list_with_invalid_format.Append(value);
175
176  // Missing one required field
177  value = new DictionaryValue();
178  value->SetString(kSourceKey, "14");
179  value->SetString(kNameKey, "missing version");
180  list_with_invalid_format.Append(value);
181
182  value = new DictionaryValue();
183  value->SetString(kSourceKey, "233");
184  value->SetString(kMaxVersionKey, "5");
185  list_with_invalid_format.Append(value);
186
187  value = new DictionaryValue();
188  value->SetString(kNameKey, "missing source");
189  value->SetString(kMaxVersionKey, "25");
190  list_with_invalid_format.Append(value);
191
192  // Invalid values in fields
193  value = new DictionaryValue();
194  value->SetString(kSourceKey, "a");
195  value->SetString(kNameKey, "bad source");
196  value->SetString(kMaxVersionKey, "12");
197  list_with_invalid_format.Append(value);
198
199  value = new DictionaryValue();
200  value->SetString(kSourceKey, "1");
201  value->SetString(kNameKey, "bad max version");
202  value->SetString(kMaxVersionKey, "a");
203  list_with_invalid_format.Append(value);
204
205  // And finally something that should work.
206  invalidation::ObjectId valid_id(42, "this should work");
207  value = new DictionaryValue();
208  value->SetString(kSourceKey, "42");
209  value->SetString(kNameKey, valid_id.name());
210  value->SetString(kMaxVersionKey, "20");
211  list_with_invalid_format.Append(value);
212
213  InvalidatorStorage::DeserializeFromList(list_with_invalid_format, &map);
214
215  EXPECT_EQ(1U, map.size());
216  EXPECT_EQ(20, map[valid_id].version);
217}
218
219// Tests behavior when there are duplicate entries for a single key. The value
220// of the last entry with that key should be used in the version map.
221TEST_F(InvalidatorStorageTest, DeserializeFromListWithDuplicates) {
222  InvalidationStateMap map;
223  base::ListValue list;
224  DictionaryValue* value;
225
226  value = new DictionaryValue();
227  value->SetString(kSourceKey, base::IntToString(kBookmarksId_.source()));
228  value->SetString(kNameKey, kBookmarksId_.name());
229  value->SetString(kMaxVersionKey, "20");
230  list.Append(value);
231  value = new DictionaryValue();
232  value->SetString(kSourceKey, base::IntToString(kAutofillId_.source()));
233  value->SetString(kNameKey, kAutofillId_.name());
234  value->SetString(kMaxVersionKey, "10");
235  list.Append(value);
236  value = new DictionaryValue();
237  value->SetString(kSourceKey, base::IntToString(kBookmarksId_.source()));
238  value->SetString(kNameKey, kBookmarksId_.name());
239  value->SetString(kMaxVersionKey, "15");
240  list.Append(value);
241
242  InvalidatorStorage::DeserializeFromList(list, &map);
243  EXPECT_EQ(2U, map.size());
244  EXPECT_EQ(10, map[kAutofillId_].version);
245  EXPECT_EQ(15, map[kBookmarksId_].version);
246}
247
248TEST_F(InvalidatorStorageTest, DeserializeFromEmptyList) {
249  InvalidationStateMap map;
250  base::ListValue list;
251  InvalidatorStorage::DeserializeFromList(list, &map);
252  EXPECT_TRUE(map.empty());
253}
254
255// Tests that deserializing a well-formed value results in the expected state
256// map.
257TEST_F(InvalidatorStorageTest, DeserializeFromListBasic) {
258  InvalidationStateMap map;
259  base::ListValue list;
260  DictionaryValue* value;
261  syncer::AckHandle ack_handle_1 = syncer::AckHandle::CreateUnique();
262  syncer::AckHandle ack_handle_2 = syncer::AckHandle::CreateUnique();
263
264  value = new DictionaryValue();
265  value->SetString(kSourceKey,
266                   base::IntToString(kAppNotificationsId_.source()));
267  value->SetString(kNameKey, kAppNotificationsId_.name());
268  value->SetString(kMaxVersionKey, "20");
269  value->SetString(kPayloadKey, "testing");
270  value->Set(kCurrentAckHandleKey, ack_handle_1.ToValue().release());
271  value->Set(kExpectedAckHandleKey, ack_handle_2.ToValue().release());
272  list.Append(value);
273
274  InvalidatorStorage::DeserializeFromList(list, &map);
275  EXPECT_EQ(1U, map.size());
276  EXPECT_EQ(20, map[kAppNotificationsId_].version);
277  EXPECT_EQ("testing", map[kAppNotificationsId_].payload);
278  EXPECT_THAT(map[kAppNotificationsId_].current, Eq(ack_handle_1));
279  EXPECT_THAT(map[kAppNotificationsId_].expected, Eq(ack_handle_2));
280}
281
282// Tests that deserializing well-formed values when optional parameters are
283// omitted works.
284TEST_F(InvalidatorStorageTest, DeserializeFromListMissingOptionalValues) {
285  InvalidationStateMap map;
286  base::ListValue list;
287  DictionaryValue* value;
288  syncer::AckHandle ack_handle = syncer::AckHandle::CreateUnique();
289
290  // Payload missing because of an upgrade from a previous browser version that
291  // didn't set the field.
292  value = new DictionaryValue();
293  value->SetString(kSourceKey, base::IntToString(kAutofillId_.source()));
294  value->SetString(kNameKey, kAutofillId_.name());
295  value->SetString(kMaxVersionKey, "10");
296  list.Append(value);
297  // A crash between SetMaxVersion() and a callback from GenerateAckHandles()
298  // could result in this state.
299  value = new DictionaryValue();
300  value->SetString(kSourceKey, base::IntToString(kBookmarksId_.source()));
301  value->SetString(kNameKey, kBookmarksId_.name());
302  value->SetString(kMaxVersionKey, "15");
303  value->SetString(kPayloadKey, "hello");
304  list.Append(value);
305  // Never acknowledged, so current ack handle is unset.
306  value = new DictionaryValue();
307  value->SetString(kSourceKey, base::IntToString(kPreferencesId_.source()));
308  value->SetString(kNameKey, kPreferencesId_.name());
309  value->SetString(kMaxVersionKey, "20");
310  value->SetString(kPayloadKey, "world");
311  value->Set(kExpectedAckHandleKey, ack_handle.ToValue().release());
312  list.Append(value);
313
314  InvalidatorStorage::DeserializeFromList(list, &map);
315  EXPECT_EQ(3U, map.size());
316
317  EXPECT_EQ(10, map[kAutofillId_].version);
318  EXPECT_EQ("", map[kAutofillId_].payload);
319  EXPECT_FALSE(map[kAutofillId_].current.IsValid());
320  EXPECT_FALSE(map[kAutofillId_].expected.IsValid());
321
322  EXPECT_EQ(15, map[kBookmarksId_].version);
323  EXPECT_EQ("hello", map[kBookmarksId_].payload);
324  EXPECT_FALSE(map[kBookmarksId_].current.IsValid());
325  EXPECT_FALSE(map[kBookmarksId_].expected.IsValid());
326
327  EXPECT_EQ(20, map[kPreferencesId_].version);
328  EXPECT_EQ("world", map[kPreferencesId_].payload);
329  EXPECT_FALSE(map[kPreferencesId_].current.IsValid());
330  EXPECT_THAT(map[kPreferencesId_].expected, Eq(ack_handle));
331}
332
333// Tests for legacy deserialization code.
334TEST_F(InvalidatorStorageTest, DeserializeMapOutOfRange) {
335  InvalidationStateMap map;
336  base::DictionaryValue dict_with_out_of_range_type;
337
338  dict_with_out_of_range_type.SetString(
339      base::IntToString(syncer::TOP_LEVEL_FOLDER), "100");
340  dict_with_out_of_range_type.SetString(
341      base::IntToString(syncer::BOOKMARKS), "5");
342
343  InvalidatorStorage::DeserializeMap(&dict_with_out_of_range_type, &map);
344
345  EXPECT_EQ(1U, map.size());
346  EXPECT_EQ(5, map[kBookmarksId_].version);
347}
348
349TEST_F(InvalidatorStorageTest, DeserializeMapInvalidFormat) {
350  InvalidationStateMap map;
351  base::DictionaryValue dict_with_invalid_format;
352
353  dict_with_invalid_format.SetString("whoops", "5");
354  dict_with_invalid_format.SetString("ohnoes", "whoops");
355  dict_with_invalid_format.SetString(
356      base::IntToString(syncer::BOOKMARKS), "ohnoes");
357  dict_with_invalid_format.SetString(
358      base::IntToString(syncer::AUTOFILL), "10");
359
360  InvalidatorStorage::DeserializeMap(&dict_with_invalid_format, &map);
361
362  EXPECT_EQ(1U, map.size());
363  EXPECT_EQ(10, map[kAutofillId_].version);
364}
365
366TEST_F(InvalidatorStorageTest, DeserializeMapEmptyDictionary) {
367  InvalidationStateMap map;
368  base::DictionaryValue dict;
369  InvalidatorStorage::DeserializeMap(&dict, &map);
370  EXPECT_TRUE(map.empty());
371}
372
373TEST_F(InvalidatorStorageTest, DeserializeMapBasic) {
374  InvalidationStateMap map;
375  base::DictionaryValue dict;
376
377  dict.SetString(base::IntToString(syncer::AUTOFILL), "10");
378  dict.SetString(base::IntToString(syncer::BOOKMARKS), "15");
379
380  InvalidatorStorage::DeserializeMap(&dict, &map);
381  EXPECT_EQ(2U, map.size());
382  EXPECT_EQ(10, map[kAutofillId_].version);
383  EXPECT_EQ(15, map[kBookmarksId_].version);
384}
385
386// Test that the migration code for the legacy preference works as expected.
387// Migration should happen on construction of InvalidatorStorage.
388TEST_F(InvalidatorStorageTest, MigrateLegacyPreferences) {
389  base::DictionaryValue* legacy_dict = new DictionaryValue;
390  legacy_dict->SetString(base::IntToString(syncer::AUTOFILL), "10");
391  legacy_dict->SetString(base::IntToString(syncer::BOOKMARKS), "32");
392  legacy_dict->SetString(base::IntToString(syncer::PREFERENCES), "54");
393  pref_service_.SetUserPref(prefs::kSyncMaxInvalidationVersions, legacy_dict);
394  InvalidatorStorage storage(&pref_service_);
395
396  // Legacy pref should be cleared.
397  const base::DictionaryValue* dict =
398      pref_service_.GetDictionary(prefs::kSyncMaxInvalidationVersions);
399  EXPECT_TRUE(dict->empty());
400
401  // Validate the new pref is set correctly.
402  InvalidationStateMap map;
403  const base::ListValue* list =
404      pref_service_.GetList(prefs::kInvalidatorMaxInvalidationVersions);
405  InvalidatorStorage::DeserializeFromList(*list, &map);
406
407  EXPECT_EQ(3U, map.size());
408  EXPECT_EQ(10, map[kAutofillId_].version);
409  EXPECT_EQ(32, map[kBookmarksId_].version);
410  EXPECT_EQ(54, map[kPreferencesId_].version);
411}
412
413TEST_F(InvalidatorStorageTest, SetGetNotifierClientId) {
414  InvalidatorStorage storage(&pref_service_);
415  const std::string client_id("fK6eDzAIuKqx9A4+93bljg==");
416
417  storage.SetInvalidatorClientId(client_id);
418  EXPECT_EQ(client_id, storage.GetInvalidatorClientId());
419}
420
421TEST_F(InvalidatorStorageTest, SetGetBootstrapData) {
422  InvalidatorStorage storage(&pref_service_);
423  const std::string mess("n\0tK\0\0l\344", 8);
424  ASSERT_FALSE(IsStringUTF8(mess));
425
426  storage.SetBootstrapData(mess);
427  EXPECT_EQ(mess, storage.GetBootstrapData());
428}
429
430// Test that we correctly generate ack handles, acknowledge them, and persist
431// them.
432TEST_F(InvalidatorStorageTest, GenerateAckHandlesAndAcknowledge) {
433  InvalidatorStorage storage(&pref_service_);
434  syncer::ObjectIdSet ids;
435  InvalidationStateMap state_map;
436  syncer::AckHandleMap ack_handle_map;
437  syncer::AckHandleMap::const_iterator it;
438
439  // Test that it works as expected if the key doesn't already exist in the map,
440  // e.g. the first invalidation received for the object ID was not for a
441  // specific version.
442  ids.insert(kAutofillId_);
443  storage.GenerateAckHandles(
444      ids, base::MessageLoopProxy::current(),
445      base::Bind(&GenerateAckHandlesTestHelper, &ack_handle_map));
446  loop_.RunUntilIdle();
447  EXPECT_EQ(1U, ack_handle_map.size());
448  it = ack_handle_map.find(kAutofillId_);
449  // Android STL appears to be buggy and causes gtest's IsContainerTest<> to
450  // treat an iterator as a STL container so we use != instead of ASSERT_NE.
451  ASSERT_TRUE(ack_handle_map.end() != it);
452  EXPECT_TRUE(it->second.IsValid());
453  state_map[kAutofillId_].expected = it->second;
454  EXPECT_EQ(state_map, storage.GetAllInvalidationStates());
455
456  storage.Acknowledge(kAutofillId_, it->second);
457  state_map[kAutofillId_].current = it->second;
458  EXPECT_EQ(state_map, storage.GetAllInvalidationStates());
459
460  ids.clear();
461
462  // Test that it works as expected if the key already exists.
463  state_map[kBookmarksId_].version = 11;
464  state_map[kBookmarksId_].payload = "hello";
465  storage.SetMaxVersionAndPayload(kBookmarksId_, 11, "hello");
466  EXPECT_EQ(state_map, storage.GetAllInvalidationStates());
467  ids.insert(kBookmarksId_);
468  storage.GenerateAckHandles(
469      ids, base::MessageLoopProxy::current(),
470      base::Bind(&GenerateAckHandlesTestHelper, &ack_handle_map));
471  loop_.RunUntilIdle();
472  EXPECT_EQ(1U, ack_handle_map.size());
473  it = ack_handle_map.find(kBookmarksId_);
474  ASSERT_TRUE(ack_handle_map.end() != it);
475  EXPECT_TRUE(it->second.IsValid());
476  state_map[kBookmarksId_].expected = it->second;
477  EXPECT_EQ(state_map, storage.GetAllInvalidationStates());
478
479  storage.Acknowledge(kBookmarksId_, it->second);
480  state_map[kBookmarksId_].current = it->second;
481  EXPECT_EQ(state_map, storage.GetAllInvalidationStates());
482
483  // Finally, test that the ack handles are updated if we're asked to generate
484  // another ack handle for the same object ID.
485  state_map[kBookmarksId_].version = 12;
486  state_map[kBookmarksId_].payload = "world";
487  storage.SetMaxVersionAndPayload(kBookmarksId_, 12, "world");
488  EXPECT_EQ(state_map, storage.GetAllInvalidationStates());
489  ids.insert(kBookmarksId_);
490  storage.GenerateAckHandles(
491      ids, base::MessageLoopProxy::current(),
492      base::Bind(&GenerateAckHandlesTestHelper, &ack_handle_map));
493  loop_.RunUntilIdle();
494  EXPECT_EQ(1U, ack_handle_map.size());
495  it = ack_handle_map.find(kBookmarksId_);
496  ASSERT_TRUE(ack_handle_map.end() != it);
497  EXPECT_TRUE(it->second.IsValid());
498  state_map[kBookmarksId_].expected = it->second;
499  EXPECT_EQ(state_map, storage.GetAllInvalidationStates());
500
501  storage.Acknowledge(kBookmarksId_, it->second);
502  state_map[kBookmarksId_].current = it->second;
503  EXPECT_EQ(state_map, storage.GetAllInvalidationStates());
504}
505
506}  // namespace invalidation
507