IssueTracker

Component used: androidx.work.CoroutineWorker (androidx.work:work-runtime-ktx)

Version used: 2.9.0

Devices/Android versions reproduced on: Android Emulator API Version 33

Long running work with constraints gets immediately cancelled after calling setForeground in instrumented tests. This makes such Work difficult to test in instrumented tests.

Following the documentation on long running Android work request I call setForeground to allow long-running work.

Following the official documentation I can use a TestDriver to set the conditions met.

setConditionsMet allows the work to start running, but immediately after calling setForeground` the Work gets cancelled anyway.

The only way that I have found to test this kind of Work is to remove the constraints. Which is obviously not ideal as I cannot test the constraints themselves.

The following stand-alone test demonstrates the problem:

package example.of.long.running.worker.being.immediately.cancelled

import android.app.NotificationChannel
import android.app.NotificationManager
import android.content.Context
import android.os.Build
import android.util.Log
import androidx.core.app.NotificationCompat
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.platform.app.InstrumentationRegistry
import androidx.work.Configuration
import androidx.work.Constraints
import androidx.work.CoroutineWorker
import androidx.work.ForegroundInfo
import androidx.work.OneTimeWorkRequestBuilder
import androidx.work.WorkInfo
import androidx.work.WorkManager
import androidx.work.WorkerParameters
import androidx.work.testing.SynchronousExecutor
import androidx.work.testing.WorkManagerTestInitHelper
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith

public class LongRunningWorkerWithNotification(context: Context, parameters: WorkerParameters) :
    CoroutineWorker(context, parameters) {
  override suspend fun doWork(): Result {
    try {
      val foregroundInfo = createForegroundInfo()
      setForeground(foregroundInfo)
      // almost immediately after calling setForeground
      // a CancellationException is thrown
      delay(1000)
      return Result.success()
    } catch (e: CancellationException) {
      return Result.failure()
    }
  }

  private fun createForegroundInfo(): ForegroundInfo {
    val channelName = "TEST_NOTIFICATION_CHANNEL_NAME"
    createNotificationChannel(channelName)
    val notification =
        NotificationCompat.Builder(applicationContext, channelName)
            .setContentTitle("Title")
            .setPriority(NotificationCompat.PRIORITY_MIN)
            .setSmallIcon(R.drawable.ic_launcher_foreground)
            .build()
    return ForegroundInfo(0, notification)
  }

  private fun createNotificationChannel(
    name: String
  ) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
      val channel = NotificationChannel(name, name, NotificationManager.IMPORTANCE_DEFAULT)
      val notificationManager: NotificationManager =
          applicationContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
      notificationManager.createNotificationChannel(channel)
    }
  }

}

@RunWith(AndroidJUnit4::class)
internal class DemonstrateWorkTestProblem {

  val context = InstrumentationRegistry.getInstrumentation().targetContext

  @Before
  fun setup() {
    val config =
        Configuration.Builder()
            .setMinimumLoggingLevel(Log.DEBUG)
            .setExecutor(SynchronousExecutor())
            .build()

    // Initialize WorkManager for instrumentation tests.
    WorkManagerTestInitHelper.initializeTestWorkManager(context, config)
  }

  @Test
  fun testLongRunningWorkerWithNotification() = runBlocking {
    val request =
        OneTimeWorkRequestBuilder<LongRunningWorkerWithNotification>()
            .setConstraints(Constraints.Builder().setRequiresCharging(true).build())
            .build()
    val workManager = WorkManager.getInstance(context)
    workManager.enqueue(request)
    // set the constraints to be met so that the work will start
    val testDriver = WorkManagerTestInitHelper.getTestDriver(context)
    testDriver?.setAllConstraintsMet(request.id)
    delay(3000) // give it a chance to run
    val workInfo = workManager.getWorkInfoById(request.id).get()
    assert(workInfo.state == WorkInfo.State.SUCCEEDED)
  }
}