chrome/browser/extensions/api/bookmarks/bookmark_api_helpers_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/extensions/api/bookmarks/bookmark_api_helpers.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/strings/string_number_conversions.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "base/values.h"
  11 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
  12 #include "chrome/browser/bookmarks/chrome_bookmark_client.h"
  13 #include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h"
  14 #include "chrome/browser/extensions/api/bookmarks/bookmark_api_constants.h"
  15 #include "chrome/common/extensions/api/bookmarks.h"
  16 #include "chrome/test/base/testing_profile.h"
  17 #include "components/bookmarks/browser/bookmark_model.h"
  18 #include "components/bookmarks/test/bookmark_test_helpers.h"
  19 #include "content/public/test/test_browser_thread_bundle.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21
  22 using bookmarks::BookmarkModel;
  23 using bookmarks::BookmarkNode;
  24
  25 namespace extensions {
  26
  27 namespace keys = bookmark_api_constants;
  28 using api::bookmarks::BookmarkTreeNode;
  29
  30 namespace bookmark_api_helpers {
  31
  32 class ExtensionBookmarksTest : public testing::Test {
  33  public:
  34   ExtensionBookmarksTest()
  35       : client_(NULL), model_(NULL), node_(NULL), node2_(NULL), folder_(NULL) {}
  36
  37   void SetUp() override {
  38     profile_.CreateBookmarkModel(false);
  39     model_ = BookmarkModelFactory::GetForProfile(&profile_);
  40     client_ = ChromeBookmarkClientFactory::GetForProfile(&profile_);
  41     bookmarks::test::WaitForBookmarkModelToLoad(model_);
  42
  43     node_ = model_->AddURL(model_->other_node(), 0, base::ASCIIToUTF16("Digg"),
  44                            GURL("http://www.reddit.com"));
  45     model_->SetNodeMetaInfo(node_, "some_key1", "some_value1");
  46     model_->SetNodeMetaInfo(node_, "some_key2", "some_value2");
  47     model_->AddURL(model_->other_node(), 0, base::ASCIIToUTF16("News"),
  48                    GURL("http://www.foxnews.com"));
  49     folder_ = model_->AddFolder(
  50         model_->other_node(), 0, base::ASCIIToUTF16("outer folder"));
  51     model_->SetNodeMetaInfo(folder_, "some_key1", "some_value1");
  52     model_->AddFolder(folder_, 0, base::ASCIIToUTF16("inner folder 1"));
  53     model_->AddFolder(folder_, 0, base::ASCIIToUTF16("inner folder 2"));
  54     node2_ = model_->AddURL(
  55         folder_, 0, base::ASCIIToUTF16("Digg"), GURL("http://reddit.com"));
  56     model_->SetNodeMetaInfo(node2_, "some_key2", "some_value2");
  57     model_->AddURL(
  58         folder_, 0, base::ASCIIToUTF16("CNet"), GURL("http://cnet.com"));
  59   }
  60
  61   content::TestBrowserThreadBundle thread_bundle_;
  62   TestingProfile profile_;
  63   ChromeBookmarkClient* client_;
  64   BookmarkModel* model_;
  65   const BookmarkNode* node_;
  66   const BookmarkNode* node2_;
  67   const BookmarkNode* folder_;
  68 };
  69
  70 TEST_F(ExtensionBookmarksTest, GetFullTreeFromRoot) {
  71   scoped_ptr<BookmarkTreeNode> tree(
  72       GetBookmarkTreeNode(client_,
  73                           model_->other_node(),
  74                           true,    // Recurse.
  75                           false));  // Not only folders.
  76   ASSERT_EQ(3U, tree->children->size());
  77 }
  78
  79 TEST_F(ExtensionBookmarksTest, GetFoldersOnlyFromRoot) {
  80   scoped_ptr<BookmarkTreeNode> tree(
  81       GetBookmarkTreeNode(client_,
  82                           model_->other_node(),
  83                           true,   // Recurse.
  84                           true));  // Only folders.
  85   ASSERT_EQ(1U, tree->children->size());
  86 }
  87
  88 TEST_F(ExtensionBookmarksTest, GetSubtree) {
  89   scoped_ptr<BookmarkTreeNode> tree(
  90       GetBookmarkTreeNode(client_,
  91                           folder_,
  92                           true,    // Recurse.
  93                           false));  // Not only folders.
  94   ASSERT_EQ(4U, tree->children->size());
  95   linked_ptr<BookmarkTreeNode> digg = tree->children->at(1);
  96   ASSERT_TRUE(digg.get());
  97   ASSERT_EQ("Digg", digg->title);
  98 }
  99
 100 TEST_F(ExtensionBookmarksTest, GetSubtreeFoldersOnly) {
 101   scoped_ptr<BookmarkTreeNode> tree(
 102       GetBookmarkTreeNode(client_,
 103                           folder_,
 104                           true,   // Recurse.
 105                           true));  // Only folders.
 106   ASSERT_EQ(2U, tree->children->size());
 107   linked_ptr<BookmarkTreeNode> inner_folder = tree->children->at(1);
 108   ASSERT_TRUE(inner_folder.get());
 109   ASSERT_EQ("inner folder 1", inner_folder->title);
 110 }
 111
 112 TEST_F(ExtensionBookmarksTest, GetModifiableNode) {
 113   scoped_ptr<BookmarkTreeNode> tree(
 114       GetBookmarkTreeNode(client_,
 115                           node_,
 116                           false,    // Recurse.
 117                           false));  // Only folders.
 118   EXPECT_EQ("Digg", tree->title);
 119   ASSERT_TRUE(tree->url);
 120   EXPECT_EQ("http://www.reddit.com/", *tree->url);
 121   EXPECT_EQ(api::bookmarks::BOOKMARK_TREE_NODE_UNMODIFIABLE_NONE,
 122             tree->unmodifiable);
 123 }
 124
 125 TEST_F(ExtensionBookmarksTest, GetManagedNode) {
 126   const BookmarkNode* managed_bookmark =
 127       model_->AddURL(client_->managed_node(),
 128                      0,
 129                      base::ASCIIToUTF16("Chromium"),
 130                      GURL("http://www.chromium.org/"));
 131   scoped_ptr<BookmarkTreeNode> tree(
 132       GetBookmarkTreeNode(client_,
 133                           managed_bookmark,
 134                           false,    // Recurse.
 135                           false));  // Only folders.
 136   EXPECT_EQ("Chromium", tree->title);
 137   EXPECT_EQ("http://www.chromium.org/", *tree->url);
 138   EXPECT_EQ(api::bookmarks::BOOKMARK_TREE_NODE_UNMODIFIABLE_MANAGED,
 139             tree->unmodifiable);
 140 }
 141
 142 TEST_F(ExtensionBookmarksTest, RemoveNodeInvalidId) {
 143   int64 invalid_id = model_->next_node_id();
 144   std::string error;
 145   EXPECT_FALSE(RemoveNode(model_, client_, invalid_id, true, &error));
 146   EXPECT_EQ(keys::kNoNodeError, error);
 147 }
 148
 149 TEST_F(ExtensionBookmarksTest, RemoveNodePermanent) {
 150   std::string error;
 151   EXPECT_FALSE(
 152       RemoveNode(model_, client_, model_->other_node()->id(), true, &error));
 153   EXPECT_EQ(keys::kModifySpecialError, error);
 154 }
 155
 156 TEST_F(ExtensionBookmarksTest, RemoveNodeManaged) {
 157   const BookmarkNode* managed_bookmark =
 158       model_->AddURL(client_->managed_node(),
 159                      0,
 160                      base::ASCIIToUTF16("Chromium"),
 161                      GURL("http://www.chromium.org"));
 162   std::string error;
 163   EXPECT_FALSE(
 164       RemoveNode(model_, client_, managed_bookmark->id(), true, &error));
 165   EXPECT_EQ(keys::kModifyManagedError, error);
 166 }
 167
 168 TEST_F(ExtensionBookmarksTest, RemoveNodeNotRecursive) {
 169   std::string error;
 170   EXPECT_FALSE(RemoveNode(model_, client_, folder_->id(), false, &error));
 171   EXPECT_EQ(keys::kFolderNotEmptyError, error);
 172 }
 173
 174 TEST_F(ExtensionBookmarksTest, RemoveNodeRecursive) {
 175   EXPECT_EQ(3, model_->other_node()->child_count());
 176   std::string error;
 177   EXPECT_TRUE(RemoveNode(model_, client_, folder_->id(), true, &error));
 178   EXPECT_EQ(2, model_->other_node()->child_count());
 179 }
 180
 181 TEST_F(ExtensionBookmarksTest, GetMetaInfo) {
 182   base::DictionaryValue id_to_meta_info_map;
 183   GetMetaInfo(*model_->other_node(), &id_to_meta_info_map);
 184   EXPECT_EQ(8u, id_to_meta_info_map.size());
 185
 186   // Verify top level node.
 187   const base::Value* value = NULL;
 188   EXPECT_TRUE(id_to_meta_info_map.Get(
 189       base::Int64ToString(model_->other_node()->id()), &value));
 190   ASSERT_TRUE(NULL != value);
 191   const base::DictionaryValue* dictionary_value = NULL;
 192   EXPECT_TRUE(value->GetAsDictionary(&dictionary_value));
 193   ASSERT_TRUE(NULL != dictionary_value);
 194   EXPECT_EQ(0u, dictionary_value->size());
 195
 196   // Verify bookmark with two meta info key/value pairs.
 197   value = NULL;
 198   EXPECT_TRUE(id_to_meta_info_map.Get(
 199       base::Int64ToString(node_->id()), &value));
 200   ASSERT_TRUE(NULL != value);
 201   dictionary_value = NULL;
 202   EXPECT_TRUE(value->GetAsDictionary(&dictionary_value));
 203   ASSERT_TRUE(NULL != dictionary_value);
 204   EXPECT_EQ(2u, dictionary_value->size());
 205   std::string string_value;
 206   EXPECT_TRUE(dictionary_value->GetString("some_key1", &string_value));
 207   EXPECT_EQ("some_value1", string_value);
 208   EXPECT_TRUE(dictionary_value->GetString("some_key2", &string_value));
 209   EXPECT_EQ("some_value2", string_value);
 210
 211   // Verify folder with one meta info key/value pair.
 212   value = NULL;
 213   EXPECT_TRUE(id_to_meta_info_map.Get(
 214       base::Int64ToString(folder_->id()), &value));
 215   ASSERT_TRUE(NULL != value);
 216   dictionary_value = NULL;
 217   EXPECT_TRUE(value->GetAsDictionary(&dictionary_value));
 218   ASSERT_TRUE(NULL != dictionary_value);
 219   EXPECT_EQ(1u, dictionary_value->size());
 220   EXPECT_TRUE(dictionary_value->GetString("some_key1", &string_value));
 221   EXPECT_EQ("some_value1", string_value);
 222
 223   // Verify bookmark in a subfolder with one meta info key/value pairs.
 224   value = NULL;
 225   EXPECT_TRUE(id_to_meta_info_map.Get(
 226       base::Int64ToString(node2_->id()), &value));
 227   ASSERT_TRUE(NULL != value);
 228   dictionary_value = NULL;
 229   EXPECT_TRUE(value->GetAsDictionary(&dictionary_value));
 230   ASSERT_TRUE(NULL != dictionary_value);
 231   EXPECT_EQ(1u, dictionary_value->size());
 232   string_value.clear();
 233   EXPECT_FALSE(dictionary_value->GetString("some_key1", &string_value));
 234   EXPECT_EQ("", string_value);
 235   EXPECT_TRUE(dictionary_value->GetString("some_key2", &string_value));
 236   EXPECT_EQ("some_value2", string_value);
 237
 238 }
 239
 240 }  // namespace bookmark_api_helpers
 241 }  // namespace extensions