Testowanie implementacji instancji roboczej

WorkManager udostępnia interfejsy API do testowania Worker, ListenableWorker oraz ListenableWorker wariantów (CoroutineWorker i RxWorker).

Instancje robocze

Załóżmy, że mamy Worker, który wygląda tak:

class SleepWorker(context: Context, parameters: WorkerParameters) :
    Worker(context, parameters) {

    override fun doWork(): Result {
        // Sleep on a background thread.
        Thread.sleep(1000)
        return Result.success()
    }
}

public class SleepWorker extends Worker {
    public SleepWorker(
            @NonNull Context context,
            @NonNull WorkerParameters workerParameters) {
        super(context, workerParameters);
    }

    @NonNull
    @Override
    public Result doWork() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException ignore) {
return Result.success();
        }
    }
}

Aby przetestować ten zasób (Worker), możesz użyć TestWorkerBuilder. Ten kreator pomaga w tworzeniu instancji Worker, których można używać do testowania logiki biznesowej.

// Kotlin code uses the TestWorkerBuilder extension to build
// the Worker
@RunWith(AndroidJUnit4::class)
class SleepWorkerTest {
    private lateinit var context: Context
    private lateinit var executor: Executor

    @Before
    fun setUp() {
        context = ApplicationProvider.getApplicationContext()
        executor = Executors.newSingleThreadExecutor()
    }

    @Test
    fun testSleepWorker() {
        val worker = TestWorkerBuilder<SleepWorker>(
            context = context,
            executor = executor
        ).build()

        val result = worker.doWork()
        assertThat(result, `is`(Result.success()))
    }
}

@RunWith(AndroidJUnit4.class)
public class SleepWorkerJavaTest {
    private Context context;
    private Executor executor;

    @Before
    public void setUp() {
        context = ApplicationProvider.getApplicationContext();
        executor = Executors.newSingleThreadExecutor();
    }

    @Test
    public void testSleepWorker() {
        SleepWorker worker =
                (SleepWorker) TestWorkerBuilder.from(context,
                        SleepWorker.class,
                        executor)
                        .build();

        Result result = worker.doWork();
        assertThat(result, is(Result.success()));
    }
}

Za pomocą TestWorkerBuilder możesz też ustawić tagi, takie jak inputData lub runAttemptCount, aby umożliwić weryfikację stanu instancji roboczej w izolacji. Przeanalizujmy przykład, w którym SleepWorker przyjmuje czas trwania snu jako dane wejściowe, a nie jest stałą zdefiniowaną w instancji roboczej:

class SleepWorker(context: Context, parameters: WorkerParameters) :
    Worker(context, parameters) {

    override fun doWork(): Result {
        // Sleep on a background thread.
        val sleepDuration = inputData.getLong(SLEEP_DURATION, 1000)
        Thread.sleep(sleepDuration)
        return Result.success()
    }

    companion object {
        const val SLEEP_DURATION = "SLEEP_DURATION"
    }
}

public class SleepWorker extends Worker {
    public static final String SLEEP_DURATION = "SLEEP_DURATION";

    public SleepWorker(
            @NonNull Context context,
            @NonNull WorkerParameters workerParameters) {
        super(context, workerParameters);
    }

    @NonNull
    @Override
    public Result doWork() {
        try {
            long duration = getInputData().getLong(SLEEP_DURATION, 1000);
            Thread.sleep(duration);
        } catch (InterruptedException ignore) {
       return Result.success();
        }
    }
}

W usłudze SleepWorkerTest możesz udostępnić te dane wejściowe do TestWorkerBuilder, aby zaspokoić potrzeby usługi SleepWorker.

// Kotlin code uses the TestWorkerBuilder extension to build
// the Worker
@RunWith(AndroidJUnit4::class)
class SleepWorkerTest {
    private lateinit var context: Context
    private lateinit var executor: Executor

    @Before
    fun setUp() {
        context = ApplicationProvider.getApplicationContext()
        executor = Executors.newSingleThreadExecutor()
    }

    @Test
    fun testSleepWorker() {
        val worker = TestWorkerBuilder<SleepWorker>(
            context = context,
            executor = executor,
            inputData = workDataOf("SLEEP_DURATION" to 1000L)
        ).build()

        val result = worker.doWork()
        assertThat(result, `is`(Result.success()))
    }
}

@RunWith(AndroidJUnit4.class)
public class SleepWorkerJavaTest {
    private Context context;
    private Executor executor;

    @Before
    public void setUp() {
        context = ApplicationProvider.getApplicationContext();
        executor = Executors.newSingleThreadExecutor();
    }

    @Test
    public void testSleepWorker() {
        Data inputData = new Data.Builder()
                .putLong("SLEEP_DURATION", 1000L)
                .build();

        SleepWorker worker =
                (SleepWorker) TestWorkerBuilder.from(context,
                        SleepWorker.class, executor)
                        .setInputData(inputData)
                        .build();

        Result result = worker.doWork();
        assertThat(result, is(Result.success()));
    }
}

Więcej informacji o interfejsie TestWorkerBuilder API znajdziesz na stronie dokumentacji TestListenableWorkerBuilder, która jest klasą nadrzędną typu TestWorkerBuilder.

Testowanie ListenableWorker i jej wariantów

Aby przetestować element ListenableWorker lub jego warianty (CoroutineWorker i RxWorker), użyj parametru TestListenableWorkerBuilder. Główna różnica między TestWorkerBuilder a TestListenableWorkerBuilder polega na tym, że TestWorkerBuilder pozwala określić tło Executor używane do uruchamiania elementu Worker, natomiast TestListenableWorkerBuilder korzysta z logiki podziału na wątki w implementacji ListenableWorker.

Załóżmy na przykład, że musimy przetestować element CoroutineWorker, który wygląda tak:

class SleepWorker(context: Context, parameters: WorkerParameters) :
    CoroutineWorker(context, parameters) {
    override suspend fun doWork(): Result {
        delay(1000L) // milliseconds
        return Result.success()
    }
}

Aby przetestować SleepWorker, najpierw tworzymy instancję instancji roboczej za pomocą TestListenableWorkerBuilder, a następnie wywołujemy jej funkcję doWork w współprogramie.

@RunWith(AndroidJUnit4::class)
class SleepWorkerTest {
    private lateinit var context: Context

    @Before
    fun setUp() {
        context = ApplicationProvider.getApplicationContext()
    }

    @Test
    fun testSleepWorker() {
        val worker = TestListenableWorkerBuilder<SleepWorker>(context).build()
        runBlocking {
            val result = worker.doWork()
            assertThat(result, `is`(Result.success()))
        }
    }
}

runBlocking pełni sens jako konstruktor współgratów do testów. Dzięki temu każdy kod, który wykonywałby się asynchronicznie, był uruchamiany równolegle.

Testowanie implementacji RxWorker przypomina testowanie CoroutineWorker, ponieważ TestListenableWorkerBuilder obsługuje dowolną podklasę ListenableWorker. Zastanów się nad wersją SleepWorker, która korzysta z serwisu RxJava zamiast współprogramów.

class SleepWorker(
    context: Context,
    parameters: WorkerParameters
) : RxWorker(context, parameters) {
    override fun createWork(): Single<Result> {
        return Single.just(Result.success())
            .delay(1000L, TimeUnit.MILLISECONDS)
    }
}

public class SleepWorker extends RxWorker {
    public SleepWorker(@NonNull Context appContext, 
@NonNull WorkerParameters workerParams) {
        super(appContext, workerParams);
    }

    @NonNull
    @Override
    public Single<Result> createWork() {
        return Single.just(Result.success())
                .delay(1000L, TimeUnit.MILLISECONDS);
    }
}

Wersja SleepWorkerTest, która testuje RxWorker, może wyglądać podobnie do wersji, która testowała CoroutineWorker. Używasz tego samego atrybutu TestListenableWorkerBuilder, ale teraz wywołujesz funkcję createWork funkcji RxWorker. createWork zwraca wartość Single, która może posłużyć do zweryfikowania działania instancji roboczej. TestListenableWorkerBuilder obsługuje wszystkie złożoności wątków i wykonuje kod instancji roboczej równolegle.

@RunWith(AndroidJUnit4::class)
class SleepWorkerTest {
    private lateinit var context: Context

    @Before
    fun setUp() {
        context = ApplicationProvider.getApplicationContext()
    }

    @Test
    fun testSleepWorker() {
        val worker = TestListenableWorkerBuilder<SleepWorker>(context).build()
        worker.createWork().subscribe { result ->
            assertThat(result, `is`(Result.success()))
        }
    }
}

@RunWith(AndroidJUnit4.class)
public class SleepWorkerTest {
    private Context context;

    @Before
    public void setUp() {
        context = ApplicationProvider.getApplicationContext();
    }

    @Test
    public void testSleepWorker() {
        SleepWorker worker = TestListenableWorkerBuilder.from(context, SleepWorker.class)
                .build();
        worker.createWork().subscribe(result ->
                assertThat(result, is(Result.success())));
        }
}