1 /*
2  * Copyright (C) 2023 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.privatespace;
18 
19 
20 import static android.safetycenter.SafetyEvent.SAFETY_EVENT_TYPE_DEVICE_REBOOTED;
21 
22 import static com.android.settings.privatespace.PrivateSpaceSafetySource.SAFETY_SOURCE_ID;
23 
24 import static com.google.common.truth.Truth.assertThat;
25 
26 import static org.mockito.ArgumentMatchers.any;
27 import static org.mockito.ArgumentMatchers.eq;
28 import static org.mockito.Mockito.never;
29 import static org.mockito.Mockito.spy;
30 import static org.mockito.Mockito.verify;
31 import static org.mockito.Mockito.when;
32 
33 import android.content.Context;
34 import android.os.Flags;
35 import android.os.UserManager;
36 import android.platform.test.flag.junit.SetFlagsRule;
37 import android.safetycenter.SafetyEvent;
38 import android.safetycenter.SafetySourceData;
39 import android.safetycenter.SafetySourceStatus;
40 
41 import androidx.test.core.app.ApplicationProvider;
42 import androidx.test.ext.junit.runners.AndroidJUnit4;
43 
44 import com.android.settings.safetycenter.SafetyCenterManagerWrapper;
45 
46 import org.junit.After;
47 import org.junit.Before;
48 import org.junit.Rule;
49 import org.junit.Test;
50 import org.junit.runner.RunWith;
51 import org.mockito.ArgumentCaptor;
52 import org.mockito.Mock;
53 import org.mockito.MockitoAnnotations;
54 
55 @RunWith(AndroidJUnit4.class)
56 public class PrivateSpaceSafetySourceTest {
57     private static final SafetyEvent EVENT_TYPE_DEVICE_REBOOTED =
58             new SafetyEvent.Builder(SAFETY_EVENT_TYPE_DEVICE_REBOOTED).build();
59     private Context mContext = ApplicationProvider.getApplicationContext();
60     private Context mMockContext;
61     @Mock private SafetyCenterManagerWrapper mSafetyCenterManagerWrapper;
62     @Mock private UserManager mUserManager;
63     @Rule public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
64 
65     /** Required setup before a test. */
66     @Before
setUp()67     public void setUp() {
68         MockitoAnnotations.initMocks(this);
69         SafetyCenterManagerWrapper.sInstance = mSafetyCenterManagerWrapper;
70     }
71 
72     /** Required setup after a test. */
73     @After
tearDown()74     public void tearDown() {
75         SafetyCenterManagerWrapper.sInstance = null;
76     }
77 
78     /** Tests that when SC is disabled we don't set any data. */
79     @Test
onDeviceRebootedEvent_whenSafetyCenterDisabled_doesNotSetData()80     public void onDeviceRebootedEvent_whenSafetyCenterDisabled_doesNotSetData() {
81         when(mSafetyCenterManagerWrapper.isEnabled(mContext)).thenReturn(false);
82 
83         PrivateSpaceSafetySource.setSafetySourceData(mContext, EVENT_TYPE_DEVICE_REBOOTED);
84 
85         verify(mSafetyCenterManagerWrapper, never()).setSafetySourceData(
86                 any(), any(), any(), any());
87     }
88 
89     /** Tests that when SC is enabled we set data. */
90     @Test
onDeviceRebootedEvent_whenSafetyCenterEnabled_setsData()91     public void onDeviceRebootedEvent_whenSafetyCenterEnabled_setsData() {
92         when(mSafetyCenterManagerWrapper.isEnabled(mContext)).thenReturn(true);
93         mSetFlagsRule.enableFlags(Flags.FLAG_ALLOW_PRIVATE_PROFILE,
94                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
95 
96         PrivateSpaceSafetySource.setSafetySourceData(mContext, EVENT_TYPE_DEVICE_REBOOTED);
97 
98         verify(mSafetyCenterManagerWrapper).setSafetySourceData(
99                 any(), eq(SAFETY_SOURCE_ID), any(), eq(EVENT_TYPE_DEVICE_REBOOTED));
100     }
101 
102     /** Tests that when the feature is disabled null data is set. */
103     @Test
setSafetySourceData_whenFeatureDisabled_setsNullData()104     public void setSafetySourceData_whenFeatureDisabled_setsNullData() {
105         when(mSafetyCenterManagerWrapper.isEnabled(mContext)).thenReturn(true);
106         mSetFlagsRule.disableFlags(Flags.FLAG_ALLOW_PRIVATE_PROFILE,
107                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
108 
109         PrivateSpaceSafetySource.setSafetySourceData(mContext, EVENT_TYPE_DEVICE_REBOOTED);
110 
111         ArgumentCaptor<SafetySourceData> captor = ArgumentCaptor.forClass(SafetySourceData.class);
112         verify(mSafetyCenterManagerWrapper).setSafetySourceData(
113                 any(), eq(SAFETY_SOURCE_ID), captor.capture(), eq(EVENT_TYPE_DEVICE_REBOOTED));
114         SafetySourceData safetySourceData = captor.getValue();
115         assertThat(safetySourceData).isNull();
116     }
117 
118     /** Tests that setSafetySourceData sets the source status enabled. */
119     @Test
setSafetySourceData_setsEnabled()120     public void setSafetySourceData_setsEnabled() {
121         when(mSafetyCenterManagerWrapper.isEnabled(mContext)).thenReturn(true);
122         mSetFlagsRule.enableFlags(Flags.FLAG_ALLOW_PRIVATE_PROFILE,
123                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
124 
125         PrivateSpaceSafetySource.setSafetySourceData(mContext, EVENT_TYPE_DEVICE_REBOOTED);
126 
127         ArgumentCaptor<SafetySourceData> captor = ArgumentCaptor.forClass(SafetySourceData.class);
128         verify(mSafetyCenterManagerWrapper).setSafetySourceData(
129                 any(), eq(SAFETY_SOURCE_ID), captor.capture(), eq(EVENT_TYPE_DEVICE_REBOOTED));
130         SafetySourceData safetySourceData = captor.getValue();
131         SafetySourceStatus safetySourceStatus = safetySourceData.getStatus();
132         assertThat(safetySourceStatus.isEnabled()).isTrue();
133     }
134 
135     /** Tests that setSafetySourceData sets the PS settings page authenticator intent. */
136     @Test
setSafetySourceData_setsPsAuthenticatorIntent()137     public void setSafetySourceData_setsPsAuthenticatorIntent() {
138         when(mSafetyCenterManagerWrapper.isEnabled(mContext)).thenReturn(true);
139         mSetFlagsRule.enableFlags(Flags.FLAG_ALLOW_PRIVATE_PROFILE,
140                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
141 
142         PrivateSpaceSafetySource.setSafetySourceData(mContext, EVENT_TYPE_DEVICE_REBOOTED);
143 
144         ArgumentCaptor<SafetySourceData> captor = ArgumentCaptor.forClass(SafetySourceData.class);
145         verify(mSafetyCenterManagerWrapper).setSafetySourceData(
146                 any(), eq(SAFETY_SOURCE_ID), captor.capture(), eq(EVENT_TYPE_DEVICE_REBOOTED));
147         SafetySourceData safetySourceData = captor.getValue();
148         SafetySourceStatus safetySourceStatus = safetySourceData.getStatus();
149         assertThat(safetySourceStatus.getPendingIntent().getIntent().getComponent().getClassName())
150                 .isEqualTo(PrivateSpaceAuthenticationActivity.class.getName());
151         assertThat(safetySourceStatus.getPendingIntent().getIntent().getIdentifier())
152                 .isEqualTo(SAFETY_SOURCE_ID);
153     }
154 
155     /** Tests that setSafetySourceData sets the source status enabled. */
156     @Test
setSafetySourceData_whenNonMainUser_doesNotSendData()157     public void setSafetySourceData_whenNonMainUser_doesNotSendData() {
158         mSetFlagsRule.enableFlags(Flags.FLAG_ALLOW_PRIVATE_PROFILE,
159                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
160         mMockContext = spy(mContext);
161         when(mSafetyCenterManagerWrapper.isEnabled(mMockContext)).thenReturn(true);
162         when(mMockContext.getSystemService(UserManager.class)).thenReturn(mUserManager);
163         when(mUserManager.isMainUser()).thenReturn(false);
164 
165         PrivateSpaceSafetySource.setSafetySourceData(mMockContext, EVENT_TYPE_DEVICE_REBOOTED);
166 
167         verify(mSafetyCenterManagerWrapper, never()).setSafetySourceData(
168                 any(), any(), any(), any());
169     }
170 }
171