Google Git
Sign in
android / platform / frameworks / support / 137f4aae2fd1d4aa731e0d77ba9386bbe23624cc / . / work / workmanager / src / androidTest / java / androidx / work / impl / WorkerWrapperTest.java
blob: 00014a97bc9a517e3e4d13cf64fdc4f37f26ef18 [file] [log] [blame]
Xyan Bhatnagarb8909f22017-09-20 15:45:56 -0700[diff] [blame]1/*
Sumir Katariada315bf2017-12-06 16:29:10 -0800[diff] [blame]2 * Copyright 2017 The Android Open Source Project
Xyan Bhatnagarb8909f22017-09-20 15:45:56 -0700[diff] [blame]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
Sumir Kataria564e4302018-02-14 11:22:30 -0800[diff] [blame]17package androidx.work.impl;
Sumir Katariab6430f22018-02-05 13:45:22 -0800[diff] [blame]18
Rahul Ravikumar7f7ab612018-11-01 16:22:11 -0700[diff] [blame]19import static androidx.work.WorkInfo.State.BLOCKED;
20import static androidx.work.WorkInfo.State.CANCELLED;
21import static androidx.work.WorkInfo.State.ENQUEUED;
22import static androidx.work.WorkInfo.State.FAILED;
23import static androidx.work.WorkInfo.State.RUNNING;
24import static androidx.work.WorkInfo.State.SUCCEEDED;
Sumir Katariab5728f42018-03-19 12:58:41 -0700[diff] [blame]25
Sumir Katariada315bf2017-12-06 16:29:10 -0800[diff] [blame]26import static org.hamcrest.CoreMatchers.equalTo;
Jan Clarin9e3c28e2017-09-29 16:18:41 -0700[diff] [blame]27import static org.hamcrest.CoreMatchers.is;
Sumir Katariada315bf2017-12-06 16:29:10 -0800[diff] [blame]28import static org.hamcrest.CoreMatchers.notNullValue;
Jan Clarin9e3c28e2017-09-29 16:18:41 -0700[diff] [blame]29import static org.hamcrest.MatcherAssert.assertThat;
Sumir Kataria9244d372017-11-30 13:39:07 -0800[diff] [blame]30import static org.hamcrest.Matchers.contains;
Sumir Kataria9e637902017-11-27 14:03:47 -0800[diff] [blame]31import static org.hamcrest.Matchers.containsInAnyOrder;
Jan Clarin0deb5e22017-12-06 11:26:29 -0800[diff] [blame]32import static org.hamcrest.Matchers.greaterThan;
Sumir Katariac4fde482018-12-11 12:58:51 -0800[diff] [blame]33import static org.hamcrest.Matchers.isOneOf;
Sumir Kataria4184cf02018-07-10 13:24:17 -0700[diff] [blame]34import static org.mockito.ArgumentMatchers.any;
Rahul Ravikumar275ff752018-06-22 14:20:43 -0700[diff] [blame]35import static org.mockito.Mockito.atLeast;
Sumir Kataria9554b662017-10-02 14:49:46 -0700[diff] [blame]36import static org.mockito.Mockito.mock;
Sumir Kataria4184cf02018-07-10 13:24:17 -0700[diff] [blame]37import static org.mockito.Mockito.never;
Rahul Ravikumar9f91ee82018-03-20 17:33:38 -0700[diff] [blame]38import static org.mockito.Mockito.times;
Sumir Kataria9554b662017-10-02 14:49:46 -0700[diff] [blame]39import static org.mockito.Mockito.verify;
Xyan Bhatnagard7b783e2017-09-22 14:21:25 -0700[diff] [blame]40
Xyan Bhatnagarb8909f22017-09-20 15:45:56 -0700[diff] [blame]41import android.content.Context;
Sumir Kataria7b5c5602018-05-21 15:51:33 -0700[diff] [blame]42import android.net.Uri;
Rahul Ravikumar275ff752018-06-22 14:20:43 -0700[diff] [blame]43import android.os.Build;
Sumir Kataria5c0277e2018-09-24 13:24:18 -0700[diff] [blame]44import android.util.Log;
Xyan Bhatnagarb8909f22017-09-20 15:45:56 -0700[diff] [blame]45
Alan Viverettebadf2f82018-12-18 12:14:10 -0500[diff] [blame]46import androidx.test.core.app.ApplicationProvider;
47import androidx.test.ext.junit.runners.AndroidJUnit4;
Aurimas Liutikasb7eeda42018-07-10 11:57:16 -0700[diff] [blame]48import androidx.test.filters.LargeTest;
49import androidx.test.filters.SmallTest;
Sumir Kataria564e4302018-02-14 11:22:30 -0800[diff] [blame]50import androidx.work.ArrayCreatingInputMerger;
Rahul Ravikumare3265922018-06-07 16:35:15 -0700[diff] [blame]51import androidx.work.Configuration;
Sumir Kataria64e6bd82018-03-28 17:14:22 -0700[diff] [blame]52import androidx.work.Data;
Sumir Kataria564e4302018-02-14 11:22:30 -0800[diff] [blame]53import androidx.work.DatabaseTest;
Sumir Kataria32f10f672018-09-28 15:00:45 -0700[diff] [blame]54import androidx.work.ListenableWorker;
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]55import androidx.work.OneTimeWorkRequest;
Sumir Kataria8b3284f2018-04-13 09:50:18 -0700[diff] [blame]56import androidx.work.PeriodicWorkRequest;
Sumir Katariaf82a3d62018-09-12 14:18:23 -0700[diff] [blame]57import androidx.work.WorkerParameters;
Sumir Kataria564e4302018-02-14 11:22:30 -0800[diff] [blame]58import androidx.work.impl.model.Dependency;
59import androidx.work.impl.model.DependencyDao;
60import androidx.work.impl.model.WorkSpec;
61import androidx.work.impl.model.WorkSpecDao;
Sumir Kataria2cea33c2018-09-07 15:10:39 -0700[diff] [blame]62import androidx.work.impl.utils.SynchronousExecutor;
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]63import androidx.work.impl.utils.taskexecutor.InstantWorkTaskExecutor;
64import androidx.work.impl.utils.taskexecutor.TaskExecutor;
Sumir Kataria564e4302018-02-14 11:22:30 -0800[diff] [blame]65import androidx.work.worker.ChainedArgumentWorker;
66import androidx.work.worker.EchoingWorker;
Sumir Kataria3f0c0fb2018-05-07 16:24:48 -0700[diff] [blame]67import androidx.work.worker.ExceptionWorker;
Sumir Kataria564e4302018-02-14 11:22:30 -0800[diff] [blame]68import androidx.work.worker.FailureWorker;
Sumir Katariab24ef382018-06-01 14:13:53 -0700[diff] [blame]69import androidx.work.worker.InfiniteTestWorker;
Sumir Katariabf4f4f72018-05-22 11:23:27 -0700[diff] [blame]70import androidx.work.worker.InterruptionAwareWorker;
Sumir Kataria5c0277e2018-09-24 13:24:18 -0700[diff] [blame]71import androidx.work.worker.LatchWorker;
Sumir Kataria564e4302018-02-14 11:22:30 -0800[diff] [blame]72import androidx.work.worker.RetryWorker;
Rahul Ravikumard64fb002018-12-03 13:10:53 -0800[diff] [blame]73import androidx.work.worker.ReturnNullResultWorker;
Sumir Kataria564e4302018-02-14 11:22:30 -0800[diff] [blame]74import androidx.work.worker.SleepTestWorker;
75import androidx.work.worker.TestWorker;
Sumir Kataria768d1602018-09-17 14:09:06 -0700[diff] [blame]76import androidx.work.worker.UsedWorker;
Sumir Kataria564e4302018-02-14 11:22:30 -0800[diff] [blame]77
Sergey Vasilinetsd0ac2cc2018-09-12 11:23:16 -0700[diff] [blame]78import com.google.common.util.concurrent.ListenableFuture;
79
Sumir Katariab5728f42018-03-19 12:58:41 -0700[diff] [blame]80import org.junit.Before;
Sumir Katariab5728f42018-03-19 12:58:41 -0700[diff] [blame]81import org.junit.Test;
82import org.junit.runner.RunWith;
83import org.mockito.ArgumentCaptor;
84
85import java.util.Arrays;
86import java.util.Collections;
87import java.util.List;
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]88import java.util.concurrent.ExecutionException;
89import java.util.concurrent.Executor;
Sumir Katariab5728f42018-03-19 12:58:41 -0700[diff] [blame]90import java.util.concurrent.Executors;
91import java.util.concurrent.TimeUnit;
92
Xyan Bhatnagarb8909f22017-09-20 15:45:56 -0700[diff] [blame]93@RunWith(AndroidJUnit4.class)
Sumir Kataria9e637902017-11-27 14:03:47 -0800[diff] [blame]94public class WorkerWrapperTest extends DatabaseTest {
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]95
Rahul Ravikumare3265922018-06-07 16:35:15 -0700[diff] [blame]96 private Configuration mConfiguration;
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]97 private TaskExecutor mWorkTaskExecutor;
Xyan Bhatnagard7b783e2017-09-22 14:21:25 -0700[diff] [blame]98 private WorkSpecDao mWorkSpecDao;
Xyan Bhatnagar6463beb2017-09-27 16:37:04 -0700[diff] [blame]99 private DependencyDao mDependencyDao;
Xyan Bhatnagarb8909f22017-09-20 15:45:56 -0700[diff] [blame]100 private Context mContext;
Sumir Kataria9554b662017-10-02 14:49:46 -0700[diff] [blame]101 private Scheduler mMockScheduler;
Sumir Kataria2cea33c2018-09-07 15:10:39 -0700[diff] [blame]102 private Executor mSynchronousExecutor = new SynchronousExecutor();
Xyan Bhatnagarb8909f22017-09-20 15:45:56 -0700[diff] [blame]103
104 @Before
Xyan Bhatnagar63ccec52017-09-22 16:09:31 -0700[diff] [blame]105 public void setUp() {
Alan Viverettebadf2f82018-12-18 12:14:10 -0500[diff] [blame]106 mContext = ApplicationProvider.getApplicationContext();
Sumir Kataria2cea33c2018-09-07 15:10:39 -0700[diff] [blame]107 mConfiguration = new Configuration.Builder()
108 .setExecutor(new SynchronousExecutor())
Sumir Kataria5c0277e2018-09-24 13:24:18 -0700[diff] [blame]109 .setMinimumLoggingLevel(Log.VERBOSE)
Sumir Kataria2cea33c2018-09-07 15:10:39 -0700[diff] [blame]110 .build();
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]111 mWorkTaskExecutor = new InstantWorkTaskExecutor();
Rahul Ravikumare5356662019-03-04 16:22:14 -0800[diff] [blame]112 mWorkSpecDao = mDatabase.workSpecDao();
Xyan Bhatnagar6463beb2017-09-27 16:37:04 -0700[diff] [blame]113 mDependencyDao = mDatabase.dependencyDao();
Sumir Kataria9554b662017-10-02 14:49:46 -0700[diff] [blame]114 mMockScheduler = mock(Scheduler.class);
Xyan Bhatnagarb8909f22017-09-20 15:45:56 -0700[diff] [blame]115 }
116
Xyan Bhatnagarb8909f22017-09-20 15:45:56 -0700[diff] [blame]117 @Test
Xyan Bhatnagar687da332017-11-15 10:39:57 -0800[diff] [blame]118 @SmallTest
Sumir Katariadcbf20d2018-04-16 12:40:10 -0700[diff] [blame]119 public void testSuccess() {
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]120 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(TestWorker.class).build();
Sumir Kataria1cd0e4e2017-12-12 10:53:46 -0800[diff] [blame]121 insertWork(work);
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]122 WorkerWrapper workerWrapper = createBuilder(work.getStringId()).build();
123 FutureListener listener = createAndAddFutureListener(workerWrapper);
124 workerWrapper.run();
125 assertThat(listener.mResult, is(false));
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]126 assertThat(mWorkSpecDao.getState(work.getStringId()), is(SUCCEEDED));
Xyan Bhatnagarb8909f22017-09-20 15:45:56 -0700[diff] [blame]127 }
128
129 @Test
Xyan Bhatnagar367c6492017-10-06 11:20:02 -0700[diff] [blame]130 @SmallTest
131 public void testRunAttemptCountIncremented_successfulExecution() {
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]132 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(TestWorker.class).build();
Sumir Kataria1cd0e4e2017-12-12 10:53:46 -0800[diff] [blame]133 insertWork(work);
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]134 createBuilder(work.getStringId())
Rahul Ravikumar9f91ee82018-03-20 17:33:38 -0700[diff] [blame]135 .withSchedulers(Collections.singletonList(mMockScheduler))
Xyan Bhatnagar367c6492017-10-06 11:20:02 -0700[diff] [blame]136 .build()
137 .run();
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]138 WorkSpec latestWorkSpec = mWorkSpecDao.getWorkSpec(work.getStringId());
Sumir Katariab5728f42018-03-19 12:58:41 -0700[diff] [blame]139 assertThat(latestWorkSpec.runAttemptCount, is(1));
Xyan Bhatnagar367c6492017-10-06 11:20:02 -0700[diff] [blame]140 }
141
142 @Test
143 @SmallTest
144 public void testRunAttemptCountIncremented_failedExecution() {
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]145 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(FailureWorker.class).build();
Sumir Kataria1cd0e4e2017-12-12 10:53:46 -0800[diff] [blame]146 insertWork(work);
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]147 createBuilder(work.getStringId())
Xyan Bhatnagar367c6492017-10-06 11:20:02 -0700[diff] [blame]148 .build()
149 .run();
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]150 WorkSpec latestWorkSpec = mWorkSpecDao.getWorkSpec(work.getStringId());
Sumir Katariaa3262882018-08-17 16:15:35 -0700[diff] [blame]151 assertThat(latestWorkSpec.runAttemptCount, is(1));
Xyan Bhatnagar367c6492017-10-06 11:20:02 -0700[diff] [blame]152 }
153
154 @Test
Jan Clarinee302e12017-10-09 11:16:19 -0700[diff] [blame]155 @SmallTest
Sumir Katariadcbf20d2018-04-16 12:40:10 -0700[diff] [blame]156 public void testPermanentErrorWithInvalidWorkSpecId() {
Xyan Bhatnagarb8909f22017-09-20 15:45:56 -0700[diff] [blame]157 final String invalidWorkSpecId = "INVALID_ID";
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]158 WorkerWrapper workerWrapper = createBuilder(invalidWorkSpecId).build();
159 FutureListener listener = createAndAddFutureListener(workerWrapper);
160 workerWrapper.run();
161 assertThat(listener.mResult, is(false));
Xyan Bhatnagarb8909f22017-09-20 15:45:56 -0700[diff] [blame]162 }
163
164 @Test
Xyan Bhatnagar687da332017-11-15 10:39:57 -0800[diff] [blame]165 @SmallTest
Sumir Kataria4184cf02018-07-10 13:24:17 -0700[diff] [blame]166 public void testInvalidWorkerClassName() {
167 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(TestWorker.class).build();
168 work.getWorkSpec().workerClassName = "dummy";
169 insertWork(work);
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]170 WorkerWrapper workerWrapper = createBuilder(work.getStringId())
Sumir Kataria4184cf02018-07-10 13:24:17 -0700[diff] [blame]171 .withSchedulers(Collections.singletonList(mMockScheduler))
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]172 .build();
173 FutureListener listener = createAndAddFutureListener(workerWrapper);
174 workerWrapper.run();
175 assertThat(listener.mResult, is(false));
Sumir Kataria4184cf02018-07-10 13:24:17 -0700[diff] [blame]176 verify(mMockScheduler, never()).schedule(any(WorkSpec[].class));
177 assertThat(mWorkSpecDao.getState(work.getStringId()), is(FAILED));
178 }
179
180 @Test
181 @SmallTest
Sumir Kataria768d1602018-09-17 14:09:06 -0700[diff] [blame]182 public void testUsedWorker_failsExecution() {
183 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(TestWorker.class).build();
184 insertWork(work);
Sumir Katariaa5658ce2018-09-27 15:02:32 -0700[diff] [blame]185
Sumir Kataria931889d2018-10-01 12:44:42 -0700[diff] [blame]186 UsedWorker usedWorker = (UsedWorker) mConfiguration.getWorkerFactory()
187 .createWorkerWithDefaultFallback(
188 mContext.getApplicationContext(),
189 UsedWorker.class.getName(),
190 new WorkerParameters(
191 work.getId(),
192 Data.EMPTY,
193 work.getTags(),
194 new WorkerParameters.RuntimeExtras(),
195 1,
196 mSynchronousExecutor,
Sumir Kataria9e8b8cc2018-10-01 13:21:12 -0700[diff] [blame]197 mWorkTaskExecutor,
Sumir Kataria931889d2018-10-01 12:44:42 -0700[diff] [blame]198 mConfiguration.getWorkerFactory()));
Sumir Katariaa5658ce2018-09-27 15:02:32 -0700[diff] [blame]199
Sumir Kataria768d1602018-09-17 14:09:06 -0700[diff] [blame]200 WorkerWrapper workerWrapper = createBuilder(work.getStringId())
Sumir Katariaa5658ce2018-09-27 15:02:32 -0700[diff] [blame]201 .withWorker(usedWorker)
Sumir Kataria768d1602018-09-17 14:09:06 -0700[diff] [blame]202 .build();
203 workerWrapper.run();
204 assertThat(mWorkSpecDao.getState(work.getStringId()), is(FAILED));
205 }
206
207 @Test
208 @SmallTest
Sumir Katariadcbf20d2018-04-16 12:40:10 -0700[diff] [blame]209 public void testNotEnqueued() {
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]210 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(TestWorker.class)
Sumir Kataria62a7e772018-04-23 21:12:57 -0700[diff] [blame]211 .setInitialState(RUNNING)
Sumir Kataria8b3284f2018-04-13 09:50:18 -0700[diff] [blame]212 .build();
Sumir Kataria1cd0e4e2017-12-12 10:53:46 -0800[diff] [blame]213 insertWork(work);
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]214 WorkerWrapper workerWrapper = createBuilder(work.getStringId()).build();
215 FutureListener listener = createAndAddFutureListener(workerWrapper);
216 workerWrapper.run();
217 assertThat(listener.mResult, is(true));
Xyan Bhatnagarb8909f22017-09-20 15:45:56 -0700[diff] [blame]218 }
219
220 @Test
Xyan Bhatnagar687da332017-11-15 10:39:57 -0800[diff] [blame]221 @SmallTest
Sumir Katariadcbf20d2018-04-16 12:40:10 -0700[diff] [blame]222 public void testCancelled() {
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]223 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(TestWorker.class)
Sumir Kataria5b84f5c2018-05-04 14:34:49 +0000[diff] [blame]224 .setInitialState(CANCELLED)
Sumir Kataria8b3284f2018-04-13 09:50:18 -0700[diff] [blame]225 .build();
Sumir Kataria1cd0e4e2017-12-12 10:53:46 -0800[diff] [blame]226 insertWork(work);
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]227 WorkerWrapper workerWrapper = createBuilder(work.getStringId()).build();
228 FutureListener listener = createAndAddFutureListener(workerWrapper);
229 workerWrapper.run();
230 assertThat(listener.mResult, is(false));
Sumir Kataria5b84f5c2018-05-04 14:34:49 +0000[diff] [blame]231 assertThat(mWorkSpecDao.getState(work.getStringId()), is(CANCELLED));
Sumir Kataria2ace67d2017-11-21 13:23:53 -0800[diff] [blame]232 }
233
234 @Test
235 @SmallTest
Sumir Katariadcbf20d2018-04-16 12:40:10 -0700[diff] [blame]236 public void testPermanentErrorWithInvalidWorkerClass() {
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]237 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(TestWorker.class).build();
Sumir Katariab5728f42018-03-19 12:58:41 -0700[diff] [blame]238 getWorkSpec(work).workerClassName = "INVALID_CLASS_NAME";
Sumir Kataria1cd0e4e2017-12-12 10:53:46 -0800[diff] [blame]239 insertWork(work);
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]240 WorkerWrapper workerWrapper = createBuilder(work.getStringId()).build();
241 FutureListener listener = createAndAddFutureListener(workerWrapper);
242 workerWrapper.run();
243 assertThat(listener.mResult, is(false));
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]244 assertThat(mWorkSpecDao.getState(work.getStringId()), is(FAILED));
Xyan Bhatnagard7b783e2017-09-22 14:21:25 -0700[diff] [blame]245 }
246
247 @Test
Xyan Bhatnagar687da332017-11-15 10:39:57 -0800[diff] [blame]248 @SmallTest
Sumir Katariadcbf20d2018-04-16 12:40:10 -0700[diff] [blame]249 public void testPermanentErrorWithInvalidInputMergerClass() {
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]250 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(TestWorker.class).build();
Sumir Katariab5728f42018-03-19 12:58:41 -0700[diff] [blame]251 getWorkSpec(work).inputMergerClassName = "INVALID_CLASS_NAME";
Sumir Kataria1cd0e4e2017-12-12 10:53:46 -0800[diff] [blame]252 insertWork(work);
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]253 WorkerWrapper workerWrapper = createBuilder(work.getStringId())
Rahul Ravikumar9f91ee82018-03-20 17:33:38 -0700[diff] [blame]254 .withSchedulers(Collections.singletonList(mMockScheduler))
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]255 .build();
256 FutureListener listener = createAndAddFutureListener(workerWrapper);
257 workerWrapper.run();
258 assertThat(listener.mResult, is(false));
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]259 assertThat(mWorkSpecDao.getState(work.getStringId()), is(FAILED));
Xyan Bhatnagar35574572017-12-11 11:26:16 -0800[diff] [blame]260 }
261
262 @Test
263 @SmallTest
Sumir Katariadcbf20d2018-04-16 12:40:10 -0700[diff] [blame]264 public void testFailed() {
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]265 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(FailureWorker.class).build();
Sumir Kataria1cd0e4e2017-12-12 10:53:46 -0800[diff] [blame]266 insertWork(work);
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]267 WorkerWrapper workerWrapper = createBuilder(work.getStringId()).build();
268 FutureListener listener = createAndAddFutureListener(workerWrapper);
269 workerWrapper.run();
270 assertThat(listener.mResult, is(false));
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]271 assertThat(mWorkSpecDao.getState(work.getStringId()), is(FAILED));
Xyan Bhatnagar63ccec52017-09-22 16:09:31 -0700[diff] [blame]272 }
273
274 @Test
Sumir Katariab93bf042019-03-27 13:13:49 -0700[diff] [blame]275 @LargeTest
Sumir Kataria286a63d2019-03-25 16:37:22 -0700[diff] [blame]276 public void testFailedOnDeepHierarchy() {
277 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(FailureWorker.class).build();
278 insertWork(work);
279 String previousId = work.getStringId();
280 String firstWorkId = previousId;
281 for (int i = 0; i < 500; ++i) {
282 work = new OneTimeWorkRequest.Builder(FailureWorker.class).build();
283 insertWork(work);
284 mDependencyDao.insertDependency(new Dependency(work.getStringId(), previousId));
285 previousId = work.getStringId();
286 }
287 WorkerWrapper workerWrapper = createBuilder(firstWorkId).build();
288 workerWrapper.setFailedAndResolve();
289 assertThat(mWorkSpecDao.getState(firstWorkId), is(FAILED));
290 assertThat(mWorkSpecDao.getState(previousId), is(FAILED));
291 }
292
293 @Test
Xyan Bhatnagar367c6492017-10-06 11:20:02 -0700[diff] [blame]294 @LargeTest
Xyan Bhatnagar63ccec52017-09-22 16:09:31 -0700[diff] [blame]295 public void testRunning() throws InterruptedException {
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]296 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(SleepTestWorker.class).build();
Sumir Kataria1cd0e4e2017-12-12 10:53:46 -0800[diff] [blame]297 insertWork(work);
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]298 WorkerWrapper wrapper = createBuilder(work.getStringId()).build();
299 FutureListener listener = createAndAddFutureListener(wrapper);
Xyan Bhatnagard7b783e2017-09-22 14:21:25 -0700[diff] [blame]300 Executors.newSingleThreadExecutor().submit(wrapper);
Xyan Bhatnagar687da332017-11-15 10:39:57 -0800[diff] [blame]301 Thread.sleep(2000L); // Async wait duration.
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]302 assertThat(mWorkSpecDao.getState(work.getStringId()), is(RUNNING));
Xyan Bhatnagardc31aa82017-09-26 10:53:38 -0700[diff] [blame]303 Thread.sleep(SleepTestWorker.SLEEP_DURATION);
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]304 assertThat(listener.mResult, is(false));
Xyan Bhatnagard7b783e2017-09-22 14:21:25 -0700[diff] [blame]305 }
Xyan Bhatnagar6463beb2017-09-27 16:37:04 -0700[diff] [blame]306
307 @Test
Xyan Bhatnagar367c6492017-10-06 11:20:02 -0700[diff] [blame]308 @SmallTest
Sumir Katariadcbf20d2018-04-16 12:40:10 -0700[diff] [blame]309 public void testRunning_onlyWhenEnqueued() {
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]310 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(TestWorker.class)
Sumir Kataria62a7e772018-04-23 21:12:57 -0700[diff] [blame]311 .setInitialState(RUNNING)
Sumir Katariadcbf20d2018-04-16 12:40:10 -0700[diff] [blame]312 .build();
313 insertWork(work);
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]314 WorkerWrapper workerWrapper = createBuilder(work.getStringId()).build();
315 FutureListener listener = createAndAddFutureListener(workerWrapper);
316 workerWrapper.run();
317 assertThat(listener.mResult, is(true));
Sumir Katariadcbf20d2018-04-16 12:40:10 -0700[diff] [blame]318 }
319
320 @Test
321 @SmallTest
Xyan Bhatnagar367c6492017-10-06 11:20:02 -0700[diff] [blame]322 public void testDependencies() {
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]323 OneTimeWorkRequest prerequisiteWork =
324 new OneTimeWorkRequest.Builder(TestWorker.class).build();
325 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(TestWorker.class)
Sumir Kataria62a7e772018-04-23 21:12:57 -0700[diff] [blame]326 .setInitialState(BLOCKED).build();
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]327 Dependency dependency = new Dependency(work.getStringId(), prerequisiteWork.getStringId());
Xyan Bhatnagar6463beb2017-09-27 16:37:04 -0700[diff] [blame]328
Sumir Kataria5643e2e2017-09-29 14:44:22 -0700[diff] [blame]329 mDatabase.beginTransaction();
330 try {
Sumir Kataria1cd0e4e2017-12-12 10:53:46 -0800[diff] [blame]331 insertWork(prerequisiteWork);
332 insertWork(work);
Sumir Kataria5643e2e2017-09-29 14:44:22 -0700[diff] [blame]333 mDependencyDao.insertDependency(dependency);
334 mDatabase.setTransactionSuccessful();
335 } finally {
336 mDatabase.endTransaction();
337 }
338
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]339 assertThat(mWorkSpecDao.getState(prerequisiteWork.getStringId()), is(ENQUEUED));
340 assertThat(mWorkSpecDao.getState(work.getStringId()), is(BLOCKED));
341 assertThat(mDependencyDao.hasCompletedAllPrerequisites(work.getStringId()), is(false));
Sumir Kataria5643e2e2017-09-29 14:44:22 -0700[diff] [blame]342
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]343 createBuilder(prerequisiteWork.getStringId())
Sumir Kataria137c84c2018-02-13 15:13:33 -0800[diff] [blame]344 .withSchedulers(Collections.singletonList(mMockScheduler))
Xyan Bhatnagar969025c2017-09-28 10:42:42 -0700[diff] [blame]345 .build()
346 .run();
Sumir Kataria5643e2e2017-09-29 14:44:22 -0700[diff] [blame]347
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]348 assertThat(mWorkSpecDao.getState(prerequisiteWork.getStringId()), is(SUCCEEDED));
349 assertThat(mWorkSpecDao.getState(work.getStringId()), is(ENQUEUED));
350 assertThat(mDependencyDao.hasCompletedAllPrerequisites(work.getStringId()), is(true));
Sumir Kataria9554b662017-10-02 14:49:46 -0700[diff] [blame]351
352 ArgumentCaptor<WorkSpec> captor = ArgumentCaptor.forClass(WorkSpec.class);
353 verify(mMockScheduler).schedule(captor.capture());
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]354 assertThat(captor.getValue().id, is(work.getStringId()));
Xyan Bhatnagar6463beb2017-09-27 16:37:04 -0700[diff] [blame]355 }
Xyan Bhatnagar969025c2017-09-28 10:42:42 -0700[diff] [blame]356
357 @Test
Xyan Bhatnagar687da332017-11-15 10:39:57 -0800[diff] [blame]358 @SmallTest
Sumir Kataria9244d372017-11-30 13:39:07 -0800[diff] [blame]359 public void testDependencies_passesOutputs() {
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]360 OneTimeWorkRequest prerequisiteWork =
361 new OneTimeWorkRequest.Builder(ChainedArgumentWorker.class).build();
362 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(TestWorker.class)
Sumir Kataria62a7e772018-04-23 21:12:57 -0700[diff] [blame]363 .setInitialState(BLOCKED)
Sumir Kataria8b3284f2018-04-13 09:50:18 -0700[diff] [blame]364 .build();
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]365 Dependency dependency = new Dependency(work.getStringId(), prerequisiteWork.getStringId());
Sumir Kataria1e9589d2017-11-22 13:23:46 -0800[diff] [blame]366
367 mDatabase.beginTransaction();
368 try {
Sumir Kataria1cd0e4e2017-12-12 10:53:46 -0800[diff] [blame]369 insertWork(prerequisiteWork);
370 insertWork(work);
Sumir Kataria1e9589d2017-11-22 13:23:46 -0800[diff] [blame]371 mDependencyDao.insertDependency(dependency);
372 mDatabase.setTransactionSuccessful();
373 } finally {
374 mDatabase.endTransaction();
375 }
376
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]377 createBuilder(prerequisiteWork.getStringId())
Rahul Ravikumar9f91ee82018-03-20 17:33:38 -0700[diff] [blame]378 .withSchedulers(Collections.singletonList(mMockScheduler))
379 .build().run();
Sumir Kataria1e9589d2017-11-22 13:23:46 -0800[diff] [blame]380
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]381 List<Data> arguments = mWorkSpecDao.getInputsFromPrerequisites(work.getStringId());
Sumir Kataria9244d372017-11-30 13:39:07 -0800[diff] [blame]382 assertThat(arguments.size(), is(1));
383 assertThat(arguments, contains(ChainedArgumentWorker.getChainedArguments()));
Sumir Kataria1e9589d2017-11-22 13:23:46 -0800[diff] [blame]384 }
385
386 @Test
387 @SmallTest
Sumir Kataria9244d372017-11-30 13:39:07 -0800[diff] [blame]388 public void testDependencies_passesMergedOutputs() {
Sumir Kataria6ae802c2017-11-29 16:00:44 -0800[diff] [blame]389 String key = "key";
390 String value1 = "value1";
391 String value2 = "value2";
392
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]393 OneTimeWorkRequest prerequisiteWork1 = new OneTimeWorkRequest.Builder(EchoingWorker.class)
Sumir Kataria62a7e772018-04-23 21:12:57 -0700[diff] [blame]394 .setInputData(new Data.Builder().putString(key, value1).build())
Sumir Kataria6ae802c2017-11-29 16:00:44 -0800[diff] [blame]395 .build();
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]396 OneTimeWorkRequest prerequisiteWork2 = new OneTimeWorkRequest.Builder(EchoingWorker.class)
Sumir Kataria62a7e772018-04-23 21:12:57 -0700[diff] [blame]397 .setInputData(new Data.Builder().putString(key, value2).build())
Sumir Kataria6ae802c2017-11-29 16:00:44 -0800[diff] [blame]398 .build();
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]399 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(TestWorker.class)
Sumir Kataria62a7e772018-04-23 21:12:57 -0700[diff] [blame]400 .setInputMerger(ArrayCreatingInputMerger.class)
Sumir Kataria6ae802c2017-11-29 16:00:44 -0800[diff] [blame]401 .build();
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]402 Dependency dependency1 =
403 new Dependency(work.getStringId(), prerequisiteWork1.getStringId());
404 Dependency dependency2 =
405 new Dependency(work.getStringId(), prerequisiteWork2.getStringId());
Sumir Kataria6ae802c2017-11-29 16:00:44 -0800[diff] [blame]406
407 mDatabase.beginTransaction();
408 try {
Sumir Kataria1cd0e4e2017-12-12 10:53:46 -0800[diff] [blame]409 insertWork(prerequisiteWork1);
410 insertWork(prerequisiteWork2);
411 insertWork(work);
Sumir Kataria6ae802c2017-11-29 16:00:44 -0800[diff] [blame]412 mDependencyDao.insertDependency(dependency1);
413 mDependencyDao.insertDependency(dependency2);
414 mDatabase.setTransactionSuccessful();
415 } finally {
416 mDatabase.endTransaction();
417 }
418
419 // Run the prerequisites.
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]420 createBuilder(prerequisiteWork1.getStringId())
Rahul Ravikumar9f91ee82018-03-20 17:33:38 -0700[diff] [blame]421 .withSchedulers(Collections.singletonList(mMockScheduler))
422 .build().run();
423
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]424 createBuilder(prerequisiteWork2.getStringId())
Rahul Ravikumar9f91ee82018-03-20 17:33:38 -0700[diff] [blame]425 .withSchedulers(Collections.singletonList(mMockScheduler))
426 .build().run();
Sumir Kataria6ae802c2017-11-29 16:00:44 -0800[diff] [blame]427
428 // Create and run the dependent work.
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]429 WorkerWrapper workerWrapper =
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]430 createBuilder(work.getStringId())
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]431 .withSchedulers(Collections.singletonList(mMockScheduler))
432 .build();
Sumir Kataria6ae802c2017-11-29 16:00:44 -0800[diff] [blame]433 workerWrapper.run();
434
Sumir Kataria64e6bd82018-03-28 17:14:22 -0700[diff] [blame]435 Data input = workerWrapper.mWorker.getInputData();
436 assertThat(input.size(), is(1));
437 assertThat(Arrays.asList(input.getStringArray(key)),
Sumir Kataria6ae802c2017-11-29 16:00:44 -0800[diff] [blame]438 containsInAnyOrder(value1, value2));
439 }
440
441 @Test
442 @SmallTest
Jan Clarin0deb5e22017-12-06 11:26:29 -0800[diff] [blame]443 public void testDependencies_setsPeriodStartTimesForUnblockedWork() {
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]444 OneTimeWorkRequest prerequisiteWork =
445 new OneTimeWorkRequest.Builder(TestWorker.class).build();
446 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(TestWorker.class)
Sumir Kataria62a7e772018-04-23 21:12:57 -0700[diff] [blame]447 .setInitialState(BLOCKED)
Sumir Kataria8b3284f2018-04-13 09:50:18 -0700[diff] [blame]448 .build();
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]449 Dependency dependency = new Dependency(work.getStringId(), prerequisiteWork.getStringId());
Jan Clarin0deb5e22017-12-06 11:26:29 -0800[diff] [blame]450
451 mDatabase.beginTransaction();
452 try {
Sumir Kataria1cd0e4e2017-12-12 10:53:46 -0800[diff] [blame]453 insertWork(prerequisiteWork);
454 insertWork(work);
Jan Clarin0deb5e22017-12-06 11:26:29 -0800[diff] [blame]455 mDependencyDao.insertDependency(dependency);
456 mDatabase.setTransactionSuccessful();
457 } finally {
458 mDatabase.endTransaction();
459 }
460
461 long beforeUnblockedTime = System.currentTimeMillis();
462
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]463 createBuilder(prerequisiteWork.getStringId())
Sumir Kataria137c84c2018-02-13 15:13:33 -0800[diff] [blame]464 .withSchedulers(Collections.singletonList(mMockScheduler))
Jan Clarin0deb5e22017-12-06 11:26:29 -0800[diff] [blame]465 .build()
466 .run();
467
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]468 WorkSpec workSpec = mWorkSpecDao.getWorkSpec(work.getStringId());
Sumir Katariab5728f42018-03-19 12:58:41 -0700[diff] [blame]469 assertThat(workSpec.periodStartTime, is(greaterThan(beforeUnblockedTime)));
Jan Clarin0deb5e22017-12-06 11:26:29 -0800[diff] [blame]470 }
471
472 @Test
473 @SmallTest
Sumir Katariac4fde482018-12-11 12:58:51 -0800[diff] [blame]474 public void testDependencies_enqueuesBlockedDependentsOnSuccess() {
475 OneTimeWorkRequest prerequisiteWork =
476 new OneTimeWorkRequest.Builder(TestWorker.class).build();
477 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(TestWorker.class)
478 .setInitialState(BLOCKED)
479 .build();
480 OneTimeWorkRequest cancelledWork = new OneTimeWorkRequest.Builder(TestWorker.class)
481 .setInitialState(CANCELLED)
482 .build();
483 Dependency dependency1 = new Dependency(work.getStringId(), prerequisiteWork.getStringId());
484 Dependency dependency2 =
485 new Dependency(cancelledWork.getStringId(), prerequisiteWork.getStringId());
486
487 mDatabase.beginTransaction();
488 try {
489 insertWork(prerequisiteWork);
490 insertWork(work);
491 insertWork(cancelledWork);
492 mDependencyDao.insertDependency(dependency1);
493 mDependencyDao.insertDependency(dependency2);
494 mDatabase.setTransactionSuccessful();
495 } finally {
496 mDatabase.endTransaction();
497 }
498
499 createBuilder(prerequisiteWork.getStringId())
500 .build()
501 .run();
502
503 assertThat(mWorkSpecDao.getState(prerequisiteWork.getStringId()), is(SUCCEEDED));
504 assertThat(mWorkSpecDao.getState(work.getStringId()),
505 isOneOf(ENQUEUED, RUNNING, SUCCEEDED));
506 assertThat(mWorkSpecDao.getState(cancelledWork.getStringId()), is(CANCELLED));
507 }
508
509 @Test
510 @SmallTest
Sumir Katariac1ba6332018-03-06 16:54:45 -0800[diff] [blame]511 public void testDependencies_failsUncancelledDependentsOnFailure() {
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]512 OneTimeWorkRequest prerequisiteWork =
513 new OneTimeWorkRequest.Builder(FailureWorker.class).build();
514 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(TestWorker.class)
Sumir Kataria62a7e772018-04-23 21:12:57 -0700[diff] [blame]515 .setInitialState(BLOCKED)
Sumir Kataria8b3284f2018-04-13 09:50:18 -0700[diff] [blame]516 .build();
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]517 OneTimeWorkRequest cancelledWork = new OneTimeWorkRequest.Builder(TestWorker.class)
Sumir Kataria5b84f5c2018-05-04 14:34:49 +0000[diff] [blame]518 .setInitialState(CANCELLED)
Sumir Kataria8b3284f2018-04-13 09:50:18 -0700[diff] [blame]519 .build();
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]520 Dependency dependency1 = new Dependency(work.getStringId(), prerequisiteWork.getStringId());
521 Dependency dependency2 =
522 new Dependency(cancelledWork.getStringId(), prerequisiteWork.getStringId());
Sumir Katariac1ba6332018-03-06 16:54:45 -0800[diff] [blame]523
524 mDatabase.beginTransaction();
525 try {
526 insertWork(prerequisiteWork);
527 insertWork(work);
528 insertWork(cancelledWork);
529 mDependencyDao.insertDependency(dependency1);
530 mDependencyDao.insertDependency(dependency2);
531 mDatabase.setTransactionSuccessful();
532 } finally {
533 mDatabase.endTransaction();
534 }
535
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]536 createBuilder(prerequisiteWork.getStringId())
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]537 .build()
538 .run();
Sumir Katariac1ba6332018-03-06 16:54:45 -0800[diff] [blame]539
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]540 assertThat(mWorkSpecDao.getState(prerequisiteWork.getStringId()), is(FAILED));
541 assertThat(mWorkSpecDao.getState(work.getStringId()), is(FAILED));
Sumir Kataria5b84f5c2018-05-04 14:34:49 +0000[diff] [blame]542 assertThat(mWorkSpecDao.getState(cancelledWork.getStringId()), is(CANCELLED));
Sumir Katariac1ba6332018-03-06 16:54:45 -0800[diff] [blame]543 }
544
545 @Test
546 @SmallTest
Rahul Ravikumar1cb6e002019-01-15 14:24:59 -0800[diff] [blame]547 public void testBackedOffOneTimeWork_doesNotRun() {
548 OneTimeWorkRequest retryWork =
549 new OneTimeWorkRequest.Builder(RetryWorker.class).build();
550
551 long future = System.currentTimeMillis() + TimeUnit.HOURS.toMillis(1);
552 mDatabase.beginTransaction();
553 try {
554 mWorkSpecDao.insertWorkSpec(retryWork.getWorkSpec());
555 mWorkSpecDao.setPeriodStartTime(retryWork.getStringId(), future);
556 mWorkSpecDao.incrementWorkSpecRunAttemptCount(retryWork.getStringId());
557 mDatabase.setTransactionSuccessful();
558 } finally {
559 mDatabase.endTransaction();
560 }
561
562 createBuilder(retryWork.getStringId())
563 .build()
564 .run();
565
566 WorkSpec workSpec = mWorkSpecDao.getWorkSpec(retryWork.getStringId());
567 // The run attempt count should remain the same
568 assertThat(workSpec.runAttemptCount, is(1));
569 }
570
571 @Test
572 @SmallTest
Jan Clarin0deb5e22017-12-06 11:26:29 -0800[diff] [blame]573 public void testRun_periodicWork_success_updatesPeriodStartTime() {
Sumir Kataria8b3284f2018-04-13 09:50:18 -0700[diff] [blame]574 long intervalDuration = PeriodicWorkRequest.MIN_PERIODIC_INTERVAL_MILLIS;
Jan Clarin0deb5e22017-12-06 11:26:29 -0800[diff] [blame]575 long periodStartTime = System.currentTimeMillis();
Jan Clarin0deb5e22017-12-06 11:26:29 -0800[diff] [blame]576
Sumir Kataria8b3284f2018-04-13 09:50:18 -0700[diff] [blame]577 PeriodicWorkRequest periodicWork = new PeriodicWorkRequest.Builder(
Sumir Katariaf4ae2b72018-03-06 10:54:57 -0800[diff] [blame]578 TestWorker.class, intervalDuration, TimeUnit.MILLISECONDS).build();
Jan Clarin0deb5e22017-12-06 11:26:29 -0800[diff] [blame]579
Sumir Katariab5728f42018-03-19 12:58:41 -0700[diff] [blame]580 getWorkSpec(periodicWork).periodStartTime = periodStartTime;
Sumir Kataria1cd0e4e2017-12-12 10:53:46 -0800[diff] [blame]581 insertWork(periodicWork);
Jan Clarin0deb5e22017-12-06 11:26:29 -0800[diff] [blame]582
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]583 createBuilder(periodicWork.getStringId())
Jan Clarin0deb5e22017-12-06 11:26:29 -0800[diff] [blame]584 .build()
585 .run();
586
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]587 WorkSpec updatedWorkSpec = mWorkSpecDao.getWorkSpec(periodicWork.getStringId());
Rahul Ravikumar67a9b192019-01-28 15:00:20 -0800[diff] [blame]588 assertThat(updatedWorkSpec.calculateNextRunTime(), greaterThan(periodStartTime));
Jan Clarin0deb5e22017-12-06 11:26:29 -0800[diff] [blame]589 }
590
591 @Test
592 @SmallTest
593 public void testRun_periodicWork_failure_updatesPeriodStartTime() {
Sumir Kataria8b3284f2018-04-13 09:50:18 -0700[diff] [blame]594 long intervalDuration = PeriodicWorkRequest.MIN_PERIODIC_INTERVAL_MILLIS;
Jan Clarin0deb5e22017-12-06 11:26:29 -0800[diff] [blame]595 long periodStartTime = System.currentTimeMillis();
Jan Clarin0deb5e22017-12-06 11:26:29 -0800[diff] [blame]596
Sumir Kataria8b3284f2018-04-13 09:50:18 -0700[diff] [blame]597 PeriodicWorkRequest periodicWork = new PeriodicWorkRequest.Builder(
Sumir Katariaf4ae2b72018-03-06 10:54:57 -0800[diff] [blame]598 FailureWorker.class, intervalDuration, TimeUnit.MILLISECONDS).build();
Jan Clarin0deb5e22017-12-06 11:26:29 -0800[diff] [blame]599
Sumir Katariab5728f42018-03-19 12:58:41 -0700[diff] [blame]600 getWorkSpec(periodicWork).periodStartTime = periodStartTime;
Sumir Kataria1cd0e4e2017-12-12 10:53:46 -0800[diff] [blame]601 insertWork(periodicWork);
Jan Clarin0deb5e22017-12-06 11:26:29 -0800[diff] [blame]602
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]603 createBuilder(periodicWork.getStringId())
Jan Clarin0deb5e22017-12-06 11:26:29 -0800[diff] [blame]604 .build()
605 .run();
606
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]607 WorkSpec updatedWorkSpec = mWorkSpecDao.getWorkSpec(periodicWork.getStringId());
Rahul Ravikumar67a9b192019-01-28 15:00:20 -0800[diff] [blame]608 assertThat(updatedWorkSpec.calculateNextRunTime(), greaterThan(periodStartTime));
Jan Clarin0deb5e22017-12-06 11:26:29 -0800[diff] [blame]609 }
610
611 @Test
612 @SmallTest
Sumir Katariadcbf20d2018-04-16 12:40:10 -0700[diff] [blame]613 public void testPeriodicWork_success() {
Sumir Kataria8b3284f2018-04-13 09:50:18 -0700[diff] [blame]614 PeriodicWorkRequest periodicWork = new PeriodicWorkRequest.Builder(
Sumir Kataria3f630c92017-10-24 16:38:54 -0700[diff] [blame]615 TestWorker.class,
Sumir Kataria8b3284f2018-04-13 09:50:18 -0700[diff] [blame]616 PeriodicWorkRequest.MIN_PERIODIC_INTERVAL_MILLIS,
Sumir Katariaf4ae2b72018-03-06 10:54:57 -0800[diff] [blame]617 TimeUnit.MILLISECONDS)
Jan Clarinee302e12017-10-09 11:16:19 -0700[diff] [blame]618 .build();
619
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]620 final String periodicWorkId = periodicWork.getStringId();
Sumir Kataria1cd0e4e2017-12-12 10:53:46 -0800[diff] [blame]621 insertWork(periodicWork);
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]622 WorkerWrapper workerWrapper = createBuilder(periodicWorkId)
Rahul Ravikumar275ff752018-06-22 14:20:43 -0700[diff] [blame]623 .withSchedulers(Collections.singletonList(mMockScheduler))
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]624 .build();
625 FutureListener listener = createAndAddFutureListener(workerWrapper);
626 workerWrapper.run();
Jan Clarinee302e12017-10-09 11:16:19 -0700[diff] [blame]627
Jan Clarinee302e12017-10-09 11:16:19 -0700[diff] [blame]628 WorkSpec periodicWorkSpecAfterFirstRun = mWorkSpecDao.getWorkSpec(periodicWorkId);
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]629 assertThat(listener.mResult, is(false));
Sumir Katariab5728f42018-03-19 12:58:41 -0700[diff] [blame]630 assertThat(periodicWorkSpecAfterFirstRun.runAttemptCount, is(0));
631 assertThat(periodicWorkSpecAfterFirstRun.state, is(ENQUEUED));
Rahul Ravikumar275ff752018-06-22 14:20:43 -0700[diff] [blame]632 // SystemAlarmScheduler needs to reschedule the same worker.
633 if (Build.VERSION.SDK_INT <= WorkManagerImpl.MAX_PRE_JOB_SCHEDULER_API_LEVEL) {
634 ArgumentCaptor<WorkSpec> captor = ArgumentCaptor.forClass(WorkSpec.class);
635 verify(mMockScheduler, atLeast(1))
636 .schedule(captor.capture());
637
638 WorkSpec workSpec = captor.getValue();
639 assertThat(workSpec.id, is(periodicWorkId));
640 }
Jan Clarinee302e12017-10-09 11:16:19 -0700[diff] [blame]641 }
642
643 @Test
Xyan Bhatnagar367c6492017-10-06 11:20:02 -0700[diff] [blame]644 @SmallTest
Sumir Katariadcbf20d2018-04-16 12:40:10 -0700[diff] [blame]645 public void testPeriodicWork_fail() {
Sumir Kataria8b3284f2018-04-13 09:50:18 -0700[diff] [blame]646 PeriodicWorkRequest periodicWork = new PeriodicWorkRequest.Builder(
Xyan Bhatnagarfdd887f2017-11-17 16:44:55 -0800[diff] [blame]647 FailureWorker.class,
Sumir Kataria8b3284f2018-04-13 09:50:18 -0700[diff] [blame]648 PeriodicWorkRequest.MIN_PERIODIC_INTERVAL_MILLIS,
Sumir Katariaf4ae2b72018-03-06 10:54:57 -0800[diff] [blame]649 TimeUnit.MILLISECONDS)
Xyan Bhatnagarfdd887f2017-11-17 16:44:55 -0800[diff] [blame]650 .build();
651
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]652 final String periodicWorkId = periodicWork.getStringId();
Sumir Kataria1cd0e4e2017-12-12 10:53:46 -0800[diff] [blame]653 insertWork(periodicWork);
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]654 WorkerWrapper workerWrapper = createBuilder(periodicWorkId).build();
655 FutureListener listener = createAndAddFutureListener(workerWrapper);
656 workerWrapper.run();
Xyan Bhatnagarfdd887f2017-11-17 16:44:55 -0800[diff] [blame]657
658 WorkSpec periodicWorkSpecAfterFirstRun = mWorkSpecDao.getWorkSpec(periodicWorkId);
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]659 assertThat(listener.mResult, is(false));
Sumir Katariab5728f42018-03-19 12:58:41 -0700[diff] [blame]660 assertThat(periodicWorkSpecAfterFirstRun.runAttemptCount, is(0));
661 assertThat(periodicWorkSpecAfterFirstRun.state, is(ENQUEUED));
Xyan Bhatnagarfdd887f2017-11-17 16:44:55 -0800[diff] [blame]662 }
663
664 @Test
665 @SmallTest
Sumir Katariadcbf20d2018-04-16 12:40:10 -0700[diff] [blame]666 public void testPeriodicWork_retry() {
Sumir Kataria8b3284f2018-04-13 09:50:18 -0700[diff] [blame]667 PeriodicWorkRequest periodicWork = new PeriodicWorkRequest.Builder(
Xyan Bhatnagarfdd887f2017-11-17 16:44:55 -0800[diff] [blame]668 RetryWorker.class,
Sumir Kataria8b3284f2018-04-13 09:50:18 -0700[diff] [blame]669 PeriodicWorkRequest.MIN_PERIODIC_INTERVAL_MILLIS,
Sumir Katariaf4ae2b72018-03-06 10:54:57 -0800[diff] [blame]670 TimeUnit.MILLISECONDS)
Xyan Bhatnagarfdd887f2017-11-17 16:44:55 -0800[diff] [blame]671 .build();
672
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]673 final String periodicWorkId = periodicWork.getStringId();
Sumir Kataria1cd0e4e2017-12-12 10:53:46 -0800[diff] [blame]674 insertWork(periodicWork);
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]675 WorkerWrapper workerWrapper = createBuilder(periodicWorkId).build();
676 FutureListener listener = createAndAddFutureListener(workerWrapper);
677 workerWrapper.run();
Xyan Bhatnagarfdd887f2017-11-17 16:44:55 -0800[diff] [blame]678
679 WorkSpec periodicWorkSpecAfterFirstRun = mWorkSpecDao.getWorkSpec(periodicWorkId);
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]680 assertThat(listener.mResult, is(true));
Sumir Katariab5728f42018-03-19 12:58:41 -0700[diff] [blame]681 assertThat(periodicWorkSpecAfterFirstRun.runAttemptCount, is(1));
682 assertThat(periodicWorkSpecAfterFirstRun.state, is(ENQUEUED));
Xyan Bhatnagarfdd887f2017-11-17 16:44:55 -0800[diff] [blame]683 }
684
Rahul Ravikumar82d2db92019-01-04 11:28:27 -0800[diff] [blame]685
686 @Test
687 @SmallTest
688 public void testPeriodic_dedupe() {
689 PeriodicWorkRequest periodicWork = new PeriodicWorkRequest.Builder(
690 TestWorker.class,
691 PeriodicWorkRequest.MIN_PERIODIC_INTERVAL_MILLIS,
692 TimeUnit.MILLISECONDS)
693 .build();
694
695 final String periodicWorkId = periodicWork.getStringId();
696 final WorkSpec workSpec = periodicWork.getWorkSpec();
697 long now = System.currentTimeMillis();
698 workSpec.periodStartTime = now + workSpec.intervalDuration;
699 insertWork(periodicWork);
700 WorkerWrapper workerWrapper = createBuilder(periodicWorkId).build();
701 FutureListener listener = createAndAddFutureListener(workerWrapper);
702 workerWrapper.run();
Rahul Ravikumarebb4f872019-01-29 16:16:17 -0800[diff] [blame]703 // Should get rescheduled
704 assertThat(listener.mResult, is(true));
Rahul Ravikumar82d2db92019-01-04 11:28:27 -0800[diff] [blame]705 }
706
Xyan Bhatnagarfdd887f2017-11-17 16:44:55 -0800[diff] [blame]707 @Test
708 @SmallTest
Rahul Ravikumar6dc75802019-02-12 15:41:35 -0800[diff] [blame]709 public void testPeriodic_firstRun_flexApplied_noDedupe() {
710 PeriodicWorkRequest periodicWork = new PeriodicWorkRequest.Builder(
711 TestWorker.class,
712 PeriodicWorkRequest.MIN_PERIODIC_INTERVAL_MILLIS,
713 TimeUnit.MILLISECONDS,
714 PeriodicWorkRequest.MIN_PERIODIC_FLEX_MILLIS,
715 TimeUnit.MILLISECONDS)
716 .build();
717
718 final String periodicWorkId = periodicWork.getStringId();
719 final WorkSpec workSpec = periodicWork.getWorkSpec();
720 workSpec.periodStartTime = 0;
721 insertWork(periodicWork);
722 WorkerWrapper workerWrapper = createBuilder(periodicWorkId).build();
723 FutureListener listener = createAndAddFutureListener(workerWrapper);
724 workerWrapper.run();
725 // Should not get rescheduled
726 assertThat(listener.mResult, is(false));
727 }
728
729 @Test
730 @SmallTest
Sumir Katariadcbf20d2018-04-16 12:40:10 -0700[diff] [blame]731 public void testScheduler() {
Sumir Kataria8e3ba6f2018-07-03 14:04:00 -0700[diff] [blame]732 OneTimeWorkRequest prerequisiteWork =
733 new OneTimeWorkRequest.Builder(TestWorker.class).build();
734 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(TestWorker.class)
735 .setInitialState(BLOCKED).build();
736 Dependency dependency = new Dependency(work.getStringId(), prerequisiteWork.getStringId());
Xyan Bhatnagara1af78b2017-10-04 17:36:36 -0700[diff] [blame]737
Sumir Kataria8e3ba6f2018-07-03 14:04:00 -0700[diff] [blame]738 mDatabase.beginTransaction();
739 try {
740 insertWork(prerequisiteWork);
741 insertWork(work);
742 mDependencyDao.insertDependency(dependency);
743 mDatabase.setTransactionSuccessful();
744 } finally {
745 mDatabase.endTransaction();
746 }
747
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]748 createBuilder(prerequisiteWork.getStringId())
Sumir Kataria8e3ba6f2018-07-03 14:04:00 -0700[diff] [blame]749 .withSchedulers(Collections.singletonList(mMockScheduler))
Xyan Bhatnagara1af78b2017-10-04 17:36:36 -0700[diff] [blame]750 .build()
751 .run();
752
Sumir Kataria8e3ba6f2018-07-03 14:04:00 -0700[diff] [blame]753 ArgumentCaptor<WorkSpec> captor = ArgumentCaptor.forClass(WorkSpec.class);
754 verify(mMockScheduler).schedule(captor.capture());
755 assertThat(captor.getValue().id, is(work.getStringId()));
Xyan Bhatnagara1af78b2017-10-04 17:36:36 -0700[diff] [blame]756 }
Sumir Katariada315bf2017-12-06 16:29:10 -0800[diff] [blame]757
758 @Test
759 @SmallTest
Sumir Katariadcbf20d2018-04-16 12:40:10 -0700[diff] [blame]760 public void testFromWorkSpec_hasAppContext() {
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]761 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(TestWorker.class).build();
Sumir Kataria931889d2018-10-01 12:44:42 -0700[diff] [blame]762 ListenableWorker worker = mConfiguration.getWorkerFactory().createWorkerWithDefaultFallback(
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]763 mContext.getApplicationContext(),
764 TestWorker.class.getName(),
Sumir Katariaf82a3d62018-09-12 14:18:23 -0700[diff] [blame]765 new WorkerParameters(
766 work.getId(),
767 Data.EMPTY,
768 work.getTags(),
769 new WorkerParameters.RuntimeExtras(),
Sumir Kataria2cea33c2018-09-07 15:10:39 -0700[diff] [blame]770 1,
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]771 mSynchronousExecutor,
Sumir Kataria9e8b8cc2018-10-01 13:21:12 -0700[diff] [blame]772 mWorkTaskExecutor,
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]773 mConfiguration.getWorkerFactory()));
Sumir Katariada315bf2017-12-06 16:29:10 -0800[diff] [blame]774
775 assertThat(worker, is(notNullValue()));
Rahul Ravikumard0d61c52018-04-19 16:52:46 -0700[diff] [blame]776 assertThat(worker.getApplicationContext(), is(equalTo(mContext.getApplicationContext())));
Sumir Katariada315bf2017-12-06 16:29:10 -0800[diff] [blame]777 }
778
779 @Test
780 @SmallTest
Sumir Katariadcbf20d2018-04-16 12:40:10 -0700[diff] [blame]781 public void testFromWorkSpec_hasCorrectArguments() {
Sumir Katariada315bf2017-12-06 16:29:10 -0800[diff] [blame]782 String key = "KEY";
783 String expectedValue = "VALUE";
Sumir Kataria64e6bd82018-03-28 17:14:22 -0700[diff] [blame]784 Data input = new Data.Builder().putString(key, expectedValue).build();
Sumir Katariada315bf2017-12-06 16:29:10 -0800[diff] [blame]785
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]786 OneTimeWorkRequest work =
Sumir Kataria62a7e772018-04-23 21:12:57 -0700[diff] [blame]787 new OneTimeWorkRequest.Builder(TestWorker.class).setInputData(input).build();
Sumir Kataria931889d2018-10-01 12:44:42 -0700[diff] [blame]788 ListenableWorker worker = mConfiguration.getWorkerFactory().createWorkerWithDefaultFallback(
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]789 mContext.getApplicationContext(),
790 TestWorker.class.getName(),
Sumir Katariaf82a3d62018-09-12 14:18:23 -0700[diff] [blame]791 new WorkerParameters(
792 work.getId(),
793 input,
794 work.getTags(),
795 new WorkerParameters.RuntimeExtras(),
Sumir Kataria2cea33c2018-09-07 15:10:39 -0700[diff] [blame]796 1,
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]797 mSynchronousExecutor,
Sumir Kataria9e8b8cc2018-10-01 13:21:12 -0700[diff] [blame]798 mWorkTaskExecutor,
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]799 mConfiguration.getWorkerFactory()));
Sumir Katariada315bf2017-12-06 16:29:10 -0800[diff] [blame]800
801 assertThat(worker, is(notNullValue()));
Sumir Kataria6d1c4d62018-07-02 12:50:38 -0700[diff] [blame]802 assertThat(worker.getInputData().getString(key), is(expectedValue));
Sumir Katariada315bf2017-12-06 16:29:10 -0800[diff] [blame]803
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]804 work = new OneTimeWorkRequest.Builder(TestWorker.class).build();
Sumir Kataria931889d2018-10-01 12:44:42 -0700[diff] [blame]805 worker = mConfiguration.getWorkerFactory().createWorkerWithDefaultFallback(
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]806 mContext.getApplicationContext(),
807 TestWorker.class.getName(),
Sumir Katariaf82a3d62018-09-12 14:18:23 -0700[diff] [blame]808 new WorkerParameters(
809 work.getId(),
810 Data.EMPTY,
811 work.getTags(),
812 new WorkerParameters.RuntimeExtras(),
Sumir Kataria2cea33c2018-09-07 15:10:39 -0700[diff] [blame]813 1,
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]814 mSynchronousExecutor,
Sumir Kataria9e8b8cc2018-10-01 13:21:12 -0700[diff] [blame]815 mWorkTaskExecutor,
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]816 mConfiguration.getWorkerFactory()));
Sumir Katariada315bf2017-12-06 16:29:10 -0800[diff] [blame]817
818 assertThat(worker, is(notNullValue()));
Sumir Kataria64e6bd82018-03-28 17:14:22 -0700[diff] [blame]819 assertThat(worker.getInputData().size(), is(0));
Sumir Katariada315bf2017-12-06 16:29:10 -0800[diff] [blame]820 }
Rahul Ravikumar9f91ee82018-03-20 17:33:38 -0700[diff] [blame]821
822 @Test
823 @SmallTest
Sumir Kataria7b5c5602018-05-21 15:51:33 -0700[diff] [blame]824 public void testFromWorkSpec_hasCorrectTags() {
825 OneTimeWorkRequest work =
826 new OneTimeWorkRequest.Builder(TestWorker.class)
827 .addTag("one")
828 .addTag("two")
829 .addTag("three")
830 .build();
Sumir Kataria931889d2018-10-01 12:44:42 -0700[diff] [blame]831 ListenableWorker worker = mConfiguration.getWorkerFactory().createWorkerWithDefaultFallback(
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]832 mContext.getApplicationContext(),
833 TestWorker.class.getName(),
Sumir Katariaf82a3d62018-09-12 14:18:23 -0700[diff] [blame]834 new WorkerParameters(
835 work.getId(),
836 Data.EMPTY,
Sumir Katariaa3262882018-08-17 16:15:35 -0700[diff] [blame]837 Arrays.asList("one", "two", "three"),
Sumir Katariaf82a3d62018-09-12 14:18:23 -0700[diff] [blame]838 new WorkerParameters.RuntimeExtras(),
Sumir Kataria2cea33c2018-09-07 15:10:39 -0700[diff] [blame]839 1,
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]840 mSynchronousExecutor,
Sumir Kataria9e8b8cc2018-10-01 13:21:12 -0700[diff] [blame]841 mWorkTaskExecutor,
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]842 mConfiguration.getWorkerFactory()));
Sumir Kataria7b5c5602018-05-21 15:51:33 -0700[diff] [blame]843
844 assertThat(worker, is(notNullValue()));
845 assertThat(worker.getTags(), containsInAnyOrder("one", "two", "three"));
846 }
847
848 @Test
849 @SmallTest
850 public void testFromWorkSpec_hasCorrectRuntimeExtras() {
851 OneTimeWorkRequest work =
852 new OneTimeWorkRequest.Builder(TestWorker.class).build();
Sumir Katariaf82a3d62018-09-12 14:18:23 -0700[diff] [blame]853 WorkerParameters.RuntimeExtras runtimeExtras = new WorkerParameters.RuntimeExtras();
Rahul Ravikumarb3a76ba2018-10-12 14:28:06 -0700[diff] [blame]854 runtimeExtras.triggeredContentAuthorities = Arrays.asList("tca1", "tca2", "tca3");
855 runtimeExtras.triggeredContentUris = Arrays.asList(Uri.parse("tcu1"), Uri.parse("tcu2"));
Sumir Kataria7b5c5602018-05-21 15:51:33 -0700[diff] [blame]856
Sumir Kataria931889d2018-10-01 12:44:42 -0700[diff] [blame]857 ListenableWorker worker = mConfiguration.getWorkerFactory().createWorkerWithDefaultFallback(
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]858 mContext.getApplicationContext(),
859 TestWorker.class.getName(),
Sumir Katariaf82a3d62018-09-12 14:18:23 -0700[diff] [blame]860 new WorkerParameters(
861 work.getId(),
862 Data.EMPTY,
863 work.getTags(),
Sumir Kataria2cea33c2018-09-07 15:10:39 -0700[diff] [blame]864 runtimeExtras,
865 1,
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]866 mSynchronousExecutor,
Sumir Kataria9e8b8cc2018-10-01 13:21:12 -0700[diff] [blame]867 mWorkTaskExecutor,
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]868 mConfiguration.getWorkerFactory()));
Sumir Kataria7b5c5602018-05-21 15:51:33 -0700[diff] [blame]869
870 assertThat(worker, is(notNullValue()));
871 assertThat(worker.getTriggeredContentAuthorities(),
Rahul Ravikumarb3a76ba2018-10-12 14:28:06 -0700[diff] [blame]872 containsInAnyOrder(runtimeExtras.triggeredContentAuthorities.toArray()));
Sumir Kataria7b5c5602018-05-21 15:51:33 -0700[diff] [blame]873 assertThat(worker.getTriggeredContentUris(),
Rahul Ravikumarb3a76ba2018-10-12 14:28:06 -0700[diff] [blame]874 containsInAnyOrder(runtimeExtras.triggeredContentUris.toArray()));
Sumir Kataria7b5c5602018-05-21 15:51:33 -0700[diff] [blame]875 }
876
877 @Test
878 @SmallTest
Rahul Ravikumar9f91ee82018-03-20 17:33:38 -0700[diff] [blame]879 public void testSuccess_withPendingScheduledWork() {
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]880 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(TestWorker.class).build();
Rahul Ravikumar9f91ee82018-03-20 17:33:38 -0700[diff] [blame]881 insertWork(work);
882
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]883 OneTimeWorkRequest unscheduled = new OneTimeWorkRequest.Builder(TestWorker.class).build();
Rahul Ravikumar9f91ee82018-03-20 17:33:38 -0700[diff] [blame]884 insertWork(unscheduled);
885
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]886 WorkerWrapper workerWrapper = createBuilder(work.getStringId())
Rahul Ravikumar9f91ee82018-03-20 17:33:38 -0700[diff] [blame]887 .withSchedulers(Collections.singletonList(mMockScheduler))
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]888 .build();
889 FutureListener listener = createAndAddFutureListener(workerWrapper);
890 workerWrapper.run();
Rahul Ravikumar9f91ee82018-03-20 17:33:38 -0700[diff] [blame]891
892 verify(mMockScheduler, times(1)).schedule(unscheduled.getWorkSpec());
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]893 assertThat(listener.mResult, is(false));
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]894 assertThat(mWorkSpecDao.getState(work.getStringId()), is(SUCCEEDED));
Rahul Ravikumar9f91ee82018-03-20 17:33:38 -0700[diff] [blame]895 }
896
897 @Test
898 @SmallTest
899 public void testFailure_withPendingScheduledWork() {
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]900 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(FailureWorker.class).build();
Rahul Ravikumar9f91ee82018-03-20 17:33:38 -0700[diff] [blame]901 insertWork(work);
902
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]903 OneTimeWorkRequest unscheduled = new OneTimeWorkRequest.Builder(TestWorker.class).build();
Rahul Ravikumar9f91ee82018-03-20 17:33:38 -0700[diff] [blame]904 insertWork(unscheduled);
905
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]906 WorkerWrapper workerWrapper = createBuilder(work.getStringId())
Rahul Ravikumar9f91ee82018-03-20 17:33:38 -0700[diff] [blame]907 .withSchedulers(Collections.singletonList(mMockScheduler))
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]908 .build();
909 FutureListener listener = createAndAddFutureListener(workerWrapper);
910 workerWrapper.run();
Rahul Ravikumar9f91ee82018-03-20 17:33:38 -0700[diff] [blame]911
912 verify(mMockScheduler, times(1)).schedule(unscheduled.getWorkSpec());
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]913 assertThat(listener.mResult, is(false));
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]914 assertThat(mWorkSpecDao.getState(work.getStringId()), is(FAILED));
Rahul Ravikumar9f91ee82018-03-20 17:33:38 -0700[diff] [blame]915 }
Sumir Katariab0a0d7b2018-04-16 16:12:35 -0700[diff] [blame]916
917 @Test
Sumir Katariad8748112018-05-11 11:22:58 -0700[diff] [blame]918 @LargeTest
Sumir Katariab0a0d7b2018-04-16 16:12:35 -0700[diff] [blame]919 public void testInterruption() throws InterruptedException {
Rahul Ravikumar7031a0f2018-04-19 14:24:30 -0700[diff] [blame]920 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(TestWorker.class).build();
Sumir Katariab0a0d7b2018-04-16 16:12:35 -0700[diff] [blame]921 insertWork(work);
922
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]923 WorkerWrapper workerWrapper =
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]924 createBuilder(work.getStringId())
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]925 .withSchedulers(Collections.singletonList(mMockScheduler))
Sumir Katariafa284c92018-04-23 14:25:53 -0700[diff] [blame]926 .build();
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]927 FutureListener listener = createAndAddFutureListener(workerWrapper);
Sumir Katariab0a0d7b2018-04-16 16:12:35 -0700[diff] [blame]928 Executors.newSingleThreadExecutor().submit(workerWrapper);
Sumir Kataria5d373d32018-05-30 16:51:36 -0700[diff] [blame]929 workerWrapper.interrupt(false);
Sumir Katariab0a0d7b2018-04-16 16:12:35 -0700[diff] [blame]930 Thread.sleep(6000L);
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]931 assertThat(listener.mResult, is(true));
Sumir Katariab0a0d7b2018-04-16 16:12:35 -0700[diff] [blame]932 }
Sumir Kataria3f0c0fb2018-05-07 16:24:48 -0700[diff] [blame]933
934 @Test
Sumir Kataria5c0277e2018-09-24 13:24:18 -0700[diff] [blame]935 @LargeTest
936 public void testPruneWhileRunning_callsSchedulerCancel() throws InterruptedException {
937 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(LatchWorker.class).build();
938 insertWork(work);
939
Sumir Kataria931889d2018-10-01 12:44:42 -0700[diff] [blame]940 LatchWorker latchWorker =
941 (LatchWorker) mConfiguration.getWorkerFactory().createWorkerWithDefaultFallback(
942 mContext.getApplicationContext(),
943 LatchWorker.class.getName(),
944 new WorkerParameters(
945 work.getId(),
946 Data.EMPTY,
947 work.getTags(),
948 new WorkerParameters.RuntimeExtras(),
949 1,
950 Executors.newSingleThreadExecutor(),
Sumir Kataria9e8b8cc2018-10-01 13:21:12 -0700[diff] [blame]951 mWorkTaskExecutor,
Sumir Kataria931889d2018-10-01 12:44:42 -0700[diff] [blame]952 mConfiguration.getWorkerFactory()));
Sumir Kataria5c0277e2018-09-24 13:24:18 -0700[diff] [blame]953
954 WorkerWrapper workerWrapper =
955 createBuilder(work.getStringId())
956 .withSchedulers(Collections.singletonList(mMockScheduler))
957 .withWorker(latchWorker)
958 .build();
959 FutureListener listener = createAndAddFutureListener(workerWrapper);
960 Executors.newSingleThreadExecutor().submit(workerWrapper);
961
962 Thread.sleep(1000L);
963
964 mDatabase.workSpecDao().delete(work.getStringId());
965 assertThat(latchWorker.mLatch.getCount(), is(greaterThan(0L)));
966
967 latchWorker.mLatch.countDown();
968
969 Thread.sleep(1000L);
970
971 assertThat(listener.mResult, is(notNullValue()));
972 verify(mMockScheduler, times(1)).cancel(work.getStringId());
973 }
974
975 @Test
Sumir Kataria3f0c0fb2018-05-07 16:24:48 -0700[diff] [blame]976 @SmallTest
Sumir Kataria5d373d32018-05-30 16:51:36 -0700[diff] [blame]977 public void testInterruptionWithoutCancellation_isMarkedOnRunningWorker() {
Sumir Katariabf4f4f72018-05-22 11:23:27 -0700[diff] [blame]978 OneTimeWorkRequest work =
979 new OneTimeWorkRequest.Builder(InterruptionAwareWorker.class).build();
980 insertWork(work);
981
Sumir Kataria931889d2018-10-01 12:44:42 -0700[diff] [blame]982 ListenableWorker worker = mConfiguration.getWorkerFactory().createWorkerWithDefaultFallback(
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]983 mContext.getApplicationContext(),
Sumir Katariabf4f4f72018-05-22 11:23:27 -0700[diff] [blame]984 InterruptionAwareWorker.class.getName(),
Sumir Katariaf82a3d62018-09-12 14:18:23 -0700[diff] [blame]985 new WorkerParameters(
986 work.getId(),
987 Data.EMPTY,
988 work.getTags(),
989 new WorkerParameters.RuntimeExtras(),
Sumir Kataria2cea33c2018-09-07 15:10:39 -0700[diff] [blame]990 1,
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]991 mSynchronousExecutor,
Sumir Kataria9e8b8cc2018-10-01 13:21:12 -0700[diff] [blame]992 mWorkTaskExecutor,
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]993 mConfiguration.getWorkerFactory()));
Sumir Katariabf4f4f72018-05-22 11:23:27 -0700[diff] [blame]994 assertThat(worker, is(notNullValue()));
995 assertThat(worker.isStopped(), is(false));
996
997 WorkerWrapper workerWrapper =
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]998 createBuilder(work.getStringId())
Sumir Katariabf4f4f72018-05-22 11:23:27 -0700[diff] [blame]999 .withSchedulers(Collections.singletonList(mMockScheduler))
Sumir Katariabf4f4f72018-05-22 11:23:27 -0700[diff] [blame]1000 .withWorker(worker)
1001 .build();
1002 Executors.newSingleThreadExecutor().submit(workerWrapper);
Sumir Kataria5d373d32018-05-30 16:51:36 -0700[diff] [blame]1003 workerWrapper.interrupt(false);
Sumir Katariabf4f4f72018-05-22 11:23:27 -0700[diff] [blame]1004 assertThat(worker.isStopped(), is(true));
Sumir Kataria5d373d32018-05-30 16:51:36 -0700[diff] [blame]1005 }
1006
1007 @Test
1008 @SmallTest
1009 public void testInterruptionWithCancellation_isMarkedOnRunningWorker() {
1010 OneTimeWorkRequest work =
1011 new OneTimeWorkRequest.Builder(InterruptionAwareWorker.class).build();
1012 insertWork(work);
1013
Sumir Kataria931889d2018-10-01 12:44:42 -0700[diff] [blame]1014 ListenableWorker worker = mConfiguration.getWorkerFactory().createWorkerWithDefaultFallback(
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]1015 mContext.getApplicationContext(),
Sumir Kataria5d373d32018-05-30 16:51:36 -0700[diff] [blame]1016 InterruptionAwareWorker.class.getName(),
Sumir Katariaf82a3d62018-09-12 14:18:23 -0700[diff] [blame]1017 new WorkerParameters(
1018 work.getId(),
1019 Data.EMPTY,
Sumir Katariaa3262882018-08-17 16:15:35 -0700[diff] [blame]1020 Collections.<String>emptyList(),
Sumir Katariaf82a3d62018-09-12 14:18:23 -0700[diff] [blame]1021 new WorkerParameters.RuntimeExtras(),
Sumir Kataria2cea33c2018-09-07 15:10:39 -0700[diff] [blame]1022 1,
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]1023 mSynchronousExecutor,
Sumir Kataria9e8b8cc2018-10-01 13:21:12 -0700[diff] [blame]1024 mWorkTaskExecutor,
Sumir Katariaf7554d2b2018-09-14 13:47:29 -0700[diff] [blame]1025 mConfiguration.getWorkerFactory()));
Sumir Kataria5d373d32018-05-30 16:51:36 -0700[diff] [blame]1026 assertThat(worker, is(notNullValue()));
1027 assertThat(worker.isStopped(), is(false));
1028
1029 WorkerWrapper workerWrapper =
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]1030 createBuilder(work.getStringId())
Sumir Kataria5d373d32018-05-30 16:51:36 -0700[diff] [blame]1031 .withSchedulers(Collections.singletonList(mMockScheduler))
Sumir Kataria5d373d32018-05-30 16:51:36 -0700[diff] [blame]1032 .withWorker(worker)
1033 .build();
1034 Executors.newSingleThreadExecutor().submit(workerWrapper);
1035 workerWrapper.interrupt(true);
1036 assertThat(worker.isStopped(), is(true));
Sumir Katariabf4f4f72018-05-22 11:23:27 -0700[diff] [blame]1037 }
1038
1039 @Test
1040 @SmallTest
Sumir Kataria3f0c0fb2018-05-07 16:24:48 -0700[diff] [blame]1041 public void testException_isTreatedAsFailure() {
1042 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(ExceptionWorker.class).build();
1043 insertWork(work);
1044
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]1045 createBuilder(work.getStringId())
Sumir Kataria3f0c0fb2018-05-07 16:24:48 -0700[diff] [blame]1046 .withSchedulers(Collections.singletonList(mMockScheduler))
Sumir Kataria3f0c0fb2018-05-07 16:24:48 -0700[diff] [blame]1047 .build()
1048 .run();
1049
1050 assertThat(mWorkSpecDao.getState(work.getStringId()), is(FAILED));
1051 }
Sumir Katariad8748112018-05-11 11:22:58 -0700[diff] [blame]1052
1053 @Test
1054 @LargeTest
1055 public void testWorkerWrapper_handlesWorkSpecDeletion() throws InterruptedException {
1056 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(SleepTestWorker.class).build();
1057 insertWork(work);
1058
1059 WorkerWrapper workerWrapper =
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]1060 createBuilder(work.getStringId())
Sumir Katariad8748112018-05-11 11:22:58 -0700[diff] [blame]1061 .withSchedulers(Collections.singletonList(mMockScheduler))
Sumir Katariad8748112018-05-11 11:22:58 -0700[diff] [blame]1062 .build();
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]1063 FutureListener listener = createAndAddFutureListener(workerWrapper);
Sumir Katariad8748112018-05-11 11:22:58 -0700[diff] [blame]1064 Executors.newSingleThreadExecutor().submit(workerWrapper);
1065 mWorkSpecDao.delete(work.getStringId());
1066 Thread.sleep(6000L);
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]1067 assertThat(listener.mResult, is(false));
Sumir Katariad8748112018-05-11 11:22:58 -0700[diff] [blame]1068 }
Sumir Katariab24ef382018-06-01 14:13:53 -0700[diff] [blame]1069
1070 @Test
1071 @LargeTest
1072 public void testWorker_getsRunAttemptCount() throws InterruptedException {
1073 OneTimeWorkRequest work = new OneTimeWorkRequest.Builder(InfiniteTestWorker.class)
1074 .setInitialRunAttemptCount(10)
1075 .build();
1076 insertWork(work);
1077
1078 WorkerWrapper workerWrapper =
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]1079 createBuilder(work.getStringId())
Rahul Ravikumare3265922018-06-07 16:35:15 -0700[diff] [blame]1080 .withSchedulers(Collections.singletonList(mMockScheduler))
Rahul Ravikumare3265922018-06-07 16:35:15 -0700[diff] [blame]1081 .build();
Sumir Katariab24ef382018-06-01 14:13:53 -0700[diff] [blame]1082
1083 Executors.newSingleThreadExecutor().submit(workerWrapper);
1084 Thread.sleep(1000L);
1085 assertThat(workerWrapper.mWorker.getRunAttemptCount(), is(10));
1086 }
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]1087
Rahul Ravikumard64fb002018-12-03 13:10:53 -0800[diff] [blame]1088 @Test
1089 @SmallTest
1090 public void testWorkerThatReturnsNullResult() {
1091 OneTimeWorkRequest work =
1092 new OneTimeWorkRequest.Builder(ReturnNullResultWorker.class).build();
1093 insertWork(work);
1094 WorkerWrapper workerWrapper = createBuilder(work.getStringId()).build();
1095 FutureListener listener = createAndAddFutureListener(workerWrapper);
1096 workerWrapper.run();
1097 assertThat(listener.mResult, is(false));
1098 assertThat(mWorkSpecDao.getState(work.getStringId()), is(FAILED));
1099 }
1100
Rahul Ravikumar4d2e0092019-02-20 18:19:43 -0800[diff] [blame]1101 @Test
1102 @SmallTest
1103 public void testWorkerThatThrowsAnException() {
1104 OneTimeWorkRequest work =
1105 new OneTimeWorkRequest.Builder(ExceptionWorker.class).build();
1106 insertWork(work);
1107 WorkerWrapper workerWrapper = createBuilder(work.getStringId()).build();
1108 FutureListener listener = createAndAddFutureListener(workerWrapper);
1109 workerWrapper.run();
1110 assertThat(listener.mResult, is(false));
1111 assertThat(mWorkSpecDao.getState(work.getStringId()), is(FAILED));
1112 }
1113
Sumir Kataria8df18fe2018-08-23 10:19:02 -0700[diff] [blame]1114 private WorkerWrapper.Builder createBuilder(String workSpecId) {
1115 return new WorkerWrapper.Builder(
1116 mContext,
1117 mConfiguration,
1118 mWorkTaskExecutor,
1119 mDatabase,
1120 workSpecId);
1121 }
Sumir Kataria0c320a82018-09-06 16:20:53 -0700[diff] [blame]1122
1123 private FutureListener createAndAddFutureListener(WorkerWrapper workerWrapper) {
1124 ListenableFuture<Boolean> future = workerWrapper.getFuture();
1125 FutureListener listener = new FutureListener(future);
1126 future.addListener(listener, mSynchronousExecutor);
1127 return listener;
1128 }
1129
1130 private static class FutureListener implements Runnable {
1131
1132 ListenableFuture<Boolean> mFuture;
1133 Boolean mResult;
1134
1135 FutureListener(ListenableFuture<Boolean> future) {
1136 mFuture = future;
1137 }
1138
1139 @Override
1140 public void run() {
1141 try {
1142 mResult = mFuture.get();
1143 } catch (InterruptedException | ExecutionException e) {
1144 // Do nothing.
1145 }
1146 }
1147 }
Xyan Bhatnagarb8909f22017-09-20 15:45:56 -0700[diff] [blame]1148}