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.Mockito.when;
25 
26 import android.content.ComponentName;
27 import android.content.Context;
28 import android.os.UserHandle;
29 
30 import androidx.test.InstrumentationRegistry;
31 import androidx.test.filters.SmallTest;
32 
33 import com.android.managedprovisioning.common.SettingsFacade;
34 import com.android.managedprovisioning.common.Utils;
35 import com.android.managedprovisioning.model.ProvisioningParams;
36 import com.android.managedprovisioning.task.AbstractProvisioningTask;
37 import com.android.managedprovisioning.task.AddWifiNetworkTask;
38 import com.android.managedprovisioning.task.CreateAndProvisionManagedProfileTask;
39 
40 import org.junit.Before;
41 import org.junit.Test;
42 import org.junit.runner.RunWith;
43 import org.junit.runners.JUnit4;
44 import org.mockito.Mock;
45 import org.mockito.MockitoAnnotations;
46 
47 @SmallTest
48 @RunWith(JUnit4.class)
49 public final class AdminIntegratedFlowPrepareControllerTest {
50     private static final String ADMIN_PACKAGE = "com.test.admin";
51     private static final ComponentName ADMIN = new ComponentName(ADMIN_PACKAGE, ".Receiver");
52     private static final ProvisioningParams ORG_OWNED_PARAMS = new ProvisioningParams.Builder()
53             .setProvisioningAction(ACTION_PROVISION_MANAGED_DEVICE_FROM_TRUSTED_SOURCE)
54             .setDeviceAdminComponentName(ADMIN)
55             .setInitiatorRequestedProvisioningModes(FLAG_SUPPORTED_MODES_ORGANIZATION_OWNED)
56             .build();
57     private static final ProvisioningParams PERSONALLY_OWNED_PARAMS =
58             new ProvisioningParams.Builder()
59                     .setProvisioningAction(ACTION_PROVISION_MANAGED_DEVICE_FROM_TRUSTED_SOURCE)
60                     .setDeviceAdminComponentName(ADMIN)
61                     .build();
62     private static final ProvisioningParams PARAMS = PERSONALLY_OWNED_PARAMS;
63     private static final int USER_ID = UserHandle.USER_SYSTEM;
64     private static final Utils mUtils = new Utils();
65     private static final int ERROR_CODE = 0;
66 
67     private final Context mContext = InstrumentationRegistry.getTargetContext();
68     @Mock
69     private SettingsFacade mSettingsFacade;
70     private final AbstractProvisioningTask mTask =
71             new CreateAndProvisionManagedProfileTask(
72                     mContext, PARAMS, createProvisioningTaskCallback());
73     private final AddWifiNetworkTask mWifiTask =
74             new AddWifiNetworkTask(mContext, PARAMS, createProvisioningTaskCallback());
75 
76     @Before
setUp()77     public void setUp() {
78         MockitoAnnotations.initMocks(this);
79     }
80 
81     @Test
getRequireFactoryReset_deviceProvisioned_returnsFalse()82     public void getRequireFactoryReset_deviceProvisioned_returnsFalse() {
83         AdminIntegratedFlowPrepareController mController =
84                 createController(PARAMS, /* isDeviceProvisioned= */ true);
85 
86         assertThat(mController.getRequireFactoryReset(mTask, ERROR_CODE)).isFalse();
87     }
88 
89     @Test
getRequireFactoryReset_isPersonallyOwned_returnsFalse()90     public void getRequireFactoryReset_isPersonallyOwned_returnsFalse() {
91         AdminIntegratedFlowPrepareController mController =
92                 createController(PERSONALLY_OWNED_PARAMS);
93 
94         assertThat(mController.getRequireFactoryReset(mTask, ERROR_CODE)).isFalse();
95     }
96 
97     @Test
getRequireFactoryReset_isWifiNetworkTask_returnsFalse()98     public void getRequireFactoryReset_isWifiNetworkTask_returnsFalse() {
99         AdminIntegratedFlowPrepareController mController = createController(ORG_OWNED_PARAMS);
100 
101         assertThat(mController.getRequireFactoryReset(mWifiTask, ERROR_CODE)).isFalse();
102     }
103 
104     @Test
getRequireFactoryReset_works()105     public void getRequireFactoryReset_works() {
106         AdminIntegratedFlowPrepareController mController = createController(ORG_OWNED_PARAMS);
107 
108         assertThat(mController.getRequireFactoryReset(mTask, ERROR_CODE)).isTrue();
109     }
110 
createController( ProvisioningParams params)111     private AdminIntegratedFlowPrepareController createController(
112             ProvisioningParams params) {
113         return createController(params, /* isDeviceProvisioned= */ false);
114     }
115 
createController( ProvisioningParams params, boolean isDeviceProvisioned)116     private AdminIntegratedFlowPrepareController createController(
117             ProvisioningParams params,
118             boolean isDeviceProvisioned) {
119         AdminIntegratedFlowPrepareController mController =
120                 AdminIntegratedFlowPrepareController.createInstance(
121                         mContext,
122                         params,
123                         USER_ID,
124                         createProvisioningControllerCallback(),
125                         mUtils,
126                         mSettingsFacade);
127         when(mSettingsFacade.isDeviceProvisioned(mContext)).thenReturn(isDeviceProvisioned);
128         return mController;
129     }
130 
createProvisioningControllerCallback()131     private ProvisioningControllerCallback createProvisioningControllerCallback() {
132         return new ProvisioningControllerCallback() {
133             @Override
134             public void cleanUpCompleted() {}
135 
136             @Override
137             public void provisioningTasksCompleted() {}
138 
139             @Override
140             public void error(int dialogTitleId, int errorMessageId,
141                     boolean factoryResetRequired) {}
142 
143             @Override
144             public void preFinalizationCompleted() {}
145         };
146     }
147 
createProvisioningTaskCallback()148     private AbstractProvisioningTask.Callback createProvisioningTaskCallback() {
149         return new AbstractProvisioningTask.Callback() {
150             @Override
151             public void onSuccess(AbstractProvisioningTask task) {}
152 
153             @Override
154             public void onError(AbstractProvisioningTask task, int errorCode) {}
155         };
156     }
157 }
158