Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(11)

Unified Diff: chrome/android/javatests/src/org/chromium/chrome/browser/enhanced_bookmarks/EnhancedBookmarksModelTest.java

Issue 929523002: Add tests to EnhancedBookmarksModel (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 5 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: chrome/android/javatests/src/org/chromium/chrome/browser/enhanced_bookmarks/EnhancedBookmarksModelTest.java
diff --git a/chrome/android/javatests/src/org/chromium/chrome/browser/enhanced_bookmarks/EnhancedBookmarksModelTest.java b/chrome/android/javatests/src/org/chromium/chrome/browser/enhanced_bookmarks/EnhancedBookmarksModelTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..13643614ba1015e865a3914bd32591df47ccc92e
--- /dev/null
+++ b/chrome/android/javatests/src/org/chromium/chrome/browser/enhanced_bookmarks/EnhancedBookmarksModelTest.java
@@ -0,0 +1,374 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.chrome.browser.enhanced_bookmarks;
+
+import android.test.UiThreadTest;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.chromium.base.ThreadUtils;
+import org.chromium.base.test.util.Feature;
+import org.chromium.chrome.browser.BookmarksBridge.BookmarkItem;
+import org.chromium.chrome.browser.profiles.Profile;
+import org.chromium.chrome.shell.ChromeShellActivity;
+import org.chromium.chrome.shell.ChromeShellTab;
+import org.chromium.chrome.shell.ChromeShellTestBase;
+import org.chromium.components.bookmarks.BookmarkId;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Stack;
+
+/**
+ * Tests for {@link EnhancedBookmarksModel}, the data layer of Enhanced Bookmarks.
+ */
+public class EnhancedBookmarksModelTest extends ChromeShellTestBase{
+
+ private ChromeShellActivity mActivity;
+ private EnhancedBookmarksModel mBookmarksModel;
+ private BookmarkId mRootNode;
+ private BookmarkId mMobileNode;
+ private BookmarkId mOtherNode;
+ private BookmarkId mDesktopNode;
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+ mActivity = launchChromeShellWithBlankPage();
+ assertTrue(waitForActiveShellToBeDoneLoading());
+ ThreadUtils.runOnUiThreadBlocking(new Runnable() {
+ @Override
+ public void run() {
+ ChromeShellTab tab = mActivity.getActiveTab();
+ Profile profile = tab.getProfile();
+ mBookmarksModel = new EnhancedBookmarksModel(profile);
+ mBookmarksModel.loadEmptyPartnerBookmarkShimForTesting();
+ mRootNode = mBookmarksModel.getRootFolderId();
+ mMobileNode = mBookmarksModel.getMobileFolderId();
+ mDesktopNode = mBookmarksModel.getDesktopFolderId();
+ mOtherNode = mBookmarksModel.getOtherFolderId();
+ }
+ });
+ }
+
+ @UiThreadTest
+ @SmallTest
+ @Feature({"Bookmark"})
+ public void testgetAllBookmarkIDsOrderedByCreationDate() throws InterruptedException {
+ BookmarkId folderA = mBookmarksModel.addFolder(mMobileNode, 0, "a");
+ BookmarkId folderB = mBookmarksModel.addFolder(mDesktopNode, 0, "b");
+
+ Stack<BookmarkId> stack = new Stack<BookmarkId>();
+ stack.push(mBookmarksModel.addBookmark(folderA, 0, "a", "http://www.medium.com"));
+ // If add bookmarks too fast, eventually some bookmarks will have the same timestamp, which
+ // confuses the bookmark model.
+ Thread.sleep(20);
+ stack.push(mBookmarksModel.addBookmark(folderB, 0, "b", "http://aurimas.com"));
+ Thread.sleep(20);
+ stack.push(mBookmarksModel.addBookmark(mMobileNode, 0, "c", "http://www.aurimas.com"));
+ Thread.sleep(20);
+ stack.push(mBookmarksModel.addBookmark(mDesktopNode, 0, "d", "http://www.aurimas.org"));
+ Thread.sleep(20);
+ stack.push(mBookmarksModel.addBookmark(mOtherNode, 0, "e", "http://www.google.com"));
+ Thread.sleep(20);
+ stack.push(mBookmarksModel.addBookmark(folderA, 0, "f", "http://www.newt.com"));
+ Thread.sleep(20);
+ stack.push(mBookmarksModel.addBookmark(folderB, 0, "g", "http://kkimlabs.com"));
+
+ List<BookmarkId> bookmarks = mBookmarksModel.getAllBookmarkIDsOrderedByCreationDate();
+ assertEquals(bookmarks.size(), stack.size());
+ for (BookmarkId returnedBookmark : bookmarks) {
+ android.util.Log.e("jokey", "returned "
+ + mBookmarksModel.getBookmarkTitle(returnedBookmark) + " stack "
+ + mBookmarksModel.getBookmarkTitle(stack.peek()));
+ assertEquals(stack.pop(), returnedBookmark);
+ }
+ }
+
+ @UiThreadTest
+ @SmallTest
+ @Feature({"Bookmark"})
+ public void testBookmarkPropertySetters() {
+ BookmarkId folderA = mBookmarksModel.addFolder(mMobileNode, 0, "a");
+
+ BookmarkId bookmarkA = mBookmarksModel.addBookmark(mDesktopNode, 0, "a", "http://a.com");
+ BookmarkId bookmarkB = mBookmarksModel.addBookmark(mMobileNode, 0, "a", "http://a.com");
+ BookmarkId bookmarkC = mBookmarksModel.addBookmark(mOtherNode, 0, "a", "http://a.com");
+ BookmarkId bookmarkD = mBookmarksModel.addBookmark(folderA, 0, "a", "http://a.com");
+
+ mBookmarksModel.setBookmarkTitle(folderA, "jokkk");
+ assertEquals("jokkk", mBookmarksModel.getBookmarkTitle(folderA));
+
+ mBookmarksModel.setBookmarkTitle(bookmarkA, "auri");
+ mBookmarksModel.setBookmarkUrl(bookmarkA, "http://auri.org/");
+ mBookmarksModel.setBookmarkDescription(bookmarkA, "auri");
+ verifyBookmarkWithDescription(bookmarkA, "auri", "http://auri.org/", "auri", false,
+ mDesktopNode);
+
+ mBookmarksModel.setBookmarkTitle(bookmarkB, "lauri");
+ mBookmarksModel.setBookmarkUrl(bookmarkB, "http://lauri.org/");
+ mBookmarksModel.setBookmarkDescription(bookmarkB, "lauri");
+ verifyBookmarkWithDescription(bookmarkB, "lauri", "http://lauri.org/", "lauri", false,
+ mMobileNode);
+
+ mBookmarksModel.setBookmarkTitle(bookmarkC, "mauri");
+ mBookmarksModel.setBookmarkUrl(bookmarkC, "http://mauri.org/");
+ mBookmarksModel.setBookmarkDescription(bookmarkC, "mauri");
+ verifyBookmarkWithDescription(bookmarkC, "mauri", "http://mauri.org/", "mauri", false,
+ mOtherNode);
+
+ mBookmarksModel.setBookmarkTitle(bookmarkD, "kauri");
+ mBookmarksModel.setBookmarkUrl(bookmarkD, "http://kauri.org/");
+ mBookmarksModel.setBookmarkDescription(bookmarkD, "kauri");
+ verifyBookmarkWithDescription(bookmarkD, "kauri", "http://kauri.org/", "kauri", false,
+ folderA);
+ }
+
+ @UiThreadTest
+ @SmallTest
+ @Feature({"Bookmark"})
+ public void testMoveBookmarks() {
+ BookmarkId bookmarkA = mBookmarksModel.addBookmark(mDesktopNode, 0, "a", "http://a.com");
+ BookmarkId bookmarkB = mBookmarksModel.addBookmark(mOtherNode, 0, "b", "http://b.com");
+ BookmarkId bookmarkC = mBookmarksModel.addBookmark(mMobileNode, 0, "c", "http://c.com");
+ BookmarkId folderA = mBookmarksModel.addFolder(mOtherNode, 0, "fa");
+ BookmarkId folderB = mBookmarksModel.addFolder(mDesktopNode, 0, "fb");
+ BookmarkId folderC = mBookmarksModel.addFolder(mMobileNode, 0, "fc");
+ BookmarkId bookmarkAA = mBookmarksModel.addBookmark(folderA, 0, "aa", "http://aa.com");
+ BookmarkId bookmarkCA = mBookmarksModel.addBookmark(folderC, 0, "ca", "http://ca.com");
+ BookmarkId folderAA = mBookmarksModel.addFolder(folderA, 0, "faa");
+
+ HashSet<BookmarkId> movedBookmarks = new HashSet<BookmarkId>(4);
+ movedBookmarks.add(bookmarkA);
+ movedBookmarks.add(bookmarkB);
+ movedBookmarks.add(bookmarkC);
+ movedBookmarks.add(folderC);
+ movedBookmarks.add(folderB);
+ movedBookmarks.add(bookmarkAA);
+ mBookmarksModel.moveBookmarks(new ArrayList<BookmarkId>(movedBookmarks), folderAA);
+
+ // Order of the moved bookmarks is not tested.
+ verifyBookmarkListNoOrder(mBookmarksModel.getChildIDs(folderAA, true, true),
+ new HashSet<BookmarkId>(movedBookmarks));
+ }
+
+ @UiThreadTest
+ @SmallTest
+ @Feature({"Bookmark"})
+ public void testGetChildIDs() {
+ BookmarkId folderA = mBookmarksModel.addFolder(mMobileNode, 0, "fa");
+ HashSet<BookmarkId> expectedChildren = new HashSet<>();
+ expectedChildren.add(mBookmarksModel.addBookmark(folderA, 0, "a", "http://a.com"));
+ expectedChildren.add(mBookmarksModel.addBookmark(folderA, 0, "a", "http://a.com"));
+ expectedChildren.add(mBookmarksModel.addBookmark(folderA, 0, "a", "http://a.com"));
+ expectedChildren.add(mBookmarksModel.addBookmark(folderA, 0, "a", "http://a.com"));
+ BookmarkId folderAA = mBookmarksModel.addFolder(folderA, 0, "faa");
+ // urls only
+ verifyBookmarkListNoOrder(mBookmarksModel.getChildIDs(folderA, false, true),
+ new HashSet<BookmarkId>(expectedChildren));
+ // folders only
+ verifyBookmarkListNoOrder(mBookmarksModel.getChildIDs(folderA, true, false),
+ new HashSet<BookmarkId>(Arrays.asList(folderAA)));
+ expectedChildren.add(folderAA);
+ // folders and urls
+ verifyBookmarkListNoOrder(mBookmarksModel.getChildIDs(folderA, true, true),
+ new HashSet<BookmarkId>(expectedChildren));
+ }
+
+ // Moved from BookmarksBridgeTest
+ @UiThreadTest
+ @SmallTest
+ @Feature({"Bookmark"})
+ public void testAddBookmarksAndFolders() {
+ BookmarkId bookmarkA = mBookmarksModel.addBookmark(mDesktopNode, 0, "a", "http://a.com");
+ verifyBookmark(bookmarkA, "a", "http://a.com/", false, mDesktopNode);
+ BookmarkId bookmarkB = mBookmarksModel.addBookmark(mOtherNode, 0, "b", "http://b.com");
+ verifyBookmark(bookmarkB, "b", "http://b.com/", false, mOtherNode);
+ BookmarkId bookmarkC = mBookmarksModel.addBookmark(mMobileNode, 0, "c", "http://c.com");
+ verifyBookmark(bookmarkC, "c", "http://c.com/", false, mMobileNode);
+ BookmarkId folderA = mBookmarksModel.addFolder(mOtherNode, 0, "fa");
+ verifyBookmark(folderA, "fa", null, true, mOtherNode);
+ BookmarkId folderB = mBookmarksModel.addFolder(mDesktopNode, 0, "fb");
+ verifyBookmark(folderB, "fb", null, true, mDesktopNode);
+ BookmarkId folderC = mBookmarksModel.addFolder(mMobileNode, 0, "fc");
+ verifyBookmark(folderC, "fc", null, true, mMobileNode);
+ BookmarkId bookmarkAA = mBookmarksModel.addBookmark(folderA, 0, "aa", "http://aa.com");
+ verifyBookmark(bookmarkAA, "aa", "http://aa.com/", false, folderA);
+ BookmarkId folderAA = mBookmarksModel.addFolder(folderA, 0, "faa");
+ verifyBookmark(folderAA, "faa", null, true, folderA);
+ }
+
+ // Moved from BookmarksBridgeTest
+ @UiThreadTest
+ @SmallTest
+ @Feature({"Bookmark"})
+ public void testGetAllFoldersWithDepths() {
+ BookmarkId folderA = mBookmarksModel.addFolder(mMobileNode, 0, "a");
+ BookmarkId folderB = mBookmarksModel.addFolder(mDesktopNode, 0, "b");
+ BookmarkId folderC = mBookmarksModel.addFolder(mOtherNode, 0, "c");
+ BookmarkId folderAA = mBookmarksModel.addFolder(folderA, 0, "aa");
+ BookmarkId folderBA = mBookmarksModel.addFolder(folderB, 0, "ba");
+ BookmarkId folderAAA = mBookmarksModel.addFolder(folderAA, 0, "aaa");
+ BookmarkId folderAAAA = mBookmarksModel.addFolder(folderAAA, 0, "aaaa");
+
+ mBookmarksModel.addBookmark(mMobileNode, 0, "ua", "http://www.google.com");
+ mBookmarksModel.addBookmark(mDesktopNode, 0, "ua", "http://www.google.com");
+ mBookmarksModel.addBookmark(mOtherNode, 0, "ua", "http://www.google.com");
+ mBookmarksModel.addBookmark(folderA, 0, "ua", "http://www.medium.com");
+
+ // Map folders to depths as expected results
+ HashMap<BookmarkId, Integer> idToDepth = new HashMap<BookmarkId, Integer>();
+ idToDepth.put(mMobileNode, 0);
+ idToDepth.put(folderA, 1);
+ idToDepth.put(folderAA, 2);
+ idToDepth.put(folderAAA, 3);
+ idToDepth.put(folderAAAA, 4);
+ idToDepth.put(mDesktopNode, 0);
+ idToDepth.put(folderB, 1);
+ idToDepth.put(folderBA, 2);
+ idToDepth.put(mOtherNode, 0);
+ idToDepth.put(folderC, 1);
+
+ List<BookmarkId> folderList = new ArrayList<BookmarkId>();
+ List<Integer> depthList = new ArrayList<Integer>();
+ mBookmarksModel.getAllFoldersWithDepths(folderList, depthList);
+ verifyFolderDepths(folderList, depthList, idToDepth);
+ }
+
+ // Moved from BookmarksBridgeTest
+ @UiThreadTest
+ @SmallTest
+ @Feature({"Bookmark"})
+ public void testGetMoveDestinations() {
+ BookmarkId folderA = mBookmarksModel.addFolder(mMobileNode, 0, "a");
+ BookmarkId folderB = mBookmarksModel.addFolder(mDesktopNode, 0, "b");
+ BookmarkId folderC = mBookmarksModel.addFolder(mOtherNode, 0, "c");
+ BookmarkId folderAA = mBookmarksModel.addFolder(folderA, 0, "aa");
+ BookmarkId folderBA = mBookmarksModel.addFolder(folderB, 0, "ba");
+ BookmarkId folderAAA = mBookmarksModel.addFolder(folderAA, 0, "aaa");
+
+ mBookmarksModel.addBookmark(mMobileNode, 0, "ua", "http://www.google.com");
+ mBookmarksModel.addBookmark(mDesktopNode, 0, "ua", "http://www.google.com");
+ mBookmarksModel.addBookmark(mOtherNode, 0, "ua", "http://www.google.com");
+ mBookmarksModel.addBookmark(folderA, 0, "ua", "http://www.medium.com");
+
+ // Map folders to depths as expected results
+ HashMap<BookmarkId, Integer> idToDepth = new HashMap<BookmarkId, Integer>();
+
+ List<BookmarkId> folderList = new ArrayList<BookmarkId>();
+ List<Integer> depthList = new ArrayList<Integer>();
+
+ mBookmarksModel.getMoveDestinations(folderList, depthList, Arrays.asList(folderA));
+ idToDepth.put(mMobileNode, 0);
+ idToDepth.put(mDesktopNode, 0);
+ idToDepth.put(folderB, 1);
+ idToDepth.put(folderBA, 2);
+ idToDepth.put(mOtherNode, 0);
+ idToDepth.put(folderC, 1);
+ verifyFolderDepths(folderList, depthList, idToDepth);
+
+ mBookmarksModel.getMoveDestinations(folderList, depthList, Arrays.asList(folderB));
+ idToDepth.put(mMobileNode, 0);
+ idToDepth.put(folderA, 1);
+ idToDepth.put(folderAA, 2);
+ idToDepth.put(folderAAA, 3);
+ idToDepth.put(mDesktopNode, 0);
+ idToDepth.put(mOtherNode, 0);
+ idToDepth.put(folderC, 1);
+ verifyFolderDepths(folderList, depthList, idToDepth);
+
+ mBookmarksModel.getMoveDestinations(folderList, depthList, Arrays.asList(folderC));
+ idToDepth.put(mMobileNode, 0);
+ idToDepth.put(folderA, 1);
+ idToDepth.put(folderAA, 2);
+ idToDepth.put(folderAAA, 3);
+ idToDepth.put(mDesktopNode, 0);
+ idToDepth.put(folderB, 1);
+ idToDepth.put(folderBA, 2);
+ idToDepth.put(mOtherNode, 0);
+ verifyFolderDepths(folderList, depthList, idToDepth);
+
+ mBookmarksModel.getMoveDestinations(folderList, depthList, Arrays.asList(folderBA));
+ idToDepth.put(mMobileNode, 0);
+ idToDepth.put(folderA, 1);
+ idToDepth.put(folderAA, 2);
+ idToDepth.put(folderAAA, 3);
+ idToDepth.put(mDesktopNode, 0);
+ idToDepth.put(folderB, 1);
+ idToDepth.put(mOtherNode, 0);
+ idToDepth.put(folderC, 1);
+ verifyFolderDepths(folderList, depthList, idToDepth);
+
+ mBookmarksModel.getMoveDestinations(folderList, depthList,
+ Arrays.asList(folderAA, folderC));
+ idToDepth.put(mMobileNode, 0);
+ idToDepth.put(folderA, 1);
+ idToDepth.put(mDesktopNode, 0);
+ idToDepth.put(folderB, 1);
+ idToDepth.put(folderBA, 2);
+ idToDepth.put(mOtherNode, 0);
+ verifyFolderDepths(folderList, depthList, idToDepth);
+ }
+
+ // Moved from BookmarksBridgeTest
+ private void verifyFolderDepths(List<BookmarkId> folderList, List<Integer> depthList,
+ HashMap<BookmarkId, Integer> idToDepth) {
+ assertFalse("Root node should not be returned as a destination folder: ",
+ folderList.contains(mRootNode));
+ assertEquals(folderList.size(), depthList.size());
+ assertEquals(folderList.size(), idToDepth.size());
+ for (int i = 0; i < folderList.size(); i++) {
+ BookmarkId folder = folderList.get(i);
+ Integer depth = depthList.get(i);
+ assertNotNull(folder);
+ assertNotNull(depthList.get(i));
+ assertTrue("Folder list contains non-folder elements: ",
+ mBookmarksModel.getBookmarkById(folder).isFolder());
+ assertTrue("Returned list contained unexpected key: ", idToDepth.containsKey(folder));
+ assertEquals(idToDepth.get(folder), depth);
+ idToDepth.remove(folder);
+ }
+ assertEquals(idToDepth.size(), 0);
+ folderList.clear();
+ depthList.clear();
+ }
+
+ // Moved from BookmarksBridgeTest
+ private void verifyBookmark(BookmarkId idToVerify, String expectedTitle,
+ String expectedUrl, boolean isFolder, BookmarkId expectedParent) {
+ assertNotNull(idToVerify);
+ BookmarkItem item = mBookmarksModel.getBookmarkById(idToVerify);
+ assertEquals(expectedTitle, item.getTitle());
+ assertEquals(item.isFolder(), isFolder);
+ if (!isFolder) assertEquals(expectedUrl, item.getUrl());
+ assertEquals(item.getParentId(), expectedParent);
+ }
+
+ private void verifyBookmarkWithDescription(BookmarkId idToVerify, String expectedTitle,
+ String expectedUrl, String expectedDescription, boolean isFolder,
+ BookmarkId expectedParent) {
+ assertNotNull(idToVerify);
+ assertEquals(expectedDescription, mBookmarksModel.getBookmarkDescription(idToVerify));
+ verifyBookmark(idToVerify, expectedTitle, expectedUrl, isFolder, expectedParent);
+ }
+
+ /**
+ * Before using this helper method, always make sure @param listToVerify does not contain
+ * duplicates. Note this method will remove all items in expectedIds, so be careful if you want
+ * to reuse the hashset.
+ */
+ private void verifyBookmarkListNoOrder(List<BookmarkId> listToVerify,
+ HashSet<BookmarkId> expectedIds) {
+ assertEquals(expectedIds.size(), listToVerify.size());
+ for (BookmarkId id : listToVerify) {
+ assertNotNull(id);
+ assertTrue("List contains wrong element: ", expectedIds.contains(id));
+ expectedIds.remove(id);
+ }
+ assertTrue("List does not contain some expected bookmarks: ", expectedIds.isEmpty());
+ }
+}

Powered by Google App Engine
This is Rietveld 408576698