1 /*
2  * Copyright 2016, 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;
20 
21 import static org.mockito.Matchers.anyInt;
22 import static org.mockito.Matchers.eq;
23 import static org.mockito.Mockito.verify;
24 
25 import android.content.ComponentName;
26 
27 import androidx.test.filters.SmallTest;
28 
29 import com.android.managedprovisioning.R;
30 import com.android.managedprovisioning.common.Utils;
31 import com.android.managedprovisioning.model.PackageDownloadInfo;
32 import com.android.managedprovisioning.model.ProvisioningParams;
33 import com.android.managedprovisioning.model.WifiInfo;
34 import com.android.managedprovisioning.task.AbstractProvisioningTask;
35 import com.android.managedprovisioning.task.AddWifiNetworkTask;
36 import com.android.managedprovisioning.task.ConnectMobileNetworkTask;
37 import com.android.managedprovisioning.task.DownloadPackageTask;
38 import com.android.managedprovisioning.task.ProvisionFullyManagedDeviceTask;
39 import com.android.managedprovisioning.task.VerifyPackageTask;
40 
41 import org.mockito.Mock;
42 
43 /**
44  * Unit tests for {@link DeviceOwnerProvisioningController}.
45  */
46 public class DeviceOwnerProvisioningControllerTest extends ProvisioningControllerBaseTest {
47 
48     private static final int TEST_USER_ID = 123;
49     private static final ComponentName TEST_ADMIN = new ComponentName("com.test.admin",
50             "com.test.admin.AdminReceiver");
51 
52     private static final String TEST_SSID = "SomeSsid";
53     private static final WifiInfo TEST_WIFI_INFO = new WifiInfo.Builder()
54             .setSsid(TEST_SSID)
55             .build();
56 
57     private static final String TEST_DOWNLOAD_LOCATION = "http://www.some.uri.com";
58     private static final byte[] TEST_PACKAGE_CHECKSUM = new byte[] { '1', '2', '3', '4', '5' };
59     private static final PackageDownloadInfo TEST_DOWNLOAD_INFO = new PackageDownloadInfo.Builder()
60             .setLocation(TEST_DOWNLOAD_LOCATION)
61             .setSignatureChecksum(TEST_PACKAGE_CHECKSUM)
62             .build();
63 
64     @Mock
65     private ProvisioningControllerCallback mCallback;
66 
67     @Mock
68     private Utils mUtils;
69 
70     @SmallTest
testRunAllTasks()71     public void testRunAllTasks() throws Exception {
72         // GIVEN device owner provisioning was invoked with a wifi and download info
73         createController(createProvisioningParamsBuilder().build());
74 
75         // WHEN starting the test run
76         mController.start(mHandler);
77 
78         // THEN the add wifi task should be run
79         taskSucceeded(AddWifiNetworkTask.class);
80 
81         // THEN the download package task should be run
82         taskSucceeded(DownloadPackageTask.class);
83 
84         // THEN the verify package task should be run
85         taskSucceeded(VerifyPackageTask.class);
86 
87         // THEN the install package tasks should be run
88         tasksDownloadAndInstallDeviceOwnerPackageSucceeded(TEST_USER_ID);
89 
90         // THEN the provisioning task should be run
91         taskSucceeded(ProvisionFullyManagedDeviceTask.class);
92 
93         // THEN the provisioning complete callback should have happened
94         verify(mCallback).provisioningTasksCompleted();
95     }
96 
97     @SmallTest
testNoWifiInfo()98     public void testNoWifiInfo() throws Exception {
99         // GIVEN device owner provisioning was invoked with a wifi and download info
100         createController(createProvisioningParamsBuilder().setWifiInfo(null).build());
101 
102         // WHEN starting the test run
103         mController.start(mHandler);
104 
105         // THEN the download package task should be run
106         taskSucceeded(DownloadPackageTask.class);
107 
108         // THEN the verify package task should be run
109         taskSucceeded(VerifyPackageTask.class);
110 
111         // THEN the install package tasks should be run
112         tasksDownloadAndInstallDeviceOwnerPackageSucceeded(TEST_USER_ID);
113 
114         // THEN the provisioning task should be run
115         taskSucceeded(ProvisionFullyManagedDeviceTask.class);
116 
117         // THEN the provisioning complete callback should have happened
118         verify(mCallback).provisioningTasksCompleted();
119     }
120 
121     @SmallTest
testNoDownloadInfo()122     public void testNoDownloadInfo() throws Exception {
123         // GIVEN device owner provisioning was invoked with a wifi and download info
124         createController(
125                 createProvisioningParamsBuilder().setDeviceAdminDownloadInfo(null).build());
126 
127         // WHEN starting the test run
128         mController.start(mHandler);
129 
130         // THEN the add wifi task should be run
131         taskSucceeded(AddWifiNetworkTask.class);
132 
133         // THEN the provisioning task should be run
134         taskSucceeded(ProvisionFullyManagedDeviceTask.class);
135 
136         // THEN the provisioning complete callback should have happened
137         verify(mCallback).provisioningTasksCompleted();
138     }
139 
140     @SmallTest
testErrorAddWifiTask()141     public void testErrorAddWifiTask() throws Exception {
142         // GIVEN device owner provisioning was invoked with a wifi and download info
143         createController(createProvisioningParamsBuilder().build());
144 
145         // WHEN starting the test run
146         mController.start(mHandler);
147 
148         // THEN the add wifi task should be run
149         AbstractProvisioningTask task = verifyTaskRun(AddWifiNetworkTask.class);
150 
151         // WHEN the task causes an error
152         mController.onError(task, 0);
153 
154         // THEN the onError callback should have been called without factory reset being required
155         verify(mCallback).error(eq(R.string.cant_set_up_device), anyInt(), eq(false));
156     }
157 
158     @SmallTest
testErrorDownloadAppTask()159     public void testErrorDownloadAppTask() throws Exception {
160         // GIVEN device owner provisioning was invoked with a wifi and download info
161         createController(createProvisioningParamsBuilder().build());
162 
163         // WHEN starting the test run
164         mController.start(mHandler);
165 
166         // THEN the add wifi task should be run
167         taskSucceeded(AddWifiNetworkTask.class);
168 
169         // THEN the download package task should be run
170         AbstractProvisioningTask task = verifyTaskRun(DownloadPackageTask.class);
171 
172         // WHEN the task causes an error
173         mController.onError(task, 0);
174 
175         // THEN the onError callback should have been called with factory reset being required
176         verify(mCallback).error(anyInt(), anyInt(), eq(true));
177     }
178 
179     @SmallTest
testStart_useMobileDataTrueAndNoWifiInfo_runsConnectMobileNetworkTask()180     public void testStart_useMobileDataTrueAndNoWifiInfo_runsConnectMobileNetworkTask()
181             throws Exception {
182         createController(
183                 createProvisioningParamsBuilder().setWifiInfo(null).setUseMobileData(true).build());
184         mController.start(mHandler);
185         taskSucceeded(ConnectMobileNetworkTask.class);
186     }
187 
188     @SmallTest
testStart_useMobileDataTrueAndWifiInfo_runsAddWifiNetworkTask()189     public void testStart_useMobileDataTrueAndWifiInfo_runsAddWifiNetworkTask()
190             throws Exception {
191         createController(
192                 createProvisioningParamsBuilder()
193                         .setWifiInfo(TEST_WIFI_INFO)
194                         .setUseMobileData(true)
195                         .build());
196         mController.start(mHandler);
197         taskSucceeded(AddWifiNetworkTask.class);
198     }
199 
createController(ProvisioningParams params)200     private void createController(ProvisioningParams params) {
201         mController = DeviceOwnerProvisioningController.createInstance(
202                 getContext(),
203                 params,
204                 TEST_USER_ID,
205                 mCallback,
206                 mUtils);
207     }
208 
createProvisioningParamsBuilder()209     private ProvisioningParams.Builder createProvisioningParamsBuilder() {
210         return new ProvisioningParams.Builder()
211                 .setDeviceAdminComponentName(TEST_ADMIN)
212                 .setProvisioningAction(ACTION_PROVISION_MANAGED_DEVICE)
213                 .setWifiInfo(TEST_WIFI_INFO)
214                 .setDeviceAdminDownloadInfo(TEST_DOWNLOAD_INFO);
215     }
216 }
217