tests/robotests/src/com/android/settings/search/CursorToSearchResultConverterTest.java

   1 /*
   2  * Copyright (C) 2017 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 package com.android.settings.search;
  19
  20 import android.app.Activity;
  21 import android.content.Context;
  22 import android.content.Intent;
  23 import android.database.Cursor;
  24 import android.database.MatrixCursor;
  25 import android.graphics.drawable.Drawable;
  26
  27 import com.android.settings.DisplaySettings;
  28 import com.android.settings.R;
  29 import com.android.settings.testutils.SettingsRobolectricTestRunner;
  30 import com.android.settings.TestConfig;
  31 import com.android.settings.dashboard.SiteMapManager;
  32 import com.android.settings.gestures.SwipeToNotificationSettings;
  33 import com.android.settings.search.ResultPayload.Availability;
  34 import com.android.settings.search.ResultPayload.PayloadType;
  35
  36 import com.android.settings.wifi.WifiSettings;
  37 import org.junit.Before;
  38 import org.junit.Test;
  39 import org.junit.runner.RunWith;
  40 import org.mockito.Answers;
  41 import org.mockito.Mock;
  42 import org.mockito.MockitoAnnotations;
  43 import org.robolectric.Robolectric;
  44 import org.robolectric.annotation.Config;
  45
  46 import java.util.ArrayList;
  47 import java.util.Arrays;
  48 import java.util.List;
  49 import java.util.Set;
  50
  51 import static com.google.common.truth.Truth.assertThat;
  52
  53 @RunWith(SettingsRobolectricTestRunner.class)
  54 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
  55 public class CursorToSearchResultConverterTest {
  56
  57     private static final List<String> TITLES = Arrays.asList("title1", "title2", "title3");
  58     private static final String SUMMARY = "summary";
  59     private static final String TARGET_PACKAGE = "a.b.c";
  60     private static final String TARGET_CLASS = "a.b.c.class";
  61     private static final String KEY = "key";
  62     private static final Intent INTENT = new Intent("com.android.settings");
  63     private static final int ICON = R.drawable.ic_search_history;
  64     private static final int BASE_RANK = 1;
  65
  66     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
  67     private SiteMapManager mSiteMapManager;
  68     private Drawable mDrawable;
  69     private CursorToSearchResultConverter mConverter;
  70
  71     @Before
  72     public void setUp() {
  73         MockitoAnnotations.initMocks(this);
  74         Context context = Robolectric.buildActivity(Activity.class).get();
  75         mDrawable = context.getDrawable(ICON);
  76         mConverter = new CursorToSearchResultConverter(context);
  77     }
  78
  79     @Test
  80     public void testParseNullResults_ReturnsNull() {
  81         final Set<SearchResult> results = mConverter.convertCursor(
  82                 mSiteMapManager, null, BASE_RANK);
  83         assertThat(results).isNull();
  84     }
  85
  86     @Test
  87     public void testParseCursor_NotNull() {
  88         final Set<SearchResult> results = mConverter.convertCursor(
  89                 mSiteMapManager, getDummyCursor(), BASE_RANK);
  90         assertThat(results).isNotNull();
  91     }
  92
  93     @Test
  94     public void testParseCursor_MatchesRank() {
  95         final Set<SearchResult> results = mConverter.convertCursor(
  96                 mSiteMapManager, getDummyCursor(), BASE_RANK);
  97         for (SearchResult result : results) {
  98             assertThat(result.rank).isEqualTo(BASE_RANK);
  99         }
 100     }
 101
 102     @Test
 103     public void testParseCursor_MatchesTitle() {
 104         final Set<SearchResult> results = mConverter.convertCursor(
 105                 mSiteMapManager, getDummyCursor(), BASE_RANK);
 106         for (SearchResult result : results) {
 107             assertThat(TITLES).contains(result.title);
 108         }
 109     }
 110
 111     @Test
 112     public void testParseCursor_MatchesSummary() {
 113         final Set<SearchResult> results = mConverter.convertCursor(
 114                 mSiteMapManager, getDummyCursor(), BASE_RANK);
 115         for (SearchResult result : results) {
 116             assertThat(result.summary).isEqualTo(SUMMARY);
 117         }
 118     }
 119
 120     @Test
 121     public void testParseCursor_MatchesIcon() {
 122         final MatrixCursor cursor = new MatrixCursor(DatabaseResultLoader.SELECT_COLUMNS);
 123         final byte[] payload = ResultPayloadUtils.marshall(new ResultPayload(INTENT));
 124         final String BLANK = "";
 125         cursor.addRow(new Object[]{
 126                 KEY.hashCode(),      // Doc ID
 127                 "Longer than 20 characters", // Title
 128                 SUMMARY, // Summary on
 129                 SUMMARY, // summary off
 130                 DisplaySettings.class.getName(),
 131                 BLANK,   // screen title
 132                 ICON,    // icon
 133                 BLANK,   // action
 134                 null,    // target package
 135                 BLANK,   // target class
 136                 KEY,   // Key
 137                 PayloadType.INTENT,       // Payload Type
 138                 payload     // Payload
 139         });
 140
 141         final Set<SearchResult> results = mConverter.convertCursor(
 142                 mSiteMapManager, cursor, BASE_RANK);
 143
 144         for (SearchResult result : results) {
 145             Drawable resultDrawable = result.icon;
 146             assertThat(resultDrawable).isNotNull();
 147             assertThat(resultDrawable.toString()).isEqualTo(mDrawable.toString());
 148         }
 149     }
 150
 151     @Test
 152     public void testParseCursor_NoIcon() {
 153         final Set<SearchResult> results = mConverter.convertCursor(
 154                 mSiteMapManager, getDummyCursor("noIcon" /* key */, "" /* className */), BASE_RANK);
 155         for (SearchResult result : results) {
 156             assertThat(result.icon).isNull();
 157         }
 158     }
 159
 160     @Test
 161     public void testParseCursor_MatchesPayloadType() {
 162         final Set<SearchResult> results = mConverter.convertCursor(
 163                 mSiteMapManager, getDummyCursor(), BASE_RANK);
 164         ResultPayload payload;
 165         for (SearchResult result : results) {
 166             payload = result.payload;
 167             assertThat(payload.getType()).isEqualTo(PayloadType.INTENT);
 168         }
 169     }
 170
 171     @Test
 172     public void testLongTitle_PenalizedInRank() {
 173         final MatrixCursor cursor = new MatrixCursor(DatabaseResultLoader.SELECT_COLUMNS);
 174         final byte[] payload = ResultPayloadUtils.marshall(new ResultPayload(INTENT));
 175         final String BLANK = "";
 176         cursor.addRow(new Object[]{
 177                 KEY.hashCode(),      // Doc ID
 178                 "Longer than 20 characters", // Title
 179                 SUMMARY, // Summary on
 180                 SUMMARY, // summary off
 181                 DisplaySettings.class.getName(),
 182                 BLANK,   // screen title
 183                 null,    // icon
 184                 BLANK,   // action
 185                 null,    // target package
 186                 BLANK,   // target class
 187                 KEY,   // Key
 188                 PayloadType.INTENT,       // Payload Type
 189                 payload     // Payload
 190         });
 191         final Set<SearchResult> results = mConverter.convertCursor(mSiteMapManager, cursor,
 192                 BASE_RANK);
 193         for (SearchResult result : results) {
 194             assertThat(result.rank).isEqualTo(BASE_RANK + 1);
 195         }
 196     }
 197
 198     @Test
 199     public void testParseCursor_MatchesResultPayload() {
 200         final Set<SearchResult> results = mConverter.convertCursor(
 201                 mSiteMapManager, getDummyCursor(), BASE_RANK);
 202         ResultPayload payload;
 203         for (SearchResult result : results) {
 204             payload = result.payload;
 205             Intent intent = payload.getIntent();
 206             assertThat(intent.getAction()).isEqualTo(INTENT.getAction());
 207         }
 208     }
 209
 210
 211     @Test
 212     public void testParseCursor_MatchesInlineSwitchPayload() {
 213         MatrixCursor cursor = new MatrixCursor(DatabaseResultLoader.SELECT_COLUMNS);
 214         final String BLANK = "";
 215         final String uri = "test.com";
 216         final int type = ResultPayload.PayloadType.INLINE_SWITCH;
 217         final int source = ResultPayload.SettingsSource.SECURE;
 218         final String intentKey = "key";
 219         final String intentVal = "value";
 220         final Intent intent = new Intent();
 221         intent.putExtra(intentKey, intentVal);
 222         final InlineSwitchPayload payload = new InlineSwitchPayload(uri, source, 1 /* onValue */,
 223                 intent, true /* isDeviceSupported */);
 224
 225         cursor.addRow(new Object[]{
 226                 KEY.hashCode(),      // Doc ID
 227                 TITLES.get(0), // Title
 228                 SUMMARY, // Summary on
 229                 SUMMARY, // summary off
 230                 SwipeToNotificationSettings.class.getName(),
 231                 BLANK,   // screen title
 232                 null,    // icon
 233                 BLANK,   // action
 234                 null,    // target package
 235                 BLANK,   // target class
 236                 KEY,   // Key
 237                 type,    // Payload Type
 238                 ResultPayloadUtils.marshall(payload) // Payload
 239         });
 240         final Set<SearchResult> results = mConverter.convertCursor(mSiteMapManager, cursor,
 241                 BASE_RANK);
 242
 243         for (SearchResult result : results) {
 244             final InlineSwitchPayload newPayload = (InlineSwitchPayload) result.payload;
 245             final Intent rebuiltIntent = newPayload.getIntent();
 246             assertThat(newPayload.mSettingKey).isEqualTo(uri);
 247             assertThat(newPayload.getType()).isEqualTo(type);
 248             assertThat(newPayload.mSettingSource).isEqualTo(source);
 249             assertThat(newPayload.isStandard()).isTrue();
 250             assertThat(newPayload.getAvailability()).isEqualTo(Availability.AVAILABLE);
 251             assertThat(rebuiltIntent.getStringExtra(intentKey)).isEqualTo(intentVal);
 252         }
 253     }
 254
 255     // The following tests are temporary, and should be removed when we replace the Search
 256     // White-list solution for elevating ranking.
 257
 258     @Test
 259     public void testWifiKey_PrioritizedResult() {
 260         final String key = "main_toggle_wifi";
 261         final Cursor cursor = getDummyCursor(key,  WifiSettings.class.getName());
 262         final Set<SearchResult> results = mConverter.convertCursor(mSiteMapManager, cursor,
 263                 BASE_RANK);
 264
 265         for (SearchResult result : results) {
 266             assertThat(result.rank).isEqualTo(SearchResult.TOP_RANK);
 267         }
 268     }
 269
 270     @Test
 271     public void testBluetoothKey_PrioritizedResult() {
 272         final String key = "main_toggle_bluetooth";
 273         final Cursor cursor = getDummyCursor(key,  WifiSettings.class.getName());
 274         final Set<SearchResult> results = mConverter.convertCursor(mSiteMapManager, cursor,
 275                 BASE_RANK);
 276
 277         for (SearchResult result : results) {
 278             assertThat(result.rank).isEqualTo(SearchResult.TOP_RANK);
 279         }
 280     }
 281
 282     @Test
 283     public void testAirplaneKey_PrioritizedResult() {
 284         final String key = "toggle_airplane";
 285         final Cursor cursor = getDummyCursor(key,  WifiSettings.class.getName());
 286         Set<SearchResult> results = mConverter.convertCursor(mSiteMapManager, cursor, BASE_RANK);
 287         for (SearchResult result : results) {
 288             assertThat(result.rank).isEqualTo(SearchResult.TOP_RANK);
 289         }
 290     }
 291
 292     @Test
 293     public void testHotspotKey_PrioritizedResult() {
 294         final String key = "tether_settings";
 295         final Cursor cursor = getDummyCursor(key,  WifiSettings.class.getName());
 296         final Set<SearchResult> results = mConverter.convertCursor(mSiteMapManager, cursor,
 297                 BASE_RANK);
 298
 299         for (SearchResult result : results) {
 300             assertThat(result.rank).isEqualTo(SearchResult.TOP_RANK);
 301         }
 302     }
 303
 304     @Test
 305     public void testBatterySaverKey_PrioritizedResult() {
 306         final String key = "battery_saver";
 307         final Cursor cursor = getDummyCursor(key,  WifiSettings.class.getName());
 308         final Set<SearchResult> results = mConverter.convertCursor(mSiteMapManager, cursor,
 309                 BASE_RANK);
 310
 311         for (SearchResult result : results) {
 312             assertThat(result.rank).isEqualTo(SearchResult.TOP_RANK);
 313         }
 314     }
 315
 316     @Test
 317     public void testNFCKey_PrioritizedResult() {
 318         final String key = "toggle_nfc";
 319         final Cursor cursor = getDummyCursor(key,  WifiSettings.class.getName());
 320         final Set<SearchResult> results = mConverter.convertCursor(mSiteMapManager, cursor,
 321                 BASE_RANK);
 322
 323         for (SearchResult result : results) {
 324             assertThat(result.rank).isEqualTo(SearchResult.TOP_RANK);
 325         }
 326     }
 327
 328     @Test
 329     public void testDataSaverKey_PrioritizedResult() {
 330         final String key = "restrict_background";
 331         final Cursor cursor = getDummyCursor(key,  WifiSettings.class.getName());
 332         final Set<SearchResult> results = mConverter.convertCursor(mSiteMapManager, cursor,
 333                 BASE_RANK);
 334
 335         for (SearchResult result : results) {
 336             assertThat(result.rank).isEqualTo(SearchResult.TOP_RANK);
 337         }
 338     }
 339
 340     @Test
 341     public void testDataUsageKey_PrioritizedResult() {
 342         final String key = "data_usage_enable";
 343         final Cursor cursor = getDummyCursor(key,  WifiSettings.class.getName());
 344         final Set<SearchResult> results = mConverter.convertCursor(mSiteMapManager, cursor,
 345                 BASE_RANK);
 346         for (SearchResult result : results) {
 347             assertThat(result.rank).isEqualTo(SearchResult.TOP_RANK);
 348         }
 349     }
 350
 351     @Test
 352     public void testRoamingKey_PrioritizedResult() {
 353         final String key = "button_roaming_key";
 354         final Cursor cursor = getDummyCursor(key,  WifiSettings.class.getName());
 355         final Set<SearchResult> results = mConverter.convertCursor(mSiteMapManager, cursor,
 356                 BASE_RANK);
 357
 358         for (SearchResult result : results) {
 359             assertThat(result.rank).isEqualTo(SearchResult.TOP_RANK);
 360         }
 361     }
 362
 363     // End of temporary tests
 364
 365     private MatrixCursor getDummyCursor() {
 366         String[] keys = new String[] {KEY + "1", KEY + "2", KEY + "3"};
 367         return getDummyCursor(keys, "" /* className */);
 368     }
 369
 370     private MatrixCursor getDummyCursor(String key, String className) {
 371         String[] keys = new String[] {key};
 372         return getDummyCursor(keys, className);
 373     }
 374
 375     private MatrixCursor getDummyCursor(String[] keys, String className) {
 376         MatrixCursor cursor = new MatrixCursor(DatabaseResultLoader.SELECT_COLUMNS);
 377         final String BLANK = "";
 378         final byte[] payload = ResultPayloadUtils.marshall(new ResultPayload(INTENT));
 379
 380         for (int i = 0; i < keys.length; i++) {
 381             ArrayList<Object> item = new ArrayList<>(DatabaseResultLoader.SELECT_COLUMNS.length);
 382             item.add(keys[i].hashCode()); // Doc ID
 383             item.add(TITLES.get(i)); // Title
 384             item.add(SUMMARY); // Summary on
 385             item.add(BLANK); // summary off
 386             item.add(className); // classname
 387             item.add(BLANK); // screen title
 388             item.add(null); // Icon
 389             item.add(INTENT.getAction()); // Intent action
 390             item.add(TARGET_PACKAGE); // target package
 391             item.add(TARGET_CLASS); // target class
 392             item.add(keys[i]); // Key
 393             item.add(Integer.toString(0));     // Payload Type
 394             item.add(payload); // Payload
 395
 396             cursor.addRow(item);
 397         }
 398         return cursor;
 399     }
 400 }