create test to prove operOp's enqueue doesn't wait

This commit simply adds a test to prove the following issue with
the current implementation of OperationRepo.

Once processQueueForever starts processing operations it will execute
them back-to-back until it can't process any more. This is done
intently as the idea is sync all changes to the backend quickly, after
waiting a set amount of time for batching. However nothing is in place
to account for something continually adding new operations to the repo
while it's in this mode. Some misbehaving app could be adding
operations in a tight loop as fast or faster than the queue could
exclude them.

Author: jkasten2

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

@@ -151,7 +151,7 @@ internal class OperationRepo(
         }
     }
 
-    private suspend fun executeOperations(ops: List<OperationQueueItem>) {
+    internal suspend fun executeOperations(ops: List<OperationQueueItem>) {
         try {
             val startingOp = ops.first()
             val executor =

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

@@ -11,6 +11,7 @@ import io.kotest.core.spec.style.FunSpec
 import io.kotest.matchers.shouldBe
 import io.mockk.CapturingSlot
 import io.mockk.coEvery
+import io.mockk.coVerify
 import io.mockk.coVerifyOrder
 import io.mockk.every
 import io.mockk.just
@@ -370,6 +371,37 @@ class OperationRepoTests : FunSpec({
             }
         response shouldBe true
     }
+
+    // This ensures a misbehaving app can't add operations (such as addTag())
+    // in a tight loop and cause a number of back-to-back operations without delay.
+    test("operations enqueued while repo is executing should be executed only after the next opRepoExecutionInterval") {
+        // Given
+        val mocks = Mocks()
+        mocks.configModelStore.model.opRepoExecutionInterval = 100
+        val enqueueAndWaitMaxTime = mocks.configModelStore.model.opRepoExecutionInterval / 2
+        val opRepo = mocks.operationRepo
+
+        val executeOperationsCall = Waiter()
+        coEvery { opRepo.executeOperations(any()) } coAnswers {
+            executeOperationsCall.wake()
+            delay(10)
+        }
+
+        // When
+        opRepo.start()
+        opRepo.enqueue(mockOperation(groupComparisonType = GroupComparisonType.NONE))
+        executeOperationsCall.waitForWake()
+        val secondEnqueueResult =
+            withTimeoutOrNull(enqueueAndWaitMaxTime) {
+                opRepo.enqueueAndWait(mockOperation(groupComparisonType = GroupComparisonType.NONE))
+            }
+
+        // Then
+        secondEnqueueResult shouldBe null
+        coVerify(exactly = 1) {
+            opRepo.executeOperations(any())
+        }
+    }
 }) {
     companion object {
         private fun mockOperation(