Remove last continuation in list when cancelled (#53)

* Add test to check whether pendingDecisions are empty after cancellation

* Remove last continuation from pendingDecisions when cancelled

* Synchronize both check and removal of empty decisions list

Author: sunkup

lib/src/androidTest/java/at/bitfire/cert4android/UserDecisionRegistryTest.kt

@@ -1,15 +1,22 @@
 package at.bitfire.cert4android
 
+import androidx.core.app.NotificationManagerCompat
 import androidx.test.platform.app.InstrumentationRegistry
 import io.mockk.every
+import io.mockk.just
+import io.mockk.mockk
 import io.mockk.mockkObject
+import io.mockk.runs
 import io.mockk.unmockkAll
 import io.mockk.verify
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import org.junit.After
-import org.junit.Assert.*
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
 import java.util.Collections
@@ -111,6 +118,37 @@ class UserDecisionRegistryTest {
         verify(exactly = 1) { registry.requestDecision(any(), any(), any()) }
     }
 
+    @Test
+    fun testCheck_MultipleDecisionsForSameCert_cancel() {
+        val canSendFeedback = Semaphore(0)
+        val nm = mockk<NotificationManagerCompat>()
+        every { nm.cancel(any(), any()) } just runs
+        every { NotificationUtils.createChannels(any()) } returns nm
+        every { registry.requestDecision(testCert, any(), any()) } answers {
+            thread {
+                canSendFeedback.acquire()
+                registry.onUserDecision(testCert, false)
+            }
+        }
+        val results = Collections.synchronizedList(mutableListOf<Boolean>())
+        runBlocking {
+            repeat(5) {
+                val job = launch(Dispatchers.Default) {
+                    results += registry.check(testCert, true)
+                }
+                delay(1000)
+                job.cancel() // Cancel the job
+                delay(1000)
+            }
+            canSendFeedback.release()
+        }
+        synchronized(registry.pendingDecisions) {
+            assertFalse(registry.pendingDecisions.containsKey(testCert))
+        }
+        assertEquals(0, results.size)
+        verify(exactly = 5) { registry.requestDecision(any(), any(), any()) }
+    }
+
     @Test
     fun testCheck_UserDecisionImpossible() {
         every { NotificationUtils.notificationsPermitted(any()) } returns false

lib/src/main/java/at/bitfire/cert4android/UserDecisionRegistry.kt

@@ -53,9 +53,15 @@ class UserDecisionRegistry private constructor(
             // User decision possible → remember request in pendingDecisions so that a later decision will be applied to this request
 
             cont.invokeOnCancellation {
-                // remove from pending decisions on cancellation
                 synchronized(pendingDecisions) {
-                    pendingDecisions[cert]?.remove(cont)
+                    val decisionsList = pendingDecisions[cert]
+
+                    // remove from pending decisions on cancellation
+                    decisionsList?.remove(cont)
+
+                    // Remove decisions list if empty
+                    if (decisionsList?.isEmpty() == true)
+                        pendingDecisions -= cert
                 }
 
                 val nm = NotificationUtils.createChannels(context)