tests/robotests/src/com/android/settings/enterprise/ExposureChangesCategoryPreferenceControllerTest.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 package com.android.settings.enterprise;
  18
  19 import android.content.Context;
  20 import android.support.v7.preference.Preference;
  21
  22 import com.android.settings.SettingsRobolectricTestRunner;
  23 import com.android.settings.TestConfig;
  24 import com.android.settings.core.DynamicAvailabilityPreferenceController;
  25 import com.android.settings.core.PreferenceAvailabilityObserver;
  26
  27 import org.junit.Before;
  28 import org.junit.Test;
  29 import org.junit.runner.RunWith;
  30 import org.mockito.Answers;
  31 import org.mockito.Mock;
  32 import org.mockito.MockitoAnnotations;
  33 import org.robolectric.annotation.Config;
  34
  35 import java.util.Arrays;
  36 import java.util.List;
  37
  38 import static com.google.common.truth.Truth.assertThat;
  39 import static org.mockito.Mockito.anyBoolean;
  40 import static org.mockito.Mockito.eq;
  41 import static org.mockito.Mockito.mock;
  42 import static org.mockito.Mockito.never;
  43 import static org.mockito.Mockito.reset;
  44 import static org.mockito.Mockito.verify;
  45
  46 /**
  47  * Tests for {@link ExposureChangesCategoryPreferenceController}.
  48  */
  49 @RunWith(SettingsRobolectricTestRunner.class)
  50 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
  51 public final class ExposureChangesCategoryPreferenceControllerTest {
  52
  53     private static final String KEY_1 = "key_1";
  54     private static final String KEY_2 = "key_2";
  55     private static final String KEY_EXPOSURE_CHANGES_CATEGORY = "exposure_changes_category";
  56
  57     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
  58     private Context mContext;
  59     private List<DynamicAvailabilityPreferenceController> mControllers;
  60     private ExposureChangesCategoryPreferenceController mController;
  61     @Mock private PreferenceAvailabilityObserver mObserver;
  62
  63     @Before
  64     public void setUp() {
  65         MockitoAnnotations.initMocks(this);
  66         mControllers = Arrays.asList(mock(DynamicAvailabilityPreferenceController.class),
  67                 mock(DynamicAvailabilityPreferenceController.class));
  68         mController = new ExposureChangesCategoryPreferenceController(mContext,
  69                 null /* lifecycle */, mControllers, true /* controllingUi */);
  70         mController.setAvailabilityObserver(mObserver);
  71     }
  72
  73     @Test
  74     public void testInitialization() {
  75         verify(mControllers.get(0)).setAvailabilityObserver(mController);
  76         verify(mControllers.get(1)).setAvailabilityObserver(mController);
  77     }
  78
  79     @Test
  80     public void testGetAvailabilityObserver() {
  81         assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
  82     }
  83
  84     @Test
  85     public void testOnPreferenceAvailabilityUpdated() {
  86         final Preference preference = new Preference(mContext, null, 0, 0);
  87         preference.setVisible(true);
  88
  89         mController.updateState(preference);
  90         assertThat(preference.isVisible()).isFalse();
  91
  92         mController.onPreferenceAvailabilityUpdated(KEY_1, true);
  93         verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, true);
  94         assertThat(preference.isVisible()).isTrue();
  95         reset(mObserver);
  96
  97         mController.onPreferenceAvailabilityUpdated(KEY_2, true);
  98         verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, true);
  99         assertThat(preference.isVisible()).isTrue();
 100         reset(mObserver);
 101
 102         mController.onPreferenceAvailabilityUpdated(KEY_1, false);
 103         verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, true);
 104         assertThat(preference.isVisible()).isTrue();
 105         reset(mObserver);
 106
 107         mController.onPreferenceAvailabilityUpdated(KEY_2, false);
 108         verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, false);
 109         assertThat(preference.isVisible()).isFalse();
 110     }
 111
 112     @Test
 113     public void testUpdateState() {
 114         final Preference preference = new Preference(mContext, null, 0, 0);
 115         preference.setVisible(false);
 116
 117         mController.onPreferenceAvailabilityUpdated(KEY_1, true);
 118         mController.updateState(preference);
 119         assertThat(preference.isVisible()).isTrue();
 120     }
 121
 122     @Test
 123     public void testIsAvailableForUi() {
 124         assertThat(mController.isAvailable()).isTrue();
 125         verify(mObserver, never()).onPreferenceAvailabilityUpdated(
 126                 eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
 127
 128         mController.onPreferenceAvailabilityUpdated(KEY_1, true);
 129         reset(mObserver);
 130         assertThat(mController.isAvailable()).isTrue();
 131         verify(mObserver, never()).onPreferenceAvailabilityUpdated(
 132                 eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
 133
 134         mController.onPreferenceAvailabilityUpdated(KEY_1, false);
 135         reset(mObserver);
 136         assertThat(mController.isAvailable()).isTrue();
 137         verify(mObserver, never()).onPreferenceAvailabilityUpdated(
 138                 eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
 139     }
 140
 141     @Test
 142     public void testIsAvailableForSearch() {
 143         final ExposureChangesCategoryPreferenceController controller
 144                 = new ExposureChangesCategoryPreferenceController(mContext, null /* lifecycle */,
 145                         mControllers, false /* controllingUi */);
 146         controller.setAvailabilityObserver(mObserver);
 147         verify(mControllers.get(0)).setAvailabilityObserver(controller);
 148         verify(mControllers.get(1)).setAvailabilityObserver(controller);
 149
 150         assertThat(controller.isAvailable()).isFalse();
 151         verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, false);
 152         reset(mObserver);
 153
 154         controller.onPreferenceAvailabilityUpdated(KEY_1, true);
 155         verify(mObserver, never()).onPreferenceAvailabilityUpdated(
 156                 eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
 157         assertThat(controller.isAvailable()).isTrue();
 158         verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, true);
 159         reset(mObserver);
 160
 161         controller.onPreferenceAvailabilityUpdated(KEY_2, true);
 162         verify(mObserver, never()).onPreferenceAvailabilityUpdated(
 163                 eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
 164         assertThat(controller.isAvailable()).isTrue();
 165         verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, true);
 166         reset(mObserver);
 167
 168         controller.onPreferenceAvailabilityUpdated(KEY_1, false);
 169         verify(mObserver, never()).onPreferenceAvailabilityUpdated(
 170                 eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
 171         assertThat(controller.isAvailable()).isTrue();
 172         verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, true);
 173         reset(mObserver);
 174
 175         controller.onPreferenceAvailabilityUpdated(KEY_2, false);
 176         verify(mObserver, never()).onPreferenceAvailabilityUpdated(
 177                 eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
 178         assertThat(controller.isAvailable()).isFalse();
 179         verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, false);
 180     }
 181
 182     @Test
 183     public void testHandlePreferenceTreeClick() {
 184         assertThat(mController.handlePreferenceTreeClick(new Preference(mContext, null, 0, 0)))
 185                 .isFalse();
 186     }
 187
 188     @Test
 189     public void testGetPreferenceKey() {
 190         assertThat(mController.getPreferenceKey()).isEqualTo(KEY_EXPOSURE_CHANGES_CATEGORY);
 191     }
 192 }