Merge "[Testing] AndroidJunit Enhanced4gLteSliceHelperTest"

/*

 * Copyright (C) 2020 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 com.android.settings.network.ims;

import android.content.Context;

import android.telephony.ims.ImsException;

/**

 * Controller class for mock VoLte status

 */

public class MockVolteQueryImsState extends VolteQueryImsState {

    private Boolean mIsTtyOnVolteEnabled;

    private Boolean mIsSupported;

    private Boolean mIsProvisionedOnDevice;

    private Boolean mIsServiceStateReady;

    private Boolean mIsEnabledByUser;

    /**

     * Constructor

     *

     * @param context {@link Context}

     * @param subId subscription's id

     */

    public MockVolteQueryImsState(Context context, int subId) {

        super(context, subId);

    }

    public void setIsTtyOnVolteEnabled(boolean enabled) {

        mIsTtyOnVolteEnabled = enabled;

    }

    @Override

    boolean isTtyOnVolteEnabled(int subId) {

        if (mIsTtyOnVolteEnabled != null) {

            return mIsTtyOnVolteEnabled;

        }

        return super.isTtyOnVolteEnabled(subId);

    }

    public void setEnabledByPlatform(boolean isSupported) {

        mIsSupported = isSupported;

    }

    @Override

    boolean isEnabledByPlatform(int subId) throws InterruptedException, ImsException,

            IllegalArgumentException {

        if (mIsSupported != null) {

            return mIsSupported;

        }

        return super.isEnabledByPlatform(subId);

    }

    public void setIsProvisionedOnDevice(boolean isProvisioned) {

        mIsProvisionedOnDevice = isProvisioned;

    }

    @Override

    boolean isProvisionedOnDevice(int subId) {

        if (mIsProvisionedOnDevice != null) {

            return mIsProvisionedOnDevice;

        }

        return super.isProvisionedOnDevice(subId);

    }

    public void setServiceStateReady(boolean isReady) {

        mIsServiceStateReady = isReady;

    }

    @Override

    boolean isServiceStateReady(int subId) throws InterruptedException, ImsException,

            IllegalArgumentException {

        if (mIsServiceStateReady != null) {

            return mIsServiceStateReady;

        }

        return super.isServiceStateReady(subId);

    }

    public void setIsEnabledByUser(boolean enabled) {

        mIsEnabledByUser = enabled;

    }

    @Override

    boolean isEnabledByUser(int subId) {

        if (mIsEnabledByUser != null) {

            return mIsEnabledByUser;

        }

        return super.isEnabledByUser(subId);

    }

}

/*

 * Copyright (C) 2020 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 com.android.settings.network.telephony;

import static android.app.slice.Slice.EXTRA_TOGGLE_STATE;

import static android.app.slice.Slice.HINT_TITLE;

import static android.app.slice.SliceItem.FORMAT_TEXT;

import static com.android.settings.Utils.SETTINGS_PACKAGE_NAME;

import static com.google.common.truth.Truth.assertThat;

import static org.mockito.ArgumentMatchers.anyInt;

import static org.mockito.Mockito.spy;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;

import android.app.PendingIntent;

import android.content.Context;

import android.content.Intent;

import android.content.res.Resources;

import android.telephony.CarrierConfigManager;

import android.telephony.ims.ProvisioningManager;

import androidx.slice.Slice;

import androidx.slice.SliceItem;

import androidx.slice.SliceMetadata;

import androidx.slice.SliceProvider;

import androidx.slice.core.SliceAction;

import androidx.slice.core.SliceQuery;

import androidx.slice.widget.SliceLiveData;

import androidx.test.core.app.ApplicationProvider;

import androidx.test.ext.junit.runners.AndroidJUnit4;

import com.android.settings.network.ims.MockVolteQueryImsState;

import com.android.settings.network.ims.VolteQueryImsState;

import com.android.settings.slices.CustomSliceRegistry;

import com.android.settings.slices.SettingsSliceProvider;

import com.android.settings.slices.SliceBroadcastReceiver;

import com.android.settings.slices.SlicesFeatureProvider;

import com.android.settings.testutils.FakeFeatureFactory;

import org.junit.Before;

import org.junit.Ignore;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.ArgumentCaptor;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;

import java.util.List;

@RunWith(AndroidJUnit4.class)

public class Enhanced4gLteSliceHelperTest {

    private static final int SUB_ID = 1;

    @Mock

    private CarrierConfigManager mMockCarrierConfigManager;

    @Mock

    private ProvisioningManager mProvisioningManager;

    private MockVolteQueryImsState mQueryImsState;

    private Context mContext;

    private FakeEnhanced4gLteSliceHelper mEnhanced4gLteSliceHelper;

    private SettingsSliceProvider mProvider;

    private SliceBroadcastReceiver mReceiver;

    private FakeFeatureFactory mFeatureFactory;

    private SlicesFeatureProvider mSlicesFeatureProvider;

    @Before

    public void setUp() {

        MockitoAnnotations.initMocks(this);

        mContext = spy(ApplicationProvider.getApplicationContext());

        mFeatureFactory = FakeFeatureFactory.setupForTest();

        mSlicesFeatureProvider = mFeatureFactory.getSlicesFeatureProvider();

        //setup for SettingsSliceProvider tests

        mProvider = new SettingsSliceProvider();

        mProvider.attachInfo(mContext, null);

        mProvider.onCreateSliceProvider();

        //setup for SliceBroadcastReceiver test

        mReceiver = spy(new SliceBroadcastReceiver());

        mQueryImsState = spy(new MockVolteQueryImsState(mContext, SUB_ID));

        mQueryImsState.setEnabledByPlatform(true);

        mQueryImsState.setIsProvisionedOnDevice(true);

        mQueryImsState.setIsTtyOnVolteEnabled(true);

        mQueryImsState.setServiceStateReady(true);

        mQueryImsState.setIsEnabledByUser(true);

        mEnhanced4gLteSliceHelper = spy(new FakeEnhanced4gLteSliceHelper(mContext));

        // Set-up specs for SliceMetadata.

        SliceProvider.setSpecs(SliceLiveData.SUPPORTED_SPECS);

    }

    @Test

    public void createEnhanced4gLteSlice_invalidSubId_nullSlice() {

        mQueryImsState.setEnabledByPlatform(false);

        mQueryImsState.setIsProvisionedOnDevice(false);

        mQueryImsState.setIsEnabledByUser(false);

        final Slice slice = mEnhanced4gLteSliceHelper.createEnhanced4gLteSlice(

                CustomSliceRegistry.ENHANCED_4G_SLICE_URI);

        assertThat(slice).isNull();

    }

    @Test

    public void createEnhanced4gLteSlice_enhanced4gLteNotSupported_nullSlice() {

        mQueryImsState.setEnabledByPlatform(false);

        final Slice slice = mEnhanced4gLteSliceHelper.createEnhanced4gLteSlice(

                CustomSliceRegistry.ENHANCED_4G_SLICE_URI);

        assertThat(mEnhanced4gLteSliceHelper.getDefaultVoiceSubId()).isEqualTo(1);

        assertThat(slice).isNull();

    }

    @Test

    public void createEnhanced4gLteSlice_success() {

        mQueryImsState.setEnabledByPlatform(true);

        mQueryImsState.setIsProvisionedOnDevice(true);

        when(mMockCarrierConfigManager.getConfigForSubId(1)).thenReturn(null);

        final Slice slice = mEnhanced4gLteSliceHelper.createEnhanced4gLteSlice(

                CustomSliceRegistry.ENHANCED_4G_SLICE_URI);

        assertThat(mEnhanced4gLteSliceHelper.getDefaultVoiceSubId()).isEqualTo(1);

        testEnhanced4gLteSettingsToggleSlice(slice);

    }

    @Test

    public void sttingSliceProvider_enhanced4gLteHelper_getsRightSlice() {

        mQueryImsState.setEnabledByPlatform(true);

        mQueryImsState.setIsProvisionedOnDevice(true);

        when(mMockCarrierConfigManager.getConfigForSubId(1)).thenReturn(null);

        when(mSlicesFeatureProvider.getNewEnhanced4gLteSliceHelper(mContext))

            .thenReturn(mEnhanced4gLteSliceHelper);

        final Slice slice = mProvider.onBindSlice(CustomSliceRegistry.ENHANCED_4G_SLICE_URI);

        assertThat(mEnhanced4gLteSliceHelper.getDefaultVoiceSubId()).isEqualTo(1);

        testEnhanced4gLteSettingsToggleSlice(slice);

    }

    @Test

    @Ignore

    public void sliceBroadcastReceiver_toggleOffEnhanced4gLte() {

        mQueryImsState.setEnabledByPlatform(true);

        mQueryImsState.setIsProvisionedOnDevice(true);

        mQueryImsState.setIsEnabledByUser(false);

        when(mSlicesFeatureProvider.getNewEnhanced4gLteSliceHelper(mContext))

            .thenReturn(mEnhanced4gLteSliceHelper);

        final ArgumentCaptor<Boolean> mEnhanced4gLteSettingCaptor = ArgumentCaptor.forClass(

                Boolean.class);

        // turn on Enhanced4gLte setting

        final Intent intent = new Intent(Enhanced4gLteSliceHelper.ACTION_ENHANCED_4G_LTE_CHANGED);

        intent.putExtra(EXTRA_TOGGLE_STATE, true);

        // change the setting

        mReceiver.onReceive(mContext, intent);

        verify(mEnhanced4gLteSliceHelper).setEnhanced4gLteModeSetting(anyInt(),

                mEnhanced4gLteSettingCaptor.capture());

        // assert the change

        assertThat(mEnhanced4gLteSettingCaptor.getValue()).isTrue();

    }

    private void testEnhanced4gLteSettingsUnavailableSlice(Slice slice,

            PendingIntent expectedPrimaryAction) {

        final SliceMetadata metadata = SliceMetadata.from(mContext, slice);

        //Check there is no toggle action

        final List<SliceAction> toggles = metadata.getToggles();

        assertThat(toggles).isEmpty();

        // Check whether the primary action is to open Enhanced4gLte settings activity

        final PendingIntent primaryPendingIntent =

                metadata.getPrimaryAction().getAction();

        assertThat(primaryPendingIntent).isEqualTo(expectedPrimaryAction);

        // Check the title

        final List<SliceItem> sliceItems = slice.getItems();

        assertTitle(sliceItems, resourceString("enhanced_4g_lte_mode_title"));

    }

    private void testEnhanced4gLteSettingsToggleSlice(Slice slice) {

        final SliceMetadata metadata = SliceMetadata.from(mContext, slice);

        final List<SliceAction> toggles = metadata.getToggles();

        assertThat(toggles).hasSize(1);

        final SliceAction mainToggleAction = toggles.get(0);

        // Check intent in Toggle Action

        final PendingIntent togglePendingIntent = mainToggleAction.getAction();

        final PendingIntent expectedToggleIntent = getBroadcastIntent(

                Enhanced4gLteSliceHelper.ACTION_ENHANCED_4G_LTE_CHANGED);

        assertThat(togglePendingIntent).isEqualTo(expectedToggleIntent);

        // Check primary intent

        final PendingIntent primaryPendingIntent = metadata.getPrimaryAction().getAction();

        final PendingIntent expectedPendingIntent =

                getActivityIntent(Enhanced4gLteSliceHelper.ACTION_MOBILE_NETWORK_SETTINGS_ACTIVITY);

        assertThat(primaryPendingIntent).isEqualTo(expectedPendingIntent);

        // Check the title

        final List<SliceItem> sliceItems = slice.getItems();

        assertTitle(sliceItems, resourceString("enhanced_4g_lte_mode_title"));

    }

    private PendingIntent getBroadcastIntent(String action) {

        final Intent intent = new Intent(action);

        intent.setClass(mContext, SliceBroadcastReceiver.class);

        return PendingIntent.getBroadcast(mContext, 0 /* requestCode */, intent,

                PendingIntent.FLAG_NO_CREATE);

    }

    private PendingIntent getActivityIntent(String action) {

        final Intent intent = new Intent(action);

        intent.setPackage(SETTINGS_PACKAGE_NAME);

        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

        return PendingIntent.getActivity(mContext, 0 /* requestCode */, intent, 0 /* flags */);

    }

    private void assertTitle(List<SliceItem> sliceItems, String title) {

        boolean hasTitle = false;

        for (SliceItem item : sliceItems) {

            final List<SliceItem> titleItems = SliceQuery.findAll(item, FORMAT_TEXT, HINT_TITLE,

                    null /* non-hints */);

            if (titleItems == null) {

                continue;

            }

            hasTitle = true;

            for (SliceItem subTitleItem : titleItems) {

                assertThat(subTitleItem.getText()).isEqualTo(title);

            }

        }

        assertThat(hasTitle).isTrue();

    }

    public class FakeEnhanced4gLteSliceHelper extends Enhanced4gLteSliceHelper {

        int mSubId = SUB_ID;

        FakeEnhanced4gLteSliceHelper(Context context) {

            super(context);

        }

        @Override

        protected CarrierConfigManager getCarrierConfigManager() {

            return mMockCarrierConfigManager;

        }

        protected int getDefaultVoiceSubId() {

            return mSubId;

        }

        private void setDefaultVoiceSubId(int id) {

            mSubId = id;

        }

        @Override

        protected VolteQueryImsState queryImsState(int subId) {

            return mQueryImsState;

        }

    }

    public String resourceString(String name) {

        final Resources res = mContext.getResources();

        return res.getString(res.getIdentifier(name, "string", mContext.getPackageName()));

    }

}

/*

 * Copyright (C) 2020 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 com.android.settings.testutils;

import static org.mockito.Mockito.mock;

import android.content.Context;

import com.android.settings.accounts.AccountFeatureProvider;

import com.android.settings.applications.ApplicationFeatureProvider;

import com.android.settings.aware.AwareFeatureProvider;

import com.android.settings.biometrics.face.FaceFeatureProvider;

import com.android.settings.bluetooth.BluetoothFeatureProvider;

import com.android.settings.dashboard.DashboardFeatureProvider;

import com.android.settings.dashboard.suggestions.SuggestionFeatureProvider;

import com.android.settings.enterprise.EnterprisePrivacyFeatureProvider;

import com.android.settings.fuelgauge.BatteryStatusFeatureProvider;

import com.android.settings.fuelgauge.PowerUsageFeatureProvider;

import com.android.settings.gestures.AssistGestureFeatureProvider;

import com.android.settings.homepage.contextualcards.ContextualCardFeatureProvider;

import com.android.settings.localepicker.LocaleFeatureProvider;

import com.android.settings.overlay.DockUpdaterFeatureProvider;

import com.android.settings.overlay.FeatureFactory;

import com.android.settings.overlay.SupportFeatureProvider;

import com.android.settings.overlay.SurveyFeatureProvider;

import com.android.settings.panel.PanelFeatureProvider;

import com.android.settings.search.SearchFeatureProvider;

import com.android.settings.security.SecurityFeatureProvider;

import com.android.settings.slices.SlicesFeatureProvider;

import com.android.settings.users.UserFeatureProvider;

import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;

/**

 * Test util to provide fake FeatureFactory. To use this factory, call {@code setupForTest} in

 * {@code @Before} method of the test class.

 */

public class FakeFeatureFactory extends FeatureFactory {

    public final SupportFeatureProvider supportFeatureProvider;

    public final MetricsFeatureProvider metricsFeatureProvider;

    public final BatteryStatusFeatureProvider batteryStatusFeatureProvider;

    public final PowerUsageFeatureProvider powerUsageFeatureProvider;

    public final DashboardFeatureProvider dashboardFeatureProvider;

    public final DockUpdaterFeatureProvider dockUpdaterFeatureProvider;

    public final LocaleFeatureProvider localeFeatureProvider;

    public final ApplicationFeatureProvider applicationFeatureProvider;

    public final EnterprisePrivacyFeatureProvider enterprisePrivacyFeatureProvider;

    public final SurveyFeatureProvider surveyFeatureProvider;

    public final SecurityFeatureProvider securityFeatureProvider;

    public final SuggestionFeatureProvider suggestionsFeatureProvider;

    public final UserFeatureProvider userFeatureProvider;

    public final AssistGestureFeatureProvider assistGestureFeatureProvider;

    public final AccountFeatureProvider mAccountFeatureProvider;

    public final BluetoothFeatureProvider mBluetoothFeatureProvider;

    public final AwareFeatureProvider mAwareFeatureProvider;

    public final FaceFeatureProvider mFaceFeatureProvider;

    public PanelFeatureProvider panelFeatureProvider;

    public SlicesFeatureProvider slicesFeatureProvider;

    public SearchFeatureProvider searchFeatureProvider;

    public ContextualCardFeatureProvider mContextualCardFeatureProvider;

    /**

     * Call this in {@code @Before} method of the test class to use fake factory.

     */

    public static FakeFeatureFactory setupForTest() {

        sFactory = new FakeFeatureFactory();

        return (FakeFeatureFactory) sFactory;

    }

  /**

   * FeatureFactory constructor.

   */

    public FakeFeatureFactory() {

        supportFeatureProvider = mock(SupportFeatureProvider.class);

        metricsFeatureProvider = mock(MetricsFeatureProvider.class);

        batteryStatusFeatureProvider = mock(BatteryStatusFeatureProvider.class);

        powerUsageFeatureProvider = mock(PowerUsageFeatureProvider.class);

        dashboardFeatureProvider = mock(DashboardFeatureProvider.class);

        dockUpdaterFeatureProvider = mock(DockUpdaterFeatureProvider.class);

        localeFeatureProvider = mock(LocaleFeatureProvider.class);

        applicationFeatureProvider = mock(ApplicationFeatureProvider.class);

        enterprisePrivacyFeatureProvider = mock(EnterprisePrivacyFeatureProvider.class);

        searchFeatureProvider = mock(SearchFeatureProvider.class);

        surveyFeatureProvider = mock(SurveyFeatureProvider.class);

        securityFeatureProvider = mock(SecurityFeatureProvider.class);

        suggestionsFeatureProvider = mock(SuggestionFeatureProvider.class);

        userFeatureProvider = mock(UserFeatureProvider.class);

        assistGestureFeatureProvider = mock(AssistGestureFeatureProvider.class);

        slicesFeatureProvider = mock(SlicesFeatureProvider.class);

        mAccountFeatureProvider = mock(AccountFeatureProvider.class);

        mContextualCardFeatureProvider = mock(ContextualCardFeatureProvider.class);

        panelFeatureProvider = mock(PanelFeatureProvider.class);

        mBluetoothFeatureProvider = mock(BluetoothFeatureProvider.class);

        mAwareFeatureProvider = mock(AwareFeatureProvider.class);

        mFaceFeatureProvider = mock(FaceFeatureProvider.class);

    }

    @Override

    public SuggestionFeatureProvider getSuggestionFeatureProvider(Context context) {

        return suggestionsFeatureProvider;

    }

    @Override

    public SupportFeatureProvider getSupportFeatureProvider(Context context) {

        return supportFeatureProvider;

    }

    @Override

    public MetricsFeatureProvider getMetricsFeatureProvider() {

        return metricsFeatureProvider;

    }

    @Override

    public BatteryStatusFeatureProvider getBatteryStatusFeatureProvider(Context context) {

        return batteryStatusFeatureProvider;

    }

    @Override

    public PowerUsageFeatureProvider getPowerUsageFeatureProvider(Context context) {

        return powerUsageFeatureProvider;

    }

    @Override

    public DashboardFeatureProvider getDashboardFeatureProvider(Context context) {

        return dashboardFeatureProvider;

    }

    @Override

    public DockUpdaterFeatureProvider getDockUpdaterFeatureProvider() {

        return dockUpdaterFeatureProvider;

    }

    @Override

    public ApplicationFeatureProvider getApplicationFeatureProvider(Context context) {

        return applicationFeatureProvider;

    }

    @Override

    public LocaleFeatureProvider getLocaleFeatureProvider() {

        return localeFeatureProvider;

    }

    @Override

    public EnterprisePrivacyFeatureProvider getEnterprisePrivacyFeatureProvider(Context context) {

        return enterprisePrivacyFeatureProvider;

    }

    @Override

    public SearchFeatureProvider getSearchFeatureProvider() {

        return searchFeatureProvider;

    }

    @Override

    public SurveyFeatureProvider getSurveyFeatureProvider(Context context) {

        return surveyFeatureProvider;

    }

    @Override

    public SecurityFeatureProvider getSecurityFeatureProvider() {

        return securityFeatureProvider;

    }

    @Override

    public UserFeatureProvider getUserFeatureProvider(Context context) {

        return userFeatureProvider;

    }

    @Override

    public AssistGestureFeatureProvider getAssistGestureFeatureProvider() {

        return assistGestureFeatureProvider;

    }

    @Override

    public SlicesFeatureProvider getSlicesFeatureProvider() {

        return slicesFeatureProvider;

    }

    @Override

    public AccountFeatureProvider getAccountFeatureProvider() {

        return mAccountFeatureProvider;

    }

    @Override

    public PanelFeatureProvider getPanelFeatureProvider() {

        return panelFeatureProvider;

    }

    @Override

    public ContextualCardFeatureProvider getContextualCardFeatureProvider(Context context) {

        return mContextualCardFeatureProvider;

    }

    @Override

    public BluetoothFeatureProvider getBluetoothFeatureProvider(Context context) {

        return mBluetoothFeatureProvider;

    }

    @Override

    public AwareFeatureProvider getAwareFeatureProvider() {

        return mAwareFeatureProvider;

    }

    @Override

    public FaceFeatureProvider getFaceFeatureProvider() {

        return mFaceFeatureProvider;

    }

}