Test Çalışanı uygulaması

WorkManager; Worker, ListenableWorker ve ListenableWorker varyantlarını (CoroutineWorker ve RxWorker) test etmek için API'ler sağlar.

Test Çalışanları

Aşağıdaki gibi görünen bir Worker öğemiz olduğunu varsayalım:

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();
        }
    }
}

Bu Worker öğesini test etmek için TestWorkerBuilder kullanabilirsiniz. Bu oluşturucu, iş mantığını test etmek amacıyla kullanılabilecek Worker örneklerinin oluşturulmasına yardımcı olur.

// 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()));
    }
}

TestWorkerBuilder, inputData veya runAttemptCount gibi etiketleri ayarlamak için de kullanılabilir. Böylece çalışan durumunu tek başına doğrulayabilirsiniz. SleepWorker öğesinin, çalışanda sabit bir değer olarak tanımlanmak yerine uyku süresini giriş verisi olarak aldığı bir örneği düşünün:

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();
        }
    }
}

SleepWorkerTest bölgesinde, SleepWorker cihazının ihtiyaçlarını karşılamak için bu giriş verilerini TestWorkerBuilder cihazınıza sağlayabilirsiniz.

// 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()));
    }
}

TestWorkerBuilder API hakkında daha fazla bilgi için TestWorkerBuilder üst sınıfı olan TestListenableWorkerBuilder referans sayfasını inceleyin.

ListenableWorker'ı ve varyantlarını test etme

ListenableWorker veya varyantlarını (CoroutineWorker ve RxWorker) test etmek için TestListenableWorkerBuilder ifadesini kullanın. TestWorkerBuilder ile TestListenableWorkerBuilder arasındaki temel fark, TestWorkerBuilder öğesinin Worker çalıştırmak için kullanılan Executor arka planını belirtmenize olanak tanımasıdır; TestListenableWorkerBuilder ise ListenableWorker uygulamasının iş parçacığı mantığına dayanır.

Örneğin, aşağıdaki gibi bir CoroutineWorker öğesini test etmemiz gerektiğini varsayalım:

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

SleepWorker hizmetini test etmek için önce TestListenableWorkerBuilder kullanarak Çalışanın bir örneğini oluşturur, ardından bir eş yordam içinde doWork işlevini çağırırız.

@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, testleriniz için eş yordam oluşturucu olarak anlamlıdır. Bu sayede, eşzamansız olarak çalışan tüm kodlar paralel olarak çalıştırılır.

TestListenableWorkerBuilder, tüm ListenableWorker alt sınıflarını işleyebildiğinden RxWorker uygulamasını test etmek CoroutineWorker testine benzer. Coroutin'ler yerine RxJava kullanan bir SleepWorker sürümünü düşünün.

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);
    }
}

RxWorker test edilen SleepWorkerTest sürümü, CoroutineWorker test edilen sürüme benzer görünebilir. Aynı TestListenableWorkerBuilder işlevini kullanıyorsunuz, ancak şimdi RxWorker createWork işlevini çağırıyorsunuz. createWork, çalışanınızın davranışını doğrulamak için kullanabileceğiniz bir Single döndürür. TestListenableWorkerBuilder, tüm iş parçacığı karmaşıklıklarını ele alır ve çalışan kodunuzu paralel olarak yürütür.

@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())));
        }
}