Merge "Unit tests for NetworkNotificationManager"

import android.os.UserHandle;

import android.telephony.TelephonyManager;

import android.util.Slog;

import com.android.internal.annotations.VisibleForTesting;

import com.android.internal.R;

import static android.net.NetworkCapabilities.*;

    public static enum NotificationType { SIGN_IN, NO_INTERNET, LOST_INTERNET, NETWORK_SWITCH };

    private static final String NOTIFICATION_ID = "Connectivity.Notification";

    @VisibleForTesting

    static final String NOTIFICATION_ID = "Connectivity.Notification";

    private static final String TAG = NetworkNotificationManager.class.getSimpleName();

    private static final boolean DBG = true;

/*

 * Copyright (C) 2016 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.server.connectivity;

import android.app.Notification;

import android.app.NotificationManager;

import android.content.Context;

import android.content.pm.ApplicationInfo;

import android.content.pm.PackageManager;

import android.content.res.Resources;

import android.net.NetworkCapabilities;

import android.net.NetworkInfo;

import android.telephony.TelephonyManager;

import android.test.suitebuilder.annotation.SmallTest;

import com.android.server.connectivity.NetworkNotificationManager.NotificationType;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

import junit.framework.TestCase;

import org.mockito.ArgumentCaptor;

import org.mockito.Mock;

import org.mockito.Mockito;

import org.mockito.MockitoAnnotations;

import static com.android.server.connectivity.NetworkNotificationManager.NotificationType.*;

import static org.mockito.Mockito.any;

import static org.mockito.Mockito.anyInt;

import static org.mockito.Mockito.eq;

import static org.mockito.Mockito.never;

import static org.mockito.Mockito.times;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;

public class NetworkNotificationManagerTest extends TestCase {

    static final String NOTIFICATION_ID = NetworkNotificationManager.NOTIFICATION_ID;

    static final NetworkCapabilities CELL_CAPABILITIES = new NetworkCapabilities();

    static final NetworkCapabilities WIFI_CAPABILITIES = new NetworkCapabilities();

    static {

        CELL_CAPABILITIES.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR);

        CELL_CAPABILITIES.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);

        WIFI_CAPABILITIES.addTransportType(NetworkCapabilities.TRANSPORT_WIFI);

        WIFI_CAPABILITIES.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);

    }

    @Mock Context mCtx;

    @Mock Resources mResources;

    @Mock PackageManager mPm;

    @Mock TelephonyManager mTelephonyManager;

    @Mock NotificationManager mNotificationManager;

    @Mock NetworkAgentInfo mWifiNai;

    @Mock NetworkAgentInfo mCellNai;

    @Mock NetworkInfo mNetworkInfo;

    ArgumentCaptor<Notification> mCaptor;

    NetworkNotificationManager mManager;

    public void setUp() {

        MockitoAnnotations.initMocks(this);

        mCaptor = ArgumentCaptor.forClass(Notification.class);

        mWifiNai.networkCapabilities = WIFI_CAPABILITIES;

        mWifiNai.networkInfo = mNetworkInfo;

        mCellNai.networkCapabilities = CELL_CAPABILITIES;

        mCellNai.networkInfo = mNetworkInfo;

        when(mCtx.getResources()).thenReturn(mResources);

        when(mCtx.getPackageManager()).thenReturn(mPm);

        when(mCtx.getApplicationInfo()).thenReturn(new ApplicationInfo());

        when(mResources.getColor(anyInt(), any())).thenReturn(0xFF607D8B);

        mManager = new NetworkNotificationManager(mCtx, mTelephonyManager, mNotificationManager);

    }

    @SmallTest

    public void testNotificationsShownAndCleared() {

        final int NETWORK_ID_BASE = 100;

        List<NotificationType> types = Arrays.asList(NotificationType.values());

        List<Integer> ids = new ArrayList<>(types.size());

        for (int i = 0; i < ids.size(); i++) {

            ids.add(NETWORK_ID_BASE + i);

        }

        Collections.shuffle(ids);

        Collections.shuffle(types);

        for (int i = 0; i < ids.size(); i++) {

            mManager.showNotification(ids.get(i), types.get(i), mWifiNai, mCellNai, null, false);

        }

        Collections.shuffle(ids);

        for (int i = 0; i < ids.size(); i++) {

            mManager.clearNotification(ids.get(i));

        }

        for (int i = 0; i < ids.size(); i++) {

            final int expectedId = NETWORK_ID_BASE + i;

            verify(mNotificationManager, times(1))

                    .notifyAsUser(eq(NOTIFICATION_ID), eq(expectedId), any(), any());

            verify(mNotificationManager, times(1))

                    .cancelAsUser(eq(NOTIFICATION_ID), eq(expectedId), any());

        }

    }

    @SmallTest

    public void testNoInternetNotificationsNotShownForCellular() {

        mManager.showNotification(100, NO_INTERNET, mCellNai, mWifiNai, null, false);

        mManager.showNotification(101, LOST_INTERNET, mCellNai, mWifiNai, null, false);

        verify(mNotificationManager, never()).notifyAsUser(any(), anyInt(), any(), any());

        mManager.showNotification(102, NO_INTERNET, mWifiNai, mCellNai, null, false);

        verify(mNotificationManager, times(1))

                .notifyAsUser(eq(NOTIFICATION_ID), eq(102), any(), any());

    }

    @SmallTest

    public void testNotificationsNotShownIfNoInternetCapability() {

        mWifiNai.networkCapabilities = new NetworkCapabilities();

        mWifiNai.networkCapabilities .addTransportType(NetworkCapabilities.TRANSPORT_WIFI);

        mManager.showNotification(102, NO_INTERNET, mWifiNai, mCellNai, null, false);

        mManager.showNotification(103, LOST_INTERNET, mWifiNai, mCellNai, null, false);

        mManager.showNotification(104, NETWORK_SWITCH, mWifiNai, mCellNai, null, false);

        verify(mNotificationManager, never()).notifyAsUser(any(), anyInt(), any(), any());

    }

}