RefreshCollectionsWorkerTest: wait for completion of enqueue (bitfireAT/davx5#486)

import androidx.test.platform.app.InstrumentationRegistry

import androidx.work.Configuration

import androidx.work.WorkManager

import androidx.work.await

import androidx.work.testing.WorkManagerTestInitHelper

import at.bitfire.davdroid.network.HttpClient

import at.bitfire.davdroid.TestUtils.workScheduledOrRunning

import at.bitfire.davdroid.TestUtils.workScheduledOrRunningOrSuccessful

import at.bitfire.davdroid.db.AppDatabase

import at.bitfire.davdroid.db.Collection

import at.bitfire.davdroid.db.Credentials

import at.bitfire.davdroid.db.Principal

import at.bitfire.davdroid.db.Service

import at.bitfire.davdroid.log.Logger

import at.bitfire.davdroid.network.HttpClient

import at.bitfire.davdroid.settings.Settings

import at.bitfire.davdroid.settings.SettingsManager

import at.bitfire.davdroid.ui.NotificationUtils

import dagger.hilt.android.testing.HiltAndroidTest

import io.mockk.every

import io.mockk.mockk

import kotlinx.coroutines.runBlocking

import okhttp3.mockwebserver.Dispatcher

import okhttp3.mockwebserver.MockResponse

import okhttp3.mockwebserver.MockWebServer

    @Test

    fun testRefreshCollections_enqueuesWorker() {

        val service = createTestService(Service.TYPE_CALDAV)!!

        val workerName = RefreshCollectionsWorker.enqueue(context, service.id)

        assertTrue(workScheduledOrRunning(context, workerName))

    }

    @Test

    fun testOnStopped_stopsRefreshThread() {

        val service = createTestService(Service.TYPE_CALDAV)!!

        val workerName = RefreshCollectionsWorker.enqueue(context, service.id)

        WorkManager.getInstance(context).cancelUniqueWork(workerName)

        assertFalse(workScheduledOrRunning(context, workerName))

        // here we should test whether stopping the work really interrupts the refresh thread

        val (workerName, enqueueOp) = RefreshCollectionsWorker.enqueue(context, service.id)

        enqueueOp.result.get()

        assertTrue(workScheduledOrRunningOrSuccessful(context, workerName))

    }

    @Test

import androidx.work.ExistingWorkPolicy

import androidx.work.ForegroundInfo

import androidx.work.OneTimeWorkRequestBuilder

import androidx.work.Operation

import androidx.work.OutOfQuotaPolicy

import androidx.work.WorkInfo

import androidx.work.WorkManager

         * a [RefreshCollectionsWorker].

         *

         * @param serviceId     serviceId which is to be refreshed

         * @return workerName   name of the worker started

         * @return Pair with

         *

         * 1. worker name,

         * 2. operation of [WorkManager.enqueueUniqueWork] (can be used to wait for completion)

         *

         * @throws IllegalArgumentException when there's no service with this ID

         */

        fun enqueue(context: Context, serviceId: Long): String {

        fun enqueue(context: Context, serviceId: Long): Pair<String, Operation> {

            val name = workerName(serviceId)

            val arguments = Data.Builder()

                .putLong(ARG_SERVICE_ID, serviceId)

                .setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)

                .build()

            return Pair(

                name,

                WorkManager.getInstance(context).enqueueUniqueWork(

                    name,

                    ExistingWorkPolicy.KEEP,    // if refresh is already running, just continue that one

                    workRequest

                )

            return name

            )

        }

        /**