Merge "VpnPreferenceControllerTest converted to JUnit" into sc-dev

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

import static org.mockito.ArgumentMatchers.any;

import static org.mockito.ArgumentMatchers.anyString;

import static org.mockito.Mockito.doReturn;

import static org.mockito.Mockito.spy;

import static org.mockito.Mockito.verify;

import android.net.ConnectivityManager;

import android.net.NetworkRequest;

import android.net.VpnManager;

import android.os.Looper;

import android.os.UserHandle;

import android.provider.Settings;

import android.provider.SettingsSlicesContract;

import androidx.lifecycle.LifecycleOwner;

import androidx.preference.Preference;

import androidx.preference.PreferenceManager;

import androidx.preference.PreferenceScreen;

import androidx.test.annotation.UiThreadTest;

import androidx.test.core.app.ApplicationProvider;

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

import com.android.internal.net.VpnConfig;

import com.android.settingslib.core.lifecycle.Lifecycle;

import org.junit.Before;

import org.junit.Ignore;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;

import org.robolectric.RobolectricTestRunner;

import org.robolectric.RuntimeEnvironment;

@RunWith(RobolectricTestRunner.class)

@RunWith(AndroidJUnit4.class)

public class VpnPreferenceControllerTest {

    private static final String VPN_PREFERENCE_KEY = "vpn_settings";

    @Mock

    private Context mContext;

    @Mock

    private ConnectivityManager mConnectivityManager;

    @Mock

    private VpnManager mVpnManager;

    @Mock

    private PreferenceScreen mScreen;

    @Mock

    private Preference mPreference;

    private LifecycleOwner mLifecycleOwner;

    @Before

    @UiThreadTest

    public void setUp() {

        MockitoAnnotations.initMocks(this);

        mContext = spy(ApplicationProvider.getApplicationContext());

        when(mContext.getSystemService(Context.CONNECTIVITY_SERVICE))

                .thenReturn(mConnectivityManager);

        when(mContext.getSystemService(VpnManager.class)).thenReturn(mVpnManager);

        when(mScreen.findPreference(anyString())).thenReturn(mPreference);

        if (Looper.myLooper() == null) {

            Looper.prepare();

        }

        PreferenceManager preferenceManager = new PreferenceManager(mContext);

        mScreen = preferenceManager.createPreferenceScreen(mContext);

        when(mPreference.getKey()).thenReturn(VPN_PREFERENCE_KEY);

        mScreen.addPreference(mPreference);

        mController = spy(new VpnPreferenceController(mContext));

        mLifecycleOwner = () -> mLifecycle;

    @Test

    public void displayPreference_available_shouldSetDependency() {

        doReturn(true).when(mController).isAvailable();

        mController.displayPreference(mScreen);

        Settings.Global.putString(mContext.getContentResolver(),

                Settings.Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS, "");

        VpnPreferenceController controller = spy(new VpnPreferenceController(mContext));

        doReturn(true).when(controller).isAvailable();

        controller.displayPreference(mScreen);

        verify(mPreference).setDependency(SettingsSlicesContract.KEY_AIRPLANE_MODE);

    }

    @Test

    // TODO(b/176821216) re-enable this test once VpnPreferenceController is edited to notify

    // the preference of legacy VPNs

    @Ignore

    public void goThroughLifecycle_shouldRegisterUnregisterListener() {

        doReturn(true).when(mController).isAvailable();

        final VpnConfig config = new VpnConfig();

        config.legacy = true;

        final VpnPreferenceController controller =

                new VpnPreferenceController(RuntimeEnvironment.application);

                new VpnPreferenceController(ApplicationProvider.getApplicationContext());

        final String summary = controller.getNameForVpnConfig(config, UserHandle.CURRENT);