הטמעת Worker

‫WorkManager מספק ממשקי API לבדיקת Worker,‏ ListenableWorker והווריאציות של ListenableWorker (CoroutineWorker ו-RxWorker).

בדיקת ה-Workers

נניח שיש לנו Worker שנראה כך:

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

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

כדי לבדוק את Worker, אפשר להשתמש בפקודה TestWorkerBuilder. הכלי הזה עוזר ליצור מופעים של Worker שאפשר להשתמש בהם כדי לבדוק את הלוגיקה העסקית.

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

אפשר להשתמש ב-TestWorkerBuilder גם כדי להגדיר תגים, כמו inputData או runAttemptCount, כדי שתוכלו לאמת את מצב ה-worker בנפרד. לדוגמה, נניח ש-SleepWorker מקבלת משך השינה כנתוני קלט, במקום שזה יהיה קבוע שמוגדר ב-worker:

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"
    }
}

ב-SleepWorkerTest, אתם יכולים לספק את נתוני הקלט האלה ל-TestWorkerBuilder כדי לענות על הצרכים של 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()))
    }
}

לפרטים נוספים על ה-API של TestWorkerBuilder, אפשר לעיין בדף העזרה של TestListenableWorkerBuilder, מחלקת העל של TestWorkerBuilder.

בדיקת ListenableWorker והווריאציות שלו

כדי לבדוק את ListenableWorker או את הווריאציות שלו (CoroutineWorker ו-RxWorker), משתמשים ב-TestListenableWorkerBuilder. ההבדל העיקרי בין TestWorkerBuilder לבין TestListenableWorkerBuilder הוא שב-TestWorkerBuilder אפשר לציין את ה-Executor ברקע שמשמש להפעלת ה-Worker, ואילו TestListenableWorkerBuilder מסתמך על לוגיקת ה-threading של ההטמעה של ListenableWorker.

לדוגמה, נניח שאנחנו צריכים לבדוק CoroutineWorker שנראה כך:

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

כדי לבדוק את SleepWorker, קודם יוצרים מכונה של Worker באמצעות TestListenableWorkerBuilder ואז קוראים לפונקציה doWork שלו בתוך פונקציית coroutine.

@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 מתאים כבונה שגרות המשך לבדיקות, כך שכל קוד שאמור לפעול באופן אסינכרוני יפעל במקביל.

בדיקת הטמעה של RxWorker דומה לבדיקה של CoroutineWorker, כי TestListenableWorkerBuilder יכול לטפל בכל מחלקת משנה של ListenableWorker. כדאי להשתמש בגרסה של SleepWorker שמשתמשת ב-RxJava במקום ב-coroutines.

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

גרסה של SleepWorkerTest שבודקת RxWorker עשויה להיות דומה לגרסה שבדקה CoroutineWorker. משתמשים באותו TestListenableWorkerBuilder, אבל הפעם קוראים לפונקציה createWork של RxWorker. ‫createWork מחזיר Single שבו אפשר להשתמש כדי לאמת את ההתנהגות של ה-worker. TestListenableWorkerBuilder מטפל בכל המורכבות של ה-threading ומריץ את קוד ה-worker במקביל.

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