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 "base/file_util.h"
6#include "base/files/file_path.h"
7#include "base/json/json_file_value_serializer.h"
8#include "base/memory/scoped_ptr.h"
9#include "base/path_service.h"
10#include "base/strings/string_util.h"
11#include "base/strings/utf_string_conversions.h"
12#include "base/values.h"
13#include "chrome/browser/bookmarks/bookmark_codec.h"
14#include "chrome/browser/bookmarks/bookmark_model.h"
15#include "chrome/browser/bookmarks/bookmark_model_test_utils.h"
16#include "chrome/common/chrome_paths.h"
17#include "testing/gtest/include/gtest/gtest.h"
18
19namespace {
20
21const char kUrl1Title[] = "url1";
22const char kUrl1Url[] = "http://www.url1.com";
23const char kUrl2Title[] = "url2";
24const char kUrl2Url[] = "http://www.url2.com";
25const char kUrl3Title[] = "url3";
26const char kUrl3Url[] = "http://www.url3.com";
27const char kUrl4Title[] = "url4";
28const char kUrl4Url[] = "http://www.url4.com";
29const char kFolder1Title[] = "folder1";
30const char kFolder2Title[] = "folder2";
31
32// Helper to get a mutable bookmark node.
33BookmarkNode* AsMutable(const BookmarkNode* node) {
34  return const_cast<BookmarkNode*>(node);
35}
36
37}  // namespace
38
39class BookmarkCodecTest : public testing::Test {
40 protected:
41  // Helpers to create bookmark models with different data.
42  BookmarkModel* CreateTestModel1() {
43    scoped_ptr<BookmarkModel> model(new BookmarkModel(NULL));
44    const BookmarkNode* bookmark_bar = model->bookmark_bar_node();
45    model->AddURL(bookmark_bar, 0, ASCIIToUTF16(kUrl1Title), GURL(kUrl1Url));
46    return model.release();
47  }
48  BookmarkModel* CreateTestModel2() {
49    scoped_ptr<BookmarkModel> model(new BookmarkModel(NULL));
50    const BookmarkNode* bookmark_bar = model->bookmark_bar_node();
51    model->AddURL(bookmark_bar, 0, ASCIIToUTF16(kUrl1Title), GURL(kUrl1Url));
52    model->AddURL(bookmark_bar, 1, ASCIIToUTF16(kUrl2Title), GURL(kUrl2Url));
53    return model.release();
54  }
55  BookmarkModel* CreateTestModel3() {
56    scoped_ptr<BookmarkModel> model(new BookmarkModel(NULL));
57    const BookmarkNode* bookmark_bar = model->bookmark_bar_node();
58    model->AddURL(bookmark_bar, 0, ASCIIToUTF16(kUrl1Title), GURL(kUrl1Url));
59    const BookmarkNode* folder1 = model->AddFolder(bookmark_bar, 1,
60                                                   ASCIIToUTF16(kFolder1Title));
61    model->AddURL(folder1, 0, ASCIIToUTF16(kUrl2Title), GURL(kUrl2Url));
62    return model.release();
63  }
64
65  void GetBookmarksBarChildValue(Value* value,
66                                 size_t index,
67                                 DictionaryValue** result_value) {
68    ASSERT_EQ(Value::TYPE_DICTIONARY, value->GetType());
69
70    DictionaryValue* d_value = static_cast<DictionaryValue*>(value);
71    Value* roots;
72    ASSERT_TRUE(d_value->Get(BookmarkCodec::kRootsKey, &roots));
73    ASSERT_EQ(Value::TYPE_DICTIONARY, roots->GetType());
74
75    DictionaryValue* roots_d_value = static_cast<DictionaryValue*>(roots);
76    Value* bb_value;
77    ASSERT_TRUE(roots_d_value->Get(BookmarkCodec::kRootFolderNameKey,
78                                   &bb_value));
79    ASSERT_EQ(Value::TYPE_DICTIONARY, bb_value->GetType());
80
81    DictionaryValue* bb_d_value = static_cast<DictionaryValue*>(bb_value);
82    Value* bb_children_value;
83    ASSERT_TRUE(bb_d_value->Get(BookmarkCodec::kChildrenKey,
84                                &bb_children_value));
85    ASSERT_EQ(Value::TYPE_LIST, bb_children_value->GetType());
86
87    ListValue* bb_children_l_value = static_cast<ListValue*>(bb_children_value);
88    Value* child_value;
89    ASSERT_TRUE(bb_children_l_value->Get(index, &child_value));
90    ASSERT_EQ(Value::TYPE_DICTIONARY, child_value->GetType());
91
92    *result_value = static_cast<DictionaryValue*>(child_value);
93  }
94
95  Value* EncodeHelper(BookmarkModel* model, std::string* checksum) {
96    BookmarkCodec encoder;
97    // Computed and stored checksums should be empty.
98    EXPECT_EQ("", encoder.computed_checksum());
99    EXPECT_EQ("", encoder.stored_checksum());
100
101    scoped_ptr<Value> value(encoder.Encode(model));
102    const std::string& computed_checksum = encoder.computed_checksum();
103    const std::string& stored_checksum = encoder.stored_checksum();
104
105    // Computed and stored checksums should not be empty and should be equal.
106    EXPECT_FALSE(computed_checksum.empty());
107    EXPECT_FALSE(stored_checksum.empty());
108    EXPECT_EQ(computed_checksum, stored_checksum);
109
110    *checksum = computed_checksum;
111    return value.release();
112  }
113
114  bool Decode(BookmarkCodec* codec, BookmarkModel* model, const Value& value) {
115    int64 max_id;
116    bool result = codec->Decode(AsMutable(model->bookmark_bar_node()),
117                                AsMutable(model->other_node()),
118                                AsMutable(model->mobile_node()),
119                                &max_id, value);
120    model->set_next_node_id(max_id);
121    AsMutable(model->root_node())->set_meta_info_str(codec->model_meta_info());
122    return result;
123  }
124
125  BookmarkModel* DecodeHelper(const Value& value,
126                              const std::string& expected_stored_checksum,
127                              std::string* computed_checksum,
128                              bool expected_changes) {
129    BookmarkCodec decoder;
130    // Computed and stored checksums should be empty.
131    EXPECT_EQ("", decoder.computed_checksum());
132    EXPECT_EQ("", decoder.stored_checksum());
133
134    scoped_ptr<BookmarkModel> model(new BookmarkModel(NULL));
135    EXPECT_TRUE(Decode(&decoder, model.get(), value));
136
137    *computed_checksum = decoder.computed_checksum();
138    const std::string& stored_checksum = decoder.stored_checksum();
139
140    // Computed and stored checksums should not be empty.
141    EXPECT_FALSE(computed_checksum->empty());
142    EXPECT_FALSE(stored_checksum.empty());
143
144    // Stored checksum should be as expected.
145    EXPECT_EQ(expected_stored_checksum, stored_checksum);
146
147    // The two checksums should be equal if expected_changes is true; otherwise
148    // they should be different.
149    if (expected_changes)
150      EXPECT_NE(*computed_checksum, stored_checksum);
151    else
152      EXPECT_EQ(*computed_checksum, stored_checksum);
153
154    return model.release();
155  }
156
157  void CheckIDs(const BookmarkNode* node, std::set<int64>* assigned_ids) {
158    DCHECK(node);
159    int64 node_id = node->id();
160    EXPECT_TRUE(assigned_ids->find(node_id) == assigned_ids->end());
161    assigned_ids->insert(node_id);
162    for (int i = 0; i < node->child_count(); ++i)
163      CheckIDs(node->GetChild(i), assigned_ids);
164  }
165
166  void ExpectIDsUnique(BookmarkModel* model) {
167    std::set<int64> assigned_ids;
168    CheckIDs(model->bookmark_bar_node(), &assigned_ids);
169    CheckIDs(model->other_node(), &assigned_ids);
170    CheckIDs(model->mobile_node(), &assigned_ids);
171  }
172};
173
174TEST_F(BookmarkCodecTest, ChecksumEncodeDecodeTest) {
175  scoped_ptr<BookmarkModel> model_to_encode(CreateTestModel1());
176  std::string enc_checksum;
177  scoped_ptr<Value> value(EncodeHelper(model_to_encode.get(), &enc_checksum));
178
179  EXPECT_TRUE(value.get() != NULL);
180
181  std::string dec_checksum;
182  scoped_ptr<BookmarkModel> decoded_model(DecodeHelper(
183      *value.get(), enc_checksum, &dec_checksum, false));
184}
185
186TEST_F(BookmarkCodecTest, ChecksumEncodeIdenticalModelsTest) {
187  // Encode two identical models and make sure the check-sums are same as long
188  // as the data is the same.
189  scoped_ptr<BookmarkModel> model1(CreateTestModel1());
190  std::string enc_checksum1;
191  scoped_ptr<Value> value1(EncodeHelper(model1.get(), &enc_checksum1));
192  EXPECT_TRUE(value1.get() != NULL);
193
194  scoped_ptr<BookmarkModel> model2(CreateTestModel1());
195  std::string enc_checksum2;
196  scoped_ptr<Value> value2(EncodeHelper(model2.get(), &enc_checksum2));
197  EXPECT_TRUE(value2.get() != NULL);
198
199  ASSERT_EQ(enc_checksum1, enc_checksum2);
200}
201
202TEST_F(BookmarkCodecTest, ChecksumManualEditTest) {
203  scoped_ptr<BookmarkModel> model_to_encode(CreateTestModel1());
204  std::string enc_checksum;
205  scoped_ptr<Value> value(EncodeHelper(model_to_encode.get(), &enc_checksum));
206
207  EXPECT_TRUE(value.get() != NULL);
208
209  // Change something in the encoded value before decoding it.
210  DictionaryValue* child1_value;
211  GetBookmarksBarChildValue(value.get(), 0, &child1_value);
212  std::string title;
213  ASSERT_TRUE(child1_value->GetString(BookmarkCodec::kNameKey, &title));
214  child1_value->SetString(BookmarkCodec::kNameKey, title + "1");
215
216  std::string dec_checksum;
217  scoped_ptr<BookmarkModel> decoded_model1(DecodeHelper(
218      *value.get(), enc_checksum, &dec_checksum, true));
219
220  // Undo the change and make sure the checksum is same as original.
221  child1_value->SetString(BookmarkCodec::kNameKey, title);
222  scoped_ptr<BookmarkModel> decoded_model2(DecodeHelper(
223      *value.get(), enc_checksum, &dec_checksum, false));
224}
225
226TEST_F(BookmarkCodecTest, ChecksumManualEditIDsTest) {
227  scoped_ptr<BookmarkModel> model_to_encode(CreateTestModel3());
228
229  // The test depends on existence of multiple children under bookmark bar, so
230  // make sure that's the case.
231  int bb_child_count = model_to_encode->bookmark_bar_node()->child_count();
232  ASSERT_GT(bb_child_count, 1);
233
234  std::string enc_checksum;
235  scoped_ptr<Value> value(EncodeHelper(model_to_encode.get(), &enc_checksum));
236
237  EXPECT_TRUE(value.get() != NULL);
238
239  // Change IDs for all children of bookmark bar to be 1.
240  DictionaryValue* child_value;
241  for (int i = 0; i < bb_child_count; ++i) {
242    GetBookmarksBarChildValue(value.get(), i, &child_value);
243    std::string id;
244    ASSERT_TRUE(child_value->GetString(BookmarkCodec::kIdKey, &id));
245    child_value->SetString(BookmarkCodec::kIdKey, "1");
246  }
247
248  std::string dec_checksum;
249  scoped_ptr<BookmarkModel> decoded_model(DecodeHelper(
250      *value.get(), enc_checksum, &dec_checksum, true));
251
252  ExpectIDsUnique(decoded_model.get());
253
254  // add a few extra nodes to bookmark model and make sure IDs are still uniuqe.
255  const BookmarkNode* bb_node = decoded_model->bookmark_bar_node();
256  decoded_model->AddURL(bb_node, 0, ASCIIToUTF16("new url1"),
257                        GURL("http://newurl1.com"));
258  decoded_model->AddURL(bb_node, 0, ASCIIToUTF16("new url2"),
259                        GURL("http://newurl2.com"));
260
261  ExpectIDsUnique(decoded_model.get());
262}
263
264TEST_F(BookmarkCodecTest, PersistIDsTest) {
265  scoped_ptr<BookmarkModel> model_to_encode(CreateTestModel3());
266  BookmarkCodec encoder;
267  scoped_ptr<Value> model_value(encoder.Encode(model_to_encode.get()));
268
269  BookmarkModel decoded_model(NULL);
270  BookmarkCodec decoder;
271  ASSERT_TRUE(Decode(&decoder, &decoded_model, *model_value.get()));
272  BookmarkModelTestUtils::AssertModelsEqual(model_to_encode.get(),
273                                            &decoded_model,
274                                            true);
275
276  // Add a couple of more items to the decoded bookmark model and make sure
277  // ID persistence is working properly.
278  const BookmarkNode* bookmark_bar = decoded_model.bookmark_bar_node();
279  decoded_model.AddURL(
280      bookmark_bar, bookmark_bar->child_count(), ASCIIToUTF16(kUrl3Title),
281      GURL(kUrl3Url));
282  const BookmarkNode* folder2_node = decoded_model.AddFolder(
283      bookmark_bar, bookmark_bar->child_count(), ASCIIToUTF16(kFolder2Title));
284  decoded_model.AddURL(folder2_node, 0, ASCIIToUTF16(kUrl4Title),
285                       GURL(kUrl4Url));
286
287  BookmarkCodec encoder2;
288  scoped_ptr<Value> model_value2(encoder2.Encode(&decoded_model));
289
290  BookmarkModel decoded_model2(NULL);
291  BookmarkCodec decoder2;
292  ASSERT_TRUE(Decode(&decoder2, &decoded_model2, *model_value2.get()));
293  BookmarkModelTestUtils::AssertModelsEqual(&decoded_model,
294                                            &decoded_model2,
295                                            true);
296}
297
298TEST_F(BookmarkCodecTest, CanDecodeModelWithoutMobileBookmarks) {
299  base::FilePath test_data_directory;
300  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_directory));
301  base::FilePath test_file = test_data_directory.AppendASCII(
302      "bookmarks/model_without_sync.json");
303  ASSERT_TRUE(base::PathExists(test_file));
304
305  JSONFileValueSerializer serializer(test_file);
306  scoped_ptr<Value> root(serializer.Deserialize(NULL, NULL));
307
308  BookmarkModel decoded_model(NULL);
309  BookmarkCodec decoder;
310  ASSERT_TRUE(Decode(&decoder, &decoded_model, *root.get()));
311  ExpectIDsUnique(&decoded_model);
312
313  const BookmarkNode* bbn = decoded_model.bookmark_bar_node();
314  ASSERT_EQ(1, bbn->child_count());
315
316  const BookmarkNode* child = bbn->GetChild(0);
317  EXPECT_EQ(BookmarkNode::FOLDER, child->type());
318  EXPECT_EQ(ASCIIToUTF16("Folder A"), child->GetTitle());
319  ASSERT_EQ(1, child->child_count());
320
321  child = child->GetChild(0);
322  EXPECT_EQ(BookmarkNode::URL, child->type());
323  EXPECT_EQ(ASCIIToUTF16("Bookmark Manager"), child->GetTitle());
324
325  const BookmarkNode* other = decoded_model.other_node();
326  ASSERT_EQ(1, other->child_count());
327
328  child = other->GetChild(0);
329  EXPECT_EQ(BookmarkNode::FOLDER, child->type());
330  EXPECT_EQ(ASCIIToUTF16("Folder B"), child->GetTitle());
331  ASSERT_EQ(1, child->child_count());
332
333  child = child->GetChild(0);
334  EXPECT_EQ(BookmarkNode::URL, child->type());
335  EXPECT_EQ(ASCIIToUTF16("Get started with Google Chrome"), child->GetTitle());
336
337  ASSERT_TRUE(decoded_model.mobile_node() != NULL);
338}
339
340TEST_F(BookmarkCodecTest, EncodeAndDecodeMetaInfo) {
341  // Add meta info and encode.
342  scoped_ptr<BookmarkModel> model(CreateTestModel1());
343  model->SetNodeMetaInfo(model->root_node(), "model_info", "value1");
344  model->SetNodeMetaInfo(model->bookmark_bar_node()->GetChild(0),
345                         "node_info", "value2");
346  std::string checksum;
347  scoped_ptr<Value> value(EncodeHelper(model.get(), &checksum));
348  ASSERT_TRUE(value.get() != NULL);
349
350  // Decode and check for meta info.
351  model.reset(DecodeHelper(*value, checksum, &checksum, false));
352  std::string meta_value;
353  EXPECT_TRUE(model->root_node()->GetMetaInfo("model_info", &meta_value));
354  EXPECT_EQ("value1", meta_value);
355  EXPECT_FALSE(model->root_node()->GetMetaInfo("other_key", &meta_value));
356  const BookmarkNode* bbn = model->bookmark_bar_node();
357  ASSERT_EQ(1, bbn->child_count());
358  const BookmarkNode* child = bbn->GetChild(0);
359  EXPECT_TRUE(child->GetMetaInfo("node_info", &meta_value));
360  EXPECT_EQ("value2", meta_value);
361  EXPECT_FALSE(child->GetMetaInfo("other_key", &meta_value));
362}
363