tests/robotests/src/com/android/settings/dashboard/suggestions/SuggestionAdapterTest.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 package com.android.settings.dashboard.suggestions;
  17
  18 import static com.google.common.truth.Truth.assertThat;
  19 import static org.mockito.Mockito.mock;
  20 import static org.mockito.Mockito.spy;
  21 import static org.mockito.Mockito.verify;
  22
  23 import android.app.PendingIntent;
  24 import android.content.Context;
  25 import android.graphics.drawable.Icon;
  26 import android.service.settings.suggestions.Suggestion;
  27 import android.view.LayoutInflater;
  28 import android.view.View;
  29 import android.widget.FrameLayout;
  30 import android.widget.LinearLayout;
  31
  32 import com.android.internal.logging.nano.MetricsProto;
  33 import com.android.settings.R;
  34 import com.android.settings.SettingsActivity;
  35 import com.android.settings.TestConfig;
  36 import com.android.settings.dashboard.DashboardAdapter;
  37 import com.android.settings.testutils.FakeFeatureFactory;
  38 import com.android.settings.testutils.SettingsRobolectricTestRunner;
  39 import com.android.settingslib.suggestions.SuggestionControllerMixin;
  40
  41 import org.junit.Before;
  42 import org.junit.Test;
  43 import org.junit.runner.RunWith;
  44 import org.mockito.Answers;
  45 import org.mockito.Mock;
  46 import org.mockito.MockitoAnnotations;
  47 import org.robolectric.RuntimeEnvironment;
  48 import org.robolectric.annotation.Config;
  49
  50 import java.util.ArrayList;
  51 import java.util.List;
  52
  53 @RunWith(SettingsRobolectricTestRunner.class)
  54 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
  55 public class SuggestionAdapterTest {
  56
  57     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
  58     private SettingsActivity mActivity;
  59     @Mock
  60     private SuggestionControllerMixin mSuggestionControllerMixin;
  61     private FakeFeatureFactory mFeatureFactory;
  62     private Context mContext;
  63     private SuggestionAdapter mSuggestionAdapter;
  64     private DashboardAdapter.DashboardItemHolder mSuggestionHolder;
  65     private List<Suggestion> mOneSuggestion;
  66     private List<Suggestion> mTwoSuggestions;
  67
  68     @Before
  69     public void setUp() {
  70         MockitoAnnotations.initMocks(this);
  71         mContext = RuntimeEnvironment.application;
  72         mFeatureFactory = FakeFeatureFactory.setupForTest();
  73
  74         final Suggestion suggestion1 = new Suggestion.Builder("id1")
  75                 .setTitle("Test suggestion 1")
  76                 .build();
  77         final Suggestion suggestion2 = new Suggestion.Builder("id2")
  78                 .setTitle("Test suggestion 2")
  79                 .build();
  80         mOneSuggestion = new ArrayList<>();
  81         mOneSuggestion.add(suggestion1);
  82         mTwoSuggestions = new ArrayList<>();
  83         mTwoSuggestions.add(suggestion1);
  84         mTwoSuggestions.add(suggestion2);
  85     }
  86
  87     @Test
  88     public void getItemCount_shouldReturnListSize() {
  89         mSuggestionAdapter = new SuggestionAdapter(mContext, mSuggestionControllerMixin,
  90                 mOneSuggestion, new ArrayList<>());
  91         assertThat(mSuggestionAdapter.getItemCount()).isEqualTo(1);
  92
  93         mSuggestionAdapter = new SuggestionAdapter(mContext, mSuggestionControllerMixin,
  94                 mTwoSuggestions, new ArrayList<>());
  95         assertThat(mSuggestionAdapter.getItemCount()).isEqualTo(2);
  96     }
  97
  98     @Test
  99     public void getItemViewType_shouldReturnSuggestionTile() {
 100         mSuggestionAdapter = new SuggestionAdapter(mContext, mSuggestionControllerMixin,
 101                 mOneSuggestion, new ArrayList<>());
 102         assertThat(mSuggestionAdapter.getItemViewType(0))
 103                 .isEqualTo(R.layout.suggestion_tile);
 104     }
 105
 106     @Test
 107     public void getItemType_hasButton_shouldReturnSuggestionWithButton() {
 108         final List<Suggestion> suggestions = new ArrayList<>();
 109         suggestions.add(new Suggestion.Builder("id")
 110                 .setFlags(Suggestion.FLAG_HAS_BUTTON)
 111                 .setTitle("123")
 112                 .setSummary("456")
 113                 .build());
 114         mSuggestionAdapter = new SuggestionAdapter(mContext, mSuggestionControllerMixin,
 115                 suggestions, new ArrayList<>());
 116
 117         assertThat(mSuggestionAdapter.getItemViewType(0))
 118                 .isEqualTo(R.layout.suggestion_tile_with_button);
 119     }
 120
 121     @Test
 122     public void onBindViewHolder_shouldLog() {
 123         final View view = spy(LayoutInflater.from(mContext).inflate(
 124                 R.layout.suggestion_tile, new LinearLayout(mContext), true));
 125         mSuggestionHolder = new DashboardAdapter.DashboardItemHolder(view);
 126         mSuggestionAdapter = new SuggestionAdapter(mContext, mSuggestionControllerMixin,
 127                 mOneSuggestion, new ArrayList<>());
 128
 129         // Bind twice
 130         mSuggestionAdapter.onBindViewHolder(mSuggestionHolder, 0);
 131         mSuggestionAdapter.onBindViewHolder(mSuggestionHolder, 0);
 132
 133         // Log once
 134         verify(mFeatureFactory.metricsFeatureProvider).action(
 135                 mContext, MetricsProto.MetricsEvent.ACTION_SHOW_SETTINGS_SUGGESTION,
 136                 mOneSuggestion.get(0).getId());
 137     }
 138
 139     @Test
 140     public void onBindViewHolder_itemViewShouldHandleClick()
 141             throws PendingIntent.CanceledException {
 142         final List<Suggestion> suggestions = makeSuggestions("pkg1");
 143         setupSuggestions(mActivity, suggestions);
 144
 145         mSuggestionAdapter.onBindViewHolder(mSuggestionHolder, 0);
 146         mSuggestionHolder.itemView.performClick();
 147
 148         verify(mSuggestionControllerMixin).launchSuggestion(suggestions.get(0));
 149         verify(suggestions.get(0).getPendingIntent()).send();
 150     }
 151
 152     @Test
 153     public void getSuggestions_shouldReturnSuggestionWhenMatch() {
 154         final List<Suggestion> suggestions = makeSuggestions("pkg1");
 155         setupSuggestions(mActivity, suggestions);
 156
 157         assertThat(mSuggestionAdapter.getSuggestion(0)).isNotNull();
 158     }
 159
 160     private void setupSuggestions(Context context, List<Suggestion> suggestions) {
 161         mSuggestionAdapter = new SuggestionAdapter(context, mSuggestionControllerMixin,
 162                 suggestions, new ArrayList<>());
 163         mSuggestionHolder = mSuggestionAdapter.onCreateViewHolder(
 164                 new FrameLayout(RuntimeEnvironment.application),
 165                 mSuggestionAdapter.getItemViewType(0));
 166     }
 167
 168     private List<Suggestion> makeSuggestions(String... pkgNames) {
 169         final List<Suggestion> suggestions = new ArrayList<>();
 170         for (String pkgName : pkgNames) {
 171             final Suggestion suggestion = new Suggestion.Builder(pkgName)
 172                     .setPendingIntent(mock(PendingIntent.class))
 173                     .build();
 174             suggestions.add(suggestion);
 175         }
 176         return suggestions;
 177     }
 178 }