Merge "Remove all associaitons when forget a device in Settings" into main

tests/robotests/src/com/android/settings/bluetooth/ForgetDeviceDialogFragmentTest.java

@@ -20,24 +20,36 @@ import static com.google.common.truth.Truth.assertThat;
 
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import android.bluetooth.BluetoothDevice;
+import android.companion.AssociationInfo;
+import android.companion.CompanionDeviceManager;
 import android.content.Context;
+import android.content.DialogInterface;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.net.MacAddress;
+import android.os.Bundle;
+import android.platform.test.annotations.RequiresFlagsEnabled;
+import android.platform.test.flag.junit.CheckFlagsRule;
+import android.platform.test.flag.junit.DeviceFlagsValueProvider;
 
 import androidx.appcompat.app.AlertDialog;
 import androidx.fragment.app.FragmentActivity;
 
 import com.android.settings.R;
-import com.android.settings.testutils.FakeFeatureFactory;
+import com.android.settings.flags.Flags;
 import com.android.settings.testutils.shadow.ShadowAlertDialogCompat;
 import com.android.settingslib.bluetooth.CachedBluetoothDevice;
 
 import org.junit.Before;
 import org.junit.Ignore;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Answers;
@@ -48,41 +60,64 @@ import org.robolectric.RobolectricTestRunner;
 import org.robolectric.RuntimeEnvironment;
 import org.robolectric.annotation.Config;
 import org.robolectric.shadows.ShadowDialog;
+import org.robolectric.shadows.ShadowLooper;
 import org.robolectric.shadows.androidx.fragment.FragmentController;
 
-@Ignore
+import java.util.ArrayList;
+import java.util.List;
+
 @RunWith(RobolectricTestRunner.class)
-@Config(shadows = {ShadowAlertDialogCompat.class})
+@Config(shadows = {
+        com.android.settings.testutils.shadow.ShadowFragment.class,
+        ShadowAlertDialogCompat.class,
+})
 public class ForgetDeviceDialogFragmentTest {
 
     private static final String DEVICE_NAME = "Nightshade";
+    private static final String PACKAGE_NAME = "com.android.test";
+    private static final CharSequence APP_NAME = "test";
 
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private CachedBluetoothDevice mCachedDevice;
     @Mock
     private BluetoothDevice mBluetoothDevice;
+    @Mock
+    private CompanionDeviceManager mCompanionDeviceManager;
+    @Mock
+    private PackageManager mPackageManager;
 
     private ForgetDeviceDialogFragment mFragment;
     private FragmentActivity mActivity;
     private AlertDialog mDialog;
     private Context mContext;
+    private List<AssociationInfo> mAssociations;
+
+    @Rule
+    public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
 
-        mContext = RuntimeEnvironment.application;
-        FakeFeatureFactory.setupForTest();
         String deviceAddress = "55:66:77:88:99:AA";
+        mAssociations = new ArrayList<>();
+        mFragment = spy(ForgetDeviceDialogFragment.newInstance(deviceAddress));
+        mContext = spy(RuntimeEnvironment.application);
+        mFragment.mCompanionDeviceManager = mCompanionDeviceManager;
+        mFragment.mPackageManager = mPackageManager;
+        mFragment.mDevice = mCachedDevice;
+        mActivity = Robolectric.setupActivity(FragmentActivity.class);
+
+        when(mFragment.getActivity()).thenReturn(mActivity);
         when(mCachedDevice.getAddress()).thenReturn(deviceAddress);
         when(mCachedDevice.getIdentityAddress()).thenReturn(deviceAddress);
         when(mCachedDevice.getDevice()).thenReturn(mBluetoothDevice);
         when(mCachedDevice.getName()).thenReturn(DEVICE_NAME);
-        mFragment = spy(ForgetDeviceDialogFragment.newInstance(deviceAddress));
+        when(mCompanionDeviceManager.getAllAssociations()).thenReturn(mAssociations);
         doReturn(mCachedDevice).when(mFragment).getDevice(any());
-        mActivity = Robolectric.setupActivity(FragmentActivity.class);
     }
 
+    @Ignore("b/253386225")
     @Test
     public void cancelDialog() {
         initDialog();
@@ -92,6 +127,7 @@ public class ForgetDeviceDialogFragmentTest {
         assertThat(mActivity.isFinishing()).isFalse();
     }
 
+    @Ignore("b/253386225")
     @Test
     public void confirmDialog() {
         initDialog();
@@ -101,6 +137,7 @@ public class ForgetDeviceDialogFragmentTest {
         assertThat(mActivity.isFinishing()).isTrue();
     }
 
+    @Ignore("b/253386225")
     @Test
     public void createDialog_normalDevice_showNormalMessage() {
         when(mBluetoothDevice.getMetadata(BluetoothDevice.METADATA_IS_UNTETHERED_HEADSET))
@@ -115,8 +152,86 @@ public class ForgetDeviceDialogFragmentTest {
                 mContext.getString(R.string.bluetooth_unpair_dialog_body, DEVICE_NAME));
     }
 
+    @Test
+    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_REMOVE_ASSOCIATION_BT_UNPAIR)
+    public void cancelDialog_with_association() {
+        addAssociation();
+        final AlertDialog dialog = (AlertDialog) mFragment.onCreateDialog(Bundle.EMPTY);
+        dialog.show();
+        dialog.getButton(DialogInterface.BUTTON_NEGATIVE).performClick();
+        ShadowLooper.idleMainLooper();
+
+        verify(mCachedDevice, never()).unpair();
+        verify(mCompanionDeviceManager, never()).disassociate(1);
+        assertThat(mActivity.isFinishing()).isFalse();
+    }
+
+    @Test
+    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_REMOVE_ASSOCIATION_BT_UNPAIR)
+    public void confirmDialog_with_association() {
+        addAssociation();
+        final AlertDialog dialog = (AlertDialog) mFragment.onCreateDialog(Bundle.EMPTY);
+        dialog.show();
+        dialog.getButton(DialogInterface.BUTTON_POSITIVE).performClick();
+        ShadowLooper.idleMainLooper();
+
+        verify(mCachedDevice).unpair();
+        verify(mCompanionDeviceManager).disassociate(1);
+
+        assertThat(mActivity.isFinishing()).isTrue();
+    }
+
+    @Test
+    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_REMOVE_ASSOCIATION_BT_UNPAIR)
+    public void createDialog_showMessage_with_association() {
+        addAssociation();
+        final AlertDialog dialog = (AlertDialog) mFragment.onCreateDialog(Bundle.EMPTY);
+        dialog.show();
+        ShadowLooper.idleMainLooper();
+
+        ShadowAlertDialogCompat shadowDialog = ShadowAlertDialogCompat.shadowOf(dialog);
+        assertThat(shadowDialog.getMessage().toString()).isEqualTo(
+                mContext.getString(
+                        R.string.bluetooth_unpair_dialog_with_associations_body,
+                        DEVICE_NAME, APP_NAME)
+        );
+    }
+
     private void initDialog() {
         mActivity.getSupportFragmentManager().beginTransaction().add(mFragment, null).commit();
         mDialog = (AlertDialog) ShadowDialog.getLatestDialog();
     }
+
+    private void addAssociation() {
+        setupLabelAndInfo(PACKAGE_NAME, APP_NAME);
+        final AssociationInfo association = new AssociationInfo(
+                1,
+                /* userId */ 0,
+                PACKAGE_NAME,
+                MacAddress.fromString(mCachedDevice.getAddress()),
+                /* displayName */ null,
+                /* deviceProfile */ "",
+                /* associatedDevice */ null,
+                /* selfManaged */ false,
+                /* notifyOnDeviceNearby */ true,
+                /* revoked */ false,
+                /* pending */ false,
+                /* timeApprovedMs */ System.currentTimeMillis(),
+                /* lastTimeConnected */ Long.MAX_VALUE,
+                /* systemDataSyncFlags */ -1,
+                /* deviceIcon */ null,
+                /* deviceId */ null);
+
+        mAssociations.add(association);
+    }
+
+    private void setupLabelAndInfo(String packageName, CharSequence appName) {
+        ApplicationInfo appInfo = mock(ApplicationInfo.class);
+        try {
+            when(mPackageManager.getApplicationInfo(packageName, 0)).thenReturn(appInfo);
+            when(mPackageManager.getApplicationLabel(appInfo)).thenReturn(appName);
+        } catch (PackageManager.NameNotFoundException e) {
+            throw new RuntimeException(e);
+        }
+    }
 }