Properly test WearDnsRequestListener using gms task (#5880)

Author: TimoPtr

app/src/full/kotlin/io/homeassistant/companion/android/data/wear/WearDnsRequestListener.kt

@@ -17,22 +17,21 @@ import kotlinx.coroutines.withContext
 import okhttp3.Dns
 import timber.log.Timber
 
-class WearDnsRequestListener @VisibleForTesting constructor(private val dns: Dns = Dns.SYSTEM) :
-    WearableListenerService() {
-
-    private val mainScope: CoroutineScope = CoroutineScope(Dispatchers.Main + Job())
+class WearDnsRequestListener @VisibleForTesting constructor(
+    private val dns: Dns = Dns.SYSTEM,
+    private val scope: CoroutineScope = CoroutineScope(Dispatchers.Main + Job()),
+) : WearableListenerService() {
 
     override fun onRequest(nodeId: String, path: String, request: ByteArray): Task<ByteArray>? {
         if (path == PATH_DNS_LOOKUP) {
-            return mainScope.async { dnsRequest(request) }.asTask()
+            return scope.async { dnsRequest(request) }.asTask()
         } else {
             Timber.w("Received a path ($path) that is not supported by this listener. Check the manifest intent-filter")
             return null
         }
     }
 
-    @VisibleForTesting
-    internal suspend fun dnsRequest(request: ByteArray): ByteArray = withContext(Dispatchers.IO) {
+    private suspend fun dnsRequest(request: ByteArray): ByteArray = withContext(Dispatchers.IO) {
         val hostname = request.decodeDNSRequest()
         try {
             dns.lookup(hostname).encodeDNSResult()
@@ -45,6 +44,6 @@ class WearDnsRequestListener @VisibleForTesting constructor(private val dns: Dns
     override fun onDestroy() {
         super.onDestroy()
 
-        mainScope.cancel("WearDataListener.onDestroy")
+        scope.cancel("WearDataListener.onDestroy")
     }
 }

app/src/test/kotlin/io/homeassistant/companion/android/data/wear/WearDnsRequestListenerTest.kt

@@ -3,62 +3,56 @@ package io.homeassistant.companion.android.data.wear
 import io.homeassistant.companion.android.common.util.WearDataMessages.DnsLookup.PATH_DNS_LOOKUP
 import io.homeassistant.companion.android.common.util.WearDataMessages.DnsLookup.decodeDNSResult
 import io.homeassistant.companion.android.common.util.WearDataMessages.DnsLookup.encodeDNSRequest
-import io.homeassistant.companion.android.testing.unit.MainDispatcherJUnit5Extension
 import java.net.InetAddress
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.tasks.await
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
 import kotlinx.coroutines.test.runTest
 import okhttp3.Dns
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertNotNull
 import org.junit.jupiter.api.assertNull
-import org.junit.jupiter.api.extension.ExtendWith
 
-@ExtendWith(MainDispatcherJUnit5Extension::class)
 class WearDnsRequestListenerTest {
     private val testHostname = "homeassistant.local"
 
     private val homeAssistantLocal: InetAddress = InetAddress.getByAddress(testHostname, byteArrayOf(192.toByte(), 168.toByte(), 0, 23))
 
+    @OptIn(ExperimentalCoroutinesApi::class)
     @Test
-    fun `Given a hostname when a DNS request is made then the IP address is returned`() = runTest {
+    fun `Given a request with a DNS lookup path when a request is made the IP address is returned`() = runTest {
         // Given
+        val testScope = TestScope(UnconfinedTestDispatcher())
         val fakeDns = Dns {
             if (it == testHostname) {
                 listOf(homeAssistantLocal)
             } else {
                 throw IllegalArgumentException("hostname not found")
             }
         }
-        val service = WearDnsRequestListener(fakeDns)
+        val service = WearDnsRequestListener(fakeDns, scope = testScope)
 
         // When
-        val response = service.dnsRequest(testHostname.encodeDNSRequest())
-        val addresses = response.decodeDNSResult(testHostname)
+        val task = service.onRequest("", PATH_DNS_LOOKUP, testHostname.encodeDNSRequest())
 
         // Then
+        assertNotNull(task)
+        val addresses = task.await().decodeDNSResult(testHostname)
         assertEquals(testHostname, addresses.single().hostName)
         assertEquals("192.168.0.23", addresses.single().hostAddress)
     }
 
-    @Test
-    fun `Given a request with a DNS lookup path when a request is made then a task is returned`() {
-        // Given
-        val service = WearDnsRequestListener()
-
-        // When
-        val task = service.onRequest("", PATH_DNS_LOOKUP, "homeassistant.local".encodeDNSRequest())
-
-        // Then
-        assertNotNull(task)
-    }
-
     @Test
     fun `Given a request without a DNS lookup path when a request is made then no task is returned`() {
         // Given
-        val service = WearDnsRequestListener()
+        val testScope = TestScope(StandardTestDispatcher())
+        val service = WearDnsRequestListener(scope = testScope)
 
         // When
-        val task = service.onRequest("", "", "homeassistant.local".encodeDNSRequest())
+        val task = service.onRequest("", "", testHostname.encodeDNSRequest())
 
         // Then
         assertNull(task)