1 /*
2  * Copyright (C) 2021 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.imsserviceentitlement;
18 
19 import static org.mockito.Mockito.inOrder;
20 import static org.mockito.Mockito.spy;
21 import static org.mockito.Mockito.verify;
22 import static org.mockito.Mockito.when;
23 
24 import android.app.Activity;
25 import android.app.Instrumentation;
26 import android.content.Context;
27 import android.content.Intent;
28 import android.net.ConnectivityManager;
29 import android.net.NetworkInfo;
30 import android.telephony.SubscriptionManager;
31 import android.telephony.TelephonyManager;
32 
33 import androidx.test.core.app.ApplicationProvider;
34 import androidx.test.runner.AndroidJUnit4;
35 
36 import com.android.imsserviceentitlement.entitlement.EntitlementResult;
37 import com.android.imsserviceentitlement.ts43.Ts43VowifiStatus;
38 import com.android.imsserviceentitlement.ts43.Ts43VowifiStatus.AddrStatus;
39 import com.android.imsserviceentitlement.ts43.Ts43VowifiStatus.EntitlementStatus;
40 import com.android.imsserviceentitlement.ts43.Ts43VowifiStatus.ProvStatus;
41 import com.android.imsserviceentitlement.ts43.Ts43VowifiStatus.TcStatus;
42 import com.android.imsserviceentitlement.utils.Executors;
43 
44 import org.junit.Before;
45 import org.junit.Rule;
46 import org.junit.Test;
47 import org.junit.runner.RunWith;
48 import org.mockito.InOrder;
49 import org.mockito.Mock;
50 import org.mockito.junit.MockitoJUnit;
51 import org.mockito.junit.MockitoRule;
52 
53 import java.lang.reflect.Field;
54 
55 // TODO(b/176127289) add tests
56 @RunWith(AndroidJUnit4.class)
57 public class WfcActivationControllerTest {
58     @Rule public final MockitoRule rule = MockitoJUnit.rule();
59     @Mock private TelephonyManager mTelephonyManager;
60     @Mock private ImsEntitlementApi mActivationApi;
61     @Mock private WfcActivationUi mActivationUi;
62     @Mock private ConnectivityManager mConnectivityManager;
63     @Mock private NetworkInfo mNetworkInfo;
64 
65     private static final int SUB_ID = 1;
66     private static final String EMERGENCY_ADDRESS_WEB_URL = "webUrl";
67     private static final String EMERGENCY_ADDRESS_WEB_DATA = "webData";
68     private static final String TERMS_AND_CONDITION_WEB_URL = "tncUrl";
69     private static final String WEBVIEW_JS_CONTROLLER_NAME = "webviewJsControllerName";
70 
71     private WfcActivationController mWfcActivationController;
72     private Context mContext;
73     private Instrumentation mInstrumentation;
74 
75     @Before
setUp()76     public void setUp() throws Exception {
77         mContext = spy(ApplicationProvider.getApplicationContext());
78 
79         when(mContext.getSystemService(TelephonyManager.class)).thenReturn(mTelephonyManager);
80         when(mTelephonyManager.createForSubscriptionId(SUB_ID)).thenReturn(mTelephonyManager);
81         setNetworkConnected(true);
82 
83         Field field = Executors.class.getDeclaredField("sUseDirectExecutorForTest");
84         field.setAccessible(true);
85         field.set(null, true);
86     }
87 
88     @Test
startFlow_launchAppForActivation_setPurposeActivation()89     public void startFlow_launchAppForActivation_setPurposeActivation() {
90         InOrder mOrderVerifier = inOrder(mActivationUi);
91         setNetworkConnected(false);
92         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
93 
94         mWfcActivationController.startFlow();
95 
96         verifyGeneralWaitingUiInOrder(mOrderVerifier, R.string.activate_title);
97         verifyErrorUiInOrder(
98                 mOrderVerifier,
99                 R.string.activate_title,
100                 R.string.wfc_activation_error);
101     }
102 
103     @Test
startFlow_launchAppForUpdate_setPurposeUpdate()104     public void startFlow_launchAppForUpdate_setPurposeUpdate() {
105         InOrder mOrderVerifier = inOrder(mActivationUi);
106         setNetworkConnected(false);
107         buildActivity(ActivityConstants.LAUNCH_APP_UPDATE);
108 
109         mWfcActivationController.startFlow();
110 
111         verifyGeneralWaitingUiInOrder(mOrderVerifier, R.string.e911_title);
112         verifyErrorUiInOrder(mOrderVerifier, R.string.e911_title, R.string.address_update_error);
113     }
114 
115     @Test
startFlow_launchAppForShowTc_setPurposeUpdate()116     public void startFlow_launchAppForShowTc_setPurposeUpdate() {
117         InOrder mOrderVerifier = inOrder(mActivationUi);
118         setNetworkConnected(false);
119         buildActivity(ActivityConstants.LAUNCH_APP_SHOW_TC);
120 
121         mWfcActivationController.startFlow();
122 
123         verifyGeneralWaitingUiInOrder(mOrderVerifier, R.string.tos_title);
124         verifyErrorUiInOrder(
125                 mOrderVerifier,
126                 R.string.tos_title,
127                 R.string.show_terms_and_condition_error);
128     }
129 
130     @Test
finishFlow_isFinishing_showGeneralWaitingUi()131     public void finishFlow_isFinishing_showGeneralWaitingUi() {
132         InOrder mOrderVerifier = inOrder(mActivationUi);
133         when(mActivationApi.checkEntitlementStatus()).thenReturn(null);
134         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
135 
136         mWfcActivationController.finishFlow();
137 
138         mOrderVerifier
139                 .verify(mActivationUi)
140                 .showActivationUi(
141                         R.string.activate_title,
142                         R.string.progress_text,
143                         true,
144                         0,
145                         Activity.RESULT_CANCELED,
146                         0);
147         mOrderVerifier
148                 .verify(mActivationUi)
149                 .showActivationUi(
150                         R.string.activate_title,
151                         R.string.wfc_activation_error,
152                         false,
153                         R.string.ok,
154                         WfcActivationUi.RESULT_FAILURE,
155                         0);
156     }
157 
158     @Test
handleEntitlementStatusForActivation_isVowifiEntitledTrue_setActivityResultOk()159     public void handleEntitlementStatusForActivation_isVowifiEntitledTrue_setActivityResultOk() {
160         EntitlementResult mEntitlementResult =
161                 EntitlementResult.builder()
162                         .setVowifiStatus(
163                                 Ts43VowifiStatus.builder()
164                                         .setEntitlementStatus(EntitlementStatus.ENABLED)
165                                         .setTcStatus(TcStatus.AVAILABLE)
166                                         .setAddrStatus(AddrStatus.AVAILABLE)
167                                         .setProvStatus(ProvStatus.PROVISIONED)
168                                         .build())
169                         .build();
170         when(mActivationApi.checkEntitlementStatus()).thenReturn(mEntitlementResult);
171         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
172 
173         mWfcActivationController.evaluateEntitlementStatus();
174 
175         verify(mActivationUi).setResultAndFinish(Activity.RESULT_OK);
176     }
177 
178     @Test
handleEntitlementStatusForActivation_isServerDataMissingTrue_showWebview()179     public void handleEntitlementStatusForActivation_isServerDataMissingTrue_showWebview() {
180         EntitlementResult mEntitlementResult =
181                 EntitlementResult.builder()
182                         .setVowifiStatus(
183                                 Ts43VowifiStatus.builder()
184                                         .setEntitlementStatus(EntitlementStatus.DISABLED)
185                                         .setTcStatus(TcStatus.NOT_AVAILABLE)
186                                         .setAddrStatus(AddrStatus.NOT_AVAILABLE)
187                                         .build())
188                         .setEmergencyAddressWebUrl(EMERGENCY_ADDRESS_WEB_URL)
189                         .setEmergencyAddressWebData(EMERGENCY_ADDRESS_WEB_DATA)
190                         .build();
191         when(mActivationApi.checkEntitlementStatus()).thenReturn(mEntitlementResult);
192         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
193 
194         mWfcActivationController.evaluateEntitlementStatus();
195 
196         verify(mActivationUi).showWebview(EMERGENCY_ADDRESS_WEB_URL, EMERGENCY_ADDRESS_WEB_DATA);
197     }
198 
199     @Test
handleEntitlementStatusForActivation_isIncompatibleTrue_showErrorUi()200     public void handleEntitlementStatusForActivation_isIncompatibleTrue_showErrorUi() {
201         EntitlementResult mEntitlementResult =
202                 EntitlementResult.builder()
203                         .setVowifiStatus(
204                                 Ts43VowifiStatus.builder()
205                                         .setEntitlementStatus(EntitlementStatus.INCOMPATIBLE)
206                                         .build())
207                         .build();
208         when(mActivationApi.checkEntitlementStatus()).thenReturn(mEntitlementResult);
209         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
210 
211         mWfcActivationController.evaluateEntitlementStatus();
212 
213         verifyErrorUi(R.string.activate_title, R.string.failure_contact_carrier);
214     }
215 
216     @Test
handleEntitlementStatusForActivation_unexpectedStatus_showGeneralErrorUi()217     public void handleEntitlementStatusForActivation_unexpectedStatus_showGeneralErrorUi() {
218         EntitlementResult mEntitlementResult =
219                 EntitlementResult.builder()
220                         .setVowifiStatus(
221                                 Ts43VowifiStatus.builder()
222                                         .setEntitlementStatus(EntitlementStatus.DISABLED)
223                                         .setTcStatus(TcStatus.IN_PROGRESS)
224                                         .setAddrStatus(AddrStatus.IN_PROGRESS)
225                                         .build())
226                         .build();
227         when(mActivationApi.checkEntitlementStatus()).thenReturn(mEntitlementResult);
228         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
229 
230         mWfcActivationController.evaluateEntitlementStatus();
231 
232         verifyErrorUi(R.string.activate_title, R.string.wfc_activation_error);
233     }
234 
235     @Test
handleEntitlementStatusAfterActivation_isVowifiEntitledTrue_setActivityResultOk()236     public void handleEntitlementStatusAfterActivation_isVowifiEntitledTrue_setActivityResultOk() {
237         EntitlementResult mEntitlementResult =
238                 EntitlementResult.builder()
239                         .setVowifiStatus(
240                                 Ts43VowifiStatus.builder()
241                                         .setEntitlementStatus(EntitlementStatus.ENABLED)
242                                         .setTcStatus(TcStatus.AVAILABLE)
243                                         .setAddrStatus(AddrStatus.AVAILABLE)
244                                         .setProvStatus(ProvStatus.PROVISIONED)
245                                         .build())
246                         .build();
247         when(mActivationApi.checkEntitlementStatus()).thenReturn(mEntitlementResult);
248         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
249 
250         mWfcActivationController.reevaluateEntitlementStatus();
251 
252         verify(mActivationUi).setResultAndFinish(Activity.RESULT_OK);
253     }
254 
255     @Test
handleEntitlementStatusAfterActivation_unexpectedStatus_showGeneralErrorUi()256     public void handleEntitlementStatusAfterActivation_unexpectedStatus_showGeneralErrorUi() {
257         EntitlementResult mEntitlementResult =
258                 EntitlementResult.builder()
259                         .setVowifiStatus(
260                                 Ts43VowifiStatus.builder()
261                                         .setEntitlementStatus(EntitlementStatus.DISABLED)
262                                         .setTcStatus(TcStatus.IN_PROGRESS)
263                                         .setAddrStatus(AddrStatus.IN_PROGRESS)
264                                         .build())
265                         .build();
266         when(mActivationApi.checkEntitlementStatus()).thenReturn(mEntitlementResult);
267         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
268 
269         mWfcActivationController.reevaluateEntitlementStatus();
270 
271         verifyErrorUi(R.string.activate_title, R.string.wfc_activation_error);
272     }
273 
buildActivity(int extraLaunchCarrierApp)274     private void buildActivity(int extraLaunchCarrierApp) {
275         Intent intent = new Intent(Intent.ACTION_MAIN);
276         intent.putExtra(SubscriptionManager.EXTRA_SUBSCRIPTION_INDEX, SUB_ID);
277         intent.putExtra(ActivityConstants.EXTRA_LAUNCH_CARRIER_APP, extraLaunchCarrierApp);
278         mWfcActivationController =
279                 new WfcActivationController(mContext, mActivationUi, mActivationApi, intent);
280     }
281 
setNetworkConnected(boolean isConnected)282     private void setNetworkConnected(boolean isConnected) {
283         when(mNetworkInfo.isConnected()).thenReturn(isConnected);
284         when(mContext.getSystemService(Context.CONNECTIVITY_SERVICE)).thenReturn(
285                 mConnectivityManager);
286         when(mConnectivityManager.getActiveNetworkInfo()).thenReturn(mNetworkInfo);
287         when(mNetworkInfo.isConnected()).thenReturn(isConnected);
288     }
289 
verifyErrorUi(int title, int errorMesssage)290     private void verifyErrorUi(int title, int errorMesssage) {
291         verify(mActivationUi)
292                 .showActivationUi(
293                         title,
294                         errorMesssage,
295                         false, R.string.ok,
296                         WfcActivationUi.RESULT_FAILURE,
297                         0);
298     }
299 
verifyErrorUiInOrder(InOrder inOrder, int title, int errorMesssage)300     private void verifyErrorUiInOrder(InOrder inOrder, int title, int errorMesssage) {
301         inOrder.verify(mActivationUi)
302                 .showActivationUi(
303                         title,
304                         errorMesssage,
305                         false, R.string.ok,
306                         WfcActivationUi.RESULT_FAILURE,
307                         0);
308     }
309 
verifyGeneralWaitingUiInOrder(InOrder inOrder, int title)310     private void verifyGeneralWaitingUiInOrder(InOrder inOrder, int title) {
311         inOrder.verify(mActivationUi)
312                 .showActivationUi(title, R.string.progress_text, true, 0, 0, 0);
313     }
314 }
315