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.managedprovisioning.provisioning;
18 
19 import static android.app.admin.DevicePolicyManager.ACTION_PROVISION_MANAGED_DEVICE_FROM_TRUSTED_SOURCE;
20 import static android.app.admin.DevicePolicyManager.FLAG_SUPPORTED_MODES_ORGANIZATION_OWNED;
21 
22 import static com.google.common.truth.Truth.assertThat;
23 
24 import static org.mockito.ArgumentMatchers.anyInt;
25 import static org.mockito.ArgumentMatchers.eq;
26 import static org.mockito.Mockito.verify;
27 import static org.mockito.Mockito.when;
28 
29 import android.content.ComponentName;
30 import android.content.Context;
31 import android.os.Handler;
32 import android.os.HandlerThread;
33 import android.os.UserHandle;
34 
35 import androidx.test.InstrumentationRegistry;
36 import androidx.test.filters.SmallTest;
37 
38 import com.android.managedprovisioning.common.SettingsFacade;
39 import com.android.managedprovisioning.common.Utils;
40 import com.android.managedprovisioning.model.ProvisioningParams;
41 import com.android.managedprovisioning.task.AbstractProvisioningTask;
42 import com.android.managedprovisioning.task.AddWifiNetworkTask;
43 import com.android.managedprovisioning.task.CreateAndProvisionManagedProfileTask;
44 
45 import org.junit.After;
46 import org.junit.Before;
47 import org.junit.Test;
48 import org.junit.runner.RunWith;
49 import org.junit.runners.JUnit4;
50 import org.mockito.Mock;
51 import org.mockito.MockitoAnnotations;
52 
53 @SmallTest
54 @RunWith(JUnit4.class)
55 public final class AdminIntegratedFlowPrepareControllerTest {
56     private static final String ADMIN_PACKAGE = "com.test.admin";
57     private static final ComponentName ADMIN = new ComponentName(ADMIN_PACKAGE, ".Receiver");
58     private static final ProvisioningParams ORG_OWNED_PARAMS = new ProvisioningParams.Builder()
59             .setProvisioningAction(ACTION_PROVISION_MANAGED_DEVICE_FROM_TRUSTED_SOURCE)
60             .setDeviceAdminComponentName(ADMIN)
61             .setInitiatorRequestedProvisioningModes(FLAG_SUPPORTED_MODES_ORGANIZATION_OWNED)
62             .build();
63     private static final ProvisioningParams PERSONALLY_OWNED_PARAMS =
64             new ProvisioningParams.Builder()
65                     .setProvisioningAction(ACTION_PROVISION_MANAGED_DEVICE_FROM_TRUSTED_SOURCE)
66                     .setDeviceAdminComponentName(ADMIN)
67                     .build();
68     private static final ProvisioningParams PARAMS = PERSONALLY_OWNED_PARAMS;
69     private static final int USER_ID = UserHandle.USER_SYSTEM;
70     private static final Utils mUtils = new Utils();
71     private static final int ERROR_CODE = 0;
72     private static final String TEST_ERROR_MESSAGE = "test error message";
73 
74     private final Context mContext = InstrumentationRegistry.getTargetContext();
75     @Mock
76     private SettingsFacade mSettingsFacade;
77     private final AbstractProvisioningTask mTask =
78             new CreateAndProvisionManagedProfileTask(
79                     mContext, PARAMS, createProvisioningTaskCallback());
80     private final AddWifiNetworkTask mWifiTask =
81             new AddWifiNetworkTask(mContext, PARAMS, createProvisioningTaskCallback());
82     private String mErrorMessage;
83     private HandlerThread mHandlerThread;
84     private Handler mHandler;
85 
86     @Before
setUp()87     public void setUp() {
88         MockitoAnnotations.initMocks(this);
89 
90         mHandlerThread = new HandlerThread("TestHandler");
91         mHandlerThread.start();
92         mHandler = new Handler(mHandlerThread.getLooper());
93     }
94 
95     @After
tearDown()96     public void tearDown() {
97         mHandlerThread.quitSafely();
98     }
99 
100     @Test
getRequireFactoryReset_deviceProvisioned_returnsFalse()101     public void getRequireFactoryReset_deviceProvisioned_returnsFalse() {
102         AdminIntegratedFlowPrepareController mController =
103                 createController(PARAMS, /* isDeviceProvisioned= */ true);
104 
105         assertThat(mController.getRequireFactoryReset(mTask, ERROR_CODE)).isFalse();
106     }
107 
108     @Test
getRequireFactoryReset_isPersonallyOwned_returnsFalse()109     public void getRequireFactoryReset_isPersonallyOwned_returnsFalse() {
110         AdminIntegratedFlowPrepareController mController =
111                 createController(PERSONALLY_OWNED_PARAMS);
112 
113         assertThat(mController.getRequireFactoryReset(mTask, ERROR_CODE)).isFalse();
114     }
115 
116     @Test
getRequireFactoryReset_isWifiNetworkTask_returnsFalse()117     public void getRequireFactoryReset_isWifiNetworkTask_returnsFalse() {
118         AdminIntegratedFlowPrepareController mController = createController(ORG_OWNED_PARAMS);
119 
120         assertThat(mController.getRequireFactoryReset(mWifiTask, ERROR_CODE)).isFalse();
121     }
122 
123     @Test
getRequireFactoryReset_works()124     public void getRequireFactoryReset_works() {
125         AdminIntegratedFlowPrepareController controller = createController(ORG_OWNED_PARAMS);
126 
127         assertThat(controller.getRequireFactoryReset(mTask, ERROR_CODE)).isTrue();
128     }
129 
130     @Test
testErrorWithStringMessage()131     public void testErrorWithStringMessage() {
132         AdminIntegratedFlowPrepareController controller = createController(PARAMS);
133         controller.start(mHandler);
134 
135         controller.onError(mTask, /* errorCode= */ 0, TEST_ERROR_MESSAGE);
136 
137         assertThat(mErrorMessage).isEqualTo(TEST_ERROR_MESSAGE);
138     }
139 
createController( ProvisioningParams params)140     private AdminIntegratedFlowPrepareController createController(
141             ProvisioningParams params) {
142         return createController(params, /* isDeviceProvisioned= */ false);
143     }
144 
createController( ProvisioningParams params, boolean isDeviceProvisioned)145     private AdminIntegratedFlowPrepareController createController(
146             ProvisioningParams params,
147             boolean isDeviceProvisioned) {
148         AdminIntegratedFlowPrepareController mController =
149                 AdminIntegratedFlowPrepareController.createInstance(
150                         mContext,
151                         params,
152                         USER_ID,
153                         createProvisioningControllerCallback(),
154                         mUtils,
155                         mSettingsFacade);
156         when(mSettingsFacade.isDeviceProvisioned(mContext)).thenReturn(isDeviceProvisioned);
157         return mController;
158     }
159 
createProvisioningControllerCallback()160     private ProvisioningControllerCallback createProvisioningControllerCallback() {
161         return new ProvisioningControllerCallback() {
162             @Override
163             public void cleanUpCompleted() {}
164 
165             @Override
166             public void provisioningTasksCompleted() {}
167 
168             @Override
169             public void error(int dialogTitleId, int errorMessageId,
170                     boolean factoryResetRequired) {}
171 
172             @Override
173             public void error(int dialogTitleId, String errorMessage,
174                     boolean factoryResetRequired) {
175                 mErrorMessage = errorMessage;
176             }
177 
178             @Override
179             public void preFinalizationCompleted() {}
180         };
181     }
182 
183     private AbstractProvisioningTask.Callback createProvisioningTaskCallback() {
184         return new AbstractProvisioningTask.Callback() {
185             @Override
186             public void onSuccess(AbstractProvisioningTask task) {}
187 
188             @Override
189             public void onError(
190                     AbstractProvisioningTask task, int errorCode, String errorMessage) {}
191         };
192     }
193 }
194