src/chrome/browser/ui/bookmarks/bookmark_context_menu_controller_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/ui/bookmarks/bookmark_context_menu_controller.h"
   6
   7 #include <string>
   8
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "chrome/app/chrome_command_ids.h"
  13 #include "chrome/browser/bookmarks/bookmark_model.h"
  14 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
  15 #include "chrome/browser/bookmarks/bookmark_test_helpers.h"
  16 #include "chrome/browser/profiles/profile.h"
  17 #include "chrome/browser/ui/bookmarks/bookmark_utils.h"
  18 #include "chrome/test/base/testing_profile.h"
  19 #include "content/public/browser/page_navigator.h"
  20 #include "content/public/test/test_browser_thread.h"
  21 #include "grit/generated_resources.h"
  22 #include "testing/gtest/include/gtest/gtest.h"
  23 #include "ui/base/clipboard/clipboard.h"
  24
  25 using content::BrowserThread;
  26 using content::OpenURLParams;
  27 using content::PageNavigator;
  28 using content::WebContents;
  29
  30 // PageNavigator implementation that records the URL.
  31 class TestingPageNavigator : public PageNavigator {
  32  public:
  33   virtual WebContents* OpenURL(const OpenURLParams& params) OVERRIDE {
  34     urls_.push_back(params.url);
  35     return NULL;
  36   }
  37
  38   std::vector<GURL> urls_;
  39 };
  40
  41 class BookmarkContextMenuControllerTest : public testing::Test {
  42  public:
  43   BookmarkContextMenuControllerTest()
  44       : ui_thread_(BrowserThread::UI, &message_loop_),
  45         file_thread_(BrowserThread::FILE, &message_loop_),
  46         model_(NULL) {
  47   }
  48
  49   virtual void SetUp() OVERRIDE {
  50     Reset(false);
  51   }
  52   void Reset(bool incognito) {
  53     TestingProfile::Builder builder;
  54     if (incognito)
  55       builder.SetIncognito();
  56     profile_ = builder.Build();
  57     profile_->CreateBookmarkModel(true);
  58
  59     model_ = BookmarkModelFactory::GetForProfile(profile_.get());
  60     test::WaitForBookmarkModelToLoad(model_);
  61
  62     AddTestData();
  63   }
  64
  65   virtual void TearDown() OVERRIDE {
  66     ui::Clipboard::DestroyClipboardForCurrentThread();
  67
  68     // Flush the message loop to make application verifiers happy.
  69     message_loop_.RunUntilIdle();
  70   }
  71
  72  protected:
  73   base::MessageLoopForUI message_loop_;
  74   content::TestBrowserThread ui_thread_;
  75   content::TestBrowserThread file_thread_;
  76   scoped_ptr<TestingProfile> profile_;
  77   BookmarkModel* model_;
  78   TestingPageNavigator navigator_;
  79
  80  private:
  81   // Creates the following structure:
  82   // a
  83   // F1
  84   //  f1a
  85   //  F11
  86   //   f11a
  87   // F2
  88   // F3
  89   // F4
  90   //   f4a
  91   void AddTestData() {
  92     const BookmarkNode* bb_node = model_->bookmark_bar_node();
  93     std::string test_base = "file:///c:/tmp/";
  94     model_->AddURL(bb_node, 0, ASCIIToUTF16("a"), GURL(test_base + "a"));
  95     const BookmarkNode* f1 = model_->AddFolder(bb_node, 1, ASCIIToUTF16("F1"));
  96     model_->AddURL(f1, 0, ASCIIToUTF16("f1a"), GURL(test_base + "f1a"));
  97     const BookmarkNode* f11 = model_->AddFolder(f1, 1, ASCIIToUTF16("F11"));
  98     model_->AddURL(f11, 0, ASCIIToUTF16("f11a"), GURL(test_base + "f11a"));
  99     model_->AddFolder(bb_node, 2, ASCIIToUTF16("F2"));
 100     model_->AddFolder(bb_node, 3, ASCIIToUTF16("F3"));
 101     const BookmarkNode* f4 = model_->AddFolder(bb_node, 4, ASCIIToUTF16("F4"));
 102     model_->AddURL(f4, 0, ASCIIToUTF16("f4a"), GURL(test_base + "f4a"));
 103   }
 104 };
 105
 106 // Tests Deleting from the menu.
 107 TEST_F(BookmarkContextMenuControllerTest, DeleteURL) {
 108   std::vector<const BookmarkNode*> nodes;
 109   nodes.push_back(model_->bookmark_bar_node()->GetChild(0));
 110   BookmarkContextMenuController controller(
 111       NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes);
 112   GURL url = model_->bookmark_bar_node()->GetChild(0)->url();
 113   ASSERT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE));
 114   // Delete the URL.
 115   controller.ExecuteCommand(IDC_BOOKMARK_BAR_REMOVE, 0);
 116   // Model shouldn't have URL anymore.
 117   ASSERT_FALSE(model_->IsBookmarked(url));
 118 }
 119
 120 // Tests open all on a folder with a couple of bookmarks.
 121 TEST_F(BookmarkContextMenuControllerTest, OpenAll) {
 122   const BookmarkNode* folder = model_->bookmark_bar_node()->GetChild(1);
 123   chrome::OpenAll(NULL, &navigator_, folder, NEW_FOREGROUND_TAB, NULL);
 124
 125   // Should have navigated to F1's child, but not F11's child.
 126   ASSERT_EQ(static_cast<size_t>(1), navigator_.urls_.size());
 127   ASSERT_TRUE(folder->GetChild(0)->url() == navigator_.urls_[0]);
 128 }
 129
 130 // Tests the enabled state of the menus when supplied an empty vector.
 131 TEST_F(BookmarkContextMenuControllerTest, EmptyNodes) {
 132   BookmarkContextMenuController controller(
 133       NULL, NULL, NULL, profile_.get(), NULL, model_->other_node(),
 134       std::vector<const BookmarkNode*>());
 135   EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL));
 136   EXPECT_FALSE(
 137       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW));
 138   EXPECT_FALSE(
 139       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO));
 140   EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE));
 141   EXPECT_TRUE(
 142       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK));
 143   EXPECT_TRUE(
 144       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_NEW_FOLDER));
 145 }
 146
 147 // Tests the enabled state of the menus when supplied a vector with a single
 148 // url.
 149 TEST_F(BookmarkContextMenuControllerTest, SingleURL) {
 150   std::vector<const BookmarkNode*> nodes;
 151   nodes.push_back(model_->bookmark_bar_node()->GetChild(0));
 152   BookmarkContextMenuController controller(
 153       NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes);
 154   EXPECT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL));
 155   EXPECT_TRUE(
 156       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW));
 157   EXPECT_TRUE(
 158       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO));
 159   EXPECT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE));
 160   EXPECT_TRUE(
 161       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK));
 162   EXPECT_TRUE(
 163       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_NEW_FOLDER));
 164 }
 165
 166 // Tests the enabled state of the menus when supplied a vector with multiple
 167 // urls.
 168 TEST_F(BookmarkContextMenuControllerTest, MultipleURLs) {
 169   std::vector<const BookmarkNode*> nodes;
 170   nodes.push_back(model_->bookmark_bar_node()->GetChild(0));
 171   nodes.push_back(model_->bookmark_bar_node()->GetChild(1)->GetChild(0));
 172   BookmarkContextMenuController controller(
 173       NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes);
 174   EXPECT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL));
 175   EXPECT_TRUE(
 176       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW));
 177   EXPECT_TRUE(
 178       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO));
 179   EXPECT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE));
 180   EXPECT_TRUE(
 181       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK));
 182   EXPECT_TRUE(
 183       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_NEW_FOLDER));
 184 }
 185
 186 // Tests the enabled state of the menus when supplied an vector with a single
 187 // folder.
 188 TEST_F(BookmarkContextMenuControllerTest, SingleFolder) {
 189   std::vector<const BookmarkNode*> nodes;
 190   nodes.push_back(model_->bookmark_bar_node()->GetChild(2));
 191   BookmarkContextMenuController controller(
 192       NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes);
 193   EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL));
 194   EXPECT_FALSE(
 195       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW));
 196   EXPECT_FALSE(
 197       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO));
 198   EXPECT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE));
 199   EXPECT_TRUE(
 200       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK));
 201   EXPECT_TRUE(
 202       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_NEW_FOLDER));
 203 }
 204
 205 // Tests the enabled state of the menus when supplied a vector with multiple
 206 // folders, all of which are empty.
 207 TEST_F(BookmarkContextMenuControllerTest, MultipleEmptyFolders) {
 208   std::vector<const BookmarkNode*> nodes;
 209   nodes.push_back(model_->bookmark_bar_node()->GetChild(2));
 210   nodes.push_back(model_->bookmark_bar_node()->GetChild(3));
 211   BookmarkContextMenuController controller(
 212       NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes);
 213   EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL));
 214   EXPECT_FALSE(
 215       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW));
 216   EXPECT_FALSE(
 217       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO));
 218   EXPECT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE));
 219   EXPECT_TRUE(
 220       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK));
 221   EXPECT_TRUE(
 222       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_NEW_FOLDER));
 223 }
 224
 225 // Tests the enabled state of the menus when supplied a vector with multiple
 226 // folders, some of which contain URLs.
 227 TEST_F(BookmarkContextMenuControllerTest, MultipleFoldersWithURLs) {
 228   std::vector<const BookmarkNode*> nodes;
 229   nodes.push_back(model_->bookmark_bar_node()->GetChild(3));
 230   nodes.push_back(model_->bookmark_bar_node()->GetChild(4));
 231   BookmarkContextMenuController controller(
 232       NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes);
 233   EXPECT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL));
 234   EXPECT_TRUE(
 235       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW));
 236   EXPECT_TRUE(
 237       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO));
 238   EXPECT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE));
 239   EXPECT_TRUE(
 240       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK));
 241   EXPECT_TRUE(
 242       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_NEW_FOLDER));
 243 }
 244
 245 // Tests the enabled state of open incognito.
 246 TEST_F(BookmarkContextMenuControllerTest, DisableIncognito) {
 247   // Create a new incognito profile.
 248   Reset(true);
 249   std::vector<const BookmarkNode*> nodes;
 250   nodes.push_back(model_->bookmark_bar_node()->GetChild(0));
 251   BookmarkContextMenuController controller(
 252       NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes);
 253   EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_INCOGNITO));
 254   EXPECT_FALSE(
 255       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO));
 256 }
 257
 258 // Tests that you can't remove/edit when showing the other node.
 259 TEST_F(BookmarkContextMenuControllerTest, DisabledItemsWithOtherNode) {
 260   std::vector<const BookmarkNode*> nodes;
 261   nodes.push_back(model_->other_node());
 262   BookmarkContextMenuController controller(
 263       NULL, NULL, NULL, profile_.get(), NULL, nodes[0], nodes);
 264   EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_EDIT));
 265   EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE));
 266 }
 267
 268 // Tests the enabled state of the menus when supplied an empty vector and null
 269 // parent.
 270 TEST_F(BookmarkContextMenuControllerTest, EmptyNodesNullParent) {
 271   BookmarkContextMenuController controller(
 272       NULL, NULL, NULL, profile_.get(), NULL, NULL,
 273       std::vector<const BookmarkNode*>());
 274   EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL));
 275   EXPECT_FALSE(
 276       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW));
 277   EXPECT_FALSE(
 278       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO));
 279   EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE));
 280   EXPECT_FALSE(
 281       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK));
 282   EXPECT_FALSE(
 283       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_NEW_FOLDER));
 284 }
 285
 286 // Tests the enabled state of the menus when supplied a vector containing just
 287 // the top-level bookmark bar node.
 288 TEST_F(BookmarkContextMenuControllerTest, BookmarkBar) {
 289   std::vector<const BookmarkNode*> nodes;
 290   nodes.push_back(model_->bookmark_bar_node());
 291   BookmarkContextMenuController controller(
 292       NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes);
 293   EXPECT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL));
 294   EXPECT_TRUE(
 295       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW));
 296   EXPECT_TRUE(
 297       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO));
 298   EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE));
 299   EXPECT_TRUE(
 300       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK));
 301   EXPECT_TRUE(
 302       controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_NEW_FOLDER));
 303 }
 304
 305 TEST_F(BookmarkContextMenuControllerTest, CutCopyPasteNode) {
 306   const BookmarkNode* bb_node = model_->bookmark_bar_node();
 307   std::vector<const BookmarkNode*> nodes;
 308   nodes.push_back(bb_node->GetChild(0));
 309   scoped_ptr<BookmarkContextMenuController> controller(
 310       new BookmarkContextMenuController(
 311           NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes));
 312   EXPECT_TRUE(controller->IsCommandIdEnabled(IDC_COPY));
 313   EXPECT_TRUE(controller->IsCommandIdEnabled(IDC_CUT));
 314
 315   // Copy the URL.
 316   controller->ExecuteCommand(IDC_COPY, 0);
 317
 318   controller.reset(new BookmarkContextMenuController(
 319       NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes));
 320   int old_count = bb_node->child_count();
 321   controller->ExecuteCommand(IDC_PASTE, 0);
 322
 323   ASSERT_TRUE(bb_node->GetChild(1)->is_url());
 324   ASSERT_EQ(old_count + 1, bb_node->child_count());
 325   ASSERT_EQ(bb_node->GetChild(0)->url(), bb_node->GetChild(1)->url());
 326
 327   controller.reset(new BookmarkContextMenuController(
 328       NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes));
 329   // Cut the URL.
 330   controller->ExecuteCommand(IDC_CUT, 0);
 331   ASSERT_TRUE(bb_node->GetChild(0)->is_url());
 332   ASSERT_TRUE(bb_node->GetChild(1)->is_folder());
 333   ASSERT_EQ(old_count, bb_node->child_count());
 334 }