android/provider/SearchRecentSuggestionsProviderTest.java

/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.provider;

import android.app.SearchManager;
import android.content.ContentResolver;
import android.database.Cursor;
import android.net.Uri;
import android.test.ProviderTestCase2;
import android.test.suitebuilder.annotation.MediumTest;

/**
 * ProviderTestCase that performs unit tests of SearchRecentSuggestionsProvider.
 *
 * You can run this test in isolation via the commands:
 *
 * $ (cd tests/FrameworkTests/ && mm) && adb sync
 * $ adb shell am instrument -w \
 *     -e class android.provider.SearchRecentSuggestionsProviderTest
 *     com.android.frameworktest.tests/android.test.InstrumentationTestRunner
 */
@MediumTest
public class SearchRecentSuggestionsProviderTest extends ProviderTestCase2<TestProvider> {

    // Elements prepared by setUp()
    SearchRecentSuggestions mSearchHelper;

    public SearchRecentSuggestionsProviderTest() {
        super(TestProvider.class, TestProvider.AUTHORITY);
    }

    /**
     * During setup, grab a helper for DB access
     */
    @Override
    public void setUp() throws Exception {
        super.setUp();

        // Use the recent suggestions helper.  As long as we pass in our isolated context,
        // it should correctly access the provider under test.
        mSearchHelper = new SearchRecentSuggestions(getMockContext(),
                TestProvider.AUTHORITY, TestProvider.MODE);

        // test for empty database at setup time
        checkOpenCursorCount(0);
    }

    /**
     * Simple test to see if we can instantiate the whole mess.
     */
    public void testSetup() {
        assertTrue(true);
    }

    /**
     * Simple test to see if we can write and read back a single query
     */
    public void testOneQuery() {
        final String TEST_LINE1 = "test line 1";
        final String TEST_LINE2 = "test line 2";
        mSearchHelper.saveRecentQuery(TEST_LINE1, TEST_LINE2);
        mSearchHelper.waitForSave();

        // make sure that there are is exactly one entry returned by a non-filtering cursor
        checkOpenCursorCount(1);

        // test non-filtering cursor for correct entry
        checkResultCounts(null, 1, 1, TEST_LINE1, TEST_LINE2);

        // test filtering cursor for correct entry
        checkResultCounts(TEST_LINE1, 1, 1, TEST_LINE1, TEST_LINE2);
        checkResultCounts(TEST_LINE2, 1, 1, TEST_LINE1, TEST_LINE2);

        // test that a different filter returns zero results
        checkResultCounts("bad filter", 0, 0, null, null);
    }

    /**
     * Simple test to see if we can write and read back a diverse set of queries
     */
    public void testMixedQueries() {
        // we'll make 10 queries named "query x" and 10 queries named "test x"
        final String TEST_GROUP_1 = "query ";
        final String TEST_GROUP_2 = "test ";
        final String TEST_LINE2 = "line2 ";
        final int GROUP_COUNT = 10;

        writeEntries(GROUP_COUNT, TEST_GROUP_1, TEST_LINE2);
        writeEntries(GROUP_COUNT, TEST_GROUP_2, TEST_LINE2);

        // check counts
        checkOpenCursorCount(2 * GROUP_COUNT);

        // check that each query returns the right result counts
        checkResultCounts(TEST_GROUP_1, GROUP_COUNT, GROUP_COUNT, null, null);
        checkResultCounts(TEST_GROUP_2, GROUP_COUNT, GROUP_COUNT, null, null);
        checkResultCounts(TEST_LINE2, 2 * GROUP_COUNT, 2 * GROUP_COUNT, null, null);
    }

    /**
     * Test that the reordering code works properly.  The most recently injected queries
     * should replace existing queries and be sorted to the top of the list.
     */
    public void testReordering() {
        // first we'll make 10 queries named "group1 x"
        final int GROUP_1_COUNT = 10;
        final String GROUP_1_QUERY = "group1 ";
        final String GROUP_1_LINE2 = "line2 ";
        writeEntries(GROUP_1_COUNT, GROUP_1_QUERY, GROUP_1_LINE2);

        // check totals
        checkOpenCursorCount(GROUP_1_COUNT);

        // guarantee that group 1 has older timestamps
        writeDelay();

        // next we'll add 10 entries named "group2 x"
        final int GROUP_2_COUNT = 10;
        final String GROUP_2_QUERY = "group2 ";
        final String GROUP_2_LINE2 = "line2 ";
        writeEntries(GROUP_2_COUNT, GROUP_2_QUERY, GROUP_2_LINE2);

        // check totals
        checkOpenCursorCount(GROUP_1_COUNT + GROUP_2_COUNT);

        // guarantee that group 2 has older timestamps
        writeDelay();

        // now refresh 5 of the 10 from group 1
        // change line2 so they can be more easily tracked
        final int GROUP_3_COUNT = 5;
        final String GROUP_3_QUERY = GROUP_1_QUERY;
        final String GROUP_3_LINE2 = "refreshed ";
        writeEntries(GROUP_3_COUNT, GROUP_3_QUERY, GROUP_3_LINE2);

        // confirm that the total didn't change (those were replacements, not adds)
        checkOpenCursorCount(GROUP_1_COUNT + GROUP_2_COUNT);

        // confirm that the are now 5 in group 1, 10 in group 2, and 5 in group 3
        int newGroup1Count = GROUP_1_COUNT - GROUP_3_COUNT;
        checkResultCounts(GROUP_1_QUERY, newGroup1Count, newGroup1Count, null, GROUP_1_LINE2);
        checkResultCounts(GROUP_2_QUERY, GROUP_2_COUNT, GROUP_2_COUNT, null, null);
        checkResultCounts(GROUP_3_QUERY, GROUP_3_COUNT, GROUP_3_COUNT, null, GROUP_3_LINE2);

        // finally, spot check that the right groups are in the right places
        // the ordering should be group 3 (newest), group 2, group 1 (oldest)
        Cursor c = getQueryCursor(null);
        int colQuery = c.getColumnIndexOrThrow(SearchManager.SUGGEST_COLUMN_QUERY);
        int colDisplay1 = c.getColumnIndexOrThrow(SearchManager.SUGGEST_COLUMN_TEXT_1);
        int colDisplay2 = c.getColumnIndex(SearchManager.SUGGEST_COLUMN_TEXT_2);

        // Spot check the first and last expected entries of group 3
        c.moveToPosition(0);
        assertTrue("group 3 did not properly reorder to head of list",
                checkRow(c, colQuery, colDisplay1, colDisplay2, GROUP_3_QUERY, GROUP_3_LINE2));
        c.move(GROUP_3_COUNT - 1);
        assertTrue("group 3 did not properly reorder to head of list",
                checkRow(c, colQuery, colDisplay1, colDisplay2, GROUP_3_QUERY, GROUP_3_LINE2));

        // Spot check the first and last expected entries of group 2
        c.move(1);
        assertTrue("group 2 not in expected position after reordering",
                checkRow(c, colQuery, colDisplay1, colDisplay2, GROUP_2_QUERY, GROUP_2_LINE2));
        c.move(GROUP_2_COUNT - 1);
        assertTrue("group 2 not in expected position after reordering",
                checkRow(c, colQuery, colDisplay1, colDisplay2, GROUP_2_QUERY, GROUP_2_LINE2));

        // Spot check the first and last expected entries of group 1
        c.move(1);
        assertTrue("group 1 not in expected position after reordering",
                checkRow(c, colQuery, colDisplay1, colDisplay2, GROUP_1_QUERY, GROUP_1_LINE2));
        c.move(newGroup1Count - 1);
        assertTrue("group 1 not in expected position after reordering",
                checkRow(c, colQuery, colDisplay1, colDisplay2, GROUP_1_QUERY, GROUP_1_LINE2));

        c.close();
    }

    /**
     * Test that the pruning code works properly,  The database should not go beyond 250 entries,
     * and the oldest entries should always be discarded first.
     *
     * TODO:  This is a slow test, do we have annotation for that?
     */
    public void testPruning() {
        // first we'll make 50 queries named "group1 x"
        final int GROUP_1_COUNT = 50;
        final String GROUP_1_QUERY = "group1 ";
        final String GROUP_1_LINE2 = "line2 ";
        writeEntries(GROUP_1_COUNT, GROUP_1_QUERY, GROUP_1_LINE2);

        // check totals
        checkOpenCursorCount(GROUP_1_COUNT);

        // guarantee that group 1 has older timestamps (and will be pruned first)
        writeDelay();

        // next we'll add 200 entries named "group2 x"
        final int GROUP_2_COUNT = 200;
        final String GROUP_2_QUERY = "group2 ";
        final String GROUP_2_LINE2 = "line2 ";
        writeEntries(GROUP_2_COUNT, GROUP_2_QUERY, GROUP_2_LINE2);

        // check totals
        checkOpenCursorCount(GROUP_1_COUNT + GROUP_2_COUNT);

        // Finally we'll add 10 more entries named "group3 x"
        // These should push out 10 entries from group 1
        final int GROUP_3_COUNT = 10;
        final String GROUP_3_QUERY = "group3 ";
        final String GROUP_3_LINE2 = "line2 ";
        writeEntries(GROUP_3_COUNT, GROUP_3_QUERY, GROUP_3_LINE2);

        // total should still be 250
        checkOpenCursorCount(GROUP_1_COUNT + GROUP_2_COUNT);

        // there should be 40 group 1, 200 group 2, and 10 group 3
        int group1NewCount = GROUP_1_COUNT-GROUP_3_COUNT;
        checkResultCounts(GROUP_1_QUERY, group1NewCount, group1NewCount, null, null);
        checkResultCounts(GROUP_2_QUERY, GROUP_2_COUNT, GROUP_2_COUNT, null, null);
        checkResultCounts(GROUP_3_QUERY, GROUP_3_COUNT, GROUP_3_COUNT, null, null);
    }

    /**
     * Test that the clear history code works properly.
     */
    public void testClear() {
        // first we'll make 10 queries named "group1 x"
        final int GROUP_1_COUNT = 10;
        final String GROUP_1_QUERY = "group1 ";
        final String GROUP_1_LINE2 = "line2 ";
        writeEntries(GROUP_1_COUNT, GROUP_1_QUERY, GROUP_1_LINE2);

        // next we'll add 10 entries named "group2 x"
        final int GROUP_2_COUNT = 10;
        final String GROUP_2_QUERY = "group2 ";
        final String GROUP_2_LINE2 = "line2 ";
        writeEntries(GROUP_2_COUNT, GROUP_2_QUERY, GROUP_2_LINE2);

        // check totals
        checkOpenCursorCount(GROUP_1_COUNT + GROUP_2_COUNT);

        // delete all
        mSearchHelper.clearHistory();

        // check totals
        checkOpenCursorCount(0);
    }

    /**
     * Write a sequence of queries into the database, with incrementing counters in the strings.
     */
    private void writeEntries(int groupCount, String line1Base, String line2Base) {
        for (int i = 0; i < groupCount; i++) {
            final String line1 = line1Base + i;
            final String line2 = line2Base + i;
            mSearchHelper.saveRecentQuery(line1, line2);
            mSearchHelper.waitForSave();
        }
    }

    /**
     * A very slight delay to ensure that successive groups of queries in the DB cannot
     * have the same timestamp.
     */
    private void writeDelay() {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            fail("Interrupted sleep.");
        }
    }

    /**
     * Access an "open" (no selection) suggestions cursor and confirm that it has the specified
     * number of entries.
     *
     * @param expectCount The expected number of entries returned by the cursor.
     */
    private void checkOpenCursorCount(int expectCount) {
        Cursor c = getQueryCursor(null);
        assertEquals(expectCount, c.getCount());
        c.close();
    }

    /**
     * Set up a filter cursor and then scan it for specific results.
     *
     * @param queryString The query string to apply.
     * @param minRows The minimum number of matching rows that must be found.
     * @param maxRows The maximum number of matching rows that must be found.
     * @param matchDisplay1 If non-null, must match DISPLAY1 column if row counts as match
     * @param matchDisplay2 If non-null, must match DISPLAY2 column if row counts as match
     */
    private void checkResultCounts(String queryString, int minRows, int maxRows,
            String matchDisplay1, String matchDisplay2) {

        // get the cursor and apply sanity checks to result
        Cursor c = getQueryCursor(queryString);
        assertNotNull(c);
        assertTrue("Insufficient rows in filtered cursor", c.getCount() >= minRows);

        // look for minimum set of columns (note, display2 is optional)
        int colQuery = c.getColumnIndexOrThrow(SearchManager.SUGGEST_COLUMN_QUERY);
        int colDisplay1 = c.getColumnIndexOrThrow(SearchManager.SUGGEST_COLUMN_TEXT_1);
        int colDisplay2 = c.getColumnIndex(SearchManager.SUGGEST_COLUMN_TEXT_2);

        // now loop through rows and look for desired rows
        int foundRows = 0;
        c.moveToFirst();
        while (!c.isAfterLast()) {
            if (checkRow(c, colQuery, colDisplay1, colDisplay2, matchDisplay1, matchDisplay2)) {
                foundRows++;
            }
            c.moveToNext();
        }

        // now check the results
        assertTrue(minRows <= foundRows);
        assertTrue(foundRows <= maxRows);

        c.close();
    }

    /**
     * Check a single row for equality with target strings.
     *
     * @param c The cursor, already moved to the row
     * @param colQuery The column # containing the query.  The query must match display1.
     * @param colDisp1 The column # containing display line 1.
     * @param colDisp2 The column # containing display line 2, or -1 if no column
     * @param matchDisplay1 If non-null, this must be the prefix of display1
     * @param matchDisplay2 If non-null, this must be the prefix of display2
     * @return Returns true if the row is a "match"
     */
    private boolean checkRow(Cursor c, int colQuery, int colDisp1, int colDisp2,
            String matchDisplay1, String matchDisplay2) {
        // Get the data from the row
        String query = c.getString(colQuery);
        String display1 = c.getString(colDisp1);
        String display2 = (colDisp2 >= 0) ? c.getString(colDisp2) : null;

        assertEquals(query, display1);
        boolean result = true;
        if (matchDisplay1 != null) {
            result = result && (display1 != null) && display1.startsWith(matchDisplay1);
        }
        if (matchDisplay2 != null) {
            result = result && (display2 != null) && display2.startsWith(matchDisplay2);
        }

        return result;
    }

    /**
     * Generate a query cursor in a manner like the search dialog would.
     *
     * @param queryString The search string, or, null for "all"
     * @return Returns a cursor, or null if there was some problem.  Be sure to close the cursor
     * when done with it.
     */
    private Cursor getQueryCursor(String queryString) {
        ContentResolver cr = getMockContext().getContentResolver();

        String uriStr = "content://" + TestProvider.AUTHORITY +
        '/' + SearchManager.SUGGEST_URI_PATH_QUERY;
        Uri contentUri = Uri.parse(uriStr);

        String[] selArgs = new String[] {queryString};

        Cursor c = cr.query(contentUri, null, null, selArgs, null);

        assertNotNull(c);
        return c;
    }
}