chrome/browser/android/bookmarks/partner_bookmarks_shim_unittest.cc

   1 // Copyright 2013 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/android/bookmarks/partner_bookmarks_shim.h"
   6
   7 #include "base/message_loop/message_loop.h"
   8 #include "base/strings/string16.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
  11 #include "chrome/test/base/testing_profile.h"
  12 #include "components/bookmarks/browser/bookmark_model.h"
  13 #include "components/bookmarks/test/bookmark_test_helpers.h"
  14 #include "content/public/browser/browser_thread.h"
  15 #include "content/public/test/test_browser_thread.h"
  16 #include "testing/gmock/include/gmock/gmock.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18 #include "url/gurl.h"
  19
  20 using testing::_;
  21
  22 class MockObserver : public PartnerBookmarksShim::Observer {
  23  public:
  24   MockObserver() {}
  25   MOCK_METHOD1(PartnerShimChanged, void(PartnerBookmarksShim*));
  26   MOCK_METHOD1(PartnerShimLoaded, void(PartnerBookmarksShim*));
  27
  28  private:
  29   DISALLOW_COPY_AND_ASSIGN(MockObserver);
  30 };
  31
  32 class PartnerBookmarksShimTest : public testing::Test {
  33  public:
  34   PartnerBookmarksShimTest()
  35       : ui_thread_(content::BrowserThread::UI, &message_loop_),
  36         file_thread_(content::BrowserThread::FILE, &message_loop_),
  37         model_(NULL) {
  38   }
  39
  40   TestingProfile* profile() const { return profile_.get(); }
  41   PartnerBookmarksShim* partner_bookmarks_shim() const {
  42     return PartnerBookmarksShim::BuildForBrowserContext(profile_.get());
  43   }
  44
  45   const BookmarkNode* AddBookmark(const BookmarkNode* parent,
  46                                   const GURL& url,
  47                                   const base::string16& title) {
  48     if (!parent)
  49       parent = model_->bookmark_bar_node();
  50     return model_->AddURL(parent, parent->child_count(), title, url);
  51   }
  52
  53   const BookmarkNode* AddFolder(const BookmarkNode* parent,
  54                                 const base::string16& title) {
  55     if (!parent)
  56       parent = model_->bookmark_bar_node();
  57     return model_->AddFolder(parent, parent->child_count(), title);
  58   }
  59
  60  protected:
  61   // testing::Test
  62   virtual void SetUp() OVERRIDE {
  63     profile_.reset(new TestingProfile());
  64     profile_->CreateBookmarkModel(true);
  65
  66     model_ = BookmarkModelFactory::GetForProfile(profile_.get());
  67     test::WaitForBookmarkModelToLoad(model_);
  68   }
  69
  70   virtual void TearDown() OVERRIDE {
  71     PartnerBookmarksShim::ClearInBrowserContextForTesting(profile_.get());
  72     PartnerBookmarksShim::ClearPartnerModelForTesting();
  73     PartnerBookmarksShim::EnablePartnerBookmarksEditing();
  74     profile_.reset(NULL);
  75   }
  76
  77   scoped_ptr<TestingProfile> profile_;
  78
  79   base::MessageLoopForUI message_loop_;
  80   content::TestBrowserThread ui_thread_;
  81   content::TestBrowserThread file_thread_;
  82
  83   BookmarkModel* model_;
  84   MockObserver observer_;
  85
  86   DISALLOW_COPY_AND_ASSIGN(PartnerBookmarksShimTest);
  87 };
  88
  89 TEST_F(PartnerBookmarksShimTest, GetNodeByID) {
  90   BookmarkNode* root_partner_node = new BookmarkPermanentNode(0);
  91   BookmarkNode* partner_folder1 = new BookmarkNode(1, GURL());
  92   partner_folder1->set_type(BookmarkNode::FOLDER);
  93   root_partner_node->Add(partner_folder1, root_partner_node->child_count());
  94
  95   BookmarkNode* partner_folder2 = new BookmarkNode(2, GURL());
  96   partner_folder2->set_type(BookmarkNode::FOLDER);
  97   partner_folder1->Add(partner_folder2, partner_folder1->child_count());
  98
  99   BookmarkNode* partner_bookmark1 = new BookmarkNode(3,
 100                                                      GURL("http://www.a.com"));
 101   partner_bookmark1->set_type(BookmarkNode::URL);
 102   partner_folder1->Add(partner_bookmark1, partner_folder1->child_count());
 103
 104   BookmarkNode* partner_bookmark2 = new BookmarkNode(4,
 105                                                      GURL("http://www.b.com"));
 106   partner_bookmark2->set_type(BookmarkNode::URL);
 107   partner_folder2->Add(partner_bookmark2, partner_folder2->child_count());
 108
 109   PartnerBookmarksShim* shim = partner_bookmarks_shim();
 110   ASSERT_FALSE(shim->IsLoaded());
 111   shim->SetPartnerBookmarksRoot(root_partner_node);
 112   ASSERT_TRUE(shim->IsLoaded());
 113
 114   ASSERT_TRUE(shim->IsPartnerBookmark(root_partner_node));
 115   ASSERT_EQ(shim->GetNodeByID(0), root_partner_node);
 116   ASSERT_EQ(shim->GetNodeByID(1), partner_folder1);
 117   ASSERT_EQ(shim->GetNodeByID(4), partner_bookmark2);
 118 }
 119
 120 TEST_F(PartnerBookmarksShimTest, ObserverNotifiedOfLoadNoPartnerBookmarks) {
 121   EXPECT_CALL(observer_, PartnerShimLoaded(_)).Times(0);
 122   PartnerBookmarksShim* shim = partner_bookmarks_shim();
 123   shim->AddObserver(&observer_);
 124
 125   EXPECT_CALL(observer_, PartnerShimLoaded(shim)).Times(1);
 126   shim->SetPartnerBookmarksRoot(NULL);
 127 }
 128
 129 TEST_F(PartnerBookmarksShimTest, ObserverNotifiedOfLoadWithPartnerBookmarks) {
 130   EXPECT_CALL(observer_, PartnerShimLoaded(_)).Times(0);
 131   int64 id = 5;
 132   BookmarkNode* root_partner_node = new BookmarkPermanentNode(id++);
 133   BookmarkNode* partner_bookmark1 = new BookmarkNode(id++,
 134                                                      GURL("http://www.a.com"));
 135   partner_bookmark1->set_type(BookmarkNode::URL);
 136   root_partner_node->Add(partner_bookmark1, root_partner_node->child_count());
 137
 138   PartnerBookmarksShim* shim = partner_bookmarks_shim();
 139   shim->AddObserver(&observer_);
 140
 141   EXPECT_CALL(observer_, PartnerShimLoaded(shim)).Times(1);
 142   shim->SetPartnerBookmarksRoot(root_partner_node);
 143 }
 144
 145 TEST_F(PartnerBookmarksShimTest, RemoveBookmarks) {
 146   PartnerBookmarksShim* shim = partner_bookmarks_shim();
 147   shim->AddObserver(&observer_);
 148
 149   EXPECT_CALL(observer_, PartnerShimLoaded(shim)).Times(0);
 150   EXPECT_CALL(observer_, PartnerShimChanged(shim)).Times(0);
 151
 152   BookmarkNode* root_partner_node = new BookmarkPermanentNode(0);
 153   root_partner_node->SetTitle(base::ASCIIToUTF16("Partner bookmarks"));
 154
 155   BookmarkNode* partner_folder1 = new BookmarkNode(1, GURL("http://www.a.net"));
 156   partner_folder1->set_type(BookmarkNode::FOLDER);
 157   root_partner_node->Add(partner_folder1, root_partner_node->child_count());
 158
 159   BookmarkNode* partner_folder2 = new BookmarkNode(2, GURL("http://www.b.net"));
 160   partner_folder2->set_type(BookmarkNode::FOLDER);
 161   root_partner_node->Add(partner_folder2, root_partner_node->child_count());
 162
 163   BookmarkNode* partner_bookmark1 = new BookmarkNode(3,
 164                                                      GURL("http://www.a.com"));
 165   partner_bookmark1->set_type(BookmarkNode::URL);
 166   partner_folder1->Add(partner_bookmark1, partner_folder1->child_count());
 167
 168   BookmarkNode* partner_bookmark2 = new BookmarkNode(4,
 169                                                      GURL("http://www.b.com"));
 170   partner_bookmark2->set_type(BookmarkNode::URL);
 171   partner_folder2->Add(partner_bookmark2, partner_folder2->child_count());
 172
 173   BookmarkNode* partner_folder3 = new BookmarkNode(5, GURL("http://www.c.net"));
 174   partner_folder3->set_type(BookmarkNode::FOLDER);
 175   partner_folder2->Add(partner_folder3, partner_folder2->child_count());
 176
 177   BookmarkNode* partner_bookmark3 = new BookmarkNode(6,
 178                                                      GURL("http://www.c.com"));
 179   partner_bookmark3->set_type(BookmarkNode::URL);
 180   partner_folder3->Add(partner_bookmark3, partner_folder3->child_count());
 181
 182   ASSERT_FALSE(shim->IsLoaded());
 183   EXPECT_CALL(observer_, PartnerShimLoaded(shim)).Times(1);
 184   shim->SetPartnerBookmarksRoot(root_partner_node);
 185   ASSERT_TRUE(shim->IsLoaded());
 186
 187   EXPECT_EQ(root_partner_node, shim->GetNodeByID(0));
 188   EXPECT_EQ(partner_folder1, shim->GetNodeByID(1));
 189   EXPECT_EQ(partner_folder2, shim->GetNodeByID(2));
 190   EXPECT_EQ(partner_bookmark1, shim->GetNodeByID(3));
 191   EXPECT_EQ(partner_bookmark2, shim->GetNodeByID(4));
 192   EXPECT_EQ(partner_folder3, shim->GetNodeByID(5));
 193   EXPECT_EQ(partner_bookmark3, shim->GetNodeByID(6));
 194
 195   EXPECT_TRUE(shim->IsReachable(root_partner_node));
 196   EXPECT_TRUE(shim->IsReachable(partner_folder1));
 197   EXPECT_TRUE(shim->IsReachable(partner_folder2));
 198   EXPECT_TRUE(shim->IsReachable(partner_bookmark1));
 199   EXPECT_TRUE(shim->IsReachable(partner_bookmark2));
 200   EXPECT_TRUE(shim->IsReachable(partner_folder3));
 201   EXPECT_TRUE(shim->IsReachable(partner_bookmark3));
 202
 203   EXPECT_CALL(observer_, PartnerShimChanged(shim)).Times(1);
 204   shim->RemoveBookmark(partner_bookmark2);
 205   EXPECT_TRUE(shim->IsReachable(root_partner_node));
 206   EXPECT_TRUE(shim->IsReachable(partner_folder1));
 207   EXPECT_TRUE(shim->IsReachable(partner_folder2));
 208   EXPECT_TRUE(shim->IsReachable(partner_bookmark1));
 209   EXPECT_FALSE(shim->IsReachable(partner_bookmark2));
 210   EXPECT_TRUE(shim->IsReachable(partner_folder3));
 211   EXPECT_TRUE(shim->IsReachable(partner_bookmark3));
 212
 213   EXPECT_CALL(observer_, PartnerShimChanged(shim)).Times(1);
 214   shim->RemoveBookmark(partner_folder1);
 215   EXPECT_TRUE(shim->IsReachable(root_partner_node));
 216   EXPECT_FALSE(shim->IsReachable(partner_folder1));
 217   EXPECT_TRUE(shim->IsReachable(partner_folder2));
 218   EXPECT_FALSE(shim->IsReachable(partner_bookmark1));
 219   EXPECT_FALSE(shim->IsReachable(partner_bookmark2));
 220   EXPECT_TRUE(shim->IsReachable(partner_folder3));
 221   EXPECT_TRUE(shim->IsReachable(partner_bookmark3));
 222
 223   EXPECT_CALL(observer_, PartnerShimChanged(shim)).Times(1);
 224   shim->RemoveBookmark(root_partner_node);
 225   EXPECT_FALSE(shim->IsReachable(root_partner_node));
 226   EXPECT_FALSE(shim->IsReachable(partner_folder1));
 227   EXPECT_FALSE(shim->IsReachable(partner_folder2));
 228   EXPECT_FALSE(shim->IsReachable(partner_bookmark1));
 229   EXPECT_FALSE(shim->IsReachable(partner_bookmark2));
 230   EXPECT_FALSE(shim->IsReachable(partner_folder3));
 231   EXPECT_FALSE(shim->IsReachable(partner_bookmark3));
 232 }
 233
 234 TEST_F(PartnerBookmarksShimTest, RenameBookmarks) {
 235   PartnerBookmarksShim* shim = partner_bookmarks_shim();
 236   shim->AddObserver(&observer_);
 237
 238   EXPECT_CALL(observer_, PartnerShimLoaded(shim)).Times(0);
 239   EXPECT_CALL(observer_, PartnerShimChanged(shim)).Times(0);
 240
 241   BookmarkNode* root_partner_node = new BookmarkPermanentNode(0);
 242   root_partner_node->SetTitle(base::ASCIIToUTF16("Partner bookmarks"));
 243
 244   BookmarkNode* partner_folder1 = new BookmarkNode(1, GURL("http://www.a.net"));
 245   partner_folder1->set_type(BookmarkNode::FOLDER);
 246   partner_folder1->SetTitle(base::ASCIIToUTF16("a.net"));
 247   root_partner_node->Add(partner_folder1, root_partner_node->child_count());
 248
 249   BookmarkNode* partner_folder2 = new BookmarkNode(2, GURL("http://www.b.net"));
 250   partner_folder2->set_type(BookmarkNode::FOLDER);
 251   partner_folder2->SetTitle(base::ASCIIToUTF16("b.net"));
 252   root_partner_node->Add(partner_folder2, root_partner_node->child_count());
 253
 254   BookmarkNode* partner_bookmark1 = new BookmarkNode(3,
 255                                                      GURL("http://www.a.com"));
 256   partner_bookmark1->set_type(BookmarkNode::URL);
 257   partner_bookmark1->SetTitle(base::ASCIIToUTF16("a.com"));
 258   partner_folder1->Add(partner_bookmark1, partner_folder1->child_count());
 259
 260   BookmarkNode* partner_bookmark2 = new BookmarkNode(4,
 261                                                      GURL("http://www.b.com"));
 262   partner_bookmark2->set_type(BookmarkNode::URL);
 263   partner_bookmark2->SetTitle(base::ASCIIToUTF16("b.com"));
 264   partner_folder2->Add(partner_bookmark2, partner_folder2->child_count());
 265
 266   ASSERT_FALSE(shim->IsLoaded());
 267   EXPECT_CALL(observer_, PartnerShimLoaded(shim)).Times(1);
 268   shim->SetPartnerBookmarksRoot(root_partner_node);
 269   ASSERT_TRUE(shim->IsLoaded());
 270
 271   EXPECT_EQ(root_partner_node, shim->GetNodeByID(0));
 272   EXPECT_EQ(partner_folder1, shim->GetNodeByID(1));
 273   EXPECT_EQ(partner_folder2, shim->GetNodeByID(2));
 274   EXPECT_EQ(partner_bookmark1, shim->GetNodeByID(3));
 275   EXPECT_EQ(partner_bookmark2, shim->GetNodeByID(4));
 276
 277   EXPECT_TRUE(shim->IsReachable(root_partner_node));
 278   EXPECT_TRUE(shim->IsReachable(partner_folder1));
 279   EXPECT_TRUE(shim->IsReachable(partner_folder2));
 280   EXPECT_TRUE(shim->IsReachable(partner_bookmark1));
 281   EXPECT_TRUE(shim->IsReachable(partner_bookmark2));
 282
 283   EXPECT_CALL(observer_, PartnerShimChanged(shim)).Times(1);
 284   EXPECT_EQ(base::ASCIIToUTF16("b.com"), shim->GetTitle(partner_bookmark2));
 285   shim->RenameBookmark(partner_bookmark2, base::ASCIIToUTF16("b2.com"));
 286   EXPECT_EQ(base::ASCIIToUTF16("b2.com"), shim->GetTitle(partner_bookmark2));
 287
 288   EXPECT_TRUE(shim->IsReachable(root_partner_node));
 289   EXPECT_TRUE(shim->IsReachable(partner_folder1));
 290   EXPECT_TRUE(shim->IsReachable(partner_folder2));
 291   EXPECT_TRUE(shim->IsReachable(partner_bookmark1));
 292   EXPECT_TRUE(shim->IsReachable(partner_bookmark2));
 293
 294   EXPECT_CALL(observer_, PartnerShimChanged(shim)).Times(1);
 295   EXPECT_EQ(base::ASCIIToUTF16("a.net"), shim->GetTitle(partner_folder1));
 296   shim->RenameBookmark(partner_folder1, base::ASCIIToUTF16("a2.net"));
 297   EXPECT_EQ(base::ASCIIToUTF16("a2.net"), shim->GetTitle(partner_folder1));
 298
 299   EXPECT_TRUE(shim->IsReachable(root_partner_node));
 300   EXPECT_TRUE(shim->IsReachable(partner_folder1));
 301   EXPECT_TRUE(shim->IsReachable(partner_folder2));
 302   EXPECT_TRUE(shim->IsReachable(partner_bookmark1));
 303   EXPECT_TRUE(shim->IsReachable(partner_bookmark2));
 304
 305   EXPECT_CALL(observer_, PartnerShimChanged(shim)).Times(1);
 306   EXPECT_EQ(base::ASCIIToUTF16("Partner bookmarks"),
 307             shim->GetTitle(root_partner_node));
 308   shim->RenameBookmark(root_partner_node, base::ASCIIToUTF16("Partner"));
 309   EXPECT_EQ(base::ASCIIToUTF16("Partner"), shim->GetTitle(root_partner_node));
 310
 311   EXPECT_TRUE(shim->IsReachable(root_partner_node));
 312   EXPECT_TRUE(shim->IsReachable(partner_folder1));
 313   EXPECT_TRUE(shim->IsReachable(partner_folder2));
 314   EXPECT_TRUE(shim->IsReachable(partner_bookmark1));
 315   EXPECT_TRUE(shim->IsReachable(partner_bookmark2));
 316 }
 317
 318 TEST_F(PartnerBookmarksShimTest, SaveLoadProfile) {
 319   {
 320     PartnerBookmarksShim* shim = partner_bookmarks_shim();
 321     shim->AddObserver(&observer_);
 322
 323     EXPECT_CALL(observer_, PartnerShimLoaded(shim)).Times(0);
 324     EXPECT_CALL(observer_, PartnerShimChanged(shim)).Times(0);
 325
 326     BookmarkNode* root_partner_node = new BookmarkPermanentNode(0);
 327     root_partner_node->SetTitle(base::ASCIIToUTF16("Partner bookmarks"));
 328
 329     BookmarkNode* partner_folder1 = new BookmarkNode(1, GURL("http://a.net"));
 330     partner_folder1->set_type(BookmarkNode::FOLDER);
 331     partner_folder1->SetTitle(base::ASCIIToUTF16("a.net"));
 332     root_partner_node->Add(partner_folder1, root_partner_node->child_count());
 333
 334     BookmarkNode* partner_bookmark1 = new BookmarkNode(3,
 335                                                        GURL("http://a.com"));
 336     partner_bookmark1->set_type(BookmarkNode::URL);
 337     partner_bookmark1->SetTitle(base::ASCIIToUTF16("a.com"));
 338     partner_folder1->Add(partner_bookmark1, partner_folder1->child_count());
 339
 340     BookmarkNode* partner_bookmark2 = new BookmarkNode(5,
 341                                                        GURL("http://b.com"));
 342     partner_bookmark2->set_type(BookmarkNode::URL);
 343     partner_bookmark2->SetTitle(base::ASCIIToUTF16("b.com"));
 344     partner_folder1->Add(partner_bookmark2, partner_folder1->child_count());
 345
 346     ASSERT_FALSE(shim->IsLoaded());
 347     EXPECT_CALL(observer_, PartnerShimLoaded(shim)).Times(1);
 348     shim->SetPartnerBookmarksRoot(root_partner_node);
 349     ASSERT_TRUE(shim->IsLoaded());
 350
 351     EXPECT_CALL(observer_, PartnerShimChanged(shim)).Times(2);
 352     shim->RenameBookmark(partner_bookmark1, base::ASCIIToUTF16("a2.com"));
 353     shim->RemoveBookmark(partner_bookmark2);
 354     EXPECT_EQ(base::ASCIIToUTF16("a2.com"), shim->GetTitle(partner_bookmark1));
 355     EXPECT_FALSE(shim->IsReachable(partner_bookmark2));
 356   }
 357
 358   PartnerBookmarksShim::ClearInBrowserContextForTesting(profile_.get());
 359
 360   {
 361     PartnerBookmarksShim* shim = partner_bookmarks_shim();
 362     shim->AddObserver(&observer_);
 363
 364     EXPECT_CALL(observer_, PartnerShimLoaded(shim)).Times(0);
 365     EXPECT_CALL(observer_, PartnerShimChanged(shim)).Times(0);
 366     ASSERT_TRUE(shim->IsLoaded());
 367
 368     const BookmarkNode* partner_bookmark1 = shim->GetNodeByID(3);
 369     const BookmarkNode* partner_bookmark2 = shim->GetNodeByID(5);
 370
 371     EXPECT_EQ(base::ASCIIToUTF16("a2.com"), shim->GetTitle(partner_bookmark1));
 372     EXPECT_FALSE(shim->IsReachable(partner_bookmark2));
 373   }
 374 }
 375
 376 TEST_F(PartnerBookmarksShimTest, DisableEditing) {
 377   PartnerBookmarksShim* shim = partner_bookmarks_shim();
 378   shim->AddObserver(&observer_);
 379
 380   EXPECT_CALL(observer_, PartnerShimLoaded(shim)).Times(0);
 381   EXPECT_CALL(observer_, PartnerShimChanged(shim)).Times(0);
 382
 383   BookmarkNode* root_partner_node = new BookmarkPermanentNode(0);
 384   root_partner_node->SetTitle(base::ASCIIToUTF16("Partner bookmarks"));
 385
 386   BookmarkNode* partner_bookmark1 = new BookmarkNode(3, GURL("http://a"));
 387   partner_bookmark1->set_type(BookmarkNode::URL);
 388   partner_bookmark1->SetTitle(base::ASCIIToUTF16("a"));
 389   root_partner_node->Add(partner_bookmark1, root_partner_node->child_count());
 390
 391   BookmarkNode* partner_bookmark2 = new BookmarkNode(3, GURL("http://b"));
 392   partner_bookmark2->set_type(BookmarkNode::URL);
 393   partner_bookmark2->SetTitle(base::ASCIIToUTF16("b"));
 394   root_partner_node->Add(partner_bookmark2, root_partner_node->child_count());
 395
 396   ASSERT_FALSE(shim->IsLoaded());
 397   EXPECT_CALL(observer_, PartnerShimLoaded(shim)).Times(1);
 398   shim->SetPartnerBookmarksRoot(root_partner_node);
 399   ASSERT_TRUE(shim->IsLoaded());
 400
 401   // Check that edits work by default.
 402   EXPECT_CALL(observer_, PartnerShimChanged(shim)).Times(2);
 403   shim->RenameBookmark(partner_bookmark1, base::ASCIIToUTF16("a2.com"));
 404   shim->RemoveBookmark(partner_bookmark2);
 405   EXPECT_EQ(base::ASCIIToUTF16("a2.com"), shim->GetTitle(partner_bookmark1));
 406   EXPECT_FALSE(shim->IsReachable(partner_bookmark2));
 407
 408   // Disable edits and check that edits are not applied anymore.
 409   PartnerBookmarksShim::DisablePartnerBookmarksEditing();
 410   EXPECT_EQ(base::ASCIIToUTF16("a"), shim->GetTitle(partner_bookmark1));
 411   EXPECT_TRUE(shim->IsReachable(partner_bookmark2));
 412 }