src/chrome/browser/bookmarks/bookmark_codec_unittest.cc

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