OLD | NEW |
(Empty) | |
| 1 // Copyright 2017 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 package org.chromium.components.background_task_scheduler; |
| 6 |
| 7 import static org.junit.Assert.assertEquals; |
| 8 import static org.junit.Assert.assertFalse; |
| 9 import static org.junit.Assert.assertNotNull; |
| 10 import static org.junit.Assert.assertNull; |
| 11 import static org.junit.Assert.assertTrue; |
| 12 |
| 13 import android.os.Bundle; |
| 14 |
| 15 import com.google.android.gms.common.ConnectionResult; |
| 16 import com.google.android.gms.common.GoogleApiAvailability; |
| 17 import com.google.android.gms.gcm.GcmNetworkManager; |
| 18 import com.google.android.gms.gcm.OneoffTask; |
| 19 import com.google.android.gms.gcm.PeriodicTask; |
| 20 import com.google.android.gms.gcm.Task; |
| 21 import com.google.android.gms.gcm.TaskParams; |
| 22 |
| 23 import org.junit.Before; |
| 24 import org.junit.Test; |
| 25 import org.junit.runner.RunWith; |
| 26 import org.robolectric.RuntimeEnvironment; |
| 27 import org.robolectric.annotation.Config; |
| 28 import org.robolectric.internal.ShadowExtractor; |
| 29 import org.robolectric.shadows.gms.Shadows; |
| 30 import org.robolectric.shadows.gms.common.ShadowGoogleApiAvailability; |
| 31 |
| 32 import org.chromium.base.ContextUtils; |
| 33 import org.chromium.base.test.util.Feature; |
| 34 import org.chromium.testing.local.LocalRobolectricTestRunner; |
| 35 |
| 36 import java.util.concurrent.TimeUnit; |
| 37 |
| 38 /** Unit tests for {@link BackgroundTaskSchedulerGcmNetworkManager}. */ |
| 39 @RunWith(LocalRobolectricTestRunner.class) |
| 40 @Config(manifest = Config.NONE, |
| 41 shadows = {ShadowGcmNetworkManager.class, ShadowGoogleApiAvailability.cl
ass}) |
| 42 public class BackgroundTaskSchedulerGcmNetworkManagerTest { |
| 43 private static class TestBackgroundTaskNoPublicConstructor extends TestBackg
roundTask { |
| 44 protected TestBackgroundTaskNoPublicConstructor() {} |
| 45 } |
| 46 |
| 47 ShadowGcmNetworkManager mGcmNetworkManager; |
| 48 |
| 49 @Before |
| 50 public void setUp() { |
| 51 ContextUtils.initApplicationContextForTests(RuntimeEnvironment.applicati
on); |
| 52 |
| 53 Shadows.shadowOf(GoogleApiAvailability.getInstance()) |
| 54 .setIsGooglePlayServicesAvailable(ConnectionResult.SUCCESS); |
| 55 mGcmNetworkManager = (ShadowGcmNetworkManager) ShadowExtractor.extract( |
| 56 GcmNetworkManager.getInstance(ContextUtils.getApplicationContext
())); |
| 57 } |
| 58 |
| 59 @Test |
| 60 @Feature({"BackgroundTaskScheduler"}) |
| 61 public void testOneOffTaskInfoWithDeadlineConversion() { |
| 62 TaskInfo oneOffTask = TaskInfo.createOneOffTask(TaskIds.TEST, TestBackgr
oundTask.class, |
| 63 TimeUnit.MINUTES.toMillis(200)) |
| 64 .build(); |
| 65 Task task = BackgroundTaskSchedulerGcmNetworkManager.createTaskFromTaskI
nfo(oneOffTask); |
| 66 assertTrue(task instanceof OneoffTask); |
| 67 assertEquals(Integer.toString(oneOffTask.getTaskId()), task.getTag()); |
| 68 assertEquals( |
| 69 TimeUnit.MILLISECONDS.toSeconds(oneOffTask.getOneOffInfo().getWi
ndowEndTimeMs()), |
| 70 ((OneoffTask) task).getWindowEnd()); |
| 71 assertEquals(0, ((OneoffTask) task).getWindowStart()); |
| 72 } |
| 73 |
| 74 @Test |
| 75 @Feature({"BackgroundTaskScheduler"}) |
| 76 public void testOneOffTaskInfoWithWindowConversion() { |
| 77 TaskInfo oneOffTask = |
| 78 TaskInfo.createOneOffTask(TaskIds.TEST, TestBackgroundTask.class
, |
| 79 TimeUnit.MINUTES.toMillis(100), TimeUnit.MINUTES
.toMillis(200)) |
| 80 .build(); |
| 81 Task task = BackgroundTaskSchedulerGcmNetworkManager.createTaskFromTaskI
nfo(oneOffTask); |
| 82 assertTrue(task instanceof OneoffTask); |
| 83 assertEquals(Integer.toString(oneOffTask.getTaskId()), task.getTag()); |
| 84 assertEquals( |
| 85 TimeUnit.MILLISECONDS.toSeconds(oneOffTask.getOneOffInfo().getWi
ndowEndTimeMs()), |
| 86 ((OneoffTask) task).getWindowEnd()); |
| 87 assertEquals( |
| 88 TimeUnit.MILLISECONDS.toSeconds(oneOffTask.getOneOffInfo().getWi
ndowStartTimeMs()), |
| 89 ((OneoffTask) task).getWindowStart()); |
| 90 } |
| 91 |
| 92 @Test |
| 93 @Feature({"BackgroundTaskScheduler"}) |
| 94 public void testPeriodicTaskInfoWithoutFlexConversion() { |
| 95 TaskInfo periodicTask = TaskInfo.createPeriodicTask(TaskIds.TEST, TestBa
ckgroundTask.class, |
| 96 TimeUnit.MINUTES.toMillis(200)) |
| 97 .build(); |
| 98 Task task = BackgroundTaskSchedulerGcmNetworkManager.createTaskFromTaskI
nfo(periodicTask); |
| 99 assertEquals(Integer.toString(periodicTask.getTaskId()), task.getTag()); |
| 100 assertTrue(task instanceof PeriodicTask); |
| 101 assertEquals( |
| 102 TimeUnit.MILLISECONDS.toSeconds(periodicTask.getPeriodicInfo().g
etIntervalMs()), |
| 103 ((PeriodicTask) task).getPeriod()); |
| 104 } |
| 105 |
| 106 @Test |
| 107 @Feature({"BackgroundTaskScheduler"}) |
| 108 public void testPeriodicTaskInfoWithFlexConversion() { |
| 109 TaskInfo periodicTask = |
| 110 TaskInfo.createPeriodicTask(TaskIds.TEST, TestBackgroundTask.cla
ss, |
| 111 TimeUnit.MINUTES.toMillis(200), TimeUnit.MINUTES
.toMillis(50)) |
| 112 .build(); |
| 113 Task task = BackgroundTaskSchedulerGcmNetworkManager.createTaskFromTaskI
nfo(periodicTask); |
| 114 assertEquals(Integer.toString(periodicTask.getTaskId()), task.getTag()); |
| 115 assertTrue(task instanceof PeriodicTask); |
| 116 assertEquals( |
| 117 TimeUnit.MILLISECONDS.toSeconds(periodicTask.getPeriodicInfo().g
etIntervalMs()), |
| 118 ((PeriodicTask) task).getPeriod()); |
| 119 assertEquals(TimeUnit.MILLISECONDS.toSeconds(periodicTask.getPeriodicInf
o().getFlexMs()), |
| 120 ((PeriodicTask) task).getFlex()); |
| 121 } |
| 122 |
| 123 @Test |
| 124 @Feature({"BackgroundTaskScheduler"}) |
| 125 public void testTaskInfoWithExtras() { |
| 126 Bundle userExtras = new Bundle(); |
| 127 userExtras.putString("foo", "bar"); |
| 128 userExtras.putBoolean("bools", true); |
| 129 userExtras.putLong("longs", 1342543L); |
| 130 TaskInfo oneOffTask = TaskInfo.createOneOffTask(TaskIds.TEST, TestBackgr
oundTask.class, |
| 131 TimeUnit.MINUTES.toMillis(200)) |
| 132 .setExtras(userExtras) |
| 133 .build(); |
| 134 Task task = BackgroundTaskSchedulerGcmNetworkManager.createTaskFromTaskI
nfo(oneOffTask); |
| 135 assertEquals(Integer.toString(oneOffTask.getTaskId()), task.getTag()); |
| 136 assertTrue(task instanceof OneoffTask); |
| 137 |
| 138 Bundle taskExtras = task.getExtras(); |
| 139 Bundle bundle = taskExtras.getBundle( |
| 140 BackgroundTaskSchedulerGcmNetworkManager.BACKGROUND_TASK_EXTRAS_
KEY); |
| 141 assertEquals(userExtras.keySet().size(), bundle.keySet().size()); |
| 142 assertEquals(userExtras.getString("foo"), bundle.getString("foo")); |
| 143 assertEquals(userExtras.getBoolean("bools"), bundle.getBoolean("bools"))
; |
| 144 assertEquals(userExtras.getLong("longs"), bundle.getLong("longs")); |
| 145 } |
| 146 |
| 147 @Test |
| 148 @Feature({"BackgroundTaskScheduler"}) |
| 149 public void testTaskInfoWithManyConstraints() { |
| 150 TaskInfo.Builder taskBuilder = TaskInfo.createOneOffTask( |
| 151 TaskIds.TEST, TestBackgroundTask.class, TimeUnit.MINUTES.toMilli
s(200)); |
| 152 |
| 153 Task task = BackgroundTaskSchedulerGcmNetworkManager.createTaskFromTaskI
nfo( |
| 154 taskBuilder.setIsPersisted(true).build()); |
| 155 assertTrue(task.isPersisted()); |
| 156 |
| 157 task = BackgroundTaskSchedulerGcmNetworkManager.createTaskFromTaskInfo( |
| 158 taskBuilder.setRequiredNetworkType(TaskInfo.NETWORK_TYPE_UNMETER
ED).build()); |
| 159 assertEquals(Task.NETWORK_STATE_UNMETERED, task.getRequiredNetwork()); |
| 160 |
| 161 task = BackgroundTaskSchedulerGcmNetworkManager.createTaskFromTaskInfo( |
| 162 taskBuilder.setRequiresCharging(true).build()); |
| 163 assertTrue(task.getRequiresCharging()); |
| 164 } |
| 165 |
| 166 @Test |
| 167 @Feature({"BackgroundTaskScheduler"}) |
| 168 public void testGetTaskParametersFromTaskParams() { |
| 169 Bundle extras = new Bundle(); |
| 170 Bundle taskExtras = new Bundle(); |
| 171 taskExtras.putString("foo", "bar"); |
| 172 extras.putBundle( |
| 173 BackgroundTaskSchedulerGcmNetworkManager.BACKGROUND_TASK_EXTRAS_
KEY, taskExtras); |
| 174 |
| 175 TaskParams params = new TaskParams(Integer.toString(TaskIds.TEST), extra
s); |
| 176 |
| 177 TaskParameters parameters = |
| 178 BackgroundTaskSchedulerGcmNetworkManager.getTaskParametersFromTa
skParams(params); |
| 179 assertEquals(parameters.getTaskId(), TaskIds.TEST); |
| 180 assertEquals(parameters.getExtras().getString("foo"), "bar"); |
| 181 } |
| 182 |
| 183 @Test |
| 184 @Feature({"BackgroundTaskScheduler"}) |
| 185 public void testGetBackgroundTaskFromTaskParams() { |
| 186 Bundle extras = new Bundle(); |
| 187 extras.putString(BackgroundTaskSchedulerGcmNetworkManager.BACKGROUND_TAS
K_CLASS_KEY, |
| 188 TestBackgroundTask.class.getName()); |
| 189 |
| 190 TaskParams params = new TaskParams(Integer.toString(TaskIds.TEST), extra
s); |
| 191 BackgroundTask backgroundTask = |
| 192 BackgroundTaskSchedulerGcmNetworkManager.getBackgroundTaskFromTa
skParams(params); |
| 193 |
| 194 assertNotNull(backgroundTask); |
| 195 assertTrue(backgroundTask instanceof TestBackgroundTask); |
| 196 } |
| 197 |
| 198 @Test |
| 199 @Feature({"BackgroundTaskScheduler"}) |
| 200 public void testSchedule() { |
| 201 TaskInfo oneOffTask = TaskInfo.createOneOffTask(TaskIds.TEST, TestBackgr
oundTask.class, |
| 202 TimeUnit.DAYS.toMillis(1)) |
| 203 .build(); |
| 204 |
| 205 assertNull(mGcmNetworkManager.getScheduledTask()); |
| 206 |
| 207 BackgroundTaskSchedulerDelegate delegate = new BackgroundTaskSchedulerGc
mNetworkManager(); |
| 208 |
| 209 assertTrue(delegate.schedule(ContextUtils.getApplicationContext(), oneOf
fTask)); |
| 210 |
| 211 // Check that a task was scheduled using GCM Network Manager. |
| 212 assertNotNull(mGcmNetworkManager.getScheduledTask()); |
| 213 |
| 214 // Verify details of the scheduled task. |
| 215 Task scheduledTask = mGcmNetworkManager.getScheduledTask(); |
| 216 |
| 217 assertEquals(Integer.toString(oneOffTask.getTaskId()), scheduledTask.get
Tag()); |
| 218 assertEquals( |
| 219 TimeUnit.MILLISECONDS.toSeconds(oneOffTask.getOneOffInfo().getWi
ndowEndTimeMs()), |
| 220 ((OneoffTask) scheduledTask).getWindowEnd()); |
| 221 assertEquals( |
| 222 TimeUnit.MILLISECONDS.toSeconds(oneOffTask.getOneOffInfo().getWi
ndowStartTimeMs()), |
| 223 ((OneoffTask) scheduledTask).getWindowStart()); |
| 224 } |
| 225 |
| 226 @Test |
| 227 @Feature("BackgroundTaskScheduler") |
| 228 public void testScheduleNoPublicConstructor() { |
| 229 TaskInfo oneOffTask = |
| 230 TaskInfo.createOneOffTask(TaskIds.TEST, TestBackgroundTaskNoPubl
icConstructor.class, |
| 231 TimeUnit.DAYS.toMillis(1)) |
| 232 .build(); |
| 233 |
| 234 assertFalse(new BackgroundTaskSchedulerGcmNetworkManager().schedule( |
| 235 ContextUtils.getApplicationContext(), oneOffTask)); |
| 236 } |
| 237 |
| 238 @Test |
| 239 @Feature("BackgroundTaskScheduler") |
| 240 public void testScheduleNoGooglePlayServices() { |
| 241 Shadows.shadowOf(GoogleApiAvailability.getInstance()) |
| 242 .setIsGooglePlayServicesAvailable(ConnectionResult.SERVICE_MISSI
NG); |
| 243 |
| 244 TaskInfo oneOffTask = TaskInfo.createOneOffTask(TaskIds.TEST, TestBackgr
oundTask.class, |
| 245 TimeUnit.DAYS.toMillis(1)) |
| 246 .build(); |
| 247 |
| 248 assertFalse(new BackgroundTaskSchedulerGcmNetworkManager().schedule( |
| 249 ContextUtils.getApplicationContext(), oneOffTask)); |
| 250 } |
| 251 |
| 252 @Test |
| 253 @Feature("BackgroundTaskScheduler") |
| 254 public void testCancel() { |
| 255 TaskInfo oneOffTask = TaskInfo.createOneOffTask(TaskIds.TEST, TestBackgr
oundTask.class, |
| 256 TimeUnit.DAYS.toMillis(1)) |
| 257 .build(); |
| 258 |
| 259 BackgroundTaskSchedulerDelegate delegate = new BackgroundTaskSchedulerGc
mNetworkManager(); |
| 260 |
| 261 assertTrue(delegate.schedule(ContextUtils.getApplicationContext(), oneOf
fTask)); |
| 262 delegate.cancel(ContextUtils.getApplicationContext(), oneOffTask.getTask
Id()); |
| 263 |
| 264 Task canceledTask = mGcmNetworkManager.getCanceledTask(); |
| 265 assertEquals(Integer.toString(oneOffTask.getTaskId()), canceledTask.getT
ag()); |
| 266 } |
| 267 |
| 268 @Test |
| 269 @Feature("BackgroundTaskScheduler") |
| 270 public void testCancelNoGooglePlayServices() { |
| 271 // This simulates situation where Google Play Services is uninstalled. |
| 272 Shadows.shadowOf(GoogleApiAvailability.getInstance()) |
| 273 .setIsGooglePlayServicesAvailable(ConnectionResult.SERVICE_MISSI
NG); |
| 274 |
| 275 TaskInfo oneOffTask = TaskInfo.createOneOffTask(TaskIds.TEST, TestBackgr
oundTask.class, |
| 276 TimeUnit.DAYS.toMillis(1)) |
| 277 .build(); |
| 278 |
| 279 // Ensure there was a previously scheduled task. |
| 280 mGcmNetworkManager.schedule( |
| 281 BackgroundTaskSchedulerGcmNetworkManager.createTaskFromTaskInfo(
oneOffTask)); |
| 282 |
| 283 BackgroundTaskSchedulerDelegate delegate = new BackgroundTaskSchedulerGc
mNetworkManager(); |
| 284 |
| 285 // This call is expected to have no effect on GCM Network Manager, becau
se Play Services are |
| 286 // not available. |
| 287 delegate.cancel(ContextUtils.getApplicationContext(), oneOffTask.getTask
Id()); |
| 288 assertNull(mGcmNetworkManager.getCanceledTask()); |
| 289 assertNotNull(mGcmNetworkManager.getScheduledTask()); |
| 290 } |
| 291 } |
OLD | NEW |