Add tests to EnhancedBookmarksModel

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

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());
+    }
+}