Add timeout to TLS tests

src/test/kotlin/com/dmdirc/ktirc/io/TlsTest.kt

 
 import io.mockk.every
 import io.mockk.mockk
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.async
+import kotlinx.coroutines.*
 import kotlinx.coroutines.io.writeFully
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
 import kotlinx.io.core.String
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
     @Test
     fun `can send a string to a server over TLS`() = runBlocking {
-        tlsServerSocket(12321).use { serverSocket ->
-            val plainSocket = PlainTextSocket(GlobalScope)
-            val tlsSocket = TlsSocket(GlobalScope, plainSocket, getTrustingContext(), "localhost")
-            val clientBytesAsync = GlobalScope.async {
-                ByteArray(13).apply {
-                    serverSocket.accept().getInputStream().read(this)
+        withTimeout(5000) {
+            tlsServerSocket(12321).use { serverSocket ->
+                val plainSocket = PlainTextSocket(GlobalScope)
+                val tlsSocket = TlsSocket(GlobalScope, plainSocket, getTrustingContext(), "localhost")
+                val clientBytesAsync = GlobalScope.async {
+                    ByteArray(13).apply {
+                        serverSocket.accept().getInputStream().read(this)
+                    }
                 }
-            }
 
-            tlsSocket.connect(InetSocketAddress("localhost", 12321))
-            tlsSocket.write.writeFully("Hello World\r\n".toByteArray())
+                tlsSocket.connect(InetSocketAddress("localhost", 12321))
+                tlsSocket.write.writeFully("Hello World\r\n".toByteArray())
 
-            val bytes = clientBytesAsync.await()
-            assertNotNull(bytes)
-            assertEquals("Hello World\r\n", String(bytes))
+                val bytes = clientBytesAsync.await()
+                assertNotNull(bytes)
+                assertEquals("Hello World\r\n", String(bytes))
+            }
         }
     }
 
     @Test
     fun `can read a string from a server over TLS`() = runBlocking<Unit> {
-        tlsServerSocket(12321).use { serverSocket ->
-            val plainSocket = PlainTextSocket(GlobalScope)
-            val tlsSocket = TlsSocket(GlobalScope, plainSocket, getTrustingContext(), "localhost")
-            val socket = GlobalScope.async {
-                serverSocket.accept().apply {
-                    GlobalScope.launch {
-                        getInputStream().read()
+        withTimeout(5000) {
+            tlsServerSocket(12321).use { serverSocket ->
+                val plainSocket = PlainTextSocket(GlobalScope)
+                val tlsSocket = TlsSocket(GlobalScope, plainSocket, getTrustingContext(), "localhost")
+                val socket = GlobalScope.async {
+                    serverSocket.accept().apply {
+                        GlobalScope.launch {
+                            getInputStream().read()
+                        }
                     }
                 }
-            }
 
-            tlsSocket.connect(InetSocketAddress("localhost", 12321))
+                tlsSocket.connect(InetSocketAddress("localhost", 12321))
 
-            GlobalScope.launch {
-                with (socket.await().getOutputStream()) {
-                    write("Hack the planet!".toByteArray())
-                    flush()
+                GlobalScope.launch {
+                    with(socket.await().getOutputStream()) {
+                        write("Hack the planet!".toByteArray())
+                        flush()
+                    }
                 }
-            }
 
-            val buffer = tlsSocket.read()
+                val buffer = tlsSocket.read()
 
-            assertNotNull(buffer)
-            buffer?.let {
-                assertEquals("Hack the planet!", String(it.array(), 0, it.limit()))
+                assertNotNull(buffer)
+                buffer?.let {
+                    assertEquals("Hack the planet!", String(it.array(), 0, it.limit()))
+                }
             }
         }
     }
 
     @Test
     fun `read returns null after close`() = runBlocking {
-        tlsServerSocket(12321).use { serverSocket ->
-            val plainSocket = PlainTextSocket(GlobalScope)
-            val tlsSocket = TlsSocket(GlobalScope, plainSocket, getTrustingContext(), "localhost")
-            GlobalScope.launch {
-                serverSocket.accept().getInputStream().read()
-            }
+        withTimeout(5000) {
+            tlsServerSocket(12321).use { serverSocket ->
+                val plainSocket = PlainTextSocket(GlobalScope)
+                val tlsSocket = TlsSocket(GlobalScope, plainSocket, getTrustingContext(), "localhost")
+                GlobalScope.launch {
+                    serverSocket.accept().getInputStream().read()
+                }
 
-            tlsSocket.connect(InetSocketAddress("localhost", 12321))
+                tlsSocket.connect(InetSocketAddress("localhost", 12321))
 
-            tlsSocket.close()
+                tlsSocket.close()
 
-            val buffer = tlsSocket.read()
+                val buffer = tlsSocket.read()
 
-            assertNull(buffer)
+                assertNull(buffer)
+            }
         }
     }
 
             }
 
             runBlocking {
-                try {
-                    tlsSocket.connect(InetSocketAddress("localhost", 12321))
-                    fail<Unit>("Expected an exception")
-                } catch (ex: Exception) {
-                    assertTrue(ex is CertificateException)
+                withTimeout(5000) {
+                    try {
+                        tlsSocket.connect(InetSocketAddress("localhost", 12321))
+                        fail<Unit>("Expected an exception")
+                    } catch (ex: Exception) {
+                        assertTrue(ex is CertificateException)
+                    }
                 }
             }
         }