src/components/bookmarks/core/browser/bookmark_codec_unittest.cc

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