create test to prove OperationRepo isn't sleeping

Create test to confirm that OperationRepo.processQueueForever keeps poll
when it should suspend the thread while waiting for the next operation.

My theory is this polling every 5 seconds means the app process may
never fully sleep, which contributes to battery drain.

We moved code to a new getNextOps() function simply to make it testable,
no logic changes in this commit.

Author: jkasten2

OneSignalSDK/onesignal/core/src/main/java/com/onesignal/core/internal/operations/impl/OperationRepo.kt

@@ -22,7 +22,7 @@ internal class OperationRepo(
     private val _configModelStore: ConfigModelStore,
     private val _time: ITime,
 ) : IOperationRepo, IStartableService {
-    private class OperationQueueItem(
+    internal class OperationQueueItem(
         val operation: Operation,
         val waiter: WaiterWithValue<Boolean>? = null,
         var retries: Int = 0,
@@ -107,16 +107,7 @@ internal class OperationRepo(
                 return
             }
             try {
-                var ops: List<OperationQueueItem>? = null
-
-                synchronized(queue) {
-                    val startingOp = queue.firstOrNull { it.operation.canStartExecute }
-
-                    if (startingOp != null) {
-                        queue.remove(startingOp)
-                        ops = getGroupableOperations(startingOp)
-                    }
-                }
+                val ops = getNextOps()
 
                 // if the queue is empty at this point, we are no longer in force flush mode. We
                 // check this now so if the execution is unsuccessful with retry, we don't find ourselves
@@ -253,6 +244,19 @@ internal class OperationRepo(
         delay(delayFor)
     }
 
+    internal fun getNextOps(): List<OperationQueueItem>? {
+        return synchronized(queue) {
+            val startingOp = queue.firstOrNull { it.operation.canStartExecute }
+
+            if (startingOp != null) {
+                queue.remove(startingOp)
+                getGroupableOperations(startingOp)
+            } else {
+                null
+            }
+        }
+    }
+
     /**
      * Given a starting operation, find and remove from the queue all other operations that
      * can be executed along with the starting operation.  The full list of operations, with

OneSignalSDK/onesignal/core/src/test/java/com/onesignal/core/internal/operations/OperationRepoTests.kt

@@ -17,13 +17,57 @@ import io.mockk.mockk
 import io.mockk.runs
 import io.mockk.slot
 import io.mockk.spyk
+import io.mockk.verify
+import kotlinx.coroutines.delay
 
 class OperationRepoTests : FunSpec({
 
     beforeAny {
         Logging.logLevel = LogLevel.NONE
     }
 
+    // Ensures we are not continuously waking the CPU
+    test("ensure processQueueForever suspends when queue is empty") {
+        // Given
+        val mockExecutor = mockk<IOperationExecutor>()
+        every { mockExecutor.operations } returns listOf("DUMMY_OPERATION")
+        coEvery { mockExecutor.execute(any()) } returns ExecutionResponse(ExecutionResult.SUCCESS)
+
+        val mockOperationModelStore = mockk<OperationModelStore>()
+        every { mockOperationModelStore.list() } returns listOf()
+        every { mockOperationModelStore.add(any()) } just runs
+        every { mockOperationModelStore.remove(any()) } just runs
+
+        val operationRepo =
+            spyk(
+                OperationRepo(
+                    listOf(mockExecutor),
+                    mockOperationModelStore,
+                    MockHelper.configModelStore(),
+                    MockHelper.time(1000),
+                ),
+            )
+
+        val operationIdSlot = slot<String>()
+        val operation = mockOperation(operationIdSlot = operationIdSlot)
+
+        // When
+        operationRepo.start()
+        val response = operationRepo.enqueueAndWait(operation)
+        // Must wait for background logic to spin to see how many times it
+        // will call getNextOps()
+        delay(1_000)
+
+        // Then
+        response shouldBe true
+        verify(exactly = 2) {
+            // 1st: gets the operation
+            // 2nd: will be empty
+            // 3rd: shouldn't be called, loop should be waiting on next operation
+            operationRepo.getNextOps()
+        }
+    }
+
     test("enqueue operation executes and is removed when executed") {
         // Given
         val mockExecutor = mockk<IOperationExecutor>()

OneSignalSDK/onesignal/testhelpers/src/main/java/com/onesignal/mocks/MockHelper.kt

@@ -44,6 +44,9 @@ object MockHelper {
     fun configModelStore(action: ((ConfigModel) -> Unit)? = null): ConfigModelStore {
         val configModel = ConfigModel()
 
+        configModel.opRepoExecutionInterval = 1
+        configModel.opRepoPostWakeDelay = 1
+
         configModel.appId = DEFAULT_APP_ID
 
         if (action != null) {