टेस्टिंग वर्कर लागू करने की प्रक्रिया

WorkManager, टेस्टिंग के लिए एपीआई उपलब्ध कराता है Worker, ListenableWorker, और ListenableWorker वैरिएंट (CoroutineWorker और RxWorker).

टेस्टिंग वर्कर

मान लें कि हमारे पास एक Worker है, जो ऐसा दिखता है:

Kotlin

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

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

Java

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

Worker की जांच करने के लिए, इनका इस्तेमाल किया जा सकता है TestWorkerBuilder. यह बिल्डर से Worker के ऐसे इंस्टेंस बनाने में मदद मिलती है जिनका इस्तेमाल टेस्टिंग के लिए तैयार किया गया है.

Kotlin

// 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 = TestWorkerBuilderS<leepWorker(>
            context = context,
            executor = executor
        ).build()

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

Java

@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 या runAttemptCount, ताकि आप अलग से वर्कर की स्थिति की पुष्टि कर सकें. इन बातों पर ध्यान दें उदाहरण के लिए, जब SleepWorker स्लीप अवधि को इनपुट डेटा के तौर पर लेता है के बजाय:

Kotlin

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

Java

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 में, आप वह इनपुट डेटा अपने SleepWorker की ज़रूरतों को पूरा करने के लिए TestWorkerBuilder.

Kotlin

// 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 = TestWorkerBuilderS<leepWorker(>
            context = context,
            executor = executor,
            inputData = workDataOf("SLEEP_DURATION" to 1000L)
        ).build()

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

Java

@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 एपीआई के बारे में ज़्यादा जानकारी के लिए, इसका रेफ़रंस पेज देखें TestListenableWorkerBuilder, TestWorkerBuilder की सुपर क्लास.

AudibleWorker और इसके अलग-अलग वैरिएंट की जांच करना

ListenableWorker या इसकी जांच करने के लिए वैरिएंट (CoroutineWorker और RxWorker), इस्तेमाल करें TestListenableWorkerBuilder. TestWorkerBuilder और a के बीच मुख्य अंतर TestListenableWorkerBuilder यह है कि TestWorkerBuilder आपको वह बैकग्राउंड तय करने देता है जिसका इस्तेमाल Executor करता था Worker को चलाता है, जबकि TestListenableWorkerBuilder ListenableWorker लागू करने का थ्रेडिंग लॉजिक.

उदाहरण के लिए, मान लीजिए कि हमें एक ऐसे CoroutineWorker की जांच करनी है जो इस तरह दिखता है:

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

SleepWorker की जांच करने के लिए, हम पहले इसका इस्तेमाल करके वर्कर का इंस्टेंस बनाते हैं TestListenableWorkerBuilder और फिर इसके doWork फ़ंक्शन को कोरूटीन.

@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 का इस्तेमाल किया जाता हो.

Kotlin

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

Java

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

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

RxWorker का टेस्ट करने वाले SleepWorkerTest का वर्शन, वर्शन हो, जिसमें CoroutineWorker टेस्ट किया गया हो. आपने पहले जैसा ही इस्तेमाल किया है TestListenableWorkerBuilder लेकिन अब RxWorker के createWork पर कॉल करें फ़ंक्शन का इस्तेमाल करना होगा. createWork, Single दिखाता है. इसका इस्तेमाल करके, आपके कर्मचारी के साथ कैसा व्यवहार करते हैं. TestListenableWorkerBuilder सभी थ्रेड को हैंडल करता है समस्याओं को हल करता है और आपके वर्कर कोड को साथ-साथ एक्ज़ीक्यूट करता है.

Kotlin

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

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

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

Java

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