• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 com.android.imsserviceentitlement.ImsServiceEntitlementStatsLog.IMS_SERVICE_ENTITLEMENT_UPDATED__APP_RESULT__FAILED;
20 import static com.android.imsserviceentitlement.ImsServiceEntitlementStatsLog.IMS_SERVICE_ENTITLEMENT_UPDATED__APP_RESULT__SUCCESSFUL;
21 import static com.android.imsserviceentitlement.ImsServiceEntitlementStatsLog.IMS_SERVICE_ENTITLEMENT_UPDATED__PURPOSE__ACTIVATION;
22 import static com.android.imsserviceentitlement.ImsServiceEntitlementStatsLog.IMS_SERVICE_ENTITLEMENT_UPDATED__SERVICE_TYPE__VOWIFI;
23 
24 import static org.mockito.ArgumentMatchers.any;
25 import static org.mockito.ArgumentMatchers.anyInt;
26 import static org.mockito.ArgumentMatchers.eq;
27 import static org.mockito.Mockito.inOrder;
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.app.Activity;
34 import android.content.Context;
35 import android.content.Intent;
36 import android.net.ConnectivityManager;
37 import android.net.NetworkInfo;
38 import android.os.PersistableBundle;
39 import android.os.Handler;
40 import android.os.HandlerThread;
41 import android.os.Message;
42 import android.os.TestLooperManager;
43 import android.telephony.CarrierConfigManager;
44 import android.telephony.SubscriptionManager;
45 import android.telephony.TelephonyManager;
46 
47 import androidx.test.core.app.ApplicationProvider;
48 import androidx.test.platform.app.InstrumentationRegistry;
49 import androidx.test.runner.AndroidJUnit4;
50 
51 import com.android.imsserviceentitlement.entitlement.EntitlementResult;
52 import com.android.imsserviceentitlement.ts43.Ts43Constants.EntitlementStatus;
53 import com.android.imsserviceentitlement.ts43.Ts43VowifiStatus;
54 import com.android.imsserviceentitlement.ts43.Ts43VowifiStatus.AddrStatus;
55 import com.android.imsserviceentitlement.ts43.Ts43VowifiStatus.ProvStatus;
56 import com.android.imsserviceentitlement.ts43.Ts43VowifiStatus.TcStatus;
57 import com.android.imsserviceentitlement.utils.Executors;
58 import com.android.imsserviceentitlement.utils.ImsUtils;
59 import com.android.imsserviceentitlement.utils.MetricsLogger;
60 
61 import org.junit.After;
62 import org.junit.Before;
63 import org.junit.Rule;
64 import org.junit.Test;
65 import org.junit.runner.RunWith;
66 import org.mockito.InOrder;
67 import org.mockito.Mock;
68 import org.mockito.junit.MockitoJUnit;
69 import org.mockito.junit.MockitoRule;
70 
71 import java.lang.reflect.Field;
72 
73 @RunWith(AndroidJUnit4.class)
74 public class WfcActivationControllerTest {
75     @Rule public final MockitoRule rule = MockitoJUnit.rule();
76     @Mock private TelephonyManager mMockTelephonyManager;
77     @Mock private ImsEntitlementApi mMockActivationApi;
78     @Mock private WfcActivationUi mMockActivationUi;
79     @Mock private ConnectivityManager mMockConnectivityManager;
80     @Mock private NetworkInfo mMockNetworkInfo;
81     @Mock private ImsUtils mMockImsUtils;
82     @Mock private MetricsLogger mMockMetricsLogger;
83     @Mock private CarrierConfigManager mMockCarrierConfigManager;
84 
85     private static final int SUB_ID = 1;
86     private static final int CARRIER_ID = 1234;
87     private static final String EMERGENCY_ADDRESS_WEB_URL = "webUrl";
88     private static final String EMERGENCY_ADDRESS_WEB_DATA = "webData";
89     private static final String KEY_SKIP_WFC_ACTIVATION_BOOL =
90             "imsserviceentitlement.skip_wfc_activation_bool";
91 
92     private WfcActivationController mWfcActivationController;
93     private Context mContext;
94     private PersistableBundle mCarrierConfig;
95     private TestLooperManager mTestLooperManager;
96     private Handler mUiHandler;
97     private HandlerThread mUiHandlerThread;
98 
99     @Before
setUp()100     public void setUp() throws Exception {
101         mContext = spy(ApplicationProvider.getApplicationContext());
102 
103         mUiHandlerThread = new HandlerThread("MockUiThread");
104         mUiHandlerThread.start();
105         mUiHandler = new Handler(mUiHandlerThread.getLooper());
106         mTestLooperManager =
107                 InstrumentationRegistry.getInstrumentation()
108                         .acquireLooperManager(mUiHandlerThread.getLooper());
109 
110         when(mContext.getSystemService(CarrierConfigManager.class))
111                 .thenReturn(mMockCarrierConfigManager);
112         when(mContext.getSystemService(TelephonyManager.class)).thenReturn(mMockTelephonyManager);
113         when(mMockTelephonyManager.createForSubscriptionId(SUB_ID)).thenReturn(
114                 mMockTelephonyManager);
115         setNetworkConnected(true);
116         setIsSkipWfcActivation(false);
117 
118         Field field = Executors.class.getDeclaredField("sUseDirectExecutorForTest");
119         field.setAccessible(true);
120         field.set(null, true);
121     }
122 
123     @After
tearDown()124     public void tearDown() {
125         mTestLooperManager.release();
126         mUiHandlerThread.quit();
127     }
128 
129     @Test
startFlow_launchAppForActivation_setPurposeActivation()130     public void startFlow_launchAppForActivation_setPurposeActivation() {
131         InOrder mOrderVerifier = inOrder(mMockActivationUi);
132         setNetworkConnected(false);
133         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
134 
135         mWfcActivationController.startFlow();
136 
137         verifyGeneralWaitingUiInOrder(mOrderVerifier, R.string.activate_title);
138         verifyErrorUiInOrder(
139                 mOrderVerifier,
140                 R.string.activate_title,
141                 R.string.wfc_activation_error);
142     }
143 
144     @Test
startFlow_launchAppForUpdate_setPurposeUpdate()145     public void startFlow_launchAppForUpdate_setPurposeUpdate() {
146         InOrder mOrderVerifier = inOrder(mMockActivationUi);
147         setNetworkConnected(false);
148         buildActivity(ActivityConstants.LAUNCH_APP_UPDATE);
149 
150         mWfcActivationController.startFlow();
151 
152         verifyGeneralWaitingUiInOrder(mOrderVerifier, R.string.e911_title);
153         verifyErrorUiInOrder(mOrderVerifier, R.string.e911_title, R.string.address_update_error);
154     }
155 
156     @Test
startFlow_launchAppForShowTc_setPurposeUpdate()157     public void startFlow_launchAppForShowTc_setPurposeUpdate() {
158         InOrder mOrderVerifier = inOrder(mMockActivationUi);
159         setNetworkConnected(false);
160         buildActivity(ActivityConstants.LAUNCH_APP_SHOW_TC);
161 
162         mWfcActivationController.startFlow();
163 
164         verifyGeneralWaitingUiInOrder(mOrderVerifier, R.string.tos_title);
165         verifyErrorUiInOrder(
166                 mOrderVerifier,
167                 R.string.tos_title,
168                 R.string.show_terms_and_condition_error);
169     }
170 
171     @Test
finish_launchAppForActivateWithIsSkipWfcActivationTrue_notWriteMetrics()172     public void finish_launchAppForActivateWithIsSkipWfcActivationTrue_notWriteMetrics() {
173         setIsSkipWfcActivation(true);
174         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
175 
176         mWfcActivationController.finish();
177 
178         verify(mMockMetricsLogger, never()).write(anyInt(), anyInt());
179     }
180 
181     @Test
finish_launchAppForUpdateWithIsSkipWfcActivationTrue_writeMetrics()182     public void finish_launchAppForUpdateWithIsSkipWfcActivationTrue_writeMetrics() {
183         setIsSkipWfcActivation(true);
184         buildActivity(ActivityConstants.LAUNCH_APP_UPDATE);
185 
186         mWfcActivationController.finish();
187 
188         verify(mMockMetricsLogger).write(anyInt(), anyInt());
189     }
190 
191     @Test
finish_launchAppForUpdateAndIsSkipWfcActivationFalse_writeMetrics()192     public void finish_launchAppForUpdateAndIsSkipWfcActivationFalse_writeMetrics() {
193         buildActivity(ActivityConstants.LAUNCH_APP_UPDATE);
194 
195         mWfcActivationController.finish();
196 
197         verify(mMockMetricsLogger).write(anyInt(), anyInt());
198     }
199 
200     @Test
finishFlow_isFinishing_showGeneralWaitingUi()201     public void finishFlow_isFinishing_showGeneralWaitingUi() {
202         InOrder mOrderVerifier = inOrder(mMockActivationUi);
203         when(mMockActivationApi.checkEntitlementStatus()).thenReturn(null);
204         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
205 
206         mWfcActivationController.finishFlow();
207         mTestLooperManager.execute(mTestLooperManager.next());
208 
209         mOrderVerifier
210                 .verify(mMockActivationUi)
211                 .showActivationUi(
212                         R.string.activate_title,
213                         R.string.progress_text,
214                         true,
215                         0,
216                         Activity.RESULT_CANCELED,
217                         0);
218         mOrderVerifier
219                 .verify(mMockActivationUi)
220                 .showActivationUi(
221                         R.string.activate_title,
222                         R.string.wfc_activation_error,
223                         false,
224                         R.string.ok,
225                         WfcActivationUi.RESULT_FAILURE,
226                         0);
227     }
228 
229     @Test
finishFlow_startForUpdate_showGeneralWaitingUi()230     public void finishFlow_startForUpdate_showGeneralWaitingUi() {
231         when(mMockActivationApi.checkEntitlementStatus())
232                 .thenReturn(
233                         EntitlementResult.builder(false)
234                                 .setVowifiStatus(
235                                         Ts43VowifiStatus.builder()
236                                                 .setEntitlementStatus(EntitlementStatus.ENABLED)
237                                                 .setProvStatus(ProvStatus.PROVISIONED)
238                                                 .setTcStatus(TcStatus.AVAILABLE)
239                                                 .setAddrStatus(AddrStatus.AVAILABLE)
240                                                 .build())
241                                 .build());
242         setNetworkConnected(false);
243         buildActivity(ActivityConstants.LAUNCH_APP_UPDATE);
244 
245         mWfcActivationController.finishFlow();
246         mTestLooperManager.execute(mTestLooperManager.next());
247 
248         verify(mMockActivationUi).setResultAndFinish(eq(Activity.RESULT_OK));
249     }
250 
251     @Test
finish_startFlowForActivate_writeLoggerPurposeActivation()252     public void finish_startFlowForActivate_writeLoggerPurposeActivation() {
253         when(mMockTelephonyManager.getSimCarrierId()).thenReturn(CARRIER_ID);
254         when(mMockTelephonyManager.getSimSpecificCarrierId()).thenReturn(CARRIER_ID);
255         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
256 
257         mWfcActivationController.startFlow();
258         mTestLooperManager.execute(mTestLooperManager.next());
259         mWfcActivationController.finish();
260 
261         verify(mMockMetricsLogger).start(eq(IMS_SERVICE_ENTITLEMENT_UPDATED__PURPOSE__ACTIVATION));
262         verify(mMockMetricsLogger).write(
263                 eq(IMS_SERVICE_ENTITLEMENT_UPDATED__SERVICE_TYPE__VOWIFI),
264                 eq(IMS_SERVICE_ENTITLEMENT_UPDATED__APP_RESULT__FAILED));
265     }
266 
267     @Test
finish_entitlementResultWfcEntitled_writeLoggerAppResultSuccessful()268     public void finish_entitlementResultWfcEntitled_writeLoggerAppResultSuccessful() {
269         when(mMockTelephonyManager.getSimCarrierId()).thenReturn(CARRIER_ID);
270         when(mMockTelephonyManager.getSimSpecificCarrierId()).thenReturn(CARRIER_ID);
271         when(mMockActivationApi.checkEntitlementStatus())
272                 .thenReturn(
273                         EntitlementResult.builder(false)
274                                 .setVowifiStatus(
275                                         Ts43VowifiStatus.builder()
276                                                 .setEntitlementStatus(EntitlementStatus.ENABLED)
277                                                 .setProvStatus(ProvStatus.PROVISIONED)
278                                                 .setTcStatus(TcStatus.AVAILABLE)
279                                                 .setAddrStatus(AddrStatus.AVAILABLE)
280                                                 .build())
281                                 .build());
282         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
283 
284         mWfcActivationController.startFlow();
285         mTestLooperManager.execute(mTestLooperManager.next());
286         mWfcActivationController.finish();
287 
288         verify(mMockMetricsLogger).start(eq(IMS_SERVICE_ENTITLEMENT_UPDATED__PURPOSE__ACTIVATION));
289         verify(mMockMetricsLogger).write(
290                 eq(IMS_SERVICE_ENTITLEMENT_UPDATED__SERVICE_TYPE__VOWIFI),
291                 eq(IMS_SERVICE_ENTITLEMENT_UPDATED__APP_RESULT__SUCCESSFUL));
292     }
293 
294     @Test
handleEntitlementStatusForActivation_isVowifiEntitledTrue_setActivityResultOk()295     public void handleEntitlementStatusForActivation_isVowifiEntitledTrue_setActivityResultOk() {
296         EntitlementResult entitlementResult =
297                 EntitlementResult.builder(false)
298                         .setVowifiStatus(
299                                 Ts43VowifiStatus.builder()
300                                         .setEntitlementStatus(EntitlementStatus.ENABLED)
301                                         .setTcStatus(TcStatus.AVAILABLE)
302                                         .setAddrStatus(AddrStatus.AVAILABLE)
303                                         .setProvStatus(ProvStatus.PROVISIONED)
304                                         .build())
305                         .build();
306         when(mMockActivationApi.checkEntitlementStatus()).thenReturn(entitlementResult);
307         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
308 
309         mWfcActivationController.evaluateEntitlementStatus();
310         mTestLooperManager.execute(mTestLooperManager.next());
311 
312         verify(mMockActivationUi).setResultAndFinish(Activity.RESULT_OK);
313     }
314 
315     @Test
handleEntitlementStatusForActivation_isServerDataMissingTrue_showWebview()316     public void handleEntitlementStatusForActivation_isServerDataMissingTrue_showWebview() {
317         EntitlementResult entitlementResult =
318                 EntitlementResult.builder(false)
319                         .setVowifiStatus(
320                                 Ts43VowifiStatus.builder()
321                                         .setEntitlementStatus(EntitlementStatus.DISABLED)
322                                         .setTcStatus(TcStatus.NOT_AVAILABLE)
323                                         .setAddrStatus(AddrStatus.NOT_AVAILABLE)
324                                         .build())
325                         .setEmergencyAddressWebUrl(EMERGENCY_ADDRESS_WEB_URL)
326                         .setEmergencyAddressWebData(EMERGENCY_ADDRESS_WEB_DATA)
327                         .build();
328         when(mMockActivationApi.checkEntitlementStatus()).thenReturn(entitlementResult);
329         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
330 
331         mWfcActivationController.evaluateEntitlementStatus();
332         mTestLooperManager.execute(mTestLooperManager.next());
333 
334         verify(mMockActivationUi).showWebview(EMERGENCY_ADDRESS_WEB_URL,
335                 EMERGENCY_ADDRESS_WEB_DATA);
336     }
337 
338     @Test
handleEntitlementStatusForActivation_showTc_showWebview()339     public void handleEntitlementStatusForActivation_showTc_showWebview() {
340         EntitlementResult entitlementResult =
341                 EntitlementResult.builder(false)
342                         .setVowifiStatus(
343                                 Ts43VowifiStatus.builder()
344                                         .setEntitlementStatus(EntitlementStatus.DISABLED)
345                                         .setTcStatus(TcStatus.NOT_AVAILABLE)
346                                         .setAddrStatus(AddrStatus.NOT_AVAILABLE)
347                                         .build())
348                         .setTermsAndConditionsWebUrl(EMERGENCY_ADDRESS_WEB_URL)
349                         .build();
350         when(mMockActivationApi.checkEntitlementStatus()).thenReturn(entitlementResult);
351         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
352 
353         mWfcActivationController.evaluateEntitlementStatus();
354         mTestLooperManager.execute(mTestLooperManager.next());
355 
356         verify(mMockActivationUi).showWebview(EMERGENCY_ADDRESS_WEB_URL, null);
357     }
358 
359     @Test
handleEntitlementStatusForActivation_isIncompatibleTrue_showErrorUi()360     public void handleEntitlementStatusForActivation_isIncompatibleTrue_showErrorUi() {
361         EntitlementResult entitlementResult =
362                 EntitlementResult.builder(false)
363                         .setVowifiStatus(
364                                 Ts43VowifiStatus.builder()
365                                         .setEntitlementStatus(EntitlementStatus.INCOMPATIBLE)
366                                         .build())
367                         .build();
368         when(mMockActivationApi.checkEntitlementStatus()).thenReturn(entitlementResult);
369         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
370 
371         mWfcActivationController.evaluateEntitlementStatus();
372         mTestLooperManager.execute(mTestLooperManager.next());
373 
374         verifyErrorUi(R.string.activate_title, R.string.failure_contact_carrier);
375     }
376 
377     @Test
handleEntitlementStatusForActivation_unexpectedStatus_showGeneralErrorUi()378     public void handleEntitlementStatusForActivation_unexpectedStatus_showGeneralErrorUi() {
379         EntitlementResult entitlementResult =
380                 EntitlementResult.builder(false)
381                         .setVowifiStatus(
382                                 Ts43VowifiStatus.builder()
383                                         .setEntitlementStatus(EntitlementStatus.DISABLED)
384                                         .setTcStatus(TcStatus.IN_PROGRESS)
385                                         .setAddrStatus(AddrStatus.IN_PROGRESS)
386                                         .build())
387                         .build();
388         when(mMockActivationApi.checkEntitlementStatus()).thenReturn(entitlementResult);
389         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
390 
391         mWfcActivationController.evaluateEntitlementStatus();
392         mTestLooperManager.execute(mTestLooperManager.next());
393 
394         verifyErrorUi(R.string.activate_title, R.string.wfc_activation_error);
395     }
396 
397     @Test
handleEntitlementStatusAfterActivation_isVowifiEntitledTrue_setActivityResultOk()398     public void handleEntitlementStatusAfterActivation_isVowifiEntitledTrue_setActivityResultOk() {
399         EntitlementResult entitlementResult =
400                 EntitlementResult.builder(false)
401                         .setVowifiStatus(
402                                 Ts43VowifiStatus.builder()
403                                         .setEntitlementStatus(EntitlementStatus.ENABLED)
404                                         .setTcStatus(TcStatus.AVAILABLE)
405                                         .setAddrStatus(AddrStatus.AVAILABLE)
406                                         .setProvStatus(ProvStatus.PROVISIONED)
407                                         .build())
408                         .build();
409         when(mMockActivationApi.checkEntitlementStatus()).thenReturn(entitlementResult);
410         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
411 
412         mWfcActivationController.reevaluateEntitlementStatus();
413         mTestLooperManager.execute(mTestLooperManager.next());
414 
415         verify(mMockActivationUi).setResultAndFinish(Activity.RESULT_OK);
416     }
417 
418     @Test
handleEntitlementStatusAfterActivation_unexpectedStatus_showGeneralErrorUi()419     public void handleEntitlementStatusAfterActivation_unexpectedStatus_showGeneralErrorUi() {
420         EntitlementResult entitlementResult =
421                 EntitlementResult.builder(false)
422                         .setVowifiStatus(
423                                 Ts43VowifiStatus.builder()
424                                         .setEntitlementStatus(EntitlementStatus.DISABLED)
425                                         .setTcStatus(TcStatus.IN_PROGRESS)
426                                         .setAddrStatus(AddrStatus.IN_PROGRESS)
427                                         .build())
428                         .build();
429         when(mMockActivationApi.checkEntitlementStatus()).thenReturn(entitlementResult);
430         buildActivity(ActivityConstants.LAUNCH_APP_ACTIVATE);
431 
432         mWfcActivationController.reevaluateEntitlementStatus();
433         mTestLooperManager.execute(mTestLooperManager.next());
434 
435         verifyErrorUi(R.string.activate_title, R.string.wfc_activation_error);
436     }
437 
438     @Test
handleEntitlementStatusAfterUpdating_entitlementStatusEnabled_setResultOk()439     public void handleEntitlementStatusAfterUpdating_entitlementStatusEnabled_setResultOk() {
440         EntitlementResult entitlementResult =
441                 EntitlementResult.builder(false)
442                         .setVowifiStatus(
443                                 Ts43VowifiStatus.builder()
444                                         .setEntitlementStatus(EntitlementStatus.ENABLED)
445                                         .setTcStatus(TcStatus.AVAILABLE)
446                                         .setAddrStatus(AddrStatus.AVAILABLE)
447                                         .setProvStatus(ProvStatus.PROVISIONED)
448                                         .build())
449                         .build();
450         when(mMockActivationApi.checkEntitlementStatus()).thenReturn(entitlementResult);
451         buildActivity(ActivityConstants.LAUNCH_APP_UPDATE);
452 
453         mWfcActivationController.reevaluateEntitlementStatus();
454         mTestLooperManager.execute(mTestLooperManager.next());
455 
456         verify(mMockActivationUi).setResultAndFinish(eq(Activity.RESULT_OK));
457     }
458 
459     @Test
handleEntitlementStatusAfterUpdating_entitlementStatusNoServerData_turnOffWfc()460     public void handleEntitlementStatusAfterUpdating_entitlementStatusNoServerData_turnOffWfc() {
461         EntitlementResult entitlementResult =
462                 EntitlementResult.builder(false)
463                         .setVowifiStatus(
464                                 Ts43VowifiStatus.builder()
465                                         .setEntitlementStatus(EntitlementStatus.DISABLED)
466                                         .setTcStatus(TcStatus.NOT_AVAILABLE)
467                                         .setAddrStatus(AddrStatus.NOT_AVAILABLE)
468                                         .build())
469                         .build();
470         when(mMockActivationApi.checkEntitlementStatus()).thenReturn(entitlementResult);
471         buildActivity(ActivityConstants.LAUNCH_APP_UPDATE);
472 
473         mWfcActivationController.reevaluateEntitlementStatus();
474         mTestLooperManager.execute(mTestLooperManager.next());
475 
476         verify(mMockImsUtils).turnOffWfc(any());
477     }
478 
479     @Test
handleEntitlementStatusAfterUpdating_unexpectedStatus_showGeneralErrorUi()480     public void handleEntitlementStatusAfterUpdating_unexpectedStatus_showGeneralErrorUi() {
481         EntitlementResult entitlementResult =
482                 EntitlementResult.builder(false)
483                         .setVowifiStatus(
484                                 Ts43VowifiStatus.builder()
485                                         .setEntitlementStatus(EntitlementStatus.DISABLED)
486                                         .setTcStatus(TcStatus.IN_PROGRESS)
487                                         .setAddrStatus(AddrStatus.IN_PROGRESS)
488                                         .build())
489                         .build();
490         when(mMockActivationApi.checkEntitlementStatus()).thenReturn(entitlementResult);
491         buildActivity(ActivityConstants.LAUNCH_APP_UPDATE);
492 
493         mWfcActivationController.reevaluateEntitlementStatus();
494         mTestLooperManager.execute(mTestLooperManager.next());
495 
496         verifyErrorUi(R.string.e911_title, R.string.address_update_error);
497     }
498 
499     @Test
handleEntitlementStatusForUpdate_serviceEntitled_showWebview()500     public void handleEntitlementStatusForUpdate_serviceEntitled_showWebview() {
501         when(mMockActivationApi.checkEntitlementStatus())
502                 .thenReturn(
503                         EntitlementResult.builder(false)
504                                 .setVowifiStatus(
505                                         Ts43VowifiStatus.builder()
506                                                 .setEntitlementStatus(EntitlementStatus.ENABLED)
507                                                 .setProvStatus(ProvStatus.PROVISIONED)
508                                                 .setTcStatus(TcStatus.AVAILABLE)
509                                                 .setAddrStatus(AddrStatus.AVAILABLE)
510                                                 .build())
511                                 .setEmergencyAddressWebUrl(EMERGENCY_ADDRESS_WEB_URL)
512                                 .setEmergencyAddressWebData(EMERGENCY_ADDRESS_WEB_DATA)
513                                 .build());
514         buildActivity(ActivityConstants.LAUNCH_APP_UPDATE);
515 
516         mWfcActivationController.evaluateEntitlementStatus();
517         mTestLooperManager.execute(mTestLooperManager.next());
518 
519         verify(mMockActivationUi).showWebview(EMERGENCY_ADDRESS_WEB_URL,
520                 EMERGENCY_ADDRESS_WEB_DATA);
521     }
522 
523     @Test
handleEntitlementStatusForUpdate_showTc_showWebview()524     public void handleEntitlementStatusForUpdate_showTc_showWebview() {
525         when(mMockActivationApi.checkEntitlementStatus())
526                 .thenReturn(
527                         EntitlementResult.builder(false)
528                                 .setVowifiStatus(
529                                         Ts43VowifiStatus.builder()
530                                                 .setEntitlementStatus(EntitlementStatus.ENABLED)
531                                                 .setProvStatus(ProvStatus.PROVISIONED)
532                                                 .setTcStatus(TcStatus.AVAILABLE)
533                                                 .setAddrStatus(AddrStatus.AVAILABLE)
534                                                 .build())
535                                 .setTermsAndConditionsWebUrl(EMERGENCY_ADDRESS_WEB_URL)
536                                 .build());
537         buildActivity(ActivityConstants.LAUNCH_APP_SHOW_TC);
538 
539         mWfcActivationController.evaluateEntitlementStatus();
540         mTestLooperManager.execute(mTestLooperManager.next());
541 
542         verify(mMockActivationUi).showWebview(EMERGENCY_ADDRESS_WEB_URL, null);
543     }
544 
545     @Test
handleEntitlementStatusForUpdate_entitlementStatusIncompatible_showErrorUi()546     public void handleEntitlementStatusForUpdate_entitlementStatusIncompatible_showErrorUi() {
547         EntitlementResult entitlementResult =
548                 EntitlementResult.builder(false)
549                         .setVowifiStatus(
550                                 Ts43VowifiStatus.builder()
551                                         .setEntitlementStatus(EntitlementStatus.INCOMPATIBLE)
552                                         .build())
553                         .build();
554         when(mMockActivationApi.checkEntitlementStatus()).thenReturn(entitlementResult);
555         buildActivity(ActivityConstants.LAUNCH_APP_UPDATE);
556 
557         mWfcActivationController.evaluateEntitlementStatus();
558         mTestLooperManager.execute(mTestLooperManager.next());
559 
560         verifyErrorUi(R.string.e911_title, R.string.failure_contact_carrier);
561     }
562 
563     @Test
handleEntitlementStatusForUpdate_entitlementStatusDisabled_showGenericErrorUi()564     public void handleEntitlementStatusForUpdate_entitlementStatusDisabled_showGenericErrorUi() {
565         EntitlementResult entitlementResult =
566                 EntitlementResult.builder(false)
567                         .setVowifiStatus(
568                                 Ts43VowifiStatus.builder()
569                                         .setEntitlementStatus(EntitlementStatus.DISABLED)
570                                         .build())
571                         .build();
572         when(mMockActivationApi.checkEntitlementStatus()).thenReturn(entitlementResult);
573         buildActivity(ActivityConstants.LAUNCH_APP_UPDATE);
574 
575         mWfcActivationController.evaluateEntitlementStatus();
576         mTestLooperManager.execute(mTestLooperManager.next());
577 
578         verifyErrorUi(R.string.e911_title, R.string.address_update_error);
579     }
580 
buildActivity(int extraLaunchCarrierApp)581     private void buildActivity(int extraLaunchCarrierApp) {
582         Intent intent = new Intent(Intent.ACTION_MAIN);
583         intent.putExtra(SubscriptionManager.EXTRA_SUBSCRIPTION_INDEX, SUB_ID);
584         intent.putExtra(ActivityConstants.EXTRA_LAUNCH_CARRIER_APP, extraLaunchCarrierApp);
585         mWfcActivationController =
586                 new WfcActivationController(
587                         mContext,
588                         mMockActivationUi,
589                         mMockActivationApi,
590                         intent,
591                         mMockImsUtils,
592                         mMockMetricsLogger,
593                         mUiHandler);
594     }
595 
setNetworkConnected(boolean isConnected)596     private void setNetworkConnected(boolean isConnected) {
597         when(mMockNetworkInfo.isConnected()).thenReturn(isConnected);
598         when(mContext.getSystemService(Context.CONNECTIVITY_SERVICE)).thenReturn(
599                 mMockConnectivityManager);
600         when(mMockConnectivityManager.getActiveNetworkInfo()).thenReturn(mMockNetworkInfo);
601         when(mMockNetworkInfo.isConnected()).thenReturn(isConnected);
602     }
603 
verifyErrorUi(int title, int errorMesssage)604     private void verifyErrorUi(int title, int errorMesssage) {
605         verify(mMockActivationUi)
606                 .showActivationUi(
607                         title,
608                         errorMesssage,
609                         false, R.string.ok,
610                         WfcActivationUi.RESULT_FAILURE,
611                         0);
612     }
613 
verifyErrorUiInOrder(InOrder inOrder, int title, int errorMesssage)614     private void verifyErrorUiInOrder(InOrder inOrder, int title, int errorMesssage) {
615         inOrder.verify(mMockActivationUi)
616                 .showActivationUi(
617                         title,
618                         errorMesssage,
619                         false, R.string.ok,
620                         WfcActivationUi.RESULT_FAILURE,
621                         0);
622     }
623 
verifyGeneralWaitingUiInOrder(InOrder inOrder, int title)624     private void verifyGeneralWaitingUiInOrder(InOrder inOrder, int title) {
625         inOrder.verify(mMockActivationUi)
626                 .showActivationUi(title, R.string.progress_text, true, 0, 0, 0);
627     }
628 
setIsSkipWfcActivation(boolean isSkip)629     private void setIsSkipWfcActivation(boolean isSkip) {
630         initializeCarrierConfig();
631         mCarrierConfig.putBoolean(KEY_SKIP_WFC_ACTIVATION_BOOL, isSkip);
632     }
633 
initializeCarrierConfig()634     private void initializeCarrierConfig() {
635         if (mCarrierConfig == null) {
636             mCarrierConfig = new PersistableBundle();
637             when(mMockCarrierConfigManager.getConfigForSubId(SUB_ID)).thenReturn(mCarrierConfig);
638         }
639     }
640 }
641